//-----------------------------------------------------------------------------
//     ___                      __ _       _
//    / _ \__ _ _ __ ___  ___  / /(_)_ __ | | __
//   / /_)/ _` | '__/ __|/ _ \/ / | | '_ \| |/ /
//  / ___/ (_| | |  \__ \  __/ /__| | | | |   <
//  \/    \__,_|_|  |___/\___\____/_|_| |_|_|\_\ .
//
//-----------------------------------------------------------------------------
// Author: Kurt Sassenrath
// Module: msgpack
//
// Packer tests, unsigned ints.
//
// Copyright (c) 2023 Kurt Sassenrath.
//
// License TBD.
//-----------------------------------------------------------------------------
#include "test_packer.h"

#include <rapidcheck.h>

using namespace boost::ut;

namespace {

template <typename T>
auto check_unsigned() {
    return rc::check([](T value) {
        std::array<std::byte, 16> payload;
        msgpack::packer packer(payload);
        if (!packer.pack(value)) return false;

        if (value < 128) {
            // positive_fixint
            return packer.tell() == 1
                && payload[0] == static_cast<std::byte>(value);
        } else if (within<std::uint8_t>(value)) {
            return payload[0] == msgpack::format::uint8::marker
                && verify_packed<std::uint8_t>(packer, value);
        } else if (within<std::uint16_t>(value)) {
            return payload[0] == msgpack::format::uint16::marker
                && verify_packed<std::uint16_t>(packer, value);
        } else if (within<std::uint32_t>(value)) {
            return payload[0] == msgpack::format::uint32::marker
                && verify_packed<std::uint32_t>(packer, value);
        } else {
            return payload[0] == msgpack::format::uint64::marker
                && verify_packed<std::uint64_t>(packer, value);
        }
    });
}

} // anonymous namespace

suite packer_unsigned_ints = [] {
    "packer::pack<std::uint8_t>"_test = [] {
        expect(check_unsigned<std::uint8_t>());
    };

    "packer::pack<std::uint16_t>"_test = [] {
        expect(check_unsigned<std::uint16_t>());
    };

    "packer::pack<std::uint32_t>"_test = [] {
        expect(check_unsigned<std::uint32_t>());
    };

    "packer::pack<std::uint64_t>"_test = [] {
        expect(check_unsigned<std::uint64_t>());
    };
};