Check Style

30 files changed, 388 insertions, 269 deletions

diff --git a/src/components/application_manager/include/application_manager/application.h b/src/components/application_manager/include/application_manager/application.h
index c5dec86eee..0681761b5a 100644
--- a/src/components/application_manager/include/application_manager/application.h
+++ b/src/components/application_manager/include/application_manager/application.h
@@ -127,7 +127,9 @@ class InitialApplicationData {
   virtual void set_language(const mobile_api::Language::eType& language) = 0;
   virtual void set_ui_language(
       const mobile_api::Language::eType& ui_language) = 0;
-  virtual void set_msg_version(const uint16_t major, const uint16_t minor, const uint16_t patch) = 0;
+  virtual void set_msg_version(const uint16_t major,
+                               const uint16_t minor,
+                               const uint16_t patch) = 0;
 };
 
 /*
diff --git a/src/components/application_manager/include/application_manager/application_data_impl.h b/src/components/application_manager/include/application_manager/application_data_impl.h
index 71d2c53d5b..c48b603420 100644
--- a/src/components/application_manager/include/application_manager/application_data_impl.h
+++ b/src/components/application_manager/include/application_manager/application_data_impl.h
@@ -65,7 +65,9 @@ class InitialApplicationDataImpl : public virtual Application {
   void set_ngn_media_screen_name(const smart_objects::SmartObject& ngn_name);
   void set_language(const mobile_api::Language::eType& language);
   void set_ui_language(const mobile_api::Language::eType& ui_language);
-  void set_msg_version(const uint16_t major, const uint16_t minor, const uint16_t patch);
+  void set_msg_version(const uint16_t major,
+                       const uint16_t minor,
+                       const uint16_t patch);
 
   void set_perform_interaction_layout(
       mobile_api::LayoutMode::eType layout) OVERRIDE;
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
index cd566e43fd..9b546a1340 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc
@@ -293,14 +293,19 @@ void RegisterAppInterfaceRequest::Run() {
     return;
   }
 
-  uint16_t major = msg_params[strings::sync_msg_version][strings::major_version].asUInt();
-  uint16_t minor = msg_params[strings::sync_msg_version][strings::minor_version].asUInt();
+  uint16_t major =
+      msg_params[strings::sync_msg_version][strings::major_version].asUInt();
+  uint16_t minor =
+      msg_params[strings::sync_msg_version][strings::minor_version].asUInt();
   uint16_t patch = 0;
-  if(msg_params[strings::sync_msg_version].keyExists(strings::patch_version)) {
-    patch = msg_params[strings::sync_msg_version][strings::patch_version].asUInt();
-  }
-  if (major < minimum_major_version || (major == minimum_major_version && minor < minimum_minor_version) 
-    || (major == minimum_major_version && minor == minimum_minor_version && patch < minimum_patch_version)) {
+  if (msg_params[strings::sync_msg_version].keyExists(strings::patch_version)) {
+    patch =
+        msg_params[strings::sync_msg_version][strings::patch_version].asUInt();
+  }
+  if (major < minimum_major_version ||
+      (major == minimum_major_version && minor < minimum_minor_version) ||
+      (major == minimum_major_version && minor == minimum_minor_version &&
+       patch < minimum_patch_version)) {
     SendResponse(false, mobile_apis::Result::REJECTED);
   }
 
@@ -311,18 +316,18 @@ void RegisterAppInterfaceRequest::Run() {
     return;
   }
 
-  //Version negotiation
+  // Version negotiation
   utils::SemanticVersion mobile_version(major, minor, patch);
-  utils::SemanticVersion module_version(major_version, minor_version, patch_version);
+  utils::SemanticVersion module_version(
+      major_version, minor_version, patch_version);
   if (mobile_version < module_version) {
-    //Use mobile RPC version as negotiated version
+    // Use mobile RPC version as negotiated version
     application->set_msg_version(major, minor, patch);
   } else {
-    //Use module version as negotiated version
+    // Use module version as negotiated version
     application->set_msg_version(major_version, minor_version, patch_version);
   }
 
-  
   // For resuming application need to restore hmi_app_id from resumeCtrl
   resumption::ResumeCtrl& resumer = application_manager_.resume_controller();
   const std::string& device_mac = application->mac_address();
@@ -609,7 +614,6 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile(
     return;
   }
 
-
   utils::SemanticVersion negotiated_version = application->msg_version();
 
   response_params[strings::sync_msg_version][strings::major_version] =
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/dial_number_request_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/dial_number_request_test.cc
index 8e95f43752..5d6c6dc89e 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/dial_number_request_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/dial_number_request_test.cc
@@ -139,48 +139,45 @@ TEST_F(DialNumberRequestTest, Run_SUCCESS) {
 }
 
 TEST_F(DialNumberRequestTest, OnEvent_UnknownEvent_UNSUCCESS) {
- MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
- (*command_msg)[am::strings::params][am::strings::connection_key] =
-     kConnectionKey;
+  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*command_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
 
- DialNumberRequestPtr
- command(CreateCommand<DialNumberRequest>(command_msg));
+  DialNumberRequestPtr command(CreateCommand<DialNumberRequest>(command_msg));
 
- MockAppPtr app(CreateMockApp());
- EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  MockAppPtr app(CreateMockApp());
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
 
- Event event(hmi_apis::FunctionID::INVALID_ENUM);
- EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
+  Event event(hmi_apis::FunctionID::INVALID_ENUM);
+  EXPECT_CALL(mock_rpc_service_, ManageMobileCommand(_, _)).Times(0);
 
   command->on_event(event);
 }
 
 TEST_F(DialNumberRequestTest, OnEvent_SUCCESS) {
-   MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
-   (*event_msg)[am::strings::params][am::hmi_response::code] =
-       mobile_apis::Result::SUCCESS;
-   (*event_msg)[am::strings::params][am::strings::info] = "test_info";
-
-   Event event(hmi_apis::FunctionID::BasicCommunication_DialNumber);
-   event.set_smart_object(*event_msg);
-
-   MockAppPtr app(CreateMockApp());
-   EXPECT_CALL(app_mngr_, application(kConnectionKey))
-       .WillRepeatedly(Return(app));
-   ON_CALL(app_mngr_,
-   GetRPCService()).WillByDefault(ReturnRef(mock_rpc_service_));
-   EXPECT_CALL(
-       mock_rpc_service_,
-       ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS),
-       _));
-
-   MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
-   (*command_msg)[am::strings::params][am::strings::connection_key] =
-       kConnectionKey;
-
-   DialNumberRequestPtr
-   command(CreateCommand<DialNumberRequest>(command_msg));
-   command->on_event(event);
+  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*event_msg)[am::strings::params][am::hmi_response::code] =
+      mobile_apis::Result::SUCCESS;
+  (*event_msg)[am::strings::params][am::strings::info] = "test_info";
+
+  Event event(hmi_apis::FunctionID::BasicCommunication_DialNumber);
+  event.set_smart_object(*event_msg);
+
+  MockAppPtr app(CreateMockApp());
+  EXPECT_CALL(app_mngr_, application(kConnectionKey))
+      .WillRepeatedly(Return(app));
+  ON_CALL(app_mngr_, GetRPCService())
+      .WillByDefault(ReturnRef(mock_rpc_service_));
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _));
+
+  MessageSharedPtr command_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*command_msg)[am::strings::params][am::strings::connection_key] =
+      kConnectionKey;
+
+  DialNumberRequestPtr command(CreateCommand<DialNumberRequest>(command_msg));
+  command->on_event(event);
 }
 
 }  // namespace dial_number_request
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/register_app_interface_request_test.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/register_app_interface_request_test.cc
index b4eba8f62a..0fcc1866ae 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/register_app_interface_request_test.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/register_app_interface_request_test.cc
@@ -83,7 +83,7 @@ const std::string kMacAddress = "test_mac_address";
 const std::string kAppId = "test_app_id";
 const std::string kDummyString = "test_string";
 const std::vector<uint32_t> kDummyDiagModes;
-const utils::SemanticVersion mock_semantic_version(1,0,0);
+const utils::SemanticVersion mock_semantic_version(1, 0, 0);
 }  // namespace
 
 class RegisterAppInterfaceRequestTest
@@ -117,9 +117,12 @@ class RegisterAppInterfaceRequestTest
         kHmiLanguage;
     (*msg_)[am::strings::msg_params]
            [am::strings::hmi_display_language_desired] = kHmiLanguage;
-    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version][am::strings::major_version] = 4;
-    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version][am::strings::minor_version] = 0;
-    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version][am::strings::patch_version] = 0;
+    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version]
+           [am::strings::major_version] = 4;
+    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version]
+           [am::strings::minor_version] = 0;
+    (*msg_)[am::strings::msg_params][am::strings::sync_msg_version]
+           [am::strings::patch_version] = 0;
   }
 
   MockAppPtr CreateBasicMockedApp() {
@@ -130,8 +133,10 @@ class RegisterAppInterfaceRequestTest
     ON_CALL(*mock_app, language()).WillByDefault(ReturnRef(kMobileLanguage));
     ON_CALL(*mock_app, ui_language()).WillByDefault(ReturnRef(kMobileLanguage));
     ON_CALL(*mock_app, policy_app_id()).WillByDefault(Return(kAppId));
-    ON_CALL(*mock_app, msg_version()).WillByDefault(ReturnRef(mock_semantic_version));
-    //EXPECT_CALL(*mock_app, msg_version()).WillOnce(Return(mock_semantic_version));
+    ON_CALL(*mock_app, msg_version())
+        .WillByDefault(ReturnRef(mock_semantic_version));
+    // EXPECT_CALL(*mock_app,
+    // msg_version()).WillOnce(Return(mock_semantic_version));
     return mock_app;
   }
 
@@ -288,7 +293,6 @@ TEST_F(RegisterAppInterfaceRequestTest, Run_MinimalData_SUCCESS) {
       .WillByDefault(Return(notify_upd_manager));
 
   EXPECT_CALL(app_mngr_, RegisterApplication(msg_)).WillOnce(Return(mock_app));
-  
 
   EXPECT_CALL(mock_rpc_service_,
               ManageHMICommand(HMIResultCodeIs(
diff --git a/src/components/application_manager/src/application_data_impl.cc b/src/components/application_manager/src/application_data_impl.cc
index 4f26ce5ef5..2d297fb0ad 100644
--- a/src/components/application_manager/src/application_data_impl.cc
+++ b/src/components/application_manager/src/application_data_impl.cc
@@ -103,12 +103,10 @@ const mobile_api::Language::eType& InitialApplicationDataImpl::ui_language()
   return ui_language_;
 }
 
-const utils::SemanticVersion& InitialApplicationDataImpl::msg_version()
-    const {
+const utils::SemanticVersion& InitialApplicationDataImpl::msg_version() const {
   return msg_version_;
 }
 
-
 void InitialApplicationDataImpl::set_app_types(
     const smart_objects::SmartObject& app_types) {
   if (app_types_) {
@@ -159,8 +157,9 @@ void InitialApplicationDataImpl::set_ui_language(
   ui_language_ = ui_language;
 }
 
-void InitialApplicationDataImpl::set_msg_version(
-    const uint16_t major, const uint16_t minor, const uint16_t patch) {
+void InitialApplicationDataImpl::set_msg_version(const uint16_t major,
+                                                 const uint16_t minor,
+                                                 const uint16_t patch) {
   msg_version_.major_version = major;
   msg_version_.minor_version = minor;
   msg_version_.patch_version = patch;
diff --git a/src/components/application_manager/src/rpc_handler_impl.cc b/src/components/application_manager/src/rpc_handler_impl.cc
index 7b3645ddf1..37319738f9 100644
--- a/src/components/application_manager/src/rpc_handler_impl.cc
+++ b/src/components/application_manager/src/rpc_handler_impl.cc
@@ -218,23 +218,30 @@ bool RPCHandlerImpl::ConvertMessageToSO(
 
       rpc::ValidationReport report("RPC");
 
-      //Attach RPC version to SmartObject if it does not exist yet. 
+      // Attach RPC version to SmartObject if it does not exist yet.
       auto app_ptr = app_manager_.application(message.connection_key());
       utils::SemanticVersion msg_version(2, 0, 0);
-      if (app_ptr && (output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS].keyExists(NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION) == false)) {
-        printf("Getting app msg version\n");
+      if (app_ptr &&
+          (output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS]
+               .keyExists(NsSmartDeviceLink::NsJSONHandler::strings::
+                              S_RPC_MSG_VERSION) == false)) {
         msg_version = app_ptr->msg_version();
-        output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS][NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION] = msg_version.toString();
-      } else if (mobile_apis::FunctionID::RegisterAppInterfaceID == static_cast<mobile_apis::FunctionID::eType>(output[strings::params][strings::function_id].asInt())) {
-        //Assume default version 1.0.0 until properly set in RAI
-        printf("Setting default msg version\n");
-        output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS][NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION] = msg_version.toString();
-        printf("%s\n", output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS][NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION].asString().c_str());
+        output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS]
+              [NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION] =
+                  msg_version.toString();
+      } else if (mobile_apis::FunctionID::RegisterAppInterfaceID ==
+                 static_cast<mobile_apis::FunctionID::eType>(
+                     output[strings::params][strings::function_id].asInt())) {
+        // Assume default version 1.0.0 until properly set in RAI
+        output[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS]
+              [NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION] =
+                  msg_version.toString();
       }
 
       if (!conversion_result ||
           !mobile_so_factory().attachSchema(output, true) ||
-          ((output.validate(&report, msg_version) != smart_objects::Errors::OK))) {
+          ((output.validate(&report, msg_version) !=
+            smart_objects::Errors::OK))) {
         LOG4CXX_WARN(logger_,
                      "Failed to parse string to smart object :"
                          << message.json_message());
diff --git a/src/components/application_manager/test/include/application_manager/mock_application.h b/src/components/application_manager/test/include/application_manager/mock_application.h
index de75bb8fd0..79a268530a 100644
--- a/src/components/application_manager/test/include/application_manager/mock_application.h
+++ b/src/components/application_manager/test/include/application_manager/mock_application.h
@@ -205,8 +205,10 @@ class MockApplication : public ::application_manager::Application {
                void(const mobile_apis::Language::eType& language));
   MOCK_METHOD1(set_ui_language,
                void(const mobile_apis::Language::eType& ui_language));
-   MOCK_METHOD3(set_msg_version,
-               void(const uint16_t major, const uint16_t minor, const uint16_t patch)); 
+  MOCK_METHOD3(set_msg_version,
+               void(const uint16_t major,
+                    const uint16_t minor,
+                    const uint16_t patch));
   // DynamicApplicationData methods
   MOCK_CONST_METHOD0(help_prompt, const smart_objects::SmartObject*());
   MOCK_CONST_METHOD0(timeout_prompt, const smart_objects::SmartObject*());
diff --git a/src/components/formatters/include/formatters/CSmartFactory.h b/src/components/formatters/include/formatters/CSmartFactory.h
index c2037e7adc..e7eb91912f 100644
--- a/src/components/formatters/include/formatters/CSmartFactory.h
+++ b/src/components/formatters/include/formatters/CSmartFactory.h
@@ -299,10 +299,14 @@ bool CSmartFactory<FunctionIdEnum, MessageTypeEnum, StructIdEnum>::attachSchema(
   }
 
   object.setSchema(schemaIterator->second);
-  
+
   utils::SemanticVersion msg_version;
-  if (object[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS].keyExists(NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION)) {
-    msg_version = object[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS][NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION].asString();
+  if (object[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS].keyExists(
+          NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION)) {
+    msg_version =
+        object[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS]
+              [NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION]
+                  .asString();
   }
 
   schemaIterator->second.applySchema(object, RemoveFakeParameters, msg_version);
diff --git a/src/components/formatters/src/CSmartFactory.cc b/src/components/formatters/src/CSmartFactory.cc
index 27e2064fee..6efd895500 100644
--- a/src/components/formatters/src/CSmartFactory.cc
+++ b/src/components/formatters/src/CSmartFactory.cc
@@ -47,7 +47,8 @@ const std::string NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE(
     "protocol_type");
 const std::string NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID(
     "correlation_id");
-const std::string NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION("rpc_msg_version");
+const std::string NsSmartDeviceLink::NsJSONHandler::strings::S_RPC_MSG_VERSION(
+    "rpc_msg_version");
 const std::string NsSmartDeviceLink::NsJSONHandler::strings::kCode("code");
 const std::string NsSmartDeviceLink::NsJSONHandler::strings::kMessage(
     "message");
diff --git a/src/components/include/utils/semantic_version.h b/src/components/include/utils/semantic_version.h
index 3e536e550d..66cedc2bc5 100644
--- a/src/components/include/utils/semantic_version.h
+++ b/src/components/include/utils/semantic_version.h
@@ -38,7 +38,6 @@
 namespace utils {
 
 struct SemanticVersion {
-
   SemanticVersion(uint16_t major = 0, uint16_t minor = 0, uint16_t patch = 0) {
     major_version = major;
     minor_version = minor;
@@ -48,12 +47,12 @@ struct SemanticVersion {
   SemanticVersion(const std::string& str_version) {
     std::vector<std::string> str_array;
     boost::split(str_array, str_version, boost::is_any_of("."));
-    if(str_array.size() == 3) {
-        major_version = atoi(str_array[0].c_str());
-        minor_version = atoi(str_array[1].c_str());
-        patch_version = atoi(str_array[2].c_str());
+    if (str_array.size() == 3) {
+      major_version = atoi(str_array[0].c_str());
+      minor_version = atoi(str_array[1].c_str());
+      patch_version = atoi(str_array[2].c_str());
     } else {
-      //Invalid case
+      // Invalid case
       major_version = 0;
       minor_version = 0;
       patch_version = 0;
@@ -61,7 +60,9 @@ struct SemanticVersion {
   }
 
   bool operator==(const SemanticVersion& version) const {
-    if (major_version == version.major_version && minor_version == version.minor_version && patch_version == version.patch_version) {
+    if (major_version == version.major_version &&
+        minor_version == version.minor_version &&
+        patch_version == version.patch_version) {
       return true;
     } else {
       return false;
@@ -69,9 +70,12 @@ struct SemanticVersion {
   }
 
   bool operator<(const SemanticVersion& version) const {
-    return (major_version < version.major_version) || 
-      ((major_version == version.major_version) && (minor_version < version.minor_version)) ||
-      ((major_version == version.major_version) && (minor_version == version.minor_version) && (patch_version < version.patch_version));
+    return (major_version < version.major_version) ||
+           ((major_version == version.major_version) &&
+            (minor_version < version.minor_version)) ||
+           ((major_version == version.major_version) &&
+            (minor_version == version.minor_version) &&
+            (patch_version < version.patch_version));
   }
 
   bool operator<=(const SemanticVersion& version) const {
@@ -85,9 +89,12 @@ struct SemanticVersion {
   }
 
   bool operator>(const SemanticVersion& version) const {
-    return (major_version > version.major_version) || 
-      ((major_version == version.major_version) && (minor_version > version.minor_version)) ||
-      ((major_version == version.major_version) && (minor_version == version.minor_version) && (patch_version > version.patch_version));
+    return (major_version > version.major_version) ||
+           ((major_version == version.major_version) &&
+            (minor_version > version.minor_version)) ||
+           ((major_version == version.major_version) &&
+            (minor_version == version.minor_version) &&
+            (patch_version > version.patch_version));
   }
 
   bool operator>=(const SemanticVersion& version) const {
@@ -100,27 +107,24 @@ struct SemanticVersion {
     }
   }
 
-  const std::string toString() const{
+  const std::string toString() const {
     std::string result = "";
     result += std::to_string(major_version);
     result += ".";
     result += std::to_string(minor_version);
     result += ".";
     result += std::to_string(patch_version);
-    printf("toString Result!!!: %s\n", result.c_str());
     return result;
   }
 
-  bool isValid() const{
+  bool isValid() const {
     return major_version > 0 || minor_version > 0 || patch_version > 0;
   }
 
   uint16_t major_version = 0;
   uint16_t minor_version = 0;
   uint16_t patch_version = 0;
-
 };
-
 }
 
 #endif  // SRC_COMPONENTS_INCLUDE_UTILS_CALLABLE_H
\ No newline at end of file
diff --git a/src/components/smart_objects/include/smart_objects/always_false_schema_item.h b/src/components/smart_objects/include/smart_objects/always_false_schema_item.h
index 3a8a309b8d..87e5d31ae9 100644
--- a/src/components/smart_objects/include/smart_objects/always_false_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/always_false_schema_item.h
@@ -70,7 +70,8 @@ class CAlwaysFalseSchemaItem : public ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
 
  private:
   CAlwaysFalseSchemaItem();
diff --git a/src/components/smart_objects/include/smart_objects/always_true_schema_item.h b/src/components/smart_objects/include/smart_objects/always_true_schema_item.h
index 9fe7878811..ca590fecca 100644
--- a/src/components/smart_objects/include/smart_objects/always_true_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/always_true_schema_item.h
@@ -71,7 +71,8 @@ class CAlwaysTrueSchemaItem : public ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
 
  private:
   CAlwaysTrueSchemaItem();
diff --git a/src/components/smart_objects/include/smart_objects/array_schema_item.h b/src/components/smart_objects/include/smart_objects/array_schema_item.h
index af21dd9b65..69a546b558 100644
--- a/src/components/smart_objects/include/smart_objects/array_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/array_schema_item.h
@@ -93,7 +93,8 @@ class CArraySchemaItem : public ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
 
   /**
    * @brief Apply schema.
@@ -104,7 +105,9 @@ class CArraySchemaItem : public ISchemaItem {
    * from smart object otherwise contains false.
    **/
   void applySchema(SmartObject& Object,
-                   const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion = utils::SemanticVersion()) OVERRIDE;
+                   const bool RemoveFakeParameters,
+                   const utils::SemanticVersion& MessageVersion =
+                       utils::SemanticVersion()) OVERRIDE;
 
   /**
    * @brief Unapply schema.
diff --git a/src/components/smart_objects/include/smart_objects/default_shema_item.h b/src/components/smart_objects/include/smart_objects/default_shema_item.h
index 75dbcaf67d..b094091336 100644
--- a/src/components/smart_objects/include/smart_objects/default_shema_item.h
+++ b/src/components/smart_objects/include/smart_objects/default_shema_item.h
@@ -72,7 +72,8 @@ class CDefaultSchemaItem : public ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
 
   /**
    * @brief Set default value to an object.
@@ -138,7 +139,9 @@ Errors::eType CDefaultSchemaItem<Type>::validate(
 
 template <typename Type>
 Errors::eType CDefaultSchemaItem<Type>::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return validate(Object, report__);
 }
 
diff --git a/src/components/smart_objects/include/smart_objects/enum_schema_item.h b/src/components/smart_objects/include/smart_objects/enum_schema_item.h
index 45df7476e0..54de61d4e5 100644
--- a/src/components/smart_objects/include/smart_objects/enum_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/enum_schema_item.h
@@ -47,25 +47,28 @@
 namespace NsSmartDeviceLink {
 namespace NsSmartObjects {
 
-//Element Signature for enums. Fields represent "since", "until", and "removed"
-//typedef boost::optional<std::string> OptionalString;
-//typedef boost::optional<bool> OptionalBool;
-//typedef std::tuple<OptionalString, OptionalString, OptionalBool> ElementSignature;
+// Element Signature for enums. Fields represent "since", "until", and "removed"
+// typedef boost::optional<std::string> OptionalString;
+// typedef boost::optional<bool> OptionalBool;
+// typedef std::tuple<OptionalString, OptionalString, OptionalBool>
+// ElementSignature;
 
 struct ElementSignature {
   boost::optional<utils::SemanticVersion> mSince;
   boost::optional<utils::SemanticVersion> mUntil;
   bool mRemoved;
 
-  ElementSignature(std::string since="", std::string until="", bool removed=false) {
+  ElementSignature(std::string since = "",
+                   std::string until = "",
+                   bool removed = false) {
     utils::SemanticVersion since_struct(since);
     utils::SemanticVersion until_struct(until);
 
-    if(since_struct.isValid()) {
+    if (since_struct.isValid()) {
       mSince = since_struct;
     }
 
-    if(until_struct.isValid()) {
+    if (until_struct.isValid()) {
       mUntil = until_struct;
     }
 
@@ -73,8 +76,8 @@ struct ElementSignature {
   }
 };
 
-//typedef std::map<OptionalString, OptionalString, OptionalBool> ElementSignature;
-
+// typedef std::map<OptionalString, OptionalString, OptionalBool>
+// ElementSignature;
 
 template <typename EnumType>
 class EnumConversionHelper;
@@ -104,7 +107,8 @@ class TEnumSchemaItem : public CDefaultSchemaItem<EnumType> {
    **/
   static std::shared_ptr<TEnumSchemaItem> createWithSignatures(
       const std::set<EnumType>& AllowedElements,
-      const std::map<EnumType, std::vector<ElementSignature>>& ElementSignatures,
+      const std::map<EnumType, std::vector<ElementSignature> >&
+          ElementSignatures,
       const TSchemaItemParameter<EnumType>& DefaultValue =
           TSchemaItemParameter<EnumType>());
   /**
@@ -131,7 +135,8 @@ class TEnumSchemaItem : public CDefaultSchemaItem<EnumType> {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
   /**
    * @brief Apply schema.
    * This implementation checks if enumeration is represented as string
@@ -142,7 +147,9 @@ class TEnumSchemaItem : public CDefaultSchemaItem<EnumType> {
    * from smart object otherwise contains false.
    **/
   void applySchema(SmartObject& Object,
-                   const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion = utils::SemanticVersion()) OVERRIDE;
+                   const bool RemoveFakeParameters,
+                   const utils::SemanticVersion& MessageVersion =
+                       utils::SemanticVersion()) OVERRIDE;
   /**
    * @brief Unapply schema.
    * @param Object Object to unapply schema.
@@ -160,14 +167,15 @@ class TEnumSchemaItem : public CDefaultSchemaItem<EnumType> {
 
   TEnumSchemaItem(const std::set<EnumType>& AllowedElements,
                   const TSchemaItemParameter<EnumType>& DefaultValue,
-                  const std::map<EnumType, std::vector<ElementSignature>>& ElementSignatures);
+                  const std::map<EnumType, std::vector<ElementSignature> >&
+                      ElementSignatures);
   SmartType getSmartType() const OVERRIDE;
   EnumType getDefaultValue() const OVERRIDE;
   /**
    * @brief Set of allowed enumeration elements.
    **/
   const std::set<EnumType> mAllowedElements;
-  std::map<EnumType, std::vector<ElementSignature>> mElementSignatures;
+  std::map<EnumType, std::vector<ElementSignature> > mElementSignatures;
   /**
    * @brief Default value.
    **/
@@ -274,12 +282,14 @@ std::shared_ptr<TEnumSchemaItem<EnumType> > TEnumSchemaItem<EnumType>::create(
 }
 
 template <typename EnumType>
-std::shared_ptr<TEnumSchemaItem<EnumType> > TEnumSchemaItem<EnumType>::createWithSignatures(
+std::shared_ptr<TEnumSchemaItem<EnumType> >
+TEnumSchemaItem<EnumType>::createWithSignatures(
     const std::set<EnumType>& AllowedElements,
-    const std::map<EnumType, std::vector<ElementSignature>>& ElementSignatures,
-    const TSchemaItemParameter<EnumType>& DefaultValue ) {
+    const std::map<EnumType, std::vector<ElementSignature> >& ElementSignatures,
+    const TSchemaItemParameter<EnumType>& DefaultValue) {
   return std::shared_ptr<TEnumSchemaItem<EnumType> >(
-      new TEnumSchemaItem<EnumType>(AllowedElements, DefaultValue, ElementSignatures));
+      new TEnumSchemaItem<EnumType>(
+          AllowedElements, DefaultValue, ElementSignatures));
 }
 
 template <typename EnumType>
@@ -317,7 +327,9 @@ Errors::eType TEnumSchemaItem<EnumType>::validate(
 
 template <typename EnumType>
 Errors::eType TEnumSchemaItem<EnumType>::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Integer != Object.getType()) {
     std::string validation_info;
     if (SmartType_String == Object.getType()) {
@@ -332,10 +344,10 @@ Errors::eType TEnumSchemaItem<EnumType>::validate(
     return Errors::INVALID_VALUE;
   }
 
-  auto elements_it = mAllowedElements.find(static_cast<EnumType>(Object.asInt()));
+  auto elements_it =
+      mAllowedElements.find(static_cast<EnumType>(Object.asInt()));
 
-  if (elements_it ==
-      mAllowedElements.end()) {
+  if (elements_it == mAllowedElements.end()) {
     std::stringstream stream;
     stream << "Invalid enum value: " << Object.asInt();
     std::string validation_info = stream.str();
@@ -343,51 +355,62 @@ Errors::eType TEnumSchemaItem<EnumType>::validate(
     return Errors::OUT_OF_RANGE;
   }
 
-  //Element exists in schema. Check if version is also valid.
+  // Element exists in schema. Check if version is also valid.
   if (MessageVersion.isValid()) {
     EnumType value = *elements_it;
     auto signatures_it = mElementSignatures.find(value);
     if (signatures_it != mElementSignatures.end()) {
-      if ( ! signatures_it->second.empty()) {
-        for (uint i=0; i<signatures_it->second.size(); i++) {
+      if (!signatures_it->second.empty()) {
+        for (uint i = 0; i < signatures_it->second.size(); i++) {
           ElementSignature signature = signatures_it->second[i];
           // Check if signature matches message version
           if (signature.mSince.is_initialized()) {
             if (MessageVersion < signature.mSince.get()) {
-              //Msg version predates 'since' field, check next entry
+              // Msg version predates 'since' field, check next entry
               continue;
             } else {
-              if (signature.mUntil.is_initialized() && (MessageVersion >= signature.mUntil.get())) {
-                continue; //Msg version newer than `until` field
+              if (signature.mUntil.is_initialized() &&
+                  (MessageVersion >= signature.mUntil.get())) {
+                continue;  // Msg version newer than `until` field
               } else {
-                //Found correct version
+                // Found correct version
                 if (signature.mRemoved) {
-                  //Element was removed for this version
-                  std::string validation_info = "Invalid enum value: " + Object.asString() + " removed for SyncMsgVersion " + MessageVersion.toString();
+                  // Element was removed for this version
+                  std::string validation_info = "Invalid enum value: " +
+                                                Object.asString() +
+                                                " removed for SyncMsgVersion " +
+                                                MessageVersion.toString();
                   report__->set_validation_info(validation_info);
                   return Errors::INVALID_VALUE;
                 }
-                return Errors::OK; //Mobile msg version falls within specified version range and is not removed
+                return Errors::OK;  // Mobile msg version falls within specified
+                                    // version range and is not removed
               }
             }
-          } //end if signature.mSince.is_initialized()
+          }  // end if signature.mSince.is_initialized()
 
-          if (signature.mUntil.is_initialized() && (MessageVersion >= signature.mUntil.get())) {
-            continue; //Msg version newer than `until` field, check next entry
+          if (signature.mUntil.is_initialized() &&
+              (MessageVersion >= signature.mUntil.get())) {
+            continue;  // Msg version newer than `until` field, check next entry
           } else {
-           //Found correct version
+            // Found correct version
             if (signature.mRemoved) {
-              //Element was removed for this version
-              std::string validation_info = "Enum value : " + Object.asString() + " removed for SyncMsgVersion " + MessageVersion.toString();
+              // Element was removed for this version
+              std::string validation_info =
+                  "Enum value : " + Object.asString() +
+                  " removed for SyncMsgVersion " + MessageVersion.toString();
               report__->set_validation_info(validation_info);
               return Errors::INVALID_VALUE;
             }
-            return Errors::OK; //Mobile msg version falls within specified version range and is not removed
+            return Errors::OK;  // Mobile msg version falls within specified
+                                // version range and is not removed
           }
-        } // End For Loop Version not found.
-          std::string validation_info = "Invalid enum value: " + Object.asString() + " for SyncMsgVersion " + MessageVersion.toString();
-          report__->set_validation_info(validation_info);
-          return Errors::INVALID_VALUE;        
+        }  // End For Loop Version not found.
+        std::string validation_info =
+            "Invalid enum value: " + Object.asString() +
+            " for SyncMsgVersion " + MessageVersion.toString();
+        report__->set_validation_info(validation_info);
+        return Errors::INVALID_VALUE;
       }
     }
   }
@@ -396,8 +419,10 @@ Errors::eType TEnumSchemaItem<EnumType>::validate(
 }
 
 template <typename EnumType>
-void TEnumSchemaItem<EnumType>::applySchema(SmartObject& Object,
-                                            const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion) {
+void TEnumSchemaItem<EnumType>::applySchema(
+    SmartObject& Object,
+    const bool RemoveFakeParameters,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_String == Object.getType()) {
     EnumType enum_val = static_cast<EnumType>(-1);
     if (ConversionHelper::StringToEnum(Object.asString(), &enum_val)) {
@@ -437,12 +462,11 @@ template <typename EnumType>
 TEnumSchemaItem<EnumType>::TEnumSchemaItem(
     const std::set<EnumType>& AllowedElements,
     const TSchemaItemParameter<EnumType>& DefaultValue,
-    const std::map<EnumType, std::vector<ElementSignature>>& ElementSignatures)
+    const std::map<EnumType, std::vector<ElementSignature> >& ElementSignatures)
     : CDefaultSchemaItem<EnumType>(DefaultValue)
-    , mAllowedElements(AllowedElements)
-     {
-      mElementSignatures = ElementSignatures;
-     }
+    , mAllowedElements(AllowedElements) {
+  mElementSignatures = ElementSignatures;
+}
 
 }  // namespace NsSmartObjects
 }  // namespace NsSmartDeviceLink
diff --git a/src/components/smart_objects/include/smart_objects/number_schema_item.h b/src/components/smart_objects/include/smart_objects/number_schema_item.h
index e1d294779d..ee82b87241 100644
--- a/src/components/smart_objects/include/smart_objects/number_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/number_schema_item.h
@@ -89,7 +89,8 @@ class TNumberSchemaItem : public CDefaultSchemaItem<NumberType> {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
 
  private:
   /**
@@ -205,7 +206,9 @@ Errors::eType TNumberSchemaItem<NumberType>::validate(
 
 template <typename NumberType>
 Errors::eType TNumberSchemaItem<NumberType>::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return validate(Object, report__);
 }
 
diff --git a/src/components/smart_objects/include/smart_objects/object_schema_item.h b/src/components/smart_objects/include/smart_objects/object_schema_item.h
index 8ff51d302a..4a36f06f3c 100644
--- a/src/components/smart_objects/include/smart_objects/object_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/object_schema_item.h
@@ -64,20 +64,21 @@ class CObjectSchemaItem : public ISchemaItem {
      * @param IsMandatory true if member is mandatory, false
      *                    otherwise. Defaults to true.
      **/
-    //SMember(const ISchemaItemPtr SchemaItem, const bool IsMandatory = true);
+    // SMember(const ISchemaItemPtr SchemaItem, const bool IsMandatory = true);
 
     SMember(const ISchemaItemPtr SchemaItem,
-                                        const bool IsMandatory = true,
-                                        const std::string& Since = "",
-                                        const std::string& Until = "",
-                                        const bool IsDeprecated = false,
-                                        const bool IsRemoved = false,
-                                        const std::vector<CObjectSchemaItem::SMember>& history_vector = {});
+            const bool IsMandatory = true,
+            const std::string& Since = "",
+            const std::string& Until = "",
+            const bool IsDeprecated = false,
+            const bool IsRemoved = false,
+            const std::vector<CObjectSchemaItem::SMember>& history_vector = {});
     /**
      * @brief Checks the version a parameter was removed (until)
      * If the mobile's msg version is greater than or
      **/
-    bool CheckHistoryFieldVersion(const utils::SemanticVersion& MessageVersion) const;
+    bool CheckHistoryFieldVersion(
+        const utils::SemanticVersion& MessageVersion) const;
 
     /**
      * @brief Member schema item.
@@ -92,7 +93,6 @@ class CObjectSchemaItem : public ISchemaItem {
     bool mIsDeprecated;
     bool mIsRemoved;
     std::vector<CObjectSchemaItem::SMember> mHistoryVector;
-
   };
   typedef std::map<std::string, SMember> Members;
   /**
@@ -127,7 +127,8 @@ class CObjectSchemaItem : public ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
   /**
    * @brief Apply schema.
    * @param Object Object to apply schema.
@@ -135,7 +136,9 @@ class CObjectSchemaItem : public ISchemaItem {
    * from smart object otherwise contains false.
    **/
   void applySchema(SmartObject& Object,
-                   const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion = utils::SemanticVersion()) OVERRIDE;
+                   const bool RemoveFakeParameters,
+                   const utils::SemanticVersion& MessageVersion =
+                       utils::SemanticVersion()) OVERRIDE;
   /**
    * @brief Unapply schema.
    * @param Object Object to unapply schema.
@@ -167,10 +170,11 @@ class CObjectSchemaItem : public ISchemaItem {
    * @brief Removes fake parameters from object.
    * @param Object Object to remove fake parameters.
    **/
-  void RemoveFakeParams(SmartObject& Object, const utils::SemanticVersion& MessageVersion);
+  void RemoveFakeParams(SmartObject& Object,
+                        const utils::SemanticVersion& MessageVersion);
 
   /**
-   * @brief Checks mandatory and version fields to see 
+   * @brief Checks mandatory and version fields to see
    * if a member is required.
    * @param Object Object to remove fake parameters.
    **/
diff --git a/src/components/smart_objects/include/smart_objects/schema_item.h b/src/components/smart_objects/include/smart_objects/schema_item.h
index 4e126b2bec..828dac33f0 100644
--- a/src/components/smart_objects/include/smart_objects/schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/schema_item.h
@@ -84,7 +84,8 @@ class ISchemaItem {
    * @return NsSmartObjects::Errors::eType
    **/
   virtual Errors::eType validate(const SmartObject& Object,
-                                 rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion);
+                                 rpc::ValidationReport* report__,
+                                 const utils::SemanticVersion& MessageVersion);
 
   /**
    * @brief Set default value to an object.
@@ -113,7 +114,8 @@ class ISchemaItem {
    **/
   virtual void applySchema(
       NsSmartDeviceLink::NsSmartObjects::SmartObject& Object,
-      const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion = utils::SemanticVersion());
+      const bool RemoveFakeParameters,
+      const utils::SemanticVersion& MessageVersion = utils::SemanticVersion());
 
   /**
    * @brief Unapply schema.
diff --git a/src/components/smart_objects/include/smart_objects/smart_object.h b/src/components/smart_objects/include/smart_objects/smart_object.h
index 5853c9bb3f..f594ad9820 100644
--- a/src/components/smart_objects/include/smart_objects/smart_object.h
+++ b/src/components/smart_objects/include/smart_objects/smart_object.h
@@ -693,7 +693,8 @@ class SmartObject FINAL {
    * @param messageVersion of the mobile app to check against RPC Spec Schema
    * @return Result of validation.
    */
-  Errors::eType validate(rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion);
+  Errors::eType validate(rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion);
 
   /**
    * @brief Sets new schema
diff --git a/src/components/smart_objects/include/smart_objects/smart_schema.h b/src/components/smart_objects/include/smart_objects/smart_schema.h
index 08595d311c..5ab96e82bd 100644
--- a/src/components/smart_objects/include/smart_objects/smart_schema.h
+++ b/src/components/smart_objects/include/smart_objects/smart_schema.h
@@ -91,7 +91,8 @@ class CSmartSchema FINAL {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& messageVersion) const;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& messageVersion) const;
 
   /**
    * @brief Set new root schema item.
@@ -108,7 +109,10 @@ class CSmartSchema FINAL {
    * @param RemoveFakeParameters contains true if need to remove fake parameters
    * from smart object otherwise contains false.
    **/
-  void applySchema(SmartObject& Object, const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion = utils::SemanticVersion());
+  void applySchema(
+      SmartObject& Object,
+      const bool RemoveFakeParameters,
+      const utils::SemanticVersion& MessageVersion = utils::SemanticVersion());
 
   /**
    * @brief The reverse SmartObject conversion using schema.
diff --git a/src/components/smart_objects/include/smart_objects/string_schema_item.h b/src/components/smart_objects/include/smart_objects/string_schema_item.h
index 0bf21a6449..4d5f18f711 100644
--- a/src/components/smart_objects/include/smart_objects/string_schema_item.h
+++ b/src/components/smart_objects/include/smart_objects/string_schema_item.h
@@ -82,7 +82,9 @@ class CStringSchemaItem : public CDefaultSchemaItem<std::string> {
    * @return NsSmartObjects::Errors::eType
    **/
   Errors::eType validate(const SmartObject& Object,
-                         rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) OVERRIDE;
+                         rpc::ValidationReport* report__,
+                         const utils::SemanticVersion& MessageVersion) OVERRIDE;
+
  private:
   /**
    * @brief Constructor.
diff --git a/src/components/smart_objects/src/always_false_schema_item.cc b/src/components/smart_objects/src/always_false_schema_item.cc
index 18d0d36323..acbe15485b 100644
--- a/src/components/smart_objects/src/always_false_schema_item.cc
+++ b/src/components/smart_objects/src/always_false_schema_item.cc
@@ -53,7 +53,9 @@ Errors::eType CAlwaysFalseSchemaItem::validate(
 }
 
 Errors::eType CAlwaysFalseSchemaItem::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   report__->set_validation_info("Generic error");
   return Errors::ERROR;
 }
diff --git a/src/components/smart_objects/src/always_true_schema_item.cc b/src/components/smart_objects/src/always_true_schema_item.cc
index 0402fa0d10..8a72d606a0 100644
--- a/src/components/smart_objects/src/always_true_schema_item.cc
+++ b/src/components/smart_objects/src/always_true_schema_item.cc
@@ -49,7 +49,9 @@ Errors::eType CAlwaysTrueSchemaItem::validate(const SmartObject& object,
 }
 
 Errors::eType CAlwaysTrueSchemaItem::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return Errors::OK;
 }
 
diff --git a/src/components/smart_objects/src/array_schema_item.cc b/src/components/smart_objects/src/array_schema_item.cc
index 78619050e0..108bccce11 100644
--- a/src/components/smart_objects/src/array_schema_item.cc
+++ b/src/components/smart_objects/src/array_schema_item.cc
@@ -89,8 +89,10 @@ Errors::eType CArraySchemaItem::validate(const SmartObject& Object,
   return Errors::OK;
 }
 
-Errors::eType CArraySchemaItem::validate(const SmartObject& Object,
-                                         rpc::ValidationReport* report__,  const utils::SemanticVersion& MessageVersion) {
+Errors::eType CArraySchemaItem::validate(
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Array != Object.getType()) {
     std::string validation_info = "Incorrect type, expected: " +
                                   SmartObject::typeToString(SmartType_Array) +
@@ -122,8 +124,10 @@ Errors::eType CArraySchemaItem::validate(const SmartObject& Object,
   for (size_t i = 0u; i < array_len; ++i) {
     std::stringstream strVal;
     strVal << i;
-    const Errors::eType result = mElementSchemaItem->validate(
-        Object.getElement(i), &report__->ReportSubobject(strVal.str()), MessageVersion);
+    const Errors::eType result =
+        mElementSchemaItem->validate(Object.getElement(i),
+                                     &report__->ReportSubobject(strVal.str()),
+                                     MessageVersion);
     if (Errors::OK != result) {
       return result;
     }
@@ -131,11 +135,14 @@ Errors::eType CArraySchemaItem::validate(const SmartObject& Object,
   return Errors::OK;
 }
 
-void CArraySchemaItem::applySchema(SmartObject& Object,
-                                   const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion) {
+void CArraySchemaItem::applySchema(
+    SmartObject& Object,
+    const bool RemoveFakeParameters,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Array == Object.getType()) {
     for (size_t i = 0U; i < Object.length(); ++i) {
-      mElementSchemaItem->applySchema(Object[i], RemoveFakeParameters, MessageVersion);
+      mElementSchemaItem->applySchema(
+          Object[i], RemoveFakeParameters, MessageVersion);
     }
   }
 }
diff --git a/src/components/smart_objects/src/object_schema_item.cc b/src/components/smart_objects/src/object_schema_item.cc
index f9d4f587c5..1eea823013 100644
--- a/src/components/smart_objects/src/object_schema_item.cc
+++ b/src/components/smart_objects/src/object_schema_item.cc
@@ -49,67 +49,66 @@ namespace NsSmartObjects {
 CObjectSchemaItem::SMember::SMember()
     : mSchemaItem(CAlwaysFalseSchemaItem::create()), mIsMandatory(true) {}
 
-CObjectSchemaItem::SMember::SMember(const ISchemaItemPtr SchemaItem,
-                                    const bool IsMandatory,
-                                    const std::string& Since,
-                                    const std::string& Until,
-                                    const bool IsDeprecated,
-                                    const bool IsRemoved,
-                                    const std::vector<CObjectSchemaItem::SMember>& history_vector)
+CObjectSchemaItem::SMember::SMember(
+    const ISchemaItemPtr SchemaItem,
+    const bool IsMandatory,
+    const std::string& Since,
+    const std::string& Until,
+    const bool IsDeprecated,
+    const bool IsRemoved,
+    const std::vector<CObjectSchemaItem::SMember>& history_vector)
     : mSchemaItem(SchemaItem), mIsMandatory(IsMandatory) {
-  
-      if (Since.size() > 0) {
-        utils::SemanticVersion since_struct;
-        std::vector<std::string> since_fields;
-        boost::split(since_fields, Since, boost::is_any_of("."));
-        if(since_fields.size() == 3) {
-          since_struct.major_version = atoi(since_fields[0].c_str());
-          since_struct.minor_version = atoi(since_fields[1].c_str());
-          since_struct.patch_version = atoi(since_fields[2].c_str());
-          mSince = since_struct;           
-        }
-      }
-
-      if (Until.size() > 0) {
-        utils::SemanticVersion until_struct;
-        std::vector<std::string> until_fields;
-        boost::split(until_fields, Until, boost::is_any_of("."));
-        if(until_fields.size() == 3) {
-          until_struct.major_version = atoi(until_fields[0].c_str());
-          until_struct.minor_version = atoi(until_fields[1].c_str());
-          until_struct.patch_version = atoi(until_fields[2].c_str());
-          mUntil = until_struct; 
-        }
-      }
-
-      mIsDeprecated = IsDeprecated;
-      mIsRemoved = IsRemoved;
-      mHistoryVector = history_vector;
-
+  if (Since.size() > 0) {
+    utils::SemanticVersion since_struct;
+    std::vector<std::string> since_fields;
+    boost::split(since_fields, Since, boost::is_any_of("."));
+    if (since_fields.size() == 3) {
+      since_struct.major_version = atoi(since_fields[0].c_str());
+      since_struct.minor_version = atoi(since_fields[1].c_str());
+      since_struct.patch_version = atoi(since_fields[2].c_str());
+      mSince = since_struct;
+    }
+  }
+  if (Until.size() > 0) {
+    utils::SemanticVersion until_struct;
+    std::vector<std::string> until_fields;
+    boost::split(until_fields, Until, boost::is_any_of("."));
+    if (until_fields.size() == 3) {
+      until_struct.major_version = atoi(until_fields[0].c_str());
+      until_struct.minor_version = atoi(until_fields[1].c_str());
+      until_struct.patch_version = atoi(until_fields[2].c_str());
+      mUntil = until_struct;
     }
+  }
+  mIsDeprecated = IsDeprecated;
+  mIsRemoved = IsRemoved;
+  mHistoryVector = history_vector;
+}
 
-bool CObjectSchemaItem::SMember::CheckHistoryFieldVersion(const utils::SemanticVersion& MessageVersion) const {
+bool CObjectSchemaItem::SMember::CheckHistoryFieldVersion(
+    const utils::SemanticVersion& MessageVersion) const {
   if (MessageVersion.isValid()) {
     if (mSince.is_initialized()) {
       if (MessageVersion < mSince.get()) {
-        return false; //Msg version predates `since` field
+        return false;  // Msg version predates `since` field
       } else {
         if (mUntil.is_initialized() && (MessageVersion >= mUntil.get())) {
-          return false; //Msg version newer than `until` field
+          return false;  // Msg version newer than `until` field
         } else {
-          return true; //Mobile msg version falls within specified version range
+          return true;  // Mobile msg version falls within specified version
+                        // range
         }
       }
     }
-      
+
     if (mUntil.is_initialized() && (MessageVersion >= mUntil.get())) {
-      return false; //Msg version newer than `until` field
+      return false;  // Msg version newer than `until` field
     } else {
-      return true; //Mobile msg version falls within specified version range
+      return true;  // Mobile msg version falls within specified version range
     }
   }
 
-  return true; //Not enough version information. Default true.
+  return true;  // Not enough version information. Default true.
 }
 
 std::shared_ptr<CObjectSchemaItem> CObjectSchemaItem::create(
@@ -160,8 +159,10 @@ Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
   return Errors::OK;
 }
 
-Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
-                                          rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+Errors::eType CObjectSchemaItem::validate(
+    const SmartObject& object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Map != object.getType()) {
     std::string validation_info = "Incorrect type, expected: " +
                                   SmartObject::typeToString(SmartType_Map) +
@@ -179,31 +180,44 @@ Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
     const SMember& member = it->second;
     std::set<std::string>::const_iterator key_it = object_keys.find(key);
     if (object_keys.end() == key_it) {
-      if(member.mSince.is_initialized() && MessageVersion < member.mSince.get() && member.mHistoryVector.size() > 0) {
-        //Message version predates parameter and a history vector exists.
-        for (uint i=0; i<member.mHistoryVector.size(); i++) {
-          if (member.mHistoryVector[i].mSince.is_initialized() && MessageVersion >= member.mHistoryVector[i].mSince.get()) {
-            if (member.mHistoryVector[i].mUntil.is_initialized() && MessageVersion >= member.mHistoryVector[i].mUntil.get()) {
-              //MessageVersion is newer than the specified "Until" version
+      if (member.mSince.is_initialized() &&
+          MessageVersion < member.mSince.get() &&
+          member.mHistoryVector.size() > 0) {
+        // Message version predates parameter and a history vector exists.
+        for (uint i = 0; i < member.mHistoryVector.size(); i++) {
+          if (member.mHistoryVector[i].mSince.is_initialized() &&
+              MessageVersion >= member.mHistoryVector[i].mSince.get()) {
+            if (member.mHistoryVector[i].mUntil.is_initialized() &&
+                MessageVersion >= member.mHistoryVector[i].mUntil.get()) {
+              // MessageVersion is newer than the specified "Until" version
               continue;
             } else {
-              if (member.mHistoryVector[i].mIsMandatory == true && (member.mHistoryVector[i].mIsRemoved == false)) {
-                std::string validation_info = "Missing mandatory parameter since and until: " + key;
+              if (member.mHistoryVector[i].mIsMandatory == true &&
+                  (member.mHistoryVector[i].mIsRemoved == false)) {
+                std::string validation_info =
+                    "Missing mandatory parameter since and until: " + key;
                 report__->set_validation_info(validation_info);
-                return Errors::MISSING_MANDATORY_PARAMETER;                
+                return Errors::MISSING_MANDATORY_PARAMETER;
               }
               break;
-            }            
-          } else if (member.mHistoryVector[i].mSince.is_initialized() == false && member.mHistoryVector[i].mUntil.is_initialized() && MessageVersion < member.mHistoryVector[i].mUntil.get()){
-            if (member.mHistoryVector[i].mIsMandatory == true && (member.mHistoryVector[i].mIsRemoved == false)) {
-              std::string validation_info = "Missing mandatory parameter until: " + key;
+            }
+          } else if (member.mHistoryVector[i].mSince.is_initialized() ==
+                         false &&
+                     member.mHistoryVector[i].mUntil.is_initialized() &&
+                     MessageVersion < member.mHistoryVector[i].mUntil.get()) {
+            if (member.mHistoryVector[i].mIsMandatory == true &&
+                (member.mHistoryVector[i].mIsRemoved == false)) {
+              std::string validation_info =
+                  "Missing mandatory parameter until: " + key;
               report__->set_validation_info(validation_info);
-              return Errors::MISSING_MANDATORY_PARAMETER;                
+              return Errors::MISSING_MANDATORY_PARAMETER;
             }
             break;
           }
         }
-      } else if (member.mIsMandatory && member.CheckHistoryFieldVersion(MessageVersion) && (member.mIsMandatory == false)) {
+      } else if (member.mIsMandatory &&
+                 member.CheckHistoryFieldVersion(MessageVersion) &&
+                 (member.mIsMandatory == false)) {
         std::string validation_info = "Missing mandatory parameter: " + key;
         report__->set_validation_info(validation_info);
         return Errors::MISSING_MANDATORY_PARAMETER;
@@ -214,13 +228,16 @@ Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
 
     Errors::eType result = Errors::OK;
     // Check if MessageVersion matches schema version
-    if (member.CheckHistoryFieldVersion(MessageVersion) || member.mHistoryVector.empty()) {
-        result = member.mSchemaItem->validate(field, &report__->ReportSubobject(key), MessageVersion);
-    } else if(member.mHistoryVector.size() > 0){ //Check for history
-      for (uint i=0; i<member.mHistoryVector.size(); i++) {
-        if(member.mHistoryVector[i].CheckHistoryFieldVersion(MessageVersion)) {
-          //Found the correct history schema. Call validate
-          result = member.mHistoryVector[i].mSchemaItem->validate(field, &report__->ReportSubobject(key), MessageVersion);
+    if (member.CheckHistoryFieldVersion(MessageVersion) ||
+        member.mHistoryVector.empty()) {
+      result = member.mSchemaItem->validate(
+          field, &report__->ReportSubobject(key), MessageVersion);
+    } else if (member.mHistoryVector.size() > 0) {  // Check for history
+      for (uint i = 0; i < member.mHistoryVector.size(); i++) {
+        if (member.mHistoryVector[i].CheckHistoryFieldVersion(MessageVersion)) {
+          // Found the correct history schema. Call validate
+          result = member.mHistoryVector[i].mSchemaItem->validate(
+              field, &report__->ReportSubobject(key), MessageVersion);
         }
       }
     }
@@ -232,8 +249,10 @@ Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
   return Errors::OK;
 }
 
-void CObjectSchemaItem::applySchema(SmartObject& Object,
-                                    const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion) {
+void CObjectSchemaItem::applySchema(
+    SmartObject& Object,
+    const bool RemoveFakeParameters,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Map != Object.getType()) {
     return;
   }
@@ -250,10 +269,12 @@ void CObjectSchemaItem::applySchema(SmartObject& Object,
     if (!Object.keyExists(key)) {
       if (member.mSchemaItem->setDefaultValue(default_value)) {
         Object[key] = default_value;
-        member.mSchemaItem->applySchema(Object[key], RemoveFakeParameters, MessageVersion);
+        member.mSchemaItem->applySchema(
+            Object[key], RemoveFakeParameters, MessageVersion);
       }
     } else {
-      member.mSchemaItem->applySchema(Object[key], RemoveFakeParameters, MessageVersion);
+      member.mSchemaItem->applySchema(
+          Object[key], RemoveFakeParameters, MessageVersion);
     }
   }
 }
@@ -306,11 +327,13 @@ size_t CObjectSchemaItem::GetMemberSize() {
 CObjectSchemaItem::CObjectSchemaItem(const Members& members)
     : mMembers(members) {}
 
-void CObjectSchemaItem::RemoveFakeParams(SmartObject& Object, const utils::SemanticVersion& MessageVersion) {
+void CObjectSchemaItem::RemoveFakeParams(
+    SmartObject& Object, const utils::SemanticVersion& MessageVersion) {
   for (SmartMap::const_iterator it = Object.map_begin();
        it != Object.map_end();) {
     const std::string& key = it->first;
-    std::map<std::string, SMember>::const_iterator members_it = mMembers.find(key);
+    std::map<std::string, SMember>::const_iterator members_it =
+        mMembers.find(key);
     if (mMembers.end() == members_it
         // FIXME(EZamakhov): Remove illegal usage of filed in AM
         &&
@@ -318,20 +341,22 @@ void CObjectSchemaItem::RemoveFakeParams(SmartObject& Object, const utils::Seman
         key.compare(app_id) != 0) {
       ++it;
       Object.erase(key);
-    } else if (members_it->second.mIsRemoved && members_it->second.CheckHistoryFieldVersion(MessageVersion)) {
+    } else if (members_it->second.mIsRemoved &&
+               members_it->second.CheckHistoryFieldVersion(MessageVersion)) {
       ++it;
       Object.erase(key);
     } else if (members_it->second.mHistoryVector.size() > 0) {
-      for (uint i=0; i<members_it->second.mHistoryVector.size(); i++) {
-        if (members_it->second.mHistoryVector[i].CheckHistoryFieldVersion(MessageVersion) && members_it->second.mHistoryVector[i].mIsRemoved) {
+      for (uint i = 0; i < members_it->second.mHistoryVector.size(); i++) {
+        if (members_it->second.mHistoryVector[i].CheckHistoryFieldVersion(
+                MessageVersion) &&
+            members_it->second.mHistoryVector[i].mIsRemoved) {
           ++it;
           Object.erase(key);
           break;
         }
       }
       ++it;
-    }
-    else {
+    } else {
       ++it;
     }
   }
diff --git a/src/components/smart_objects/src/schema_item.cc b/src/components/smart_objects/src/schema_item.cc
index 685cd3a79f..001aa5fc5d 100644
--- a/src/components/smart_objects/src/schema_item.cc
+++ b/src/components/smart_objects/src/schema_item.cc
@@ -44,9 +44,10 @@ Errors::eType ISchemaItem::validate(const SmartObject& object,
   return Errors::ERROR;
 }
 
-Errors::eType ISchemaItem::validate(const SmartObject& object,
-                                    rpc::ValidationReport* report__,
-                                    const utils::SemanticVersion& MessageVersion) {
+Errors::eType ISchemaItem::validate(
+    const SmartObject& object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return Errors::ERROR;
 }
 
@@ -59,7 +60,8 @@ bool ISchemaItem::hasDefaultValue(SmartObject& Object) {
 }
 
 void ISchemaItem::applySchema(SmartObject& Object,
-                              const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion) {}
+                              const bool RemoveFakeParameters,
+                              const utils::SemanticVersion& MessageVersion) {}
 
 void ISchemaItem::unapplySchema(SmartObject& Object) {}
 
diff --git a/src/components/smart_objects/src/smart_object.cc b/src/components/smart_objects/src/smart_object.cc
index a1d769dff7..527a4308f8 100644
--- a/src/components/smart_objects/src/smart_object.cc
+++ b/src/components/smart_objects/src/smart_object.cc
@@ -882,7 +882,9 @@ Errors::eType SmartObject::validate(rpc::ValidationReport* report__) {
   return m_schema.validate(*this, report__);
 }
 
-Errors::eType SmartObject::validate(rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+Errors::eType SmartObject::validate(
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return m_schema.validate(*this, report__, MessageVersion);
 }
 
diff --git a/src/components/smart_objects/src/smart_schema.cc b/src/components/smart_objects/src/smart_schema.cc
index 7e2aaed974..154f9e116f 100644
--- a/src/components/smart_objects/src/smart_schema.cc
+++ b/src/components/smart_objects/src/smart_schema.cc
@@ -50,8 +50,10 @@ Errors::eType CSmartSchema::validate(const SmartObject& object,
   return mSchemaItem->validate(object, report__);
 }
 
-Errors::eType CSmartSchema::validate(const SmartObject& object,
-                                     rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) const {
+Errors::eType CSmartSchema::validate(
+    const SmartObject& object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) const {
   return mSchemaItem->validate(object, report__, MessageVersion);
 }
 
@@ -60,7 +62,8 @@ void CSmartSchema::setSchemaItem(const ISchemaItemPtr schemaItem) {
 }
 
 void CSmartSchema::applySchema(SmartObject& Object,
-                               const bool RemoveFakeParameters, const utils::SemanticVersion& MessageVersion) {
+                               const bool RemoveFakeParameters,
+                               const utils::SemanticVersion& MessageVersion) {
   mSchemaItem->applySchema(Object, RemoveFakeParameters, MessageVersion);
 }
 
diff --git a/src/components/smart_objects/src/string_schema_item.cc b/src/components/smart_objects/src/string_schema_item.cc
index 05ed196717..cc6bf79f60 100644
--- a/src/components/smart_objects/src/string_schema_item.cc
+++ b/src/components/smart_objects/src/string_schema_item.cc
@@ -85,7 +85,9 @@ Errors::eType CStringSchemaItem::validate(const SmartObject& Object,
 }
 
 Errors::eType CStringSchemaItem::validate(
-    const SmartObject& Object, rpc::ValidationReport* report__, const utils::SemanticVersion& MessageVersion) {
+    const SmartObject& Object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   return validate(Object, report__);
 }