diff --git a/.clang-format b/.clang-format
index 6a2a2aa..52ac0a1 100644
--- a/.clang-format
+++ b/.clang-format
@@ -5,7 +5,7 @@
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: false
+AlignEscapedNewlines: Right
 AlignOperands:   true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
@@ -14,10 +14,9 @@
 AllowShortFunctionsOnASingleLine: None
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
+AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: true
 BinPackParameters: true
 BraceWrapping:
@@ -30,25 +29,50 @@
   AfterObjCDeclaration: true
   AfterStruct:     true
   AfterUnion:      true
+  AfterExternBlock: true
   BeforeCatch:     true
   BeforeElse:      true
   IndentBraces:    false
+  SplitEmptyFunction:   false
+  SplitEmptyRecord:     false
+  SplitEmptyNamespace:  false
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
+BreakStringLiterals: true
 ColumnLimit:     80
 CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
-DerivePointerAlignment: true
+DerivePointerAlignment: false
 PointerAlignment: Left
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 FixNamespaceComments: true
 ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex:           '^[<"](gtest|gmock)'
+    Priority:        7
+  - Regex:           '^"config.h"'
+    Priority:        -1
+  - Regex:           '^".*\.h"'
+    Priority:        1
+  - Regex:           '^".*\.hpp"'
+    Priority:        2
+  - Regex:           '^<.*\.h>'
+    Priority:        3
+  - Regex:           '^<.*\.hpp>'
+    Priority:        4
+  - Regex:           '^<.*'
+    Priority:        5
+  - Regex:           '.*'
+    Priority:        6
 IndentCaseLabels: true
 IndentWidth:     4
 IndentWrappedFunctionNames: true
@@ -66,12 +90,17 @@
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Right
 ReflowComments:  true
-SortIncludes:    false
+SortIncludes:    true
+SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
 SpacesInAngles:  false
@@ -79,7 +108,8 @@
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
+Standard:        Latest
 TabWidth:        4
 UseTab:          Never
 ...
+
diff --git a/file.hpp b/file.hpp
index 2819791..aaf1062 100644
--- a/file.hpp
+++ b/file.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdio.h>
+
 #include <filesystem>
 namespace phosphor
 {
diff --git a/mainapp.cpp b/mainapp.cpp
index c9da030..e08da61 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <string>
-#include "user_mgr.hpp"
 #include "config.h"
 
+#include "user_mgr.hpp"
+
+#include <string>
+
 // D-Bus root for user manager
 constexpr auto USER_MANAGER_ROOT = "/xyz/openbmc_project/user";
 
diff --git a/phosphor-ldap-config/ldap_config.cpp b/phosphor-ldap-config/ldap_config.cpp
index b602e88..bd3c97f 100644
--- a/phosphor-ldap-config/ldap_config.cpp
+++ b/phosphor-ldap-config/ldap_config.cpp
@@ -1,14 +1,15 @@
-#include "ldap_config_mgr.hpp"
 #include "ldap_config.hpp"
+
+#include "ldap_config_mgr.hpp"
+#include "ldap_mapper_serialize.hpp"
 #include "utils.hpp"
 
+#include <cereal/archives/binary.hpp>
 #include <cereal/types/string.hpp>
 #include <cereal/types/vector.hpp>
-#include <cereal/archives/binary.hpp>
-#include "ldap_mapper_serialize.hpp"
-
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
+
 #include <filesystem>
 #include <fstream>
 #include <sstream>
diff --git a/phosphor-ldap-config/ldap_config.hpp b/phosphor-ldap-config/ldap_config.hpp
index 4ebba38..e68f434 100644
--- a/phosphor-ldap-config/ldap_config.hpp
+++ b/phosphor-ldap-config/ldap_config.hpp
@@ -1,17 +1,19 @@
 #pragma once
 
 #include "config.h"
-#include <xyz/openbmc_project/Object/Enable/server.hpp>
-#include <xyz/openbmc_project/User/Ldap/Create/server.hpp>
-#include <xyz/openbmc_project/User/Ldap/Config/server.hpp>
-#include <xyz/openbmc_project/User/PrivilegeMapper/server.hpp>
-#include <xyz/openbmc_project/Common/error.hpp>
+
 #include "ldap_mapper_entry.hpp"
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
+
 #include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
+#include <xyz/openbmc_project/Object/Enable/server.hpp>
+#include <xyz/openbmc_project/User/Ldap/Config/server.hpp>
+#include <xyz/openbmc_project/User/Ldap/Create/server.hpp>
+#include <xyz/openbmc_project/User/PrivilegeMapper/server.hpp>
 
 #include <filesystem>
 #include <set>
diff --git a/phosphor-ldap-config/ldap_config_mgr.cpp b/phosphor-ldap-config/ldap_config_mgr.cpp
index bf42107..3021793 100644
--- a/phosphor-ldap-config/ldap_config_mgr.cpp
+++ b/phosphor-ldap-config/ldap_config_mgr.cpp
@@ -1,7 +1,8 @@
 #include "ldap_config_mgr.hpp"
-#include "ldap_config.hpp"
 
+#include "ldap_config.hpp"
 #include "utils.hpp"
+
 #include <filesystem>
 #include <fstream>
 #include <sstream>
diff --git a/phosphor-ldap-config/ldap_config_mgr.hpp b/phosphor-ldap-config/ldap_config_mgr.hpp
index 7186503..f623783 100644
--- a/phosphor-ldap-config/ldap_config_mgr.hpp
+++ b/phosphor-ldap-config/ldap_config_mgr.hpp
@@ -1,15 +1,17 @@
 #pragma once
 
+#include "config.h"
+
 #include "ldap_config.hpp"
 
-#include "config.h"
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
+#include <sdbusplus/bus.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Ldap/Config/server.hpp>
 #include <xyz/openbmc_project/User/Ldap/Create/server.hpp>
-#include <xyz/openbmc_project/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include <sdbusplus/bus.hpp>
+
 #include <string>
 namespace phosphor
 {
@@ -57,8 +59,7 @@
         CreateIface(bus, path, true),
         dbusPersistentPath(dbusPersistentPath), configFilePath(filePath),
         tlsCacertFile(caCertFile), tlsCertFile(certFile), bus(bus)
-    {
-    }
+    {}
 
     /** @brief concrete implementation of the pure virtual funtion
             xyz.openbmc_project.User.Ldap.Create.createConfig.
diff --git a/phosphor-ldap-config/ldap_mapper_entry.cpp b/phosphor-ldap-config/ldap_mapper_entry.cpp
index 09b0e0f..eb4a4f2 100644
--- a/phosphor-ldap-config/ldap_mapper_entry.cpp
+++ b/phosphor-ldap-config/ldap_mapper_entry.cpp
@@ -1,13 +1,17 @@
-#include <filesystem>
+#include "config.h"
+
+#include "ldap_mapper_entry.hpp"
+
+#include "ldap_config.hpp"
+#include "ldap_mapper_serialize.hpp"
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "config.h"
-#include "ldap_config.hpp"
-#include "ldap_mapper_entry.hpp"
-#include "ldap_mapper_serialize.hpp"
+
+#include <filesystem>
 
 namespace phosphor
 {
@@ -19,10 +23,10 @@
     sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
 using Argument = xyz::openbmc_project::Common::InvalidArgument;
 
-LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                                 const char *filePath,
-                                 const std::string &groupName,
-                                 const std::string &privilege, Config &parent) :
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                                 const char* filePath,
+                                 const std::string& groupName,
+                                 const std::string& privilege, Config& parent) :
     Interfaces(bus, path, true),
     id(std::stol(std::filesystem::path(path).filename())), manager(parent),
     persistPath(filePath)
@@ -32,13 +36,12 @@
     Interfaces::emit_object_added();
 }
 
-LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                                 const char *filePath, Config &parent) :
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                                 const char* filePath, Config& parent) :
     Interfaces(bus, path, true),
     id(std::stol(std::filesystem::path(path).filename())), manager(parent),
     persistPath(filePath)
-{
-}
+{}
 
 void LDAPMapperEntry::delete_(void)
 {
diff --git a/phosphor-ldap-config/ldap_mapper_entry.hpp b/phosphor-ldap-config/ldap_mapper_entry.hpp
index 310f006..efafeae 100644
--- a/phosphor-ldap-config/ldap_mapper_entry.hpp
+++ b/phosphor-ldap-config/ldap_mapper_entry.hpp
@@ -2,8 +2,8 @@
 
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
-#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
 #include <xyz/openbmc_project/Object/Delete/server.hpp>
+#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
 
 namespace phosphor
 {
@@ -30,10 +30,10 @@
   public:
     LDAPMapperEntry() = delete;
     ~LDAPMapperEntry() = default;
-    LDAPMapperEntry(const LDAPMapperEntry &) = delete;
-    LDAPMapperEntry &operator=(const LDAPMapperEntry &) = delete;
-    LDAPMapperEntry(LDAPMapperEntry &&) = default;
-    LDAPMapperEntry &operator=(LDAPMapperEntry &&) = default;
+    LDAPMapperEntry(const LDAPMapperEntry&) = delete;
+    LDAPMapperEntry& operator=(const LDAPMapperEntry&) = delete;
+    LDAPMapperEntry(LDAPMapperEntry&&) = default;
+    LDAPMapperEntry& operator=(LDAPMapperEntry&&) = default;
 
     /** @brief Constructs LDAP privilege mapper entry object.
      *
@@ -44,9 +44,9 @@
      *  @param[in] privilege - the privilege for the group
      *  @param[in] parent - LDAP privilege mapper manager
      */
-    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                    const char *filePath, const std::string &groupName,
-                    const std::string &privilege, Config &parent);
+    LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                    const char* filePath, const std::string& groupName,
+                    const std::string& privilege, Config& parent);
 
     /** @brief Constructs LDAP privilege mapper entry object
      *
@@ -55,8 +55,8 @@
      *  @param[in] filePath - serialization directory path
      *  @param[in] parent - LDAP privilege mapper manager
      */
-    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                    const char *filePath, Config &parent);
+    LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                    const char* filePath, Config& parent);
 
     /** @brief Delete privilege mapper entry object
      *
@@ -88,7 +88,7 @@
 
   private:
     Id id;
-    Config &manager;
+    Config& manager;
 
     /** @brief serialization directory path */
     std::string persistPath;
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.cpp b/phosphor-ldap-config/ldap_mapper_serialize.cpp
index 7fe2398..e8e56d4 100644
--- a/phosphor-ldap-config/ldap_mapper_serialize.cpp
+++ b/phosphor-ldap-config/ldap_mapper_serialize.cpp
@@ -1,9 +1,12 @@
+#include "config.h"
+
+#include "ldap_mapper_serialize.hpp"
+
 #include <cereal/archives/binary.hpp>
 #include <cereal/types/string.hpp>
-#include <fstream>
 #include <phosphor-logging/log.hpp>
-#include "config.h"
-#include "ldap_mapper_serialize.hpp"
+
+#include <fstream>
 
 // Register class version
 // From cereal documentation;
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.hpp b/phosphor-ldap-config/ldap_mapper_serialize.hpp
index 371a556..bc6cdd8 100644
--- a/phosphor-ldap-config/ldap_mapper_serialize.hpp
+++ b/phosphor-ldap-config/ldap_mapper_serialize.hpp
@@ -1,9 +1,11 @@
 #pragma once
 
-#include <filesystem>
 #include "config.h"
+
 #include "ldap_mapper_entry.hpp"
 
+#include <filesystem>
+
 namespace phosphor
 {
 namespace ldap
diff --git a/phosphor-ldap-config/main.cpp b/phosphor-ldap-config/main.cpp
index 4238086..041609b 100644
--- a/phosphor-ldap-config/main.cpp
+++ b/phosphor-ldap-config/main.cpp
@@ -1,11 +1,14 @@
 #include "config.h"
+
 #include "ldap_config_mgr.hpp"
-#include <filesystem>
-#include <phosphor-logging/log.hpp>
+
 #include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 
+#include <filesystem>
+
 int main(int argc, char* argv[])
 {
     using namespace phosphor::logging;
diff --git a/phosphor-ldap-config/utils.cpp b/phosphor-ldap-config/utils.cpp
index 7a40a3e..8a8b86f 100644
--- a/phosphor-ldap-config/utils.cpp
+++ b/phosphor-ldap-config/utils.cpp
@@ -1,8 +1,10 @@
 #include "utils.hpp"
-#include <cstring>
-#include <netdb.h>
+
 #include <arpa/inet.h>
 #include <ldap.h>
+#include <netdb.h>
+
+#include <cstring>
 #include <memory>
 
 namespace phosphor
diff --git a/phosphor-ldap-mapper/ldap_mapper_entry.cpp b/phosphor-ldap-mapper/ldap_mapper_entry.cpp
index 781833e..a22984f 100644
--- a/phosphor-ldap-mapper/ldap_mapper_entry.cpp
+++ b/phosphor-ldap-mapper/ldap_mapper_entry.cpp
@@ -1,14 +1,18 @@
-#include <filesystem>
-#include <xyz/openbmc_project/Common/error.hpp>
-#include <xyz/openbmc_project/User/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
 #include "config.h"
+
 #include "ldap_mapper_entry.hpp"
+
 #include "ldap_mapper_mgr.hpp"
 #include "ldap_mapper_serialize.hpp"
 
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
+#include <xyz/openbmc_project/User/Common/error.hpp>
+
+#include <filesystem>
+
 namespace phosphor
 {
 namespace user
@@ -19,11 +23,11 @@
     sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
 using Argument = xyz::openbmc_project::Common::InvalidArgument;
 
-LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                                 const char *filePath,
-                                 const std::string &groupName,
-                                 const std::string &privilege,
-                                 LDAPMapperMgr &parent) :
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                                 const char* filePath,
+                                 const std::string& groupName,
+                                 const std::string& privilege,
+                                 LDAPMapperMgr& parent) :
     Ifaces(bus, path, true),
     id(std::stol(std::filesystem::path(path).filename())), manager(parent),
     persistPath(filePath)
@@ -33,13 +37,12 @@
     Ifaces::emit_object_added();
 }
 
-LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                                 const char *filePath, LDAPMapperMgr &parent) :
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                                 const char* filePath, LDAPMapperMgr& parent) :
     Ifaces(bus, path, true),
     id(std::stol(std::filesystem::path(path).filename())), manager(parent),
     persistPath(filePath)
-{
-}
+{}
 
 void LDAPMapperEntry::delete_(void)
 {
diff --git a/phosphor-ldap-mapper/ldap_mapper_entry.hpp b/phosphor-ldap-mapper/ldap_mapper_entry.hpp
index dea85c2..bb45aa3 100644
--- a/phosphor-ldap-mapper/ldap_mapper_entry.hpp
+++ b/phosphor-ldap-mapper/ldap_mapper_entry.hpp
@@ -2,8 +2,8 @@
 
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
-#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
 #include <xyz/openbmc_project/Object/Delete/server.hpp>
+#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
 
 namespace phosphor
 {
@@ -30,10 +30,10 @@
   public:
     LDAPMapperEntry() = delete;
     ~LDAPMapperEntry() = default;
-    LDAPMapperEntry(const LDAPMapperEntry &) = delete;
-    LDAPMapperEntry &operator=(const LDAPMapperEntry &) = delete;
-    LDAPMapperEntry(LDAPMapperEntry &&) = default;
-    LDAPMapperEntry &operator=(LDAPMapperEntry &&) = default;
+    LDAPMapperEntry(const LDAPMapperEntry&) = delete;
+    LDAPMapperEntry& operator=(const LDAPMapperEntry&) = delete;
+    LDAPMapperEntry(LDAPMapperEntry&&) = default;
+    LDAPMapperEntry& operator=(LDAPMapperEntry&&) = default;
 
     /** @brief Constructs LDAP privilege mapper entry object.
      *
@@ -44,9 +44,9 @@
      *  @param[in] privilege - the privilege for the group
      *  @param[in] parent - LDAP privilege mapper manager
      */
-    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                    const char *filePath, const std::string &groupName,
-                    const std::string &privilege, LDAPMapperMgr &parent);
+    LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                    const char* filePath, const std::string& groupName,
+                    const std::string& privilege, LDAPMapperMgr& parent);
 
     /** @brief Constructs LDAP privilege mapper entry object
      *
@@ -55,8 +55,8 @@
      *  @param[in] filePath - serialization directory path
      *  @param[in] parent - LDAP privilege mapper manager
      */
-    LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
-                    const char *filePath, LDAPMapperMgr &parent);
+    LDAPMapperEntry(sdbusplus::bus::bus& bus, const char* path,
+                    const char* filePath, LDAPMapperMgr& parent);
 
     /** @brief Delete privilege mapper entry object
      *
@@ -88,7 +88,7 @@
 
   private:
     Id id;
-    LDAPMapperMgr &manager;
+    LDAPMapperMgr& manager;
 
     /** @brief serialization directory path */
     std::string persistPath;
diff --git a/phosphor-ldap-mapper/ldap_mapper_mgr.cpp b/phosphor-ldap-mapper/ldap_mapper_mgr.cpp
index b8d755b..3a383f6 100644
--- a/phosphor-ldap-mapper/ldap_mapper_mgr.cpp
+++ b/phosphor-ldap-mapper/ldap_mapper_mgr.cpp
@@ -1,12 +1,16 @@
-#include <filesystem>
+#include "config.h"
+
+#include "ldap_mapper_mgr.hpp"
+
+#include "ldap_mapper_serialize.hpp"
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "config.h"
-#include "ldap_mapper_mgr.hpp"
-#include "ldap_mapper_serialize.hpp"
+
+#include <filesystem>
 
 namespace phosphor
 {
@@ -20,12 +24,11 @@
 using PrivilegeMappingExists = sdbusplus::xyz::openbmc_project::User::Common::
     Error::PrivilegeMappingExists;
 
-LDAPMapperMgr::LDAPMapperMgr(sdbusplus::bus::bus &bus, const char *path,
-                             const char *filePath) :
+LDAPMapperMgr::LDAPMapperMgr(sdbusplus::bus::bus& bus, const char* path,
+                             const char* filePath) :
     MapperMgrIface(bus, path),
     bus(bus), path(path), persistPath(filePath)
-{
-}
+{}
 
 ObjectPath LDAPMapperMgr::create(std::string groupName, std::string privilege)
 {
@@ -60,7 +63,7 @@
     PrivilegeMapperList.erase(id);
 }
 
-void LDAPMapperMgr::checkPrivilegeMapper(const std::string &groupName)
+void LDAPMapperMgr::checkPrivilegeMapper(const std::string& groupName)
 {
     if (groupName.empty())
     {
@@ -69,7 +72,7 @@
                               Argument::ARGUMENT_VALUE("Null"));
     }
 
-    for (const auto &val : PrivilegeMapperList)
+    for (const auto& val : PrivilegeMapperList)
     {
         if (val.second.get()->groupName() == groupName)
         {
@@ -79,7 +82,7 @@
     }
 }
 
-void LDAPMapperMgr::checkPrivilegeLevel(const std::string &privilege)
+void LDAPMapperMgr::checkPrivilegeLevel(const std::string& privilege)
 {
     if (privilege.empty())
     {
@@ -104,7 +107,7 @@
         return;
     }
 
-    for (auto &file : std::filesystem::directory_iterator(dir))
+    for (auto& file : std::filesystem::directory_iterator(dir))
     {
         std::string id = file.path().filename().c_str();
         size_t idNum = std::stol(id);
diff --git a/phosphor-ldap-mapper/ldap_mapper_mgr.hpp b/phosphor-ldap-mapper/ldap_mapper_mgr.hpp
index 88e4f26..3792f0a 100644
--- a/phosphor-ldap-mapper/ldap_mapper_mgr.hpp
+++ b/phosphor-ldap-mapper/ldap_mapper_mgr.hpp
@@ -1,9 +1,11 @@
 #pragma once
 
+#include "ldap_mapper_entry.hpp"
+
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
-#include "ldap_mapper_entry.hpp"
 #include <xyz/openbmc_project/User/PrivilegeMapper/server.hpp>
+
 #include <map>
 #include <set>
 
@@ -29,10 +31,10 @@
   public:
     LDAPMapperMgr() = delete;
     ~LDAPMapperMgr() = default;
-    LDAPMapperMgr(const LDAPMapperMgr &) = delete;
-    LDAPMapperMgr &operator=(const LDAPMapperMgr &) = delete;
-    LDAPMapperMgr(LDAPMapperMgr &&) = delete;
-    LDAPMapperMgr &operator=(LDAPMapperMgr &&) = delete;
+    LDAPMapperMgr(const LDAPMapperMgr&) = delete;
+    LDAPMapperMgr& operator=(const LDAPMapperMgr&) = delete;
+    LDAPMapperMgr(LDAPMapperMgr&&) = delete;
+    LDAPMapperMgr& operator=(LDAPMapperMgr&&) = delete;
 
     /** @brief Constructs LDAPMapperMgr object.
      *
@@ -40,8 +42,8 @@
      *  @param[in] path - D-Bus path
      *  @param[in] filePath - serialization directory path
      */
-    LDAPMapperMgr(sdbusplus::bus::bus &bus, const char *path,
-                  const char *filePath);
+    LDAPMapperMgr(sdbusplus::bus::bus& bus, const char* path,
+                  const char* filePath);
 
     /** @brief Creates a mapping for the group to the privilege
      *
@@ -72,7 +74,7 @@
      *
      *  @return throw exception if the conditions are not met.
      */
-    void checkPrivilegeMapper(const std::string &groupName);
+    void checkPrivilegeMapper(const std::string& groupName);
 
     /** @brief Check if the privilege level is a valid one
      *
@@ -80,7 +82,7 @@
      *
      *  @return throw exception if the conditions are not met.
      */
-    void checkPrivilegeLevel(const std::string &privilege);
+    void checkPrivilegeLevel(const std::string& privilege);
 
     /** @brief Construct LDAP mapper entry D-Bus objects from their persisted
      *         representations.
@@ -89,7 +91,7 @@
 
   private:
     /** @brief sdbusplus handler */
-    sdbusplus::bus::bus &bus;
+    sdbusplus::bus::bus& bus;
 
     /** @brief object path for the manager object*/
     const std::string path;
diff --git a/phosphor-ldap-mapper/ldap_mapper_serialize.cpp b/phosphor-ldap-mapper/ldap_mapper_serialize.cpp
index 65918fd..b0124c2 100644
--- a/phosphor-ldap-mapper/ldap_mapper_serialize.cpp
+++ b/phosphor-ldap-mapper/ldap_mapper_serialize.cpp
@@ -1,10 +1,13 @@
+#include "config.h"
+
+#include "ldap_mapper_serialize.hpp"
+
 #include <cereal/archives/binary.hpp>
 #include <cereal/types/string.hpp>
-#include <fstream>
-#include <filesystem>
 #include <phosphor-logging/log.hpp>
-#include "config.h"
-#include "ldap_mapper_serialize.hpp"
+
+#include <filesystem>
+#include <fstream>
 
 // Register class version
 // From cereal documentation;
diff --git a/phosphor-ldap-mapper/ldap_mapper_serialize.hpp b/phosphor-ldap-mapper/ldap_mapper_serialize.hpp
index 7d918d8..f306ada 100644
--- a/phosphor-ldap-mapper/ldap_mapper_serialize.hpp
+++ b/phosphor-ldap-mapper/ldap_mapper_serialize.hpp
@@ -1,9 +1,11 @@
 #pragma once
 
-#include <filesystem>
 #include "config.h"
+
 #include "ldap_mapper_entry.hpp"
 
+#include <filesystem>
+
 namespace phosphor
 {
 namespace user
diff --git a/phosphor-ldap-mapper/main.cpp b/phosphor-ldap-mapper/main.cpp
index 1833a6a..0ccf85c 100644
--- a/phosphor-ldap-mapper/main.cpp
+++ b/phosphor-ldap-mapper/main.cpp
@@ -1,8 +1,10 @@
-#include <string>
-#include <filesystem>
 #include "config.h"
+
 #include "ldap_mapper_mgr.hpp"
 
+#include <filesystem>
+#include <string>
+
 int main(int argc, char** argv)
 {
     auto bus = sdbusplus::bus::new_default();
diff --git a/shadowlock.hpp b/shadowlock.hpp
index 81903df..f274966 100644
--- a/shadowlock.hpp
+++ b/shadowlock.hpp
@@ -1,12 +1,14 @@
 #pragma once
 
-#include <stdio.h>
-#include <cassert>
 #include <shadow.h>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <xyz/openbmc_project/Common/error.hpp>
+#include <stdio.h>
+
 #include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
+
+#include <cassert>
 namespace phosphor
 {
 namespace user
diff --git a/test/ldap_config_test.cpp b/test/ldap_config_test.cpp
index 5606af5..8168245 100644
--- a/test/ldap_config_test.cpp
+++ b/test/ldap_config_test.cpp
@@ -1,20 +1,22 @@
 #include "config.h"
+
 #include "phosphor-ldap-config/ldap_config.hpp"
 #include "phosphor-ldap-config/ldap_config_mgr.hpp"
 
-#include <phosphor-logging/log.hpp>
+#include <sys/types.h>
+
 #include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include <sdbusplus/bus.hpp>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
 
 #include <filesystem>
 #include <fstream>
 #include <string>
-#include <sys/types.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
@@ -34,8 +36,7 @@
 {
   public:
     TestLDAPConfig() : bus(sdbusplus::bus::new_default())
-    {
-    }
+    {}
     void SetUp() override
     {
         using namespace phosphor::ldap;
@@ -80,8 +81,7 @@
                   const char* caCertFile, const char* certFile) :
         phosphor::ldap::ConfigMgr(bus, path, filePath, dbusPersistentFile,
                                   caCertFile, certFile)
-    {
-    }
+    {}
     MOCK_METHOD1(restartService, void(const std::string& service));
     MOCK_METHOD1(stopService, void(const std::string& service));
     std::unique_ptr<Config>& getOpenLdapConfigPtr()
diff --git a/test/ldap_mapper_test.cpp b/test/ldap_mapper_test.cpp
index a044b64..275ebe5 100644
--- a/test/ldap_mapper_test.cpp
+++ b/test/ldap_mapper_test.cpp
@@ -1,14 +1,19 @@
-#include <gtest/gtest.h>
-#include <filesystem>
-#include <stdlib.h>
-#include <sdbusplus/bus.hpp>
+#include "config.h"
+
 #include "phosphor-ldap-mapper/ldap_mapper_entry.hpp"
 #include "phosphor-ldap-mapper/ldap_mapper_mgr.hpp"
 #include "phosphor-ldap-mapper/ldap_mapper_serialize.hpp"
+
+#include <stdlib.h>
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/test/sdbus_mock.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include "config.h"
-#include <sdbusplus/test/sdbus_mock.hpp>
+
+#include <filesystem>
+
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
@@ -21,8 +26,7 @@
     sdbusplus::SdBusMock sdbusMock;
 
     TestSerialization() : bus(sdbusplus::get_mocked_new(&sdbusMock))
-    {
-    }
+    {}
 
     void SetUp() override
     {
diff --git a/test/mock_user_mgr.hpp b/test/mock_user_mgr.hpp
index ea7c5f6..ec47909 100644
--- a/test/mock_user_mgr.hpp
+++ b/test/mock_user_mgr.hpp
@@ -1,4 +1,5 @@
 #include "user_mgr.hpp"
+
 #include <gmock/gmock.h>
 
 namespace phosphor
@@ -13,8 +14,7 @@
   public:
     MockManager(sdbusplus::bus::bus& bus, const char* path) :
         UserMgr(bus, objpath)
-    {
-    }
+    {}
 
     MOCK_METHOD1(getLdapGroupName, std::string(const std::string& userName));
     MOCK_METHOD0(getPrivilegeMapperObject, DbusUserObj());
diff --git a/test/user_mgr_test.cpp b/test/user_mgr_test.cpp
index 88911cd..818a18b 100644
--- a/test/user_mgr_test.cpp
+++ b/test/user_mgr_test.cpp
@@ -1,9 +1,12 @@
 #include "mock_user_mgr.hpp"
-#include <xyz/openbmc_project/User/Common/error.hpp>
-#include <xyz/openbmc_project/Common/error.hpp>
-#include <gtest/gtest.h>
-#include <exception>
+
 #include <sdbusplus/test/sdbus_mock.hpp>
+#include <xyz/openbmc_project/Common/error.hpp>
+#include <xyz/openbmc_project/User/Common/error.hpp>
+
+#include <exception>
+
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
@@ -24,12 +27,11 @@
 
     TestUserMgr() :
         bus(sdbusplus::get_mocked_new(&sdbusMock)), mockManager(bus, objpath)
-    {
-    }
+    {}
 
-    void createLocalUser(const std::string &userName,
+    void createLocalUser(const std::string& userName,
                          std::vector<std::string> groupNames,
-                         const std::string &priv, bool enabled)
+                         const std::string& priv, bool enabled)
     {
         std::string userObj = std::string(usersObjPath) + "/" + userName;
         mockManager.usersList.emplace(
diff --git a/test/utils_test.cpp b/test/utils_test.cpp
index cded321..d312685 100644
--- a/test/utils_test.cpp
+++ b/test/utils_test.cpp
@@ -1,7 +1,9 @@
 #include "phosphor-ldap-config/utils.hpp"
-#include <netinet/in.h>
-#include <gtest/gtest.h>
+
 #include <ldap.h>
+#include <netinet/in.h>
+
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
diff --git a/user_mgr.cpp b/user_mgr.cpp
index 0447fe7..c65a822 100644
--- a/user_mgr.cpp
+++ b/user_mgr.cpp
@@ -14,67 +14,72 @@
 // limitations under the License.
 */
 
+#include "config.h"
+
+#include "user_mgr.hpp"
+
+#include "file.hpp"
+#include "shadowlock.hpp"
+#include "users.hpp"
+
+#include <grp.h>
+#include <pwd.h>
 #include <shadow.h>
-#include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
-#include <fstream>
-#include <grp.h>
-#include <pwd.h>
-#include <regex>
-#include <algorithm>
-#include <numeric>
+#include <unistd.h>
+
+#include <boost/algorithm/string/split.hpp>
 #include <boost/process/child.hpp>
 #include <boost/process/io.hpp>
-#include <boost/algorithm/string/split.hpp>
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "shadowlock.hpp"
-#include "file.hpp"
-#include "user_mgr.hpp"
-#include "users.hpp"
-#include "config.h"
+
+#include <algorithm>
+#include <fstream>
+#include <numeric>
+#include <regex>
 
 namespace phosphor
 {
 namespace user
 {
 
-static constexpr const char *passwdFileName = "/etc/passwd";
+static constexpr const char* passwdFileName = "/etc/passwd";
 static constexpr size_t ipmiMaxUsers = 15;
 static constexpr size_t ipmiMaxUserNameLen = 16;
 static constexpr size_t systemMaxUserNameLen = 30;
 static constexpr size_t maxSystemUsers = 30;
-static constexpr const char *grpSsh = "ssh";
+static constexpr const char* grpSsh = "ssh";
 static constexpr uint8_t minPasswdLength = 8;
 static constexpr int success = 0;
 static constexpr int failure = -1;
 
 // pam modules related
-static constexpr const char *pamTally2 = "pam_tally2.so";
-static constexpr const char *pamCrackLib = "pam_cracklib.so";
-static constexpr const char *pamPWHistory = "pam_pwhistory.so";
-static constexpr const char *minPasswdLenProp = "minlen";
-static constexpr const char *remOldPasswdCount = "remember";
-static constexpr const char *maxFailedAttempt = "deny";
-static constexpr const char *unlockTimeout = "unlock_time";
-static constexpr const char *pamPasswdConfigFile = "/etc/pam.d/common-password";
-static constexpr const char *pamAuthConfigFile = "/etc/pam.d/common-auth";
+static constexpr const char* pamTally2 = "pam_tally2.so";
+static constexpr const char* pamCrackLib = "pam_cracklib.so";
+static constexpr const char* pamPWHistory = "pam_pwhistory.so";
+static constexpr const char* minPasswdLenProp = "minlen";
+static constexpr const char* remOldPasswdCount = "remember";
+static constexpr const char* maxFailedAttempt = "deny";
+static constexpr const char* unlockTimeout = "unlock_time";
+static constexpr const char* pamPasswdConfigFile = "/etc/pam.d/common-password";
+static constexpr const char* pamAuthConfigFile = "/etc/pam.d/common-auth";
 
 // Object Manager related
-static constexpr const char *ldapMgrObjBasePath =
+static constexpr const char* ldapMgrObjBasePath =
     "/xyz/openbmc_project/user/ldap";
 
 // Object Mapper related
-static constexpr const char *objMapperService =
+static constexpr const char* objMapperService =
     "xyz.openbmc_project.ObjectMapper";
-static constexpr const char *objMapperPath =
+static constexpr const char* objMapperPath =
     "/xyz/openbmc_project/object_mapper";
-static constexpr const char *objMapperInterface =
+static constexpr const char* objMapperInterface =
     "xyz.openbmc_project.ObjectMapper";
 
 using namespace phosphor::logging;
@@ -96,12 +101,12 @@
 using Argument = xyz::openbmc_project::Common::InvalidArgument;
 
 template <typename... ArgTypes>
-static std::vector<std::string> executeCmd(const char *path,
-                                           ArgTypes &&... tArgs)
+static std::vector<std::string> executeCmd(const char* path,
+                                           ArgTypes&&... tArgs)
 {
     std::vector<std::string> stdOutput;
     boost::process::ipstream stdOutStream;
-    boost::process::child execProg(path, const_cast<char *>(tArgs)...,
+    boost::process::child execProg(path, const_cast<char*>(tArgs)...,
                                    boost::process::std_out > stdOutStream);
     std::string stdOutLine;
 
@@ -149,7 +154,7 @@
     }
 }
 
-static bool removeStringFromCSV(std::string &csvStr, const std::string &delStr)
+static bool removeStringFromCSV(std::string& csvStr, const std::string& delStr)
 {
     std::string::size_type delStrPos = csvStr.find(delStr);
     if (delStrPos != std::string::npos)
@@ -168,7 +173,7 @@
     return false;
 }
 
-bool UserMgr::isUserExist(const std::string &userName)
+bool UserMgr::isUserExist(const std::string& userName)
 {
     if (userName.empty())
     {
@@ -183,7 +188,7 @@
     return true;
 }
 
-void UserMgr::throwForUserDoesNotExist(const std::string &userName)
+void UserMgr::throwForUserDoesNotExist(const std::string& userName)
 {
     if (isUserExist(userName) == false)
     {
@@ -193,7 +198,7 @@
     }
 }
 
-void UserMgr::throwForUserExists(const std::string &userName)
+void UserMgr::throwForUserExists(const std::string& userName)
 {
     if (isUserExist(userName) == true)
     {
@@ -204,7 +209,7 @@
 }
 
 void UserMgr::throwForUserNameConstraints(
-    const std::string &userName, const std::vector<std::string> &groupNames)
+    const std::string& userName, const std::vector<std::string>& groupNames)
 {
     if (std::find(groupNames.begin(), groupNames.end(), "ipmi") !=
         groupNames.end())
@@ -236,7 +241,7 @@
 }
 
 void UserMgr::throwForMaxGrpUserCount(
-    const std::vector<std::string> &groupNames)
+    const std::vector<std::string>& groupNames)
 {
     if (std::find(groupNames.begin(), groupNames.end(), "ipmi") !=
         groupNames.end())
@@ -263,7 +268,7 @@
     return;
 }
 
-void UserMgr::throwForInvalidPrivilege(const std::string &priv)
+void UserMgr::throwForInvalidPrivilege(const std::string& priv)
 {
     if (!priv.empty() &&
         (std::find(privMgr.begin(), privMgr.end(), priv) == privMgr.end()))
@@ -274,9 +279,9 @@
     }
 }
 
-void UserMgr::throwForInvalidGroups(const std::vector<std::string> &groupNames)
+void UserMgr::throwForInvalidGroups(const std::vector<std::string>& groupNames)
 {
-    for (auto &group : groupNames)
+    for (auto& group : groupNames)
     {
         if (std::find(groupsMgr.begin(), groupsMgr.end(), group) ==
             groupsMgr.end())
@@ -320,7 +325,7 @@
                    (sshRequested ? "/bin/sh" : "/bin/nologin"), "-e",
                    (enabled ? "" : "1970-01-02"));
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("Unable to create new user");
         elog<InternalFailure>();
@@ -347,7 +352,7 @@
     {
         executeCmd("/usr/sbin/userdel", userName.c_str(), "-r");
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("User delete failed",
                         entry("USER_NAME=%s", userName.c_str()));
@@ -375,13 +380,13 @@
         executeCmd("/usr/sbin/usermod", "-l", newUserName.c_str(),
                    userName.c_str(), "-d", newHomeDir.c_str(), "-m");
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("User rename failed",
                         entry("USER_NAME=%s", userName.c_str()));
         elog<InternalFailure>();
     }
-    const auto &user = usersList[userName];
+    const auto& user = usersList[userName];
     std::string priv = user.get()->userPrivilege();
     std::vector<std::string> groupNames = user.get()->userGroups();
     bool enabled = user.get()->userEnabled();
@@ -398,16 +403,16 @@
     return;
 }
 
-void UserMgr::updateGroupsAndPriv(const std::string &userName,
-                                  const std::vector<std::string> &groupNames,
-                                  const std::string &priv)
+void UserMgr::updateGroupsAndPriv(const std::string& userName,
+                                  const std::vector<std::string>& groupNames,
+                                  const std::string& priv)
 {
     throwForInvalidPrivilege(priv);
     throwForInvalidGroups(groupNames);
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
     throwForUserDoesNotExist(userName);
-    const std::vector<std::string> &oldGroupNames =
+    const std::vector<std::string>& oldGroupNames =
         usersList[userName].get()->userGroups();
     std::vector<std::string> groupDiff;
     // Note: already dealing with sorted group lists.
@@ -439,7 +444,7 @@
         executeCmd("/usr/sbin/usermod", userName.c_str(), "-G", groups.c_str(),
                    "-s", (sshRequested ? "/bin/sh" : "/bin/nologin"));
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("Unable to modify user privilege / groups");
         elog<InternalFailure>();
@@ -514,9 +519,9 @@
     return AccountPolicyIface::accountUnlockTimeout(value);
 }
 
-int UserMgr::getPamModuleArgValue(const std::string &moduleName,
-                                  const std::string &argName,
-                                  std::string &argValue)
+int UserMgr::getPamModuleArgValue(const std::string& moduleName,
+                                  const std::string& argName,
+                                  std::string& argValue)
 {
     std::string fileName;
     if (moduleName == pamTally2)
@@ -567,9 +572,9 @@
     return failure;
 }
 
-int UserMgr::setPamModuleArgValue(const std::string &moduleName,
-                                  const std::string &argName,
-                                  const std::string &argValue)
+int UserMgr::setPamModuleArgValue(const std::string& moduleName,
+                                  const std::string& argName,
+                                  const std::string& argValue)
 {
     std::string fileName;
     if (moduleName == pamTally2)
@@ -637,7 +642,7 @@
     return failure;
 }
 
-void UserMgr::userEnable(const std::string &userName, bool enabled)
+void UserMgr::userEnable(const std::string& userName, bool enabled)
 {
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
@@ -647,7 +652,7 @@
         executeCmd("/usr/sbin/usermod", userName.c_str(), "-e",
                    (enabled ? "" : "1970-01-02"));
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("Unable to modify user enabled state");
         elog<InternalFailure>();
@@ -670,7 +675,7 @@
 static constexpr size_t t2FailCntIdx = 1;
 static constexpr size_t t2OutputIndex = 1;
 
-bool UserMgr::userLockedForFailedAttempt(const std::string &userName)
+bool UserMgr::userLockedForFailedAttempt(const std::string& userName)
 {
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
@@ -699,7 +704,7 @@
         }
         return false; // User account is un-locked
     }
-    catch (const std::exception &e)
+    catch (const std::exception& e)
     {
         log<level::ERR>("Exception for userLockedForFailedAttempt",
                         entry("WHAT=%s", e.what()));
@@ -707,8 +712,8 @@
     }
 }
 
-bool UserMgr::userLockedForFailedAttempt(const std::string &userName,
-                                         const bool &value)
+bool UserMgr::userLockedForFailedAttempt(const std::string& userName,
+                                         const bool& value)
 {
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
@@ -727,15 +732,14 @@
     return userLockedForFailedAttempt(userName);
 }
 
-bool UserMgr::userPasswordExpired(const std::string &userName)
+bool UserMgr::userPasswordExpired(const std::string& userName)
 {
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
 
     struct spwd spwd
-    {
-    };
-    struct spwd *spwdPtr = nullptr;
+    {};
+    struct spwd* spwdPtr = nullptr;
     auto buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
     if (buflen < -1)
     {
@@ -831,13 +835,13 @@
     return userList.size();
 }
 
-bool UserMgr::isUserEnabled(const std::string &userName)
+bool UserMgr::isUserEnabled(const std::string& userName)
 {
     // All user management lock has to be based on /etc/shadow
     phosphor::user::shadow::Lock lock();
     std::array<char, 4096> buffer{};
     struct spwd spwd;
-    struct spwd *resultPtr = nullptr;
+    struct spwd* resultPtr = nullptr;
     int status = getspnam_r(userName.c_str(), &spwd, buffer.data(),
                             buffer.max_size(), &resultPtr);
     if (!status && (&spwd == resultPtr))
@@ -851,13 +855,13 @@
     return false; // assume user is disabled for any error.
 }
 
-std::vector<std::string> UserMgr::getUsersInGroup(const std::string &groupName)
+std::vector<std::string> UserMgr::getUsersInGroup(const std::string& groupName)
 {
     std::vector<std::string> usersInGroup;
     // Should be more than enough to get the pwd structure.
     std::array<char, 4096> buffer{};
     struct group grp;
-    struct group *resultPtr = nullptr;
+    struct group* resultPtr = nullptr;
 
     int status = getgrnam_r(groupName.c_str(), &grp, buffer.data(),
                             buffer.max_size(), &resultPtr);
@@ -895,13 +899,13 @@
         auto reply = bus.call(method);
         reply.read(objects);
     }
-    catch (const InternalFailure &e)
+    catch (const InternalFailure& e)
     {
         log<level::ERR>("Unable to get the User Service",
                         entry("WHAT=%s", e.what()));
         throw;
     }
-    catch (const sdbusplus::exception::SdBusError &e)
+    catch (const sdbusplus::exception::SdBusError& e)
     {
         log<level::ERR>(
             "Failed to excute method", entry("METHOD=%s", "GetManagedObjects"),
@@ -911,12 +915,11 @@
     return objects;
 }
 
-std::string UserMgr::getLdapGroupName(const std::string &userName)
+std::string UserMgr::getLdapGroupName(const std::string& userName)
 {
     struct passwd pwd
-    {
-    };
-    struct passwd *pwdPtr = nullptr;
+    {};
+    struct passwd* pwdPtr = nullptr;
     auto buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
     if (buflen < -1)
     {
@@ -942,7 +945,7 @@
         elog<UserNameDoesNotExist>();
     }
 
-    struct group *groups = nullptr;
+    struct group* groups = nullptr;
     std::string ldapGroupName;
 
     while ((groups = getgrent()) != NULL)
@@ -959,7 +962,7 @@
     return ldapGroupName;
 }
 
-std::string UserMgr::getServiceName(std::string &&path, std::string &&intf)
+std::string UserMgr::getServiceName(std::string&& path, std::string&& intf)
 {
     auto mapperCall = bus.new_method_call(objMapperService, objMapperPath,
                                           objMapperInterface, "GetObject");
@@ -993,7 +996,7 @@
     // Check whether the given user is local user or not.
     if (isUserExist(userName) == true)
     {
-        const auto &user = usersList[userName];
+        const auto& user = usersList[userName];
         userInfo.emplace("UserPrivilege", user.get()->userPrivilege());
         userInfo.emplace("UserGroups", user.get()->userGroups());
         userInfo.emplace("UserEnabled", user.get()->userEnabled());
@@ -1021,14 +1024,14 @@
 
         try
         {
-            for (const auto &obj : objects)
+            for (const auto& obj : objects)
             {
-                for (const auto &interface : obj.second)
+                for (const auto& interface : obj.second)
                 {
                     if ((interface.first ==
                          "xyz.openbmc_project.Object.Enable"))
                     {
-                        for (const auto &property : interface.second)
+                        for (const auto& property : interface.second)
                         {
                             auto value = std::get<bool>(property.second);
                             if ((property.first == "Enabled") &&
@@ -1051,9 +1054,9 @@
                 return userInfo;
             }
 
-            for (const auto &obj : objects)
+            for (const auto& obj : objects)
             {
-                for (const auto &interface : obj.second)
+                for (const auto& interface : obj.second)
                 {
                     if ((interface.first ==
                          "xyz.openbmc_project.User.PrivilegeMapperEntry") &&
@@ -1061,7 +1064,7 @@
                          std::string::npos))
                     {
 
-                        for (const auto &property : interface.second)
+                        for (const auto& property : interface.second)
                         {
                             auto value = std::get<std::string>(property.second);
                             if (property.first == "GroupName")
@@ -1087,7 +1090,7 @@
                 log<level::ERR>("LDAP group privilege mapping does not exist");
             }
         }
-        catch (const std::bad_variant_access &e)
+        catch (const std::bad_variant_access& e)
         {
             log<level::ERR>("Error while accessing variant",
                             entry("WHAT=%s", e.what()));
@@ -1112,7 +1115,7 @@
     if (!userNameList.empty())
     {
         std::map<std::string, std::vector<std::string>> groupLists;
-        for (auto &grp : groupsMgr)
+        for (auto& grp : groupsMgr)
         {
             if (grp == grpSsh)
             {
@@ -1124,17 +1127,17 @@
                 groupLists.emplace(grp, grpUsersList);
             }
         }
-        for (auto &grp : privMgr)
+        for (auto& grp : privMgr)
         {
             std::vector<std::string> grpUsersList = getUsersInGroup(grp);
             groupLists.emplace(grp, grpUsersList);
         }
 
-        for (auto &user : userNameList)
+        for (auto& user : userNameList)
         {
             std::vector<std::string> userGroups;
             std::string userPriv;
-            for (const auto &grp : groupLists)
+            for (const auto& grp : groupLists)
             {
                 std::vector<std::string> tempGrp = grp.second;
                 if (std::find(tempGrp.begin(), tempGrp.end(), user) !=
@@ -1162,7 +1165,7 @@
     }
 }
 
-UserMgr::UserMgr(sdbusplus::bus::bus &bus, const char *path) :
+UserMgr::UserMgr(sdbusplus::bus::bus& bus, const char* path) :
     Ifaces(bus, path, true), bus(bus), path(path)
 {
     UserMgrIface::allPrivileges(privMgr);
@@ -1187,7 +1190,7 @@
             }
             value = static_cast<decltype(value)>(tmp);
         }
-        catch (const std::exception &e)
+        catch (const std::exception& e)
         {
             log<level::ERR>("Exception for MinPasswordLength",
                             entry("WHAT=%s", e.what()));
@@ -1213,7 +1216,7 @@
             }
             value = static_cast<decltype(value)>(tmp);
         }
-        catch (const std::exception &e)
+        catch (const std::exception& e)
         {
             log<level::ERR>("Exception for RememberOldPasswordTimes",
                             entry("WHAT=%s", e.what()));
@@ -1238,7 +1241,7 @@
             }
             value16 = static_cast<decltype(value16)>(tmp);
         }
-        catch (const std::exception &e)
+        catch (const std::exception& e)
         {
             log<level::ERR>("Exception for MaxLoginAttemptBeforLockout",
                             entry("WHAT=%s", e.what()));
@@ -1263,7 +1266,7 @@
             }
             value32 = static_cast<decltype(value32)>(tmp);
         }
-        catch (const std::exception &e)
+        catch (const std::exception& e)
         {
             log<level::ERR>("Exception for AccountUnlockTimeout",
                             entry("WHAT=%s", e.what()));
diff --git a/user_mgr.hpp b/user_mgr.hpp
index 7200c09..f5aac22 100644
--- a/user_mgr.hpp
+++ b/user_mgr.hpp
@@ -14,13 +14,15 @@
 // limitations under the License.
 */
 #pragma once
+#include "users.hpp"
+
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
-#include <xyz/openbmc_project/User/Manager/server.hpp>
 #include <xyz/openbmc_project/User/AccountPolicy/server.hpp>
+#include <xyz/openbmc_project/User/Manager/server.hpp>
+
 #include <unordered_map>
 #include <variant>
-#include "users.hpp"
 
 namespace phosphor
 {
@@ -66,17 +68,17 @@
   public:
     UserMgr() = delete;
     ~UserMgr() = default;
-    UserMgr(const UserMgr &) = delete;
-    UserMgr &operator=(const UserMgr &) = delete;
-    UserMgr(UserMgr &&) = delete;
-    UserMgr &operator=(UserMgr &&) = delete;
+    UserMgr(const UserMgr&) = delete;
+    UserMgr& operator=(const UserMgr&) = delete;
+    UserMgr(UserMgr&&) = delete;
+    UserMgr& operator=(UserMgr&&) = delete;
 
     /** @brief Constructs UserMgr object.
      *
      *  @param[in] bus  - sdbusplus handler
      *  @param[in] path - D-Bus path
      */
-    UserMgr(sdbusplus::bus::bus &bus, const char *path);
+    UserMgr(sdbusplus::bus::bus& bus, const char* path);
 
     /** @brief create user method.
      *  This method creates a new user as requested
@@ -111,9 +113,9 @@
      *  @param[in] groupName - Group to be updated..
      *  @param[in] priv - Privilege to be updated.
      */
-    void updateGroupsAndPriv(const std::string &userName,
-                             const std::vector<std::string> &groups,
-                             const std::string &priv);
+    void updateGroupsAndPriv(const std::string& userName,
+                             const std::vector<std::string>& groups,
+                             const std::string& priv);
 
     /** @brief Update user enabled state.
      *  This method enables / disables user
@@ -121,7 +123,7 @@
      *  @param[in] userName - user name, for which update is requested
      *  @param[in] enabled - enable / disable the user
      */
-    void userEnable(const std::string &userName, bool enabled);
+    void userEnable(const std::string& userName, bool enabled);
 
     /** @brief update minimum password length requirement
      *
@@ -157,22 +159,22 @@
      * @param[in] - user name
      * @return - true / false indicating user locked / un-locked
      **/
-    virtual bool userLockedForFailedAttempt(const std::string &userName);
+    virtual bool userLockedForFailedAttempt(const std::string& userName);
 
     /** @brief lists user locked state for failed attempt
      *
      * @param[in]: user name
      * @param[in]: value - false -unlock user account, true - no action taken
      **/
-    bool userLockedForFailedAttempt(const std::string &userName,
-                                    const bool &value);
+    bool userLockedForFailedAttempt(const std::string& userName,
+                                    const bool& value);
 
     /** @brief shows if the user's password is expired
      *
      * @param[in]: user name
      * @return - true / false indicating user password expired
      **/
-    virtual bool userPasswordExpired(const std::string &userName);
+    virtual bool userPasswordExpired(const std::string& userName);
 
     /** @brief returns user info
      * Checks if user is local user, then returns map of properties of user.
@@ -187,7 +189,7 @@
 
   private:
     /** @brief sdbusplus handler */
-    sdbusplus::bus::bus &bus;
+    sdbusplus::bus::bus& bus;
 
     /** @brief object path */
     const std::string path;
@@ -211,7 +213,7 @@
      *
      *  @return userList  - list of users in the group.
      */
-    std::vector<std::string> getUsersInGroup(const std::string &groupName);
+    std::vector<std::string> getUsersInGroup(const std::string& groupName);
 
     /** @brief get user & SSH users list
      *  method to get the users and ssh users list.
@@ -226,21 +228,21 @@
      *  @param[in] userName - name of the user
      *  @return -true if user exists and false if not.
      */
-    bool isUserExist(const std::string &userName);
+    bool isUserExist(const std::string& userName);
 
     /** @brief check user exists
      *  method to check whether user exist, and throw if not.
      *
      *  @param[in] userName - name of the user
      */
-    void throwForUserDoesNotExist(const std::string &userName);
+    void throwForUserDoesNotExist(const std::string& userName);
 
     /** @brief check user does not exist
      *  method to check whether does not exist, and throw if exists.
      *
      *  @param[in] userName - name of the user
      */
-    void throwForUserExists(const std::string &userName);
+    void throwForUserExists(const std::string& userName);
 
     /** @brief check user name constraints
      *  method to check user name constraints and throw if failed.
@@ -249,29 +251,29 @@
      *  @param[in] groupNames - user groups
      */
     void
-        throwForUserNameConstraints(const std::string &userName,
-                                    const std::vector<std::string> &groupNames);
+        throwForUserNameConstraints(const std::string& userName,
+                                    const std::vector<std::string>& groupNames);
 
     /** @brief check group user count
      *  method to check max group user count, and throw if limit reached
      *
      *  @param[in] groupNames - group name
      */
-    void throwForMaxGrpUserCount(const std::vector<std::string> &groupNames);
+    void throwForMaxGrpUserCount(const std::vector<std::string>& groupNames);
 
     /** @brief check for valid privielge
      *  method to check valid privilege, and throw if invalid
      *
      *  @param[in] priv - privilege of the user
      */
-    void throwForInvalidPrivilege(const std::string &priv);
+    void throwForInvalidPrivilege(const std::string& priv);
 
     /** @brief check for valid groups
      *  method to check valid groups, and throw if invalid
      *
      *  @param[in] groupNames - user groups
      */
-    void throwForInvalidGroups(const std::vector<std::string> &groupName);
+    void throwForInvalidGroups(const std::vector<std::string>& groupName);
 
     /** @brief get user enabled state
      *  method to get user enabled state.
@@ -279,7 +281,7 @@
      *  @param[in] userName - name of the user
      *  @return - user enabled status (true/false)
      */
-    bool isUserEnabled(const std::string &userName);
+    bool isUserEnabled(const std::string& userName);
 
     /** @brief initialize the user manager objects
      *  method to initialize the user manager objects accordingly
@@ -303,8 +305,8 @@
      *
      *  @return 0 - success state of the function
      */
-    int getPamModuleArgValue(const std::string &moduleName,
-                             const std::string &argName, std::string &argValue);
+    int getPamModuleArgValue(const std::string& moduleName,
+                             const std::string& argName, std::string& argValue);
 
     /** @brief set pam argument value
      *  method to set argument value in pam configuration
@@ -316,9 +318,9 @@
      *
      *  @return 0 - success state of the function
      */
-    int setPamModuleArgValue(const std::string &moduleName,
-                             const std::string &argName,
-                             const std::string &argValue);
+    int setPamModuleArgValue(const std::string& moduleName,
+                             const std::string& argName,
+                             const std::string& argValue);
 
     /** @brief get service name
      *  method to get dbus service name
@@ -327,7 +329,7 @@
      *  @param[in] intf - interface
      *  @return - service name
      */
-    std::string getServiceName(std::string &&path, std::string &&intf);
+    std::string getServiceName(std::string&& path, std::string&& intf);
 
   protected:
     /** @brief get LDAP group name
@@ -336,7 +338,7 @@
      *  @param[in] - userName
      *  @return - group name
      */
-    virtual std::string getLdapGroupName(const std::string &userName);
+    virtual std::string getLdapGroupName(const std::string& userName);
 
     /** @brief get privilege mapper object
      *  method to get dbus privilege mapper object
diff --git a/users.cpp b/users.cpp
index 1dbe85a..18b552a 100644
--- a/users.cpp
+++ b/users.cpp
@@ -14,18 +14,23 @@
 // limitations under the License.
 */
 
-#include <filesystem>
-#include <unistd.h>
+#include "config.h"
+
+#include "users.hpp"
+
+#include "user_mgr.hpp"
+
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <unistd.h>
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/log.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 #include <xyz/openbmc_project/User/Common/error.hpp>
-#include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "user_mgr.hpp"
-#include "users.hpp"
-#include "config.h"
+
+#include <filesystem>
 
 namespace phosphor
 {
@@ -53,9 +58,9 @@
  *  @param[in] enabled - user enabled state
  *  @param[in] parent - user manager - parent object
  */
-Users::Users(sdbusplus::bus::bus &bus, const char *path,
+Users::Users(sdbusplus::bus::bus& bus, const char* path,
              std::vector<std::string> groups, std::string priv, bool enabled,
-             UserMgr &parent) :
+             UserMgr& parent) :
     Interfaces(bus, path, true),
     userName(std::filesystem::path(path).filename()), manager(parent)
 {
diff --git a/users.hpp b/users.hpp
index a13825b..6ff4dfb 100644
--- a/users.hpp
+++ b/users.hpp
@@ -16,8 +16,8 @@
 #pragma once
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
-#include <xyz/openbmc_project/User/Attributes/server.hpp>
 #include <xyz/openbmc_project/Object/Delete/server.hpp>
+#include <xyz/openbmc_project/User/Attributes/server.hpp>
 
 namespace phosphor
 {
@@ -41,10 +41,10 @@
   public:
     Users() = delete;
     ~Users() = default;
-    Users(const Users &) = delete;
-    Users &operator=(const Users &) = delete;
-    Users(Users &&) = delete;
-    Users &operator=(Users &&) = delete;
+    Users(const Users&) = delete;
+    Users& operator=(const Users&) = delete;
+    Users(Users&&) = delete;
+    Users& operator=(Users&&) = delete;
 
     /** @brief Constructs UserMgr object.
      *
@@ -55,9 +55,9 @@
      *  @param[in] enabled - user enabled state
      *  @param[in] parent - user manager - parent object
      */
-    Users(sdbusplus::bus::bus &bus, const char *path,
+    Users(sdbusplus::bus::bus& bus, const char* path,
           std::vector<std::string> groups, std::string priv, bool enabled,
-          UserMgr &parent);
+          UserMgr& parent);
 
     /** @brief delete user method.
      *  This method deletes the user as requested
@@ -117,7 +117,7 @@
 
   private:
     std::string userName;
-    UserMgr &manager;
+    UserMgr& manager;
 };
 
 } // namespace user