src/common/mathutil_unittest.cpp

//
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// mathutil_unittest:
//   Unit tests for the utils defined in mathutil.h
//

#include "mathutil.h"

#include <array>

#include <gtest/gtest.h>

using namespace gl;

namespace
{

// Test the correctness of packSnorm2x16 and unpackSnorm2x16 functions.
// For floats f1 and f2, unpackSnorm2x16(packSnorm2x16(f1, f2)) should be same as f1 and f2.
TEST(MathUtilTest, packAndUnpackSnorm2x16)
{
    static constexpr std::array<std::array<float, 2>, 8> input = {{
        {0.0f, 0.0f},
        {1.0f, 1.0f},
        {-1.0f, 1.0f},
        {-1.0f, -1.0f},
        {0.875f, 0.75f},
        {0.00392f, -0.99215f},
        {-0.000675f, 0.004954f},
        {-0.6937f, -0.02146f},
    }};
    const float floatFaultTolerance                            = 0.0001f;
    float outputVal1, outputVal2;

    for (size_t i = 0; i < 8; i++)
    {
        unpackSnorm2x16(packSnorm2x16(input[i][0], input[i][1]), &outputVal1, &outputVal2);
        EXPECT_NEAR(input[i][0], outputVal1, floatFaultTolerance);
        EXPECT_NEAR(input[i][1], outputVal2, floatFaultTolerance);
    }
}

// Test the correctness of packSnorm2x16 and unpackSnorm2x16 functions with infinity values,
// result should be clamped to [-1, 1].
TEST(MathUtilTest, packAndUnpackSnorm2x16Infinity)
{
    const float floatFaultTolerance = 0.0001f;
    float outputVal1, outputVal2;

    unpackSnorm2x16(packSnorm2x16(std::numeric_limits<float>::infinity(),
                                  std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(1.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(1.0f, outputVal2, floatFaultTolerance);

    unpackSnorm2x16(packSnorm2x16(std::numeric_limits<float>::infinity(),
                                  -std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(1.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(-1.0f, outputVal2, floatFaultTolerance);

    unpackSnorm2x16(packSnorm2x16(-std::numeric_limits<float>::infinity(),
                                  -std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(-1.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(-1.0f, outputVal2, floatFaultTolerance);
}

// Test the correctness of packUnorm2x16 and unpackUnorm2x16 functions.
// For floats f1 and f2, unpackUnorm2x16(packUnorm2x16(f1, f2)) should be same as f1 and f2.
TEST(MathUtilTest, packAndUnpackUnorm2x16)
{
    static constexpr std::array<std::array<float, 2>, 8> input = {{
        {0.0f, 0.0f},
        {1.0f, 1.0f},
        {-1.0f, 1.0f},
        {-1.0f, -1.0f},
        {0.875f, 0.75f},
        {0.00392f, -0.99215f},
        {-0.000675f, 0.004954f},
        {-0.6937f, -0.02146f},
    }};
    const float floatFaultTolerance                            = 0.0001f;
    float outputVal1, outputVal2;

    for (size_t i = 0; i < 8; i++)
    {
        unpackUnorm2x16(packUnorm2x16(input[i][0], input[i][1]), &outputVal1, &outputVal2);
        float expected = input[i][0] < 0.0f ? 0.0f : input[i][0];
        EXPECT_NEAR(expected, outputVal1, floatFaultTolerance);
        expected = input[i][1] < 0.0f ? 0.0f : input[i][1];
        EXPECT_NEAR(expected, outputVal2, floatFaultTolerance);
    }
}

// Test the correctness of packUnorm2x16 and unpackUnorm2x16 functions with infinity values,
// result should be clamped to [0, 1].
TEST(MathUtilTest, packAndUnpackUnorm2x16Infinity)
{
    const float floatFaultTolerance = 0.0001f;
    float outputVal1, outputVal2;

    unpackUnorm2x16(packUnorm2x16(std::numeric_limits<float>::infinity(),
                                  std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(1.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(1.0f, outputVal2, floatFaultTolerance);

    unpackUnorm2x16(packUnorm2x16(std::numeric_limits<float>::infinity(),
                                  -std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(1.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(0.0f, outputVal2, floatFaultTolerance);

    unpackUnorm2x16(packUnorm2x16(-std::numeric_limits<float>::infinity(),
                                  -std::numeric_limits<float>::infinity()),
                    &outputVal1, &outputVal2);
    EXPECT_NEAR(0.0f, outputVal1, floatFaultTolerance);
    EXPECT_NEAR(0.0f, outputVal2, floatFaultTolerance);
}

// Test the correctness of packHalf2x16 and unpackHalf2x16 functions.
// For floats f1 and f2, unpackHalf2x16(packHalf2x16(f1, f2)) should be same as f1 and f2.
TEST(MathUtilTest, packAndUnpackHalf2x16)
{
    static constexpr std::array<std::array<float, 2>, 8> input = {{
        {0.0f, 0.0f},
        {1.0f, 1.0f},
        {-1.0f, 1.0f},
        {-1.0f, -1.0f},
        {0.875f, 0.75f},
        {0.00392f, -0.99215f},
        {-0.000675f, 0.004954f},
        {-0.6937f, -0.02146f},
    }};
    const float floatFaultTolerance                            = 0.0005f;
    float outputVal1, outputVal2;

    for (size_t i = 0; i < 8; i++)
    {
        unpackHalf2x16(packHalf2x16(input[i][0], input[i][1]), &outputVal1, &outputVal2);
        EXPECT_NEAR(input[i][0], outputVal1, floatFaultTolerance);
        EXPECT_NEAR(input[i][1], outputVal2, floatFaultTolerance);
    }
}

// Test the correctness of packUnorm4x8 and unpackUnorm4x8 functions.
// For floats f1 to f4, unpackUnorm4x8(packUnorm4x8(f1, f2, f3, f4)) should be same as f1 to f4.
TEST(MathUtilTest, packAndUnpackUnorm4x8)
{
    static constexpr std::array<std::array<float, 4>, 5> input = {{
        {0.0f, 0.0f, 0.0f, 0.0f},
        {1.0f, 1.0f, 1.0f, 1.0f},
        {-1.0f, 1.0f, -1.0f, 1.0f},
        {-1.0f, -1.0f, -1.0f, -1.0f},
        {64.0f / 255.0f, 128.0f / 255.0f, 32.0f / 255.0f, 16.0f / 255.0f},
    }};

    const float floatFaultTolerance = 0.005f;
    std::array<float, 4> outputVals;

    for (size_t i = 0; i < 5; i++)
    {
        UnpackUnorm4x8(PackUnorm4x8(input[i][0], input[i][1], input[i][2], input[i][3]),
                       outputVals);
        for (size_t j = 0; j < 4; j++)
        {
            float expected = input[i][j] < 0.0f ? 0.0f : input[i][j];
            EXPECT_NEAR(expected, outputVals[j], floatFaultTolerance);
        }
    }
}

// Test the correctness of packSnorm4x8 and unpackSnorm4x8 functions.
// For floats f1 to f4, unpackSnorm4x8(packSnorm4x8(f1, f2, f3, f4)) should be same as f1 to f4.
TEST(MathUtilTest, packAndUnpackSnorm4x8)
{
    static constexpr std::array<std::array<float, 4>, 5> input = {{
        {0.0f, 0.0f, 0.0f, 0.0f},
        {1.0f, 1.0f, 1.0f, 1.0f},
        {-1.0f, 1.0f, -1.0f, 1.0f},
        {-1.0f, -1.0f, -1.0f, -1.0f},
        {64.0f / 127.0f, -8.0f / 127.0f, 32.0f / 127.0f, 16.0f / 127.0f},
    }};

    const float floatFaultTolerance = 0.01f;
    std::array<float, 4> outputVals;

    for (size_t i = 0; i < 5; i++)
    {
        UnpackSnorm4x8(PackSnorm4x8(input[i][0], input[i][1], input[i][2], input[i][3]),
                       outputVals);
        for (size_t j = 0; j < 4; j++)
        {
            float expected = input[i][j];
            EXPECT_NEAR(expected, outputVals[j], floatFaultTolerance);
        }
    }
}

// Test the correctness of gl::isNaN function.
TEST(MathUtilTest, isNaN)
{
    EXPECT_TRUE(isNaN(bitCast<float>(0xffu << 23 | 1u)));
    EXPECT_TRUE(isNaN(bitCast<float>(1u << 31 | 0xffu << 23 | 1u)));
    EXPECT_TRUE(isNaN(bitCast<float>(1u << 31 | 0xffu << 23 | 0x400000u)));
    EXPECT_TRUE(isNaN(bitCast<float>(1u << 31 | 0xffu << 23 | 0x7fffffu)));
    EXPECT_FALSE(isNaN(0.0f));
    EXPECT_FALSE(isNaN(bitCast<float>(1u << 31 | 0xffu << 23)));
    EXPECT_FALSE(isNaN(bitCast<float>(0xffu << 23)));
}

// Test the correctness of gl::isInf function.
TEST(MathUtilTest, isInf)
{
    EXPECT_TRUE(isInf(bitCast<float>(0xffu << 23)));
    EXPECT_TRUE(isInf(bitCast<float>(1u << 31 | 0xffu << 23)));
    EXPECT_FALSE(isInf(0.0f));
    EXPECT_FALSE(isInf(bitCast<float>(0xffu << 23 | 1u)));
    EXPECT_FALSE(isInf(bitCast<float>(1u << 31 | 0xffu << 23 | 1u)));
    EXPECT_FALSE(isInf(bitCast<float>(1u << 31 | 0xffu << 23 | 0x400000u)));
    EXPECT_FALSE(isInf(bitCast<float>(1u << 31 | 0xffu << 23 | 0x7fffffu)));
    EXPECT_FALSE(isInf(bitCast<float>(0xfeu << 23 | 0x7fffffu)));
    EXPECT_FALSE(isInf(bitCast<float>(1u << 31 | 0xfeu << 23 | 0x7fffffu)));
}

// Test the correctness of gl::isOutsideOfBounds function.
TEST(MathUtilTest, isOutsideOfBounds)
{
    EXPECT_TRUE(isOutsideOfBounds(0.5f, 1.0f, 16.0f));
    EXPECT_TRUE(isOutsideOfBounds(17.0f, 1.0f, 16.0f));
    EXPECT_FALSE(isOutsideOfBounds(1.0f, 1.0f, 16.0f));
    EXPECT_FALSE(isOutsideOfBounds(16.0f, 1.0f, 16.0f));
    EXPECT_FALSE(isOutsideOfBounds(8.0f, 1.0f, 16.0f));

    EXPECT_TRUE(isOutsideOfBounds(std::numeric_limits<float>::quiet_NaN(), 1.0f, 16.0f));
    EXPECT_TRUE(isOutsideOfBounds(std::numeric_limits<float>::signaling_NaN(), 1.0f, 16.0f));

    EXPECT_TRUE(isOutsideOfBounds(0, 1, 10));
    EXPECT_TRUE(isOutsideOfBounds(11, 1, 10));
    EXPECT_FALSE(isOutsideOfBounds(1, 1, 10));
    EXPECT_FALSE(isOutsideOfBounds(10, 1, 10));
    EXPECT_FALSE(isOutsideOfBounds(5, 1, 10));
}

TEST(MathUtilTest, CountLeadingZeros)
{
    for (unsigned int i = 0; i < 32u; ++i)
    {
        uint32_t iLeadingZeros = 1u << (31u - i);
        EXPECT_EQ(i, CountLeadingZeros(iLeadingZeros));
    }
    EXPECT_EQ(32u, CountLeadingZeros(0));
}

// Some basic tests. Pow2 roundUp test and test that rounding up zero produces zero.
TEST(MathUtilTest, Pow2RoundUp)
{
    EXPECT_EQ(0u, rx::roundUpPow2(0u, 4u));
    EXPECT_EQ(4u, rx::roundUpPow2(1u, 4u));
    EXPECT_EQ(4u, rx::roundUpPow2(4u, 4u));
}

// Non-pow2 test.
TEST(MathUtilTest, BasicRoundUp)
{
    EXPECT_EQ(0u, rx::roundUp(0u, 5u));
    EXPECT_EQ(5u, rx::roundUp(1u, 5u));
    EXPECT_EQ(5u, rx::roundUp(4u, 5u));
    EXPECT_EQ(5u, rx::roundUp(5u, 5u));
}

// Test that rounding up zero produces zero for checked ints.
TEST(MathUtilTest, CheckedRoundUpZero)
{
    auto checkedValue = rx::CheckedRoundUp(0u, 4u);
    ASSERT_TRUE(checkedValue.IsValid());
    ASSERT_EQ(0u, checkedValue.ValueOrDie());
}

// Test out-of-bounds with CheckedRoundUp
TEST(MathUtilTest, CheckedRoundUpInvalid)
{
    // The answer to this query is out of bounds.
    auto limit        = std::numeric_limits<unsigned int>::max();
    auto checkedValue = rx::CheckedRoundUp(limit, limit - 1);
    ASSERT_FALSE(checkedValue.IsValid());

    // Our implementation can't handle this query, despite the parameters being in range.
    auto checkedLimit = rx::CheckedRoundUp(limit - 1, limit);
    ASSERT_FALSE(checkedLimit.IsValid());
}

// Test basic correctness of rx::CheckedRoundUpPow2
TEST(MathUtilTest, CheckedRoundUpPow2)
{
    auto checkedValue = rx::CheckedRoundUpPow2(1u, 4u);
    ASSERT_TRUE(checkedValue.IsValid());
    EXPECT_EQ(4u, checkedValue.ValueOrDie());

    checkedValue = rx::CheckedRoundUpPow2(4u, 4u);
    ASSERT_TRUE(checkedValue.IsValid());
    EXPECT_EQ(4u, checkedValue.ValueOrDie());
}

// Test that rounding up zero produces zero for rx::CheckedRoundUpPow2.
TEST(MathUtilTest, CheckedRoundUpPow2Zero)
{
    auto checkedValue = rx::CheckedRoundUpPow2(0u, 4u);
    ASSERT_TRUE(checkedValue.IsValid());
    EXPECT_EQ(0u, checkedValue.ValueOrDie());
}

// Test out-of-bounds with rx::CheckedRoundUpPow2
TEST(MathUtilTest, CheckedRoundUpPow2Invalid)
{
    auto limit        = std::numeric_limits<unsigned int>::max();
    auto checkedValue = rx::CheckedRoundUpPow2(limit, 4u);
    ASSERT_FALSE(checkedValue.IsValid());
}

// Test BitfieldReverse which reverses the order of the bits in an integer.
TEST(MathUtilTest, BitfieldReverse)
{
    EXPECT_EQ(0u, gl::BitfieldReverse(0u));
    EXPECT_EQ(0x80000000u, gl::BitfieldReverse(1u));
    EXPECT_EQ(0x1u, gl::BitfieldReverse(0x80000000u));
    uint32_t bits     = (1u << 4u) | (1u << 7u);
    uint32_t reversed = (1u << (31u - 4u)) | (1u << (31u - 7u));
    EXPECT_EQ(reversed, gl::BitfieldReverse(bits));
}

// Test BitCount, which counts 1 bits in an integer.
TEST(MathUtilTest, BitCount)
{
    EXPECT_EQ(0, gl::BitCount(0u));
    EXPECT_EQ(32, gl::BitCount(0xFFFFFFFFu));
    EXPECT_EQ(10, gl::BitCount(0x17103121u));

    EXPECT_EQ(0, gl::BitCount(static_cast<uint64_t>(0ull)));
    EXPECT_EQ(32, gl::BitCount(static_cast<uint64_t>(0xFFFFFFFFull)));
    EXPECT_EQ(10, gl::BitCount(static_cast<uint64_t>(0x17103121ull)));

    EXPECT_EQ(33, gl::BitCount(static_cast<uint64_t>(0xFFFFFFFF80000000ull)));
    EXPECT_EQ(11, gl::BitCount(static_cast<uint64_t>(0x1710312180000000ull)));
}

// Test ScanForward, which scans for the least significant 1 bit from a non-zero integer.
TEST(MathUtilTest, ScanForward)
{
    EXPECT_EQ(0ul, gl::ScanForward(1u));
    EXPECT_EQ(16ul, gl::ScanForward(0x80010000u));
    EXPECT_EQ(31ul, gl::ScanForward(0x80000000u));

    EXPECT_EQ(0ul, gl::ScanForward(static_cast<uint64_t>(1ull)));
    EXPECT_EQ(16ul, gl::ScanForward(static_cast<uint64_t>(0x80010000ull)));
    EXPECT_EQ(31ul, gl::ScanForward(static_cast<uint64_t>(0x80000000ull)));

    EXPECT_EQ(32ul, gl::ScanForward(static_cast<uint64_t>(0x100000000ull)));
    EXPECT_EQ(48ul, gl::ScanForward(static_cast<uint64_t>(0x8001000000000000ull)));
    EXPECT_EQ(63ul, gl::ScanForward(static_cast<uint64_t>(0x8000000000000000ull)));
}

// Test ScanReverse, which scans for the most significant 1 bit from a non-zero integer.
TEST(MathUtilTest, ScanReverse)
{
    EXPECT_EQ(0ul, gl::ScanReverse(1u));
    EXPECT_EQ(16ul, gl::ScanReverse(static_cast<uint64_t>(0x00010030ull)));
    EXPECT_EQ(31ul, gl::ScanReverse(static_cast<uint64_t>(0x80000000ull)));

    EXPECT_EQ(32ul, gl::ScanReverse(static_cast<uint64_t>(0x100000000ull)));
    EXPECT_EQ(48ul, gl::ScanReverse(static_cast<uint64_t>(0x0001080000000000ull)));
    EXPECT_EQ(63ul, gl::ScanReverse(static_cast<uint64_t>(0x8000000000000000ull)));
}

// Test FindLSB, which finds the least significant 1 bit.
TEST(MathUtilTest, FindLSB)
{
    EXPECT_EQ(-1, gl::FindLSB(0u));
    EXPECT_EQ(0, gl::FindLSB(1u));
    EXPECT_EQ(16, gl::FindLSB(0x80010000u));
    EXPECT_EQ(31, gl::FindLSB(0x80000000u));
}

// Test FindMSB, which finds the most significant 1 bit.
TEST(MathUtilTest, FindMSB)
{
    EXPECT_EQ(-1, gl::FindMSB(0u));
    EXPECT_EQ(0, gl::FindMSB(1u));
    EXPECT_EQ(16, gl::FindMSB(0x00010030u));
    EXPECT_EQ(31, gl::FindMSB(0x80000000u));
}

// Test Ldexp, which combines mantissa and exponent into a floating-point number.
TEST(MathUtilTest, Ldexp)
{
    EXPECT_EQ(2.5f, Ldexp(0.625f, 2));
    EXPECT_EQ(-5.0f, Ldexp(-0.625f, 3));
    EXPECT_EQ(std::numeric_limits<float>::infinity(), Ldexp(0.625f, 129));
    EXPECT_EQ(0.0f, Ldexp(1.0f, -129));
}

// Test that Range::extend works as expected.
TEST(MathUtilTest, RangeExtend)
{
    RangeI range(0, 0);

    range.extend(5);
    EXPECT_EQ(0, range.low());
    EXPECT_EQ(6, range.high());
    EXPECT_EQ(6, range.length());

    range.extend(-1);
    EXPECT_EQ(-1, range.low());
    EXPECT_EQ(6, range.high());
    EXPECT_EQ(7, range.length());

    range.extend(10);
    EXPECT_EQ(-1, range.low());
    EXPECT_EQ(11, range.high());
    EXPECT_EQ(12, range.length());
}

// Test that Range::merge works as expected.
TEST(MathUtilTest, RangMerge)
{
    // merge valid range to invalid range
    RangeI range1;
    range1.invalidate();
    RangeI range2(1, 2);
    range1.merge(range2);
    EXPECT_EQ(1, range1.low());
    EXPECT_EQ(2, range1.high());
    EXPECT_EQ(1, range1.length());

    // merge invalid range to valid range
    RangeI range3(1, 2);
    RangeI range4;
    range4.invalidate();
    range3.merge(range4);
    EXPECT_EQ(1, range3.low());
    EXPECT_EQ(2, range3.high());
    EXPECT_EQ(1, range3.length());

    // merge two valid non-overlapping ranges
    RangeI range5(1, 2);
    RangeI range6(3, 4);
    range5.merge(range6);
    EXPECT_EQ(1, range5.low());
    EXPECT_EQ(4, range5.high());
    EXPECT_EQ(3, range5.length());

    // merge two valid non-overlapping ranges
    RangeI range7(2, 3);
    RangeI range8(1, 2);
    range7.merge(range8);
    EXPECT_EQ(1, range7.low());
    EXPECT_EQ(3, range7.high());
    EXPECT_EQ(2, range7.length());

    // merge two valid overlapping ranges
    RangeI range9(2, 4);
    RangeI range10(1, 3);
    range9.merge(range10);
    EXPECT_EQ(1, range9.low());
    EXPECT_EQ(4, range9.high());
    EXPECT_EQ(3, range9.length());

    // merge two valid overlapping ranges
    RangeI range11(1, 3);
    RangeI range12(2, 4);
    range11.merge(range12);
    EXPECT_EQ(1, range11.low());
    EXPECT_EQ(4, range11.high());
    EXPECT_EQ(3, range11.length());
}

// Test that Range::intersectsOrContinuous works as expected.
TEST(MathUtilTest, RangIntersectsOrContinuous)
{
    // Two non-overlapping ranges
    RangeI range1(1, 2);
    RangeI range2(3, 4);
    EXPECT_EQ(false, range1.intersectsOrContinuous(range2));
    EXPECT_EQ(false, range2.intersectsOrContinuous(range1));

    // Two overlapping ranges
    RangeI range3(1, 3);
    RangeI range4(2, 4);
    EXPECT_EQ(true, range3.intersectsOrContinuous(range4));
    EXPECT_EQ(true, range4.intersectsOrContinuous(range3));

    // Two overlapping ranges
    RangeI range5(1, 4);
    RangeI range6(2, 3);
    EXPECT_EQ(true, range5.intersectsOrContinuous(range6));
    EXPECT_EQ(true, range6.intersectsOrContinuous(range5));

    // Two continuous ranges
    RangeI range7(1, 3);
    RangeI range8(3, 4);
    EXPECT_EQ(true, range7.intersectsOrContinuous(range8));
    EXPECT_EQ(true, range8.intersectsOrContinuous(range7));

    // Two identical ranges
    RangeI range9(1, 3);
    RangeI range10(1, 3);
    EXPECT_EQ(true, range9.intersectsOrContinuous(range10));
}

// Test that Range iteration works as expected.
TEST(MathUtilTest, RangeIteration)
{
    RangeI range(0, 10);
    int expected = 0;
    for (int value : range)
    {
        EXPECT_EQ(expected, value);
        expected++;
    }
    EXPECT_EQ(range.length(), expected);
}

// Tests for clampForBitCount
TEST(MathUtilTest, ClampForBitCount)
{
    constexpr uint64_t kUnsignedMax = std::numeric_limits<uint64_t>::max();
    constexpr int64_t kSignedMax    = std::numeric_limits<int64_t>::max();
    constexpr int64_t kSignedMin    = std::numeric_limits<int64_t>::min();
    constexpr int64_t kRandomValue  = 0x4D34A0B1;

    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 64), std::numeric_limits<uint64_t>::max());
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 32),
              static_cast<uint64_t>(std::numeric_limits<uint32_t>::max()));
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 16),
              static_cast<uint64_t>(std::numeric_limits<uint16_t>::max()));
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 8),
              static_cast<uint64_t>(std::numeric_limits<uint8_t>::max()));
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 4), 15u);
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 2), 3u);
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 1), 1u);
    ASSERT_EQ(clampForBitCount<uint64_t>(kUnsignedMax, 0), 0u);

    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 64), std::numeric_limits<int64_t>::max());
    ASSERT_EQ(clampForBitCount<uint64_t>(static_cast<uint64_t>(kSignedMax), 64),
              static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 32),
              static_cast<int64_t>(std::numeric_limits<int32_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 16),
              static_cast<int64_t>(std::numeric_limits<int16_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 8),
              static_cast<int64_t>(std::numeric_limits<int8_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 4), 7);
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 2), 1);
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMax, 0), 0);

    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 64), kRandomValue);
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 32), kRandomValue);
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 16),
              static_cast<int64_t>(std::numeric_limits<int16_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 8),
              static_cast<int64_t>(std::numeric_limits<int8_t>::max()));
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 4), 7);
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 2), 1);
    ASSERT_EQ(clampForBitCount<int64_t>(kRandomValue, 0), 0);

    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 64), std::numeric_limits<int64_t>::min());
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 32),
              static_cast<int64_t>(std::numeric_limits<int32_t>::min()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 16),
              static_cast<int64_t>(std::numeric_limits<int16_t>::min()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 8),
              static_cast<int64_t>(std::numeric_limits<int8_t>::min()));
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 4), -8);
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 2), -2);
    ASSERT_EQ(clampForBitCount<int64_t>(kSignedMin, 0), 0);
}

// Tests for float32 to float16 conversion
TEST(MathUtilTest, Float32ToFloat16)
{
    ASSERT_EQ(float32ToFloat16(0.0f), 0x0000);
    ASSERT_EQ(float32ToFloat16(-0.0f), 0x8000);

    float inf = std::numeric_limits<float>::infinity();

    ASSERT_EQ(float32ToFloat16(inf), 0x7C00);
    ASSERT_EQ(float32ToFloat16(-inf), 0xFC00);

    // Check that NaN is converted to a value in one of the float16 NaN ranges
    float nan      = std::numeric_limits<float>::quiet_NaN();
    uint16_t nan16 = float32ToFloat16(nan);
    ASSERT_TRUE(nan16 > 0xFC00 || (nan16 < 0x8000 && nan16 > 0x7C00));

    ASSERT_EQ(float32ToFloat16(1.0f), 0x3C00);
}

// Tests the RGB float to 999E5 conversion
TEST(MathUtilTest, convertRGBFloatsTo999E5)
{
    const int numTests                                                = 18;
    static constexpr std::array<std::array<float, 3>, numTests> input = {{
        // The basics
        {0.0f, 0.0f, 0.0f},
        {0.0f, 0.0f, 1.0f},
        {0.0f, 1.0f, 0.0f},
        {0.0f, 1.0f, 1.0f},
        {1.0f, 0.0f, 0.0f},
        {1.0f, 0.0f, 1.0f},
        {1.0f, 1.0f, 0.0f},
        {1.0f, 1.0f, 1.0f},
        // Extended range
        {0.0f, 0.0f, 1.5f},
        {0.0f, 2.0f, 0.0f},
        {0.0f, 2.5f, 3.0f},
        {3.5f, 0.0f, 0.0f},
        {4.0f, 0.0f, 4.5f},
        {5.0f, 5.5f, 0.0f},
        {6.0f, 6.5f, 7.0f},
        // Random
        {0.1f, 9.6f, 3.2f},
        {2.0f, 1.7f, 8.6f},
        {0.7f, 4.2f, 9.1f},
    }};
    static constexpr std::array<unsigned int, numTests> result        = {
        // The basics
        0x00000000, 0x84000000, 0x80020000, 0x84020000, 0x80000100, 0x84000100, 0x80020100,
        0x84020100,
        // Extended range
        0x86000000, 0x88020000, 0x8E028000, 0x880001C0, 0x94800100, 0x9002C140, 0x97034180,
        // Random
        0x999A6603, 0x9C4C6C40, 0x9C8D0C16};

    for (int i = 0; i < numTests; i++)
    {

        EXPECT_EQ(convertRGBFloatsTo999E5(input[i][0], input[i][1], input[i][2]), result[i]);
    }
}

// Tests the 999E5 to RGB float conversion
TEST(MathUtilTest, convert999E5toRGBFloats)
{
    const int numTests                                                 = 18;
    static constexpr std::array<std::array<float, 3>, numTests> result = {{
        // The basics
        {0.0f, 0.0f, 0.0f},
        {0.0f, 0.0f, 1.0f},
        {0.0f, 1.0f, 0.0f},
        {0.0f, 1.0f, 1.0f},
        {1.0f, 0.0f, 0.0f},
        {1.0f, 0.0f, 1.0f},
        {1.0f, 1.0f, 0.0f},
        {1.0f, 1.0f, 1.0f},
        // Extended range
        {0.0f, 0.0f, 1.5f},
        {0.0f, 2.0f, 0.0f},
        {0.0f, 2.5f, 3.0f},
        {3.5f, 0.0f, 0.0f},
        {4.0f, 0.0f, 4.5f},
        {5.0f, 5.5f, 0.0f},
        {6.0f, 6.5f, 7.0f},
        // Random
        {0.1f, 9.6f, 3.2f},
        {2.0f, 1.7f, 8.6f},
        {0.7f, 4.2f, 9.1f},
    }};
    static constexpr std::array<unsigned int, numTests> input          = {
        // The basics
        0x00000000, 0x84000000, 0x80020000, 0x84020000, 0x80000100, 0x84000100, 0x80020100,
        0x84020100,
        // Extended range
        0x86000000, 0x88020000, 0x8E028000, 0x880001C0, 0x94800100, 0x9002C140, 0x97034180,
        // Random
        0x999A6603, 0x9C4C6C40, 0x9C8D0C16};
    // Note: quite a low tolerance is required
    const float floatFaultTolerance = 0.05f;
    float outR, outG, outB;

    for (int i = 0; i < numTests; i++)
    {
        convert999E5toRGBFloats(input[i], &outR, &outG, &outB);
        EXPECT_NEAR(result[i][0], outR, floatFaultTolerance);
        EXPECT_NEAR(result[i][1], outG, floatFaultTolerance);
        EXPECT_NEAR(result[i][2], outB, floatFaultTolerance);
    }
}

// Test sRGB conversions
TEST(MathUtilTest, sRGB)
{
    // Check simple roundtrip
    for (size_t c = 0; c < 256; c++)
    {
        ASSERT_EQ(c, linearToSRGB(sRGBToLinear(c)));
    }

    // Check average of identical values
    for (size_t c = 0; c < 256; c++)
    {
        ASSERT_EQ(c, linearToSRGB((sRGBToLinear(c) + sRGBToLinear(c)) * 0.5));
    }

    // Check that all average values are in range
    for (size_t a = 0; a < 256; a++)
    {
        for (size_t b = 0; b < 256; b++)
        {
            const float avg = (sRGBToLinear(a) + sRGBToLinear(b)) * 0.5f;
            ASSERT_GE(avg, 0.0f);
            ASSERT_LE(avg, 1.0f);
        }
    }
}

// Test roundToNearest with boundary values
TEST(MathUtilTest, RoundToNearest)
{
    EXPECT_EQ((roundToNearest<float, uint8_t>(0.00000000f)), 0u);
    EXPECT_EQ((roundToNearest<float, uint8_t>(0.49999997f)), 0u);
    EXPECT_EQ((roundToNearest<float, uint8_t>(0.50000000f)), 1u);

    EXPECT_EQ((roundToNearest<float, int8_t>(-0.50000000f)), -1);
    EXPECT_EQ((roundToNearest<float, int8_t>(-0.49999997f)), 0);
    EXPECT_EQ((roundToNearest<float, int8_t>(-0.00000000f)), 0);
    EXPECT_EQ((roundToNearest<float, int8_t>(+0.00000000f)), 0);
    EXPECT_EQ((roundToNearest<float, int8_t>(+0.49999997f)), 0);
    EXPECT_EQ((roundToNearest<float, int8_t>(+0.50000000f)), +1);

    EXPECT_EQ((roundToNearest<double, uint8_t>(0.00000000000000000)), 0u);
    EXPECT_EQ((roundToNearest<double, uint8_t>(0.49999999999999994)), 0u);
    EXPECT_EQ((roundToNearest<double, uint8_t>(0.50000000000000000)), 1u);

    EXPECT_EQ((roundToNearest<double, int8_t>(-0.50000000000000000)), -1);
    EXPECT_EQ((roundToNearest<double, int8_t>(-0.49999999999999994)), 0);
    EXPECT_EQ((roundToNearest<double, int8_t>(-0.00000000000000000)), 0);
    EXPECT_EQ((roundToNearest<double, int8_t>(+0.00000000000000000)), 0);
    EXPECT_EQ((roundToNearest<double, int8_t>(+0.49999999999999994)), 0);
    EXPECT_EQ((roundToNearest<double, int8_t>(+0.50000000000000000)), +1);
}

// Test floatToNormalized conversions with uint8_t
TEST(MathUtilTest, FloatToNormalizedUnorm8)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<uint8_t>(0.00f), 0u);
    EXPECT_EQ(floatToNormalized<uint8_t>(0.25f), 64u);
    EXPECT_EQ(floatToNormalized<uint8_t>(0.75f), 191u);
    EXPECT_EQ(floatToNormalized<uint8_t>(1.00f), 255u);

    // Check near values
    EXPECT_NEAR(floatToNormalized<uint8_t>(0.50f), 127u, 1);
}

// Test floatToNormalized conversions with int8_t
TEST(MathUtilTest, FloatToNormalizedSnorm8)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<int8_t>(-1.00f), -127);
    EXPECT_EQ(floatToNormalized<int8_t>(-0.75f), -95);
    EXPECT_EQ(floatToNormalized<int8_t>(-0.25f), -32);
    EXPECT_EQ(floatToNormalized<int8_t>(+0.00f), 0);
    EXPECT_EQ(floatToNormalized<int8_t>(+0.25f), +32);
    EXPECT_EQ(floatToNormalized<int8_t>(+0.75f), +95);
    EXPECT_EQ(floatToNormalized<int8_t>(+1.00f), +127);

    // Check near values
    EXPECT_NEAR(floatToNormalized<int8_t>(-0.50f), -63, 1);
    EXPECT_NEAR(floatToNormalized<int8_t>(+0.50f), +63, 1);
}

// Test floatToNormalized conversions with uint16_t
TEST(MathUtilTest, FloatToNormalizedUnorm16)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<uint16_t>(0.00f), 0u);
    EXPECT_EQ(floatToNormalized<uint16_t>(0.25f), 16384u);
    EXPECT_EQ(floatToNormalized<uint16_t>(0.75f), 49151u);
    EXPECT_EQ(floatToNormalized<uint16_t>(1.00f), 65535u);

    // Check near values
    EXPECT_NEAR(floatToNormalized<uint16_t>(0.50f), 32767u, 1);
}

// Test floatToNormalized conversions with int16_t
TEST(MathUtilTest, FloatToNormalizedSnorm16)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<int16_t>(-1.00f), -32767);
    EXPECT_EQ(floatToNormalized<int16_t>(-0.75f), -24575);
    EXPECT_EQ(floatToNormalized<int16_t>(-0.25f), -8192);
    EXPECT_EQ(floatToNormalized<int16_t>(+0.00f), 0);
    EXPECT_EQ(floatToNormalized<int16_t>(+0.25f), +8192);
    EXPECT_EQ(floatToNormalized<int16_t>(+0.75f), +24575);
    EXPECT_EQ(floatToNormalized<int16_t>(+1.00f), +32767);

    // Check near values
    EXPECT_NEAR(floatToNormalized<int16_t>(-0.50f), -16383, 1);
    EXPECT_NEAR(floatToNormalized<int16_t>(+0.50f), +16383, 1);
}

// Test floatToNormalized conversions with uint32_t
TEST(MathUtilTest, FloatToNormalizedUnorm32)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<uint32_t>(0.00f), 0u);
    EXPECT_EQ(floatToNormalized<uint32_t>(0.25f), 1073741824u);
    EXPECT_EQ(floatToNormalized<uint32_t>(0.75f), 3221225471u);
    EXPECT_EQ(floatToNormalized<uint32_t>(1.00f), 4294967295u);

    // Check near values
    EXPECT_NEAR(floatToNormalized<uint32_t>(0.50f), 2147483647u, 1);
}

// Test floatToNormalized conversions with int32_t
TEST(MathUtilTest, FloatToNormalizedSnorm32)
{
    // Check exact values
    EXPECT_EQ(floatToNormalized<int32_t>(-1.00f), -2147483647);
    EXPECT_EQ(floatToNormalized<int32_t>(-0.75f), -1610612735);
    EXPECT_EQ(floatToNormalized<int32_t>(-0.25f), -536870912);
    EXPECT_EQ(floatToNormalized<int32_t>(+0.00f), 0);
    EXPECT_EQ(floatToNormalized<int32_t>(+0.25f), +536870912);
    EXPECT_EQ(floatToNormalized<int32_t>(+0.75f), +1610612735);
    EXPECT_EQ(floatToNormalized<int32_t>(+1.00f), +2147483647);

    // Check near values
    EXPECT_NEAR(floatToNormalized<int32_t>(-0.50f), -1073741823, 1);
    EXPECT_NEAR(floatToNormalized<int32_t>(+0.50f), +1073741823, 1);
}

// Test floatToNormalized conversions with 2-bit unsigned
TEST(MathUtilTest, FloatToNormalizedUnorm2)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<2, uint8_t>(0.00f)), 0u);
    EXPECT_EQ((floatToNormalized<2, uint8_t>(0.25f)), 1u);
    EXPECT_EQ((floatToNormalized<2, uint8_t>(0.75f)), 2u);
    EXPECT_EQ((floatToNormalized<2, uint8_t>(1.00f)), 3u);

    // Check near values
    EXPECT_NEAR((floatToNormalized<2, uint8_t>(0.50f)), 1u, 1);
}

// Test floatToNormalized conversions with 2-bit signed
TEST(MathUtilTest, FloatToNormalizedSnorm2)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<2, int8_t>(-1.00f)), -1);
    EXPECT_EQ((floatToNormalized<2, int8_t>(-0.75f)), -1);
    EXPECT_EQ((floatToNormalized<2, int8_t>(-0.25f)), 0);
    EXPECT_EQ((floatToNormalized<2, int8_t>(+0.00f)), 0);
    EXPECT_EQ((floatToNormalized<2, int8_t>(+0.25f)), 0);
    EXPECT_EQ((floatToNormalized<2, int8_t>(+0.75f)), +1);
    EXPECT_EQ((floatToNormalized<2, int8_t>(+1.00f)), +1);

    // Check near values
    EXPECT_NEAR((floatToNormalized<2, int8_t>(-0.50f)), 0, 1);
    EXPECT_NEAR((floatToNormalized<2, int8_t>(+0.50f)), 0, 1);
}

// Test floatToNormalized conversions with 10-bit unsigned
TEST(MathUtilTest, FloatToNormalizedUnorm10)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<10, uint16_t>(0.00f)), 0u);
    EXPECT_EQ((floatToNormalized<10, uint16_t>(0.25f)), 256u);
    EXPECT_EQ((floatToNormalized<10, uint16_t>(0.75f)), 767u);
    EXPECT_EQ((floatToNormalized<10, uint16_t>(1.00f)), 1023u);

    // Check near values
    EXPECT_NEAR((floatToNormalized<10, uint16_t>(0.50f)), 511u, 1);
}

// Test floatToNormalized conversions with 10-bit signed
TEST(MathUtilTest, FloatToNormalizedSnorm10)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<10, int16_t>(-1.00f)), -511);
    EXPECT_EQ((floatToNormalized<10, int16_t>(-0.75f)), -383);
    EXPECT_EQ((floatToNormalized<10, int16_t>(-0.25f)), -128);
    EXPECT_EQ((floatToNormalized<10, int16_t>(+0.00f)), 0);
    EXPECT_EQ((floatToNormalized<10, int16_t>(+0.25f)), +128);
    EXPECT_EQ((floatToNormalized<10, int16_t>(+0.75f)), +383);
    EXPECT_EQ((floatToNormalized<10, int16_t>(+1.00f)), +511);

    // Check near values
    EXPECT_NEAR((floatToNormalized<10, int16_t>(-0.50f)), -255, 1);
    EXPECT_NEAR((floatToNormalized<10, int16_t>(+0.50f)), +255, 1);
}

// Test floatToNormalized conversions with 30-bit unsigned
TEST(MathUtilTest, FloatToNormalizedUnorm30)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<30, uint32_t>(0.00f)), 0u);
    EXPECT_EQ((floatToNormalized<30, uint32_t>(0.25f)), 268435456u);
    EXPECT_EQ((floatToNormalized<30, uint32_t>(0.75f)), 805306367u);
    EXPECT_EQ((floatToNormalized<30, uint32_t>(1.00f)), 1073741823u);

    // Check near values
    EXPECT_NEAR((floatToNormalized<30, uint32_t>(0.50f)), 536870911u, 1);
}

// Test floatToNormalized conversions with 30-bit signed
TEST(MathUtilTest, FloatToNormalizedSnorm30)
{
    // Check exact values
    EXPECT_EQ((floatToNormalized<30, int32_t>(-1.00f)), -536870911);
    EXPECT_EQ((floatToNormalized<30, int32_t>(-0.75f)), -402653183);
    EXPECT_EQ((floatToNormalized<30, int32_t>(-0.25f)), -134217728);
    EXPECT_EQ((floatToNormalized<30, int32_t>(+0.00f)), 0);
    EXPECT_EQ((floatToNormalized<30, int32_t>(+0.25f)), +134217728);
    EXPECT_EQ((floatToNormalized<30, int32_t>(+0.75f)), +402653183);
    EXPECT_EQ((floatToNormalized<30, int32_t>(+1.00f)), +536870911);

    // Check near values
    EXPECT_NEAR((floatToNormalized<30, int32_t>(-0.50f)), -268435455, 1);
    EXPECT_NEAR((floatToNormalized<30, int32_t>(+0.50f)), +268435455, 1);
}

// Test normalizedToFloat conversions with 8-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm8)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<uint8_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<uint8_t>(255)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<uint8_t>(127)), 0.5f, 0.004f);
    EXPECT_NEAR((normalizedToFloat<uint8_t>(128)), 0.5f, 0.004f);
}

// Test normalizedToFloat conversions with 8-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm8)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<int8_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<int8_t>(+127)), +1.0f);
    EXPECT_EQ((normalizedToFloat<int8_t>(-127)), -1.0f);
    EXPECT_EQ((normalizedToFloat<int8_t>(-128)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<int8_t>(+64)), +0.5f, 0.008f);
    EXPECT_NEAR((normalizedToFloat<int8_t>(+63)), +0.5f, 0.008f);
    EXPECT_NEAR((normalizedToFloat<int8_t>(-63)), -0.5f, 0.008f);
    EXPECT_NEAR((normalizedToFloat<int8_t>(-64)), -0.5f, 0.008f);
}

// Test normalizedToFloat conversions with 16-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm16)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<uint16_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<uint16_t>(65535)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<uint16_t>(32767)), 0.5f, 0.00002f);
    EXPECT_NEAR((normalizedToFloat<uint16_t>(32768)), 0.5f, 0.00002f);
}

// Test normalizedToFloat conversions with 16-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm16)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<int16_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<int16_t>(+32767)), +1.0f);
    EXPECT_EQ((normalizedToFloat<int16_t>(-32767)), -1.0f);
    EXPECT_EQ((normalizedToFloat<int16_t>(-32768)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<int16_t>(+16384)), +0.5f, 0.00004f);
    EXPECT_NEAR((normalizedToFloat<int16_t>(+16383)), +0.5f, 0.00004f);
    EXPECT_NEAR((normalizedToFloat<int16_t>(-16383)), -0.5f, 0.00004f);
    EXPECT_NEAR((normalizedToFloat<int16_t>(-16384)), -0.5f, 0.00004f);
}

// Test normalizedToFloat conversions with 32-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm32)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<uint32_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<uint32_t>(4294967295)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<uint32_t>(2147483647)), 0.5, 0.0000000003);
    EXPECT_NEAR((normalizedToFloat<uint32_t>(2147483648)), 0.5, 0.0000000003);
}

// Test normalizedToFloat conversions with 32-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm32)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<int32_t>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<int32_t>(+2147483647)), +1.0);
    EXPECT_EQ((normalizedToFloat<int32_t>(-2147483647)), -1.0);
    EXPECT_EQ((normalizedToFloat<int32_t>(-2147483648)), -1.0);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<int32_t>(+1073741824)), +0.5, 0.0000000005);
    EXPECT_NEAR((normalizedToFloat<int32_t>(+1073741823)), +0.5, 0.0000000005);
    EXPECT_NEAR((normalizedToFloat<int32_t>(-1073741823)), -0.5, 0.0000000005);
    EXPECT_NEAR((normalizedToFloat<int32_t>(-1073741824)), -0.5, 0.0000000005);
}

// Test normalizedToFloat conversions with 1-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm1)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<1>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<1>(1u)), 1.0f);
}

// Test normalizedToFloat conversions with 2-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm2)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<2>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<2>(1u)), 0.33333333f);
    EXPECT_EQ((normalizedToFloat<2>(2u)), 0.66666667f);
    EXPECT_EQ((normalizedToFloat<2>(3u)), 1.0f);
}

// Test normalizedToFloat conversions with 2-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm2)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<2>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<2>(+1)), +1.0f);
    EXPECT_EQ((normalizedToFloat<2>(-1)), -1.0f);
    EXPECT_EQ((normalizedToFloat<2>(-2)), -1.0f);
}

// Test normalizedToFloat conversions with 4-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm4)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<4>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<4>(15u)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<4>(7u)), 0.5f, 0.07);
    EXPECT_NEAR((normalizedToFloat<4>(8u)), 0.5f, 0.07);
}

// Test normalizedToFloat conversions with 5-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm5)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<5>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<5>(31u)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<5>(15u)), 0.5f, 0.04);
    EXPECT_NEAR((normalizedToFloat<5>(16u)), 0.5f, 0.04);
}

// Test normalizedToFloat conversions with 6-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm6)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<6>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<6>(63u)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<6>(31u)), 0.5f, 0.02);
    EXPECT_NEAR((normalizedToFloat<6>(32u)), 0.5f, 0.02);
}

// Test normalizedToFloat conversions with 10-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm10)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<10>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<10>(1023u)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<10>(511u)), 0.5f, 0.001);
    EXPECT_NEAR((normalizedToFloat<10>(512u)), 0.5f, 0.001);
}

// Test normalizedToFloat conversions with 10-bit unsigned
TEST(MathUtilTest, NormalizedToFloatSnorm10)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<10>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<10>(+511)), +1.0f);
    EXPECT_EQ((normalizedToFloat<10>(-511)), -1.0f);
    EXPECT_EQ((normalizedToFloat<10>(-512)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<10>(+256)), +0.5f, 0.002);
    EXPECT_NEAR((normalizedToFloat<10>(+255)), +0.5f, 0.002);
    EXPECT_NEAR((normalizedToFloat<10>(-255)), -0.5f, 0.002);
    EXPECT_NEAR((normalizedToFloat<10>(-256)), -0.5f, 0.002);
}

// Test normalizedToFloat conversions with 24-bit unsigned
TEST(MathUtilTest, NormalizedToFloatUnorm24)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<24>(0u)), 0.0f);
    EXPECT_EQ((normalizedToFloat<24>(16777215u)), 1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<24>(8388607u)), 0.5f, 0.00000006);
    EXPECT_NEAR((normalizedToFloat<24>(8388608u)), 0.5f, 0.00000006);
}

// Test normalizedToFloat conversions with 24-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm24)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<24>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<24>(+8388607)), +1.0f);
    EXPECT_EQ((normalizedToFloat<24>(-8388607)), -1.0f);
    EXPECT_EQ((normalizedToFloat<24>(-8388608)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<24>(+4194304)), +0.5f, 0.00000012);
    EXPECT_NEAR((normalizedToFloat<24>(+4194303)), +0.5f, 0.00000012);
    EXPECT_NEAR((normalizedToFloat<24>(-4194303)), -0.5f, 0.00000012);
    EXPECT_NEAR((normalizedToFloat<24>(-4194304)), -0.5f, 0.00000012);
}

// Test normalizedToFloat conversions with 25-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm25)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<25>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<25>(+16777215)), +1.0f);
    EXPECT_EQ((normalizedToFloat<25>(-16777215)), -1.0f);
    EXPECT_EQ((normalizedToFloat<25>(-16777216)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<25>(+8388608)), +0.5f, 0.00000006);
    EXPECT_NEAR((normalizedToFloat<25>(+8388607)), +0.5f, 0.00000006);
    EXPECT_NEAR((normalizedToFloat<25>(-8388607)), -0.5f, 0.00000006);
    EXPECT_NEAR((normalizedToFloat<25>(-8388608)), -0.5f, 0.00000006);
}

// Test normalizedToFloat conversions with 26-bit signed
TEST(MathUtilTest, NormalizedToFloatSnorm26)
{
    // Check exact values
    EXPECT_EQ((normalizedToFloat<26>(0)), 0.0f);
    EXPECT_EQ((normalizedToFloat<26>(+33554431)), +1.0f);
    EXPECT_EQ((normalizedToFloat<26>(-33554431)), -1.0f);
    EXPECT_EQ((normalizedToFloat<26>(-33554432)), -1.0f);

    // Check near values
    EXPECT_NEAR((normalizedToFloat<26>(+16777216)), +0.5f, 0.00000003);
    EXPECT_NEAR((normalizedToFloat<26>(+16777215)), +0.5f, 0.00000003);
    EXPECT_NEAR((normalizedToFloat<26>(-16777215)), -0.5f, 0.00000003);
    EXPECT_NEAR((normalizedToFloat<26>(-16777216)), -0.5f, 0.00000003);
}

// Test UnsignedCeilDivide
TEST(MathUtilTest, UnsignedCeilDivide)
{
    EXPECT_EQ(0u, rx::UnsignedCeilDivide(0u, 5u));
    EXPECT_EQ(1u, rx::UnsignedCeilDivide(1u, 5u));
    EXPECT_EQ(1u, rx::UnsignedCeilDivide(4u, 5u));
    EXPECT_EQ(1u, rx::UnsignedCeilDivide(5u, 5u));
    EXPECT_EQ(2u, rx::UnsignedCeilDivide(6u, 5u));
}

// Test UnsignedCeilDivide64
TEST(MathUtilTest, UnsignedCeilDivide64)
{
    EXPECT_EQ(0ull, rx::UnsignedCeilDivide64(0ull, 5ull));
    EXPECT_EQ(1ull, rx::UnsignedCeilDivide64(1ull, 5ull));
    EXPECT_EQ(1ull, rx::UnsignedCeilDivide64(4ull, 5ull));
    EXPECT_EQ(1ull, rx::UnsignedCeilDivide64(5ull, 5ull));
    EXPECT_EQ(2ull, rx::UnsignedCeilDivide64(6ull, 5ull));

    uint64_t largeValue = 0xFFFFFFFF00000000ull;
    EXPECT_EQ(0xFFFFFFFFull, rx::UnsignedCeilDivide64(largeValue, 0x100000000ull));
    EXPECT_EQ(0x100000000ull, rx::UnsignedCeilDivide64(largeValue + 1, 0x100000000ull));
}

}  // anonymous namespace