Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
#include <unity.h>
// not used directly, but required so that the library dependency finder gives lib/betaflight
// the Espfc include path, same reason as in test_msp
#include <platform.h>
#include <Hal/Serial.hpp>
#include <Stream/BufferWritable.hpp>
#include <Stream/Printer.hpp>
#include <Stream/ReadWritable.hpp>
#include <cmath>
#include <cstring>
using namespace Espfc::Stream;
static char buff[256];
static BufferWritable sink{buff, sizeof(buff)};
static Printer printer{sink};
void setUp(void)
{
sink.clear();
}
void tearDown(void) {}
// buffer sink
void test_buffer_write_byte()
{
TEST_ASSERT_EQUAL(1, sink.write('a'));
TEST_ASSERT_EQUAL(1, sink.size());
TEST_ASSERT_EQUAL_STRING("a", sink.c_str());
TEST_ASSERT_FALSE(sink.overflow());
}
void test_buffer_write_many()
{
const char* text = "hello";
TEST_ASSERT_EQUAL(5, sink.write(reinterpret_cast<const uint8_t*>(text), 5));
TEST_ASSERT_EQUAL_STRING("hello", sink.c_str());
TEST_ASSERT_EQUAL(sizeof(buff) - 1 - 5, sink.availableForWrite());
}
void test_buffer_overflow()
{
char small[4];
BufferWritable s{small, sizeof(small)};
TEST_ASSERT_EQUAL(3, s.availableForWrite());
TEST_ASSERT_EQUAL(3, s.write(reinterpret_cast<const uint8_t*>("abcdef"), 6));
TEST_ASSERT_EQUAL_STRING("abc", s.c_str());
TEST_ASSERT_TRUE(s.overflow());
TEST_ASSERT_EQUAL(0, s.availableForWrite());
TEST_ASSERT_EQUAL(0, s.write('x'));
s.clear();
TEST_ASSERT_EQUAL_STRING("", s.c_str());
TEST_ASSERT_FALSE(s.overflow());
}
// raw writes and strings
void test_printer_write()
{
TEST_ASSERT_EQUAL(1, printer.write(static_cast<uint8_t>(0x02)));
TEST_ASSERT_EQUAL(1, sink.size());
TEST_ASSERT_EQUAL(0x02, sink.c_str()[0]);
}
void test_printer_print_string()
{
TEST_ASSERT_EQUAL(3, printer.print("abc"));
TEST_ASSERT_EQUAL(0, printer.print(static_cast<const char*>(nullptr)));
TEST_ASSERT_EQUAL_STRING("abc", sink.c_str());
}
void test_printer_print_char()
{
// char must be emitted verbatim, not as a number
printer.print('S');
printer.print(' ');
printer.print('N');
TEST_ASSERT_EQUAL_STRING("S N", sink.c_str());
}
void test_printer_print_bool()
{
// there is no bool overload on purpose, bool promotes to int and prints as 1/0
printer.print(true);
printer.print(false);
TEST_ASSERT_EQUAL_STRING("10", sink.c_str());
}
void test_printer_print_uchar_is_numeric()
{
const uint8_t v = 65;
printer.print(v);
TEST_ASSERT_EQUAL_STRING("65", sink.c_str());
}
// integers, base 10
void test_printer_print_int()
{
printer.print(0);
printer.print(' ');
printer.print(42);
printer.print(' ');
printer.print(-42);
TEST_ASSERT_EQUAL_STRING("0 42 -42", sink.c_str());
}
void test_printer_print_int_limits()
{
printer.print(static_cast<int32_t>(2147483647));
printer.print(' ');
printer.print(static_cast<int32_t>(-2147483647 - 1));
TEST_ASSERT_EQUAL_STRING("2147483647 -2147483648", sink.c_str());
}
void test_printer_print_unsigned_limits()
{
printer.print(static_cast<uint32_t>(4294967295u));
TEST_ASSERT_EQUAL_STRING("4294967295", sink.c_str());
}
void test_printer_print_long_long()
{
printer.print(static_cast<long long>(-9007199254740993ll));
TEST_ASSERT_EQUAL_STRING("-9007199254740993", sink.c_str());
}
// bases
void test_printer_print_hex()
{
printer.print(static_cast<uint8_t>(0x0a), HEX);
printer.print(' ');
printer.print(static_cast<uint32_t>(0xdeadbeef), HEX);
TEST_ASSERT_EQUAL_STRING("A DEADBEEF", sink.c_str());
}
void test_printer_print_bin_oct()
{
printer.print(static_cast<uint8_t>(5), BIN);
printer.print(' ');
printer.print(static_cast<uint8_t>(64), OCT);
TEST_ASSERT_EQUAL_STRING("101 100", sink.c_str());
}
void test_printer_print_negative_hex_masked()
{
// negative values are two's complement of the argument width, same on 32 and 64 bit hosts
printer.print(static_cast<int>(-1), HEX);
printer.print(' ');
printer.print(static_cast<long long>(-1), HEX);
TEST_ASSERT_EQUAL_STRING("FFFFFFFF FFFFFFFFFFFFFFFF", sink.c_str());
}
void test_printer_print_base_zero_writes_raw()
{
printer.print(static_cast<uint8_t>(0x41), 0);
TEST_ASSERT_EQUAL_STRING("A", sink.c_str());
}
void test_printer_print_base_one_falls_back_to_dec()
{
printer.print(static_cast<uint8_t>(12), 1);
TEST_ASSERT_EQUAL_STRING("12", sink.c_str());
}
// floats
void test_printer_print_float_default_digits()
{
printer.print(1.5f);
TEST_ASSERT_EQUAL_STRING("1.50", sink.c_str());
}
void test_printer_print_float_digits()
{
printer.print(3.14159f, 4);
TEST_ASSERT_EQUAL_STRING("3.1416", sink.c_str());
}
void test_printer_print_float_zero_digits()
{
printer.print(2.6f, 0);
TEST_ASSERT_EQUAL_STRING("3", sink.c_str());
}
void test_printer_print_float_rounding()
{
printer.print(1.999, 2);
TEST_ASSERT_EQUAL_STRING("2.00", sink.c_str());
}
void test_printer_print_float_negative()
{
printer.print(-0.05, 2);
TEST_ASSERT_EQUAL_STRING("-0.05", sink.c_str());
}
void test_printer_print_float_specials()
{
printer.print(NAN);
printer.print(' ');
printer.print(INFINITY);
printer.print(' ');
printer.print(5e9);
printer.print(' ');
printer.print(-5e9);
TEST_ASSERT_EQUAL_STRING("nan inf ovf ovf", sink.c_str());
}
// println and printf
void test_printer_println_is_crlf()
{
TEST_ASSERT_EQUAL(2, printer.println());
TEST_ASSERT_EQUAL_STRING("\r\n", sink.c_str());
}
void test_printer_println_value()
{
printer.println("ok");
printer.println(7);
TEST_ASSERT_EQUAL_STRING("ok\r\n7\r\n", sink.c_str());
}
void test_printer_printf()
{
printer.printf("| %02x | 0x%06X | %-4s |\r\n", 5, 0x1234, "ab");
TEST_ASSERT_EQUAL_STRING("| 05 | 0x001234 | ab |\r\n", sink.c_str());
}
void test_printer_printf_size_t()
{
const size_t v = 1234;
printer.printf("total: %zu", v);
TEST_ASSERT_EQUAL_STRING("total: 1234", sink.c_str());
}
void test_printer_printf_truncates()
{
char big[Printer::PRINTF_BUFF_SIZE * 2];
std::memset(big, 'x', sizeof(big) - 1);
big[sizeof(big) - 1] = '\0';
const size_t written = printer.printf("%s", big);
TEST_ASSERT_EQUAL(Printer::PRINTF_BUFF_SIZE - 1, written);
TEST_ASSERT_EQUAL(Printer::PRINTF_BUFF_SIZE - 1, sink.size());
}
// interfaces
class TestDevice : public ReadWritable
{
public:
size_t write(uint8_t c) override
{
_last = c;
return 1;
}
size_t write(const uint8_t* data, size_t len) override
{
if (len) _last = data[len - 1];
return len;
}
int availableForWrite() override
{
return 1;
}
void flush() override {}
int available() override
{
return 1;
}
int read() override
{
return _last;
}
size_t readMany(uint8_t* data, size_t len) override
{
if (len) data[0] = _last;
return len ? 1 : 0;
}
int peek() override
{
return _last;
}
bool isTxFifoEmpty() override
{
return true;
}
void begin(const Espfc::Hal::SerialDeviceConfig& config) override {}
void updateBaudRate(int baud) override {}
uint8_t _last = 0;
};
void test_readwritable_is_usable_by_printer()
{
TestDevice dev;
Printer p{dev};
p.print(123);
TEST_ASSERT_EQUAL('3', dev.read());
TEST_ASSERT_EQUAL_PTR(static_cast<Writable*>(&dev), &p.out());
}
int main(int argc, char** argv)
{
UNITY_BEGIN();
RUN_TEST(test_buffer_write_byte);
RUN_TEST(test_buffer_write_many);
RUN_TEST(test_buffer_overflow);
RUN_TEST(test_printer_write);
RUN_TEST(test_printer_print_string);
RUN_TEST(test_printer_print_char);
RUN_TEST(test_printer_print_bool);
RUN_TEST(test_printer_print_uchar_is_numeric);
RUN_TEST(test_printer_print_int);
RUN_TEST(test_printer_print_int_limits);
RUN_TEST(test_printer_print_unsigned_limits);
RUN_TEST(test_printer_print_long_long);
RUN_TEST(test_printer_print_hex);
RUN_TEST(test_printer_print_bin_oct);
RUN_TEST(test_printer_print_negative_hex_masked);
RUN_TEST(test_printer_print_base_zero_writes_raw);
RUN_TEST(test_printer_print_base_one_falls_back_to_dec);
RUN_TEST(test_printer_print_float_default_digits);
RUN_TEST(test_printer_print_float_digits);
RUN_TEST(test_printer_print_float_zero_digits);
RUN_TEST(test_printer_print_float_rounding);
RUN_TEST(test_printer_print_float_negative);
RUN_TEST(test_printer_print_float_specials);
RUN_TEST(test_printer_println_is_crlf);
RUN_TEST(test_printer_println_value);
RUN_TEST(test_printer_printf);
RUN_TEST(test_printer_printf_size_t);
RUN_TEST(test_printer_printf_truncates);
RUN_TEST(test_readwritable_is_usable_by_printer);
return UNITY_END();
}
c04356942This file is pinned to the selected release. Download the original to open it in your design tool.