diff --git a/.clang-format b/.clang-format
index 27f96ff..ea71ad6 100644
--- a/.clang-format
+++ b/.clang-format
@@ -42,7 +42,7 @@
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
-DerivePointerAlignment: true
+DerivePointerAlignment: false
 PointerAlignment: Left
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
@@ -79,7 +79,6 @@
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Right
 ReflowComments:  true
 SortIncludes:    true
 SortUsingDeclarations: true
diff --git a/sdbusplus/asio/object_server.hpp b/sdbusplus/asio/object_server.hpp
index e4cb6ca..2473e26 100644
--- a/sdbusplus/asio/object_server.hpp
+++ b/sdbusplus/asio/object_server.hpp
@@ -15,18 +15,18 @@
 namespace asio
 {
 
-constexpr const char *PropertyNameAllowedCharacters =
+constexpr const char* PropertyNameAllowedCharacters =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
 class callback
 {
   public:
-    virtual int call(message::message &m) = 0;
+    virtual int call(message::message& m) = 0;
 };
 class callback_set
 {
   public:
-    virtual int call(message::message &m) = 0;
-    virtual int set(const boost::any &value) = 0;
+    virtual int call(message::message& m) = 0;
+    virtual int set(const boost::any& value) = 0;
 };
 
 template <typename T>
@@ -39,10 +39,10 @@
 class callback_method_instance : public callback
 {
   public:
-    callback_method_instance(CallbackType &&func) : func_(std::move(func))
+    callback_method_instance(CallbackType&& func) : func_(std::move(func))
     {
     }
-    int call(message::message &m) override
+    int call(message::message& m) override
     {
         return expandCall<CallbackType>(m);
     }
@@ -55,21 +55,21 @@
     CallbackType func_;
     template <typename T>
     std::enable_if_t<!std::is_void<T>::value, void>
-        callFunction(message::message &m, InputTupleType &inputArgs)
+        callFunction(message::message& m, InputTupleType& inputArgs)
     {
         ResultType r = std::experimental::apply(func_, inputArgs);
         m.append(r);
     }
     template <typename T>
     std::enable_if_t<std::is_void<T>::value, void>
-        callFunction(message::message &m, InputTupleType &inputArgs)
+        callFunction(message::message& m, InputTupleType& inputArgs)
     {
         std::experimental::apply(func_, inputArgs);
     }
     // optional message-first-argument callback
     template <typename T>
     std::enable_if_t<FirstArgIsMessage<T>::value, int>
-        expandCall(message::message &m)
+        expandCall(message::message& m)
     {
         using DbusTupleType =
             typename utility::strip_first_arg<InputTupleType>::type;
@@ -89,7 +89,7 @@
     // normal dbus-types-only callback
     template <typename T>
     std::enable_if_t<!FirstArgIsMessage<T>::value, int>
-        expandCall(message::message &m)
+        expandCall(message::message& m)
     {
         InputTupleType inputArgs;
         if (!utility::read_into_tuple(inputArgs, m))
@@ -108,13 +108,13 @@
 class callback_get_instance : public callback
 {
   public:
-    callback_get_instance(const std::shared_ptr<PropertyType> &value,
-                          CallbackType &&func) :
+    callback_get_instance(const std::shared_ptr<PropertyType>& value,
+                          CallbackType&& func) :
         value_(value),
         func_(std::move(func))
     {
     }
-    int call(message::message &m) override
+    int call(message::message& m) override
     {
         auto r = func_(*value_);
         m.append(r);
@@ -130,20 +130,20 @@
 class callback_set_instance : public callback_set
 {
   public:
-    callback_set_instance(const std::shared_ptr<PropertyType> &value,
-                          CallbackType &&func) :
+    callback_set_instance(const std::shared_ptr<PropertyType>& value,
+                          CallbackType&& func) :
         value_(value),
         func_(std::move(func))
     {
     }
-    int call(message::message &m) override
+    int call(message::message& m) override
     {
         PropertyType input;
         m.read(input);
 
         return func_(input, *value_);
     }
-    int set(const boost::any &value)
+    int set(const boost::any& value)
     {
         return func_(boost::any_cast<PropertyType>(value), *value_);
     }
@@ -162,7 +162,7 @@
 {
   public:
     dbus_interface(std::shared_ptr<sdbusplus::asio::connection> conn,
-                   const std::string &path, const std::string &name) :
+                   const std::string& path, const std::string& name) :
         conn_(conn),
         path_(path), name_(name)
 
@@ -178,7 +178,7 @@
     // default getter and setter
     template <typename PropertyType>
     bool register_property(
-        const std::string &name, const PropertyType &property,
+        const std::string& name, const PropertyType& property,
         PropertyPermission access = PropertyPermission::readOnly)
     {
         // can only register once
@@ -198,12 +198,12 @@
         auto propertyPtr = std::make_shared<PropertyType>(property);
 
         callbacksGet_[name] = std::make_unique<callback_get_instance<
-            PropertyType, std::function<PropertyType(const PropertyType &)>>>(
-            propertyPtr, [](const PropertyType &value) { return value; });
+            PropertyType, std::function<PropertyType(const PropertyType&)>>>(
+            propertyPtr, [](const PropertyType& value) { return value; });
         callbacksSet_[name] = std::make_unique<callback_set_instance<
             PropertyType,
-            std::function<int(const PropertyType &, PropertyType &)>>>(
-            propertyPtr, [](const PropertyType &req, PropertyType &old) {
+            std::function<int(const PropertyType&, PropertyType&)>>>(
+            propertyPtr, [](const PropertyType& req, PropertyType& old) {
                 old = req;
                 return 1;
             });
@@ -225,9 +225,9 @@
 
     // custom setter, sets take an input property and respond with an int status
     template <typename PropertyType, typename CallbackType>
-    bool register_property(const std::string &name,
-                           const PropertyType &property,
-                           CallbackType &&setFunction)
+    bool register_property(const std::string& name,
+                           const PropertyType& property,
+                           CallbackType&& setFunction)
     {
         // can only register once
         if (initialized_)
@@ -246,8 +246,8 @@
         auto propertyPtr = std::make_shared<PropertyType>(property);
 
         callbacksGet_[name] = std::make_unique<callback_get_instance<
-            PropertyType, std::function<PropertyType(const PropertyType &)>>>(
-            propertyPtr, [](const PropertyType &value) { return value; });
+            PropertyType, std::function<PropertyType(const PropertyType&)>>>(
+            propertyPtr, [](const PropertyType& value) { return value; });
 
         callbacksSet_[name] =
             std::make_unique<callback_set_instance<PropertyType, CallbackType>>(
@@ -263,10 +263,10 @@
     // property. property is only passed for type deduction
     template <typename PropertyType, typename CallbackType,
               typename CallbackTypeGet>
-    bool register_property(const std::string &name,
-                           const PropertyType &property,
-                           CallbackType &&setFunction,
-                           CallbackTypeGet &&getFunction)
+    bool register_property(const std::string& name,
+                           const PropertyType& property,
+                           CallbackType&& setFunction,
+                           CallbackTypeGet&& getFunction)
     {
         // can only register once
         if (initialized_)
@@ -298,7 +298,7 @@
         return true;
     }
     template <typename PropertyType>
-    bool set_property(const std::string &name, const PropertyType &value)
+    bool set_property(const std::string& name, const PropertyType& value)
     {
         if (!initialized_)
         {
@@ -319,7 +319,7 @@
 
     template <typename CallbackType>
     std::enable_if_t<FirstArgIsMessage<CallbackType>::value, bool>
-        register_method(const std::string &name, CallbackType &&handler)
+        register_method(const std::string& name, CallbackType&& handler)
     {
         using CallbackSignature = typename utility::strip_first_arg<
             boost::callable_traits::args_t<CallbackType>>::type;
@@ -349,7 +349,7 @@
 
     template <typename CallbackType>
     std::enable_if_t<!FirstArgIsMessage<CallbackType>::value, bool>
-        register_method(const std::string &name, CallbackType &&handler)
+        register_method(const std::string& name, CallbackType&& handler)
     {
         using CallbackSignature = boost::callable_traits::args_t<CallbackType>;
         using InputTupleType =
@@ -376,11 +376,11 @@
         return true;
     }
 
-    static int get_handler(sd_bus *bus, const char *path, const char *interface,
-                           const char *property, sd_bus_message *reply,
-                           void *userdata, sd_bus_error *error)
+    static int get_handler(sd_bus* bus, const char* path, const char* interface,
+                           const char* property, sd_bus_message* reply,
+                           void* userdata, sd_bus_error* error)
     {
-        dbus_interface *data = static_cast<dbus_interface *>(userdata);
+        dbus_interface* data = static_cast<dbus_interface*>(userdata);
         auto func = data->callbacksGet_.find(property);
         auto mesg = message::message(reply);
         if (func != data->callbacksGet_.end())
@@ -393,7 +393,7 @@
 #ifdef __EXCEPTIONS
             }
 
-            catch (sdbusplus::exception_t &e)
+            catch (sdbusplus::exception_t& e)
             {
                 sd_bus_error_set_const(error, e.name(), e.description());
                 return -EINVAL;
@@ -408,11 +408,11 @@
         return -EINVAL;
     }
 
-    static int set_handler(sd_bus *bus, const char *path, const char *interface,
-                           const char *property, sd_bus_message *value,
-                           void *userdata, sd_bus_error *error)
+    static int set_handler(sd_bus* bus, const char* path, const char* interface,
+                           const char* property, sd_bus_message* value,
+                           void* userdata, sd_bus_error* error)
     {
-        dbus_interface *data = static_cast<dbus_interface *>(userdata);
+        dbus_interface* data = static_cast<dbus_interface*>(userdata);
         auto func = data->callbacksSet_.find(property);
         auto mesg = message::message(value);
         if (func != data->callbacksSet_.end())
@@ -430,7 +430,7 @@
 #ifdef __EXCEPTIONS
             }
 
-            catch (sdbusplus::exception_t &e)
+            catch (sdbusplus::exception_t& e)
             {
                 sd_bus_error_set_const(error, e.name(), e.description());
                 return -EINVAL;
@@ -445,10 +445,10 @@
         return -EINVAL;
     }
 
-    static int method_handler(sd_bus_message *m, void *userdata,
-                              sd_bus_error *error)
+    static int method_handler(sd_bus_message* m, void* userdata,
+                              sd_bus_error* error)
     {
-        dbus_interface *data = static_cast<dbus_interface *>(userdata);
+        dbus_interface* data = static_cast<dbus_interface*>(userdata);
         auto mesg = message::message(m);
         auto func = data->callbacksMethod_.find(mesg.get_member());
         if (func != data->callbacksMethod_.end())
@@ -465,7 +465,7 @@
 #ifdef __EXCEPTIONS
             }
 
-            catch (sdbusplus::exception_t &e)
+            catch (sdbusplus::exception_t& e)
             {
                 sd_bus_error_set_const(error, e.name(), e.description());
                 return -EINVAL;
@@ -491,18 +491,18 @@
         vtable_.emplace_back(vtable::end());
 
         interface_ = std::make_unique<sdbusplus::server::interface::interface>(
-            static_cast<sdbusplus::bus::bus &>(*conn_), path_.c_str(),
-            name_.c_str(), static_cast<const sd_bus_vtable *>(&vtable_[0]),
+            static_cast<sdbusplus::bus::bus&>(*conn_), path_.c_str(),
+            name_.c_str(), static_cast<const sd_bus_vtable*>(&vtable_[0]),
             this);
         conn_->emit_interfaces_added(path_.c_str(),
                                      std::vector<std::string>{name_});
-        for (const std::string &name : propertyNames_)
+        for (const std::string& name : propertyNames_)
         {
             signal_property(name);
         }
         return true;
     }
-    void signal_property(const std::string &name)
+    void signal_property(const std::string& name)
     {
         interface_->property_changed(name.c_str());
     }
@@ -538,7 +538,7 @@
 class object_server
 {
   public:
-    object_server(std::shared_ptr<sdbusplus::asio::connection> &conn) :
+    object_server(std::shared_ptr<sdbusplus::asio::connection>& conn) :
         conn_(conn)
     {
         auto root = add_interface("/", "");
@@ -546,8 +546,8 @@
         add_manager("/");
     }
 
-    std::shared_ptr<dbus_interface> add_interface(const std::string &path,
-                                                  const std::string &name)
+    std::shared_ptr<dbus_interface> add_interface(const std::string& path,
+                                                  const std::string& name)
     {
 
         auto dbusIface = std::make_shared<dbus_interface>(conn_, path, name);
@@ -555,14 +555,14 @@
         return dbusIface;
     }
 
-    void add_manager(const std::string &path)
+    void add_manager(const std::string& path)
     {
         managers_.emplace_back(
             std::make_unique<server::manager::manager>(server::manager::manager(
-                static_cast<sdbusplus::bus::bus &>(*conn_), path.c_str())));
+                static_cast<sdbusplus::bus::bus&>(*conn_), path.c_str())));
     }
 
-    bool remove_interface(std::shared_ptr<dbus_interface> &iface)
+    bool remove_interface(std::shared_ptr<dbus_interface>& iface)
     {
         auto findIface =
             std::find(interfaces_.begin(), interfaces_.end(), iface);
diff --git a/sdbusplus/sdbus.hpp b/sdbusplus/sdbus.hpp
index 4477d6e..74fe86d 100644
--- a/sdbusplus/sdbus.hpp
+++ b/sdbusplus/sdbus.hpp
@@ -13,123 +13,123 @@
   public:
     virtual ~SdBusInterface() = default;
 
-    virtual int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot,
-                                          const char *path) = 0;
+    virtual int sd_bus_add_object_manager(sd_bus* bus, sd_bus_slot** slot,
+                                          const char* path) = 0;
 
-    virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot,
-                                         const char *path,
-                                         const char *interface,
-                                         const sd_bus_vtable *vtable,
-                                         void *userdata) = 0;
+    virtual int sd_bus_add_object_vtable(sd_bus* bus, sd_bus_slot** slot,
+                                         const char* path,
+                                         const char* interface,
+                                         const sd_bus_vtable* vtable,
+                                         void* userdata) = 0;
 
-    virtual int sd_bus_attach_event(sd_bus *bus, sd_event *e, int priority) = 0;
+    virtual int sd_bus_attach_event(sd_bus* bus, sd_event* e, int priority) = 0;
 
-    virtual int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec,
-                            sd_bus_error *ret_error,
-                            sd_bus_message **reply) = 0;
+    virtual int sd_bus_call(sd_bus* bus, sd_bus_message* m, uint64_t usec,
+                            sd_bus_error* ret_error,
+                            sd_bus_message** reply) = 0;
 
-    virtual int sd_bus_detach_event(sd_bus *bus) = 0;
+    virtual int sd_bus_detach_event(sd_bus* bus) = 0;
 
-    virtual int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path,
-                                                  char **interfaces) = 0;
-    virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus,
-                                                    const char *path,
-                                                    char **interfaces) = 0;
-    virtual int sd_bus_emit_object_added(sd_bus *bus, const char *path) = 0;
-    virtual int sd_bus_emit_object_removed(sd_bus *bus, const char *path) = 0;
-    virtual int sd_bus_emit_properties_changed_strv(sd_bus *bus,
-                                                    const char *path,
-                                                    const char *interface,
-                                                    char **names) = 0;
+    virtual int sd_bus_emit_interfaces_added_strv(sd_bus* bus, const char* path,
+                                                  char** interfaces) = 0;
+    virtual int sd_bus_emit_interfaces_removed_strv(sd_bus* bus,
+                                                    const char* path,
+                                                    char** interfaces) = 0;
+    virtual int sd_bus_emit_object_added(sd_bus* bus, const char* path) = 0;
+    virtual int sd_bus_emit_object_removed(sd_bus* bus, const char* path) = 0;
+    virtual int sd_bus_emit_properties_changed_strv(sd_bus* bus,
+                                                    const char* path,
+                                                    const char* interface,
+                                                    char** names) = 0;
 
-    virtual int sd_bus_error_set_const(sd_bus_error *e, const char *name,
-                                       const char *message) = 0;
-    virtual int sd_bus_error_get_errno(const sd_bus_error *e) = 0;
-    virtual int sd_bus_error_set_errno(sd_bus_error *e, int error) = 0;
-    virtual int sd_bus_error_is_set(const sd_bus_error *e) = 0;
-    virtual void sd_bus_error_free(sd_bus_error *e) = 0;
+    virtual int sd_bus_error_set_const(sd_bus_error* e, const char* name,
+                                       const char* message) = 0;
+    virtual int sd_bus_error_get_errno(const sd_bus_error* e) = 0;
+    virtual int sd_bus_error_set_errno(sd_bus_error* e, int error) = 0;
+    virtual int sd_bus_error_is_set(const sd_bus_error* e) = 0;
+    virtual void sd_bus_error_free(sd_bus_error* e) = 0;
 
-    virtual sd_event *sd_bus_get_event(sd_bus *bus) = 0;
-    virtual int sd_bus_get_fd(sd_bus *bus) = 0;
-    virtual int sd_bus_get_unique_name(sd_bus *bus, const char **unique) = 0;
+    virtual sd_event* sd_bus_get_event(sd_bus* bus) = 0;
+    virtual int sd_bus_get_fd(sd_bus* bus) = 0;
+    virtual int sd_bus_get_unique_name(sd_bus* bus, const char** unique) = 0;
 
-    virtual int sd_bus_list_names(sd_bus *bus, char ***acquired,
-                                  char ***activatable) = 0;
+    virtual int sd_bus_list_names(sd_bus* bus, char*** acquired,
+                                  char*** activatable) = 0;
 
     // https://github.com/systemd/systemd/blob/master/src/systemd/sd-bus.h
-    virtual int sd_bus_message_append_basic(sd_bus_message *message, char type,
-                                            const void *value) = 0;
+    virtual int sd_bus_message_append_basic(sd_bus_message* message, char type,
+                                            const void* value) = 0;
 
-    virtual int sd_bus_message_at_end(sd_bus_message *m, int complete) = 0;
+    virtual int sd_bus_message_at_end(sd_bus_message* m, int complete) = 0;
 
-    virtual int sd_bus_message_close_container(sd_bus_message *m) = 0;
+    virtual int sd_bus_message_close_container(sd_bus_message* m) = 0;
 
-    virtual int sd_bus_message_enter_container(sd_bus_message *m, char type,
-                                               const char *contents) = 0;
+    virtual int sd_bus_message_enter_container(sd_bus_message* m, char type,
+                                               const char* contents) = 0;
 
-    virtual int sd_bus_message_exit_container(sd_bus_message *m) = 0;
+    virtual int sd_bus_message_exit_container(sd_bus_message* m) = 0;
 
-    virtual sd_bus *sd_bus_message_get_bus(sd_bus_message *m) = 0;
-    virtual int sd_bus_message_get_cookie(sd_bus_message *m,
-                                          uint64_t *cookie) = 0;
-    virtual const char *sd_bus_message_get_destination(sd_bus_message *m) = 0;
-    virtual const char *sd_bus_message_get_interface(sd_bus_message *m) = 0;
-    virtual const char *sd_bus_message_get_member(sd_bus_message *m) = 0;
-    virtual const char *sd_bus_message_get_path(sd_bus_message *m) = 0;
-    virtual const char *sd_bus_message_get_sender(sd_bus_message *m) = 0;
-    virtual const char *sd_bus_message_get_signature(sd_bus_message *m,
+    virtual sd_bus* sd_bus_message_get_bus(sd_bus_message* m) = 0;
+    virtual int sd_bus_message_get_cookie(sd_bus_message* m,
+                                          uint64_t* cookie) = 0;
+    virtual const char* sd_bus_message_get_destination(sd_bus_message* m) = 0;
+    virtual const char* sd_bus_message_get_interface(sd_bus_message* m) = 0;
+    virtual const char* sd_bus_message_get_member(sd_bus_message* m) = 0;
+    virtual const char* sd_bus_message_get_path(sd_bus_message* m) = 0;
+    virtual const char* sd_bus_message_get_sender(sd_bus_message* m) = 0;
+    virtual const char* sd_bus_message_get_signature(sd_bus_message* m,
                                                      int complete) = 0;
-    virtual int sd_bus_message_get_errno(sd_bus_message *m) = 0;
+    virtual int sd_bus_message_get_errno(sd_bus_message* m) = 0;
 
-    virtual int sd_bus_message_is_method_call(sd_bus_message *m,
-                                              const char *interface,
-                                              const char *member) = 0;
-    virtual int sd_bus_message_is_method_error(sd_bus_message *m,
-                                               const char *name) = 0;
-    virtual int sd_bus_message_is_signal(sd_bus_message *m,
-                                         const char *interface,
-                                         const char *member) = 0;
+    virtual int sd_bus_message_is_method_call(sd_bus_message* m,
+                                              const char* interface,
+                                              const char* member) = 0;
+    virtual int sd_bus_message_is_method_error(sd_bus_message* m,
+                                               const char* name) = 0;
+    virtual int sd_bus_message_is_signal(sd_bus_message* m,
+                                         const char* interface,
+                                         const char* member) = 0;
 
-    virtual int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m,
-                                               const char *destination,
-                                               const char *path,
-                                               const char *interface,
-                                               const char *member) = 0;
+    virtual int sd_bus_message_new_method_call(sd_bus* bus, sd_bus_message** m,
+                                               const char* destination,
+                                               const char* path,
+                                               const char* interface,
+                                               const char* member) = 0;
 
-    virtual int sd_bus_message_new_method_return(sd_bus_message *call,
-                                                 sd_bus_message **m) = 0;
+    virtual int sd_bus_message_new_method_return(sd_bus_message* call,
+                                                 sd_bus_message** m) = 0;
 
-    virtual int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m,
-                                          const char *path,
-                                          const char *interface,
-                                          const char *member) = 0;
+    virtual int sd_bus_message_new_signal(sd_bus* bus, sd_bus_message** m,
+                                          const char* path,
+                                          const char* interface,
+                                          const char* member) = 0;
 
-    virtual int sd_bus_message_open_container(sd_bus_message *m, char type,
-                                              const char *contents) = 0;
+    virtual int sd_bus_message_open_container(sd_bus_message* m, char type,
+                                              const char* contents) = 0;
 
-    virtual int sd_bus_message_read_basic(sd_bus_message *m, char type,
-                                          void *p) = 0;
+    virtual int sd_bus_message_read_basic(sd_bus_message* m, char type,
+                                          void* p) = 0;
 
-    virtual sd_bus_message *sd_bus_message_ref(sd_bus_message *m) = 0;
+    virtual sd_bus_message* sd_bus_message_ref(sd_bus_message* m) = 0;
 
-    virtual int sd_bus_message_skip(sd_bus_message *m, const char *types) = 0;
+    virtual int sd_bus_message_skip(sd_bus_message* m, const char* types) = 0;
 
-    virtual int sd_bus_message_verify_type(sd_bus_message *m, char type,
-                                           const char *contents) = 0;
+    virtual int sd_bus_message_verify_type(sd_bus_message* m, char type,
+                                           const char* contents) = 0;
 
-    virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
+    virtual int sd_bus_process(sd_bus* bus, sd_bus_message** r) = 0;
 
-    virtual sd_bus *sd_bus_ref(sd_bus *bus) = 0;
+    virtual sd_bus* sd_bus_ref(sd_bus* bus) = 0;
 
-    virtual int sd_bus_request_name(sd_bus *bus, const char *name,
+    virtual int sd_bus_request_name(sd_bus* bus, const char* name,
                                     uint64_t flags) = 0;
 
-    virtual int sd_bus_send(sd_bus *bus, sd_bus_message *m,
-                            uint64_t *cookie) = 0;
+    virtual int sd_bus_send(sd_bus* bus, sd_bus_message* m,
+                            uint64_t* cookie) = 0;
 
-    virtual sd_bus *sd_bus_unref(sd_bus *bus) = 0;
+    virtual sd_bus* sd_bus_unref(sd_bus* bus) = 0;
 
-    virtual int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) = 0;
+    virtual int sd_bus_wait(sd_bus* bus, uint64_t timeout_usec) = 0;
 };
 
 class SdBusImpl : public SdBusInterface
@@ -137,287 +137,287 @@
   public:
     SdBusImpl() = default;
     ~SdBusImpl() = default;
-    SdBusImpl(const SdBusImpl &) = default;
-    SdBusImpl &operator=(const SdBusImpl &) = default;
-    SdBusImpl(SdBusImpl &&) = default;
-    SdBusImpl &operator=(SdBusImpl &&) = default;
+    SdBusImpl(const SdBusImpl&) = default;
+    SdBusImpl& operator=(const SdBusImpl&) = default;
+    SdBusImpl(SdBusImpl&&) = default;
+    SdBusImpl& operator=(SdBusImpl&&) = default;
 
-    int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot,
-                                  const char *path) override
+    int sd_bus_add_object_manager(sd_bus* bus, sd_bus_slot** slot,
+                                  const char* path) override
     {
         return ::sd_bus_add_object_manager(bus, slot, path);
     }
 
-    int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot,
-                                 const char *path, const char *interface,
-                                 const sd_bus_vtable *vtable,
-                                 void *userdata) override
+    int sd_bus_add_object_vtable(sd_bus* bus, sd_bus_slot** slot,
+                                 const char* path, const char* interface,
+                                 const sd_bus_vtable* vtable,
+                                 void* userdata) override
     {
         return ::sd_bus_add_object_vtable(bus, slot, path, interface, vtable,
                                           userdata);
     }
 
-    int sd_bus_attach_event(sd_bus *bus, sd_event *e, int priority) override
+    int sd_bus_attach_event(sd_bus* bus, sd_event* e, int priority) override
     {
         return ::sd_bus_attach_event(bus, e, priority);
     }
 
-    int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec,
-                    sd_bus_error *ret_error, sd_bus_message **reply) override
+    int sd_bus_call(sd_bus* bus, sd_bus_message* m, uint64_t usec,
+                    sd_bus_error* ret_error, sd_bus_message** reply) override
     {
         return ::sd_bus_call(bus, m, usec, ret_error, reply);
     }
 
-    int sd_bus_detach_event(sd_bus *bus) override
+    int sd_bus_detach_event(sd_bus* bus) override
     {
         return ::sd_bus_detach_event(bus);
     }
 
-    int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path,
-                                          char **interfaces) override
+    int sd_bus_emit_interfaces_added_strv(sd_bus* bus, const char* path,
+                                          char** interfaces) override
     {
         return ::sd_bus_emit_interfaces_added_strv(bus, path, interfaces);
     }
 
-    int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path,
-                                            char **interfaces) override
+    int sd_bus_emit_interfaces_removed_strv(sd_bus* bus, const char* path,
+                                            char** interfaces) override
     {
         return ::sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
     }
 
-    int sd_bus_emit_object_added(sd_bus *bus, const char *path) override
+    int sd_bus_emit_object_added(sd_bus* bus, const char* path) override
     {
         return ::sd_bus_emit_object_added(bus, path);
     }
 
-    int sd_bus_emit_object_removed(sd_bus *bus, const char *path) override
+    int sd_bus_emit_object_removed(sd_bus* bus, const char* path) override
     {
         return ::sd_bus_emit_object_removed(bus, path);
     }
 
-    int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path,
-                                            const char *interface,
-                                            char **names) override
+    int sd_bus_emit_properties_changed_strv(sd_bus* bus, const char* path,
+                                            const char* interface,
+                                            char** names) override
     {
         return ::sd_bus_emit_properties_changed_strv(bus, path, interface,
                                                      names);
     }
 
-    int sd_bus_error_set_const(sd_bus_error *e, const char *name,
-                               const char *message) override
+    int sd_bus_error_set_const(sd_bus_error* e, const char* name,
+                               const char* message) override
     {
         return ::sd_bus_error_set_const(e, name, message);
     }
 
-    int sd_bus_error_get_errno(const sd_bus_error *e) override
+    int sd_bus_error_get_errno(const sd_bus_error* e) override
     {
         return ::sd_bus_error_get_errno(e);
     }
 
-    int sd_bus_error_set_errno(sd_bus_error *e, int error) override
+    int sd_bus_error_set_errno(sd_bus_error* e, int error) override
     {
         return ::sd_bus_error_set_errno(e, error);
     }
 
-    int sd_bus_error_is_set(const sd_bus_error *e) override
+    int sd_bus_error_is_set(const sd_bus_error* e) override
     {
         return ::sd_bus_error_is_set(e);
     }
 
-    void sd_bus_error_free(sd_bus_error *e) override
+    void sd_bus_error_free(sd_bus_error* e) override
     {
         return ::sd_bus_error_free(e);
     }
 
-    sd_event *sd_bus_get_event(sd_bus *bus) override
+    sd_event* sd_bus_get_event(sd_bus* bus) override
     {
         return ::sd_bus_get_event(bus);
     }
 
-    int sd_bus_get_fd(sd_bus *bus) override
+    int sd_bus_get_fd(sd_bus* bus) override
     {
         return ::sd_bus_get_fd(bus);
     }
 
-    int sd_bus_get_unique_name(sd_bus *bus, const char **unique) override
+    int sd_bus_get_unique_name(sd_bus* bus, const char** unique) override
     {
         return ::sd_bus_get_unique_name(bus, unique);
     }
 
-    int sd_bus_list_names(sd_bus *bus, char ***acquired,
-                          char ***activatable) override
+    int sd_bus_list_names(sd_bus* bus, char*** acquired,
+                          char*** activatable) override
     {
         return ::sd_bus_list_names(bus, acquired, activatable);
     }
 
-    int sd_bus_message_append_basic(sd_bus_message *message, char type,
-                                    const void *value) override
+    int sd_bus_message_append_basic(sd_bus_message* message, char type,
+                                    const void* value) override
     {
         return ::sd_bus_message_append_basic(message, type, value);
     }
 
-    int sd_bus_message_at_end(sd_bus_message *m, int complete) override
+    int sd_bus_message_at_end(sd_bus_message* m, int complete) override
     {
         return ::sd_bus_message_at_end(m, complete);
     }
 
-    int sd_bus_message_close_container(sd_bus_message *m) override
+    int sd_bus_message_close_container(sd_bus_message* m) override
     {
         return ::sd_bus_message_close_container(m);
     }
 
-    int sd_bus_message_enter_container(sd_bus_message *m, char type,
-                                       const char *contents) override
+    int sd_bus_message_enter_container(sd_bus_message* m, char type,
+                                       const char* contents) override
     {
         return ::sd_bus_message_enter_container(m, type, contents);
     }
 
-    int sd_bus_message_exit_container(sd_bus_message *m) override
+    int sd_bus_message_exit_container(sd_bus_message* m) override
     {
         return ::sd_bus_message_exit_container(m);
     }
 
-    sd_bus *sd_bus_message_get_bus(sd_bus_message *m) override
+    sd_bus* sd_bus_message_get_bus(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_bus(m);
     }
 
-    int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie) override
+    int sd_bus_message_get_cookie(sd_bus_message* m, uint64_t* cookie) override
     {
         return ::sd_bus_message_get_cookie(m, cookie);
     }
 
-    const char *sd_bus_message_get_destination(sd_bus_message *m) override
+    const char* sd_bus_message_get_destination(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_destination(m);
     }
 
-    const char *sd_bus_message_get_interface(sd_bus_message *m) override
+    const char* sd_bus_message_get_interface(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_interface(m);
     }
 
-    const char *sd_bus_message_get_member(sd_bus_message *m) override
+    const char* sd_bus_message_get_member(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_member(m);
     }
 
-    const char *sd_bus_message_get_path(sd_bus_message *m) override
+    const char* sd_bus_message_get_path(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_path(m);
     }
 
-    const char *sd_bus_message_get_sender(sd_bus_message *m) override
+    const char* sd_bus_message_get_sender(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_sender(m);
     }
 
-    const char *sd_bus_message_get_signature(sd_bus_message *m,
+    const char* sd_bus_message_get_signature(sd_bus_message* m,
                                              int complete) override
     {
         return ::sd_bus_message_get_signature(m, complete);
     }
 
-    int sd_bus_message_get_errno(sd_bus_message *m) override
+    int sd_bus_message_get_errno(sd_bus_message* m) override
     {
         return ::sd_bus_message_get_errno(m);
     }
 
-    int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface,
-                                      const char *member) override
+    int sd_bus_message_is_method_call(sd_bus_message* m, const char* interface,
+                                      const char* member) override
     {
         return ::sd_bus_message_is_method_call(m, interface, member);
     }
 
-    int sd_bus_message_is_method_error(sd_bus_message *m,
-                                       const char *name) override
+    int sd_bus_message_is_method_error(sd_bus_message* m,
+                                       const char* name) override
     {
         return ::sd_bus_message_is_method_error(m, name);
     }
 
-    int sd_bus_message_is_signal(sd_bus_message *m, const char *interface,
-                                 const char *member) override
+    int sd_bus_message_is_signal(sd_bus_message* m, const char* interface,
+                                 const char* member) override
     {
         return ::sd_bus_message_is_signal(m, interface, member);
     }
 
-    int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m,
-                                       const char *destination,
-                                       const char *path, const char *interface,
-                                       const char *member) override
+    int sd_bus_message_new_method_call(sd_bus* bus, sd_bus_message** m,
+                                       const char* destination,
+                                       const char* path, const char* interface,
+                                       const char* member) override
     {
         return ::sd_bus_message_new_method_call(bus, m, destination, path,
                                                 interface, member);
     }
 
-    int sd_bus_message_new_method_return(sd_bus_message *call,
-                                         sd_bus_message **m) override
+    int sd_bus_message_new_method_return(sd_bus_message* call,
+                                         sd_bus_message** m) override
     {
         return ::sd_bus_message_new_method_return(call, m);
     }
 
-    int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m,
-                                  const char *path, const char *interface,
-                                  const char *member) override
+    int sd_bus_message_new_signal(sd_bus* bus, sd_bus_message** m,
+                                  const char* path, const char* interface,
+                                  const char* member) override
     {
         return ::sd_bus_message_new_signal(bus, m, path, interface, member);
     }
 
-    int sd_bus_message_open_container(sd_bus_message *m, char type,
-                                      const char *contents) override
+    int sd_bus_message_open_container(sd_bus_message* m, char type,
+                                      const char* contents) override
     {
         return ::sd_bus_message_open_container(m, type, contents);
     }
 
-    int sd_bus_message_read_basic(sd_bus_message *m, char type,
-                                  void *p) override
+    int sd_bus_message_read_basic(sd_bus_message* m, char type,
+                                  void* p) override
     {
         return ::sd_bus_message_read_basic(m, type, p);
     }
 
-    sd_bus_message *sd_bus_message_ref(sd_bus_message *m) override
+    sd_bus_message* sd_bus_message_ref(sd_bus_message* m) override
     {
         return ::sd_bus_message_ref(m);
     }
 
-    int sd_bus_message_skip(sd_bus_message *m, const char *types) override
+    int sd_bus_message_skip(sd_bus_message* m, const char* types) override
     {
         return ::sd_bus_message_skip(m, types);
     }
 
-    int sd_bus_message_verify_type(sd_bus_message *m, char type,
-                                   const char *contents) override
+    int sd_bus_message_verify_type(sd_bus_message* m, char type,
+                                   const char* contents) override
     {
         return ::sd_bus_message_verify_type(m, type, contents);
     }
 
-    int sd_bus_process(sd_bus *bus, sd_bus_message **r) override
+    int sd_bus_process(sd_bus* bus, sd_bus_message** r) override
     {
         return ::sd_bus_process(bus, r);
     }
 
-    sd_bus *sd_bus_ref(sd_bus *bus) override
+    sd_bus* sd_bus_ref(sd_bus* bus) override
     {
         return ::sd_bus_ref(bus);
     }
 
-    int sd_bus_request_name(sd_bus *bus, const char *name,
+    int sd_bus_request_name(sd_bus* bus, const char* name,
                             uint64_t flags) override
     {
         return ::sd_bus_request_name(bus, name, flags);
     }
 
-    int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) override
+    int sd_bus_send(sd_bus* bus, sd_bus_message* m, uint64_t* cookie) override
     {
         return ::sd_bus_send(bus, m, cookie);
     }
 
-    sd_bus *sd_bus_unref(sd_bus *bus) override
+    sd_bus* sd_bus_unref(sd_bus* bus) override
     {
         return ::sd_bus_unref(bus);
     }
 
-    int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) override
+    int sd_bus_wait(sd_bus* bus, uint64_t timeout_usec) override
     {
         return ::sd_bus_wait(bus, timeout_usec);
     }
diff --git a/sdbusplus/test/sdbus_mock.hpp b/sdbusplus/test/sdbus_mock.hpp
index 4f1bfb3..ea96c0f 100644
--- a/sdbusplus/test/sdbus_mock.hpp
+++ b/sdbusplus/test/sdbus_mock.hpp
@@ -14,95 +14,93 @@
     virtual ~SdBusMock(){};
 
     MOCK_METHOD3(sd_bus_add_object_manager,
-                 int(sd_bus *, sd_bus_slot **, const char *));
+                 int(sd_bus*, sd_bus_slot**, const char*));
     MOCK_METHOD6(sd_bus_add_object_vtable,
-                 int(sd_bus *, sd_bus_slot **, const char *, const char *,
-                     const sd_bus_vtable *, void *));
-    MOCK_METHOD3(sd_bus_attach_event, int(sd_bus *, sd_event *, int));
-    MOCK_METHOD5(sd_bus_call, int(sd_bus *, sd_bus_message *, uint64_t,
-                                  sd_bus_error *, sd_bus_message **));
-    MOCK_METHOD1(sd_bus_detach_event, int(sd_bus *));
+                 int(sd_bus*, sd_bus_slot**, const char*, const char*,
+                     const sd_bus_vtable*, void*));
+    MOCK_METHOD3(sd_bus_attach_event, int(sd_bus*, sd_event*, int));
+    MOCK_METHOD5(sd_bus_call, int(sd_bus*, sd_bus_message*, uint64_t,
+                                  sd_bus_error*, sd_bus_message**));
+    MOCK_METHOD1(sd_bus_detach_event, int(sd_bus*));
 
     MOCK_METHOD3(sd_bus_emit_interfaces_added_strv,
-                 int(sd_bus *, const char *, char **));
+                 int(sd_bus*, const char*, char**));
     MOCK_METHOD3(sd_bus_emit_interfaces_removed_strv,
-                 int(sd_bus *, const char *, char **));
-    MOCK_METHOD2(sd_bus_emit_object_added, int(sd_bus *, const char *));
-    MOCK_METHOD2(sd_bus_emit_object_removed, int(sd_bus *, const char *));
+                 int(sd_bus*, const char*, char**));
+    MOCK_METHOD2(sd_bus_emit_object_added, int(sd_bus*, const char*));
+    MOCK_METHOD2(sd_bus_emit_object_removed, int(sd_bus*, const char*));
     MOCK_METHOD4(sd_bus_emit_properties_changed_strv,
-                 int(sd_bus *, const char *, const char *, char **));
+                 int(sd_bus*, const char*, const char*, char**));
 
     MOCK_METHOD3(sd_bus_error_set_const,
-                 int(sd_bus_error *, const char *, const char *));
-    MOCK_METHOD1(sd_bus_error_get_errno, int(const sd_bus_error *));
-    MOCK_METHOD2(sd_bus_error_set_errno, int(sd_bus_error *, int));
-    MOCK_METHOD1(sd_bus_error_is_set, int(const sd_bus_error *));
-    MOCK_METHOD1(sd_bus_error_free, void(sd_bus_error *));
+                 int(sd_bus_error*, const char*, const char*));
+    MOCK_METHOD1(sd_bus_error_get_errno, int(const sd_bus_error*));
+    MOCK_METHOD2(sd_bus_error_set_errno, int(sd_bus_error*, int));
+    MOCK_METHOD1(sd_bus_error_is_set, int(const sd_bus_error*));
+    MOCK_METHOD1(sd_bus_error_free, void(sd_bus_error*));
 
-    MOCK_METHOD1(sd_bus_get_event, sd_event *(sd_bus *));
-    MOCK_METHOD1(sd_bus_get_fd, int(sd_bus *));
-    MOCK_METHOD2(sd_bus_get_unique_name, int(sd_bus *, const char **));
+    MOCK_METHOD1(sd_bus_get_event, sd_event*(sd_bus*));
+    MOCK_METHOD1(sd_bus_get_fd, int(sd_bus*));
+    MOCK_METHOD2(sd_bus_get_unique_name, int(sd_bus*, const char**));
 
-    MOCK_METHOD3(sd_bus_list_names, int(sd_bus *, char ***, char ***));
+    MOCK_METHOD3(sd_bus_list_names, int(sd_bus*, char***, char***));
 
     MOCK_METHOD3(sd_bus_message_append_basic,
-                 int(sd_bus_message *, char, const void *));
-    MOCK_METHOD2(sd_bus_message_at_end, int(sd_bus_message *, int));
-    MOCK_METHOD1(sd_bus_message_close_container, int(sd_bus_message *));
+                 int(sd_bus_message*, char, const void*));
+    MOCK_METHOD2(sd_bus_message_at_end, int(sd_bus_message*, int));
+    MOCK_METHOD1(sd_bus_message_close_container, int(sd_bus_message*));
     MOCK_METHOD3(sd_bus_message_enter_container,
-                 int(sd_bus_message *, char, const char *));
-    MOCK_METHOD1(sd_bus_message_exit_container, int(sd_bus_message *));
+                 int(sd_bus_message*, char, const char*));
+    MOCK_METHOD1(sd_bus_message_exit_container, int(sd_bus_message*));
 
-    MOCK_METHOD1(sd_bus_message_get_bus, sd_bus *(sd_bus_message *));
-    MOCK_METHOD2(sd_bus_message_get_cookie, int(sd_bus_message *, uint64_t *));
-    MOCK_METHOD1(sd_bus_message_get_destination,
-                 const char *(sd_bus_message *));
-    MOCK_METHOD1(sd_bus_message_get_interface, const char *(sd_bus_message *));
-    MOCK_METHOD1(sd_bus_message_get_member, const char *(sd_bus_message *));
-    MOCK_METHOD1(sd_bus_message_get_path, const char *(sd_bus_message *));
-    MOCK_METHOD1(sd_bus_message_get_sender, const char *(sd_bus_message *));
+    MOCK_METHOD1(sd_bus_message_get_bus, sd_bus*(sd_bus_message*));
+    MOCK_METHOD2(sd_bus_message_get_cookie, int(sd_bus_message*, uint64_t*));
+    MOCK_METHOD1(sd_bus_message_get_destination, const char*(sd_bus_message*));
+    MOCK_METHOD1(sd_bus_message_get_interface, const char*(sd_bus_message*));
+    MOCK_METHOD1(sd_bus_message_get_member, const char*(sd_bus_message*));
+    MOCK_METHOD1(sd_bus_message_get_path, const char*(sd_bus_message*));
+    MOCK_METHOD1(sd_bus_message_get_sender, const char*(sd_bus_message*));
     MOCK_METHOD2(sd_bus_message_get_signature,
-                 const char *(sd_bus_message *, int));
-    MOCK_METHOD1(sd_bus_message_get_errno, int(sd_bus_message *));
+                 const char*(sd_bus_message*, int));
+    MOCK_METHOD1(sd_bus_message_get_errno, int(sd_bus_message*));
 
     MOCK_METHOD3(sd_bus_message_is_method_call,
-                 int(sd_bus_message *, const char *, const char *));
+                 int(sd_bus_message*, const char*, const char*));
     MOCK_METHOD2(sd_bus_message_is_method_error,
-                 int(sd_bus_message *, const char *));
+                 int(sd_bus_message*, const char*));
     MOCK_METHOD3(sd_bus_message_is_signal,
-                 int(sd_bus_message *, const char *, const char *));
+                 int(sd_bus_message*, const char*, const char*));
 
     MOCK_METHOD6(sd_bus_message_new_method_call,
-                 int(sd_bus *, sd_bus_message **, const char *, const char *,
-                     const char *, const char *));
+                 int(sd_bus*, sd_bus_message**, const char*, const char*,
+                     const char*, const char*));
 
     MOCK_METHOD2(sd_bus_message_new_method_return,
-                 int(sd_bus_message *, sd_bus_message **));
+                 int(sd_bus_message*, sd_bus_message**));
 
     MOCK_METHOD5(sd_bus_message_new_signal,
-                 int(sd_bus *, sd_bus_message **, const char *, const char *,
-                     const char *));
+                 int(sd_bus*, sd_bus_message**, const char*, const char*,
+                     const char*));
 
     MOCK_METHOD3(sd_bus_message_open_container,
-                 int(sd_bus_message *, char, const char *));
+                 int(sd_bus_message*, char, const char*));
 
-    MOCK_METHOD3(sd_bus_message_read_basic,
-                 int(sd_bus_message *, char, void *));
-    MOCK_METHOD1(sd_bus_message_ref, sd_bus_message *(sd_bus_message *));
+    MOCK_METHOD3(sd_bus_message_read_basic, int(sd_bus_message*, char, void*));
+    MOCK_METHOD1(sd_bus_message_ref, sd_bus_message*(sd_bus_message*));
 
-    MOCK_METHOD2(sd_bus_message_skip, int(sd_bus_message *, const char *));
+    MOCK_METHOD2(sd_bus_message_skip, int(sd_bus_message*, const char*));
     MOCK_METHOD3(sd_bus_message_verify_type,
-                 int(sd_bus_message *, char, const char *));
+                 int(sd_bus_message*, char, const char*));
 
-    MOCK_METHOD2(sd_bus_process, int(sd_bus *, sd_bus_message **));
-    MOCK_METHOD1(sd_bus_ref, sd_bus *(sd_bus *));
-    MOCK_METHOD3(sd_bus_request_name, int(sd_bus *, const char *, uint64_t));
-    MOCK_METHOD3(sd_bus_send, int(sd_bus *, sd_bus_message *, uint64_t *));
-    MOCK_METHOD1(sd_bus_unref, sd_bus *(sd_bus *));
-    MOCK_METHOD2(sd_bus_wait, int(sd_bus *, uint64_t));
+    MOCK_METHOD2(sd_bus_process, int(sd_bus*, sd_bus_message**));
+    MOCK_METHOD1(sd_bus_ref, sd_bus*(sd_bus*));
+    MOCK_METHOD3(sd_bus_request_name, int(sd_bus*, const char*, uint64_t));
+    MOCK_METHOD3(sd_bus_send, int(sd_bus*, sd_bus_message*, uint64_t*));
+    MOCK_METHOD1(sd_bus_unref, sd_bus*(sd_bus*));
+    MOCK_METHOD2(sd_bus_wait, int(sd_bus*, uint64_t));
 };
 
-inline bus::bus get_mocked_new(SdBusMock *sdbus)
+inline bus::bus get_mocked_new(SdBusMock* sdbus)
 {
     using ::testing::IsNull;
     using ::testing::Return;
diff --git a/test/message/append.cpp b/test/message/append.cpp
index de40ef6..76faeeb 100644
--- a/test/message/append.cpp
+++ b/test/message/append.cpp
@@ -45,24 +45,23 @@
     template <typename T>
     void expect_basic(char type, T val)
     {
-        EXPECT_CALL(mock,
-                    sd_bus_message_append_basic(
-                        nullptr, type,
-                        MatcherCast<const void *>(
-                            SafeMatcherCast<const T *>(Pointee(Eq(val))))))
+        EXPECT_CALL(mock, sd_bus_message_append_basic(
+                              nullptr, type,
+                              MatcherCast<const void*>(
+                                  SafeMatcherCast<const T*>(Pointee(Eq(val))))))
             .WillOnce(Return(0));
     }
 
-    void expect_basic_string(char type, const char *str)
+    void expect_basic_string(char type, const char* str)
     {
         EXPECT_CALL(mock, sd_bus_message_append_basic(
                               nullptr, type,
-                              MatcherCast<const void *>(
-                                  SafeMatcherCast<const char *>(StrEq(str)))))
+                              MatcherCast<const void*>(
+                                  SafeMatcherCast<const char*>(StrEq(str)))))
             .WillOnce(Return(0));
     }
 
-    void expect_open_container(char type, const char *contents)
+    void expect_open_container(char type, const char* contents)
     {
         EXPECT_CALL(
             mock, sd_bus_message_open_container(nullptr, type, StrEq(contents)))
@@ -144,14 +143,14 @@
 
 TEST_F(AppendTest, LValueCString)
 {
-    const char *const s = "asdf";
+    const char* const s = "asdf";
     expect_basic_string(SD_BUS_TYPE_STRING, s);
     new_message().append(s);
 }
 
 TEST_F(AppendTest, XValueCString)
 {
-    const char *s = "asdf";
+    const char* s = "asdf";
     expect_basic_string(SD_BUS_TYPE_STRING, s);
     new_message().append(std::move(s));
 }
@@ -194,7 +193,7 @@
 {
     const int c = 3;
     const std::string s1{"fdsa"};
-    const char *const s2 = "asdf";
+    const char* const s2 = "asdf";
 
     {
         testing::InSequence seq;
@@ -215,7 +214,7 @@
     {
         testing::InSequence seq;
         expect_open_container(SD_BUS_TYPE_ARRAY, "d");
-        for (const auto &i : a)
+        for (const auto& i : a)
         {
             expect_basic<double>(SD_BUS_TYPE_DOUBLE, i);
         }
@@ -231,7 +230,7 @@
     {
         testing::InSequence seq;
         expect_open_container(SD_BUS_TYPE_ARRAY, "i");
-        for (const auto &i : v)
+        for (const auto& i : v)
         {
             expect_basic<int>(SD_BUS_TYPE_INT32, i);
         }
@@ -247,7 +246,7 @@
     {
         testing::InSequence seq;
         expect_open_container(SD_BUS_TYPE_ARRAY, "s");
-        for (const auto &i : s)
+        for (const auto& i : s)
         {
             expect_basic_string(SD_BUS_TYPE_STRING, i.c_str());
         }
@@ -268,7 +267,7 @@
     {
         testing::InSequence seq;
         expect_open_container(SD_BUS_TYPE_ARRAY, "{is}");
-        for (const auto &i : m)
+        for (const auto& i : m)
         {
             expect_open_container(SD_BUS_TYPE_DICT_ENTRY, "is");
             expect_basic<int>(SD_BUS_TYPE_INT32, i.first);
@@ -292,7 +291,7 @@
     {
         testing::InSequence seq;
         expect_open_container(SD_BUS_TYPE_ARRAY, "{ib}");
-        for (const auto &i : m)
+        for (const auto& i : m)
         {
             expect_open_container(SD_BUS_TYPE_DICT_ENTRY, "ib");
             expect_basic<int>(SD_BUS_TYPE_INT32, i.first);
@@ -348,10 +347,10 @@
         testing::InSequence seq;
 
         expect_open_container(SD_BUS_TYPE_ARRAY, "as");
-        for (const auto &as : vas)
+        for (const auto& as : vas)
         {
             expect_open_container(SD_BUS_TYPE_ARRAY, "s");
-            for (const auto &s : as)
+            for (const auto& s : as)
             {
                 expect_basic_string(SD_BUS_TYPE_STRING, s.c_str());
             }
@@ -360,7 +359,7 @@
         expect_close_container();
 
         expect_open_container(SD_BUS_TYPE_ARRAY, "{sv}");
-        for (const auto &sv : msv)
+        for (const auto& sv : msv)
         {
             expect_open_container(SD_BUS_TYPE_DICT_ENTRY, "sv");
             expect_basic_string(SD_BUS_TYPE_STRING, sv.first.c_str());
diff --git a/test/message/read.cpp b/test/message/read.cpp
index 14da902..eeafd32 100644
--- a/test/message/read.cpp
+++ b/test/message/read.cpp
@@ -24,7 +24,7 @@
 ACTION_TEMPLATE(AssignReadVal, HAS_1_TEMPLATE_PARAMS(typename, T),
                 AND_1_VALUE_PARAMS(val))
 {
-    *static_cast<T *>(arg2) = val;
+    *static_cast<T*>(arg2) = val;
 }
 
 class ReadTest : public testing::Test
@@ -59,7 +59,7 @@
             .WillOnce(DoAll(AssignReadVal<T>(val), Return(0)));
     }
 
-    void expect_verify_type(char type, const char *contents, int ret)
+    void expect_verify_type(char type, const char* contents, int ret)
     {
         EXPECT_CALL(mock,
                     sd_bus_message_verify_type(nullptr, type, StrEq(contents)))
@@ -72,13 +72,13 @@
             .WillOnce(Return(ret));
     }
 
-    void expect_skip(const char *contents, int ret = 0)
+    void expect_skip(const char* contents, int ret = 0)
     {
         EXPECT_CALL(mock, sd_bus_message_skip(nullptr, StrEq(contents)))
             .WillOnce(Return(ret));
     }
 
-    void expect_enter_container(char type, const char *contents, int ret = 0)
+    void expect_enter_container(char type, const char* contents, int ret = 0)
     {
         EXPECT_CALL(mock, sd_bus_message_enter_container(nullptr, type,
                                                          StrEq(contents)))
@@ -121,17 +121,17 @@
 
 TEST_F(ReadTest, CString)
 {
-    const char *const s = "asdf";
-    expect_basic<const char *>(SD_BUS_TYPE_STRING, s);
-    const char *ret;
+    const char* const s = "asdf";
+    expect_basic<const char*>(SD_BUS_TYPE_STRING, s);
+    const char* ret;
     new_message().read(ret);
     EXPECT_EQ(s, ret);
 }
 
 TEST_F(ReadTest, String)
 {
-    const char *const s = "fsda";
-    expect_basic<const char *>(SD_BUS_TYPE_STRING, s);
+    const char* const s = "fsda";
+    expect_basic<const char*>(SD_BUS_TYPE_STRING, s);
     std::string ret;
     new_message().read(ret);
     // Pointer comparison here is intentional as we don't expect a copy
@@ -140,8 +140,8 @@
 
 TEST_F(ReadTest, ObjectPath)
 {
-    const char *const s = "/fsda";
-    expect_basic<const char *>(SD_BUS_TYPE_OBJECT_PATH, s);
+    const char* const s = "/fsda";
+    expect_basic<const char*>(SD_BUS_TYPE_OBJECT_PATH, s);
     sdbusplus::message::object_path ret;
     new_message().read(ret);
     EXPECT_EQ(s, ret.str);
@@ -149,8 +149,8 @@
 
 TEST_F(ReadTest, Signature)
 {
-    const char *const s = "{ii}";
-    expect_basic<const char *>(SD_BUS_TYPE_SIGNATURE, s);
+    const char* const s = "{ii}";
+    expect_basic<const char*>(SD_BUS_TYPE_SIGNATURE, s);
     sdbusplus::message::signature ret;
     new_message().read(ret);
     EXPECT_EQ(s, ret.str);
@@ -159,20 +159,20 @@
 TEST_F(ReadTest, CombinedBasic)
 {
     const double a = 2.2;
-    const char *const b = "ijkd";
+    const char* const b = "ijkd";
     const bool c = false;
     const int d = 18;
 
     {
         testing::InSequence seq;
         expect_basic<double>(SD_BUS_TYPE_DOUBLE, a);
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, b);
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, b);
         expect_basic<int>(SD_BUS_TYPE_BOOLEAN, c);
         expect_basic<int>(SD_BUS_TYPE_INT32, d);
     }
 
     double ret_a;
-    const char *ret_b;
+    const char* ret_b;
     bool ret_c;
     int ret_d;
     new_message().read(ret_a, ret_b, ret_c, ret_d);
@@ -217,7 +217,7 @@
     {
         testing::InSequence seq;
         expect_enter_container(SD_BUS_TYPE_ARRAY, "i");
-        for (const auto &i : vi)
+        for (const auto& i : vi)
         {
             expect_at_end(false, 0);
             expect_basic<int>(SD_BUS_TYPE_INT32, i);
@@ -280,10 +280,10 @@
     {
         testing::InSequence seq;
         expect_enter_container(SD_BUS_TYPE_ARRAY, "s");
-        for (const auto &s : ss)
+        for (const auto& s : ss)
         {
             expect_at_end(false, 0);
-            expect_basic<const char *>(SD_BUS_TYPE_STRING, s.c_str());
+            expect_basic<const char*>(SD_BUS_TYPE_STRING, s.c_str());
         }
         expect_at_end(false, 1);
         expect_exit_container();
@@ -306,12 +306,12 @@
     {
         testing::InSequence seq;
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{is}");
-        for (const auto &is : mis)
+        for (const auto& is : mis)
         {
             expect_at_end(false, 0);
             expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "is");
             expect_basic<int>(SD_BUS_TYPE_INT32, is.first);
-            expect_basic<const char *>(SD_BUS_TYPE_STRING, is.second.c_str());
+            expect_basic<const char*>(SD_BUS_TYPE_STRING, is.second.c_str());
             expect_exit_container();
         }
         expect_at_end(false, 1);
@@ -354,7 +354,7 @@
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{si}");
         expect_at_end(false, 0);
         expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "si");
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, "ab");
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, "ab");
         expect_basic<int>(SD_BUS_TYPE_INT32, 1);
         expect_exit_container(-EINVAL);
     }
@@ -370,7 +370,7 @@
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{si}");
         expect_at_end(false, 0);
         expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "si");
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, "ab");
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, "ab");
         expect_basic<int>(SD_BUS_TYPE_INT32, 1);
         expect_exit_container();
         expect_at_end(false, -EINVAL);
@@ -387,7 +387,7 @@
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{si}");
         expect_at_end(false, 0);
         expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "si");
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, "ab");
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, "ab");
         expect_basic<int>(SD_BUS_TYPE_INT32, 1);
         expect_exit_container();
         expect_at_end(false, 1);
@@ -410,12 +410,12 @@
     {
         testing::InSequence seq;
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{is}");
-        for (const auto &is : mis)
+        for (const auto& is : mis)
         {
             expect_at_end(false, 0);
             expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "is");
             expect_basic<int>(SD_BUS_TYPE_INT32, is.first);
-            expect_basic<const char *>(SD_BUS_TYPE_STRING, is.second.c_str());
+            expect_basic<const char*>(SD_BUS_TYPE_STRING, is.second.c_str());
             expect_exit_container();
         }
         expect_at_end(false, 1);
@@ -435,8 +435,8 @@
         testing::InSequence seq;
         expect_enter_container(SD_BUS_TYPE_STRUCT, "isb");
         expect_basic<int>(SD_BUS_TYPE_INT32, std::get<0>(tisb));
-        expect_basic<const char *>(SD_BUS_TYPE_STRING,
-                                   std::get<1>(tisb).c_str());
+        expect_basic<const char*>(SD_BUS_TYPE_STRING,
+                                  std::get<1>(tisb).c_str());
         expect_basic<int>(SD_BUS_TYPE_BOOLEAN, std::get<2>(tisb));
         expect_exit_container();
     }
@@ -464,7 +464,7 @@
         expect_enter_container(SD_BUS_TYPE_STRUCT, "bis");
         expect_basic<int>(SD_BUS_TYPE_BOOLEAN, false);
         expect_basic<int>(SD_BUS_TYPE_INT32, 1);
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, "ab");
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, "ab");
         expect_exit_container(-EINVAL);
     }
 
@@ -489,7 +489,7 @@
         expect_verify_type(SD_BUS_TYPE_VARIANT, "i", false);
         expect_verify_type(SD_BUS_TYPE_VARIANT, "s", true);
         expect_enter_container(SD_BUS_TYPE_VARIANT, "s");
-        expect_basic<const char *>(SD_BUS_TYPE_STRING, s2.c_str());
+        expect_basic<const char*>(SD_BUS_TYPE_STRING, s2.c_str());
         expect_exit_container();
     }
 
@@ -575,14 +575,14 @@
         testing::InSequence seq;
 
         expect_enter_container(SD_BUS_TYPE_ARRAY, "as");
-        for (const auto &as : vas)
+        for (const auto& as : vas)
         {
             expect_at_end(false, 0);
             expect_enter_container(SD_BUS_TYPE_ARRAY, "s");
-            for (const auto &s : as)
+            for (const auto& s : as)
             {
                 expect_at_end(false, 0);
-                expect_basic<const char *>(SD_BUS_TYPE_STRING, s.c_str());
+                expect_basic<const char*>(SD_BUS_TYPE_STRING, s.c_str());
             }
             expect_at_end(false, 1);
             expect_exit_container();
@@ -591,11 +591,11 @@
         expect_exit_container();
 
         expect_enter_container(SD_BUS_TYPE_ARRAY, "{sv}");
-        for (const auto &sv : msv)
+        for (const auto& sv : msv)
         {
             expect_at_end(false, 0);
             expect_enter_container(SD_BUS_TYPE_DICT_ENTRY, "sv");
-            expect_basic<const char *>(SD_BUS_TYPE_STRING, sv.first.c_str());
+            expect_basic<const char*>(SD_BUS_TYPE_STRING, sv.first.c_str());
             if (sv.second.is<int>())
             {
                 expect_verify_type(SD_BUS_TYPE_VARIANT, "i", true);