Uncrustified test headers

libuavcan/test/clock.hpp

@@ -19,10 +19,10 @@ public:
     bool preserve_utc;
 
     SystemClockMock(uint64_t initial = 0)
-    : monotonic(initial)
-    , utc(initial)
-    , monotonic_auto_advance(0)
-    , preserve_utc(false)
+        : monotonic(initial)
+        , utc(initial)
+        , monotonic_auto_advance(0)
+        , preserve_utc(false)
     { }
 
     void advance(uint64_t usec) const

libuavcan/test/node/test_node.hpp

@@ -18,8 +18,8 @@ struct TestNode : public uavcan::INode
     uavcan::Scheduler scheduler;
 
     TestNode(uavcan::ICanDriver& can_driver, uavcan::ISystemClock& clock_driver, uavcan::NodeID self_node_id)
-    : otr(poolmgr)
-    , scheduler(can_driver, poolmgr, clock_driver, otr)
+        : otr(poolmgr)
+        , scheduler(can_driver, poolmgr, clock_driver, otr)
     {
         poolmgr.addPool(&pool);
         setNodeID(self_node_id);
@@ -45,8 +45,8 @@ struct PairableCanDriver : public uavcan::ICanDriver, public uavcan::ICanIface
     std::queue<uavcan::CanFrame> loopback_queue;
 
     PairableCanDriver(uavcan::ISystemClock& clock)
-    : clock(clock)
-    , other(NULL)
+        : clock(clock)
+        , other(NULL)
     { }
 
     void linkTogether(PairableCanDriver* with)
@@ -58,7 +58,9 @@ struct PairableCanDriver : public uavcan::ICanDriver, public uavcan::ICanIface
     uavcan::ICanIface* getIface(int iface_index)
     {
         if (iface_index == 0)
+        {
             return this;
+        }
         return NULL;
     }
 
@@ -73,10 +75,14 @@ struct PairableCanDriver : public uavcan::ICanDriver, public uavcan::ICanIface
         }
 
         if (inout_masks.read || inout_masks.write)
+        {
             return 1;
+        }
 
         while (clock.getMonotonic() < blocking_deadline)
+        {
             usleep(1000);
+        }
 
         return 0;
     }
@@ -131,19 +137,19 @@ struct InterlinkedTestNodes
     TestNode b;
 
     InterlinkedTestNodes(uavcan::NodeID nid_first, uavcan::NodeID nid_second)
-    : can_a(clock_a)
-    , can_b(clock_b)
-    , a(can_a, clock_a, nid_first)
-    , b(can_b, clock_b, nid_second)
+        : can_a(clock_a)
+        , can_b(clock_b)
+        , a(can_a, clock_a, nid_first)
+        , b(can_b, clock_b, nid_second)
     {
         can_a.linkTogether(&can_b);
     }
 
     InterlinkedTestNodes()
-    : can_a(clock_a)
-    , can_b(clock_b)
-    , a(can_a, clock_a, 1)
-    , b(can_b, clock_b, 2)
+        : can_a(clock_a)
+        , can_b(clock_b)
+        , a(can_a, clock_a, 1)
+        , b(can_b, clock_b, 2)
     {
         can_a.linkTogether(&can_b);
     }
@@ -158,10 +164,14 @@ struct InterlinkedTestNodes
             int ret = -1;
             ret = a.spin(uavcan::MonotonicDuration::fromMSec(1));
             if (ret < 0)
+            {
                 return ret;
+            }
             ret = b.spin(uavcan::MonotonicDuration::fromMSec(1));
             if (ret < 0)
+            {
                 return ret;
+            }
         }
         return 0;
     }

libuavcan/test/protocol/helpers.hpp

@@ -24,7 +24,7 @@ public:
     std::auto_ptr<ReceivedDataStructType> msg;
 
     typedef uavcan::MethodBinder<SubscriptionCollector*,
-        void (SubscriptionCollector::*)(const ReceivedDataStructType&)> Binder;
+                                 void (SubscriptionCollector::*)(const ReceivedDataStructType&)> Binder;
 
     Binder bind() { return Binder(this, &SubscriptionCollector::handler); }
 };
@@ -40,7 +40,7 @@ struct SubscriberWithCollector
     Subscriber subscriber;
 
     SubscriberWithCollector(uavcan::INode& node)
-    : subscriber(node)
+        : subscriber(node)
     { }
 
     int start() { return subscriber.start(collector.bind()); }
@@ -61,7 +61,7 @@ public:
     std::auto_ptr<ResultType> result;
 
     typedef uavcan::MethodBinder<ServiceCallResultCollector*,
-        void (ServiceCallResultCollector::*)(const ResultType&)> Binder;
+                                 void (ServiceCallResultCollector::*)(const ResultType&)> Binder;
 
     Binder bind() { return Binder(this, &ServiceCallResultCollector::handler); }
 };
@@ -77,7 +77,7 @@ struct ServiceClientWithCollector
     ServiceClient client;
 
     ServiceClientWithCollector(uavcan::INode& node)
-    : client(node)
+        : client(node)
     { }
 
     int call(uavcan::NodeID node_id, const typename DataType::Request& request)
@@ -86,4 +86,3 @@ struct ServiceClientWithCollector
         return client.call(node_id, request);
     }
 };
-

libuavcan/test/transport/can/can.hpp

@@ -24,13 +24,13 @@ public:
         uavcan::MonotonicTime time;
 
         FrameWithTime(const uavcan::CanFrame& frame, uavcan::MonotonicTime time)
-        : frame(frame)
-        , time(time)
+            : frame(frame)
+            , time(time)
         { }
 
         FrameWithTime(const uavcan::CanFrame& frame, uint64_t time_usec)
-        : frame(frame)
-        , time(uavcan::MonotonicTime::fromUSec(time_usec))
+            : frame(frame)
+            , time(uavcan::MonotonicTime::fromUSec(time_usec))
         { }
     };
 
@@ -45,12 +45,12 @@ public:
     bool enable_utc_timestamping;
 
     CanIfaceMock(uavcan::ISystemClock& iclock)
-    : writeable(true)
-    , tx_failure(false)
-    , rx_failure(false)
-    , num_errors(0)
-    , iclock(iclock)
-    , enable_utc_timestamping(false)
+        : writeable(true)
+        , tx_failure(false)
+        , rx_failure(false)
+        , num_errors(0)
+        , iclock(iclock)
+        , enable_utc_timestamping(false)
     { }
 
     void pushRx(const uavcan::CanFrame& frame)
@@ -99,12 +99,18 @@ public:
         assert(this);
         EXPECT_TRUE(writeable);        // Shall never be called when not writeable
         if (tx_failure)
+        {
             return -1;
+        }
         if (!writeable)
+        {
             return 0;
+        }
         tx.push(FrameWithTime(frame, tx_deadline));
         if (flags & uavcan::CanIOFlagLoopback)
+        {
             loopback.push(FrameWithTime(frame, iclock.getMonotonic()));
+        }
         return 1;
     }
 
@@ -117,9 +123,13 @@ public:
         {
             EXPECT_TRUE(rx.size());        // Shall never be called when not readable
             if (rx_failure)
+            {
                 return -1;
+            }
             if (rx.empty())
+            {
                 return 0;
+            }
             const FrameWithTime frame = rx.front();
             rx.pop();
             out_frame = frame.frame;
@@ -153,9 +163,9 @@ public:
     bool select_failure;
 
     CanDriverMock(int num_ifaces, uavcan::ISystemClock& iclock)
-    : ifaces(num_ifaces, CanIfaceMock(iclock))
-    , iclock(iclock)
-    , select_failure(false)
+        : ifaces(num_ifaces, CanIfaceMock(iclock))
+        , iclock(iclock)
+        , select_failure(false)
     { }
 
     int select(uavcan::CanSelectMasks& inout_masks, uavcan::MonotonicTime deadline)
@@ -164,7 +174,9 @@ public:
         //std::cout << "Write/read masks: " << inout_write_iface_mask << "/" << inout_read_iface_mask << std::endl;
 
         if (select_failure)
+        {
             return -1;
+        }
 
         const int valid_iface_mask = (1 << getNumIfaces()) - 1;
         EXPECT_FALSE(inout_masks.write & ~valid_iface_mask);
@@ -176,9 +188,13 @@ public:
         {
             const int mask = 1 << i;
             if ((inout_masks.write & mask) && ifaces.at(i).writeable)
+            {
                 out_write_mask |= mask;
+            }
             if ((inout_masks.read & mask) && (ifaces.at(i).rx.size() || ifaces.at(i).loopback.size()))
+            {
                 out_read_mask |= mask;
+            }
         }
         inout_masks.write = out_write_mask;
         inout_masks.read = out_read_mask;
@@ -190,12 +206,16 @@ public:
             if (mock)
             {
                 if (diff.isPositive())
+                {
                     mock->advance(diff.toUSec());   // Emulating timeout
+                }
             }
             else
             {
                 if (diff.isPositive())
+                {
                     usleep(diff.toUSec());
+                }
             }
             return 0;
         }

libuavcan/test/transport/transfer_test_helpers.hpp

@@ -25,13 +25,13 @@ struct Transfer
     std::string payload;
 
     Transfer(const uavcan::IncomingTransfer& tr, const uavcan::DataTypeDescriptor& data_type)
-    : ts_monotonic(tr.getMonotonicTimestamp())
-    , ts_utc(tr.getUtcTimestamp())
-    , transfer_type(tr.getTransferType())
-    , transfer_id(tr.getTransferID())
-    , src_node_id(tr.getSrcNodeID())
-    , dst_node_id() // default is invalid
-    , data_type(data_type)
+        : ts_monotonic(tr.getMonotonicTimestamp())
+        , ts_utc(tr.getUtcTimestamp())
+        , transfer_type(tr.getTransferType())
+        , transfer_id(tr.getTransferID())
+        , src_node_id(tr.getSrcNodeID())
+        , dst_node_id() // default is invalid
+        , data_type(data_type)
     {
         unsigned int offset = 0;
         while (true)
@@ -44,7 +44,9 @@ struct Transfer
                 exit(1);
             }
             if (res == 0)
+            {
                 break;
+            }
             payload += std::string(reinterpret_cast<const char*>(buf), res);
             offset += res;
         }
@@ -53,27 +55,27 @@ struct Transfer
     Transfer(uavcan::MonotonicTime ts_monotonic, uavcan::UtcTime ts_utc, uavcan::TransferType transfer_type,
              uavcan::TransferID transfer_id, uavcan::NodeID src_node_id, uavcan::NodeID dst_node_id,
              const std::string& payload, const uavcan::DataTypeDescriptor& data_type)
-    : ts_monotonic(ts_monotonic)
-    , ts_utc(ts_utc)
-    , transfer_type(transfer_type)
-    , transfer_id(transfer_id)
-    , src_node_id(src_node_id)
-    , dst_node_id(dst_node_id)
-    , data_type(data_type)
-    , payload(payload)
+        : ts_monotonic(ts_monotonic)
+        , ts_utc(ts_utc)
+        , transfer_type(transfer_type)
+        , transfer_id(transfer_id)
+        , src_node_id(src_node_id)
+        , dst_node_id(dst_node_id)
+        , data_type(data_type)
+        , payload(payload)
     { }
 
     Transfer(uint64_t ts_monotonic, uint64_t ts_utc, uavcan::TransferType transfer_type,
              uavcan::TransferID transfer_id, uavcan::NodeID src_node_id, uavcan::NodeID dst_node_id,
              const std::string& payload, const uavcan::DataTypeDescriptor& data_type)
-    : ts_monotonic(uavcan::MonotonicTime::fromUSec(ts_monotonic))
-    , ts_utc(uavcan::UtcTime::fromUSec(ts_utc))
-    , transfer_type(transfer_type)
-    , transfer_id(transfer_id)
-    , src_node_id(src_node_id)
-    , dst_node_id(dst_node_id)
-    , data_type(data_type)
-    , payload(payload)
+        : ts_monotonic(uavcan::MonotonicTime::fromUSec(ts_monotonic))
+        , ts_utc(uavcan::UtcTime::fromUSec(ts_utc))
+        , transfer_type(transfer_type)
+        , transfer_id(transfer_id)
+        , src_node_id(src_node_id)
+        , dst_node_id(dst_node_id)
+        , data_type(data_type)
+        , payload(payload)
     { }
 
     bool operator==(const Transfer& rhs) const
@@ -93,13 +95,13 @@ struct Transfer
     {
         std::ostringstream os;
         os << "ts_m="     << ts_monotonic
-            << " ts_utc=" << ts_utc
-            << " tt="     << transfer_type
-            << " tid="    << int(transfer_id.get())
-            << " snid="   << int(src_node_id.get())
-            << " dnid="   << int(dst_node_id.get())
-            << " dtid="   << int(data_type.getID().get())
-            << "\n\t'" << payload << "'";
+           << " ts_utc=" << ts_utc
+           << " tt="     << transfer_type
+           << " tid="    << int(transfer_id.get())
+           << " snid="   << int(src_node_id.get())
+           << " dnid="   << int(dst_node_id.get())
+           << " dtid="   << int(data_type.getID().get())
+           << "\n\t'" << payload << "'";
         return os.str();
     }
 };
@@ -118,7 +120,7 @@ class TestListener : public uavcan::TransferListener<MAX_BUF_SIZE, NUM_STATIC_BU
 
 public:
     TestListener(const uavcan::DataTypeDescriptor& data_type, uavcan::IAllocator& allocator)
-    : Base(data_type, allocator)
+        : Base(data_type, allocator)
     { }
 
     void handleIncomingTransfer(uavcan::IncomingTransfer& transfer)
@@ -143,8 +145,8 @@ public:
         if (!res)
         {
             std::cout << "TestSubscriber: Transfer mismatch:\n"
-                << "Expected: " << reference.toString() << "\n"
-                << "Received: " << tr.toString() << std::endl;
+                      << "Expected: " << reference.toString() << "\n"
+                      << "Received: " << tr.toString() << std::endl;
         }
         return res;
     }
@@ -163,13 +165,17 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
     switch (transfer.transfer_type)
     {
     case uavcan::TransferTypeMessageBroadcast:
+    {
         need_crc = transfer.payload.length() > sizeof(uavcan::CanFrame::data);
         break;
+    }
     case uavcan::TransferTypeServiceResponse:
     case uavcan::TransferTypeServiceRequest:
     case uavcan::TransferTypeMessageUnicast:
+    {
         need_crc = transfer.payload.length() > (sizeof(uavcan::CanFrame::data) - 1);
         break;
+    }
     default:
         std::cerr << "X_X" << std::endl;
         std::exit(1);
@@ -206,7 +212,9 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
             std::exit(1);
         }
         if (spres == bytes_left)
+        {
             frm.makeLast();
+        }
 
         offset += spres;
         EXPECT_GE(uavcan::Frame::MaxIndex, frame_index);
@@ -218,7 +226,9 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
 
         output.push_back(rxfrm);
         if (frm.isLast())
+        {
             break;
+        }
     }
     return output;
 }
@@ -240,7 +250,7 @@ class IncomingTransferEmulatorBase
 
 public:
     IncomingTransferEmulatorBase(uavcan::NodeID dst_node_id)
-    : dst_node_id_(dst_node_id)
+        : dst_node_id_(dst_node_id)
     { }
 
     virtual ~IncomingTransferEmulatorBase() { }
@@ -251,9 +261,9 @@ public:
     {
         ts_ += uavcan::MonotonicDuration::fromUSec(100);
         const uavcan::UtcTime utc = uavcan::UtcTime::fromUSec(ts_.toUSec() + 1000000000ul);
-        const uavcan::NodeID dst_node_id = (transfer_type == uavcan::TransferTypeMessageBroadcast)
-                    ? uavcan::NodeID::Broadcast
-                    : (dst_node_id_override.isValid() ? dst_node_id_override : dst_node_id_);
+        const uavcan::NodeID dst_node_id = (transfer_type == uavcan::TransferTypeMessageBroadcast) ?
+                                           uavcan::NodeID::Broadcast :
+                                           (dst_node_id_override.isValid() ? dst_node_id_override : dst_node_id_);
         const Transfer tr(ts_, utc, transfer_type, tid_, source_node_id, dst_node_id, payload, type);
         tid_.increment();
         return tr;
@@ -271,14 +281,18 @@ public:
             for (std::vector<std::vector<uavcan::RxFrame> >::const_iterator it = sers.begin(); it != sers.end(); ++it)
             {
                 if (it->size() <= index)
+                {
                     continue;
+                }
                 all_empty = false;
                 std::cout << "Incoming Transfer Emulator: Sending: " << it->at(index).toString() << std::endl;
                 sendOneFrame(it->at(index));
             }
             index++;
             if (all_empty)
+            {
                 break;
+            }
         }
     }
 
@@ -286,7 +300,9 @@ public:
     {
         std::vector<std::vector<uavcan::RxFrame> > sers;
         while (num_transfers--)
+        {
             sers.push_back(serializeTransfer(*transfers++));
+        }
         send(sers);
     }