1 files changed, 43 insertions, 56 deletions

diff --git a/src/components/rpc_base/test/rpc_base_dbus_test.cc b/src/components/rpc_base/test/rpc_base_dbus_test.cc
index e217eff476..f26ce25c5d 100644
--- a/src/components/rpc_base/test/rpc_base_dbus_test.cc
+++ b/src/components/rpc_base/test/rpc_base_dbus_test.cc
@@ -38,11 +38,7 @@ namespace test {
 using namespace rpc;
 using namespace dbus;
 
-enum TestEnum {
-  kValue0,
-  kValue1,
-  kInvalidValue
-};
+enum TestEnum { kValue0, kValue1, kInvalidValue };
 
 bool IsValidEnum(TestEnum val) {
   return val == kValue0 || val == kValue1;
@@ -74,8 +70,7 @@ const char* EnumToJsonString(TestEnum enm) {
 struct DbusDeserialization : public testing::Test {
   dbus::MessageRef msgref;
   DbusDeserialization()
-      : msgref(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL)) {
-  }
+      : msgref(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL)) {}
 };
 
 TEST_F(DbusDeserialization, DeserializeBool) {
@@ -97,7 +92,7 @@ TEST_F(DbusDeserialization, DeserializeByte) {
   }
   {
     dbus::MessageReader reader(msgref);
-    Integer < uint8_t, 1, 220 > byte(&reader);
+    Integer<uint8_t, 1, 220> byte(&reader);
     ASSERT_TRUE(byte.is_initialized());
     ASSERT_TRUE(byte.is_valid());
     ASSERT_EQ(byte, 200);
@@ -113,7 +108,7 @@ TEST_F(DbusDeserialization, DeserializeInt64) {
   }
   {
     dbus::MessageReader reader(msgref);
-    Integer < int64_t, -5, 220 > int64(&reader);
+    Integer<int64_t, -5, 220> int64(&reader);
     ASSERT_TRUE(int64.is_initialized());
     ASSERT_TRUE(int64.is_valid());
     ASSERT_EQ(int64, -1);
@@ -129,7 +124,7 @@ TEST_F(DbusDeserialization, DeserializeFloat) {
   }
   {
     dbus::MessageReader reader(msgref);
-    Float < 3, 4 > pi(&reader);
+    Float<3, 4> pi(&reader);
     ASSERT_TRUE(pi.is_initialized());
     ASSERT_TRUE(pi.is_valid());
     ASSERT_DOUBLE_EQ(pi, 3.14);
@@ -145,7 +140,7 @@ TEST_F(DbusDeserialization, DeserializeString) {
   }
   {
     dbus::MessageReader reader(msgref);
-    String < 3, 10 > hello(&reader);
+    String<3, 10> hello(&reader);
     ASSERT_TRUE(hello.is_initialized());
     ASSERT_TRUE(hello.is_valid());
     ASSERT_EQ(std::string(hello), "Hello");
@@ -174,9 +169,9 @@ TEST_F(DbusDeserialization, DeserializeArray) {
   {
     dbus::MessageWriter writer(msgref);
     std::string array_signature;
-    rpc::DbusSignature<Integer<int32_t, 1, 50> >(&array_signature);
-    dbus::MessageWriter array_writer(&writer, dbus::kArray,
-                                     array_signature.c_str());
+    rpc::DbusSignature<Integer<int32_t, 1, 50>>(&array_signature);
+    dbus::MessageWriter array_writer(
+        &writer, dbus::kArray, array_signature.c_str());
     array_writer.PutInt32(5);
     array_writer.PutInt32(33);
   }
@@ -190,7 +185,6 @@ TEST_F(DbusDeserialization, DeserializeArray) {
     ASSERT_EQ(array.size(), 2u);
     ASSERT_EQ(array[0], 5);
     ASSERT_EQ(array[1], 33);
-
   }
 }
 
@@ -198,15 +192,15 @@ TEST_F(DbusDeserialization, DeserializeArrayOfArrays) {
   {
     dbus::MessageWriter writer(msgref);
     std::string array_signature;
-    rpc::DbusSignature<Array<Integer<int32_t, 1, 50>, 1, 5> >(&array_signature);
-    dbus::MessageWriter array_writer(&writer, dbus::kArray,
-                                     array_signature.c_str());
+    rpc::DbusSignature<Array<Integer<int32_t, 1, 50>, 1, 5>>(&array_signature);
+    dbus::MessageWriter array_writer(
+        &writer, dbus::kArray, array_signature.c_str());
     int val = 5;
     for (int i = 0; i < 2; ++i) {
       std::string subarray_signature;
-      rpc::DbusSignature<Integer<int32_t, 1, 50> >(&subarray_signature);
-      dbus::MessageWriter subarray_wirter(&array_writer, dbus::kArray,
-                                          subarray_signature.c_str());
+      rpc::DbusSignature<Integer<int32_t, 1, 50>>(&subarray_signature);
+      dbus::MessageWriter subarray_wirter(
+          &array_writer, dbus::kArray, subarray_signature.c_str());
 
       subarray_wirter.PutInt32(val++);
       subarray_wirter.PutInt32(val++);
@@ -226,7 +220,6 @@ TEST_F(DbusDeserialization, DeserializeArrayOfArrays) {
     ASSERT_EQ(array[0][1], 6);
     ASSERT_EQ(array[1][0], 7);
     ASSERT_EQ(array[1][1], 8);
-
   }
 }
 
@@ -235,9 +228,9 @@ TEST_F(DbusDeserialization, DeserializeMap) {
     dbus::MessageWriter writer(msgref);
     std::string dict_signature;
     rpc::DbusSignature<Map<Enum<TestEnum>, 1, 5>::value_type>(&dict_signature);
-    dbus::MessageWriter array_writer(&writer, dbus::kArray,
-                                     dict_signature.c_str());
-    const char* keys[] = { "Hello", "World" };
+    dbus::MessageWriter array_writer(
+        &writer, dbus::kArray, dict_signature.c_str());
+    const char* keys[] = {"Hello", "World"};
     int val = 0;
     for (int i = 0; i < 2; ++i) {
       dbus::MessageWriter dictval_wirter(&array_writer, dbus::kDictEntry, NULL);
@@ -255,7 +248,6 @@ TEST_F(DbusDeserialization, DeserializeMap) {
     ASSERT_EQ(amap.size(), 2u);
     ASSERT_EQ(amap["Hello"], kValue0);
     ASSERT_EQ(amap["World"], kValue1);
-
   }
 }
 
@@ -283,7 +275,7 @@ TEST_F(DbusDeserialization, DeserializeOptionalString) {
   }
   {
     dbus::MessageReader reader(msgref);
-    Optional < String<1, 100> > readback(&reader);
+    Optional<String<1, 100>> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_EQ(std::string(*readback), "Hello dear");
@@ -301,16 +293,14 @@ TEST_F(DbusDeserialization, DeserializeOptionalInt) {
   }
   {
     dbus::MessageReader reader(msgref);
-    Optional < Integer<int32_t, 1, 90>> readback(&reader);
+    Optional<Integer<int32_t, 1, 90>> readback(&reader);
     ASSERT_FALSE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_FALSE(reader.has_failed());
     ASSERT_FALSE(reader.HasNext());
-
   }
 }
 
-
 TEST_F(DbusDeserialization, SerializeDeserializeBool) {
   {
     Boolean true_bool(true);
@@ -330,13 +320,13 @@ TEST_F(DbusDeserialization, SerializeDeserializeBool) {
 
 TEST_F(DbusDeserialization, SerializeDeserializeInt8t) {
   {
-    Integer < int8_t, 1, 100 > int8(42);
+    Integer<int8_t, 1, 100> int8(42);
     dbus::MessageWriter writer(msgref);
     int8.ToDbusWriter(&writer);
   }
   {
     dbus::MessageReader reader(msgref);
-    Integer < int8_t, 1, 100 > readback(&reader);
+    Integer<int8_t, 1, 100> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_EQ(readback, 42);
@@ -347,13 +337,13 @@ TEST_F(DbusDeserialization, SerializeDeserializeInt8t) {
 
 TEST_F(DbusDeserialization, BadSerializeDeserializeInt8t) {
   {
-    Integer < int8_t, 1, 12 > int8(42);
+    Integer<int8_t, 1, 12> int8(42);
     dbus::MessageWriter writer(msgref);
     int8.ToDbusWriter(&writer);
   }
   {
     dbus::MessageReader reader(msgref);
-    Integer < int8_t, 1, 12 > readback(&reader);
+    Integer<int8_t, 1, 12> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_FALSE(readback.is_valid());
     ASSERT_FALSE(reader.has_failed());
@@ -363,13 +353,13 @@ TEST_F(DbusDeserialization, BadSerializeDeserializeInt8t) {
 
 TEST_F(DbusDeserialization, SerializeDeserializeInt64t) {
   {
-    Integer < int64_t, 1, 0xFFFFFFFFFF > int64(0xFFFFFFFFF1);
+    Integer<int64_t, 1, 0xFFFFFFFFFF> int64(0xFFFFFFFFF1);
     dbus::MessageWriter writer(msgref);
     int64.ToDbusWriter(&writer);
   }
   {
     dbus::MessageReader reader(msgref);
-    Integer < int64_t, 1, 0xFFFFFFFFFF > readback(&reader);
+    Integer<int64_t, 1, 0xFFFFFFFFFF> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_EQ(readback, 0xFFFFFFFFF1);
@@ -378,16 +368,15 @@ TEST_F(DbusDeserialization, SerializeDeserializeInt64t) {
   }
 }
 
-
 TEST_F(DbusDeserialization, SerializeDeserializeDouble) {
   {
-    Float < 1, 5 > flt(3.14);
+    Float<1, 5> flt(3.14);
     dbus::MessageWriter writer(msgref);
     flt.ToDbusWriter(&writer);
   }
   {
     dbus::MessageReader reader(msgref);
-    Float < 1, 5 > readback(&reader);
+    Float<1, 5> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_DOUBLE_EQ(readback, 3.14);
@@ -398,13 +387,13 @@ TEST_F(DbusDeserialization, SerializeDeserializeDouble) {
 
 TEST_F(DbusDeserialization, SerializeDeserializeString) {
   {
-    String < 1, 12 > hello("Hello");
+    String<1, 12> hello("Hello");
     dbus::MessageWriter writer(msgref);
     hello.ToDbusWriter(&writer);
   }
   {
     dbus::MessageReader reader(msgref);
-    String < 1, 12 > readback(&reader);
+    String<1, 12> readback(&reader);
     ASSERT_TRUE(readback.is_initialized());
     ASSERT_TRUE(readback.is_valid());
     ASSERT_EQ(std::string(readback), "Hello");
@@ -505,61 +494,61 @@ TEST(ValidatedTypes, TestBooleanDbusSignature) {
 
 TEST(ValidatedTypes, TestIntDbusSignature) {
   std::string sign;
-  DbusSignature<Integer<int32_t, 1, 2> >(&sign);
+  DbusSignature<Integer<int32_t, 1, 2>>(&sign);
   ASSERT_EQ(sign, "i");
 }
 
 TEST(ValidatedTypes, TestFloatDbusSignature) {
   std::string sign;
-  DbusSignature<Float<1, 2> >(&sign);
+  DbusSignature<Float<1, 2>>(&sign);
   ASSERT_EQ(sign, "d");
 }
 
 TEST(ValidatedTypes, TestStringDbusSignature) {
   std::string sign;
-  DbusSignature<String<1, 2> >(&sign);
+  DbusSignature<String<1, 2>>(&sign);
   ASSERT_EQ(sign, "s");
 }
 
 TEST(ValidatedTypes, TestEnumDbusSignature) {
   std::string sign;
-  DbusSignature<Enum<TestEnum> >(&sign);
+  DbusSignature<Enum<TestEnum>>(&sign);
   ASSERT_EQ(sign, "i");
 }
 
 TEST(ValidatedTypes, TestIntArrayDbusSignature) {
   std::string sign;
-  DbusSignature<Array<Integer<int32_t, 1, 2>, 1, 3> >(&sign);
+  DbusSignature<Array<Integer<int32_t, 1, 2>, 1, 3>>(&sign);
   ASSERT_EQ(sign, "ai");
 }
 
 TEST(ValidatedTypes, TestIntArrayArrayDbusSignature) {
   std::string sign;
-  DbusSignature<Array<Array<Integer<int32_t, 1, 2>, 1, 3>, 4, 5> >(&sign);
+  DbusSignature<Array<Array<Integer<int32_t, 1, 2>, 1, 3>, 4, 5>>(&sign);
   ASSERT_EQ(sign, "aai");
 }
 
 TEST(ValidatedTypes, TestMapDbusSignature) {
   std::string sign;
-  DbusSignature<Map<Integer<int32_t, 1, 2>, 3, 4> >(&sign);
+  DbusSignature<Map<Integer<int32_t, 1, 2>, 3, 4>>(&sign);
   ASSERT_EQ(sign, "a{si}");
 }
 
 TEST(ValidatedTypes, TestMandatoryEnumDbusSignature) {
   std::string sign;
-  DbusSignature<Enum<TestEnum> >(&sign);
+  DbusSignature<Enum<TestEnum>>(&sign);
   ASSERT_EQ(sign, "i");
 }
 
 TEST(ValidatedTypes, TestOptionalEnumDbusSignature) {
   std::string sign;
-  DbusSignature<Optional<Enum<TestEnum> > >(&sign);
+  DbusSignature<Optional<Enum<TestEnum>>>(&sign);
   ASSERT_EQ(sign, "(bi)");
 }
 
 TEST(ValidatedTypes, TestOptionalFloatArrayDbusSignature) {
   std::string sign;
-  DbusSignature<Optional<Array<Float<1, 2>, 3, 4> > >(&sign);
+  DbusSignature<Optional<Array<Float<1, 2>, 3, 4>>>(&sign);
   ASSERT_EQ(sign, "(bad)");
 }
 
@@ -571,9 +560,7 @@ TEST(DbusMessageConstructionTest, DbusMessageConstruction) {
 class DbusTest : public testing::Test {
  public:
   dbus::MessageRef msgref;
-  DbusTest()
-      : msgref(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL)) {
-  }
+  DbusTest() : msgref(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL)) {}
 };
 
 TEST_F(DbusTest, DbusWriterConstructionTest) {
@@ -637,8 +624,8 @@ TEST_F(DbusTest, DbusMultipleParamsReadWrite) {
 TEST_F(DbusTest, DbusArrayTest) {
   {
     dbus::MessageWriter writer(msgref);
-    dbus::MessageWriter array_writer(&writer, dbus::kArray,
-    DBUS_TYPE_INT16_AS_STRING);
+    dbus::MessageWriter array_writer(
+        &writer, dbus::kArray, DBUS_TYPE_INT16_AS_STRING);
     array_writer.PutInt16(3);
     array_writer.PutInt16(4);
     array_writer.PutInt16(5);