fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-27 15:53:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Style fix: All constants are CamelCase now

Browse Source
This commit is contained in:
Pavel Kirienko
2014-02-21 18:45:23 +04:00
parent a155e6f859
commit 47a2b01a14
41 changed files with 473 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libuavcan/test/can_driver.cpp
+5 -5
View File
@@ -14,7 +14,7 @@ TEST(CanFrame, FrameProperties)
EXPECT_FALSE(makeCanFrame(0, "", STD).isRemoteTransmissionRequest());
uavcan::CanFrame frame = makeCanFrame(123, "", STD);
frame.id |= uavcan::CanFrame::FLAG_RTR;
frame.id |= uavcan::CanFrame::FlagRTR;
EXPECT_TRUE(frame.isRemoteTransmissionRequest());
}
@@ -22,17 +22,17 @@ TEST(CanFrame, ToString)
{
uavcan::CanFrame frame = makeCanFrame(123, "\x01\x02\x03\x04""1234", EXT);
EXPECT_EQ("0x0000007b 01 02 03 04 31 32 33 34 '....1234'", frame.toString());
EXPECT_TRUE(frame.toString() == frame.toString(uavcan::CanFrame::STR_ALIGNED));
EXPECT_TRUE(frame.toString() == frame.toString(uavcan::CanFrame::StrAligned));
frame = makeCanFrame(123, "z", EXT);
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString(uavcan::CanFrame::STR_ALIGNED));
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ("0x0000007b 7a 'z'", frame.toString());
EXPECT_EQ(" 0x141 61 62 63 64 aa bb cc dd 'abcd....'",
makeCanFrame(321, "abcd""\xaa\xbb\xcc\xdd", STD).toString(uavcan::CanFrame::STR_ALIGNED));
makeCanFrame(321, "abcd""\xaa\xbb\xcc\xdd", STD).toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ(" 0x100 ''",
makeCanFrame(256, "", STD).toString(uavcan::CanFrame::STR_ALIGNED));
makeCanFrame(256, "", STD).toString(uavcan::CanFrame::StrAligned));
EXPECT_EQ("0x100 ''",
makeCanFrame(256, "", STD).toString());
libuavcan/test/common.hpp
+1 -1
View File
@@ -50,6 +50,6 @@ public:
enum FrameType { STD, EXT };
static uavcan::CanFrame makeCanFrame(uint32_t id, const std::string& str_data, FrameType type)
{
id |= (type == EXT) ? uavcan::CanFrame::FLAG_EFF : 0;
id |= (type == EXT) ? uavcan::CanFrame::FlagEFF : 0;
return uavcan::CanFrame(id, reinterpret_cast<const uint8_t*>(str_data.c_str()), str_data.length());
}
libuavcan/test/map.cpp
+1 -1
View File
@@ -30,7 +30,7 @@ TEST(Map, Basic)
using uavcan::Map;
static const int POOL_BLOCKS = 3;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<2> poolmgr;
poolmgr.addPool(&pool);
libuavcan/test/transport/can/io.cpp
+13 -13
View File
@@ -12,8 +12,8 @@ static bool rxFrameEquals(const uavcan::CanRxFrame& rxframe, const uavcan::CanFr
if (static_cast<const uavcan::CanFrame&>(rxframe) != frame)
{
std::cout << "Frame mismatch:\n"
<< " " << rxframe.toString(uavcan::CanFrame::STR_ALIGNED) << "\n"
<< " " << frame.toString(uavcan::CanFrame::STR_ALIGNED) << std::endl;
<< " " << rxframe.toString(uavcan::CanFrame::StrAligned) << "\n"
<< " " << frame.toString(uavcan::CanFrame::StrAligned) << std::endl;
}
return (static_cast<const uavcan::CanFrame&>(rxframe) == frame) &&
(rxframe.ts_monotonic == timestamp) && (rxframe.iface_index == iface_index);
@@ -127,11 +127,11 @@ TEST(CanIOManager, Transmission)
/*
* Simple transmission
*/
EXPECT_EQ(2, iomgr.send(frames[0], 100, 0, ALL_IFACES_MASK, CanTxQueue::VOLATILE)); // To both
EXPECT_EQ(2, iomgr.send(frames[0], 100, 0, ALL_IFACES_MASK, CanTxQueue::Volatile)); // To both
EXPECT_TRUE(driver.ifaces.at(0).matchAndPopTx(frames[0], 100));
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 100));
EXPECT_EQ(1, iomgr.send(frames[1], 200, 100, 2, CanTxQueue::PERSISTENT)); // To #1
EXPECT_EQ(1, iomgr.send(frames[1], 200, 100, 2, CanTxQueue::Persistent)); // To #1
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[1], 200));
EXPECT_EQ(0, clockmock.monotonic);
@@ -148,7 +148,7 @@ TEST(CanIOManager, Transmission)
// Sending to both, #0 blocked
driver.ifaces.at(0).writeable = false;
EXPECT_LT(0, iomgr.send(frames[0], 201, 200, ALL_IFACES_MASK, CanTxQueue::PERSISTENT));
EXPECT_LT(0, iomgr.send(frames[0], 201, 200, ALL_IFACES_MASK, CanTxQueue::Persistent));
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 201));
EXPECT_EQ(200, clockmock.monotonic);
EXPECT_EQ(200, clockmock.utc);
@@ -158,11 +158,11 @@ TEST(CanIOManager, Transmission)
// Sending to both, both blocked
driver.ifaces.at(1).writeable = false;
EXPECT_EQ(0, iomgr.send(frames[1], 777, 300, ALL_IFACES_MASK, CanTxQueue::VOLATILE));
EXPECT_EQ(0, iomgr.send(frames[1], 777, 300, ALL_IFACES_MASK, CanTxQueue::Volatile));
EXPECT_EQ(3, pool.getNumUsedBlocks()); // Total 3 frames in TX queue now
// Sending to #0, both blocked
EXPECT_EQ(0, iomgr.send(frames[2], 888, 400, 1, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[2], 888, 400, 1, CanTxQueue::Persistent));
EXPECT_EQ(400, clockmock.monotonic);
EXPECT_EQ(400, clockmock.utc);
EXPECT_TRUE(driver.ifaces.at(0).tx.empty());
@@ -176,7 +176,7 @@ TEST(CanIOManager, Transmission)
// Sending to #1, both writeable
driver.ifaces.at(0).writeable = true;
driver.ifaces.at(1).writeable = true;
EXPECT_LT(0, iomgr.send(frames[0], 999, 500, 2, CanTxQueue::PERSISTENT)); // One frame per each iface will be sent
EXPECT_LT(0, iomgr.send(frames[0], 999, 500, 2, CanTxQueue::Persistent)); // One frame per each iface will be sent
EXPECT_TRUE(driver.ifaces.at(0).matchAndPopTx(frames[1], 777)); // Note that frame[0] on iface #0 has expired
EXPECT_TRUE(driver.ifaces.at(1).matchAndPopTx(frames[0], 999)); // In different order due to prioritization
EXPECT_TRUE(driver.ifaces.at(0).tx.empty());
@@ -202,9 +202,9 @@ TEST(CanIOManager, Transmission)
driver.ifaces.at(1).writeable = false;
// Sending 5 frames, one will be rejected
EXPECT_EQ(0, iomgr.send(frames[2], 2222, 1000, ALL_IFACES_MASK, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[0], 3333, 1100, 2, CanTxQueue::PERSISTENT));
EXPECT_EQ(0, iomgr.send(frames[1], 4444, 1200, ALL_IFACES_MASK, CanTxQueue::VOLATILE)); // One frame kicked here
EXPECT_EQ(0, iomgr.send(frames[2], 2222, 1000, ALL_IFACES_MASK, CanTxQueue::Persistent));
EXPECT_EQ(0, iomgr.send(frames[0], 3333, 1100, 2, CanTxQueue::Persistent));
EXPECT_EQ(0, iomgr.send(frames[1], 4444, 1200, ALL_IFACES_MASK, CanTxQueue::Volatile)); // One frame kicked here
// State checks
EXPECT_EQ(4, pool.getNumUsedBlocks()); // TX queue is full
@@ -247,7 +247,7 @@ TEST(CanIOManager, Transmission)
// Select failure
driver.select_failure = true;
EXPECT_EQ(-1, iomgr.receive(rx_frame, 2000));
EXPECT_EQ(-1, iomgr.send(frames[0], 2100, 2000, ALL_IFACES_MASK, CanTxQueue::VOLATILE));
EXPECT_EQ(-1, iomgr.send(frames[0], 2100, 2000, ALL_IFACES_MASK, CanTxQueue::Volatile));
EXPECT_EQ(1200, clockmock.monotonic);
EXPECT_EQ(1200, clockmock.utc);
@@ -257,7 +257,7 @@ TEST(CanIOManager, Transmission)
driver.ifaces.at(1).writeable = true;
driver.ifaces.at(0).tx_failure = true;
driver.ifaces.at(1).tx_failure = true;
EXPECT_GE(0, iomgr.send(frames[0], 2200, 0, ALL_IFACES_MASK, CanTxQueue::PERSISTENT)); // Non-blocking - return < 0
EXPECT_GE(0, iomgr.send(frames[0], 2200, 0, ALL_IFACES_MASK, CanTxQueue::Persistent)); // Non-blocking - return < 0
ASSERT_EQ(2, pool.getNumUsedBlocks()); // Untransmitted frames will be buffered
libuavcan/test/transport/can/tx_queue.cpp
+17 -17
View File
@@ -33,22 +33,22 @@ static bool isInQueue(uavcan::CanTxQueue& queue, const uavcan::CanFrame& frame)
TEST(CanTxQueue, Qos)
{
uavcan::CanTxQueue::Entry e1(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::VOLATILE);
uavcan::CanTxQueue::Entry e2(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::VOLATILE);
uavcan::CanTxQueue::Entry e1(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::Volatile);
uavcan::CanTxQueue::Entry e2(makeCanFrame(100, "", EXT), 1000, uavcan::CanTxQueue::Volatile);
EXPECT_FALSE(e1.qosHigherThan(e2));
EXPECT_FALSE(e2.qosHigherThan(e1));
EXPECT_FALSE(e1.qosLowerThan(e2));
EXPECT_FALSE(e2.qosLowerThan(e1));
e2.qos = uavcan::CanTxQueue::PERSISTENT;
e2.qos = uavcan::CanTxQueue::Persistent;
EXPECT_FALSE(e1.qosHigherThan(e2));
EXPECT_TRUE(e2.qosHigherThan(e1));
EXPECT_TRUE(e1.qosLowerThan(e2));
EXPECT_FALSE(e2.qosLowerThan(e1));
e1.qos = uavcan::CanTxQueue::PERSISTENT;
e1.qos = uavcan::CanTxQueue::Persistent;
e1.frame.id -= 1;
EXPECT_TRUE(e1.qosHigherThan(e2));
@@ -86,7 +86,7 @@ TEST(CanTxQueue, TxQueue)
/*
* Priority insertion
*/
queue.push(f4, 100, CanTxQueue::PERSISTENT);
queue.push(f4, 100, CanTxQueue::Persistent);
EXPECT_FALSE(queue.isEmpty());
EXPECT_EQ(1, pool32.getNumUsedBlocks());
EXPECT_EQ(f4, queue.peek()->frame);
@@ -94,13 +94,13 @@ TEST(CanTxQueue, TxQueue)
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f4)); // Equal
EXPECT_FALSE(queue.topPriorityHigherOrEqual(f3));
queue.push(f3, 200, CanTxQueue::PERSISTENT);
queue.push(f3, 200, CanTxQueue::Persistent);
EXPECT_EQ(f3, queue.peek()->frame);
queue.push(f0, 300, CanTxQueue::VOLATILE);
queue.push(f0, 300, CanTxQueue::Volatile);
EXPECT_EQ(f0, queue.peek()->frame);
queue.push(f1, 400, CanTxQueue::VOLATILE);
queue.push(f1, 400, CanTxQueue::Volatile);
EXPECT_EQ(f0, queue.peek()->frame); // Still f0, since it is highest
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f0)); // Equal
EXPECT_TRUE(queue.topPriorityHigherOrEqual(f1));
@@ -125,28 +125,28 @@ TEST(CanTxQueue, TxQueue)
* QoS
*/
EXPECT_FALSE(isInQueue(queue, f2));
queue.push(f2, 100, CanTxQueue::VOLATILE); // Non preempting, will be rejected
queue.push(f2, 100, CanTxQueue::Volatile); // Non preempting, will be rejected
EXPECT_FALSE(isInQueue(queue, f2));
queue.push(f2, 500, CanTxQueue::PERSISTENT); // Will override f1 (f3 and f4 are presistent)
queue.push(f2, 500, CanTxQueue::Persistent); // Will override f1 (f3 and f4 are presistent)
EXPECT_TRUE(isInQueue(queue, f2));
EXPECT_FALSE(isInQueue(queue, f1));
EXPECT_EQ(4, getQueueLength(queue));
EXPECT_EQ(2, queue.getNumRejectedFrames());
EXPECT_EQ(f0, queue.peek()->frame); // Check the priority
queue.push(f5, 600, CanTxQueue::PERSISTENT); // Will override f0 (rest are presistent)
queue.push(f5, 600, CanTxQueue::Persistent); // Will override f0 (rest are presistent)
EXPECT_TRUE(isInQueue(queue, f5));
EXPECT_FALSE(isInQueue(queue, f0));
EXPECT_EQ(f2, queue.peek()->frame); // Check the priority
// No volatile frames left now
queue.push(f5a, 700, CanTxQueue::PERSISTENT); // Will override f5 (same frame, same QoS)
queue.push(f5a, 700, CanTxQueue::Persistent); // Will override f5 (same frame, same QoS)
EXPECT_TRUE(isInQueue(queue, f5a));
EXPECT_FALSE(isInQueue(queue, f5));
queue.push(f6, 700, CanTxQueue::PERSISTENT); // Will be rejected (lowest QoS)
queue.push(f6, 700, CanTxQueue::Persistent); // Will be rejected (lowest QoS)
EXPECT_FALSE(isInQueue(queue, f6));
EXPECT_FALSE(queue.topPriorityHigherOrEqual(f0));
@@ -165,19 +165,19 @@ TEST(CanTxQueue, TxQueue)
* Expiration
*/
clockmock.monotonic = 101;
queue.push(f0, 800, CanTxQueue::VOLATILE); // Will replace f4 which is expired now
queue.push(f0, 800, CanTxQueue::Volatile); // Will replace f4 which is expired now
EXPECT_TRUE(isInQueue(queue, f0));
EXPECT_FALSE(isInQueue(queue, f4));
EXPECT_EQ(6, queue.getNumRejectedFrames());
clockmock.monotonic = 1001;
queue.push(f5, 2000, CanTxQueue::VOLATILE); // Entire queue is expired
queue.push(f5, 2000, CanTxQueue::Volatile); // Entire queue is expired
EXPECT_TRUE(isInQueue(queue, f5));
EXPECT_EQ(1, getQueueLength(queue)); // Just one entry left - f5
EXPECT_EQ(1, pool32.getNumUsedBlocks()); // Make sure there is no leaks
EXPECT_EQ(10, queue.getNumRejectedFrames());
queue.push(f0, 1000, CanTxQueue::PERSISTENT); // This entry is already expired
queue.push(f0, 1000, CanTxQueue::Persistent); // This entry is already expired
EXPECT_EQ(1, getQueueLength(queue));
EXPECT_EQ(1, pool32.getNumUsedBlocks());
EXPECT_EQ(11, queue.getNumRejectedFrames());
@@ -185,7 +185,7 @@ TEST(CanTxQueue, TxQueue)
/*
* Removing
*/
queue.push(f4, 5000, CanTxQueue::VOLATILE);
queue.push(f4, 5000, CanTxQueue::Volatile);
EXPECT_EQ(2, getQueueLength(queue));
EXPECT_TRUE(isInQueue(queue, f4));
EXPECT_EQ(f4, queue.peek()->frame);
libuavcan/test/transport/dispatcher.cpp
+17 -17
View File
@@ -34,7 +34,7 @@ static const uavcan::NodeID SELF_NODE_ID(64);
TEST(Dispatcher, Reception)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -52,10 +52,10 @@ TEST(Dispatcher, Reception)
*/
static const uavcan::DataTypeDescriptor TYPES[4] =
{
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 2),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1)
makeDataType(uavcan::DataTypeKindMessage, 1),
makeDataType(uavcan::DataTypeKindMessage, 2),
makeDataType(uavcan::DataTypeKindService, 1),
makeDataType(uavcan::DataTypeKindService, 1)
};
typedef TestSubscriber<512, 2, 2> Subscriber;
@@ -92,16 +92,16 @@ TEST(Dispatcher, Reception)
const Transfer transfers[9] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 10, DATA[0], TYPES[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, DATA[1], TYPES[1]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 12, DATA[2], TYPES[2]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 13, DATA[3], TYPES[3]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 14, DATA[4], TYPES[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 15, DATA[5], TYPES[1]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 10, DATA[0], TYPES[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, DATA[1], TYPES[1]),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 12, DATA[2], TYPES[2]),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 13, DATA[3], TYPES[3]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 14, DATA[4], TYPES[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 15, DATA[5], TYPES[1]),
// Wrongly addressed:
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 10, DATA[0], TYPES[3], 100),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 11, DATA[1], TYPES[2], 101),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 12, DATA[2], TYPES[1], 102)
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 10, DATA[0], TYPES[3], 100),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 11, DATA[1], TYPES[2], 101),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 12, DATA[2], TYPES[1], 102)
};
/*
@@ -183,7 +183,7 @@ TEST(Dispatcher, Reception)
TEST(Dispatcher, Transmission)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -201,10 +201,10 @@ TEST(Dispatcher, Transmission)
// uint_fast16_t data_type_id, TransferType transfer_type, NodeID src_node_id, NodeID dst_node_id,
// uint_fast8_t frame_index, TransferID transfer_id, bool last_frame = false
uavcan::Frame frame(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, SELF_NODE_ID, 2, 0, 0, true);
uavcan::Frame frame(123, uavcan::TransferTypeMessageUnicast, SELF_NODE_ID, 2, 0, 0, true);
frame.setPayload(reinterpret_cast<const uint8_t*>("123"), 3);
ASSERT_EQ(2, dispatcher.send(frame, TX_DEADLINE, 0, uavcan::CanTxQueue::VOLATILE));
ASSERT_EQ(2, dispatcher.send(frame, TX_DEADLINE, 0, uavcan::CanTxQueue::Volatile));
/*
* Validation
libuavcan/test/transport/incoming_transfer.cpp
+1 -1
View File
@@ -10,7 +10,7 @@
static uavcan::RxFrame makeFrame()
{
uavcan::RxFrame frame(
uavcan::Frame(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, uavcan::NodeID::BROADCAST, 0, 1, true),
uavcan::Frame(123, uavcan::TransferTypeMessageBroadcast, 1, uavcan::NodeID::Broadcast, 0, 1, true),
123, 456, 0);
uint8_t data[8];
for (unsigned int i = 0; i < sizeof(data); i++)
libuavcan/test/transport/outgoing_transfer_registry.cpp
+5 -5
View File
@@ -18,11 +18,11 @@ TEST(OutgoingTransferRegistry, Basic)
static const int NUM_KEYS = 5;
const OutgoingTransferRegistryKey keys[NUM_KEYS] =
{
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 42),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 2),
OutgoingTransferRegistryKey(123, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 4),
OutgoingTransferRegistryKey(456, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 2)
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageUnicast, 42),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageBroadcast, 0),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeServiceRequest, 2),
OutgoingTransferRegistryKey(123, uavcan::TransferTypeMessageUnicast, 4),
OutgoingTransferRegistryKey(456, uavcan::TransferTypeServiceRequest, 2)
};
ASSERT_EQ(0, otr.accessOrCreate(keys[0], 1000000)->get());
libuavcan/test/transport/transfer.cpp
+28 -28
View File
@@ -13,7 +13,7 @@ TEST(Transfer, TransferID)
using uavcan::TransferID;
// Tests below are based on this assumption
ASSERT_EQ(8, 1 << TransferID::BITLEN);
ASSERT_EQ(8, 1 << TransferID::BitLen);
/*
* forwardDistance()
@@ -40,7 +40,7 @@ TEST(Transfer, TransferID)
TransferID tid;
for (int i = 0; i < 999; i++)
{
ASSERT_EQ(i & ((1 << TransferID::BITLEN) - 1), tid.get());
ASSERT_EQ(i & ((1 << TransferID::BitLen) - 1), tid.get());
const TransferID copy = tid;
tid.increment();
ASSERT_EQ(1, copy.forwardDistance(tid));
@@ -63,7 +63,7 @@ TEST(Transfer, FrameParseCompile)
(1 << 3) | // Last Frame
(29 << 4) | // Frame Index
(42 << 10) | // Source Node ID
(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) |
(uavcan::TransferTypeMessageBroadcast << 17) |
(456 << 19); // Data Type ID
const std::string payload_string = "hello";
@@ -72,7 +72,7 @@ TEST(Transfer, FrameParseCompile)
* Parse
*/
// Invalid CAN frames
ASSERT_FALSE(frame.parse(CanFrame(can_id | CanFrame::FLAG_RTR, (const uint8_t*)"", 0)));
ASSERT_FALSE(frame.parse(CanFrame(can_id | CanFrame::FlagRTR, (const uint8_t*)"", 0)));
ASSERT_FALSE(frame.parse(makeCanFrame(can_id, payload_string, STD)));
// Valid
@@ -82,7 +82,7 @@ TEST(Transfer, FrameParseCompile)
EXPECT_TRUE(frame.isLast());
EXPECT_EQ(29, frame.getIndex());
EXPECT_EQ(uavcan::NodeID(42), frame.getSrcNodeID());
EXPECT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, frame.getTransferType());
EXPECT_EQ(uavcan::TransferTypeMessageBroadcast, frame.getTransferType());
EXPECT_EQ(456, frame.getDataTypeID());
EXPECT_EQ(payload_string.length(), frame.getPayloadLen());
@@ -131,25 +131,25 @@ TEST(Transfer, FrameParsing)
/*
* SFT broadcast
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageBroadcast << 17) | (456 << 19);
ASSERT_TRUE(frame.parse(can));
ASSERT_TRUE(frame.isFirst());
ASSERT_TRUE(frame.isLast());
ASSERT_EQ(0, frame.getIndex());
ASSERT_EQ(NodeID(42), frame.getSrcNodeID());
ASSERT_EQ(NodeID::BROADCAST, frame.getDstNodeID());
ASSERT_EQ(NodeID::Broadcast, frame.getDstNodeID());
ASSERT_EQ(456, frame.getDataTypeID());
ASSERT_EQ(TransferID(2), frame.getTransferID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageBroadcast, frame.getTransferType());
ASSERT_EQ(sizeof(CanFrame::data), frame.getMaxPayloadLen());
/*
* SFT addressed
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can)); // No payload - failure
@@ -167,39 +167,39 @@ TEST(Transfer, FrameParsing)
ASSERT_EQ(NodeID(127), frame.getDstNodeID());
ASSERT_EQ(456, frame.getDataTypeID());
ASSERT_EQ(TransferID(2), frame.getTransferID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageUnicast, frame.getTransferType());
ASSERT_EQ(sizeof(CanFrame::data) - 1, frame.getMaxPayloadLen());
/*
* MFT invalid - unterminated transfer
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (0 << 3) | (Frame::INDEX_MAX << 4) | (42 << 10) |
(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (0 << 3) | (Frame::MaxIndex << 4) | (42 << 10) |
(uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can));
/*
* MFT invalid - invalid frame index
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (0 << 3) | (63 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (0 << 3) | (63 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can));
/*
* Malformed frames
*/
can.id = CanFrame::FLAG_EFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF |
(2 << 0) | (1 << 3) | (0 << 4) | (42 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
can.dlc = 3;
can.data[0] = 42;
ASSERT_FALSE(frame.parse(can)); // Src == Dst Node ID
can.data[0] = 41;
ASSERT_TRUE(frame.parse(can));
can.id = CanFrame::FLAG_EFF | // cppcheck-suppress duplicateExpression
(2 << 0) | (1 << 3) | (0 << 4) | (0 << 10) | (uavcan::TRANSFER_TYPE_MESSAGE_UNICAST << 17) | (456 << 19);
can.id = CanFrame::FlagEFF | // cppcheck-suppress duplicateExpression
(2 << 0) | (1 << 3) | (0 << 4) | (0 << 10) | (uavcan::TransferTypeMessageUnicast << 17) | (456 << 19);
ASSERT_FALSE(frame.parse(can)); // Broadcast Src Node ID
}
@@ -218,12 +218,12 @@ TEST(Transfer, RxFrameParse)
ASSERT_FALSE(rx_frame.parse(can_rx_frame));
// Valid
can_rx_frame.id = CanFrame::FLAG_EFF |
can_rx_frame.id = CanFrame::FlagEFF |
(2 << 0) | // Transfer ID
(1 << 3) | // Last Frame
(29 << 4) | // Frame Index
(42 << 10) | // Source Node ID
(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST << 17) |
(uavcan::TransferTypeMessageBroadcast << 17) |
(456 << 19); // Data Type ID
ASSERT_TRUE(rx_frame.parse(can_rx_frame));
@@ -233,14 +233,14 @@ TEST(Transfer, RxFrameParse)
can_rx_frame.ts_monotonic = 123;
can_rx_frame.iface_index = 2;
Frame frame(456, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, uavcan::NodeID::BROADCAST, 0, 0);
Frame frame(456, uavcan::TransferTypeMessageBroadcast, 1, uavcan::NodeID::Broadcast, 0, 0);
ASSERT_TRUE(frame.compile(can_rx_frame));
ASSERT_TRUE(rx_frame.parse(can_rx_frame));
ASSERT_EQ(123, rx_frame.getMonotonicTimestamp());
ASSERT_EQ(2, rx_frame.getIfaceIndex());
ASSERT_EQ(456, rx_frame.getDataTypeID());
ASSERT_EQ(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, rx_frame.getTransferType());
ASSERT_EQ(uavcan::TransferTypeMessageBroadcast, rx_frame.getTransferType());
}
@@ -254,9 +254,9 @@ TEST(Transfer, FrameToString)
EXPECT_EQ("dtid=0 tt=4 snid=255 dnid=255 idx=0 last=0 tid=0 payload=[] ts_m=0 ts_utc=0 iface=0", rx_frame.toString());
// RX frame max len
rx_frame = RxFrame(Frame(Frame::DATA_TYPE_ID_MAX, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST,
uavcan::NodeID::MAX, uavcan::NodeID::MAX - 1, Frame::INDEX_MAX,
uavcan::TransferID::MAX, true),
rx_frame = RxFrame(Frame(Frame::MaxDataTypeID, uavcan::TransferTypeMessageUnicast,
uavcan::NodeID::Max, uavcan::NodeID::Max - 1, Frame::MaxIndex,
uavcan::TransferID::Max, true),
0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 3);
uint8_t data[8];
libuavcan/test/transport/transfer_buffer.cpp
+10 -10
View File
@@ -75,7 +75,7 @@ static bool matchAgainstTestData(const uavcan::ITransferBuffer& tbb, unsigned in
TEST(TransferBuffer, TestDataValidation)
{
ASSERT_LE(4, TEST_DATA.length() / uavcan::MEM_POOL_BLOCK_SIZE);
ASSERT_LE(4, TEST_DATA.length() / uavcan::MemPoolBlockSize);
uint8_t local_buffer[50];
std::copy(TEST_DATA.begin(), TEST_DATA.begin() + sizeof(local_buffer), local_buffer);
ASSERT_FALSE(allEqual(local_buffer));
@@ -134,7 +134,7 @@ TEST(DynamicTransferBufferManagerEntry, Basic)
static const int MAX_SIZE = TEST_BUFFER_SIZE;
static const int POOL_BLOCKS = 8;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<2> poolmgr;
poolmgr.addPool(&pool);
@@ -234,7 +234,7 @@ TEST(TransferBufferManager, Basic)
using uavcan::ITransferBuffer;
static const int POOL_BLOCKS = 8;
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -242,18 +242,18 @@ TEST(TransferBufferManager, Basic)
std::auto_ptr<TransferBufferManagerType> mgr(new TransferBufferManagerType(poolmgr));
// Empty
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(127, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast)));
ASSERT_FALSE(mgr->access(TransferBufferManagerKey(127, uavcan::TransferTypeMessageUnicast)));
ITransferBuffer* tbb = NULL;
const TransferBufferManagerKey keys[5] =
{
TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST),
TransferBufferManagerKey(1, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST),
TransferBufferManagerKey(2, uavcan::TRANSFER_TYPE_SERVICE_REQUEST),
TransferBufferManagerKey(127, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE),
TransferBufferManagerKey(64, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST)
TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast),
TransferBufferManagerKey(1, uavcan::TransferTypeMessageBroadcast),
TransferBufferManagerKey(2, uavcan::TransferTypeServiceRequest),
TransferBufferManagerKey(127, uavcan::TransferTypeServiceResponse),
TransferBufferManagerKey(64, uavcan::TransferTypeMessageBroadcast)
};
// Static 0
libuavcan/test/transport/transfer_listener.cpp
+33 -33
View File
@@ -30,12 +30,12 @@ public:
TEST(TransferListener, BasicMFT)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
static const int NUM_POOL_BLOCKS = 12; // This number is just enough to pass the test
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * NUM_POOL_BLOCKS, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * NUM_POOL_BLOCKS, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
@@ -62,11 +62,11 @@ TEST(TransferListener, BasicMFT)
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, DATA[0]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, DATA[1]), // Same NID
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, DATA[2]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 3, DATA[3]),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 4, DATA[4]),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, DATA[0]),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, DATA[1]), // Same NID
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, DATA[2]),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 3, DATA[3]),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 4, DATA[4]),
};
/*
@@ -87,8 +87,8 @@ TEST(TransferListener, BasicMFT)
TEST(TransferListener, CrcFailure)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory
@@ -98,8 +98,8 @@ TEST(TransferListener, CrcFailure)
* Generating transfers with damaged payload (CRC is not valid)
*/
TransferListenerEmulator emulator(subscriber, type);
const Transfer tr_mft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, "abcd");
const Transfer tr_mft = emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, "abcd");
std::vector<uavcan::RxFrame> ser_mft = serializeTransfer(tr_mft);
std::vector<uavcan::RxFrame> ser_sft = serializeTransfer(tr_sft);
@@ -132,8 +132,8 @@ TEST(TransferListener, CrcFailure)
TEST(TransferListener, BasicSFT)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory. At all.
@@ -142,15 +142,15 @@ TEST(TransferListener, BasicSFT)
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, "123"),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, "456"), // Same NID
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, ""),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 3, "abc"),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 4, ""),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 2, ""), // New TT, ignored due to OOM
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "foo"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "123456789abc"),// Same as 2, not SFT - ignore
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, "bar"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, "123"),
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, "456"), // Same NID
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, ""),
emulator.makeTransfer(uavcan::TransferTypeServiceRequest, 3, "abc"),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 4, ""),
emulator.makeTransfer(uavcan::TransferTypeServiceResponse, 2, ""), // New TT, ignored due to OOM
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "foo"), // Same as 2, not ignored
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "123456789abc"),// Same as 2, not SFT - ignore
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 2, "bar"), // Same as 2, not ignored
};
emulator.send(transfers);
@@ -169,8 +169,8 @@ TEST(TransferListener, BasicSFT)
TEST(TransferListener, Cleanup)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr; // No dynamic memory
@@ -180,8 +180,8 @@ TEST(TransferListener, Cleanup)
* Generating transfers
*/
TransferListenerEmulator emulator(subscriber, type);
const Transfer tr_mft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 11, "abcd");
const Transfer tr_mft = emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 42, "123456789abcdefghik");
const Transfer tr_sft = emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 11, "abcd");
const std::vector<uavcan::RxFrame> ser_mft = serializeTransfer(tr_mft);
const std::vector<uavcan::RxFrame> ser_sft = serializeTransfer(tr_sft);
@@ -225,20 +225,20 @@ TEST(TransferListener, Cleanup)
TEST(TransferListener, MaximumTransferLength)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i | (i << 4);
uavcan::PoolManager<1> poolmgr;
TestSubscriber<uavcan::MAX_TRANSFER_PAYLOAD_LEN * 2, 2, 2> subscriber(type, poolmgr);
TestSubscriber<uavcan::MaxTransferPayloadLen * 2, 2, 2> subscriber(type, poolmgr);
static const std::string DATA_OK(uavcan::MAX_TRANSFER_PAYLOAD_LEN, 'z');
static const std::string DATA_OK(uavcan::MaxTransferPayloadLen, 'z');
TransferListenerEmulator emulator(subscriber, type);
const Transfer transfers[] =
{
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, DATA_OK),
emulator.makeTransfer(uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, DATA_OK)
emulator.makeTransfer(uavcan::TransferTypeMessageUnicast, 1, DATA_OK),
emulator.makeTransfer(uavcan::TransferTypeMessageBroadcast, 1, DATA_OK)
};
emulator.send(transfers);
libuavcan/test/transport/transfer_receiver.cpp
+30 -30
View File
@@ -29,8 +29,8 @@ struct RxFrameGenerator
uint8_t transfer_id, uint64_t ts_monotonic, uint64_t ts_utc = 0)
{
const uavcan::NodeID dst_nid =
(bufmgr_key.getTransferType() == uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST) ?
uavcan::NodeID::BROADCAST : TARGET_NODE_ID;
(bufmgr_key.getTransferType() == uavcan::TransferTypeMessageBroadcast) ?
uavcan::NodeID::Broadcast : TARGET_NODE_ID;
uavcan::Frame frame(data_type_id, bufmgr_key.getTransferType(), bufmgr_key.getNodeID(),
dst_nid, frame_index, transfer_id, last);
@@ -41,7 +41,7 @@ struct RxFrameGenerator
}
};
const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
const uavcan::TransferBufferManagerKey RxFrameGenerator::DEFAULT_KEY(42, uavcan::TransferTypeMessageBroadcast);
template <unsigned int BUFSIZE>
@@ -85,15 +85,15 @@ static bool matchBufferContent(const uavcan::ITransferBuffer* tbb, const std::st
}
#define CHECK_NOT_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_NOT_COMPLETE, (x))
#define CHECK_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_COMPLETE, (x))
#define CHECK_SINGLE_FRAME(x) ASSERT_EQ(uavcan::TransferReceiver::RESULT_SINGLE_FRAME, (x))
#define CHECK_NOT_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::ResultNotComplete, (x))
#define CHECK_COMPLETE(x) ASSERT_EQ(uavcan::TransferReceiver::ResultComplete, (x))
#define CHECK_SINGLE_FRAME(x) ASSERT_EQ(uavcan::TransferReceiver::ResultSingleFrame, (x))
TEST(TransferReceiver, Basic)
{
using uavcan::TransferReceiver;
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -101,14 +101,14 @@ TEST(TransferReceiver, Basic)
/*
* Empty
*/
ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_EQ(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(0, rcv.getLastTransferTimestampMonotonic());
/*
* Single frame transfer with zero ts, must be ignored
*/
CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "Foo", 0, true, 0, 0), bk));
ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_EQ(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(0, rcv.getLastTransferTimestampMonotonic());
/*
@@ -120,7 +120,7 @@ TEST(TransferReceiver, Basic)
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678foo"));
ASSERT_EQ(0x1234, rcv.getLastTransferCrc());
ASSERT_EQ(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval()); // Not initialized yet
ASSERT_EQ(TransferReceiver::DefaultTransferInterval, rcv.getInterval()); // Not initialized yet
ASSERT_EQ(100, rcv.getLastTransferTimestampMonotonic());
/*
@@ -138,8 +138,8 @@ TEST(TransferReceiver, Basic)
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678abcdefgh"));
ASSERT_EQ(0x789A, rcv.getLastTransferCrc());
ASSERT_GT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_LT(TransferReceiver::MIN_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_GT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_LT(TransferReceiver::MinTransferInterval, rcv.getInterval());
ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic());
ASSERT_FALSE(rcv.isTimedOut(1000));
ASSERT_FALSE(rcv.isTimedOut(5000));
@@ -153,7 +153,7 @@ TEST(TransferReceiver, Basic)
CHECK_SINGLE_FRAME(rcv.addFrame(gen(0, "qwe", 0, true, 2, 2200), bk));
ASSERT_FALSE(bufmgr.access(gen.bufmgr_key)); // Buffer must be removed
ASSERT_GT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_GT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_EQ(2200, rcv.getLastTransferTimestampMonotonic());
CHECK_SINGLE_FRAME(rcv.addFrame(gen(0, "", 0, true, 3, 2500), bk));
@@ -195,9 +195,9 @@ TEST(TransferReceiver, Basic)
ASSERT_FALSE(rcv.isTimedOut(1000));
ASSERT_FALSE(rcv.isTimedOut(900000200));
ASSERT_TRUE(rcv.isTimedOut(1000 * 1000000));
ASSERT_LT(TransferReceiver::DEFAULT_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_LE(TransferReceiver::MIN_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_GE(TransferReceiver::MAX_TRANSFER_INTERVAL, rcv.getInterval());
ASSERT_LT(TransferReceiver::DefaultTransferInterval, rcv.getInterval());
ASSERT_LE(TransferReceiver::MinTransferInterval, rcv.getInterval());
ASSERT_GE(TransferReceiver::MaxTransferInterval, rcv.getInterval());
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), "345678qwe"));
ASSERT_EQ(0x5678, rcv.getLastTransferCrc());
@@ -213,7 +213,7 @@ TEST(TransferReceiver, Basic)
TEST(TransferReceiver, OutOfBufferSpace_32bytes)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -248,18 +248,18 @@ TEST(TransferReceiver, OutOfBufferSpace_32bytes)
TEST(TransferReceiver, UnterminatedTransfer)
{
Context<512> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
std::string content;
for (int i = 0; i <= uavcan::Frame::INDEX_MAX; i++)
for (int i = 0; i <= uavcan::Frame::MaxIndex; i++)
{
CHECK_NOT_COMPLETE(rcv.addFrame(gen(1, "12345678", i, false, 0, 1000 + i), bk)); // Last one will be dropped
content += "12345678";
}
CHECK_COMPLETE(rcv.addFrame(gen(1, "12345678", uavcan::Frame::INDEX_MAX, true, 0, 1100), bk));
CHECK_COMPLETE(rcv.addFrame(gen(1, "12345678", uavcan::Frame::MaxIndex, true, 0, 1100), bk));
ASSERT_EQ(1000, rcv.getLastTransferTimestampMonotonic());
ASSERT_TRUE(matchBufferContent(bufmgr.access(gen.bufmgr_key), std::string(content, 2)));
ASSERT_EQ(0x3231, rcv.getLastTransferCrc());
@@ -269,7 +269,7 @@ TEST(TransferReceiver, UnterminatedTransfer)
TEST(TransferReceiver, OutOfOrderFrames)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -290,7 +290,7 @@ TEST(TransferReceiver, OutOfOrderFrames)
TEST(TransferReceiver, IntervalMeasurement)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -320,7 +320,7 @@ TEST(TransferReceiver, IntervalMeasurement)
TEST(TransferReceiver, Restart)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -362,7 +362,7 @@ TEST(TransferReceiver, Restart)
TEST(TransferReceiver, UtcTransferTimestamping)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
uavcan::TransferBufferAccessor bk(context.bufmgr, RxFrameGenerator::DEFAULT_KEY);
@@ -412,15 +412,15 @@ TEST(TransferReceiver, UtcTransferTimestamping)
TEST(TransferReceiver, HeaderParsing)
{
Context<32> context;
RxFrameGenerator gen(789, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
RxFrameGenerator gen(789, uavcan::TransferTypeMessageBroadcast);
uavcan::TransferReceiver& rcv = context.receiver;
uavcan::ITransferBufferManager& bufmgr = context.bufmgr;
static const uavcan::TransferType ADDRESSED_TRANSFER_TYPES[3] =
{
uavcan::TRANSFER_TYPE_MESSAGE_UNICAST,
uavcan::TRANSFER_TYPE_SERVICE_REQUEST,
uavcan::TRANSFER_TYPE_SERVICE_RESPONSE
uavcan::TransferTypeMessageUnicast,
uavcan::TransferTypeServiceRequest,
uavcan::TransferTypeServiceResponse
};
uavcan::TransferID tid;
@@ -430,7 +430,7 @@ TEST(TransferReceiver, HeaderParsing)
*/
{
gen.bufmgr_key =
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TransferTypeMessageBroadcast);
uavcan::TransferBufferAccessor bk1(context.bufmgr, gen.bufmgr_key);
CHECK_NOT_COMPLETE(rcv.addFrame(gen(0, "12345678", 0, false, tid.get(), 1), bk1));
@@ -472,7 +472,7 @@ TEST(TransferReceiver, HeaderParsing)
{
gen.bufmgr_key =
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST);
uavcan::TransferBufferManagerKey(gen.bufmgr_key.getNodeID(), uavcan::TransferTypeMessageBroadcast);
uavcan::TransferBufferAccessor bk(context.bufmgr, gen.bufmgr_key);
const uavcan::RxFrame frame = gen(0, SFT_PAYLOAD_BROADCAST, 0, true, tid.get(), 1000);
libuavcan/test/transport/transfer_sender.cpp
+20 -20
View File
@@ -45,14 +45,14 @@ TEST(TransferSender, Basic)
*/
static const uavcan::DataTypeDescriptor TYPES[2] =
{
makeDataType(uavcan::DATA_TYPE_KIND_MESSAGE, 1),
makeDataType(uavcan::DATA_TYPE_KIND_SERVICE, 1)
makeDataType(uavcan::DataTypeKindMessage, 1),
makeDataType(uavcan::DataTypeKindService, 1)
};
uavcan::TransferSender senders[2] =
{
uavcan::TransferSender(dispatcher_tx, TYPES[0], uavcan::CanTxQueue::VOLATILE),
uavcan::TransferSender(dispatcher_tx, TYPES[1], uavcan::CanTxQueue::PERSISTENT)
uavcan::TransferSender(dispatcher_tx, TYPES[0], uavcan::CanTxQueue::Volatile),
uavcan::TransferSender(dispatcher_tx, TYPES[1], uavcan::CanTxQueue::Persistent)
};
static const std::string DATA[4] =
@@ -71,27 +71,27 @@ TEST(TransferSender, Basic)
*/
static const uint64_t TX_DEADLINE = 1000000;
sendOne(senders[0], DATA[0], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0);
sendOne(senders[0], DATA[1], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, RX_NODE_ID);
sendOne(senders[0], "123", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0);
sendOne(senders[0], "456", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, RX_NODE_ID);
sendOne(senders[0], DATA[0], TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0);
sendOne(senders[0], DATA[1], TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, RX_NODE_ID);
sendOne(senders[0], "123", TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0);
sendOne(senders[0], "456", TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, RX_NODE_ID);
sendOne(senders[1], DATA[2], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, RX_NODE_ID);
sendOne(senders[1], DATA[3], TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, RX_NODE_ID, 1);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, RX_NODE_ID);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, RX_NODE_ID, 2);
sendOne(senders[1], DATA[2], TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, RX_NODE_ID);
sendOne(senders[1], DATA[3], TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, RX_NODE_ID, 1);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, RX_NODE_ID);
sendOne(senders[1], "", TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, RX_NODE_ID, 2);
static const Transfer TRANSFERS[8] =
{
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 0, TX_NODE_ID, 0, DATA[0], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 0, TX_NODE_ID, RX_NODE_ID, DATA[1], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, TX_NODE_ID, 0, "123", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 1, TX_NODE_ID, RX_NODE_ID, "456", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 0, TX_NODE_ID, 0, DATA[0], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, 0, TX_NODE_ID, RX_NODE_ID, DATA[1], TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageBroadcast, 1, TX_NODE_ID, 0, "123", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeMessageUnicast, 1, TX_NODE_ID, RX_NODE_ID, "456", TYPES[0]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 0, TX_NODE_ID, RX_NODE_ID, DATA[2], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 1, TX_NODE_ID, RX_NODE_ID, DATA[3], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 1, TX_NODE_ID, RX_NODE_ID, "", TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 2, TX_NODE_ID, RX_NODE_ID, "", TYPES[1])
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, 0, TX_NODE_ID, RX_NODE_ID, DATA[2], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, 1, TX_NODE_ID, RX_NODE_ID, DATA[3], TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceRequest, 1, TX_NODE_ID, RX_NODE_ID, "", TYPES[1]),
Transfer(TX_DEADLINE, 0, uavcan::TransferTypeServiceResponse, 2, TX_NODE_ID, RX_NODE_ID, "", TYPES[1])
};
/*
libuavcan/test/transport/transfer_test_helpers.cpp
+12 -12
View File
@@ -8,14 +8,14 @@
TEST(TransferTestHelpers, Transfer)
{
uavcan::PoolAllocator<uavcan::MEM_POOL_BLOCK_SIZE * 8, uavcan::MEM_POOL_BLOCK_SIZE> pool;
uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
uavcan::PoolManager<1> poolmgr;
poolmgr.addPool(&pool);
uavcan::TransferBufferManager<128, 1> mgr(poolmgr);
uavcan::TransferBufferAccessor tba(mgr, uavcan::TransferBufferManagerKey(0, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST));
uavcan::TransferBufferAccessor tba(mgr, uavcan::TransferBufferManagerKey(0, uavcan::TransferTypeMessageUnicast));
uavcan::RxFrame frame(uavcan::Frame(123, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 1, 0, 0, 0, true), 0, 0, 0);
uavcan::RxFrame frame(uavcan::Frame(123, uavcan::TransferTypeMessageBroadcast, 1, 0, 0, 0, true), 0, 0, 0);
uavcan::MultiFrameIncomingTransfer mfit(10, 1000, frame, tba);
// Filling the buffer with data
@@ -32,12 +32,12 @@ TEST(TransferTestHelpers, Transfer)
TEST(TransferTestHelpers, MFTSerialization)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i;
static const std::string DATA = "To go wrong in one's own way is better than to go right in someone else's.";
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_UNICAST, 2, 42, 127, DATA, type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageUnicast, 2, 42, 127, DATA, type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
@@ -63,30 +63,30 @@ TEST(TransferTestHelpers, MFTSerialization)
TEST(TransferTestHelpers, SFTSerialization)
{
uavcan::DataTypeDescriptor type(uavcan::DATA_TYPE_KIND_MESSAGE, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i++)
uavcan::DataTypeDescriptor type(uavcan::DataTypeKindMessage, 123, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i++)
type.hash.value[i] = i;
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 7, 42, 0, "Nvrfrget", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageBroadcast, 7, 42, 0, "Nvrfrget", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_SERVICE_REQUEST, 7, 42, 127, "7-chars", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeServiceRequest, 7, 42, 127, "7-chars", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST, 7, 42, 0, "", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeMessageBroadcast, 7, 42, 0, "", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
}
{
const Transfer transfer(1, 100000, uavcan::TRANSFER_TYPE_SERVICE_RESPONSE, 7, 42, 127, "", type);
const Transfer transfer(1, 100000, uavcan::TransferTypeServiceResponse, 7, 42, 127, "", type);
const std::vector<uavcan::RxFrame> ser = serializeTransfer(transfer);
ASSERT_EQ(1, ser.size());
std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n";
libuavcan/test/transport/transfer_test_helpers.hpp
+9 -9
View File
@@ -149,12 +149,12 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
bool need_crc = false;
switch (transfer.transfer_type)
{
case uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST:
case uavcan::TransferTypeMessageBroadcast:
need_crc = transfer.payload.length() > sizeof(uavcan::CanFrame::data);
break;
case uavcan::TRANSFER_TYPE_SERVICE_RESPONSE:
case uavcan::TRANSFER_TYPE_SERVICE_REQUEST:
case uavcan::TRANSFER_TYPE_MESSAGE_UNICAST:
case uavcan::TransferTypeServiceResponse:
case uavcan::TransferTypeServiceRequest:
case uavcan::TransferTypeMessageUnicast:
need_crc = transfer.payload.length() > (sizeof(uavcan::CanFrame::data) - 1);
break;
default:
@@ -165,7 +165,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
std::vector<uint8_t> raw_payload;
if (need_crc)
{
uavcan::Crc16 payload_crc(transfer.data_type.hash.value, uavcan::DataTypeHash::NUM_BYTES);
uavcan::Crc16 payload_crc(transfer.data_type.hash.value, uavcan::DataTypeHash::NumBytes);
payload_crc.add(reinterpret_cast<const uint8_t*>(transfer.payload.c_str()), transfer.payload.length());
// Little endian
raw_payload.push_back(payload_crc.get() & 0xFF);
@@ -196,7 +196,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
frm.makeLast();
offset += spres;
EXPECT_GE(uavcan::Frame::INDEX_MAX, frame_index);
EXPECT_GE(uavcan::Frame::MaxIndex, frame_index);
frame_index++;
const uavcan::RxFrame rxfrm(frm, ts_monotonic, ts_utc, 0);
@@ -213,7 +213,7 @@ std::vector<uavcan::RxFrame> serializeTransfer(const Transfer& transfer)
uavcan::DataTypeDescriptor makeDataType(uavcan::DataTypeKind kind, uint16_t id)
{
uavcan::DataTypeDescriptor dtd(kind, id, uavcan::DataTypeHash());
for (int i = 0; i < uavcan::DataTypeHash::NUM_BYTES; i += 2)
for (int i = 0; i < uavcan::DataTypeHash::NumBytes; i += 2)
{
dtd.hash.value[i] = id & 0xFF;
dtd.hash.value[i + 1] = id >> 8;
@@ -243,8 +243,8 @@ public:
uavcan::NodeID dst_node_id_override = uavcan::NodeID())
{
ts_ += 100;
const uavcan::NodeID dst_node_id = (transfer_type == uavcan::TRANSFER_TYPE_MESSAGE_BROADCAST)
? uavcan::NodeID::BROADCAST
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_, ts_ + 1000000000ul, transfer_type, tid_, source_node_id, dst_node_id, payload, type);
tid_.increment();