130 lines
4.0 KiB
C++
130 lines
4.0 KiB
C++
#include "parselink/msgpack/core/reader.h"
|
|
#include <boost/ut.hpp>
|
|
#include <string>
|
|
|
|
namespace {
|
|
|
|
using namespace boost::ut;
|
|
namespace format = msgpack::format;
|
|
|
|
template <typename... Bytes>
|
|
constexpr std::array<std::byte, sizeof...(Bytes)> make_bytes(Bytes&&... bytes) {
|
|
return {std::byte(std::forward<Bytes>(bytes))...};
|
|
}
|
|
|
|
template <typename T, std::size_t C = 1024>
|
|
struct oversized_array {
|
|
std::array<T, C> data;
|
|
std::size_t size;
|
|
};
|
|
|
|
constexpr auto to_bytes_array_oversized(auto const& container) {
|
|
oversized_array<std::byte> arr;
|
|
std::copy(std::begin(container), std::end(container), std::begin(arr.data));
|
|
arr.size = std::distance(std::begin(container), std::end(container));
|
|
return arr;
|
|
}
|
|
|
|
consteval auto generate_bytes(auto callable) {
|
|
constexpr auto oversized = to_bytes_array_oversized(callable());
|
|
std::array<std::byte, oversized.size> out;
|
|
std::copy(std::begin(oversized.data),
|
|
std::next(std::begin(oversized.data), oversized.size),
|
|
std::begin(out));
|
|
return out;
|
|
}
|
|
|
|
template <std::size_t A, std::size_t B>
|
|
consteval auto cat(
|
|
std::array<std::byte, A> const& a, std::array<std::byte, B> const& b) {
|
|
std::array<std::byte, A + B> out;
|
|
std::copy(std::begin(a), std::next(std::begin(a), std::size(a)),
|
|
std::begin(out));
|
|
std::copy(std::begin(b), std::next(std::begin(b), std::size(b)),
|
|
std::next(std::begin(out), std::size(a)));
|
|
return out;
|
|
}
|
|
|
|
template <typename T, typename Itr>
|
|
constexpr auto zip(T val, Itr begin, Itr end) {
|
|
std::vector<T> output;
|
|
for (auto itr = begin; itr != end; ++itr) {
|
|
output.emplace_back(val);
|
|
output.emplace_back(*itr);
|
|
}
|
|
return output;
|
|
}
|
|
|
|
template <typename T, typename Iterable>
|
|
constexpr auto zip(T val, Iterable const& itr) {
|
|
return zip(val, std::begin(itr), std::end(itr));
|
|
}
|
|
|
|
using relaxed_reader = msgpack::reader<msgpack::reader_policy::relaxed>;
|
|
|
|
} // namespace
|
|
|
|
suite relaxed = [] {
|
|
"empty span"_test = [] {
|
|
using error = msgpack::error;
|
|
std::span<std::byte> bytes;
|
|
relaxed_reader reader(bytes);
|
|
auto v = reader.read<msgpack::format::uint8>();
|
|
expect(v.error() == error::end_of_message);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Unsigned integers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
"reader<reader_policy::relaxed>::read<format::uint8>"_test = [] {
|
|
using fmt = format::uint8;
|
|
using error = msgpack::error;
|
|
/**
|
|
* All bytes 0x00->0x79 are effectively literal uint8s.
|
|
*/
|
|
{
|
|
constexpr auto payload = make_bytes(0x52, 0xcc, 0x84);
|
|
relaxed_reader reader(payload);
|
|
{
|
|
auto result = reader.read<fmt>();
|
|
expect(result == std::uint8_t(0x52));
|
|
}
|
|
{
|
|
auto result = reader.read<fmt>();
|
|
expect(result == std::uint8_t(0x84));
|
|
}
|
|
|
|
auto result = reader.read<fmt>();
|
|
expect(result == tl::make_unexpected(error::end_of_message));
|
|
}
|
|
};
|
|
|
|
"reader<reader_policy::relaxed>::read<formats::uint16>"_test = [] {
|
|
using fmt = msgpack::format::uint16;
|
|
using error = msgpack::error;
|
|
/**
|
|
* All bytes 0x00->0x79 are effectively literal uint8s.
|
|
*/
|
|
{
|
|
constexpr auto payload =
|
|
make_bytes(0x52, 0xcc, 0x84, 0xcd, 0xaa, 0xcc);
|
|
relaxed_reader reader(payload);
|
|
{
|
|
auto result = reader.read<fmt>();
|
|
expect(result == std::uint16_t(0x52));
|
|
}
|
|
{
|
|
auto result = reader.read<fmt>();
|
|
expect(result == std::uint16_t(0x84));
|
|
}
|
|
{
|
|
auto result = reader.read<fmt>();
|
|
expect(result == std::uint16_t(0xaacc));
|
|
}
|
|
|
|
auto result = reader.read<fmt>();
|
|
expect(result == tl::make_unexpected(error::end_of_message));
|
|
}
|
|
};
|
|
};
|