| // Copyright 2022 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <cmath> |
| #include <cstdint> |
| #include <tuple> |
| #include <variant> |
| #include <vector> |
| |
| #include "src/tint/lang/wgsl/program/program_builder.h" |
| #include "src/tint/utils/macros/compiler.h" |
| #include "src/tint/utils/text/string_stream.h" |
| |
| #include "gtest/gtest.h" |
| |
| using namespace tint::core::number_suffixes; // NOLINT |
| |
| namespace tint::core { |
| namespace { |
| |
| // Concats any number of std::vectors |
| template <typename Vec, typename... Vecs> |
| [[nodiscard]] inline auto Concat(Vec&& v1, Vecs&&... vs) { |
| auto total_size = v1.size() + (vs.size() + ...); |
| v1.reserve(total_size); |
| (std::move(vs.begin(), vs.end(), std::back_inserter(v1)), ...); |
| return std::move(v1); |
| } |
| |
| // Next ULP up from kHighestF32 for a float64. |
| constexpr double kHighestF32NextULP = 0x1.fffffe0000001p+127; |
| |
| // Highest subnormal value for a float32. |
| constexpr double kHighestF32Subnormal = 0x0.fffffep-126; |
| |
| // Next ULP up from kHighestF16 for a float64. |
| constexpr double kHighestF16NextULP = 0x1.ffc0000000001p+15; |
| |
| // Highest subnormal value for a float16. |
| constexpr double kHighestF16Subnormal = 0x0.ffcp-14; |
| |
| constexpr double kLowestF32NextULP = -kHighestF32NextULP; |
| constexpr double kLowestF16NextULP = -kHighestF16NextULP; |
| |
| // MSVC (only in release builds) can grumble about some of the inlined numerical overflow / |
| // underflow that's done in this file. We like to think we know what we're doing, so silence the |
| // warning. |
| TINT_BEGIN_DISABLE_WARNING(CONSTANT_OVERFLOW); |
| |
| TEST(NumberTest, Equality) { |
| EXPECT_TRUE(0_a == 0_a); |
| EXPECT_TRUE(10_a == 10_a); |
| EXPECT_TRUE(-10_a == -10_a); |
| |
| EXPECT_TRUE(0_i == 0_i); |
| EXPECT_TRUE(10_i == 10_i); |
| EXPECT_TRUE(-10_i == -10_i); |
| |
| EXPECT_TRUE(0_u == 0_u); |
| EXPECT_TRUE(10_u == 10_u); |
| |
| EXPECT_TRUE(0._a == 0._a); |
| EXPECT_TRUE(0._a == -0._a); |
| EXPECT_TRUE(-0._a == 0._a); |
| EXPECT_TRUE(-0._a == -0._a); |
| EXPECT_TRUE(10._a == 10._a); |
| EXPECT_TRUE(-10._a == -10._a); |
| |
| EXPECT_TRUE(0_f == 0_f); |
| EXPECT_TRUE(0._f == -0._f); |
| EXPECT_TRUE(-0._f == 0._f); |
| EXPECT_TRUE(-0_f == -0_f); |
| EXPECT_TRUE(10_f == 10_f); |
| EXPECT_TRUE(-10_f == -10_f); |
| |
| EXPECT_TRUE(0_h == 0_h); |
| EXPECT_TRUE(0._h == -0._h); |
| EXPECT_TRUE(-0._h == 0._h); |
| EXPECT_TRUE(-0_h == -0_h); |
| EXPECT_TRUE(10_h == 10_h); |
| EXPECT_TRUE(-10_h == -10_h); |
| } |
| |
| TEST(NumberTest, Inequality) { |
| EXPECT_TRUE(0_a != 1_a); |
| EXPECT_TRUE(10_a != 11_a); |
| EXPECT_TRUE(11_a != 10_a); |
| EXPECT_TRUE(-10_a != -11_a); |
| EXPECT_TRUE(-11_a != -10_a); |
| |
| EXPECT_TRUE(0_i != 1_i); |
| EXPECT_TRUE(1_i != 0_i); |
| EXPECT_TRUE(10_i != 11_i); |
| EXPECT_TRUE(11_i != 10_i); |
| EXPECT_TRUE(-10_i != -11_i); |
| EXPECT_TRUE(-11_i != -10_i); |
| |
| EXPECT_TRUE(0_u != 1_u); |
| EXPECT_TRUE(1_u != 0_u); |
| EXPECT_TRUE(10_u != 11_u); |
| EXPECT_TRUE(11_u != 10_u); |
| |
| EXPECT_FALSE(0._a != -0._a); |
| EXPECT_FALSE(-0._a != 0._a); |
| EXPECT_TRUE(10._a != 11._a); |
| EXPECT_TRUE(11._a != 10._a); |
| EXPECT_TRUE(-10._a != -11._a); |
| EXPECT_TRUE(-11._a != -10._a); |
| |
| EXPECT_FALSE(0_f != -0_f); |
| EXPECT_FALSE(-0_f != 0_f); |
| EXPECT_TRUE(-0_f != -1_f); |
| EXPECT_TRUE(-1_f != -0_f); |
| EXPECT_TRUE(10_f != -10_f); |
| EXPECT_TRUE(-10_f != 10_f); |
| EXPECT_TRUE(10_f != 11_f); |
| EXPECT_TRUE(-10_f != -11_f); |
| |
| EXPECT_FALSE(0_h != -0_h); |
| EXPECT_FALSE(-0_h != 0_h); |
| EXPECT_TRUE(-0_h != -1_h); |
| EXPECT_TRUE(-1_h != -0_h); |
| EXPECT_TRUE(10_h != -10_h); |
| EXPECT_TRUE(-10_h != 10_h); |
| EXPECT_TRUE(10_h != 11_h); |
| EXPECT_TRUE(-10_h != -11_h); |
| } |
| |
| TEST(NumberTest, CheckedConvertIdentity) { |
| EXPECT_EQ(CheckedConvert<AInt>(0_a), 0_a); |
| EXPECT_EQ(CheckedConvert<AFloat>(0_a), 0.0_a); |
| EXPECT_EQ(CheckedConvert<i32>(0_i), 0_i); |
| EXPECT_EQ(CheckedConvert<i8>(i8(0)), i8(0)); |
| EXPECT_EQ(CheckedConvert<u32>(0_u), 0_u); |
| EXPECT_EQ(CheckedConvert<u8>(u8(0)), u8(0)); |
| EXPECT_EQ(CheckedConvert<f32>(0_f), 0_f); |
| EXPECT_EQ(CheckedConvert<f16>(0_h), 0_h); |
| |
| EXPECT_EQ(CheckedConvert<AInt>(1_a), 1_a); |
| EXPECT_EQ(CheckedConvert<AFloat>(1_a), 1.0_a); |
| EXPECT_EQ(CheckedConvert<i32>(1_i), 1_i); |
| EXPECT_EQ(CheckedConvert<i8>(i8(1)), i8(1)); |
| EXPECT_EQ(CheckedConvert<u32>(1_u), 1_u); |
| EXPECT_EQ(CheckedConvert<u8>(u8(1)), u8(1)); |
| EXPECT_EQ(CheckedConvert<f32>(1_f), 1_f); |
| EXPECT_EQ(CheckedConvert<f16>(1_h), 1_h); |
| } |
| |
| TEST(NumberTest, CheckedConvertLargestValue) { |
| EXPECT_EQ(CheckedConvert<i32>(AInt(i32::Highest())), i32::Highest()); |
| EXPECT_EQ(CheckedConvert<i8>(AInt(i8::Highest())), i8::Highest()); |
| EXPECT_EQ(CheckedConvert<u32>(AInt(u32::Highest())), u32::Highest()); |
| EXPECT_EQ(CheckedConvert<u32>(i32::Highest()), u32(i32::Highest())); |
| EXPECT_EQ(CheckedConvert<u8>(AInt(u8::Highest())), u8::Highest()); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(f32::Highest())), f32::Highest()); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(f16::Highest())), f16::Highest()); |
| } |
| |
| TEST(NumberTest, CheckedConvertLowestValue) { |
| EXPECT_EQ(CheckedConvert<i32>(AInt(i32::Lowest())), i32::Lowest()); |
| EXPECT_EQ(CheckedConvert<i8>(AInt(i8::Lowest())), i8::Lowest()); |
| EXPECT_EQ(CheckedConvert<u32>(AInt(u32::Lowest())), u32::Lowest()); |
| EXPECT_EQ(CheckedConvert<u8>(AInt(u8::Lowest())), u8::Lowest()); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(f32::Lowest())), f32::Lowest()); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(f16::Lowest())), f16::Lowest()); |
| } |
| |
| TEST(NumberTest, CheckedConvertSmallestValue) { |
| EXPECT_EQ(CheckedConvert<i32>(AInt(0)), i32(0)); |
| EXPECT_EQ(CheckedConvert<i8>(AInt(0)), i8(0)); |
| EXPECT_EQ(CheckedConvert<u32>(AInt(0)), u32(0)); |
| EXPECT_EQ(CheckedConvert<u8>(AInt(0)), u8(0)); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(f32::Smallest())), f32::Smallest()); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(f16::Smallest())), f16::Smallest()); |
| } |
| |
| TEST(NumberTest, CheckedConvertExceedsPositiveLimit) { |
| EXPECT_EQ(CheckedConvert<i32>(AInt(static_cast<int64_t>(i32::Highest()) + 1)), |
| ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<i8>(AInt(static_cast<int64_t>(i8::Highest()) + 1)), |
| ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<u32>(AInt(static_cast<uint64_t>(u32::Highest()) + 1)), |
| ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<u8>(AInt(static_cast<uint64_t>(u8::Highest()) + 1)), |
| ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<i32>(u32::Highest()), ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<i32>(u32(0x80000000)), ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<i8>(u8::Highest()), ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<i8>(u8(0x80)), ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<u32>(f32::Highest()), u32::Highest()); |
| EXPECT_EQ(CheckedConvert<u8>(f32::Highest()), u8::Highest()); |
| EXPECT_EQ(CheckedConvert<i32>(f32::Highest()), i32::Highest()); |
| EXPECT_EQ(CheckedConvert<i8>(f32::Highest()), i8::Highest()); |
| EXPECT_EQ(CheckedConvert<u32>(AFloat::Highest()), u32::Highest()); |
| EXPECT_EQ(CheckedConvert<u8>(AFloat::Highest()), u8::Highest()); |
| EXPECT_EQ(CheckedConvert<i32>(AFloat::Highest()), i32::Highest()); |
| EXPECT_EQ(CheckedConvert<i8>(AFloat::Highest()), i8::Highest()); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(kHighestF32NextULP)), |
| ConversionFailure::kExceedsPositiveLimit); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(kHighestF16NextULP)), |
| ConversionFailure::kExceedsPositiveLimit); |
| } |
| |
| TEST(NumberTest, CheckedConvertExceedsNegativeLimit) { |
| EXPECT_EQ(CheckedConvert<i32>(AInt(static_cast<int64_t>(i32::Lowest()) - 1)), |
| ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<i8>(AInt(static_cast<int64_t>(i8::Lowest()) - 1)), |
| ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u32>(AInt(static_cast<uint64_t>(u32::Lowest()) - 1)), |
| ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u8>(AInt(static_cast<uint64_t>(u8::Lowest()) - 1)), |
| ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u32>(i32(-1)), ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u32>(i32::Lowest()), ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u32>(f32::Lowest()), u32::Lowest()); |
| EXPECT_EQ(CheckedConvert<u8>(i8(-1)), ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u8>(i8::Lowest()), ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<u8>(f32::Lowest()), u8::Lowest()); |
| EXPECT_EQ(CheckedConvert<i32>(f32::Lowest()), i32::Lowest()); |
| EXPECT_EQ(CheckedConvert<i8>(f32::Lowest()), i8::Lowest()); |
| EXPECT_EQ(CheckedConvert<u32>(AFloat::Lowest()), u32::Lowest()); |
| EXPECT_EQ(CheckedConvert<u8>(AFloat::Lowest()), u8::Lowest()); |
| EXPECT_EQ(CheckedConvert<i32>(AFloat::Lowest()), i32::Lowest()); |
| EXPECT_EQ(CheckedConvert<i8>(AFloat::Lowest()), i8::Lowest()); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(kLowestF32NextULP)), |
| ConversionFailure::kExceedsNegativeLimit); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(kLowestF16NextULP)), |
| ConversionFailure::kExceedsNegativeLimit); |
| } |
| |
| TEST(NumberTest, CheckedConvertSubnormals) { |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(kHighestF32Subnormal)), f32(kHighestF32Subnormal)); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(kHighestF16Subnormal)), f16(kHighestF16Subnormal)); |
| EXPECT_EQ(CheckedConvert<f32>(AFloat(-kHighestF32Subnormal)), f32(-kHighestF32Subnormal)); |
| EXPECT_EQ(CheckedConvert<f16>(AFloat(-kHighestF16Subnormal)), f16(-kHighestF16Subnormal)); |
| } |
| |
| // Test cases for f16 subnormal quantization and BitsRepresentation. |
| // The ULP is based on float rather than double or f16, since F16::Quantize and |
| // F16::BitsRepresentation take float as input. |
| constexpr float lowestPositiveNormalF16 = 0x1p-14; |
| constexpr float lowestPositiveNormalF16PlusULP = 0x1.000002p-14; |
| constexpr float lowestPositiveNormalF16MinusULP = 0x1.fffffep-15; |
| constexpr float highestPositiveSubnormalF16 = 0x0.ffcp-14; |
| constexpr float highestPositiveSubnormalF16PlusULP = 0x1.ff8002p-15; |
| constexpr float highestPositiveSubnormalF16MinusULP = 0x1.ff7ffep-15; |
| constexpr float lowestPositiveSubnormalF16 = 0x1.p-24; |
| constexpr float lowestPositiveSubnormalF16PlusULP = 0x1.000002p-24; |
| constexpr float lowestPositiveSubnormalF16MinusULP = 0x1.fffffep-25; |
| |
| constexpr uint16_t lowestPositiveNormalF16Bits = 0x0400u; |
| constexpr uint16_t highestPositiveSubnormalF16Bits = 0x03ffu; |
| constexpr uint16_t lowestPositiveSubnormalF16Bits = 0x0001u; |
| |
| constexpr float highestNegativeNormalF16 = -lowestPositiveNormalF16; |
| constexpr float highestNegativeNormalF16PlusULP = -lowestPositiveNormalF16MinusULP; |
| constexpr float highestNegativeNormalF16MinusULP = -lowestPositiveNormalF16PlusULP; |
| constexpr float lowestNegativeSubnormalF16 = -highestPositiveSubnormalF16; |
| constexpr float lowestNegativeSubnormalF16PlusULP = -highestPositiveSubnormalF16MinusULP; |
| constexpr float lowestNegativeSubnormalF16MinusULP = -highestPositiveSubnormalF16PlusULP; |
| constexpr float highestNegativeSubnormalF16 = -lowestPositiveSubnormalF16; |
| constexpr float highestNegativeSubnormalF16PlusULP = -lowestPositiveSubnormalF16MinusULP; |
| constexpr float highestNegativeSubnormalF16MinusULP = -lowestPositiveSubnormalF16PlusULP; |
| |
| constexpr uint16_t highestNegativeNormalF16Bits = 0x8400u; |
| constexpr uint16_t lowestNegativeSubnormalF16Bits = 0x83ffu; |
| constexpr uint16_t highestNegativeSubnormalF16Bits = 0x8001u; |
| |
| constexpr float f32_nan = std::numeric_limits<float>::quiet_NaN(); |
| constexpr float f32_inf = std::numeric_limits<float>::infinity(); |
| |
| struct F16TestCase { |
| float input_value; |
| float quantized_value; |
| uint16_t f16_bit_pattern; |
| }; |
| |
| using NumberF16Test = testing::TestWithParam<F16TestCase>; |
| |
| TEST_P(NumberF16Test, QuantizeF16) { |
| float input_value = GetParam().input_value; |
| float quantized_value = GetParam().quantized_value; |
| |
| StringStream ss; |
| ss << "input value = " << input_value << ", expected quantized value = " << quantized_value; |
| SCOPED_TRACE(ss.str()); |
| |
| if (std::isnan(quantized_value)) { |
| EXPECT_TRUE(std::isnan(f16(input_value))); |
| } else { |
| EXPECT_EQ(f16(input_value), quantized_value); |
| } |
| } |
| |
| TEST_P(NumberF16Test, BitsRepresentation) { |
| float input_value = GetParam().input_value; |
| uint16_t representation = GetParam().f16_bit_pattern; |
| |
| StringStream ss; |
| ss << "input value = " << input_value |
| << ", expected binary16 bits representation = " << std::hex << std::showbase |
| << representation; |
| SCOPED_TRACE(ss.str()); |
| |
| EXPECT_EQ(f16(input_value).BitsRepresentation(), representation); |
| } |
| |
| TEST_P(NumberF16Test, FromBits) { |
| float input_value = GetParam().quantized_value; |
| uint16_t representation = GetParam().f16_bit_pattern; |
| |
| StringStream ss; |
| ss << "binary16 bits representation = " << std::hex << std::showbase << representation |
| << " expected value = " << input_value; |
| SCOPED_TRACE(ss.str()); |
| |
| if (std::isnan(input_value)) { |
| EXPECT_TRUE(std::isnan(f16::FromBits(representation))); |
| } else { |
| EXPECT_EQ(f16::FromBits(representation), f16(input_value)); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| NumberF16Test, |
| NumberF16Test, |
| testing::ValuesIn(std::vector<F16TestCase>{ |
| // NaN, Inf |
| {f32_inf, f32_inf, 0x7c00u}, |
| {-f32_inf, -f32_inf, 0xfc00u}, |
| {f32_nan, f32_nan, 0x7e00u}, |
| {-f32_nan, -f32_nan, 0x7e00u}, |
| // +/- zero |
| {+0.0f, 0.0f, 0x0000u}, |
| {-0.0f, -0.0f, 0x8000u}, |
| // Value in normal f16 range |
| {1.0f, 1.0f, 0x3c00u}, |
| {-1.0f, -1.0f, 0xbc00u}, |
| // 0.00006106496 quantized to 0.000061035156 = 0x1p-14 |
| {0.00006106496f, 0.000061035156f, 0x0400u}, |
| {-0.00006106496f, -0.000061035156f, 0x8400u}, |
| // 1.0004883 quantized to 1.0 = 0x1p0 |
| {1.0004883f, 1.0f, 0x3c00u}, |
| {-1.0004883f, -1.0f, 0xbc00u}, |
| // 8196.0 quantized to 8192.0 = 0x1p13 |
| {8196.0f, 8192.f, 0x7000u}, |
| {-8196.0f, -8192.f, 0xf000u}, |
| // Value in subnormal f16 range |
| {0x0.034p-14f, 0x0.034p-14f, 0x000du}, |
| {-0x0.034p-14f, -0x0.034p-14f, 0x800du}, |
| {0x0.068p-14f, 0x0.068p-14f, 0x001au}, |
| {-0x0.068p-14f, -0x0.068p-14f, 0x801au}, |
| // 0x0.06b7p-14 quantized to 0x0.068p-14 |
| {0x0.06b7p-14f, 0x0.068p-14f, 0x001au}, |
| {-0x0.06b7p-14f, -0x0.068p-14, 0x801au}, |
| // Value out of f16 range |
| {65504.003f, f32_inf, 0x7c00u}, |
| {-65504.003f, -f32_inf, 0xfc00u}, |
| {0x1.234p56f, f32_inf, 0x7c00u}, |
| {-0x4.321p65f, -f32_inf, 0xfc00u}, |
| |
| // Test for subnormal quantization. |
| // Value larger than or equal to lowest positive normal f16 will be quantized to normal f16. |
| {lowestPositiveNormalF16PlusULP, lowestPositiveNormalF16, lowestPositiveNormalF16Bits}, |
| {lowestPositiveNormalF16, lowestPositiveNormalF16, lowestPositiveNormalF16Bits}, |
| // Positive value smaller than lowest positive normal f16 but not smaller than lowest |
| // positive |
| // subnormal f16 will be quantized to subnormal f16 or zero. |
| {lowestPositiveNormalF16MinusULP, highestPositiveSubnormalF16, |
| highestPositiveSubnormalF16Bits}, |
| {highestPositiveSubnormalF16PlusULP, highestPositiveSubnormalF16, |
| highestPositiveSubnormalF16Bits}, |
| {highestPositiveSubnormalF16, highestPositiveSubnormalF16, highestPositiveSubnormalF16Bits}, |
| {highestPositiveSubnormalF16MinusULP, 0x0.ff8p-14, 0x03feu}, |
| {lowestPositiveSubnormalF16PlusULP, lowestPositiveSubnormalF16, |
| lowestPositiveSubnormalF16Bits}, |
| {lowestPositiveSubnormalF16, lowestPositiveSubnormalF16, lowestPositiveSubnormalF16Bits}, |
| // Positive value smaller than lowest positive subnormal f16 will be quantized to zero. |
| {lowestPositiveSubnormalF16MinusULP, 0.0, 0x0000u}, |
| // Test the mantissa discarding, the least significant mantissa bit is 0x1p-24 = |
| // 0x0.004p-14. |
| {0x0.064p-14f, 0x0.064p-14, 0x0019u}, |
| {0x0.067fecp-14f, 0x0.064p-14, 0x0019u}, |
| {0x0.063ffep-14f, 0x0.060p-14, 0x0018u}, |
| {0x0.008p-14f, 0x0.008p-14, 0x0002u}, |
| {0x0.00bffep-14f, 0x0.008p-14, 0x0002u}, |
| {0x0.007ffep-14f, 0x0.004p-14, 0x0001u}, |
| |
| // Vice versa for negative cases. |
| {highestNegativeNormalF16MinusULP, highestNegativeNormalF16, highestNegativeNormalF16Bits}, |
| {highestNegativeNormalF16, highestNegativeNormalF16, highestNegativeNormalF16Bits}, |
| {highestNegativeNormalF16PlusULP, lowestNegativeSubnormalF16, |
| lowestNegativeSubnormalF16Bits}, |
| {lowestNegativeSubnormalF16MinusULP, lowestNegativeSubnormalF16, |
| lowestNegativeSubnormalF16Bits}, |
| {lowestNegativeSubnormalF16, lowestNegativeSubnormalF16, lowestNegativeSubnormalF16Bits}, |
| {lowestNegativeSubnormalF16PlusULP, -0x0.ff8p-14, 0x83feu}, |
| {highestNegativeSubnormalF16MinusULP, highestNegativeSubnormalF16, |
| highestNegativeSubnormalF16Bits}, |
| {highestNegativeSubnormalF16, highestNegativeSubnormalF16, highestNegativeSubnormalF16Bits}, |
| {highestNegativeSubnormalF16PlusULP, -0.0, 0x8000u}, |
| // Test the mantissa discarding. |
| {-0x0.064p-14f, -0x0.064p-14, 0x8019u}, |
| {-0x0.067fecp-14f, -0x0.064p-14, 0x8019u}, |
| {-0x0.063ffep-14f, -0x0.060p-14, 0x8018u}, |
| {-0x0.008p-14f, -0x0.008p-14, 0x8002u}, |
| {-0x0.00bffep-14f, -0x0.008p-14, 0x8002u}, |
| {-0x0.007ffep-14f, -0x0.004p-14, 0x8001u}, |
| ///////////////////////////////////// |
| })); |
| |
| #ifdef OVERFLOW |
| #undef OVERFLOW // corecrt_math.h :( |
| #endif |
| #define OVERFLOW \ |
| {} |
| |
| // An error value. IEEE 754 exceptions map to this, including overflow, |
| // invalid operation, and division by zero. |
| template <typename T> |
| auto Error = std::optional<T>{}; |
| |
| using BinaryCheckedCase_AInt = std::tuple<std::optional<AInt>, AInt, AInt>; |
| using CheckedAddTest_AInt = testing::TestWithParam<BinaryCheckedCase_AInt>; |
| |
| using FloatInputTypes = std::variant<AFloat, f32, f16>; |
| using FloatExpectedTypes = |
| std::variant<std::optional<AFloat>, std::optional<f32>, std::optional<f16>>; |
| using BinaryCheckedCase_Float = std::tuple<FloatExpectedTypes, FloatInputTypes, FloatInputTypes>; |
| |
| /// Validates that result is equal to expect. If `float_comp` is true, uses EXPECT_FLOAT_EQ to |
| /// compare the values. |
| template <typename T> |
| void ValidateResult(std::optional<T> result, std::optional<T> expect, bool float_comp = false) { |
| if (!expect) { |
| EXPECT_TRUE(!result) << *result; |
| } else { |
| ASSERT_TRUE(result); |
| if constexpr (IsIntegral<T>) { |
| EXPECT_EQ(*result, *expect); |
| } else { |
| if (float_comp) { |
| EXPECT_FLOAT_EQ(*result, *expect); |
| } else { |
| EXPECT_EQ(*result, *expect); |
| } |
| } |
| } |
| } |
| |
| TEST_P(CheckedAddTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| ValidateResult(CheckedAdd(a, b), expect); |
| ValidateResult(CheckedAdd(b, a), expect); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedAddTest_AInt, |
| CheckedAddTest_AInt, |
| testing::ValuesIn(std::vector<BinaryCheckedCase_AInt>{ |
| {AInt(0), AInt(0), AInt(0)}, |
| {AInt(1), AInt(1), AInt(0)}, |
| {AInt(2), AInt(1), AInt(1)}, |
| {AInt(0), AInt(-1), AInt(1)}, |
| {AInt(3), AInt(2), AInt(1)}, |
| {AInt(-1), AInt(-2), AInt(1)}, |
| {AInt(0x300), AInt(0x100), AInt(0x200)}, |
| {AInt(0x100), AInt(-0x100), AInt(0x200)}, |
| {AInt::Highest(), AInt(1), AInt(AInt::kHighestValue - 1)}, |
| {AInt::Lowest(), AInt(-1), AInt(AInt::kLowestValue + 1)}, |
| {AInt::Highest(), AInt(0x7fffffff00000000ll), AInt(0x00000000ffffffffll)}, |
| {AInt::Highest(), AInt::Highest(), AInt(0)}, |
| {AInt::Lowest(), AInt::Lowest(), AInt(0)}, |
| {OVERFLOW, AInt(1), AInt::Highest()}, |
| {OVERFLOW, AInt(-1), AInt::Lowest()}, |
| {OVERFLOW, AInt(2), AInt::Highest()}, |
| {OVERFLOW, AInt(-2), AInt::Lowest()}, |
| {OVERFLOW, AInt(10000), AInt::Highest()}, |
| {OVERFLOW, AInt(-10000), AInt::Lowest()}, |
| {OVERFLOW, AInt::Highest(), AInt::Highest()}, |
| {OVERFLOW, AInt::Lowest(), AInt::Lowest()}, |
| //////////////////////////////////////////////////////////////////////// |
| })); |
| |
| using CheckedAddTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedAddTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| EXPECT_TRUE(CheckedAdd(lhs, rhs) == expect) |
| << std::hex << "0x" << lhs << " + 0x" << rhs; |
| EXPECT_TRUE(CheckedAdd(rhs, lhs) == expect) |
| << std::hex << "0x" << lhs << " + 0x" << rhs; |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedAddTest_FloatCases() { |
| return { |
| {T(0), T(0), T(0)}, |
| {T(1), T(1), T(0)}, |
| {T(2), T(1), T(1)}, |
| {T(0), T(-1), T(1)}, |
| {T(3), T(2), T(1)}, |
| {T(-1), T(-2), T(1)}, |
| {T(0x300), T(0x100), T(0x200)}, |
| {T(0x100), T(-0x100), T(0x200)}, |
| {T::Highest(), T::Highest(), T(0)}, |
| {T::Lowest(), T::Lowest(), T(0)}, |
| {Error<T>, T::Highest(), T::Highest()}, |
| {Error<T>, T::Lowest(), T::Lowest()}, |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedAddTest_Float, |
| CheckedAddTest_Float, |
| testing::ValuesIn(Concat(CheckedAddTest_FloatCases<AFloat>(), |
| CheckedAddTest_FloatCases<f32>(), |
| CheckedAddTest_FloatCases<f16>()))); |
| |
| using CheckedSubTest_AInt = testing::TestWithParam<BinaryCheckedCase_AInt>; |
| TEST_P(CheckedSubTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| ValidateResult(CheckedSub(a, b), expect); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedSubTest_AInt, |
| CheckedSubTest_AInt, |
| testing::ValuesIn(std::vector<BinaryCheckedCase_AInt>{ |
| {AInt(0), AInt(0), AInt(0)}, |
| {AInt(1), AInt(1), AInt(0)}, |
| {AInt(0), AInt(1), AInt(1)}, |
| {AInt(-2), AInt(-1), AInt(1)}, |
| {AInt(1), AInt(2), AInt(1)}, |
| {AInt(-3), AInt(-2), AInt(1)}, |
| {AInt(0x100), AInt(0x300), AInt(0x200)}, |
| {AInt(-0x300), AInt(-0x100), AInt(0x200)}, |
| {AInt::Highest(), AInt(AInt::kHighestValue - 1), AInt(-1)}, |
| {AInt::Lowest(), AInt(AInt::kLowestValue + 1), AInt(1)}, |
| {AInt(0x00000000ffffffffll), AInt::Highest(), AInt(0x7fffffff00000000ll)}, |
| {AInt::Highest(), AInt::Highest(), AInt(0)}, |
| {AInt::Lowest(), AInt::Lowest(), AInt(0)}, |
| {OVERFLOW, AInt::Lowest(), AInt(1)}, |
| {OVERFLOW, AInt::Highest(), AInt(-1)}, |
| {OVERFLOW, AInt::Lowest(), AInt(2)}, |
| {OVERFLOW, AInt::Highest(), AInt(-2)}, |
| {OVERFLOW, AInt::Lowest(), AInt(10000)}, |
| {OVERFLOW, AInt::Highest(), AInt(-10000)}, |
| {OVERFLOW, AInt::Lowest(), AInt::Highest()}, |
| //////////////////////////////////////////////////////////////////////// |
| })); |
| |
| using CheckedSubTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedSubTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| ValidateResult(CheckedSub(lhs, rhs), expect); |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedSubTest_FloatCases() { |
| return { |
| {T(0), T(0), T(0)}, |
| {T(1), T(1), T(0)}, |
| {T(0), T(1), T(1)}, |
| {T(-2), T(-1), T(1)}, |
| {T(1), T(2), T(1)}, |
| {T(-3), T(-2), T(1)}, |
| {T(0x100), T(0x300), T(0x200)}, |
| {T(-0x300), T(-0x100), T(0x200)}, |
| {T::Highest(), T::Highest(), T(0)}, |
| {T::Lowest(), T::Lowest(), T(0)}, |
| {Error<T>, T::Lowest(), T::Highest()}, |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedSubTest_Float, |
| CheckedSubTest_Float, |
| testing::ValuesIn(Concat(CheckedSubTest_FloatCases<AFloat>(), |
| CheckedSubTest_FloatCases<f32>(), |
| CheckedSubTest_FloatCases<f16>()))); |
| |
| using CheckedMulTest_AInt = testing::TestWithParam<BinaryCheckedCase_AInt>; |
| TEST_P(CheckedMulTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| ValidateResult(CheckedMul(a, b), expect); |
| ValidateResult(CheckedMul(b, a), expect); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedMulTest_AInt, |
| CheckedMulTest_AInt, |
| testing::ValuesIn(std::vector<BinaryCheckedCase_AInt>{ |
| {AInt(0), AInt(0), AInt(0)}, |
| {AInt(0), AInt(1), AInt(0)}, |
| {AInt(1), AInt(1), AInt(1)}, |
| {AInt(-1), AInt(-1), AInt(1)}, |
| {AInt(2), AInt(2), AInt(1)}, |
| {AInt(-2), AInt(-2), AInt(1)}, |
| {AInt(0x20000), AInt(0x100), AInt(0x200)}, |
| {AInt(-0x20000), AInt(-0x100), AInt(0x200)}, |
| {AInt(0x4000000000000000ll), AInt(0x80000000ll), AInt(0x80000000ll)}, |
| {AInt(0x4000000000000000ll), AInt(-0x80000000ll), AInt(-0x80000000ll)}, |
| {AInt(0x1000000000000000ll), AInt(0x40000000ll), AInt(0x40000000ll)}, |
| {AInt(-0x1000000000000000ll), AInt(-0x40000000ll), AInt(0x40000000ll)}, |
| {AInt(0x100000000000000ll), AInt(0x1000000), AInt(0x100000000ll)}, |
| {AInt(0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(2)}, |
| {AInt(-0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(-2)}, |
| {AInt(-0x2000000000000000ll), AInt(-0x1000000000000000ll), AInt(2)}, |
| {AInt(-0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(-2)}, |
| {AInt(0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(4)}, |
| {AInt(-0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(-4)}, |
| {AInt(-0x4000000000000000ll), AInt(-0x1000000000000000ll), AInt(4)}, |
| {AInt(-0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(-4)}, |
| {AInt(INT64_MIN), AInt(0x1000000000000000ll), AInt(-8)}, |
| {AInt(INT64_MIN), AInt(-0x1000000000000000ll), AInt(8)}, |
| {AInt(0), AInt::Highest(), AInt(0)}, |
| {AInt(0), AInt::Lowest(), AInt(0)}, |
| {OVERFLOW, AInt(0x1000000000000000ll), AInt(8)}, |
| {OVERFLOW, AInt(-0x1000000000000000ll), AInt(-8)}, |
| {OVERFLOW, AInt(0x800000000000000ll), AInt(0x10)}, |
| {OVERFLOW, AInt(0x80000000ll), AInt(0x100000000ll)}, |
| {OVERFLOW, AInt::Highest(), AInt::Highest()}, |
| {OVERFLOW, AInt::Highest(), AInt::Lowest()}, |
| //////////////////////////////////////////////////////////////////////// |
| })); |
| |
| using CheckedMulTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedMulTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| ValidateResult(CheckedMul(lhs, rhs), expect); |
| ValidateResult(CheckedMul(rhs, lhs), expect); |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedMulTest_FloatCases() { |
| return { |
| {T(0), T(0), T(0)}, |
| {T(0), T(1), T(0)}, |
| {T(1), T(1), T(1)}, |
| {T(-1), T(-1), T(1)}, |
| {T(2), T(2), T(1)}, |
| {T(-2), T(-2), T(1)}, |
| {T(0), T::Highest(), T(0)}, |
| {T(0), T::Lowest(), -T(0)}, |
| {Error<T>, T::Highest(), T::Highest()}, |
| {Error<T>, T::Lowest(), T::Lowest()}, |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedMulTest_Float, |
| CheckedMulTest_Float, |
| testing::ValuesIn(Concat(CheckedMulTest_FloatCases<AFloat>(), |
| CheckedMulTest_FloatCases<f32>(), |
| CheckedMulTest_FloatCases<f16>()))); |
| |
| using CheckedDivTest_AInt = testing::TestWithParam<BinaryCheckedCase_AInt>; |
| TEST_P(CheckedDivTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| ValidateResult(CheckedDiv(a, b), expect); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedDivTest_AInt, |
| CheckedDivTest_AInt, |
| testing::ValuesIn(std::vector<BinaryCheckedCase_AInt>{ |
| {AInt(0), AInt(0), AInt(1)}, |
| {AInt(1), AInt(1), AInt(1)}, |
| {AInt(1), AInt(1), AInt(1)}, |
| {AInt(2), AInt(2), AInt(1)}, |
| {AInt(2), AInt(4), AInt(2)}, |
| {AInt::Highest(), AInt::Highest(), AInt(1)}, |
| {AInt::Lowest(), AInt::Lowest(), AInt(1)}, |
| {AInt(1), AInt::Highest(), AInt::Highest()}, |
| {AInt(0), AInt(0), AInt::Highest()}, |
| {AInt(0), AInt(0), AInt::Lowest()}, |
| {OVERFLOW, AInt(123), AInt(0)}, |
| {OVERFLOW, AInt(-123), AInt(0)}, |
| //////////////////////////////////////////////////////////////////////// |
| })); |
| |
| using CheckedDivTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedDivTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| ValidateResult(CheckedDiv(lhs, rhs), expect); |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedDivTest_FloatCases() { |
| return { |
| {T(0), T(0), T(1)}, |
| {T(1), T(1), T(1)}, |
| {T(1), T(1), T(1)}, |
| {T(2), T(2), T(1)}, |
| {T(2), T(4), T(2)}, |
| {T::Highest(), T::Highest(), T(1)}, |
| {T::Lowest(), T::Lowest(), T(1)}, |
| {T(1), T::Highest(), T::Highest()}, |
| {T(0), T(0), T::Highest()}, |
| {-T(0), T(0), T::Lowest()}, |
| {Error<T>, T(123), T(0.0)}, |
| {Error<T>, T(123), T(-0.0)}, |
| {Error<T>, T(-123), T(0.0)}, |
| {Error<T>, T(-123), T(-0.0)}, |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedDivTest_Float, |
| CheckedDivTest_Float, |
| testing::ValuesIn(Concat(CheckedDivTest_FloatCases<AFloat>(), |
| CheckedDivTest_FloatCases<f32>(), |
| CheckedDivTest_FloatCases<f16>()))); |
| |
| using CheckedModTest_AInt = testing::TestWithParam<BinaryCheckedCase_AInt>; |
| TEST_P(CheckedModTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| EXPECT_TRUE(CheckedMod(a, b) == expect) << std::hex << "0x" << a << " % 0x" << b; |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedModTest_AInt, |
| CheckedModTest_AInt, |
| testing::ValuesIn(std::vector<BinaryCheckedCase_AInt>{ |
| {AInt(0), AInt(0), AInt(1)}, |
| {AInt(0), AInt(1), AInt(1)}, |
| {AInt(1), AInt(10), AInt(3)}, |
| {AInt(2), AInt(10), AInt(4)}, |
| {AInt(0), AInt::Highest(), AInt::Highest()}, |
| {AInt(0), AInt::Lowest(), AInt::Lowest()}, |
| {AInt(2), AInt::Highest(), AInt(5)}, |
| {AInt(1), AInt::Highest(), AInt(6)}, |
| {AInt(0), AInt::Highest(), AInt(7)}, |
| {-AInt{1}, -AInt{10}, AInt{3}}, |
| {-AInt{2}, -AInt{10}, AInt{4}}, |
| {AInt{1}, AInt{10}, -AInt{3}}, |
| {AInt{2}, AInt{10}, -AInt{4}}, |
| {-AInt{1}, -AInt{10}, -AInt{3}}, |
| {-AInt{2}, -AInt{10}, -AInt{4}}, |
| {OVERFLOW, AInt::Highest(), AInt(0)}, |
| {OVERFLOW, AInt::Lowest(), AInt(0)}, |
| //////////////////////////////////////////////////////////////////////// |
| })); |
| |
| using CheckedModTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedModTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| ValidateResult(CheckedMod(lhs, rhs), expect); |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedModTest_FloatCases() { |
| return { |
| {T(0.5), T(10.5), T(1)}, // |
| {T(0.5), T(10.5), T(2)}, // |
| {T(1.5), T(10.5), T(3)}, // |
| {T(2.5), T(10.5), T(4)}, // |
| {T(0.5), T(10.5), T(5)}, // |
| {T(0), T::Highest(), T::Highest()}, // |
| {T(0), T::Lowest(), T::Lowest()}, // |
| {-T{1}, -T{10}, T{3}}, // |
| {-T{2}, -T{10}, T{4}}, // |
| {T{1}, T{10}, -T{3}}, // |
| {T{2}, T{10}, -T{4}}, // |
| {-T{1}, -T{10}, -T{3}}, // |
| {-T{2}, -T{10}, -T{4}}, // |
| {Error<T>, T(123), T(0.0)}, // |
| {Error<T>, T(123), T(-0.0)}, // |
| {Error<T>, T(-123), T(0.0)}, // |
| {Error<T>, T(-123), T(-0.0)}, |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedModTest_Float, |
| CheckedModTest_Float, |
| testing::ValuesIn(Concat(CheckedModTest_FloatCases<AFloat>(), |
| CheckedModTest_FloatCases<f32>(), |
| CheckedModTest_FloatCases<f16>()))); |
| |
| using CheckedPowTest_Float = testing::TestWithParam<BinaryCheckedCase_Float>; |
| TEST_P(CheckedPowTest_Float, Test) { |
| auto& p = GetParam(); |
| std::visit( |
| [&](auto&& lhs) { |
| using T = std::decay_t<decltype(lhs)>; |
| auto rhs = std::get<T>(std::get<2>(p)); |
| auto expect = std::get<std::optional<T>>(std::get<0>(p)); |
| ValidateResult(CheckedPow(lhs, rhs), expect, /* float_comp */ true); |
| }, |
| std::get<1>(p)); |
| } |
| template <typename T> |
| std::vector<BinaryCheckedCase_Float> CheckedPowTest_FloatCases() { |
| return { |
| {T(0), T(0), T(1)}, // |
| {T(0), T(0), T::Highest()}, // |
| {T(1), T(1), T(1)}, // |
| {T(1), T(1), T::Lowest()}, // |
| {T(4), T(2), T(2)}, // |
| {T(8), T(2), T(3)}, // |
| {T(1), T(1), T::Highest()}, // |
| {T(1), T(1), -T(1)}, // |
| {T(0.25), T(2), -T(2)}, // |
| {T(0.125), T(2), -T(3)}, // |
| {T(15.625), T(2.5), T(3)}, // |
| {T(11.313708498), T(2), T(3.5)}, // |
| {T(24.705294220), T(2.5), T(3.5)}, // |
| {T(0.0883883476), T(2), -T(3.5)}, // |
| {Error<T>, -T(1), T(1)}, // |
| {Error<T>, -T(1), T::Highest()}, // |
| {Error<T>, T::Lowest(), T(1)}, // |
| {Error<T>, T::Lowest(), T::Highest()}, // |
| {Error<T>, T::Lowest(), T::Lowest()}, // |
| {Error<T>, T(0), T(0)}, // |
| {Error<T>, T(0), -T(1)}, // |
| {Error<T>, T(0), T::Lowest()}, // |
| // Check exceptional cases from IEEE 754 `powr` function |
| // which has its exceptions derived from the formulation |
| // powr(x,y) = exp(y * log(x)) |
| {Error<T>, T(0.0f), T(-2)}, // (0, less-than-zero) |
| {Error<T>, T(-0.0f), T(-2)}, // (0, less-than-zero) |
| {Error<T>, T(-2), T(5)}, // (less-than-zero, finite) |
| {Error<T>, T(-2), T(0)}, // (less-than-zero, finite) |
| {Error<T>, T(-2), T(-5)}, // (less-than-zero, finite) |
| {Error<T>, T(0.0f), T(0.0f)}, // (0,0) |
| {Error<T>, T(-0.0f), T(0.0f)}, // (0,0) |
| {Error<T>, T(0.0f), T(-0.0f)}, // (0,0) |
| {Error<T>, T(-0.0), T(-0.0f)}, // (0,0) |
| }; |
| } |
| INSTANTIATE_TEST_SUITE_P(CheckedPowTest_Float, |
| CheckedPowTest_Float, |
| testing::ValuesIn(Concat(CheckedPowTest_FloatCases<AFloat>(), |
| CheckedPowTest_FloatCases<f32>(), |
| CheckedPowTest_FloatCases<f16>()))); |
| |
| using TernaryCheckedCase = std::tuple<std::optional<AInt>, AInt, AInt, AInt>; |
| |
| using CheckedMaddTest_AInt = testing::TestWithParam<TernaryCheckedCase>; |
| TEST_P(CheckedMaddTest_AInt, Test) { |
| auto expect = std::get<0>(GetParam()); |
| auto a = std::get<1>(GetParam()); |
| auto b = std::get<2>(GetParam()); |
| auto c = std::get<3>(GetParam()); |
| ValidateResult(CheckedMadd(a, b, c), expect); |
| ValidateResult(CheckedMadd(b, a, c), expect); |
| } |
| INSTANTIATE_TEST_SUITE_P( |
| CheckedMaddTest_AInt, |
| CheckedMaddTest_AInt, |
| testing::ValuesIn(std::vector<TernaryCheckedCase>{ |
| {AInt(0), AInt(0), AInt(0), AInt(0)}, |
| {AInt(0), AInt(1), AInt(0), AInt(0)}, |
| {AInt(1), AInt(1), AInt(1), AInt(0)}, |
| {AInt(2), AInt(1), AInt(1), AInt(1)}, |
| {AInt(0), AInt(1), AInt(-1), AInt(1)}, |
| {AInt(-1), AInt(1), AInt(-2), AInt(1)}, |
| {AInt(-1), AInt(-1), AInt(1), AInt(0)}, |
| {AInt(2), AInt(2), AInt(1), AInt(0)}, |
| {AInt(-2), AInt(-2), AInt(1), AInt(0)}, |
| {AInt(0), AInt::Highest(), AInt(0), AInt(0)}, |
| {AInt(0), AInt::Lowest(), AInt(0), AInt(0)}, |
| {AInt(3), AInt(1), AInt(2), AInt(1)}, |
| {AInt(0x300), AInt(1), AInt(0x100), AInt(0x200)}, |
| {AInt(0x100), AInt(1), AInt(-0x100), AInt(0x200)}, |
| {AInt(0x20000), AInt(0x100), AInt(0x200), AInt(0)}, |
| {AInt(-0x20000), AInt(-0x100), AInt(0x200), AInt(0)}, |
| {AInt(0x4000000000000000ll), AInt(0x80000000ll), AInt(0x80000000ll), AInt(0)}, |
| {AInt(0x4000000000000000ll), AInt(-0x80000000ll), AInt(-0x80000000ll), AInt(0)}, |
| {AInt(0x1000000000000000ll), AInt(0x40000000ll), AInt(0x40000000ll), AInt(0)}, |
| {AInt(-0x1000000000000000ll), AInt(-0x40000000ll), AInt(0x40000000ll), AInt(0)}, |
| {AInt(0x100000000000000ll), AInt(0x1000000), AInt(0x100000000ll), AInt(0)}, |
| {AInt(0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(2), AInt(0)}, |
| {AInt(-0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(-2), AInt(0)}, |
| {AInt(-0x2000000000000000ll), AInt(-0x1000000000000000ll), AInt(2), AInt(0)}, |
| {AInt(-0x2000000000000000ll), AInt(0x1000000000000000ll), AInt(-2), AInt(0)}, |
| {AInt(0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(4), AInt(0)}, |
| {AInt(-0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(-4), AInt(0)}, |
| {AInt(-0x4000000000000000ll), AInt(-0x1000000000000000ll), AInt(4), AInt(0)}, |
| {AInt(-0x4000000000000000ll), AInt(0x1000000000000000ll), AInt(-4), AInt(0)}, |
| {AInt(INT64_MIN), AInt(0x1000000000000000ll), AInt(-8), AInt(0)}, |
| {AInt(INT64_MIN), AInt(-0x1000000000000000ll), AInt(8), AInt(0)}, |
| {AInt::Highest(), AInt(1), AInt(1), AInt(AInt::kHighestValue - 1)}, |
| {AInt::Lowest(), AInt(1), AInt(-1), AInt(AInt::kLowestValue + 1)}, |
| {AInt::Highest(), AInt(1), AInt(0x7fffffff00000000ll), AInt(0x00000000ffffffffll)}, |
| {AInt::Highest(), AInt(1), AInt::Highest(), AInt(0)}, |
| {AInt::Lowest(), AInt(1), AInt::Lowest(), AInt(0)}, |
| {OVERFLOW, AInt(0x1000000000000000ll), AInt(8), AInt(0)}, |
| {OVERFLOW, AInt(-0x1000000000000000ll), AInt(-8), AInt(0)}, |
| {OVERFLOW, AInt(0x800000000000000ll), AInt(0x10), AInt(0)}, |
| {OVERFLOW, AInt(0x80000000ll), AInt(0x100000000ll), AInt(0)}, |
| {OVERFLOW, AInt::Highest(), AInt::Highest(), AInt(0)}, |
| {OVERFLOW, AInt::Highest(), AInt::Lowest(), AInt(0)}, |
| {OVERFLOW, AInt(1), AInt(1), AInt::Highest()}, |
| {OVERFLOW, AInt(1), AInt(-1), AInt::Lowest()}, |
| {OVERFLOW, AInt(1), AInt(2), AInt::Highest()}, |
| {OVERFLOW, AInt(1), AInt(-2), AInt::Lowest()}, |
| {OVERFLOW, AInt(1), AInt(10000), AInt::Highest()}, |
| {OVERFLOW, AInt(1), AInt(-10000), AInt::Lowest()}, |
| {OVERFLOW, AInt(1), AInt::Highest(), AInt::Highest()}, |
| {OVERFLOW, AInt(1), AInt::Lowest(), AInt::Lowest()}, |
| {OVERFLOW, AInt(1), AInt::Highest(), AInt(1)}, |
| {OVERFLOW, AInt(1), AInt::Lowest(), AInt(-1)}, |
| })); |
| |
| TINT_END_DISABLE_WARNING(CONSTANT_OVERFLOW); |
| |
| } // namespace |
| } // namespace tint::core |
