diff --git a/test/TestBmcEpoch.cpp b/test/TestBmcEpoch.cpp
index 18f3218..eb116e5 100644
--- a/test/TestBmcEpoch.cpp
+++ b/test/TestBmcEpoch.cpp
@@ -1,13 +1,15 @@
-#include "bmc_epoch.hpp"
 #include "config.h"
-#include "types.hpp"
-#include "mocked_bmc_time_change_listener.hpp"
 
-#include <gtest/gtest.h>
+#include "bmc_epoch.hpp"
+#include "mocked_bmc_time_change_listener.hpp"
+#include "types.hpp"
+
 #include <memory>
 #include <sdbusplus/bus.hpp>
 #include <xyz/openbmc_project/Time/error.hpp>
 
+#include <gtest/gtest.h>
+
 namespace phosphor
 {
 namespace time
@@ -15,57 +17,52 @@
 
 using ::testing::_;
 using namespace std::chrono;
-using NotAllowed =
-    sdbusplus::xyz::openbmc_project::Time::Error::NotAllowed;
+using NotAllowed = sdbusplus::xyz::openbmc_project::Time::Error::NotAllowed;
 
 class TestBmcEpoch : public testing::Test
 {
-    public:
-        sdbusplus::bus::bus bus;
-        sd_event* event;
-        MockBmcTimeChangeListener listener;
-        std::unique_ptr<BmcEpoch> bmcEpoch;
+  public:
+    sdbusplus::bus::bus bus;
+    sd_event* event;
+    MockBmcTimeChangeListener listener;
+    std::unique_ptr<BmcEpoch> bmcEpoch;
 
-        TestBmcEpoch()
-            : bus(sdbusplus::bus::new_default())
-        {
-            // BmcEpoch requires sd_event to init
-            sd_event_default(&event);
-            bus.attach_event(event, SD_EVENT_PRIORITY_NORMAL);
-            bmcEpoch = std::make_unique<BmcEpoch>(bus, OBJPATH_BMC);
-            bmcEpoch->setBmcTimeChangeListener(&listener);
-        }
+    TestBmcEpoch() : bus(sdbusplus::bus::new_default())
+    {
+        // BmcEpoch requires sd_event to init
+        sd_event_default(&event);
+        bus.attach_event(event, SD_EVENT_PRIORITY_NORMAL);
+        bmcEpoch = std::make_unique<BmcEpoch>(bus, OBJPATH_BMC);
+        bmcEpoch->setBmcTimeChangeListener(&listener);
+    }
 
-        ~TestBmcEpoch()
-        {
-            bus.detach_event();
-            sd_event_unref(event);
-        }
+    ~TestBmcEpoch()
+    {
+        bus.detach_event();
+        sd_event_unref(event);
+    }
 
-        // Proxies for BmcEpoch's private members and functions
-        Mode getTimeMode()
-        {
-            return bmcEpoch->timeMode;
-        }
-        Owner getTimeOwner()
-        {
-            return bmcEpoch->timeOwner;
-        }
-        void setTimeOwner(Owner owner)
-        {
-            bmcEpoch->timeOwner = owner;
-        }
-        void setTimeMode(Mode mode)
-        {
-            bmcEpoch->timeMode = mode;
-        }
-        void triggerTimeChange()
-        {
-            bmcEpoch->onTimeChange(nullptr,
-                                   -1,
-                                   0,
-                                   bmcEpoch.get());
-        }
+    // Proxies for BmcEpoch's private members and functions
+    Mode getTimeMode()
+    {
+        return bmcEpoch->timeMode;
+    }
+    Owner getTimeOwner()
+    {
+        return bmcEpoch->timeOwner;
+    }
+    void setTimeOwner(Owner owner)
+    {
+        bmcEpoch->timeOwner = owner;
+    }
+    void setTimeMode(Mode mode)
+    {
+        bmcEpoch->timeMode = mode;
+    }
+    void triggerTimeChange()
+    {
+        bmcEpoch->onTimeChange(nullptr, -1, 0, bmcEpoch.get());
+    }
 };
 
 TEST_F(TestBmcEpoch, empty)
@@ -85,15 +82,14 @@
 
 TEST_F(TestBmcEpoch, setElapsedNotAllowed)
 {
-    auto epochNow = duration_cast<microseconds>(
-        system_clock::now().time_since_epoch()).count();
+    auto epochNow =
+        duration_cast<microseconds>(system_clock::now().time_since_epoch())
+            .count();
 
     // In Host owner, setting time is not allowed
     setTimeMode(Mode::Manual);
     setTimeOwner(Owner::Host);
-    EXPECT_THROW(
-        bmcEpoch->elapsed(epochNow),
-        NotAllowed);
+    EXPECT_THROW(bmcEpoch->elapsed(epochNow), NotAllowed);
 }
 
 TEST_F(TestBmcEpoch, setElapsedOK)
@@ -110,5 +106,5 @@
     triggerTimeChange();
 }
 
-}
-}
+} // namespace time
+} // namespace phosphor
diff --git a/test/TestEpochBase.cpp b/test/TestEpochBase.cpp
index 6c2ec88..b193969 100644
--- a/test/TestEpochBase.cpp
+++ b/test/TestEpochBase.cpp
@@ -1,8 +1,9 @@
-#include <sdbusplus/bus.hpp>
-#include <gtest/gtest.h>
-
-#include "types.hpp"
 #include "epoch_base.hpp"
+#include "types.hpp"
+
+#include <sdbusplus/bus.hpp>
+
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
@@ -11,25 +12,23 @@
 
 class TestEpochBase : public testing::Test
 {
-    public:
-        sdbusplus::bus::bus bus;
-        EpochBase epochBase;
+  public:
+    sdbusplus::bus::bus bus;
+    EpochBase epochBase;
 
-        TestEpochBase()
-            : bus(sdbusplus::bus::new_default()),
-              epochBase(bus, "")
-        {
-            // Empty
-        }
+    TestEpochBase() : bus(sdbusplus::bus::new_default()), epochBase(bus, "")
+    {
+        // Empty
+    }
 
-        Mode getMode()
-        {
-            return epochBase.timeMode;
-        }
-        Owner getOwner()
-        {
-            return epochBase.timeOwner;
-        }
+    Mode getMode()
+    {
+        return epochBase.timeMode;
+    }
+    Owner getOwner()
+    {
+        return epochBase.timeOwner;
+    }
 };
 
 TEST_F(TestEpochBase, onModeChange)
@@ -56,5 +55,5 @@
     EXPECT_EQ(Owner::Both, getOwner());
 }
 
-}
-}
+} // namespace time
+} // namespace phosphor
diff --git a/test/TestHostEpoch.cpp b/test/TestHostEpoch.cpp
index 1004dad..7ddf92f 100644
--- a/test/TestHostEpoch.cpp
+++ b/test/TestHostEpoch.cpp
@@ -1,13 +1,13 @@
-#include "host_epoch.hpp"
-#include "utils.hpp"
 #include "config.h"
-#include "types.hpp"
 
-#include <xyz/openbmc_project/Time/error.hpp>
+#include "host_epoch.hpp"
+#include "types.hpp"
+#include "utils.hpp"
 
 #include <sdbusplus/bus.hpp>
-#include <gtest/gtest.h>
+#include <xyz/openbmc_project/Time/error.hpp>
 
+#include <gtest/gtest.h>
 
 namespace phosphor
 {
@@ -16,129 +16,128 @@
 
 using namespace std::chrono;
 using namespace std::chrono_literals;
-using NotAllowed =
-    sdbusplus::xyz::openbmc_project::Time::Error::NotAllowed;
+using NotAllowed = sdbusplus::xyz::openbmc_project::Time::Error::NotAllowed;
 
 const constexpr microseconds USEC_ZERO{0};
 
 class TestHostEpoch : public testing::Test
 {
-    public:
-        sdbusplus::bus::bus bus;
-        HostEpoch hostEpoch;
+  public:
+    sdbusplus::bus::bus bus;
+    HostEpoch hostEpoch;
 
-        static constexpr auto FILE_NOT_EXIST = "path/to/file-not-exist";
-        static constexpr auto FILE_OFFSET = "saved_host_offset";
-        const microseconds delta = 2s;
+    static constexpr auto FILE_NOT_EXIST = "path/to/file-not-exist";
+    static constexpr auto FILE_OFFSET = "saved_host_offset";
+    const microseconds delta = 2s;
 
-        TestHostEpoch()
-            : bus(sdbusplus::bus::new_default()),
-              hostEpoch(bus, OBJPATH_HOST)
-        {
-            // Make sure the file does not exist
-            std::remove(FILE_NOT_EXIST);
-        }
-        ~TestHostEpoch()
-        {
-            // Cleanup test file
-            std::remove(FILE_OFFSET);
-        }
+    TestHostEpoch() :
+        bus(sdbusplus::bus::new_default()), hostEpoch(bus, OBJPATH_HOST)
+    {
+        // Make sure the file does not exist
+        std::remove(FILE_NOT_EXIST);
+    }
+    ~TestHostEpoch()
+    {
+        // Cleanup test file
+        std::remove(FILE_OFFSET);
+    }
 
-        // Proxies for HostEpoch's private members and functions
-        Mode getTimeMode()
-        {
-            return hostEpoch.timeMode;
-        }
-        Owner getTimeOwner()
-        {
-            return hostEpoch.timeOwner;
-        }
-        microseconds getOffset()
-        {
-            return hostEpoch.offset;
-        }
-        void setOffset(microseconds us)
-        {
-            hostEpoch.offset = us;
-        }
-        void setTimeOwner(Owner owner)
-        {
-            hostEpoch.onOwnerChanged(owner);
-        }
-        void setTimeMode(Mode mode)
-        {
-            hostEpoch.onModeChanged(mode);
-        }
+    // Proxies for HostEpoch's private members and functions
+    Mode getTimeMode()
+    {
+        return hostEpoch.timeMode;
+    }
+    Owner getTimeOwner()
+    {
+        return hostEpoch.timeOwner;
+    }
+    microseconds getOffset()
+    {
+        return hostEpoch.offset;
+    }
+    void setOffset(microseconds us)
+    {
+        hostEpoch.offset = us;
+    }
+    void setTimeOwner(Owner owner)
+    {
+        hostEpoch.onOwnerChanged(owner);
+    }
+    void setTimeMode(Mode mode)
+    {
+        hostEpoch.onModeChanged(mode);
+    }
 
-        void checkSettingTimeNotAllowed()
-        {
-            // By default offset shall be 0
-            EXPECT_EQ(0, getOffset().count());
+    void checkSettingTimeNotAllowed()
+    {
+        // By default offset shall be 0
+        EXPECT_EQ(0, getOffset().count());
 
-            // Set time is not allowed,
-            // so verify offset is still 0 after set time
-            microseconds diff = 1min;
-            EXPECT_THROW(
-                hostEpoch.elapsed(hostEpoch.elapsed() + diff.count()),
-                NotAllowed);
-            EXPECT_EQ(0, getOffset().count());
-        }
+        // Set time is not allowed,
+        // so verify offset is still 0 after set time
+        microseconds diff = 1min;
+        EXPECT_THROW(hostEpoch.elapsed(hostEpoch.elapsed() + diff.count()),
+                     NotAllowed);
+        EXPECT_EQ(0, getOffset().count());
+    }
 
-        void checkSetSplitTimeInFuture()
-        {
-            // Get current time, and set future +1min time
-            auto t1 = hostEpoch.elapsed();
-            EXPECT_NE(0, t1);
-            microseconds diff = 1min;
-            auto t2 = t1 + diff.count();
-            hostEpoch.elapsed(t2);
+    void checkSetSplitTimeInFuture()
+    {
+        // Get current time, and set future +1min time
+        auto t1 = hostEpoch.elapsed();
+        EXPECT_NE(0, t1);
+        microseconds diff = 1min;
+        auto t2 = t1 + diff.count();
+        hostEpoch.elapsed(t2);
 
-            // Verify that the offset shall be positive,
-            // and less or equal to diff, and shall be not too less.
-            auto offset = getOffset();
-            EXPECT_GT(offset, USEC_ZERO);
-            EXPECT_LE(offset, diff);
-            diff -= delta;
-            EXPECT_GE(offset, diff);
+        // Verify that the offset shall be positive,
+        // and less or equal to diff, and shall be not too less.
+        auto offset = getOffset();
+        EXPECT_GT(offset, USEC_ZERO);
+        EXPECT_LE(offset, diff);
+        diff -= delta;
+        EXPECT_GE(offset, diff);
 
-            // Now get time shall be around future +1min time
-            auto epochNow = duration_cast<microseconds>(
-                                system_clock::now().time_since_epoch()).count();
-            auto elapsedGot = hostEpoch.elapsed();
-            EXPECT_LT(epochNow, elapsedGot);
-            auto epochDiff = elapsedGot - epochNow;
-            diff = 1min;
-            EXPECT_GT(epochDiff, (diff - delta).count());
-            EXPECT_LT(epochDiff, (diff + delta).count());
-        }
-        void checkSetSplitTimeInPast()
-        {
-            // Get current time, and set past -1min time
-            auto t1 = hostEpoch.elapsed();
-            EXPECT_NE(0, t1);
-            microseconds diff = 1min;
-            auto t2 = t1 - diff.count();
-            hostEpoch.elapsed(t2);
+        // Now get time shall be around future +1min time
+        auto epochNow =
+            duration_cast<microseconds>(system_clock::now().time_since_epoch())
+                .count();
+        auto elapsedGot = hostEpoch.elapsed();
+        EXPECT_LT(epochNow, elapsedGot);
+        auto epochDiff = elapsedGot - epochNow;
+        diff = 1min;
+        EXPECT_GT(epochDiff, (diff - delta).count());
+        EXPECT_LT(epochDiff, (diff + delta).count());
+    }
+    void checkSetSplitTimeInPast()
+    {
+        // Get current time, and set past -1min time
+        auto t1 = hostEpoch.elapsed();
+        EXPECT_NE(0, t1);
+        microseconds diff = 1min;
+        auto t2 = t1 - diff.count();
+        hostEpoch.elapsed(t2);
 
-            // Verify that the offset shall be negative, and the absolute value
-            // shall be equal or greater than diff, and shall not be too greater
-            auto offset = getOffset();
-            EXPECT_LT(offset, USEC_ZERO);
-            offset = -offset;
-            EXPECT_GE(offset, diff);
-            diff += 10s;
-            EXPECT_LE(offset, diff);
+        // Verify that the offset shall be negative, and the absolute value
+        // shall be equal or greater than diff, and shall not be too greater
+        auto offset = getOffset();
+        EXPECT_LT(offset, USEC_ZERO);
+        offset = -offset;
+        EXPECT_GE(offset, diff);
+        diff += 10s;
+        EXPECT_LE(offset, diff);
 
-            // Now get time shall be around past -1min time
-            auto epochNow = duration_cast<microseconds>(
-                                system_clock::now().time_since_epoch()).count();
-            auto elapsedGot = hostEpoch.elapsed();
-            EXPECT_LT(elapsedGot, epochNow);
-            auto epochDiff = epochNow - elapsedGot;
-            diff = 1min;
-            EXPECT_GT(epochDiff, (diff - delta).count());
-            EXPECT_LT(epochDiff, (diff + delta).count());
-        }
+        // Now get time shall be around past -1min time
+        auto epochNow =
+            duration_cast<microseconds>(system_clock::now().time_since_epoch())
+                .count();
+        auto elapsedGot = hostEpoch.elapsed();
+        EXPECT_LT(elapsedGot, epochNow);
+        auto epochDiff = epochNow - elapsedGot;
+        diff = 1min;
+        EXPECT_GT(epochDiff, (diff - delta).count());
+        EXPECT_LT(epochDiff, (diff + delta).count());
+    }
 };
 
 TEST_F(TestHostEpoch, empty)
@@ -160,13 +159,13 @@
 {
     // Write offset to file
     microseconds offsetToWrite(1234567);
-    utils::writeData<decltype(offsetToWrite)::rep>(
-        FILE_OFFSET, offsetToWrite.count());
+    utils::writeData<decltype(offsetToWrite)::rep>(FILE_OFFSET,
+                                                   offsetToWrite.count());
 
     // Read it back
     microseconds offsetToRead;
-    offsetToRead = microseconds(
-                       utils::readData<decltype(offsetToRead)::rep>(FILE_OFFSET));
+    offsetToRead =
+        microseconds(utils::readData<decltype(offsetToRead)::rep>(FILE_OFFSET));
     EXPECT_EQ(offsetToWrite, offsetToRead);
 }
 
@@ -295,5 +294,5 @@
     EXPECT_EQ(USEC_ZERO, getOffset());
 }
 
-}
-}
+} // namespace time
+} // namespace phosphor
diff --git a/test/TestManager.cpp b/test/TestManager.cpp
index aa7a647..c0763c8 100644
--- a/test/TestManager.cpp
+++ b/test/TestManager.cpp
@@ -1,9 +1,10 @@
-#include <sdbusplus/bus.hpp>
-#include <gtest/gtest.h>
-
-#include "types.hpp"
 #include "manager.hpp"
 #include "mocked_property_change_listener.hpp"
+#include "types.hpp"
+
+#include <sdbusplus/bus.hpp>
+
+#include <gtest/gtest.h>
 
 using ::testing::_;
 
@@ -14,52 +15,49 @@
 
 class TestManager : public testing::Test
 {
-    public:
-        sdbusplus::bus::bus bus;
-        Manager manager;
-        MockPropertyChangeListner listener1;
-        MockPropertyChangeListner listener2;
+  public:
+    sdbusplus::bus::bus bus;
+    Manager manager;
+    MockPropertyChangeListner listener1;
+    MockPropertyChangeListner listener2;
 
-        TestManager()
-            : bus(sdbusplus::bus::new_default()),
-              manager(bus)
-        {
-            // Add two mocked listeners so that we can test
-            // the behavior related to listeners
-            manager.addListener(&listener1);
-            manager.addListener(&listener2);
-        }
+    TestManager() : bus(sdbusplus::bus::new_default()), manager(bus)
+    {
+        // Add two mocked listeners so that we can test
+        // the behavior related to listeners
+        manager.addListener(&listener1);
+        manager.addListener(&listener2);
+    }
 
-        // Proxies for Manager's private members and functions
-        Mode getTimeMode()
-        {
-            return manager.timeMode;
-        }
-        Owner getTimeOwner()
-        {
-            return manager.timeOwner;
-        }
-        bool hostOn()
-        {
-            return manager.hostOn;
-        }
-        std::string getRequestedMode()
-        {
-            return manager.requestedMode;
-        }
-        std::string getRequestedOwner()
-        {
-            return manager.requestedOwner;
-        }
-        void notifyPropertyChanged(const std::string& key,
-                                   const std::string& value)
-        {
-            manager.onPropertyChanged(key, value);
-        }
-        void notifyOnHostState(bool hostOn)
-        {
-            manager.onHostState(hostOn);
-        }
+    // Proxies for Manager's private members and functions
+    Mode getTimeMode()
+    {
+        return manager.timeMode;
+    }
+    Owner getTimeOwner()
+    {
+        return manager.timeOwner;
+    }
+    bool hostOn()
+    {
+        return manager.hostOn;
+    }
+    std::string getRequestedMode()
+    {
+        return manager.requestedMode;
+    }
+    std::string getRequestedOwner()
+    {
+        return manager.requestedOwner;
+    }
+    void notifyPropertyChanged(const std::string& key, const std::string& value)
+    {
+        manager.onPropertyChanged(key, value);
+    }
+    void notifyOnHostState(bool hostOn)
+    {
+        manager.onHostState(hostOn);
+    }
 };
 
 TEST_F(TestManager, DISABLED_empty)
@@ -73,7 +71,6 @@
     EXPECT_EQ(Owner::Both, getTimeOwner());
 }
 
-
 TEST_F(TestManager, DISABLED_hostStateChange)
 {
     notifyOnHostState(true);
@@ -96,9 +93,8 @@
     notifyPropertyChanged(
         "TimeSyncMethod",
         "xyz.openbmc_project.Time.Synchronization.Method.Manual");
-    notifyPropertyChanged(
-        "TimeOwner",
-        "xyz.openbmc_project.Time.Owner.Owners.Host");
+    notifyPropertyChanged("TimeOwner",
+                          "xyz.openbmc_project.Time.Owner.Owners.Host");
 
     EXPECT_EQ("", getRequestedMode());
     EXPECT_EQ("", getRequestedOwner());
@@ -115,16 +111,14 @@
     notifyPropertyChanged(
         "TimeSyncMethod",
         "xyz.openbmc_project.Time.Synchronization.Method.NTP");
-    notifyPropertyChanged(
-        "TimeOwner",
-        "xyz.openbmc_project.Time.Owner.Owners.Split");
+    notifyPropertyChanged("TimeOwner",
+                          "xyz.openbmc_project.Time.Owner.Owners.Split");
 
     EXPECT_EQ("xyz.openbmc_project.Time.Synchronization.Method.NTP",
               getRequestedMode());
     EXPECT_EQ("xyz.openbmc_project.Time.Owner.Owners.Split",
               getRequestedOwner());
 
-
     // When host becomes off, the requested mode/owner shall be notified
     // to listeners, and be cleared
     EXPECT_CALL(listener1, onModeChanged(Mode::NTP)).Times(1);
@@ -149,9 +143,8 @@
     notifyPropertyChanged(
         "TimeSyncMethod",
         "xyz.openbmc_project.Time.Synchronization.Method.Manual");
-    notifyPropertyChanged(
-        "TimeOwner",
-        "xyz.openbmc_project.Time.Owner.Owners.Host");
+    notifyPropertyChanged("TimeOwner",
+                          "xyz.openbmc_project.Time.Owner.Owners.Host");
 
     // Set host on
     notifyOnHostState(true);
@@ -165,9 +158,8 @@
     notifyPropertyChanged(
         "TimeSyncMethod",
         "xyz.openbmc_project.Time.Synchronization.Method.NTP");
-    notifyPropertyChanged(
-        "TimeOwner",
-        "xyz.openbmc_project.Time.Owner.Owners.Split");
+    notifyPropertyChanged("TimeOwner",
+                          "xyz.openbmc_project.Time.Owner.Owners.Split");
 
     // Saved as requested mode/owner
     EXPECT_EQ("xyz.openbmc_project.Time.Synchronization.Method.NTP",
@@ -179,9 +171,8 @@
     notifyPropertyChanged(
         "TimeSyncMethod",
         "xyz.openbmc_project.Time.Synchronization.Method.Manual");
-    notifyPropertyChanged(
-        "TimeOwner",
-        "xyz.openbmc_project.Time.Owner.Owners.Host");
+    notifyPropertyChanged("TimeOwner",
+                          "xyz.openbmc_project.Time.Owner.Owners.Host");
 
     // Requested mode/owner shall be updated
     EXPECT_EQ("xyz.openbmc_project.Time.Synchronization.Method.Manual",
@@ -206,5 +197,5 @@
 // TODO: if gmock is ready, add case to test
 // updateNtpSetting() and updateNetworkSetting()
 
-}
-}
+} // namespace time
+} // namespace phosphor
diff --git a/test/TestUtils.cpp b/test/TestUtils.cpp
index 483e82a..1cbc852 100644
--- a/test/TestUtils.cpp
+++ b/test/TestUtils.cpp
@@ -1,8 +1,9 @@
 #include "utils.hpp"
 
-#include <gtest/gtest.h>
 #include <xyz/openbmc_project/Common/error.hpp>
 
+#include <gtest/gtest.h>
+
 namespace phosphor
 {
 namespace time
@@ -14,9 +15,8 @@
 
 TEST(TestUtil, strToMode)
 {
-    EXPECT_EQ(
-        Mode::NTP,
-        strToMode("xyz.openbmc_project.Time.Synchronization.Method.NTP"));
+    EXPECT_EQ(Mode::NTP,
+              strToMode("xyz.openbmc_project.Time.Synchronization.Method.NTP"));
     EXPECT_EQ(
         Mode::Manual,
         strToMode("xyz.openbmc_project.Time.Synchronization.Method.Manual"));
@@ -29,7 +29,6 @@
     EXPECT_THROW(strToMode("whatever"), InvalidEnumString);
 }
 
-
 TEST(TestUtil, strToOwner)
 {
     EXPECT_EQ(Owner::BMC,
diff --git a/test/mocked_bmc_time_change_listener.hpp b/test/mocked_bmc_time_change_listener.hpp
index 9b2c81c..364b333 100644
--- a/test/mocked_bmc_time_change_listener.hpp
+++ b/test/mocked_bmc_time_change_listener.hpp
@@ -1,16 +1,18 @@
 #pragma once
-#include <gmock/gmock.h>
 #include "bmc_time_change_listener.hpp"
 
-namespace phosphor {
-namespace time {
+#include <gmock/gmock.h>
 
-class MockBmcTimeChangeListener : public BmcTimeChangeListener {
- public:
-  MOCK_METHOD1(onBmcTimeChanged,
-      void(const std::chrono::microseconds&));
+namespace phosphor
+{
+namespace time
+{
+
+class MockBmcTimeChangeListener : public BmcTimeChangeListener
+{
+  public:
+    MOCK_METHOD1(onBmcTimeChanged, void(const std::chrono::microseconds&));
 };
 
-}  // namespace time
-}  // namespace phosphor
-
+} // namespace time
+} // namespace phosphor
diff --git a/test/mocked_property_change_listener.hpp b/test/mocked_property_change_listener.hpp
index d581dd3..5d7a3b5 100644
--- a/test/mocked_property_change_listener.hpp
+++ b/test/mocked_property_change_listener.hpp
@@ -1,17 +1,19 @@
 #pragma once
-#include <gmock/gmock.h>
 #include "property_change_listener.hpp"
 
-namespace phosphor {
-namespace time {
+#include <gmock/gmock.h>
 
-class MockPropertyChangeListner : public PropertyChangeListner {
- public:
-  MOCK_METHOD1(onModeChanged,
-      void(Mode mode));
-  MOCK_METHOD1(onOwnerChanged,
-      void(Owner owner));
+namespace phosphor
+{
+namespace time
+{
+
+class MockPropertyChangeListner : public PropertyChangeListner
+{
+  public:
+    MOCK_METHOD1(onModeChanged, void(Mode mode));
+    MOCK_METHOD1(onOwnerChanged, void(Owner owner));
 };
 
-}  // namespace time
-}  // namespace phosphor
+} // namespace time
+} // namespace phosphor