mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-04-14 10:07:39 +08:00
99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
/*
|
|
* Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <limits>
|
|
#include <uavcan/marshal/scalar_codec.hpp>
|
|
#include <uavcan/transport/transfer_buffer.hpp>
|
|
|
|
|
|
TEST(ScalarCodec, Basic)
|
|
{
|
|
uavcan::StaticTransferBuffer<38> buf;
|
|
uavcan::BitStream bs_wr(buf);
|
|
uavcan::ScalarCodec sc_wr(bs_wr);
|
|
|
|
{
|
|
uint64_t u64 = 0;
|
|
ASSERT_EQ(0, sc_wr.decode<64>(u64)); // Out of buffer space
|
|
}
|
|
|
|
/*
|
|
* Encoding some variables
|
|
*/
|
|
ASSERT_EQ(1, sc_wr.encode<12>((uint16_t)0xbeda)); // --> 0xeda
|
|
ASSERT_EQ(1, sc_wr.encode<1>((uint8_t)1));
|
|
ASSERT_EQ(1, sc_wr.encode<1>((uint16_t)0));
|
|
ASSERT_EQ(1, sc_wr.encode<4>((uint8_t)8));
|
|
ASSERT_EQ(1, sc_wr.encode<32>((uint32_t)0xdeadbeef));
|
|
ASSERT_EQ(1, sc_wr.encode<3>((int8_t)-1));
|
|
ASSERT_EQ(1, sc_wr.encode<4>((int8_t)-6));
|
|
ASSERT_EQ(1, sc_wr.encode<20>((int32_t)-123456));
|
|
ASSERT_EQ(1, sc_wr.encode<64>(std::numeric_limits<int64_t>::min()));
|
|
ASSERT_EQ(1, sc_wr.encode<64>(std::numeric_limits<int64_t>::max()));
|
|
ASSERT_EQ(1, sc_wr.encode<15>((int16_t)-1));
|
|
ASSERT_EQ(1, sc_wr.encode<2>((int16_t)-1));
|
|
ASSERT_EQ(1, sc_wr.encode<16>(std::numeric_limits<int16_t>::min()));
|
|
ASSERT_EQ(1, sc_wr.encode<64>(std::numeric_limits<uint64_t>::max())); // Total 302 bit (38 bytes)
|
|
|
|
ASSERT_EQ(0, sc_wr.encode<64>(std::numeric_limits<uint64_t>::min())); // Out of buffer space
|
|
|
|
/*
|
|
* Decoding back
|
|
*/
|
|
uavcan::BitStream bs_rd(buf);
|
|
uavcan::ScalarCodec sc_rd(bs_rd);
|
|
|
|
uint8_t u8 = 0;
|
|
int8_t i8 = 0;
|
|
uint16_t u16 = 0;
|
|
int16_t i16 = 0;
|
|
uint32_t u32 = 0;
|
|
int32_t i32 = 0;
|
|
uint64_t u64 = 0;
|
|
int64_t i64 = 0;
|
|
|
|
#define CHECK(bitlen, variable, expected_value) \
|
|
do { \
|
|
ASSERT_EQ(1, sc_rd.decode<bitlen>(variable)); \
|
|
ASSERT_EQ(expected_value, variable); \
|
|
} while (0)
|
|
|
|
CHECK(12, u16, 0xeda);
|
|
CHECK(1, u8, 1);
|
|
CHECK(1, u16, 0);
|
|
CHECK(4, u8, 8);
|
|
CHECK(32, u32, 0xdeadbeef);
|
|
CHECK(3, i8, -1);
|
|
CHECK(4, i8, -6);
|
|
CHECK(20, i32, -123456);
|
|
CHECK(64, i64, std::numeric_limits<int64_t>::min());
|
|
CHECK(64, i64, std::numeric_limits<int64_t>::max());
|
|
CHECK(15, i16, -1);
|
|
CHECK(2, i8, -1);
|
|
CHECK(16, i16, std::numeric_limits<int16_t>::min());
|
|
CHECK(64, u64, std::numeric_limits<uint64_t>::max());
|
|
|
|
#undef CHECK
|
|
|
|
ASSERT_EQ(0, sc_rd.decode<64>(u64)); // Out of buffer space
|
|
}
|
|
|
|
TEST(ScalarCodec, RepresentationCorrectness)
|
|
{
|
|
uavcan::StaticTransferBuffer<4> buf;
|
|
uavcan::BitStream bs_wr(buf);
|
|
uavcan::ScalarCodec sc_wr(bs_wr);
|
|
|
|
ASSERT_EQ(1, sc_wr.encode<12>((uint16_t)0xbeda)); // --> 0xeda
|
|
ASSERT_EQ(1, sc_wr.encode<3>((int8_t)-1));
|
|
ASSERT_EQ(1, sc_wr.encode<4>((int8_t)-5));
|
|
ASSERT_EQ(1, sc_wr.encode<2>((int16_t)-1));
|
|
ASSERT_EQ(1, sc_wr.encode<4>((uint8_t)0x88)); // --> 8
|
|
|
|
// This representation was carefully crafted and triple checked:
|
|
static const std::string REFERENCE = "11011010 11101111 01111100 00000000";
|
|
ASSERT_EQ(REFERENCE, bs_wr.toString());
|
|
}
|