Few manual style fixes for tests

libuavcan/test/dsdl_test/dsdl_uavcan_compilability.cpp

@@ -43,7 +43,8 @@ TEST(Dsdl, Streaming)
     ps.a.resize(2);
     os << ps << std::endl << "==========" << std::endl;
 
-    static const std::string Reference = "seq: 0\n"
+    static const std::string Reference =
+        "seq: 0\n"
         "sysid: 0\n"
         "compid: 0\n"
         "msgid: 0\n"

libuavcan/test/marshal/array.cpp

@@ -31,7 +31,11 @@ struct CustomType
     typename uavcan::StorageType<B>::Type b;
     typename uavcan::StorageType<C>::Type c;
 
-    CustomType() : a(), b(), c() { }
+    CustomType()
+        : a()
+        , b()
+        , c()
+    { }
 
     bool operator==(const CustomType& rhs) const { return a == rhs.a && b == rhs.b && c == rhs.c; }
 
@@ -39,19 +43,21 @@ struct CustomType
                       uavcan::TailArrayOptimizationMode tao_mode = uavcan::TailArrayOptEnabled)
     {
         int res = 0;
-
         res = A::encode(obj.a, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
-
+        }
         res = B::encode(obj.b, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
-
+        }
         res = C::encode(obj.c, codec, tao_mode);
         if (res <= 0)
+        {
             return res;
-
+        }
         return 1;
     }
 
@@ -59,19 +65,21 @@ struct CustomType
                       uavcan::TailArrayOptimizationMode tao_mode = uavcan::TailArrayOptEnabled)
     {
         int res = 0;
-
         res = A::decode(obj.a, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
-
+        }
         res = B::decode(obj.b, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
-
+        }
         res = C::decode(obj.c, codec, tao_mode);
         if (res <= 0)
+        {
             return res;
-
+        }
         return 1;
     }
 };
@@ -356,7 +364,10 @@ struct CustomType2
     typename uavcan::StorageType<A>::Type a;
     typename uavcan::StorageType<B>::Type b;
 
-    CustomType2() : a(), b() { }
+    CustomType2()
+        : a()
+        , b()
+    { }
 
     bool operator==(const CustomType2& rhs) const { return a == rhs.a && b == rhs.b; }
 
@@ -366,10 +377,14 @@ struct CustomType2
         int res = 0;
         res = A::encode(obj.a, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
+        }
         res = B::encode(obj.b, codec, tao_mode);
         if (res <= 0)
+        {
             return res;
+        }
         return 1;
     }
 
@@ -379,10 +394,14 @@ struct CustomType2
         int res = 0;
         res = A::decode(obj.a, codec, uavcan::TailArrayOptDisabled);
         if (res <= 0)
+        {
             return res;
+        }
         res = B::decode(obj.b, codec, tao_mode);
         if (res <= 0)
+        {
             return res;
+        }
         return 1;
     }
 };

libuavcan/test/marshal/float_spec.cpp

@@ -165,7 +165,8 @@ TEST(FloatSpec, Float16Representation)
 
     ASSERT_EQ(0, F16S::encode(0, sc_wr, uavcan::TailArrayOptDisabled));  // Out of buffer space now
 
-    static const std::string Reference =  // Keep in mind that this is LITTLE ENDIAN representation
+    // Keep in mind that this is LITTLE ENDIAN representation
+    static const std::string Reference =
         "00000000 00000000 " // 0.0
         "00000000 00111100 " // 1.0
         "00000000 11000000 " // -2.0

libuavcan/test/node/global_data_type_registry.cpp

@@ -7,52 +7,54 @@
 
 namespace
 {
-    struct DataTypeAMessage
-    {
-        enum { DefaultDataTypeID = 0 };
-        enum { DataTypeKind = uavcan::DataTypeKindMessage };
-        static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(123); }
-        static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
-    };
 
-    struct DataTypeAService
+struct DataTypeAMessage
-    {
+{
-        enum { DefaultDataTypeID = 0 };
+    enum { DefaultDataTypeID = 0 };
-        enum { DataTypeKind = uavcan::DataTypeKindService };
+    enum { DataTypeKind = uavcan::DataTypeKindMessage };
-        static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(789); }
+    static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(123); }
-        static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
+    static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
-    };
+};
 
-    struct DataTypeB
+struct DataTypeAService
-    {
+{
-        enum { DefaultDataTypeID = 42 };
+    enum { DefaultDataTypeID = 0 };
-        enum { DataTypeKind = uavcan::DataTypeKindMessage };
+    enum { DataTypeKind = uavcan::DataTypeKindService };
-        static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(456); }
+    static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(789); }
-        static const char* getDataTypeFullName() { return "my_namespace.DataTypeB"; }
+    static const char* getDataTypeFullName() { return "my_namespace.DataTypeA"; }
-    };
+};
 
-    struct DataTypeC
+struct DataTypeB
-    {
+{
-        enum { DefaultDataTypeID = 1023 };
+    enum { DefaultDataTypeID = 42 };
-        enum { DataTypeKind = uavcan::DataTypeKindMessage };
+    enum { DataTypeKind = uavcan::DataTypeKindMessage };
-        static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(654); }
+    static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(456); }
-        static const char* getDataTypeFullName() { return "foo.DataTypeC"; }
+    static const char* getDataTypeFullName() { return "my_namespace.DataTypeB"; }
-    };
+};
 
-    struct DataTypeD
+struct DataTypeC
-    {
+{
-        enum { DefaultDataTypeID = 43 };
+    enum { DefaultDataTypeID = 1023 };
-        enum { DataTypeKind = uavcan::DataTypeKindService };
+    enum { DataTypeKind = uavcan::DataTypeKindMessage };
-        static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(987); }
+    static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(654); }
-        static const char* getDataTypeFullName() { return "foo.DataTypeD"; }
+    static const char* getDataTypeFullName() { return "foo.DataTypeC"; }
-    };
+};
+
+struct DataTypeD
+{
+    enum { DefaultDataTypeID = 43 };
+    enum { DataTypeKind = uavcan::DataTypeKindService };
+    static uavcan::DataTypeSignature getDataTypeSignature() { return uavcan::DataTypeSignature(987); }
+    static const char* getDataTypeFullName() { return "foo.DataTypeD"; }
+};
+
+template <typename Type>
+uavcan::DataTypeDescriptor extractDescriptor(uint16_t dtid = Type::DefaultDataTypeID)
+{
+    return uavcan::DataTypeDescriptor(uavcan::DataTypeKind(Type::DataTypeKind), dtid,
+                                      Type::getDataTypeSignature(), Type::getDataTypeFullName());
+}
 
-    template <typename Type>
-    uavcan::DataTypeDescriptor extractDescriptor(uint16_t dtid = Type::DefaultDataTypeID)
-    {
-        return uavcan::DataTypeDescriptor(uavcan::DataTypeKind(Type::DataTypeKind), dtid,
-                                          Type::getDataTypeSignature(), Type::getDataTypeFullName());
-    }
 }
 
 

libuavcan/test/node/scheduler.cpp

@@ -18,6 +18,9 @@ struct TimerCallCounter
     void callB(const uavcan::TimerEvent& ev) { events_b.push_back(ev); }
 
     typedef uavcan::MethodBinder<TimerCallCounter*, void(TimerCallCounter::*)(const uavcan::TimerEvent&)> Binder;
+
+    Binder bindA() { return Binder(this, &TimerCallCounter::callA); }
+    Binder bindB() { return Binder(this, &TimerCallCounter::callB); }
 };
 
 /*
@@ -34,10 +37,8 @@ TEST(Scheduler, Timers)
      */
     {
         TimerCallCounter tcc;
-        uavcan::TimerEventForwarder<TimerCallCounter::Binder>
+        uavcan::TimerEventForwarder<TimerCallCounter::Binder> a(node, tcc.bindA());
-            a(node, TimerCallCounter::Binder(&tcc, &TimerCallCounter::callA));
+        uavcan::TimerEventForwarder<TimerCallCounter::Binder> b(node, tcc.bindB());
-        uavcan::TimerEventForwarder<TimerCallCounter::Binder>
-            b(node, TimerCallCounter::Binder(&tcc, &TimerCallCounter::callB));
 
         ASSERT_EQ(0, node.getScheduler().getDeadlineScheduler().getNumHandlers());
 

libuavcan/test/transport/frame.cpp

@@ -179,7 +179,8 @@ TEST(Frame, RxFrameParse)
 
     // Valid
     can_rx_frame.ts_mono = uavcan::MonotonicTime::fromUSec(1);  // Zero is not allowed
-    can_rx_frame.id = CanFrame::FlagEFF |
+    can_rx_frame.id =
+        CanFrame::FlagEFF |
         (2 << 0)   |      //    Transfer ID
         (1 << 3)   |      //    Last Frame
         (29 << 4)  |      //    Frame Index