bits.cpp

Go to the documentation of this file.

#define KBLIB_DEF_MACROS 1
#include "kblib/bits.h"
#include "catch/catch.hpp"
#include "kblib/hash.h"
 
#include <type_traits>
 
template <typename T>
struct print;
 
// These tests are POSIX-based, so spell out that requirement.
static_assert(CHAR_BIT == 8, "8-bit bytes");
static_assert(sizeof(short) == 2, "16-bit shorts");
static_assert(sizeof(int) == 4, "32-bit ints");
static_assert(sizeof(long) == 8, "64-bit longs");
 
static_assert(std::is_same<kblib::uint_smallest_t<0>, unsigned char>::value,
              "uint_smallest_t");
static_assert(std::is_same<kblib::uint_smallest_t<1>, unsigned char>::value,
              "uint_smallest_t");
static_assert(std::is_same<kblib::uint_smallest_t<255>, unsigned char>::value,
              "uint_smallest_t");
static_assert(std::is_same<kblib::uint_smallest_t<256>, unsigned short>::value,
              "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<32768>, unsigned short>::value,
    "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<65535>, unsigned short>::value,
    "uint_smallest_t");
static_assert(std::is_same<kblib::uint_smallest_t<65536>, unsigned int>::value,
              "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<1u << 31u>, unsigned int>::value,
    "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<UINT_MAX>, unsigned int>::value,
    "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<1ul << 32u>, unsigned long>::value,
    "uint_smallest_t");
static_assert(
    std::is_same<kblib::uint_smallest_t<1ul << 63u>, unsigned long>::value,
    "uint_smallest_t");
 
// print<kblib::int_smallest_t<1>> t{};
static_assert(std::is_same<kblib::int_smallest_t<1>, signed char>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<127>, signed char>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<256>, signed short>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<32767>, signed short>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<32768>, signed int>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<65536>, signed int>::value,
              "int_smallest_t");
static_assert(std::is_same<kblib::int_smallest_t<INT_MAX>, signed int>::value,
              "int_smallest_t");
static_assert(
    std::is_same<kblib::int_smallest_t<long(INT_MAX) + 1>, signed long>::value,
    "int_smallest_t");
 
#if KBLIB_USE_CXX17
TEST_CASE("test_trie") {
   kblib::compact_bit_trie<unsigned short, 1024, int> test;
   REQUIRE(test.insert({0b1000100010000000, 10}, 1));
   // has UB, so I hardcoded a test failure as a reminder
   // std::cout<<test.at({0b1000100010000000, 10})<<'\n';
   REQUIRE(not +"test.at({0b1000100010000000, 10}) has UB");
}
#endif
 
struct buffer {
   struct ret_proxy {
      const char* buf;
      template <typename T, typename std::enable_if<
                                std::is_trivially_copyable<T>::value, int>::type
                            = 0>
      operator T() const {
         T t;
         std::memcpy(&t, buf, sizeof(T));
         return t;
      }
   };
   std::vector<char> buf;
   KBLIB_NODISCARD auto operator[](std::size_t p) -> ret_proxy {
      return {&buf[p]};
   }
};
 
using kblib::bitfield;
 
union Addr1 {
   bitfield<0, 16, uint16_t> raw{};
 
   bitfield<0, 5, uint16_t> cX;
   bitfield<5, 5, uint16_t> cY;
   bitfield<10, 2, uint16_t> nt;
   bitfield<12, 3, uint16_t> fY;
 
   bitfield<0, 8, uint16_t> l;
   bitfield<8, 7, uint16_t> h;
 
   bitfield<0, 14, uint16_t> addr;
};
#if __cpp_lib_is_pointer_interconvertible
static_assert(std::is_pointer_interconvertible_with_class(&Addr1::raw));
static_assert(
    std::is_pointer_interconvertible_with_class(&decltype(Addr1::raw)::raw_));
#endif
 
TEST_CASE("bitfields1") {
   static_assert(sizeof(Addr1) == 2, "");
   Addr1 a;
   a.l = 0b1100'1100;
   a.h(0b001'1001);
   REQUIRE(a.raw == 0b0001'1001'1100'1100);
   REQUIRE(a.cX() == 0b0'1100);
   REQUIRE(a.cY == 0b0'1110);
   REQUIRE(a.nt == 0b10);
   REQUIRE(a.fY == 0b001);
}
 
// Loopy's VRAM address
struct Addr {
   std::uint16_t raw{};
 
   BITFIELD(0u, 5u, cX, raw)
   BITFIELD(5u, 5u, cY, raw)
   BITFIELD(10u, 2u, nt, raw)
   BITFIELD(12u, 3u, fY, raw)
 
   BITFIELD(0u, 8u, l, raw)
   BITFIELD(8u, 7u, h, raw)
 
   BITFIELD(0u, 14u, addr, raw)
};
 
KBLIB_NODISCARD constexpr auto test_bitfield() -> Addr {
   Addr a;
   a.l() = 0b1100'1100;
   a.h(0b001'1001);
   return a;
}
 
TEST_CASE("bitfields") {
   static_assert(sizeof(Addr) == 2, "");
   constexpr Addr a = test_bitfield();
   static_assert(a.raw == 0b0001'1001'1100'1100, "");
   static_assert(a.cX() == 0b0'1100, "");
   static_assert(a.cY() == 0b0'1110, "");
   static_assert(a.nt() == 0b10, "");
   static_assert(a.fY() == 0b001, "");
 
   static_assert(Addr::get_cX_v<a.raw> == 0b0'1100, "");
   static_assert(Addr::get_cY_v<a.raw> == 0b0'1110, "");
   static_assert(Addr::get_nt_v<a.raw> == 0b10, "");
   static_assert(Addr::get_fY_v<a.raw> == 0b001, "");
 
   constexpr Addr b = {Addr::set_h_v<0b001'1001, Addr::set_l_v<0b1100'1100>>};
 
   static_assert(Addr::get_cX_v<b.raw> == 0b0'1100, "");
   static_assert(Addr::get_cY_v<b.raw> == 0b0'1110, "");
   static_assert(Addr::get_nt_v<b.raw> == 0b10, "");
   static_assert(Addr::get_fY_v<b.raw> == 0b001, "");
}
 
#if KBLIB_USE_CXX17
union punner {
   char storage[sizeof(char*)]{};
   kblib::union_pun<const char*, &punner::storage> ptr;
   kblib::union_pun<std::uintptr_t, &punner::storage> val;
   kblib::union_pun<char16_t[sizeof(char*) / 2], &punner::storage> s;
};
 
TEST_CASE("union_punning") {
   punner pun;
   std::uintptr_t ival = 0xABCD;
   kblib::to_bytes_le(ival, pun.storage);
   REQUIRE(std::equal(std::begin(pun.storage), std::begin(pun.storage) + 4,
                      "\xCD\xAB\0\0"));
   REQUIRE(pun.val == ival);
   std::array<char16_t, sizeof(char*) / 2> ustr{u'\xABCD', u'\0'};
   decltype(ustr) t = pun.s;
   REQUIRE(t == ustr);
   REQUIRE(decltype(ustr)(pun.s) == ustr);
 
   pun.val = 0;
   const char* c = "";
   pun.ptr = c;
   REQUIRE(pun.val == kblib::byte_cast<std::uintptr_t>(c));
}
 
TEST_CASE("punning") {
   kblib::punner<char[], const char*, std::uintptr_t,
                 char16_t[sizeof(char*) / 2]>
       pun{};
   void(kblib::get<0>(pun));
   void(pun.get<1>());
 
   std::uintptr_t ival = 0xABCD;
   kblib::to_bytes_le(ival, pun.get<0>());
   REQUIRE(std::equal(std::begin(pun.get<0>()), std::begin(pun.get<0>()) + 4,
                      "\xCD\xAB\0\0"));
   REQUIRE(pun.get<2>() == ival);
   std::array<char16_t, sizeof(char*) / 2> ustr{u'\xABCD', u'\0'};
   decltype(ustr) t = pun.get<3>();
   REQUIRE(t == ustr);
   REQUIRE(decltype(ustr)(pun.get<3>()) == ustr);
 
   pun.get<2>() = 0;
   const char* c = "";
   pun.get<1>() = c;
   REQUIRE(pun.get<2>() == kblib::byte_cast<std::uintptr_t>(c));
}
#endif