20577379106

Committed 29 Dec 2025 04:16PM UTC coverage: 90.245% (-0.003%) from 90.248%

Build # 20577379106

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5194 from randombit/jack/solinas-mask

Use a faster method for setting up a mask during Solinas correction step

Run Details

101303 of 112253 relevant lines covered (90.25%)

12702697.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.01

/src/tests/test_utils.cpp

/*
* (C) 2015,2018,2024 Jack Lloyd
* (C) 2016 Daniel Neus, Rohde & Schwarz Cybersecurity
* (C) 2017 René Korthaus, Rohde & Schwarz Cybersecurity
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "tests.h"
#include <botan/version.h>
#include <botan/internal/bit_ops.h>
#include <botan/internal/calendar.h>
#include <botan/internal/charset.h>
#include <botan/internal/ct_utils.h>
#include <botan/internal/fmt.h>
#include <botan/internal/int_utils.h>
#include <botan/internal/loadstor.h>
#include <botan/internal/parsing.h>
#include <botan/internal/rounding.h>
#include <botan/internal/stl_util.h>
#include <botan/internal/target_info.h>

#include <bit>
#include <ctime>
#include <functional>

#if defined(BOTAN_HAS_CPUID)
   #include <botan/internal/cpuid.h>
#endif

#if defined(BOTAN_HAS_POLY_DBL)
   #include <botan/internal/poly_dbl.h>
#endif

#if defined(BOTAN_HAS_UUID)
   #include <botan/uuid.h>
#endif

namespace Botan_Tests {

namespace {

class Utility_Function_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         std::vector<Test::Result> results;

         results.push_back(test_checked_add());
         results.push_back(test_checked_mul());
         results.push_back(test_checked_cast());
         results.push_back(test_round_up());
         results.push_back(test_loadstore());
         results.push_back(test_loadstore_ambiguity());
         results.push_back(test_loadstore_fallback());
         results.push_back(test_loadstore_constexpr());
         return Botan::concat(results, test_copy_out_be_le());
      }

   private:
      Test::Result test_checked_add() {
         Test::Result result("checked_add");

         const size_t large = static_cast<size_t>(-5);
         const size_t zero = 0;

         for(int si = -15; si != 15; ++si) {
            const size_t i = static_cast<size_t>(si);
            auto sum1 = Botan::checked_add<size_t>(i, zero, zero, zero, large);
            auto sum2 = Botan::checked_add<size_t>(large, zero, zero, zero, i);

            result.confirm("checked_add looks at all args", sum1 == sum2);

            if(i < 5) {
               result.test_eq("checked_add worked", sum1.value(), i + large);
            } else {
               result.confirm("checked_add did not return a result", !sum1.has_value());
            }
         }

         auto& rng = Test::rng();

         for(size_t i = 0; i != 100; ++i) {
            const uint16_t x = Botan::make_uint16(rng.next_byte(), rng.next_byte());
            const uint16_t y = Botan::make_uint16(rng.next_byte(), rng.next_byte());

            const uint32_t ref = static_cast<uint32_t>(x) + y;

            if(auto z = Botan::checked_add(x, y)) {
               result.test_int_eq("checked_add adds", z.value(), ref);
            } else {
               result.confirm("checked_add checks", (ref >> 16) > 0);
            }
         }

         return result;
      }

      Test::Result test_checked_mul() {
         Test::Result result("checked_mul");

         auto& rng = Test::rng();

         for(size_t i = 0; i != 100; ++i) {
            const uint16_t x = Botan::make_uint16(rng.next_byte(), rng.next_byte());
            const uint16_t y = Botan::make_uint16(rng.next_byte(), rng.next_byte());

            const uint32_t ref = static_cast<uint32_t>(x) * y;

            if(auto z = Botan::checked_mul(x, y)) {
               result.test_int_eq("checked_mul multiplies", z.value(), ref);
            } else {
               result.confirm("checked_mul checks", (ref >> 16) > 0);
            }
         }

         return result;
      }

      Test::Result test_checked_cast() {
         Test::Result result("checked_cast");

         const uint32_t large = static_cast<uint32_t>(-1);
         const uint32_t is_16_bits = 0x8123;
         const uint32_t is_8_bits = 0x89;

         result.test_throws("checked_cast checks", [&] { Botan::checked_cast_to<uint16_t>(large); });
         result.test_throws("checked_cast checks", [&] { Botan::checked_cast_to<uint8_t>(large); });

         result.test_int_eq("checked_cast converts", Botan::checked_cast_to<uint32_t>(large), large);
         result.test_int_eq("checked_cast converts", Botan::checked_cast_to<uint16_t>(is_16_bits), 0x8123);
         result.test_int_eq("checked_cast converts", Botan::checked_cast_to<uint8_t>(is_8_bits), 0x89);

         return result;
      }

      Test::Result test_round_up() {
         Test::Result result("Util round_up");

         // clang-format off
         const std::vector<size_t> inputs = {
            0, 1, 2, 3, 4, 9, 10, 32, 99, 100, 101, 255, 256, 1000, 10000,
            65535, 65536, 65537,
         };

         const std::vector<size_t> alignments = {
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 16, 32, 50, 64, 100, 512, 521,
            1000, 1023, 1024, 1025, 10000, 65535, 65536
         };
         // clang-format on

         for(const size_t i : inputs) {
            for(const size_t m : alignments) {
               try {
                  const size_t z = Botan::round_up(i, m);

                  result.confirm("z % m == 0", z % m == 0);
                  result.confirm("z >= i", z >= i);
                  result.confirm("z <= i + m", z <= i + m);
               } catch(Botan::Exception& e) {
                  result.test_failure(Botan::fmt("round_up({},{})", i, m), e.what());
               }
            }
         }

         result.test_throws("Integer overflow is detected", []() { Botan::round_up(static_cast<size_t>(-1), 1024); });

         return result;
      }

      using TestInt64 = Botan::Strong<uint64_t, struct TestInt64_>;
      using TestInt32 = Botan::Strong<uint32_t, struct TestInt64_>;
      using TestVectorSink = Botan::Strong<std::vector<uint8_t>, struct TestVectorSink_>;

      enum class TestEnum64 : uint64_t {
         _1 = 0x1234567890ABCDEF,
         _2 = 0xEFCDAB9078563412,
      };

      enum class TestEnum32 : uint32_t {
         _1 = 0x12345678,
         _2 = 0x78563412,
      };

      static Test::Result test_loadstore() {
         Test::Result result("Util load/store");

         const std::vector<uint8_t> membuf = Botan::hex_decode("00112233445566778899AABBCCDDEEFF");
         const uint8_t* mem = membuf.data();

         const uint16_t in16 = 0x1234;
         const uint32_t in32 = 0xA0B0C0D0;
         const uint64_t in64 = 0xABCDEF0123456789;

         result.test_is_eq<uint8_t>(Botan::get_byte<0>(in32), 0xA0);
         result.test_is_eq<uint8_t>(Botan::get_byte<1>(in32), 0xB0);
         result.test_is_eq<uint8_t>(Botan::get_byte<2>(in32), 0xC0);
         result.test_is_eq<uint8_t>(Botan::get_byte<3>(in32), 0xD0);

         result.test_is_eq<uint16_t>(Botan::make_uint16(0xAA, 0xBB), 0xAABB);
         result.test_is_eq<uint32_t>(Botan::make_uint32(0x01, 0x02, 0x03, 0x04), 0x01020304);

         result.test_is_eq<uint16_t>(Botan::load_be<uint16_t>(mem, 0), 0x0011);
         result.test_is_eq<uint16_t>(Botan::load_be<uint16_t>(mem, 1), 0x2233);
         result.test_is_eq<uint16_t>(Botan::load_be<uint16_t>(mem, 2), 0x4455);
         result.test_is_eq<uint16_t>(Botan::load_be<uint16_t>(mem, 3), 0x6677);

         result.test_is_eq<uint16_t>(Botan::load_le<uint16_t>(mem, 0), 0x1100);
         result.test_is_eq<uint16_t>(Botan::load_le<uint16_t>(mem, 1), 0x3322);
         result.test_is_eq<uint16_t>(Botan::load_le<uint16_t>(mem, 2), 0x5544);
         result.test_is_eq<uint16_t>(Botan::load_le<uint16_t>(mem, 3), 0x7766);

         result.test_is_eq<uint32_t>(Botan::load_be<uint32_t>(mem, 0), 0x00112233);
         result.test_is_eq<uint32_t>(Botan::load_be<uint32_t>(mem, 1), 0x44556677);
         result.test_is_eq<uint32_t>(Botan::load_be<uint32_t>(mem, 2), 0x8899AABB);
         result.test_is_eq<uint32_t>(Botan::load_be<uint32_t>(mem, 3), 0xCCDDEEFF);

         result.test_is_eq<uint32_t>(Botan::load_le<uint32_t>(mem, 0), 0x33221100);
         result.test_is_eq<uint32_t>(Botan::load_le<uint32_t>(mem, 1), 0x77665544);
         result.test_is_eq<uint32_t>(Botan::load_le<uint32_t>(mem, 2), 0xBBAA9988);
         result.test_is_eq<uint32_t>(Botan::load_le<uint32_t>(mem, 3), 0xFFEEDDCC);

         result.test_is_eq<uint64_t>(Botan::load_be<uint64_t>(mem, 0), 0x0011223344556677);
         result.test_is_eq<uint64_t>(Botan::load_be<uint64_t>(mem, 1), 0x8899AABBCCDDEEFF);

         result.test_is_eq<uint64_t>(Botan::load_le<uint64_t>(mem, 0), 0x7766554433221100);
         result.test_is_eq<uint64_t>(Botan::load_le<uint64_t>(mem, 1), 0xFFEEDDCCBBAA9988);

         // Check misaligned loads:
         result.test_is_eq<uint16_t>(Botan::load_be<uint16_t>(mem + 1, 0), 0x1122);
         result.test_is_eq<uint16_t>(Botan::load_le<uint16_t>(mem + 3, 0), 0x4433);

         result.test_is_eq<uint32_t>(Botan::load_be<uint32_t>(mem + 1, 1), 0x55667788);
         result.test_is_eq<uint32_t>(Botan::load_le<uint32_t>(mem + 3, 1), 0xAA998877);

         result.test_is_eq<uint64_t>(Botan::load_be<uint64_t>(mem + 1, 0), 0x1122334455667788);
         result.test_is_eq<uint64_t>(Botan::load_le<uint64_t>(mem + 7, 0), 0xEEDDCCBBAA998877);
         result.test_is_eq<uint64_t>(Botan::load_le<uint64_t>(mem + 5, 0), 0xCCBBAA9988776655);

         uint8_t outbuf[16] = {0};

         for(size_t offset = 0; offset != 7; ++offset) {
            uint8_t* out = outbuf + offset;  // NOLINT(*-const-correctness) clang-tidy bug

            Botan::store_be(in16, out);
            result.test_is_eq<uint8_t>(out[0], 0x12);
            result.test_is_eq<uint8_t>(out[1], 0x34);

            Botan::store_le(in16, out);
            result.test_is_eq<uint8_t>(out[0], 0x34);
            result.test_is_eq<uint8_t>(out[1], 0x12);

            Botan::store_be(in32, out);
            result.test_is_eq<uint8_t>(out[0], 0xA0);
            result.test_is_eq<uint8_t>(out[1], 0xB0);
            result.test_is_eq<uint8_t>(out[2], 0xC0);
            result.test_is_eq<uint8_t>(out[3], 0xD0);

            Botan::store_le(in32, out);
            result.test_is_eq<uint8_t>(out[0], 0xD0);
            result.test_is_eq<uint8_t>(out[1], 0xC0);
            result.test_is_eq<uint8_t>(out[2], 0xB0);
            result.test_is_eq<uint8_t>(out[3], 0xA0);

            Botan::store_be(in64, out);
            result.test_is_eq<uint8_t>(out[0], 0xAB);
            result.test_is_eq<uint8_t>(out[1], 0xCD);
            result.test_is_eq<uint8_t>(out[2], 0xEF);
            result.test_is_eq<uint8_t>(out[3], 0x01);
            result.test_is_eq<uint8_t>(out[4], 0x23);
            result.test_is_eq<uint8_t>(out[5], 0x45);
            result.test_is_eq<uint8_t>(out[6], 0x67);
            result.test_is_eq<uint8_t>(out[7], 0x89);

            Botan::store_le(in64, out);
            result.test_is_eq<uint8_t>(out[0], 0x89);
            result.test_is_eq<uint8_t>(out[1], 0x67);
            result.test_is_eq<uint8_t>(out[2], 0x45);
            result.test_is_eq<uint8_t>(out[3], 0x23);
            result.test_is_eq<uint8_t>(out[4], 0x01);
            result.test_is_eq<uint8_t>(out[5], 0xEF);
            result.test_is_eq<uint8_t>(out[6], 0xCD);
            result.test_is_eq<uint8_t>(out[7], 0xAB);
         }

         std::array<uint8_t, 8> outarr{};
         uint16_t i0 = 0;
         uint16_t i1 = 0;
         uint16_t i2 = 0;
         uint16_t i3 = 0;
         Botan::store_be(in64, outarr);

         Botan::load_be(outarr, i0, i1, i2, i3);
         result.test_is_eq<uint16_t>(i0, 0xABCD);
         result.test_is_eq<uint16_t>(i1, 0xEF01);
         result.test_is_eq<uint16_t>(i2, 0x2345);
         result.test_is_eq<uint16_t>(i3, 0x6789);

         Botan::load_le(std::span{outarr}.first<6>(), i0, i1, i2);
         result.test_is_eq<uint16_t>(i0, 0xCDAB);
         result.test_is_eq<uint16_t>(i1, 0x01EF);
         result.test_is_eq<uint16_t>(i2, 0x4523);
         result.test_is_eq<uint16_t>(i3, 0x6789);  // remains unchanged

         Botan::store_le(in64, outarr);

         Botan::load_le(outarr, i0, i1, i2, i3);
         result.test_is_eq<uint16_t>(i0, 0x6789);
         result.test_is_eq<uint16_t>(i1, 0x2345);
         result.test_is_eq<uint16_t>(i2, 0xEF01);
         result.test_is_eq<uint16_t>(i3, 0xABCD);

         Botan::load_be(std::span{outarr}.first<6>(), i0, i1, i2);
         result.test_is_eq<uint16_t>(i0, 0x8967);
         result.test_is_eq<uint16_t>(i1, 0x4523);
         result.test_is_eq<uint16_t>(i2, 0x01EF);
         result.test_is_eq<uint16_t>(i3, 0xABCD);  // remains unchanged

         i0 = 0xAA11;
         i1 = 0xBB22;
         i2 = 0xCC33;
         i3 = 0xDD44;
         Botan::store_be(outarr, i0, i1, i2, i3);
         result.test_is_eq(outarr, {0xAA, 0x11, 0xBB, 0x22, 0xCC, 0x33, 0xDD, 0x44});
         std::vector<uint8_t> outvec(8);
         Botan::store_be(outvec, i0, i1, i2, i3);
         result.test_is_eq(outvec, Botan::hex_decode("AA11BB22CC33DD44"));

         Botan::store_le(outarr, i0, i1, i2, i3);
         result.test_is_eq(outarr, {0x11, 0xAA, 0x22, 0xBB, 0x33, 0xCC, 0x44, 0xDD});
         Botan::store_le(outvec, i0, i1, i2, i3);
         result.test_is_eq(outvec, Botan::hex_decode("11AA22BB33CC44DD"));

#if !defined(BOTAN_TERMINATE_ON_ASSERTS)
         std::vector<uint8_t> sink56bits(7);
         std::vector<uint8_t> sink72bits(9);
         result.test_throws("store_le with a buffer that is too small",
                            [&] { Botan::store_le(sink56bits, i0, i1, i2, i3); });
         result.test_throws("store_le with a buffer that is too big",
                            [&] { Botan::store_le(sink72bits, i0, i1, i2, i3); });
         result.test_throws("store_be with a buffer that is too small",
                            [&] { Botan::store_be(sink56bits, i0, i1, i2, i3); });
         result.test_throws("store_be with a buffer that is too big",
                            [&] { Botan::store_be(sink72bits, i0, i1, i2, i3); });
#endif

         // can store multiple values straight into a collection
         auto out64_array_be = Botan::store_be(i0, i1, i2, i3);
         auto out64_vec_be = Botan::store_be<std::vector<uint8_t>>(i0, i1, i2, i3);
         auto out64_strong_be = Botan::store_be<TestVectorSink>(i0, i1, i2, i3);
         result.test_is_eq(out64_array_be, {0xAA, 0x11, 0xBB, 0x22, 0xCC, 0x33, 0xDD, 0x44});
         result.test_is_eq(out64_vec_be, Botan::hex_decode("AA11BB22CC33DD44"));
         result.test_is_eq(out64_strong_be, TestVectorSink(Botan::hex_decode("AA11BB22CC33DD44")));
         auto out64_array_le = Botan::store_le(i0, i1, i2, i3);
         auto out64_vec_le = Botan::store_le<std::vector<uint8_t>>(i0, i1, i2, i3);
         auto out64_strong_le = Botan::store_le<TestVectorSink>(i0, i1, i2, i3);
         result.test_is_eq(out64_array_le, {0x11, 0xAA, 0x22, 0xBB, 0x33, 0xCC, 0x44, 0xDD});
         result.test_is_eq(out64_vec_le, Botan::hex_decode("11AA22BB33CC44DD"));
         result.test_is_eq(out64_strong_le, TestVectorSink(Botan::hex_decode("11AA22BB33CC44DD")));

         result.test_is_eq(in16, Botan::load_be(Botan::store_be(in16)));
         result.test_is_eq(in32, Botan::load_be(Botan::store_be(in32)));
         result.test_is_eq(in64, Botan::load_be(Botan::store_be(in64)));

         result.test_is_eq(in16, Botan::load_le(Botan::store_le(in16)));
         result.test_is_eq(in32, Botan::load_le(Botan::store_le(in32)));
         result.test_is_eq(in64, Botan::load_le(Botan::store_le(in64)));

         // Test that the runtime detects incompatible range sizes
#if !defined(BOTAN_TERMINATE_ON_ASSERTS)
         std::vector<uint16_t> too_big16(4);
         std::vector<uint16_t> too_small16(1);
         result.test_throws("load_le with incompatible buffers",
                            [&] { Botan::load_le(too_big16, Botan::hex_decode("BAADB00B")); });
         result.test_throws("load_le with incompatible buffers",
                            [&] { Botan::load_le(too_small16, Botan::hex_decode("BAADB00B")); });
         result.test_throws("load_be with incompatible buffers",
                            [&] { Botan::load_be(too_big16, Botan::hex_decode("BAADB00B")); });
         result.test_throws("load_be with incompatible buffers",
                            [&] { Botan::load_be(too_small16, Botan::hex_decode("BAADB00B")); });

         std::vector<uint8_t> too_big8(4);
         std::vector<uint8_t> too_small8(1);
         result.test_throws("store_le with incompatible buffers",
                            [&] { Botan::store_le(too_big8, std::array<uint16_t, 1>{}); });
         result.test_throws("store_le with incompatible buffers",
                            [&] { Botan::store_le(too_small8, std::array<uint16_t, 1>{}); });
         result.test_throws("store_be with incompatible buffers",
                            [&] { Botan::store_be(too_big8, std::array<uint16_t, 1>{}); });
         result.test_throws("store_be with incompatible buffers",
                            [&] { Botan::store_be(too_small8, std::array<uint16_t, 1>{}); });
#endif

         // Test store of entire ranges
         const std::array<uint16_t, 2> in16_array = {0x0A0B, 0x0C0D};
         result.test_is_eq(Botan::store_be<std::vector<uint8_t>>(in16_array), Botan::hex_decode("0A0B0C0D"));
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(in16_array), Botan::hex_decode("0B0A0D0C"));

         const std::vector<uint16_t> in16_vector = {0x0A0B, 0x0C0D};
         result.test_is_eq(Botan::store_be<std::vector<uint8_t>>(in16_vector), Botan::hex_decode("0A0B0C0D"));
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(in16_vector), Botan::hex_decode("0B0A0D0C"));

         std::array<uint8_t, 4> out_array{};
         Botan::store_be(out_array, in16_array);
         result.test_is_eq(out_array, std::array<uint8_t, 4>{0x0A, 0x0B, 0x0C, 0x0D});
         Botan::store_le(out_array, in16_array);
         result.test_is_eq(out_array, std::array<uint8_t, 4>{0x0B, 0x0A, 0x0D, 0x0C});

         const auto be_inferred = Botan::store_be(in16_array);
         result.test_is_eq(be_inferred, std::array<uint8_t, 4>{0x0A, 0x0B, 0x0C, 0x0D});
         const auto le_inferred = Botan::store_le(in16_array);
         result.test_is_eq(le_inferred, std::array<uint8_t, 4>{0x0B, 0x0A, 0x0D, 0x0C});

         // Test load of entire ranges
         const auto in_buffer = Botan::hex_decode("AABBCCDD");
         auto out16_array_be = Botan::load_be<std::array<uint16_t, 2>>(in_buffer);
         result.test_is_eq<uint16_t>(out16_array_be[0], 0xAABB);
         result.test_is_eq<uint16_t>(out16_array_be[1], 0xCCDD);
         auto out16_vec_be = Botan::load_be<std::vector<uint16_t>>(in_buffer);
         result.test_eq_sz("be-vector has expected size", out16_vec_be.size(), 2);
         result.test_is_eq<uint16_t>(out16_vec_be[0], 0xAABB);
         result.test_is_eq<uint16_t>(out16_vec_be[1], 0xCCDD);

         auto out16_array_le = Botan::load_le<std::array<uint16_t, 2>>(in_buffer);
         result.test_is_eq<uint16_t>(out16_array_le[0], 0xBBAA);
         result.test_is_eq<uint16_t>(out16_array_le[1], 0xDDCC);
         auto out16_vec_le = Botan::load_le<Botan::secure_vector<uint16_t>>(in_buffer);
         result.test_eq_sz("le-vector has expected size", out16_vec_be.size(), 2);
         result.test_is_eq<uint16_t>(out16_vec_le[0], 0xBBAA);
         result.test_is_eq<uint16_t>(out16_vec_le[1], 0xDDCC);

         // Test loading/storing of strong type integers
         const TestInt64 in64_strong{0xABCDEF0123456789};
         const TestInt32 in32_strong{0xABCDEF01};

         result.test_is_eq(Botan::store_be<std::vector<uint8_t>>(in64_strong), Botan::hex_decode("ABCDEF0123456789"));
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(in64_strong), Botan::hex_decode("8967452301EFCDAB"));
         result.test_is_eq(Botan::store_be<std::vector<uint8_t>>(in32_strong), Botan::hex_decode("ABCDEF01"));
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(in32_strong), Botan::hex_decode("01EFCDAB"));

         result.test_is_eq(Botan::load_be<TestInt64>(Botan::hex_decode("ABCDEF0123456789")), in64_strong);
         result.test_is_eq(Botan::load_le<TestInt64>(Botan::hex_decode("8967452301EFCDAB")), in64_strong);
         result.test_is_eq(Botan::load_be<TestInt32>(Botan::hex_decode("ABCDEF01")), in32_strong);
         result.test_is_eq(Botan::load_le<TestInt32>(Botan::hex_decode("01EFCDAB")), in32_strong);

         const std::vector<TestInt64> some_in64_strongs{TestInt64{0xABCDEF0123456789}, TestInt64{0x0123456789ABCDEF}};
         result.test_is_eq(Botan::store_be<std::vector<uint8_t>>(some_in64_strongs),
                           Botan::hex_decode("ABCDEF01234567890123456789ABCDEF"));
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(some_in64_strongs),
                           Botan::hex_decode("8967452301EFCDABEFCDAB8967452301"));

         const auto in64_strongs_le =
            Botan::load_le<std::array<TestInt64, 2>>(Botan::hex_decode("8967452301EFCDABEFCDAB8967452301"));
         result.test_is_eq(in64_strongs_le[0], TestInt64{0xABCDEF0123456789});
         result.test_is_eq(in64_strongs_le[1], TestInt64{0x0123456789ABCDEF});

         const auto in64_strongs_be =
            Botan::load_be<std::vector<TestInt64>>(Botan::hex_decode("ABCDEF01234567890123456789ABCDEF"));
         result.test_is_eq(in64_strongs_be[0], TestInt64{0xABCDEF0123456789});
         result.test_is_eq(in64_strongs_be[1], TestInt64{0x0123456789ABCDEF});

         // Test loading/storing of enum types with different endianness
         const auto in64_enum_le = Botan::load_le<TestEnum64>(Botan::hex_decode("1234567890ABCDEF"));
         result.test_is_eq(in64_enum_le, TestEnum64::_2);
         const auto in64_enum_be = Botan::load_be<TestEnum64>(Botan::hex_decode("1234567890ABCDEF"));
         result.test_is_eq(in64_enum_be, TestEnum64::_1);
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(TestEnum64::_1),
                           Botan::hex_decode("EFCDAB9078563412"));
         result.test_is_eq<std::array<uint8_t, 8>>(Botan::store_be(TestEnum64::_2),
                                                   {0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12});

         const auto in32_enum_le = Botan::load_le<TestEnum32>(Botan::hex_decode("78563412"));
         result.test_is_eq(in32_enum_le, TestEnum32::_1);
         const auto in32_enum_be = Botan::load_be<TestEnum32>(Botan::hex_decode("78563412"));
         result.test_is_eq(in32_enum_be, TestEnum32::_2);
         result.test_is_eq(Botan::store_le<std::vector<uint8_t>>(TestEnum32::_1), Botan::hex_decode("78563412"));
         result.test_is_eq<std::array<uint8_t, 4>>(Botan::store_be(TestEnum32::_2), {0x78, 0x56, 0x34, 0x12});

         return result;
      }

      template <std::unsigned_integral T>
      static T fb_load_be(std::array<const uint8_t, sizeof(T)> in) {
         return Botan::detail::fallback_load_any<std::endian::big, T>(in);
      }

      template <std::unsigned_integral T>
      static T fb_load_le(std::array<const uint8_t, sizeof(T)> in) {
         return Botan::detail::fallback_load_any<std::endian::little, T>(in);
      }

      template <std::unsigned_integral T>
      static decltype(auto) fb_store_be(const T in) {
         std::array<uint8_t, sizeof(T)> out{};
         Botan::detail::fallback_store_any<std::endian::big, T>(in, out);
         return out;
      }

      template <std::unsigned_integral T>
      static decltype(auto) fb_store_le(const T in) {
         std::array<uint8_t, sizeof(T)> out{};
         Botan::detail::fallback_store_any<std::endian::little, T>(in, out);
         return out;
      }

      template <size_t N>
      using a = std::array<uint8_t, N>;

      static Test::Result test_loadstore_ambiguity() {
         // This is a regression test for a (probable) compiler bug in Xcode 15
         // where it would fail to compile the load/store functions for size_t
         //
         // It seems that this platform defines uint64_t as "unsigned long long"
         // and size_t as "unsigned long". Both are 64-bits but the compiler
         // was unable to disambiguate the two in reverse_bytes in bswap.h

         const uint32_t in32 = 0x01234567;
         const uint64_t in64 = 0x0123456789ABCDEF;
         const size_t inszt = 0x87654321;

         Test::Result result("Util load/store ambiguity");
         const auto out_be_32 = Botan::store_be(in32);
         const auto out_le_32 = Botan::store_le(in32);
         const auto out_be_64 = Botan::store_be(in64);
         const auto out_le_64 = Botan::store_le(in64);
         const auto out_be_szt = Botan::store_be(inszt);
         const auto out_le_szt = Botan::store_le(inszt);

         result.test_is_eq<uint32_t>("be 32", Botan::load_be<uint32_t>(out_be_32), in32);
         result.test_is_eq<uint32_t>("le 32", Botan::load_le<uint32_t>(out_le_32), in32);
         result.test_is_eq<uint64_t>("be 64", Botan::load_be<uint64_t>(out_be_64), in64);
         result.test_is_eq<uint64_t>("le 64", Botan::load_le<uint64_t>(out_le_64), in64);
         result.test_is_eq<size_t>("be szt", Botan::load_be<size_t>(out_be_szt), inszt);
         result.test_is_eq<size_t>("le szt", Botan::load_le<size_t>(out_le_szt), inszt);

         return result;
      }

      static Test::Result test_loadstore_fallback() {
         // The fallback implementation is only used if we don't know the
         // endianness of the target at compile time. This makes sure that the
         // fallback implementation is correct. On all typical platforms it
         // won't be called in production.
         Test::Result result("Util load/store fallback");

         result.test_is_eq<uint16_t>("lLE 16", fb_load_le<uint16_t>({1, 2}), 0x0201);
         result.test_is_eq<uint32_t>("lLE 32", fb_load_le<uint32_t>({1, 2, 3, 4}), 0x04030201);
         result.test_is_eq<uint64_t>("lLE 64", fb_load_le<uint64_t>({1, 2, 3, 4, 5, 6, 7, 8}), 0x0807060504030201);

         result.test_is_eq<uint16_t>("lBE 16", fb_load_be<uint16_t>({1, 2}), 0x0102);
         result.test_is_eq<uint32_t>("lBE 32", fb_load_be<uint32_t>({1, 2, 3, 4}), 0x01020304);
         result.test_is_eq<uint64_t>("lBE 64", fb_load_be<uint64_t>({1, 2, 3, 4, 5, 6, 7, 8}), 0x0102030405060708);

         result.test_is_eq<a<2>>("sLE 16", fb_store_le<uint16_t>(0x0201), {1, 2});
         result.test_is_eq<a<4>>("sLE 32", fb_store_le<uint32_t>(0x04030201), {1, 2, 3, 4});
         result.test_is_eq<a<8>>("sLE 64", fb_store_le<uint64_t>(0x0807060504030201), {1, 2, 3, 4, 5, 6, 7, 8});

         result.test_is_eq<a<2>>("sBE 16", fb_store_be<uint16_t>(0x0102), {1, 2});
         result.test_is_eq<a<4>>("sBE 32", fb_store_be<uint32_t>(0x01020304), {1, 2, 3, 4});
         result.test_is_eq<a<8>>("sBE 64", fb_store_be<uint64_t>(0x0102030405060708), {1, 2, 3, 4, 5, 6, 7, 8});

         return result;
      }

      static Test::Result test_loadstore_constexpr() {
         Test::Result result("Util load/store constexpr");

         constexpr uint16_t in16 = 0x1234;
         constexpr uint32_t in32 = 0xA0B0C0D0;
         constexpr uint64_t in64 = 0xABCDEF0123456789;

         // clang-format off
         constexpr std::array<uint8_t, 16> cex_mem = {
            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
         };
         // clang-format on

         // get_byte<> w/ 16bit
         constexpr auto cex_byte_16_0 = Botan::get_byte<0>(in16);
         result.test_is_eq<uint8_t>(cex_byte_16_0, 0x12);
         constexpr auto cex_byte_16_1 = Botan::get_byte<1>(in16);
         result.test_is_eq<uint8_t>(cex_byte_16_1, 0x34);

         // get_byte<> w/ 32bit
         constexpr auto cex_byte_32_0 = Botan::get_byte<0>(in32);
         result.test_is_eq<uint8_t>(cex_byte_32_0, 0xA0);
         constexpr auto cex_byte_32_1 = Botan::get_byte<1>(in32);
         result.test_is_eq<uint8_t>(cex_byte_32_1, 0xB0);
         constexpr auto cex_byte_32_2 = Botan::get_byte<2>(in32);
         result.test_is_eq<uint8_t>(cex_byte_32_2, 0xC0);
         constexpr auto cex_byte_32_3 = Botan::get_byte<3>(in32);
         result.test_is_eq<uint8_t>(cex_byte_32_3, 0xD0);

         // get_byte<> w/ 64bit
         constexpr auto cex_byte_64_0 = Botan::get_byte<0>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_0, 0xAB);
         constexpr auto cex_byte_64_1 = Botan::get_byte<1>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_1, 0xCD);
         constexpr auto cex_byte_64_2 = Botan::get_byte<2>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_2, 0xEF);
         constexpr auto cex_byte_64_3 = Botan::get_byte<3>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_3, 0x01);
         constexpr auto cex_byte_64_4 = Botan::get_byte<4>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_4, 0x23);
         constexpr auto cex_byte_64_5 = Botan::get_byte<5>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_5, 0x45);
         constexpr auto cex_byte_64_6 = Botan::get_byte<6>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_6, 0x67);
         constexpr auto cex_byte_64_7 = Botan::get_byte<7>(in64);
         result.test_is_eq<uint8_t>(cex_byte_64_7, 0x89);

         // make_uintXX()
         constexpr auto cex_uint16_t = Botan::make_uint16(0x12, 0x34);
         result.test_is_eq<uint16_t>(cex_uint16_t, in16);
         constexpr auto cex_uint32_t = Botan::make_uint32(0xA0, 0xB0, 0xC0, 0xD0);
         result.test_is_eq<uint32_t>(cex_uint32_t, in32);
         constexpr auto cex_uint64_t = Botan::make_uint64(0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89);
         result.test_is_eq<uint64_t>(cex_uint64_t, in64);

         // store_le/be with a single integer
         constexpr std::array<uint8_t, 2> cex_store_le16 = Botan::store_le(in16);
         result.test_is_eq(cex_store_le16, std::array<uint8_t, 2>{0x34, 0x12});
         constexpr std::array<uint8_t, 4> cex_store_le32 = Botan::store_le(in32);
         result.test_is_eq(cex_store_le32, std::array<uint8_t, 4>{0xD0, 0xC0, 0xB0, 0xA0});
         constexpr std::array<uint8_t, 8> cex_store_le64 = Botan::store_le(in64);
         result.test_is_eq(cex_store_le64, std::array<uint8_t, 8>{0x89, 0x67, 0x45, 0x23, 0x01, 0xEF, 0xCD, 0xAB});

         constexpr std::array<uint8_t, 2> cex_store_be16 = Botan::store_be(in16);
         result.test_is_eq(cex_store_be16, std::array<uint8_t, 2>{0x12, 0x34});
         constexpr std::array<uint8_t, 4> cex_store_be32 = Botan::store_be(in32);
         result.test_is_eq(cex_store_be32, std::array<uint8_t, 4>{0xA0, 0xB0, 0xC0, 0xD0});
         constexpr std::array<uint8_t, 8> cex_store_be64 = Botan::store_be(in64);
         result.test_is_eq(cex_store_be64, std::array<uint8_t, 8>{0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89});

         // store_le/be with multiple integers, both as a parameter pack and a range (std::array for constexpr)
         constexpr std::array<uint8_t, 16> cex_store_le16s =
            Botan::store_le(in16, in16, in16, in16, in16, in16, in16, in16);
         constexpr std::array<uint8_t, 16> cex_store_le16s2 =
            Botan::store_le(std::array{in16, in16, in16, in16, in16, in16, in16, in16});
         result.test_is_eq(
            cex_store_le16s,
            {0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12});
         result.test_is_eq(cex_store_le16s, cex_store_le16s2);
         constexpr std::array<uint8_t, 16> cex_store_le32s = Botan::store_le(in32, in32, in32, in32);
         constexpr std::array<uint8_t, 16> cex_store_le32s2 = Botan::store_le(std::array{in32, in32, in32, in32});
         result.test_is_eq(
            cex_store_le32s,
            {0xD0, 0xC0, 0xB0, 0xA0, 0xD0, 0xC0, 0xB0, 0xA0, 0xD0, 0xC0, 0xB0, 0xA0, 0xD0, 0xC0, 0xB0, 0xA0});
         result.test_is_eq(cex_store_le32s, cex_store_le32s2);
         constexpr std::array<uint8_t, 16> cex_store_le64s = Botan::store_le(in64, in64);
         constexpr std::array<uint8_t, 16> cex_store_le64s2 = Botan::store_le(std::array{in64, in64});
         result.test_is_eq(
            cex_store_le64s,
            {0x89, 0x67, 0x45, 0x23, 0x01, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01, 0xEF, 0xCD, 0xAB});
         result.test_is_eq(cex_store_le64s, cex_store_le64s2);

         constexpr std::array<uint8_t, 16> cex_store_be16s =
            Botan::store_be(in16, in16, in16, in16, in16, in16, in16, in16);
         constexpr std::array<uint8_t, 16> cex_store_be16s2 =
            Botan::store_be(std::array{in16, in16, in16, in16, in16, in16, in16, in16});
         result.test_is_eq(
            cex_store_be16s,
            {0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34, 0x12, 0x34});
         result.test_is_eq(cex_store_be16s, cex_store_be16s2);
         constexpr std::array<uint8_t, 16> cex_store_be32s = Botan::store_be(in32, in32, in32, in32);
         constexpr std::array<uint8_t, 16> cex_store_be32s2 = Botan::store_be(std::array{in32, in32, in32, in32});
         result.test_is_eq(
            cex_store_be32s,
            {0xA0, 0xB0, 0xC0, 0xD0, 0xA0, 0xB0, 0xC0, 0xD0, 0xA0, 0xB0, 0xC0, 0xD0, 0xA0, 0xB0, 0xC0, 0xD0});
         result.test_is_eq(cex_store_be32s, cex_store_be32s2);
         constexpr std::array<uint8_t, 16> cex_store_be64s = Botan::store_be(in64, in64);
         constexpr std::array<uint8_t, 16> cex_store_be64s2 = Botan::store_be(std::array{in64, in64});
         result.test_is_eq(
            cex_store_be64s,
            {0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45, 0x67, 0x89});
         result.test_is_eq(cex_store_be64s, cex_store_be64s2);

         // load_le/be a single integer
         constexpr uint16_t cex_load_le16 = Botan::load_le<uint16_t>(cex_store_le16);
         result.test_is_eq(cex_load_le16, in16);
         constexpr uint32_t cex_load_le32 = Botan::load_le<uint32_t>(cex_store_le32);
         result.test_is_eq(cex_load_le32, in32);
         constexpr uint64_t cex_load_le64 = Botan::load_le<uint64_t>(cex_store_le64);
         result.test_is_eq(cex_load_le64, in64);

         constexpr uint16_t cex_load_be16 = Botan::load_be<uint16_t>(cex_store_be16);
         result.test_is_eq(cex_load_be16, in16);
         constexpr uint32_t cex_load_be32 = Botan::load_be<uint32_t>(cex_store_be32);
         result.test_is_eq(cex_load_be32, in32);
         constexpr uint64_t cex_load_be64 = Botan::load_be<uint64_t>(cex_store_be64);
         result.test_is_eq(cex_load_be64, in64);

         // load_le/be multiple integers into a std::array for constexpr
         constexpr auto cex_load_le16s = Botan::load_le<std::array<uint16_t, cex_mem.size() / 2>>(cex_mem);
         result.test_is_eq(cex_load_le16s, {0x1100, 0x3322, 0x5544, 0x7766, 0x9988, 0xBBAA, 0xDDCC, 0xFFEE});
         constexpr auto cex_load_le32s = Botan::load_le<std::array<uint32_t, cex_mem.size() / 4>>(cex_mem);
         result.test_is_eq(cex_load_le32s, {0x33221100, 0x77665544, 0xBBAA9988, 0xFFEEDDCC});
         constexpr auto cex_load_le64s = Botan::load_le<std::array<uint64_t, cex_mem.size() / 8>>(cex_mem);
         result.test_is_eq(cex_load_le64s, {0x7766554433221100, 0xFFEEDDCCBBAA9988});

         constexpr auto cex_load_be16s = Botan::load_be<std::array<uint16_t, cex_mem.size() / 2>>(cex_mem);
         result.test_is_eq(cex_load_be16s, {0x0011, 0x2233, 0x4455, 0x6677, 0x8899, 0xAABB, 0xCCDD, 0xEEFF});
         constexpr auto cex_load_be32s = Botan::load_be<std::array<uint32_t, cex_mem.size() / 4>>(cex_mem);
         result.test_is_eq(cex_load_be32s, {0x00112233, 0x44556677, 0x8899AABB, 0xCCDDEEFF});
         constexpr auto cex_load_be64s = Botan::load_be<std::array<uint64_t, cex_mem.size() / 8>>(cex_mem);
         result.test_is_eq(cex_load_be64s, {0x0011223344556677, 0x8899AABBCCDDEEFF});

         return result;
      }

      static std::vector<Test::Result> test_copy_out_be_le() {
         return {
            CHECK("copy_out_be with 16bit input (word aligned)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(4);
                     const std::array<uint16_t, 2> in_array = {0x0A0B, 0x0C0D};
                     Botan::copy_out_be(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0A0B0C0D"));
                  }),

            CHECK("copy_out_be with 16bit input (partial words)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(3);
                     const std::array<uint16_t, 2> in_array = {0x0A0B, 0x0C0D};
                     Botan::copy_out_be(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0A0B0C"));
                  }),

            CHECK("copy_out_le with 16bit input (word aligned)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(4);
                     const std::array<uint16_t, 2> in_array = {0x0A0B, 0x0C0D};
                     Botan::copy_out_le(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0B0A0D0C"));
                  }),

            CHECK("copy_out_le with 16bit input (partial words)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(3);
                     const std::array<uint16_t, 2> in_array = {0x0A0B, 0x0C0D};
                     Botan::copy_out_le(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0B0A0D"));
                  }),

            CHECK("copy_out_be with 64bit input (word aligned)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(16);
                     const std::array<uint64_t, 2> in_array = {0x0A0B0C0D0E0F1011, 0x1213141516171819};
                     Botan::copy_out_be(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0A0B0C0D0E0F10111213141516171819"));
                  }),

            CHECK("copy_out_le with 64bit input (word aligned)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(16);
                     const std::array<uint64_t, 2> in_array = {0x0A0B0C0D0E0F1011, 0x1213141516171819};
                     Botan::copy_out_le(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("11100F0E0D0C0B0A1918171615141312"));
                  }),

            CHECK("copy_out_be with 64bit input (partial words)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(15);
                     const std::array<uint64_t, 2> in_array = {0x0A0B0C0D0E0F1011, 0x1213141516171819};
                     Botan::copy_out_be(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("0A0B0C0D0E0F101112131415161718"));
                  }),

            CHECK("copy_out_le with 64bit input (partial words)",
                  [&](auto& result) {
                     std::vector<uint8_t> out_vector(15);
                     const std::array<uint64_t, 2> in_array = {0x0A0B0C0D0E0F1011, 0x1213141516171819};
                     Botan::copy_out_le(out_vector, in_array);
                     result.test_is_eq(out_vector, Botan::hex_decode("11100F0E0D0C0B0A19181716151413"));
                  }),
         };
      }
};

BOTAN_REGISTER_SMOKE_TEST("utils", "util", Utility_Function_Tests);

class BitOps_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         std::vector<Test::Result> results;

         results.push_back(test_power_of_2());
         results.push_back(test_ctz());
         results.push_back(test_sig_bytes());
         results.push_back(test_popcount());
         results.push_back(test_reverse_bits());

         return results;
      }

   private:
      template <typename T>
      void test_ctz(Test::Result& result, T val, size_t expected) {
         Botan::CT::poison(val);
         const size_t computed = Botan::ctz<T>(val);
         Botan::CT::unpoison_all(computed, val);
         result.test_eq("ctz(" + std::to_string(val) + ")", computed, expected);
      }

      Test::Result test_ctz() {
         Test::Result result("ctz");
         test_ctz<uint32_t>(result, 0, 32);
         test_ctz<uint32_t>(result, 1, 0);
         test_ctz<uint32_t>(result, 0x80, 7);
         test_ctz<uint32_t>(result, 0x8000000, 27);
         test_ctz<uint32_t>(result, 0x8100000, 20);
         test_ctz<uint32_t>(result, 0x80000000, 31);

         return result;
      }

      template <typename T>
      void test_sig_bytes(Test::Result& result, T val, size_t expected) {
         Botan::CT::poison(val);
         const size_t computed = Botan::significant_bytes<T>(val);
         Botan::CT::unpoison_all(computed, val);
         result.test_eq("significant_bytes(" + std::to_string(val) + ")", computed, expected);
      }

      Test::Result test_sig_bytes() {
         Test::Result result("significant_bytes");
         test_sig_bytes<uint32_t>(result, 0, 0);
         test_sig_bytes<uint32_t>(result, 1, 1);
         test_sig_bytes<uint32_t>(result, 0x80, 1);
         test_sig_bytes<uint32_t>(result, 255, 1);
         test_sig_bytes<uint32_t>(result, 256, 2);
         test_sig_bytes<uint32_t>(result, 65535, 2);
         test_sig_bytes<uint32_t>(result, 65536, 3);
         test_sig_bytes<uint32_t>(result, 0x80000000, 4);

         test_sig_bytes<uint64_t>(result, 0, 0);
         test_sig_bytes<uint64_t>(result, 1, 1);
         test_sig_bytes<uint64_t>(result, 0x80, 1);
         test_sig_bytes<uint64_t>(result, 256, 2);
         test_sig_bytes<uint64_t>(result, 0x80000000, 4);
         test_sig_bytes<uint64_t>(result, 0x100000000, 5);

         return result;
      }

      template <typename T>
      void test_power_of_2(Test::Result& result, T val, bool expected) {
         result.test_eq("power_of_2(" + std::to_string(val) + ")", Botan::is_power_of_2<T>(val), expected);
      }

      Test::Result test_power_of_2() {
         Test::Result result("is_power_of_2");

         test_power_of_2<uint32_t>(result, 0, false);
         test_power_of_2<uint32_t>(result, 1, false);
         test_power_of_2<uint32_t>(result, 2, true);
         test_power_of_2<uint32_t>(result, 3, false);
         test_power_of_2<uint32_t>(result, 0x8000, true);
         test_power_of_2<uint32_t>(result, 0x8001, false);
         test_power_of_2<uint32_t>(result, 0x8000000, true);

         test_power_of_2<uint64_t>(result, 0, false);
         test_power_of_2<uint64_t>(result, 1, false);
         test_power_of_2<uint64_t>(result, 2, true);
         test_power_of_2<uint64_t>(result, 3, false);
         test_power_of_2<uint64_t>(result, 0x8000, true);
         test_power_of_2<uint64_t>(result, 0x8001, false);
         test_power_of_2<uint64_t>(result, 0x8000000, true);
         test_power_of_2<uint64_t>(result, 0x100000000000, true);

         return result;
      }

      template <typename T>
      auto pc(T val) -> decltype(Botan::ct_popcount(val)) {
         return Botan::ct_popcount(val);
      }

      template <typename T>
      auto random_pc(Test::Result& result) {
         auto n = Botan::load_le<T>(Test::rng().random_array<sizeof(T)>());
         result.test_is_eq<size_t>(Botan::fmt("popcount({}) == {}", n, std::popcount(n)), pc(n), std::popcount(n));
      }

      Test::Result test_popcount() {
         Test::Result result("popcount");

         result.test_is_eq<uint8_t>("popcount<uint8_t>(0)", pc<uint8_t>(0), 0);
         result.test_is_eq<uint8_t>("popcount<uint16_t>(0)", pc<uint16_t>(0), 0);
         result.test_is_eq<uint8_t>("popcount<uint32_t>(0)", pc<uint32_t>(0), 0);
         result.test_is_eq<uint8_t>("popcount<uint64_t>(0)", pc<uint64_t>(0), 0);

         result.test_is_eq<uint8_t>("popcount<uint8_t>(1)", pc<uint8_t>(1), 1);
         result.test_is_eq<uint8_t>("popcount<uint16_t>(1)", pc<uint16_t>(1), 1);
         result.test_is_eq<uint8_t>("popcount<uint32_t>(1)", pc<uint32_t>(1), 1);
         result.test_is_eq<uint8_t>("popcount<uint64_t>(1)", pc<uint64_t>(1), 1);

         result.test_is_eq<uint8_t>("popcount<uint8_t>(0xAA)", pc<uint8_t>(0xAA), 4);
         result.test_is_eq<uint8_t>("popcount<uint16_t>(0xAAAA)", pc<uint16_t>(0xAAAA), 8);
         result.test_is_eq<uint8_t>("popcount<uint32_t>(0xAAAA...)", pc<uint32_t>(0xAAAAAAAA), 16);
         result.test_is_eq<uint8_t>("popcount<uint64_t>(0xAAAA...)", pc<uint64_t>(0xAAAAAAAAAAAAAAAA), 32);

         result.test_is_eq<uint8_t>("popcount<uint8_t>(0xFF)", pc<uint8_t>(0xFF), 8);
         result.test_is_eq<uint8_t>("popcount<uint16_t>(0xFFFF)", pc<uint16_t>(0xFFFF), 16);
         result.test_is_eq<uint8_t>("popcount<uint32_t>(0xFFFF...)", pc<uint32_t>(0xFFFFFFFF), 32);
         result.test_is_eq<uint8_t>("popcount<uint64_t>(0xFFFF...)", pc<uint64_t>(0xFFFFFFFFFFFFFFFF), 64);

         random_pc<uint8_t>(result);
         random_pc<uint16_t>(result);
         random_pc<uint32_t>(result);
         random_pc<uint64_t>(result);

         return result;
      }

      Test::Result test_reverse_bits() {
         Test::Result result("reverse_bits");

         result.test_is_eq<uint8_t>("rev(0u8)", Botan::ct_reverse_bits<uint8_t>(0b00000000), 0b00000000);
         result.test_is_eq<uint8_t>("rev(1u8)", Botan::ct_reverse_bits<uint8_t>(0b01010101), 0b10101010);
         result.test_is_eq<uint8_t>("rev(2u8)", Botan::ct_reverse_bits<uint8_t>(0b01001011), 0b11010010);

         result.test_is_eq<uint16_t>(
            "rev(0u16)", Botan::ct_reverse_bits<uint16_t>(0b0000000000000000), 0b0000000000000000);
         result.test_is_eq<uint16_t>(
            "rev(1u16)", Botan::ct_reverse_bits<uint16_t>(0b0101010101010101), 0b1010101010101010);
         result.test_is_eq<uint16_t>(
            "rev(2u16)", Botan::ct_reverse_bits<uint16_t>(0b0100101101011010), 0b0101101011010010);

         result.test_is_eq<uint32_t>("rev(0u32)", Botan::ct_reverse_bits<uint32_t>(0xFFFFFFFF), 0xFFFFFFFF);
         result.test_is_eq<uint32_t>("rev(1u32)", Botan::ct_reverse_bits<uint32_t>(0x55555555), 0xAAAAAAAA);
         result.test_is_eq<uint32_t>("rev(2u32)", Botan::ct_reverse_bits<uint32_t>(0x4B6A2C1D), 0xB83456D2);

         result.test_is_eq<uint64_t>(
            "rev(0u64)", Botan::ct_reverse_bits<uint64_t>(0xF0E0D0C005040302), 0x40C020A0030B070F);
         result.test_is_eq<uint64_t>(
            "rev(1u64)", Botan::ct_reverse_bits<uint64_t>(0x5555555555555555), 0xAAAAAAAAAAAAAAAA);
         result.test_is_eq<uint64_t>(
            "rev(2u64)", Botan::ct_reverse_bits<uint64_t>(0x4B6A2C1D5E7F8A90), 0x951FE7AB83456D2);

         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "bit_ops", BitOps_Tests);

#if defined(BOTAN_HAS_POLY_DBL)

class Poly_Double_Tests final : public Text_Based_Test {
   public:
      Poly_Double_Tests() : Text_Based_Test("poly_dbl.vec", "In,Out") {}

      Test::Result run_one_test(const std::string& /*header*/, const VarMap& vars) override {
         Test::Result result("Polynomial doubling");
         const std::vector<uint8_t> in = vars.get_req_bin("In");
         const std::vector<uint8_t> out = vars.get_req_bin("Out");

         std::vector<uint8_t> b = in;
         Botan::poly_double_n(b.data(), b.size());

         result.test_eq("Expected value", b, out);
         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "poly_dbl", Poly_Double_Tests);

#endif

class Version_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         Test::Result result("Versions");

         result.confirm("Version datestamp matches macro", Botan::version_datestamp() == BOTAN_VERSION_DATESTAMP);

         const char* version_cstr = Botan::version_cstr();
         const std::string version_str = Botan::version_string();
         result.test_eq("Same version string", version_str, std::string(version_cstr));

         const char* sversion_cstr = Botan::short_version_cstr();
         const std::string sversion_str = Botan::short_version_string();
         result.test_eq("Same short version string", sversion_str, std::string(sversion_cstr));

         const auto expected_sversion =
            Botan::fmt("{}.{}.{}", BOTAN_VERSION_MAJOR, BOTAN_VERSION_MINOR, BOTAN_VERSION_PATCH);

         // May have a suffix eg 4.0.0-rc2
         result.confirm("Short version string has expected format", sversion_str.starts_with(expected_sversion));

         const std::string version_check_ok =
            Botan::runtime_version_check(BOTAN_VERSION_MAJOR, BOTAN_VERSION_MINOR, BOTAN_VERSION_PATCH);

         result.confirm("Correct version no warning", version_check_ok.empty());

         const std::string version_check_bad = Botan::runtime_version_check(1, 19, 42);

         const std::string expected_error =
            "Warning: linked version (" + sversion_str + ") does not match version built against (1.19.42)\n";

         result.test_eq("Expected warning text", version_check_bad, expected_error);

         return {result};
      }
};

BOTAN_REGISTER_TEST("utils", "versioning", Version_Tests);

class Date_Format_Tests final : public Text_Based_Test {
   public:
      Date_Format_Tests() : Text_Based_Test("dates.vec", "Date") {}

      static std::vector<uint32_t> parse_date(const std::string& s) {
         const std::vector<std::string> parts = Botan::split_on(s, ',');
         if(parts.size() != 6) {
            throw Test_Error("Bad date format '" + s + "'");
         }

         std::vector<uint32_t> u32s;
         u32s.reserve(parts.size());
         for(const auto& sub : parts) {
            u32s.push_back(Botan::to_u32bit(sub));
         }
         return u32s;
      }

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         const std::string date_str = vars.get_req_str("Date");
         Test::Result result("Date parsing");

         const std::vector<uint32_t> d = parse_date(date_str);

         if(type == "valid" || type == "valid.not_std" || type == "valid.64_bit_time_t") {
            const Botan::calendar_point c(d[0], d[1], d[2], d[3], d[4], d[5]);
            result.test_is_eq(date_str + " year", c.year(), d[0]);
            result.test_is_eq(date_str + " month", c.month(), d[1]);
            result.test_is_eq(date_str + " day", c.day(), d[2]);
            result.test_is_eq(date_str + " hour", c.hour(), d[3]);
            result.test_is_eq(date_str + " minute", c.minutes(), d[4]);
            result.test_is_eq(date_str + " second", c.seconds(), d[5]);

            if(type == "valid.not_std" ||
               (type == "valid.64_bit_time_t" && c.year() > 2037 && sizeof(std::time_t) == 4)) {
               result.test_throws("valid but out of std::timepoint range", [c]() { c.to_std_timepoint(); });
            } else {
               const Botan::calendar_point c2(c.to_std_timepoint());
               result.test_is_eq(date_str + " year", c2.year(), d[0]);
               result.test_is_eq(date_str + " month", c2.month(), d[1]);
               result.test_is_eq(date_str + " day", c2.day(), d[2]);
               result.test_is_eq(date_str + " hour", c2.hour(), d[3]);
               result.test_is_eq(date_str + " minute", c2.minutes(), d[4]);
               result.test_is_eq(date_str + " second", c2.seconds(), d[5]);
            }
         } else if(type == "invalid") {
            result.test_throws("invalid date",
                               [d]() { const Botan::calendar_point c(d[0], d[1], d[2], d[3], d[4], d[5]); });
         } else {
            throw Test_Error("Unexpected header '" + type + "' in date format tests");
         }

         return result;
      }

      std::vector<Test::Result> run_final_tests() override {
         Test::Result result("calendar_point::to_string");
         const Botan::calendar_point d(2008, 5, 15, 9, 30, 33);
         // desired format: <YYYY>-<MM>-<dd>T<HH>:<mm>:<ss>
         result.test_eq("calendar_point::to_string", d.to_string(), "2008-05-15T09:30:33");
         return {result};
      }
};

BOTAN_REGISTER_TEST("utils", "util_dates", Date_Format_Tests);

class Charset_Tests final : public Text_Based_Test {
   public:
      Charset_Tests() : Text_Based_Test("charset.vec", "In,Out") {}

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("Charset");

         const std::vector<uint8_t> in = vars.get_req_bin("In");
         const std::vector<uint8_t> expected = vars.get_req_bin("Out");

         std::string converted;

         if(type == "UCS2-UTF8") {
            converted = Botan::ucs2_to_utf8(in.data(), in.size());
         } else if(type == "UCS4-UTF8") {
            converted = Botan::ucs4_to_utf8(in.data(), in.size());
         } else if(type == "LATIN1-UTF8") {
            converted = Botan::latin1_to_utf8(in.data(), in.size());
         } else {
            throw Test_Error("Unexpected header '" + type + "' in charset tests");
         }

         result.test_eq(
            "string converted successfully", std::vector<uint8_t>(converted.begin(), converted.end()), expected);

         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "charset", Charset_Tests);

class Hostname_Tests final : public Text_Based_Test {
   public:
      Hostname_Tests() : Text_Based_Test("hostnames.vec", "Issued,Hostname") {}

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("Hostname Matching");

         const std::string issued = vars.get_req_str("Issued");
         const std::string hostname = vars.get_req_str("Hostname");
         const bool expected = (type == "Invalid") ? false : true;

         const std::string what = hostname + ((expected == true) ? " matches " : " does not match ") + issued;
         result.test_eq(what, Botan::host_wildcard_match(issued, hostname), expected);

         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "hostname", Hostname_Tests);

class DNS_Check_Tests final : public Text_Based_Test {
   public:
      DNS_Check_Tests() : Text_Based_Test("utils/dns.vec", "DNS") {}

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("DNS name validation");

         const std::string name = vars.get_req_str("DNS");
         const bool valid = (type == "Invalid") ? false : true;

         try {
            const auto canonicalized = Botan::check_and_canonicalize_dns_name(name);
            BOTAN_UNUSED(canonicalized);

            if(valid) {
               result.test_success("Accepted valid name");
            } else {
               result.test_failure("Accepted invalid name");
            }
         } catch(Botan::Decoding_Error&) {
            if(valid) {
               result.test_failure("Rejected valid name");
            } else {
               result.test_success("Rejected invalid name");
            }
         }

         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "dns_check", DNS_Check_Tests);

class IPv4_Parsing_Tests final : public Text_Based_Test {
   public:
      IPv4_Parsing_Tests() : Text_Based_Test("utils/ipv4.vec", "IPv4") {}

      Test::Result run_one_test(const std::string& status, const VarMap& vars) override {
         Test::Result result("IPv4 parsing");

         const std::string input = vars.get_req_str("IPv4");
         const bool valid = (status == "Valid");

         auto ipv4 = Botan::string_to_ipv4(input);

         result.test_eq("string_to_ipv4 accepts only valid", valid, ipv4.has_value());

         if(ipv4) {
            const std::string rt = Botan::ipv4_to_string(ipv4.value());
            result.test_eq("ipv4_to_string and string_to_ipv4 round trip", input, rt);
         }

         return result;
      }
};

BOTAN_REGISTER_TEST("utils", "ipv4_parse", IPv4_Parsing_Tests);

class ReadKV_Tests final : public Text_Based_Test {
   public:
      ReadKV_Tests() : Text_Based_Test("utils/read_kv.vec", "Input,Expected") {}

      Test::Result run_one_test(const std::string& status, const VarMap& vars) override {
         Test::Result result("read_kv");

         const bool is_valid = (status == "Valid");

         const std::string input = vars.get_req_str("Input");
         const std::string expected = vars.get_req_str("Expected");

         if(is_valid) {
            confirm_kv(result, Botan::read_kv(input), split_group(expected));
         } else {
            // In this case "expected" is the expected exception message
            result.test_throws("Invalid key value input throws exception", expected, [&]() { Botan::read_kv(input); });
         }
         return result;
      }

   private:
      static std::vector<std::string> split_group(const std::string& str) {
         std::vector<std::string> elems;
         if(str.empty()) {
            return elems;
         }

         std::string substr;
         for(const char c : str) {
            if(c == '|') {
               elems.push_back(substr);
               substr.clear();
            } else {
               substr += c;
            }
         }

         if(!substr.empty()) {
            elems.push_back(substr);
         }

         return elems;
      }

      static void confirm_kv(Test::Result& result,
                             const std::map<std::string, std::string>& kv,
                             const std::vector<std::string>& expected) {
         if(!result.test_eq("expected size", expected.size() % 2, size_t(0))) {
            return;
         }

         for(size_t i = 0; i != expected.size(); i += 2) {
            auto j = kv.find(expected[i]);
            if(result.confirm("Found key", j != kv.end())) {
               result.test_eq("Matching value", j->second, expected[i + 1]);
            }
         }

         result.test_eq("KV has same size as expected", kv.size(), expected.size() / 2);
      }
};

BOTAN_REGISTER_TEST("utils", "util_read_kv", ReadKV_Tests);

#if defined(BOTAN_HAS_CPUID)

class CPUID_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         Test::Result result("CPUID");

         const std::string cpuid_string = Botan::CPUID::to_string();
         result.test_success("CPUID::to_string doesn't crash");

         for(size_t b = 0; b != 32; ++b) {
            try {
               const auto bit = static_cast<uint32_t>(1) << b;
               // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
               const auto feat = Botan::CPUID::Feature(static_cast<Botan::CPUID::Feature::Bit>(bit));

               const std::string feat_str = feat.to_string();

               result.confirm("Feature string is not empty", !feat_str.empty());

               if(auto from_str = Botan::CPUID::Feature::from_string(feat_str)) {
                  result.test_int_eq("Feature::from_string returns expected bit", from_str->as_u32(), bit);
               } else {
                  result.test_failure(
                     Botan::fmt("Feature::from_string didn't recognize its own output ({})", feat_str));
               }
            } catch(Botan::Invalid_State&) {
               // This will thrown if the bit is not a valid one
            }
         }

   #if defined(BOTAN_TARGET_ARCH_IS_X86_FAMILY)

         const auto bit = Botan::CPUID::Feature::SSE2;

         if(Botan::CPUID::has(bit)) {
            result.confirm("Output string includes sse2", cpuid_string.find("sse2") != std::string::npos);

            Botan::CPUID::clear_cpuid_bit(bit);

            result.test_eq(
               "After clearing cpuid bit, CPUID::has for SSE2 returns false", Botan::CPUID::has(bit), false);

            Botan::CPUID::initialize();  // reset state
            result.test_eq(
               "After reinitializing, CPUID::has for SSE2 returns true again", Botan::CPUID::has(bit), true);
         }
   #else
         BOTAN_UNUSED(cpuid_string);
   #endif

         return {result};
      }
};

BOTAN_REGISTER_SERIALIZED_TEST("utils", "cpuid", CPUID_Tests);

#endif

#if defined(BOTAN_HAS_UUID)

class UUID_Tests : public Test {
   public:
      std::vector<Test::Result> run() override {
         Test::Result result("UUID");

         const Botan::UUID empty_uuid;
         const Botan::UUID random_uuid1(this->rng());
         const Botan::UUID random_uuid2(this->rng());
         const Botan::UUID loaded_uuid(std::vector<uint8_t>(16, 4));

         result.test_throws("Cannot load wrong number of bytes",
                            []() { const Botan::UUID u(std::vector<uint8_t>(15)); });

         result.test_eq("Empty UUID is empty", empty_uuid.is_valid(), false);
         result.confirm("Empty UUID equals another empty UUID", empty_uuid == Botan::UUID());

         result.test_throws("Empty UUID cannot become a string", [&]() { empty_uuid.to_string(); });

         result.test_eq("Random UUID not empty", random_uuid1.is_valid(), true);
         result.test_eq("Random UUID not empty", random_uuid2.is_valid(), true);

         result.confirm("Random UUIDs are distinct", random_uuid1 != random_uuid2);
         result.confirm("Random UUIDs not equal to empty", random_uuid1 != empty_uuid);

         const std::string uuid4_str = loaded_uuid.to_string();
         result.test_eq("String matches expected", uuid4_str, "04040404-0404-0404-0404-040404040404");

         const std::string uuid_r1_str = random_uuid1.to_string();
         result.confirm("UUID from string matches", Botan::UUID(uuid_r1_str) == random_uuid1);

         class AllSame_RNG : public Botan::RandomNumberGenerator {
            public:
               explicit AllSame_RNG(uint8_t b) : m_val(b) {}

               void fill_bytes_with_input(std::span<uint8_t> output, std::span<const uint8_t> /* ignored */) override {
                  std::fill(output.begin(), output.end(), m_val);
               }

               std::string name() const override { return "zeros"; }

               bool accepts_input() const override { return false; }

               void clear() override {}

               bool is_seeded() const override { return true; }

            private:
               uint8_t m_val;
         };

         AllSame_RNG zeros(0x00);
         const Botan::UUID zero_uuid(zeros);
         result.test_eq("Zero UUID matches expected", zero_uuid.to_string(), "00000000-0000-4000-8000-000000000000");

         AllSame_RNG ones(0xFF);
         const Botan::UUID ones_uuid(ones);
         result.test_eq("Ones UUID matches expected", ones_uuid.to_string(), "FFFFFFFF-FFFF-4FFF-BFFF-FFFFFFFFFFFF");

         return {result};
      }
};

BOTAN_REGISTER_TEST("utils", "uuid", UUID_Tests);

#endif

class Formatter_Tests : public Test {
   public:
      std::vector<Test::Result> run() override {
         Test::Result result("Format utility");

         /*
         In a number of these tests, we are not strictly depending on the
         behavior, for instance checking `fmt("{}") == "{}"` is more about
         checking that we don't crash, rather than we return that precise string.
         */

         result.test_eq("test 1", Botan::fmt("hi"), "hi");
         result.test_eq("test 2", Botan::fmt("ignored", 5), "ignored");
         result.test_eq("test 3", Botan::fmt("answer is {}", 42), "answer is 42");
         result.test_eq("test 4", Botan::fmt("{", 5), "{");
         result.test_eq("test 4", Botan::fmt("{}"), "{}");
         result.test_eq("test 5", Botan::fmt("{} == '{}'", 5, "five"), "5 == 'five'");

         return {result};
      }
};

BOTAN_REGISTER_TEST("utils", "fmt", Formatter_Tests);

class ScopedCleanup_Tests : public Test {
   public:
      std::vector<Test::Result> run() override {
         return {
            CHECK("leaving a scope results in cleanup",
                  [](Test::Result& result) {
                     bool ran = false;
                     {
                        auto clean = Botan::scoped_cleanup([&] { ran = true; });
                     }
                     result.confirm("cleanup ran", ran);
                  }),

            CHECK("leaving a function, results in cleanup",
                  [](Test::Result& result) {
                     bool ran = false;
                     bool fn_called = false;
                     auto fn = [&] {
                        auto clean = Botan::scoped_cleanup([&] { ran = true; });
                        fn_called = true;
                     };

                     result.confirm("cleanup not yet ran", !ran);
                     fn();
                     result.confirm("fn called", fn_called);
                     result.confirm("cleanup ran", ran);
                  }),

            CHECK("stack unwinding results in cleanup",
                  [](Test::Result& result) {
                     bool ran = false;
                     bool fn_called = false;
                     bool exception_caught = false;
                     auto fn = [&] {
                        auto clean = Botan::scoped_cleanup([&] { ran = true; });
                        fn_called = true;
                        throw std::runtime_error("test");
                     };

                     result.confirm("cleanup not yet ran", !ran);
                     try {
                        fn();
                     } catch(const std::exception&) {
                        exception_caught = true;
                     }

                     result.confirm("fn called", fn_called);
                     result.confirm("cleanup ran", ran);
                     result.confirm("exception caught", exception_caught);
                  }),

            CHECK("cleanup isn't called after disengaging",
                  [](Test::Result& result) {
                     bool ran = false;
                     {
                        auto clean = Botan::scoped_cleanup([&] { ran = true; });
                        clean.disengage();
                     }
                     result.confirm("cleanup not ran", !ran);
                  }),

         };
      }
};

BOTAN_REGISTER_TEST("utils", "scoped_cleanup", ScopedCleanup_Tests);

}  // namespace

}  // namespace Botan_Tests

randombit / botan / 20577379106

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous