add .clang-format

Change-Id: I94ce26d595367e08d6fb3734535bcd855f1b1473
Signed-off-by: Patrick Venture <venture@google.com>
diff --git a/test/fanpwm_unittest.cpp b/test/fanpwm_unittest.cpp
index 63520d3..11dcee9 100644
--- a/test/fanpwm_unittest.cpp
+++ b/test/fanpwm_unittest.cpp
@@ -1,11 +1,11 @@
 #include "fan_pwm.hpp"
-
 #include "hwmonio_mock.hpp"
 
+#include <sdbusplus/test/sdbus_mock.hpp>
+#include <string>
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <sdbusplus/test/sdbus_mock.hpp>
-#include <string>
 
 using ::testing::_;
 using ::testing::Invoke;
@@ -19,55 +19,38 @@
 
 // Handle basic expectations we'll need for all these tests, if it's found that
 // this is helpful for more tests, it can be promoted in scope.
-void SetupDbusObject(
-        sdbusplus::SdBusMock *sdbus_mock,
-        const std::string& path,
-        const std::string& intf,
-        const std::string property = "")
+void SetupDbusObject(sdbusplus::SdBusMock *sdbus_mock, const std::string &path,
+                     const std::string &intf, const std::string property = "")
 {
     EXPECT_CALL(*sdbus_mock,
-                sd_bus_add_object_vtable(
-                    IsNull(),
-                    NotNull(),
-                    StrEq(path),
-                    StrEq(intf),
-                    NotNull(),
-                    NotNull()))
-    .WillOnce(Return(0));
+                sd_bus_add_object_vtable(IsNull(), NotNull(), StrEq(path),
+                                         StrEq(intf), NotNull(), NotNull()))
+        .WillOnce(Return(0));
 
     if (property.empty())
     {
         EXPECT_CALL(*sdbus_mock,
-                    sd_bus_emit_properties_changed_strv(
-                        IsNull(),
-                        StrEq(path),
-                        StrEq(intf),
-                        NotNull()))
-        .WillOnce(Return(0));
+                    sd_bus_emit_properties_changed_strv(IsNull(), StrEq(path),
+                                                        StrEq(intf), NotNull()))
+            .WillOnce(Return(0));
     }
     else
     {
         EXPECT_CALL(*sdbus_mock,
-                    sd_bus_emit_properties_changed_strv(
-                        IsNull(),
-                        StrEq(path),
-                        StrEq(intf),
-                        NotNull()))
-        .WillOnce(
-            Invoke([=](sd_bus *bus,
-                       const char *path,
-                       const char *interface,
-                       char **names) {
+                    sd_bus_emit_properties_changed_strv(IsNull(), StrEq(path),
+                                                        StrEq(intf), NotNull()))
+            .WillOnce(Invoke([=](sd_bus *bus, const char *path,
+                                 const char *interface, char **names) {
                 EXPECT_STREQ(property.c_str(), names[0]);
                 return 0;
-            })
-        );
+            }));
     }
 
     return;
 }
 
-TEST(FanPwmTest, BasicConstructorDeferredTest) {
+TEST(FanPwmTest, BasicConstructorDeferredTest)
+{
     // Attempt to just instantiate one.
 
     // NOTE: This test's goal is to figure out what's minimally required to
@@ -87,16 +70,12 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 }
 
-TEST(FanPwmTest, BasicConstructorNotDeferredTest) {
+TEST(FanPwmTest, BasicConstructorNotDeferredTest)
+{
     // Attempt to just instantiate one.
 
     // NOTE: This test's goal is to figure out what's minimally required to
@@ -116,24 +95,18 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    EXPECT_CALL(sdbus_mock,
-                sd_bus_emit_object_added(IsNull(), StrEq("asdf")))
-    .WillOnce(Return(0));
+    EXPECT_CALL(sdbus_mock, sd_bus_emit_object_added(IsNull(), StrEq("asdf")))
+        .WillOnce(Return(0));
 
-    EXPECT_CALL(sdbus_mock,
-                sd_bus_emit_object_removed(IsNull(), StrEq("asdf")))
-    .WillOnce(Return(0));
+    EXPECT_CALL(sdbus_mock, sd_bus_emit_object_removed(IsNull(), StrEq("asdf")))
+        .WillOnce(Return(0));
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 }
 
-TEST(FanPwmTest, WriteTargetValue) {
+TEST(FanPwmTest, WriteTargetValue)
+{
     // Create a FanPwm and write a value to the object.
 
     sdbusplus::SdBusMock sdbus_mock;
@@ -154,43 +127,29 @@
     hwmonio::HwmonIOMock *hwmonio =
         reinterpret_cast<hwmonio::HwmonIOMock *>(hwmonio_mock.get());
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 
     target = 0x64;
 
-    EXPECT_CALL(*hwmonio, write(static_cast<uint32_t>(target),
-                                StrEq("pwm"),
-                                StrEq("the_id"),
-                                _,
-                                hwmonio::retries,
-                                hwmonio::delay));
+    EXPECT_CALL(*hwmonio,
+                write(static_cast<uint32_t>(target), StrEq("pwm"),
+                      StrEq("the_id"), _, hwmonio::retries, hwmonio::delay));
 
     EXPECT_CALL(sdbus_mock,
                 sd_bus_emit_properties_changed_strv(
-                    IsNull(),
-                    StrEq("asdf"),
-                    StrEq(FanPwmIntf),
-                    NotNull()))
-    .WillOnce(
-        Invoke([&](sd_bus *bus,
-                   const char *path,
-                   const char *interface,
-                   char **names) {
+                    IsNull(), StrEq("asdf"), StrEq(FanPwmIntf), NotNull()))
+        .WillOnce(Invoke([&](sd_bus *bus, const char *path,
+                             const char *interface, char **names) {
             EXPECT_EQ(0, strncmp("Target", names[0], 6));
             return 0;
-        })
-    );
+        }));
 
     EXPECT_EQ(target, f.target(target));
 }
 
-TEST(FanPwmTest, WriteTargetValueNoUpdate) {
+TEST(FanPwmTest, WriteTargetValueNoUpdate)
+{
     // Create a FanPwm and write a value to the object that was the previous
     // value.
 
@@ -209,13 +168,8 @@
 
     SetupDbusObject(&sdbus_mock, objPath, FanPwmIntf, FanPwmProp);
 
-    hwmon::FanPwm f(std::move(hwmonio_mock),
-                    devPath,
-                    id,
-                    bus_mock,
-                    objPath.c_str(),
-                    defer,
-                    target);
+    hwmon::FanPwm f(std::move(hwmonio_mock), devPath, id, bus_mock,
+                    objPath.c_str(), defer, target);
 
     EXPECT_EQ(target, f.target(target));
 }
diff --git a/test/hwmon_unittest.cpp b/test/hwmon_unittest.cpp
index 035d098..1c538c7 100644
--- a/test/hwmon_unittest.cpp
+++ b/test/hwmon_unittest.cpp
@@ -3,10 +3,9 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-TEST(HwmonTest, InvalidType) {
+TEST(HwmonTest, InvalidType)
+{
 
-  hwmon::Attributes attrs;
-  EXPECT_FALSE(hwmon::getAttributes("invalid", attrs));
-
+    hwmon::Attributes attrs;
+    EXPECT_FALSE(hwmon::getAttributes("invalid", attrs));
 }
-
diff --git a/test/hwmonio_mock.hpp b/test/hwmonio_mock.hpp
index 4ad944c..6caa67e 100644
--- a/test/hwmonio_mock.hpp
+++ b/test/hwmonio_mock.hpp
@@ -1,30 +1,26 @@
 #pragma once
 
-#include <gmock/gmock.h>
-
 #include "hwmonio.hpp"
 
-namespace hwmonio {
+#include <gmock/gmock.h>
+
+namespace hwmonio
+{
 
 class HwmonIOMock : public HwmonIOInterface
 {
-    public:
-        virtual ~HwmonIOMock(){};
+  public:
+    virtual ~HwmonIOMock(){};
 
-        MOCK_CONST_METHOD5(read, int64_t(const std::string&,
-                                         const std::string&,
-                                         const std::string&,
-                                         size_t,
-                                         std::chrono::milliseconds));
+    MOCK_CONST_METHOD5(read, int64_t(const std::string&, const std::string&,
+                                     const std::string&, size_t,
+                                     std::chrono::milliseconds));
 
-        MOCK_CONST_METHOD6(write, void(uint32_t,
-                                       const std::string&,
-                                       const std::string&,
-                                       const std::string&,
-                                       size_t,
-                                       std::chrono::milliseconds));
+    MOCK_CONST_METHOD6(write, void(uint32_t, const std::string&,
+                                   const std::string&, const std::string&,
+                                   size_t, std::chrono::milliseconds));
 
-        MOCK_CONST_METHOD0(path, std::string());
+    MOCK_CONST_METHOD0(path, std::string());
 };
 
 } // namespace hwmonio