From 47a2b01a14183b3b8b41375931bc901332e8574e Mon Sep 17 00:00:00 2001 From: Pavel Kirienko Date: Fri, 21 Feb 2014 18:45:23 +0400 Subject: [PATCH] Style fix: All constants are CamelCase now --- libuavcan/include/uavcan/can_driver.hpp | 20 +++--- .../include/uavcan/internal/data_type.hpp | 18 ++--- .../uavcan/internal/dynamic_memory.hpp | 36 +++++----- .../uavcan/internal/impl_constants.hpp | 10 +-- libuavcan/include/uavcan/internal/map.hpp | 16 ++--- .../internal/marshalling/bit_stream.hpp | 8 +-- .../internal/marshalling/scalar_codec.hpp | 72 +++++++++---------- .../uavcan/internal/transport/can_io.hpp | 14 ++-- .../include/uavcan/internal/transport/crc.hpp | 4 +- .../uavcan/internal/transport/dispatcher.hpp | 2 +- .../transport/outgoing_transfer_registry.hpp | 8 +-- .../uavcan/internal/transport/transfer.hpp | 52 +++++++------- .../internal/transport/transfer_buffer.hpp | 52 +++++++------- .../internal/transport/transfer_listener.hpp | 10 +-- .../internal/transport/transfer_receiver.hpp | 18 ++--- .../internal/transport/transfer_sender.hpp | 6 +- libuavcan/include/uavcan/internal/util.hpp | 4 +- libuavcan/src/can_driver.cpp | 22 +++--- libuavcan/src/marshalling/bit_stream.cpp | 16 ++--- libuavcan/src/transport/can_io.cpp | 14 ++-- libuavcan/src/transport/crc.cpp | 4 +- libuavcan/src/transport/dispatcher.cpp | 24 +++---- libuavcan/src/transport/transfer.cpp | 48 ++++++------- libuavcan/src/transport/transfer_buffer.cpp | 4 +- libuavcan/src/transport/transfer_listener.cpp | 6 +- libuavcan/src/transport/transfer_receiver.cpp | 53 +++++++------- libuavcan/test/can_driver.cpp | 10 +-- libuavcan/test/common.hpp | 2 +- libuavcan/test/map.cpp | 2 +- libuavcan/test/transport/can/io.cpp | 26 +++---- libuavcan/test/transport/can/tx_queue.cpp | 34 ++++----- libuavcan/test/transport/dispatcher.cpp | 34 ++++----- .../test/transport/incoming_transfer.cpp | 2 +- .../transport/outgoing_transfer_registry.cpp | 10 +-- libuavcan/test/transport/transfer.cpp | 56 +++++++-------- libuavcan/test/transport/transfer_buffer.cpp | 20 +++--- .../test/transport/transfer_listener.cpp | 66 ++++++++--------- .../test/transport/transfer_receiver.cpp | 60 ++++++++-------- libuavcan/test/transport/transfer_sender.cpp | 40 +++++------ .../test/transport/transfer_test_helpers.cpp | 24 +++---- .../test/transport/transfer_test_helpers.hpp | 18 ++--- 41 files changed, 473 insertions(+), 472 deletions(-) diff --git a/libuavcan/include/uavcan/can_driver.hpp b/libuavcan/include/uavcan/can_driver.hpp index a9baa17aa1..c05f1f0110 100644 --- a/libuavcan/include/uavcan/can_driver.hpp +++ b/libuavcan/include/uavcan/can_driver.hpp @@ -18,10 +18,10 @@ namespace uavcan #pragma pack(push, 1) struct CanFrame { - static const uint32_t MASK_STDID = 0x000007FF; - static const uint32_t MASK_EXTID = 0x1FFFFFFF; - static const uint32_t FLAG_EFF = 1 << 31; ///< Extended frame format - static const uint32_t FLAG_RTR = 1 << 30; ///< Remote transmission request + static const uint32_t MaskStdID = 0x000007FF; + static const uint32_t MaskExtID = 0x1FFFFFFF; + static const uint32_t FlagEFF = 1 << 31; ///< Extended frame format + static const uint32_t FlagRTR = 1 << 30; ///< Remote transmission request uint32_t id; ///< CAN ID with flags (above) uint8_t data[8]; @@ -48,21 +48,21 @@ struct CanFrame return (id == rhs.id) && (dlc == rhs.dlc) && std::equal(data, data + dlc, rhs.data); } - bool isExtended() const { return id & FLAG_EFF; } - bool isRemoteTransmissionRequest() const { return id & FLAG_RTR; } + bool isExtended() const { return id & FlagEFF; } + bool isRemoteTransmissionRequest() const { return id & FlagRTR; } - enum StringRepresentation { STR_TIGHT, STR_ALIGNED }; - std::string toString(StringRepresentation mode = STR_TIGHT) const; + enum StringRepresentation { StrTight, StrAligned }; + std::string toString(StringRepresentation mode = StrTight) const; // TODO: priority comparison for EXT vs STD frames bool priorityHigherThan(const CanFrame& rhs) const { - return (id & CanFrame::MASK_EXTID) < (rhs.id & CanFrame::MASK_EXTID); + return (id & CanFrame::MaskExtID) < (rhs.id & CanFrame::MaskExtID); } bool priorityLowerThan(const CanFrame& rhs) const { - return (id & CanFrame::MASK_EXTID) > (rhs.id & CanFrame::MASK_EXTID); + return (id & CanFrame::MaskExtID) > (rhs.id & CanFrame::MaskExtID); } }; #pragma pack(pop) diff --git a/libuavcan/include/uavcan/internal/data_type.hpp b/libuavcan/include/uavcan/internal/data_type.hpp index 07366264fa..27d07c1be7 100644 --- a/libuavcan/include/uavcan/internal/data_type.hpp +++ b/libuavcan/include/uavcan/internal/data_type.hpp @@ -12,31 +12,31 @@ namespace uavcan enum DataTypeKind { - DATA_TYPE_KIND_SERVICE, - DATA_TYPE_KIND_MESSAGE, - NUM_DATA_TYPE_KINDS + DataTypeKindService, + DataTypeKindMessage, + NumDataTypeKinds }; struct DataTypeHash { - enum { NUM_BYTES = 16 }; - uint8_t value[NUM_BYTES]; + enum { NumBytes = 16 }; + uint8_t value[NumBytes]; DataTypeHash() { - std::fill(value, value + NUM_BYTES, 0); + std::fill(value, value + NumBytes, 0); } - DataTypeHash(const uint8_t source[NUM_BYTES]) + DataTypeHash(const uint8_t source[NumBytes]) { - std::copy(source, source + NUM_BYTES, value); + std::copy(source, source + NumBytes, value); } bool operator!=(const DataTypeHash& rhs) const { return !operator==(rhs); } bool operator==(const DataTypeHash& rhs) const { - return std::equal(value, value + NUM_BYTES, rhs.value); + return std::equal(value, value + NumBytes, rhs.value); } }; diff --git a/libuavcan/include/uavcan/internal/dynamic_memory.hpp b/libuavcan/include/uavcan/internal/dynamic_memory.hpp index a28906d227..6e22ac262b 100644 --- a/libuavcan/include/uavcan/internal/dynamic_memory.hpp +++ b/libuavcan/include/uavcan/internal/dynamic_memory.hpp @@ -34,10 +34,10 @@ public: }; -template +template class PoolManager : public IAllocator, Noncopyable { - IPoolAllocator* pools_[MAX_POOLS]; + IPoolAllocator* pools_[MaxPools]; static bool sortComparePoolAllocators(const IPoolAllocator* a, const IPoolAllocator* b) { @@ -56,7 +56,7 @@ public: { assert(pool); bool retval = false; - for (int i = 0; i < MAX_POOLS; i++) + for (int i = 0; i < MaxPools; i++) { assert(pools_[i] != pool); if (pools_[i] == NULL || pools_[i] == pool) @@ -67,13 +67,13 @@ public: } } // We need to keep the pools in order, so that smallest blocks go first - std::sort(pools_, pools_ + MAX_POOLS, &PoolManager::sortComparePoolAllocators); + std::sort(pools_, pools_ + MaxPools, &PoolManager::sortComparePoolAllocators); return retval; } void* allocate(std::size_t size) { - for (int i = 0; i < MAX_POOLS; i++) + for (int i = 0; i < MaxPools; i++) { if (pools_[i] == NULL) break; @@ -86,7 +86,7 @@ public: void deallocate(const void* ptr) { - for (int i = 0; i < MAX_POOLS; i++) + for (int i = 0; i < MaxPools; i++) { if (pools_[i] == NULL) { @@ -103,37 +103,37 @@ public: }; -template +template class PoolAllocator : public IPoolAllocator, Noncopyable { union Node { - uint8_t data[BLOCK_SIZE]; + uint8_t data[BlockSize]; Node* next; }; Node* free_list_; - uint8_t pool_[POOL_SIZE] __attribute__((aligned(16))); // TODO: compiler-independent alignment + uint8_t pool_[PoolSize] __attribute__((aligned(16))); // TODO: compiler-independent alignment // Noncopyable PoolAllocator(const PoolAllocator&); PoolAllocator& operator=(const PoolAllocator&); public: - static const int NUM_BLOCKS = int(POOL_SIZE / BLOCK_SIZE); + static const int NumBlocks = int(PoolSize / BlockSize); PoolAllocator() : free_list_(reinterpret_cast(pool_)) // TODO: alignment { - memset(pool_, 0, POOL_SIZE); - for (int i = 0; i < NUM_BLOCKS - 1; i++) + memset(pool_, 0, PoolSize); + for (int i = 0; i < NumBlocks - 1; i++) free_list_[i].next = free_list_ + i + 1; - free_list_[NUM_BLOCKS - 1].next = NULL; + free_list_[NumBlocks - 1].next = NULL; } void* allocate(std::size_t size) { - if (free_list_ == NULL || size > BLOCK_SIZE) + if (free_list_ == NULL || size > BlockSize) return NULL; void* pmem = free_list_; free_list_ = free_list_->next; @@ -156,10 +156,10 @@ public: { return ptr >= pool_ && - ptr < (pool_ + POOL_SIZE); + ptr < (pool_ + PoolSize); } - std::size_t getBlockSize() const { return BLOCK_SIZE; } + std::size_t getBlockSize() const { return BlockSize; } int getNumFreeBlocks() const { @@ -168,7 +168,7 @@ public: while (p) { num++; - assert(num <= NUM_BLOCKS); + assert(num <= NumBlocks); p = p->next; } return num; @@ -176,7 +176,7 @@ public: int getNumUsedBlocks() const { - return NUM_BLOCKS - getNumFreeBlocks(); + return NumBlocks - getNumFreeBlocks(); } }; diff --git a/libuavcan/include/uavcan/internal/impl_constants.hpp b/libuavcan/include/uavcan/internal/impl_constants.hpp index dbf0e56c34..48df88a375 100644 --- a/libuavcan/include/uavcan/internal/impl_constants.hpp +++ b/libuavcan/include/uavcan/internal/impl_constants.hpp @@ -15,19 +15,19 @@ namespace uavcan * fit this size; otherwise compilation fails. */ #if UAVCAN_MEM_POOL_BLOCK_SIZE -enum { MEM_POOL_BLOCK_SIZE = UAVCAN_MEM_POOL_BLOCK_SIZE }; +enum { MemPoolBlockSize = UAVCAN_MEM_POOL_BLOCK_SIZE }; #else -enum { MEM_POOL_BLOCK_SIZE = 32 + sizeof(void*) * 2 }; +enum { MemPoolBlockSize = 32 + sizeof(void*) * 2 }; #endif -enum { MEM_POOL_ALIGNMENT = 8 }; +enum { MemPoolAlignment = 8 }; -typedef char _alignment_check_for_MEM_POOL_BLOCK_SIZE[((MEM_POOL_BLOCK_SIZE & (MEM_POOL_ALIGNMENT - 1)) == 0) ? 1 : -1]; +typedef char _alignment_check_for_MEM_POOL_BLOCK_SIZE[((MemPoolBlockSize & (MemPoolAlignment - 1)) == 0) ? 1 : -1]; template struct IsDynamicallyAllocatable { - static void check() { StaticAssert::check(); } + static void check() { StaticAssert::check(); } }; } diff --git a/libuavcan/include/uavcan/internal/map.hpp b/libuavcan/include/uavcan/internal/map.hpp index 6b726d01bb..7c90bb5744 100644 --- a/libuavcan/include/uavcan/internal/map.hpp +++ b/libuavcan/include/uavcan/internal/map.hpp @@ -20,9 +20,9 @@ namespace uavcan * Both key and value must be copyable, assignable and default constructible. * Key must implement a comparison operator. * Key's default constructor must initialize the object into invalid state. - * Size of Key + Value + padding must not exceed MEM_POOL_BLOCK_SIZE. + * Size of Key + Value + padding must not exceed MemPoolBlockSize. */ -template +template class Map : Noncopyable { #pragma pack(push, 1) @@ -37,7 +37,7 @@ class Map : Noncopyable struct KVGroup : LinkedListNode { - enum { NUM_KV = (MEM_POOL_BLOCK_SIZE - sizeof(LinkedListNode)) / sizeof(KVPair) }; + enum { NUM_KV = (MemPoolBlockSize - sizeof(LinkedListNode)) / sizeof(KVPair) }; KVPair kvs[NUM_KV]; KVGroup() @@ -76,11 +76,11 @@ class Map : Noncopyable LinkedListRoot list_; IAllocator& allocator_; - KVPair static_[NUM_STATIC_ENTRIES]; + KVPair static_[NumStaticEntries]; KVPair* find(const Key& key) { - for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++) + for (unsigned int i = 0; i < NumStaticEntries; i++) if (static_[i].match(key)) return static_ + i; @@ -101,7 +101,7 @@ class Map : Noncopyable { // Looking for first EMPTY static entry KVPair* stat = NULL; - for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++) + for (unsigned int i = 0; i < NumStaticEntries; i++) { if (static_[i].match(Key())) { @@ -232,7 +232,7 @@ public: { unsigned int num_removed = 0; - for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++) + for (unsigned int i = 0; i < NumStaticEntries; i++) { if (!static_[i].match(Key())) { @@ -280,7 +280,7 @@ public: unsigned int getNumStaticPairs() const { unsigned int num = 0; - for (unsigned int i = 0; i < NUM_STATIC_ENTRIES; i++) + for (unsigned int i = 0; i < NumStaticEntries; i++) if (!static_[i].match(Key())) num++; return num; diff --git a/libuavcan/include/uavcan/internal/marshalling/bit_stream.hpp b/libuavcan/include/uavcan/internal/marshalling/bit_stream.hpp index 6f0f0802e2..910a70b82f 100644 --- a/libuavcan/include/uavcan/internal/marshalling/bit_stream.hpp +++ b/libuavcan/include/uavcan/internal/marshalling/bit_stream.hpp @@ -18,7 +18,7 @@ extern "C" void bitarray_copy(const unsigned char *src_org, int src_offset, int class BitStream { - enum { MAX_BYTES_PER_RW = 16 }; + enum { MaxBytesPerRW = 16 }; ITransferBuffer& buf_; int bit_offset_; @@ -34,12 +34,12 @@ class BitStream } public: - enum { MAX_BITS_PER_RW = MAX_BYTES_PER_RW * 8 }; + enum { MaxBitsPerRW = MaxBytesPerRW * 8 }; enum { - RESULT_OUT_OF_BUFFER = 0, - RESULT_OK = 1 + ResultOutOfBuffer = 0, + ResultOk = 1 }; BitStream(ITransferBuffer& buf) diff --git a/libuavcan/include/uavcan/internal/marshalling/scalar_codec.hpp b/libuavcan/include/uavcan/internal/marshalling/scalar_codec.hpp index 78a30b72a8..d86d52f168 100644 --- a/libuavcan/include/uavcan/internal/marshalling/scalar_codec.hpp +++ b/libuavcan/include/uavcan/internal/marshalling/scalar_codec.hpp @@ -18,10 +18,10 @@ class ScalarCodec { BitStream& stream_; - template - static void swapByteOrder(uint8_t (&bytes)[SIZE]) + template + static void swapByteOrder(uint8_t (&bytes)[Size]) { - for (int i = 0, j = SIZE - 1; i < j; i++, j--) + for (int i = 0, j = Size - 1; i < j; i++, j--) { const uint8_t c = bytes[i]; bytes[i] = bytes[j]; @@ -29,9 +29,9 @@ class ScalarCodec } } - template - static typename EnableIf<(BITLEN > 8)>::Type - convertByteOrder(uint8_t (&bytes)[SIZE]) + template + static typename EnableIf<(BitLen > 8)>::Type + convertByteOrder(uint8_t (&bytes)[Size]) { #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) static const bool big_endian = BYTE_ORDER == BIG_ENDIAN; @@ -50,50 +50,50 @@ class ScalarCodec swapByteOrder(bytes); } - template - static typename EnableIf<(BITLEN <= 8)>::Type - convertByteOrder(uint8_t (&bytes)[SIZE]) + template + static typename EnableIf<(BitLen <= 8)>::Type + convertByteOrder(uint8_t (&bytes)[Size]) { (void)bytes; } - template - static typename EnableIf::is_signed && ((sizeof(T) * 8) > BITLEN)>::Type + template + static typename EnableIf::is_signed && ((sizeof(T) * 8) > BitLen)>::Type fixTwosComplement(T& value) { StaticAssert::is_integer>::check(); // Not applicable to floating point types - if (value & (T(1) << (BITLEN - 1))) // The most significant bit is set --> negative - value |= 0xFFFFFFFFFFFFFFFF & ~((T(1) << BITLEN) - 1); + if (value & (T(1) << (BitLen - 1))) // The most significant bit is set --> negative + value |= 0xFFFFFFFFFFFFFFFF & ~((T(1) << BitLen) - 1); } - template - static typename EnableIf::is_signed || ((sizeof(T) * 8) == BITLEN)>::Type + template + static typename EnableIf::is_signed || ((sizeof(T) * 8) == BitLen)>::Type fixTwosComplement(T& value) { (void)value; } - template - static typename EnableIf<((sizeof(T) * 8) > BITLEN)>::Type + template + static typename EnableIf<((sizeof(T) * 8) > BitLen)>::Type clearExtraBits(T& value) { - value &= (T(1) << BITLEN) - 1; // Signedness doesn't matter + value &= (T(1) << BitLen) - 1; // Signedness doesn't matter } - template - static typename EnableIf<((sizeof(T) * 8) == BITLEN)>::Type + template + static typename EnableIf<((sizeof(T) * 8) == BitLen)>::Type clearExtraBits(T& value) { (void)value; } - template + template void validate() { - StaticAssert<((sizeof(T) * 8) >= BITLEN)>::check(); - StaticAssert<(BITLEN <= BitStream::MAX_BITS_PER_RW)>::check(); - StaticAssert::is_signed ? (BITLEN > 1) : 1>::check(); + StaticAssert<((sizeof(T) * 8) >= BitLen)>::check(); + StaticAssert<(BitLen <= BitStream::MaxBitsPerRW)>::check(); + StaticAssert::is_signed ? (BitLen > 1) : 1>::check(); } public: @@ -101,10 +101,10 @@ public: : stream_(stream) { } - template + template int encode(const T value) { - validate(); + validate(); union ByteUnion { T value; @@ -112,19 +112,19 @@ public: } byte_union; byte_union.value = value; - clearExtraBits(byte_union.value); - convertByteOrder(byte_union.bytes); + clearExtraBits(byte_union.value); + convertByteOrder(byte_union.bytes); // Underlying stream class assumes that more significant bits have lower index, so we need to shift some. - byte_union.bytes[BITLEN / 8] <<= (8 - (BITLEN % 8)) & 7; + byte_union.bytes[BitLen / 8] <<= (8 - (BitLen % 8)) & 7; - return stream_.write(byte_union.bytes, BITLEN); + return stream_.write(byte_union.bytes, BitLen); } - template + template int decode(T& value) { - validate(); + validate(); union ByteUnion { T value; @@ -132,14 +132,14 @@ public: } byte_union; std::fill(byte_union.bytes, byte_union.bytes + sizeof(T), 0); - const int read_res = stream_.read(byte_union.bytes, BITLEN); + const int read_res = stream_.read(byte_union.bytes, BitLen); if (read_res <= 0) return read_res; - byte_union.bytes[BITLEN / 8] >>= (8 - (BITLEN % 8)) & 7; // As in encode(), vice versa + byte_union.bytes[BitLen / 8] >>= (8 - (BitLen % 8)) & 7; // As in encode(), vice versa - convertByteOrder(byte_union.bytes); - fixTwosComplement(byte_union.value); + convertByteOrder(byte_union.bytes); + fixTwosComplement(byte_union.value); value = byte_union.value; return read_res; diff --git a/libuavcan/include/uavcan/internal/transport/can_io.hpp b/libuavcan/include/uavcan/internal/transport/can_io.hpp index 0c81c8261b..4fecc49479 100644 --- a/libuavcan/include/uavcan/internal/transport/can_io.hpp +++ b/libuavcan/include/uavcan/internal/transport/can_io.hpp @@ -29,14 +29,14 @@ struct CanRxFrame : public CanFrame , iface_index(0) { } - std::string toString(StringRepresentation mode = STR_TIGHT) const; + std::string toString(StringRepresentation mode = StrTight) const; }; class CanTxQueue : Noncopyable { public: - enum Qos { VOLATILE, PERSISTENT }; + enum Qos { Volatile, Persistent }; struct Entry : public LinkedListNode // Not required to be packed - fits the block in any case { @@ -49,7 +49,7 @@ public: , frame(frame) , qos(uint8_t(qos)) { - assert(qos == VOLATILE || qos == PERSISTENT); + assert(qos == Volatile || qos == Persistent); IsDynamicallyAllocatable::check(); } @@ -116,13 +116,13 @@ public: class CanIOManager : Noncopyable { public: - enum { MAX_IFACES = 3 }; + enum { MaxIfaces = 3 }; private: ICanDriver& driver_; ISystemClock& sysclock_; - CanTxQueue tx_queues_[MAX_IFACES]; + CanTxQueue tx_queues_[MaxIfaces]; // Noncopyable CanIOManager(CanIOManager&); @@ -138,9 +138,9 @@ public: : driver_(driver) , sysclock_(sysclock) { - assert(driver.getNumIfaces() <= MAX_IFACES); + assert(driver.getNumIfaces() <= MaxIfaces); // We can't initialize member array with non-default constructors in C++03 - for (int i = 0; i < MAX_IFACES; i++) + for (int i = 0; i < MaxIfaces; i++) { tx_queues_[i].~CanTxQueue(); new (tx_queues_ + i) CanTxQueue(&allocator, &sysclock); diff --git a/libuavcan/include/uavcan/internal/transport/crc.hpp b/libuavcan/include/uavcan/internal/transport/crc.hpp index 06336a1794..40fab5cb5d 100644 --- a/libuavcan/include/uavcan/internal/transport/crc.hpp +++ b/libuavcan/include/uavcan/internal/transport/crc.hpp @@ -16,10 +16,12 @@ namespace uavcan */ class Crc16 { - static const uint16_t TABLE[256]; + static const uint16_t Table[256]; uint16_t value_; public: + enum { NumBytes = 2 }; + Crc16() : value_(0x0000) { } diff --git a/libuavcan/include/uavcan/internal/transport/dispatcher.hpp b/libuavcan/include/uavcan/internal/transport/dispatcher.hpp index fc502a4d74..9192038091 100644 --- a/libuavcan/include/uavcan/internal/transport/dispatcher.hpp +++ b/libuavcan/include/uavcan/internal/transport/dispatcher.hpp @@ -37,7 +37,7 @@ class Dispatcher : Noncopyable }; public: - enum Mode { UNIQUE_LISTENER, MANY_LISTENERS }; + enum Mode { UniqueListener, ManyListeners }; bool add(TransferListenerBase* listener, Mode mode); void remove(TransferListenerBase* listener); diff --git a/libuavcan/include/uavcan/internal/transport/outgoing_transfer_registry.hpp b/libuavcan/include/uavcan/internal/transport/outgoing_transfer_registry.hpp index 3eae5d3d7c..ac60d8b63a 100644 --- a/libuavcan/include/uavcan/internal/transport/outgoing_transfer_registry.hpp +++ b/libuavcan/include/uavcan/internal/transport/outgoing_transfer_registry.hpp @@ -31,12 +31,12 @@ public: , transfer_type_(transfer_type) , destination_node_id_(destination_node_id) { - assert((transfer_type == TRANSFER_TYPE_MESSAGE_BROADCAST) == destination_node_id.isBroadcast()); + assert((transfer_type == TransferTypeMessageBroadcast) == destination_node_id.isBroadcast()); /* Service response transfers must use the same Transfer ID as matching service request transfer, * so this registry is not applicable for service response transfers at all. */ - assert(transfer_type != TRANSFER_TYPE_SERVICE_RESPONSE); + assert(transfer_type != TransferTypeServiceResponse); } bool operator==(const OutgoingTransferRegistryKey& rhs) const @@ -59,7 +59,7 @@ public: }; -template +template class OutgoingTransferRegistry : public IOutgoingTransferRegistry, Noncopyable { #pragma pack(push, 1) @@ -88,7 +88,7 @@ class OutgoingTransferRegistry : public IOutgoingTransferRegistry, Noncopyable } }; - Map map_; + Map map_; public: OutgoingTransferRegistry(IAllocator& allocator) diff --git a/libuavcan/include/uavcan/internal/transport/transfer.hpp b/libuavcan/include/uavcan/internal/transport/transfer.hpp index 29f7393f16..49f7ff8e6d 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer.hpp @@ -12,15 +12,15 @@ namespace uavcan { -enum { MAX_TRANSFER_PAYLOAD_LEN = 439 }; ///< According to the standard +enum { MaxTransferPayloadLen = 439 }; ///< According to the standard enum TransferType { - TRANSFER_TYPE_SERVICE_RESPONSE = 0, - TRANSFER_TYPE_SERVICE_REQUEST = 1, - TRANSFER_TYPE_MESSAGE_BROADCAST = 2, - TRANSFER_TYPE_MESSAGE_UNICAST = 3, - NUM_TRANSFER_TYPES = 4 + TransferTypeServiceResponse = 0, + TransferTypeServiceRequest = 1, + TransferTypeMessageBroadcast = 2, + TransferTypeMessageUnicast = 3, + NumTransferTypes = 4 }; @@ -28,18 +28,18 @@ class NodeID { enum { - VALUE_BROADCAST = 0, - VALUE_INVALID = 0xFF + ValueBroadcast = 0, + ValueInvalid = 0xFF }; uint8_t value_; public: - enum { BITLEN = 7 }; - enum { MAX = (1 << BITLEN) - 1 }; + enum { BitLen = 7 }; + enum { Max = (1 << BitLen) - 1 }; - static const NodeID BROADCAST; + static const NodeID Broadcast; - NodeID() : value_(VALUE_INVALID) { } + NodeID() : value_(ValueInvalid) { } NodeID(uint8_t value) : value_(value) @@ -49,9 +49,9 @@ public: uint8_t get() const { return value_; } - bool isValid() const { return value_ <= MAX; } - bool isBroadcast() const { return value_ == VALUE_BROADCAST; } - bool isUnicast() const { return (value_ <= MAX) && (value_ != VALUE_BROADCAST); } + bool isValid() const { return value_ <= Max; } + bool isBroadcast() const { return value_ == ValueBroadcast; } + bool isUnicast() const { return (value_ <= Max) && (value_ != ValueBroadcast); } bool operator!=(NodeID rhs) const { return !operator==(rhs); } bool operator==(NodeID rhs) const { return value_ == rhs.value_; } @@ -63,8 +63,8 @@ class TransferID uint8_t value_; public: - enum { BITLEN = 3 }; - enum { MAX = (1 << BITLEN) - 1 }; + enum { BitLen = 3 }; + enum { Max = (1 << BitLen) - 1 }; TransferID() : value_(0) @@ -73,7 +73,7 @@ public: TransferID(uint8_t value) // implicit : value_(value) { - value_ &= MAX; + value_ &= Max; assert(value == value_); } @@ -82,12 +82,12 @@ public: void increment() { - value_ = (value_ + 1) & MAX; + value_ = (value_ + 1) & Max; } uint8_t get() const { - assert(value_ <= MAX); + assert(value_ <= Max); return value_; } @@ -111,11 +111,11 @@ class Frame bool last_frame_; public: - enum { DATA_TYPE_ID_MAX = 1023 }; - enum { INDEX_MAX = 62 }; // 63 (or 0b111111) is reserved + enum { MaxDataTypeID = 1023 }; + enum { MaxIndex = 62 }; // 63 (or 0b111111) is reserved Frame() - : transfer_type_(TransferType(NUM_TRANSFER_TYPES)) // That is invalid value + : transfer_type_(TransferType(NumTransferTypes)) // That is invalid value , data_type_id_(0) , payload_len_(0) , frame_index_(0) @@ -134,10 +134,10 @@ public: , transfer_id_(transfer_id) , last_frame_(last_frame) { - assert((transfer_type == TRANSFER_TYPE_MESSAGE_BROADCAST) == dst_node_id.isBroadcast()); - assert(data_type_id <= DATA_TYPE_ID_MAX); + assert((transfer_type == TransferTypeMessageBroadcast) == dst_node_id.isBroadcast()); + assert(data_type_id <= MaxDataTypeID); assert(src_node_id != dst_node_id); - assert(frame_index <= INDEX_MAX); + assert(frame_index <= MaxIndex); } int getMaxPayloadLen() const; diff --git a/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp b/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp index 2d2ba36a1b..72b2a585bf 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer_buffer.hpp @@ -99,8 +99,8 @@ class DynamicTransferBufferManagerEntry : public TransferBufferManagerEntry, { struct Block : LinkedListNode { - enum { SIZE = MEM_POOL_BLOCK_SIZE - sizeof(LinkedListNode) }; - uint8_t data[SIZE]; + enum { Size = MemPoolBlockSize - sizeof(LinkedListNode) }; + uint8_t data[Size]; static Block* instantiate(IAllocator& allocator); static void destroy(Block*& obj, IAllocator& allocator); @@ -124,7 +124,7 @@ public: , max_write_pos_(0) , max_size_(max_size) { - StaticAssert<(Block::SIZE > 8)>::check(); + StaticAssert<(Block::Size > 8)>::check(); IsDynamicallyAllocatable::check(); IsDynamicallyAllocatable::check(); } @@ -145,18 +145,18 @@ public: /** * Standalone static buffer */ -template +template class StaticTransferBuffer : public ITransferBuffer { - uint8_t data_[SIZE]; + uint8_t data_[Size]; unsigned int max_write_pos_; public: StaticTransferBuffer() : max_write_pos_(0) { - StaticAssert<(SIZE > 0)>::check(); - std::fill(data_, data_ + SIZE, 0); + StaticAssert<(Size > 0)>::check(); + std::fill(data_, data_ + Size, 0); } int read(unsigned int offset, uint8_t* data, unsigned int len) const @@ -182,11 +182,11 @@ public: assert(0); return -1; } - if (offset >= SIZE) + if (offset >= Size) return 0; - if ((offset + len) > SIZE) - len = SIZE - offset; - assert((offset + len) <= SIZE); + if ((offset + len) > Size) + len = Size - offset; + assert((offset + len) <= Size); std::copy(data, data + len, data_ + offset); max_write_pos_ = std::max(offset + len, max_write_pos_); return len; @@ -196,7 +196,7 @@ public: { max_write_pos_ = 0; #if UAVCAN_DEBUG - std::fill(data_, data_ + SIZE, 0); + std::fill(data_, data_ + Size, 0); #endif } @@ -207,10 +207,10 @@ public: /** * Statically allocated storage for buffer manager */ -template +template class StaticTransferBufferManagerEntry : public TransferBufferManagerEntry { - StaticTransferBuffer buf_; + StaticTransferBuffer buf_; void resetImpl() { @@ -238,19 +238,19 @@ public: // Resetting self and moving all data from the source TransferBufferManagerEntry::reset(tbme->getKey()); - const int res = tbme->read(0, buf_.getRawPtr(), SIZE); + const int res = tbme->read(0, buf_.getRawPtr(), Size); if (res < 0) { TransferBufferManagerEntry::reset(); return false; } buf_.setMaxWritePos(res); - if (res < int(SIZE)) + if (res < int(Size)) return true; // Now we need to make sure that all data can fit the storage uint8_t dummy = 0; - if (tbme->read(SIZE, &dummy, 1) > 0) + if (tbme->read(Size, &dummy, 1) > 0) { TransferBufferManagerEntry::reset(); // Damn, the buffer was too large return false; @@ -294,18 +294,18 @@ public: /** * Buffer manager implementation. */ -template +template class TransferBufferManager : public ITransferBufferManager, Noncopyable { - typedef StaticTransferBufferManagerEntry StaticBufferType; + typedef StaticTransferBufferManagerEntry StaticBufferType; - StaticBufferType static_buffers_[NUM_STATIC_BUFS]; + StaticBufferType static_buffers_[NumStaticBufs]; LinkedListRoot dynamic_buffers_; IAllocator& allocator_; StaticBufferType* findFirstStatic(const TransferBufferManagerKey& key) { - for (unsigned int i = 0; i < NUM_STATIC_BUFS; i++) + for (unsigned int i = 0; i < NumStaticBufs; i++) { if (static_buffers_[i].getKey() == key) return static_buffers_ + i; @@ -350,7 +350,7 @@ class TransferBufferManager : public ITransferBufferManager, Noncopyable * This should never happen during normal operation because dynamic buffers are limited in growth. */ UAVCAN_TRACE("TransferBufferManager", "Storage optimization: MIGRATION FAILURE %s MAXSIZE %u", - dyn->getKey().toString().c_str(), MAX_BUF_SIZE); + dyn->getKey().toString().c_str(), MaxBufSize); assert(0); sb->reset(); break; @@ -362,8 +362,8 @@ public: TransferBufferManager(IAllocator& allocator) : allocator_(allocator) { - StaticAssert<(MAX_BUF_SIZE > 0)>::check(); - StaticAssert<(NUM_STATIC_BUFS > 0)>::check(); + StaticAssert<(MaxBufSize > 0)>::check(); + StaticAssert<(NumStaticBufs > 0)>::check(); } ~TransferBufferManager() @@ -403,7 +403,7 @@ public: TransferBufferManagerEntry* tbme = findFirstStatic(TransferBufferManagerKey()); if (tbme == NULL) { - DynamicTransferBufferManagerEntry* dyn = DynamicTransferBufferManagerEntry::instantiate(allocator_, MAX_BUF_SIZE); + DynamicTransferBufferManagerEntry* dyn = DynamicTransferBufferManagerEntry::instantiate(allocator_, MaxBufSize); tbme = dyn; if (dyn == NULL) return NULL; // Epic fail. @@ -454,7 +454,7 @@ public: unsigned int getNumStaticBuffers() const { unsigned int res = 0; - for (unsigned int i = 0; i < NUM_STATIC_BUFS; i++) + for (unsigned int i = 0; i < NumStaticBufs; i++) { if (!static_buffers_[i].isEmpty()) res++; diff --git a/libuavcan/include/uavcan/internal/transport/transfer_listener.hpp b/libuavcan/include/uavcan/internal/transport/transfer_listener.hpp index ac3c59e873..d9ce3b0b44 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer_listener.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer_listener.hpp @@ -95,7 +95,7 @@ class TransferListenerBase : public LinkedListNode protected: TransferListenerBase(const DataTypeDescriptor& data_type) : data_type_(data_type) - , crc_base_(data_type.hash.value, DataTypeHash::NUM_BYTES) + , crc_base_(data_type.hash.value, DataTypeHash::NumBytes) { } virtual ~TransferListenerBase() { } @@ -114,12 +114,12 @@ public: /** * This class should be derived by transfer receivers (subscribers, servers, callers). */ -template +template class TransferListener : public TransferListenerBase, Noncopyable { - typedef TransferBufferManager BufferManager; + typedef TransferBufferManager BufferManager; BufferManager bufmgr_; - Map receivers_; + Map receivers_; void handleFrame(const RxFrame& frame) { @@ -185,7 +185,7 @@ public: , bufmgr_(allocator) , receivers_(allocator) { - StaticAssert<(NUM_STATIC_RECEIVERS >= NUM_STATIC_BUFS)>::check(); // Otherwise it would be meaningless + StaticAssert<(NumStaticReceivers >= NumStaticBufs)>::check(); // Otherwise it would be meaningless } ~TransferListener() diff --git a/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp b/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp index a41ad96e0a..d030ad653c 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer_receiver.hpp @@ -15,15 +15,15 @@ namespace uavcan class TransferReceiver { public: - enum ResultCode { RESULT_NOT_COMPLETE, RESULT_COMPLETE, RESULT_SINGLE_FRAME }; + enum ResultCode { ResultNotComplete, ResultComplete, ResultSingleFrame }; - static const uint32_t DEFAULT_TRANSFER_INTERVAL = 500 * 1000UL; - static const uint32_t MIN_TRANSFER_INTERVAL = 1 * 1000UL; - static const uint32_t MAX_TRANSFER_INTERVAL = 10 * 1000 * 1000UL; + static const uint32_t DefaultTransferInterval = 500 * 1000UL; + static const uint32_t MinTransferInterval = 1 * 1000UL; + static const uint32_t MaxTransferInterval = 10 * 1000 * 1000UL; private: - enum TidRelation { TID_SAME, TID_REPEAT, TID_FUTURE }; - enum { IFACE_INDEX_NOTSET = 0xFF }; + enum TidRelation { TidSame, TidRepeat, TidFuture }; + enum { IfaceIndexNotSet = 0xFF }; uint64_t prev_transfer_ts_monotonic_; uint64_t this_transfer_ts_monotonic_; @@ -35,7 +35,7 @@ private: uint8_t iface_index_; uint8_t next_frame_index_; - bool isInitialized() const { return iface_index_ != IFACE_INDEX_NOTSET; } + bool isInitialized() const { return iface_index_ != IfaceIndexNotSet; } TidRelation getTidRelation(const RxFrame& frame) const; @@ -51,10 +51,10 @@ public: : prev_transfer_ts_monotonic_(0) , this_transfer_ts_monotonic_(0) , first_frame_ts_utc_(0) - , transfer_interval_(DEFAULT_TRANSFER_INTERVAL) + , transfer_interval_(DefaultTransferInterval) , this_transfer_crc_(0) , buffer_write_pos_(0) - , iface_index_(IFACE_INDEX_NOTSET) + , iface_index_(IfaceIndexNotSet) , next_frame_index_(0) { } diff --git a/libuavcan/include/uavcan/internal/transport/transfer_sender.hpp b/libuavcan/include/uavcan/internal/transport/transfer_sender.hpp index 7f182af9cd..1889a4e3af 100644 --- a/libuavcan/include/uavcan/internal/transport/transfer_sender.hpp +++ b/libuavcan/include/uavcan/internal/transport/transfer_sender.hpp @@ -16,7 +16,7 @@ namespace uavcan class TransferSender { - static const uint64_t DEFAULT_MAX_TRANSFER_INTERVAL = 60 * 1000 * 1000; + static const uint64_t DefaultMaxTransferInterval = 60 * 1000 * 1000; const uint64_t max_transfer_interval_; const DataTypeDescriptor& data_type_; @@ -27,11 +27,11 @@ class TransferSender public: TransferSender(Dispatcher& dispatcher, const DataTypeDescriptor& data_type, CanTxQueue::Qos qos, - uint64_t max_transfer_interval = DEFAULT_MAX_TRANSFER_INTERVAL) + uint64_t max_transfer_interval = DefaultMaxTransferInterval) : max_transfer_interval_(max_transfer_interval) , data_type_(data_type) , qos_(qos) - , crc_base_(data_type.hash.value, DataTypeHash::NUM_BYTES) + , crc_base_(data_type.hash.value, DataTypeHash::NumBytes) , dispatcher_(dispatcher) { } diff --git a/libuavcan/include/uavcan/internal/util.hpp b/libuavcan/include/uavcan/internal/util.hpp index ba99ca6279..3961b33351 100644 --- a/libuavcan/include/uavcan/internal/util.hpp +++ b/libuavcan/include/uavcan/internal/util.hpp @@ -12,7 +12,7 @@ namespace uavcan * Usage: * StaticAssert::check(); */ -template +template struct StaticAssert; template <> @@ -44,7 +44,7 @@ template struct EnableIf { typedef T Type; }; -template +template struct StaticIf; template diff --git a/libuavcan/src/can_driver.cpp b/libuavcan/src/can_driver.cpp index 38858d1a3f..b8042bdf40 100644 --- a/libuavcan/src/can_driver.cpp +++ b/libuavcan/src/can_driver.cpp @@ -10,17 +10,17 @@ namespace uavcan { -const uint32_t CanFrame::MASK_STDID; -const uint32_t CanFrame::MASK_EXTID; -const uint32_t CanFrame::FLAG_EFF; -const uint32_t CanFrame::FLAG_RTR; +const uint32_t CanFrame::MaskStdID; +const uint32_t CanFrame::MaskExtID; +const uint32_t CanFrame::FlagEFF; +const uint32_t CanFrame::FlagRTR; std::string CanFrame::toString(StringRepresentation mode) const { using std::snprintf; - assert(mode == STR_TIGHT || mode == STR_ALIGNED); + assert(mode == StrTight || mode == StrAligned); static const int ASCII_COLUMN_OFFSET = 36; @@ -28,17 +28,17 @@ std::string CanFrame::toString(StringRepresentation mode) const char* wpos = buf, *epos = buf + sizeof(buf); std::fill(buf, buf + sizeof(buf), 0); - if (id & FLAG_EFF) + if (id & FlagEFF) { - wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MASK_EXTID)); + wpos += snprintf(wpos, epos - wpos, "0x%08x ", (unsigned int)(id & MaskExtID)); } else { - const char* const fmt = (mode == STR_ALIGNED) ? " 0x%03x " : "0x%03x "; - wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MASK_STDID)); + const char* const fmt = (mode == StrAligned) ? " 0x%03x " : "0x%03x "; + wpos += snprintf(wpos, epos - wpos, fmt, (unsigned int)(id & MaskStdID)); } - if (id & FLAG_RTR) + if (id & FlagRTR) { wpos += snprintf(wpos, epos - wpos, " RTR"); } @@ -47,7 +47,7 @@ std::string CanFrame::toString(StringRepresentation mode) const for (int dlen = 0; dlen < dlc; dlen++) // hex bytes wpos += snprintf(wpos, epos - wpos, " %02x", (unsigned int)data[dlen]); - while (mode == STR_ALIGNED && wpos < buf + ASCII_COLUMN_OFFSET) // alignment + while (mode == StrAligned && wpos < buf + ASCII_COLUMN_OFFSET) // alignment *wpos++ = ' '; wpos += snprintf(wpos, epos - wpos, " \'"); // ascii diff --git a/libuavcan/src/marshalling/bit_stream.cpp b/libuavcan/src/marshalling/bit_stream.cpp index b169de7b4f..a9dda27ee0 100644 --- a/libuavcan/src/marshalling/bit_stream.cpp +++ b/libuavcan/src/marshalling/bit_stream.cpp @@ -12,11 +12,11 @@ namespace uavcan int BitStream::write(const uint8_t* bytes, const int bitlen) { // Temporary buffer is needed to merge new bits with cached unaligned bits from the last write() (see byte_cache_) - uint8_t tmp[MAX_BYTES_PER_RW + 1]; + uint8_t tmp[MaxBytesPerRW + 1]; // Tmp space must be large enough to accomodate new bits AND unaligned bits from the last write() const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8)); - assert(MAX_BYTES_PER_RW >= bytelen); + assert(MaxBytesPerRW >= bytelen); tmp[0] = tmp[bytelen - 1] = 0; std::fill(tmp, tmp + bytelen, 0); @@ -39,29 +39,29 @@ int BitStream::write(const uint8_t* bytes, const int bitlen) if (write_res < 0) return write_res; if (write_res < bytelen) - return RESULT_OUT_OF_BUFFER; + return ResultOutOfBuffer; bit_offset_ = new_bit_offset; - return RESULT_OK; + return ResultOk; } int BitStream::read(uint8_t* bytes, const int bitlen) { - uint8_t tmp[MAX_BYTES_PER_RW + 1]; + uint8_t tmp[MaxBytesPerRW + 1]; const int bytelen = bitlenToBytelen(bitlen + (bit_offset_ % 8)); - assert(MAX_BYTES_PER_RW >= bytelen); + assert(MaxBytesPerRW >= bytelen); const int read_res = buf_.read(bit_offset_ / 8, tmp, bytelen); if (read_res < 0) return read_res; if (read_res < bytelen) - return RESULT_OUT_OF_BUFFER; + return ResultOutOfBuffer; std::fill(bytes, bytes + bitlenToBytelen(bitlen), 0); copyBitArray(tmp, bit_offset_ % 8, bitlen, bytes, 0); bit_offset_ += bitlen; - return RESULT_OK; + return ResultOk; } std::string BitStream::toString() const diff --git a/libuavcan/src/transport/can_io.cpp b/libuavcan/src/transport/can_io.cpp index 7bc8033190..0938dc0ca5 100644 --- a/libuavcan/src/transport/can_io.cpp +++ b/libuavcan/src/transport/can_io.cpp @@ -55,10 +55,10 @@ std::string CanTxQueue::Entry::toString() const std::string str_qos; switch (qos) { - case VOLATILE: + case Volatile: str_qos = " "; break; - case PERSISTENT: + case Persistent: str_qos = " "; break; default: @@ -196,7 +196,7 @@ bool CanTxQueue::topPriorityHigherOrEqual(const CanFrame& rhs_frame) const */ int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t monotonic_tx_deadline) { - assert(iface_index >= 0 && iface_index < MAX_IFACES); + assert(iface_index >= 0 && iface_index < MaxIfaces); ICanIface* const iface = driver_.getIface(iface_index); if (iface == NULL) { @@ -216,7 +216,7 @@ int CanIOManager::sendToIface(int iface_index, const CanFrame& frame, uint64_t m int CanIOManager::sendFromTxQueue(int iface_index) { - assert(iface_index >= 0 && iface_index < MAX_IFACES); + assert(iface_index >= 0 && iface_index < MaxIfaces); CanTxQueue::Entry* entry = tx_queues_[iface_index].peek(); if (entry == NULL) return 0; @@ -246,14 +246,14 @@ uint64_t CanIOManager::getTimeUntilMonotonicDeadline(uint64_t monotonic_deadline int CanIOManager::getNumIfaces() const { const int num = driver_.getNumIfaces(); - assert(num > 0 && num <= MAX_IFACES); - return std::min(std::max(num, 0), (int)MAX_IFACES); + assert(num > 0 && num <= MaxIfaces); + return std::min(std::max(num, 0), (int)MaxIfaces); } uint64_t CanIOManager::getNumErrors(int iface_index) const { ICanIface* const iface = driver_.getIface(iface_index); - if (iface == NULL || iface_index >= MAX_IFACES || iface_index < 0) + if (iface == NULL || iface_index >= MaxIfaces || iface_index < 0) { assert(0); return std::numeric_limits::max(); diff --git a/libuavcan/src/transport/crc.cpp b/libuavcan/src/transport/crc.cpp index e4bd64fa81..cec7475aed 100644 --- a/libuavcan/src/transport/crc.cpp +++ b/libuavcan/src/transport/crc.cpp @@ -9,7 +9,7 @@ namespace uavcan { // print ', '.join(map(lambda x: '%04x' % x, map(lambda x: int(x, 0), c.crc_ccitt_tab))) -const uint16_t Crc16::TABLE[256] = +const uint16_t Crc16::Table[256] = { 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, @@ -47,7 +47,7 @@ const uint16_t Crc16::TABLE[256] = uint16_t Crc16::add(uint8_t byte) { - value_ = (value_ << 8) ^ TABLE[((value_ >> 8) ^ byte) & 0xFF]; + value_ = (value_ << 8) ^ Table[((value_ >> 8) ^ byte) & 0xFF]; return value_; } diff --git a/libuavcan/src/transport/dispatcher.cpp b/libuavcan/src/transport/dispatcher.cpp index aad6e9b1fb..397bd18acd 100644 --- a/libuavcan/src/transport/dispatcher.cpp +++ b/libuavcan/src/transport/dispatcher.cpp @@ -13,7 +13,7 @@ namespace uavcan */ bool Dispatcher::ListenerRegister::add(TransferListenerBase* listener, Mode mode) { - if (mode == UNIQUE_LISTENER) + if (mode == UniqueListener) { TransferListenerBase* p = list_.get(); while (p) @@ -68,7 +68,7 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame) return; } - if ((frame.getDstNodeID() != NodeID::BROADCAST) && + if ((frame.getDstNodeID() != NodeID::Broadcast) && (frame.getDstNodeID() != getSelfNodeID())) { return; @@ -76,16 +76,16 @@ void Dispatcher::handleFrame(const CanRxFrame& can_frame) switch (frame.getTransferType()) { - case TRANSFER_TYPE_MESSAGE_BROADCAST: - case TRANSFER_TYPE_MESSAGE_UNICAST: + case TransferTypeMessageBroadcast: + case TransferTypeMessageUnicast: lmsg_.handleFrame(frame); break; - case TRANSFER_TYPE_SERVICE_REQUEST: + case TransferTypeServiceRequest: lsrv_req_.handleFrame(frame); break; - case TRANSFER_TYPE_SERVICE_RESPONSE: + case TransferTypeServiceResponse: lsrv_resp_.handleFrame(frame); break; @@ -145,32 +145,32 @@ void Dispatcher::cleanup(uint64_t ts_monotonic) bool Dispatcher::registerMessageListener(TransferListenerBase* listener) { - if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_MESSAGE) + if (listener->getDataTypeDescriptor().kind != DataTypeKindMessage) { assert(0); return false; } - return lmsg_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple subscribers are OK + return lmsg_.add(listener, ListenerRegister::ManyListeners); // Multiple subscribers are OK } bool Dispatcher::registerServiceRequestListener(TransferListenerBase* listener) { - if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE) + if (listener->getDataTypeDescriptor().kind != DataTypeKindService) { assert(0); return false; } - return lsrv_req_.add(listener, ListenerRegister::UNIQUE_LISTENER); // Only one server per data type + return lsrv_req_.add(listener, ListenerRegister::UniqueListener); // Only one server per data type } bool Dispatcher::registerServiceResponseListener(TransferListenerBase* listener) { - if (listener->getDataTypeDescriptor().kind != DATA_TYPE_KIND_SERVICE) + if (listener->getDataTypeDescriptor().kind != DataTypeKindService) { assert(0); return false; } - return lsrv_resp_.add(listener, ListenerRegister::MANY_LISTENERS); // Multiple callers may call same srv + return lsrv_resp_.add(listener, ListenerRegister::ManyListeners); // Multiple callers may call same srv } void Dispatcher::unregisterMessageListener(TransferListenerBase* listener) diff --git a/libuavcan/src/transport/transfer.cpp b/libuavcan/src/transport/transfer.cpp index 978db48206..079532ae09 100644 --- a/libuavcan/src/transport/transfer.cpp +++ b/libuavcan/src/transport/transfer.cpp @@ -12,7 +12,7 @@ namespace uavcan /** * NodeID */ -const NodeID NodeID::BROADCAST(VALUE_BROADCAST); +const NodeID NodeID::Broadcast(ValueBroadcast); /** * TransferID @@ -21,9 +21,9 @@ int TransferID::forwardDistance(TransferID rhs) const { int d = int(rhs.get()) - int(get()); if (d < 0) - d += 1 << BITLEN; + d += 1 << BitLen; - assert(((get() + d) & MAX) == rhs.get()); + assert(((get() + d) & Max) == rhs.get()); return d; } @@ -34,13 +34,13 @@ int Frame::getMaxPayloadLen() const { switch (getTransferType()) { - case TRANSFER_TYPE_MESSAGE_BROADCAST: + case TransferTypeMessageBroadcast: return sizeof(payload_); break; - case TRANSFER_TYPE_SERVICE_RESPONSE: - case TRANSFER_TYPE_SERVICE_REQUEST: - case TRANSFER_TYPE_MESSAGE_UNICAST: + case TransferTypeServiceResponse: + case TransferTypeServiceRequest: + case TransferTypeMessageUnicast: return sizeof(payload_) - 1; break; @@ -69,7 +69,7 @@ inline static uint32_t bitunpack(uint32_t val) bool Frame::parse(const CanFrame& can_frame) { - if ((can_frame.id & CanFrame::FLAG_RTR) || !(can_frame.id & CanFrame::FLAG_EFF)) + if ((can_frame.id & CanFrame::FlagRTR) || !(can_frame.id & CanFrame::FlagEFF)) return false; if (can_frame.dlc > sizeof(CanFrame::data)) @@ -81,7 +81,7 @@ bool Frame::parse(const CanFrame& can_frame) /* * CAN ID parsing */ - const uint32_t id = can_frame.id & CanFrame::MASK_EXTID; + const uint32_t id = can_frame.id & CanFrame::MaskExtID; transfer_id_ = bitunpack<0, 3>(id); last_frame_ = bitunpack<3, 1>(id); frame_index_ = bitunpack<4, 6>(id); @@ -94,15 +94,15 @@ bool Frame::parse(const CanFrame& can_frame) */ switch (transfer_type_) { - case TRANSFER_TYPE_MESSAGE_BROADCAST: - dst_node_id_ = NodeID::BROADCAST; + case TransferTypeMessageBroadcast: + dst_node_id_ = NodeID::Broadcast; payload_len_ = can_frame.dlc; std::copy(can_frame.data, can_frame.data + can_frame.dlc, payload_); break; - case TRANSFER_TYPE_SERVICE_RESPONSE: - case TRANSFER_TYPE_SERVICE_REQUEST: - case TRANSFER_TYPE_MESSAGE_UNICAST: + case TransferTypeServiceResponse: + case TransferTypeServiceRequest: + case TransferTypeMessageUnicast: if (can_frame.dlc < 1) return false; if (can_frame.data[0] & 0x80) // RESERVED, must be zero @@ -133,7 +133,7 @@ bool Frame::compile(CanFrame& out_can_frame) const return false; } - out_can_frame.id = CanFrame::FLAG_EFF | + out_can_frame.id = CanFrame::FlagEFF | bitpack<0, 3>(transfer_id_.get()) | bitpack<3, 1>(last_frame_) | bitpack<4, 6>(frame_index_) | @@ -143,14 +143,14 @@ bool Frame::compile(CanFrame& out_can_frame) const switch (transfer_type_) { - case TRANSFER_TYPE_MESSAGE_BROADCAST: + case TransferTypeMessageBroadcast: out_can_frame.dlc = payload_len_; std::copy(payload_, payload_ + payload_len_, out_can_frame.data); break; - case TRANSFER_TYPE_SERVICE_RESPONSE: - case TRANSFER_TYPE_SERVICE_REQUEST: - case TRANSFER_TYPE_MESSAGE_UNICAST: + case TransferTypeServiceResponse: + case TransferTypeServiceRequest: + case TransferTypeMessageUnicast: assert((payload_len_ + 1) <= sizeof(CanFrame::data)); out_can_frame.data[0] = dst_node_id_.get(); out_can_frame.dlc = payload_len_ + 1; @@ -168,15 +168,15 @@ bool Frame::isValid() const { // Refer to the specification for the detailed explanation of the checks const bool invalid = - (frame_index_ > INDEX_MAX) || - ((frame_index_ == INDEX_MAX) && !last_frame_) || + (frame_index_ > MaxIndex) || + ((frame_index_ == MaxIndex) && !last_frame_) || (!src_node_id_.isUnicast()) || (!dst_node_id_.isValid()) || (src_node_id_ == dst_node_id_) || - ((transfer_type_ == TRANSFER_TYPE_MESSAGE_BROADCAST) != dst_node_id_.isBroadcast()) || - (transfer_type_ >= NUM_TRANSFER_TYPES) || + ((transfer_type_ == TransferTypeMessageBroadcast) != dst_node_id_.isBroadcast()) || + (transfer_type_ >= NumTransferTypes) || (payload_len_ > getMaxPayloadLen()) || - (data_type_id_ > DATA_TYPE_ID_MAX); + (data_type_id_ > MaxDataTypeID); return !invalid; } diff --git a/libuavcan/src/transport/transfer_buffer.cpp b/libuavcan/src/transport/transfer_buffer.cpp index 0f3970dc4b..6c0338b6b8 100644 --- a/libuavcan/src/transport/transfer_buffer.cpp +++ b/libuavcan/src/transport/transfer_buffer.cpp @@ -45,7 +45,7 @@ void DynamicTransferBufferManagerEntry::Block::read(uint8_t*& outptr, unsigned i unsigned int& total_offset, unsigned int& left_to_read) { assert(outptr); - for (int i = 0; (i < Block::SIZE) && (left_to_read > 0); i++, total_offset++) + for (int i = 0; (i < Block::Size) && (left_to_read > 0); i++, total_offset++) { if (total_offset >= target_offset) { @@ -59,7 +59,7 @@ void DynamicTransferBufferManagerEntry::Block::write(const uint8_t*& inptr, unsi unsigned int& total_offset, unsigned int& left_to_write) { assert(inptr); - for (int i = 0; (i < Block::SIZE) && (left_to_write > 0); i++, total_offset++) + for (int i = 0; (i < Block::Size) && (left_to_write > 0); i++, total_offset++) { if (total_offset >= target_offset) { diff --git a/libuavcan/src/transport/transfer_listener.cpp b/libuavcan/src/transport/transfer_listener.cpp index ed6215a7a3..f3e64cbe4f 100644 --- a/libuavcan/src/transport/transfer_listener.cpp +++ b/libuavcan/src/transport/transfer_listener.cpp @@ -97,17 +97,17 @@ void TransferListenerBase::handleReception(TransferReceiver& receiver, const RxF { switch (receiver.addFrame(frame, tba)) { - case TransferReceiver::RESULT_NOT_COMPLETE: + case TransferReceiver::ResultNotComplete: return; - case TransferReceiver::RESULT_SINGLE_FRAME: + case TransferReceiver::ResultSingleFrame: { SingleFrameIncomingTransfer it(frame); handleIncomingTransfer(it); return; } - case TransferReceiver::RESULT_COMPLETE: + case TransferReceiver::ResultComplete: { const ITransferBuffer* tbb = tba.access(); if (tbb == NULL) diff --git a/libuavcan/src/transport/transfer_receiver.cpp b/libuavcan/src/transport/transfer_receiver.cpp index c124ac7cd3..bb68eb5441 100644 --- a/libuavcan/src/transport/transfer_receiver.cpp +++ b/libuavcan/src/transport/transfer_receiver.cpp @@ -8,24 +8,23 @@ #include #include #include +#include namespace uavcan { -static const int CRC_LEN = 2; - -const uint32_t TransferReceiver::DEFAULT_TRANSFER_INTERVAL; -const uint32_t TransferReceiver::MIN_TRANSFER_INTERVAL; -const uint32_t TransferReceiver::MAX_TRANSFER_INTERVAL; +const uint32_t TransferReceiver::DefaultTransferInterval; +const uint32_t TransferReceiver::MinTransferInterval; +const uint32_t TransferReceiver::MaxTransferInterval; TransferReceiver::TidRelation TransferReceiver::getTidRelation(const RxFrame& frame) const { const int distance = tid_.forwardDistance(frame.getTransferID()); if (distance == 0) - return TID_SAME; - if (distance < ((1 << TransferID::BITLEN) / 2)) - return TID_FUTURE; - return TID_REPEAT; + return TidSame; + if (distance < ((1 << TransferID::BitLen) / 2)) + return TidFuture; + return TidRepeat; } void TransferReceiver::updateTransferTimings() @@ -40,7 +39,7 @@ void TransferReceiver::updateTransferTimings() (prev_transfer_ts_monotonic_ >= prev_prev_ts)) { uint64_t interval = prev_transfer_ts_monotonic_ - prev_prev_ts; - interval = std::max(std::min(interval, uint64_t(MAX_TRANSFER_INTERVAL)), uint64_t(MIN_TRANSFER_INTERVAL)); + interval = std::max(std::min(interval, uint64_t(MaxTransferInterval)), uint64_t(MinTransferInterval)); transfer_interval_ = static_cast((uint64_t(transfer_interval_) * 7 + interval) / 8); } } @@ -57,13 +56,13 @@ bool TransferReceiver::validate(const RxFrame& frame) const if (iface_index_ != frame.getIfaceIndex()) return false; - if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < CRC_LEN)) + if (frame.isFirst() && !frame.isLast() && (frame.getPayloadLen() < Crc16::NumBytes)) { UAVCAN_TRACE("TransferReceiver", "CRC expected, %s", frame.toString().c_str()); return false; } - if ((frame.getIndex() == Frame::INDEX_MAX) && !frame.isLast()) + if ((frame.getIndex() == Frame::MaxIndex) && !frame.isLast()) { UAVCAN_TRACE("TransferReceiver", "Unterminated transfer, %s", frame.toString().c_str()); return false; @@ -76,7 +75,7 @@ bool TransferReceiver::validate(const RxFrame& frame) const return false; } - if (getTidRelation(frame) != TID_SAME) + if (getTidRelation(frame) != TidSame) { UAVCAN_TRACE("TransferReceiver", "Unexpected TID (current %i), %s", tid_.get(), frame.toString().c_str()); return false; @@ -91,13 +90,13 @@ bool TransferReceiver::writePayload(const RxFrame& frame, ITransferBuffer& buf) if (frame.isFirst()) // First frame contains CRC, we need to extract it now { - if (frame.getPayloadLen() < CRC_LEN) // Must have been validated earlier though. I think I'm paranoid. + if (frame.getPayloadLen() < Crc16::NumBytes) // Must have been validated earlier though. I think I'm paranoid. return false; this_transfer_crc_ = (payload[0] & 0xFF) | (uint16_t(payload[1] & 0xFF) << 8); // Little endian. - const int effective_payload_len = payload_len - CRC_LEN; - const int res = buf.write(buffer_write_pos_, payload + CRC_LEN, effective_payload_len); + const int effective_payload_len = payload_len - Crc16::NumBytes; + const int res = buf.write(buffer_write_pos_, payload + Crc16::NumBytes, effective_payload_len); const bool success = res == effective_payload_len; if (success) buffer_write_pos_ += effective_payload_len; @@ -128,7 +127,7 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra updateTransferTimings(); prepareForNextTransfer(); this_transfer_crc_ = 0; // SFT has no CRC - return RESULT_SINGLE_FRAME; + return ResultSingleFrame; } // Payload write @@ -139,14 +138,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra { UAVCAN_TRACE("TransferReceiver", "Failed to access the buffer, %s", frame.toString().c_str()); prepareForNextTransfer(); - return RESULT_NOT_COMPLETE; + return ResultNotComplete; } if (!writePayload(frame, *buf)) { UAVCAN_TRACE("TransferReceiver", "Payload write failed, %s", frame.toString().c_str()); tba.remove(); prepareForNextTransfer(); - return RESULT_NOT_COMPLETE; + return ResultNotComplete; } next_frame_index_++; @@ -154,14 +153,14 @@ TransferReceiver::ResultCode TransferReceiver::receive(const RxFrame& frame, Tra { updateTransferTimings(); prepareForNextTransfer(); - return RESULT_COMPLETE; + return ResultComplete; } - return RESULT_NOT_COMPLETE; + return ResultNotComplete; } bool TransferReceiver::isTimedOut(uint64_t ts_monotonic) const { - static const uint64_t INTERVAL_MULT = (1 << TransferID::BITLEN) / 2 + 1; + static const uint64_t INTERVAL_MULT = (1 << TransferID::BitLen) / 2 + 1; const uint64_t ts = this_transfer_ts_monotonic_; if (ts_monotonic <= ts) return false; @@ -174,7 +173,7 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr (frame.getMonotonicTimestamp() < prev_transfer_ts_monotonic_) || (frame.getMonotonicTimestamp() < this_transfer_ts_monotonic_)) { - return RESULT_NOT_COMPLETE; + return ResultNotComplete; } const bool not_initialized = !isInitialized(); @@ -188,8 +187,8 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr const bool need_restart = // FSM, the hard way (not_initialized) || (receiver_timed_out) || - (same_iface && first_fame && (tid_rel == TID_FUTURE)) || - (iface_timed_out && first_fame && (tid_rel == TID_FUTURE)); + (same_iface && first_fame && (tid_rel == TidFuture)) || + (iface_timed_out && first_fame && (tid_rel == TidFuture)); if (need_restart) { @@ -206,12 +205,12 @@ TransferReceiver::ResultCode TransferReceiver::addFrame(const RxFrame& frame, Tr if (!first_fame) { tid_.increment(); - return RESULT_NOT_COMPLETE; + return ResultNotComplete; } } if (!validate(frame)) - return RESULT_NOT_COMPLETE; + return ResultNotComplete; return receive(frame, tba); } diff --git a/libuavcan/test/can_driver.cpp b/libuavcan/test/can_driver.cpp index 7ff0f0805d..1805d05369 100644 --- a/libuavcan/test/can_driver.cpp +++ b/libuavcan/test/can_driver.cpp @@ -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()); diff --git a/libuavcan/test/common.hpp b/libuavcan/test/common.hpp index cafc0b50c3..2fb015cdca 100644 --- a/libuavcan/test/common.hpp +++ b/libuavcan/test/common.hpp @@ -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(str_data.c_str()), str_data.length()); } diff --git a/libuavcan/test/map.cpp b/libuavcan/test/map.cpp index 7d305870db..f9c48cd409 100644 --- a/libuavcan/test/map.cpp +++ b/libuavcan/test/map.cpp @@ -30,7 +30,7 @@ TEST(Map, Basic) using uavcan::Map; static const int POOL_BLOCKS = 3; - uavcan::PoolAllocator pool; + uavcan::PoolAllocator pool; uavcan::PoolManager<2> poolmgr; poolmgr.addPool(&pool); diff --git a/libuavcan/test/transport/can/io.cpp b/libuavcan/test/transport/can/io.cpp index f1529ff3af..ce8e624fbb 100644 --- a/libuavcan/test/transport/can/io.cpp +++ b/libuavcan/test/transport/can/io.cpp @@ -12,8 +12,8 @@ static bool rxFrameEquals(const uavcan::CanRxFrame& rxframe, const uavcan::CanFr if (static_cast(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(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 diff --git a/libuavcan/test/transport/can/tx_queue.cpp b/libuavcan/test/transport/can/tx_queue.cpp index 24582aa839..f8fb19ec75 100644 --- a/libuavcan/test/transport/can/tx_queue.cpp +++ b/libuavcan/test/transport/can/tx_queue.cpp @@ -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); diff --git a/libuavcan/test/transport/dispatcher.cpp b/libuavcan/test/transport/dispatcher.cpp index 3171b7e048..cb55b91b47 100644 --- a/libuavcan/test/transport/dispatcher.cpp +++ b/libuavcan/test/transport/dispatcher.cpp @@ -34,7 +34,7 @@ static const uavcan::NodeID SELF_NODE_ID(64); TEST(Dispatcher, Reception) { - uavcan::PoolAllocator pool; + uavcan::PoolAllocator 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 pool; + uavcan::PoolAllocator 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("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 diff --git a/libuavcan/test/transport/incoming_transfer.cpp b/libuavcan/test/transport/incoming_transfer.cpp index ac46af8384..7d667f8ad5 100644 --- a/libuavcan/test/transport/incoming_transfer.cpp +++ b/libuavcan/test/transport/incoming_transfer.cpp @@ -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++) diff --git a/libuavcan/test/transport/outgoing_transfer_registry.cpp b/libuavcan/test/transport/outgoing_transfer_registry.cpp index 4b8a1dc71b..597b55e984 100644 --- a/libuavcan/test/transport/outgoing_transfer_registry.cpp +++ b/libuavcan/test/transport/outgoing_transfer_registry.cpp @@ -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()); diff --git a/libuavcan/test/transport/transfer.cpp b/libuavcan/test/transport/transfer.cpp index 0baa7e9314..9101d0c4c8 100644 --- a/libuavcan/test/transport/transfer.cpp +++ b/libuavcan/test/transport/transfer.cpp @@ -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]; diff --git a/libuavcan/test/transport/transfer_buffer.cpp b/libuavcan/test/transport/transfer_buffer.cpp index d546423cb2..be660cb86e 100644 --- a/libuavcan/test/transport/transfer_buffer.cpp +++ b/libuavcan/test/transport/transfer_buffer.cpp @@ -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 pool; + uavcan::PoolAllocator 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 pool; + uavcan::PoolAllocator pool; uavcan::PoolManager<1> poolmgr; poolmgr.addPool(&pool); @@ -242,18 +242,18 @@ TEST(TransferBufferManager, Basic) std::auto_ptr 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 diff --git a/libuavcan/test/transport/transfer_listener.cpp b/libuavcan/test/transport/transfer_listener.cpp index a3f0dc3045..26800d1e8a 100644 --- a/libuavcan/test/transport/transfer_listener.cpp +++ b/libuavcan/test/transport/transfer_listener.cpp @@ -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 pool; + uavcan::PoolAllocator 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 ser_mft = serializeTransfer(tr_mft); std::vector 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 ser_mft = serializeTransfer(tr_mft); const std::vector 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 subscriber(type, poolmgr); + TestSubscriber 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); diff --git a/libuavcan/test/transport/transfer_receiver.cpp b/libuavcan/test/transport/transfer_receiver.cpp index 4b99ac8588..376c872d87 100644 --- a/libuavcan/test/transport/transfer_receiver.cpp +++ b/libuavcan/test/transport/transfer_receiver.cpp @@ -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 @@ -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); diff --git a/libuavcan/test/transport/transfer_sender.cpp b/libuavcan/test/transport/transfer_sender.cpp index 329ecfd31e..cf34b0f807 100644 --- a/libuavcan/test/transport/transfer_sender.cpp +++ b/libuavcan/test/transport/transfer_sender.cpp @@ -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]) }; /* diff --git a/libuavcan/test/transport/transfer_test_helpers.cpp b/libuavcan/test/transport/transfer_test_helpers.cpp index 2e8827dba7..94a708cb06 100644 --- a/libuavcan/test/transport/transfer_test_helpers.cpp +++ b/libuavcan/test/transport/transfer_test_helpers.cpp @@ -8,14 +8,14 @@ TEST(TransferTestHelpers, Transfer) { - uavcan::PoolAllocator pool; + uavcan::PoolAllocator 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 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 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 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 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 ser = serializeTransfer(transfer); ASSERT_EQ(1, ser.size()); std::cout << "Serialized transfer:\n\t" << ser[0].toString() << "\n"; diff --git a/libuavcan/test/transport/transfer_test_helpers.hpp b/libuavcan/test/transport/transfer_test_helpers.hpp index 2277007f03..18b647e41d 100644 --- a/libuavcan/test/transport/transfer_test_helpers.hpp +++ b/libuavcan/test/transport/transfer_test_helpers.hpp @@ -149,12 +149,12 @@ std::vector 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 serializeTransfer(const Transfer& transfer) std::vector 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(transfer.payload.c_str()), transfer.payload.length()); // Little endian raw_payload.push_back(payload_crc.get() & 0xFF); @@ -196,7 +196,7 @@ std::vector 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 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();