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);