| // 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 "src/tint/lang/core/constant/eval_test.h" |
| |
| namespace tint::core::constant::test { |
| namespace { |
| |
| using namespace tint::core::fluent_types; // NOLINT |
| using namespace tint::core::number_suffixes; // NOLINT |
| |
| struct Case { |
| Value input; |
| struct Success { |
| Value value; |
| }; |
| struct Failure { |
| builder::CreatePtrs create_ptrs; |
| }; |
| tint::Result<Success, Failure> expected; |
| }; |
| |
| static std::ostream& operator<<(std::ostream& o, const Case& c) { |
| o << "input: " << c.input; |
| if (c.expected == Success) { |
| o << ", expected: " << c.expected.Get().value; |
| } else { |
| o << ", expected failed bitcast to " << c.expected.Failure().create_ptrs; |
| } |
| return o; |
| } |
| |
| template <typename TO, typename FROM> |
| Case Success(FROM input, TO expected) { |
| return Case{input, Case::Success{expected}}; |
| } |
| |
| template <typename TO, typename FROM> |
| Case Failure(FROM input) { |
| return Case{input, Case::Failure{builder::CreatePtrsFor<TO>()}}; |
| } |
| |
| using ConstEvalBitcastTest = ConstEvalTestWithParam<Case>; |
| |
| TEST_P(ConstEvalBitcastTest, Test) { |
| const auto& input = GetParam().input; |
| const auto& expected = GetParam().expected; |
| |
| // Get the target type CreatePtrs |
| builder::CreatePtrs target_create_ptrs; |
| if (expected == tint::Success) { |
| target_create_ptrs = expected.Get().value.create_ptrs; |
| } else { |
| target_create_ptrs = expected.Failure().create_ptrs; |
| } |
| |
| auto target_ty = target_create_ptrs.ast(*this); |
| ASSERT_NE(target_ty, nullptr); |
| auto* input_val = input.Expr(*this); |
| const ast::Expression* expr = Bitcast(Source{{12, 34}}, target_ty, input_val); |
| |
| WrapInFunction(expr); |
| |
| auto* target_sem_ty = target_create_ptrs.sem(*this); |
| |
| if (expected == tint::Success) { |
| EXPECT_TRUE(r()->Resolve()) << r()->error(); |
| |
| auto* sem = Sem().GetVal(expr); |
| ASSERT_NE(sem, nullptr); |
| EXPECT_TYPE(sem->Type(), target_sem_ty); |
| ASSERT_NE(sem->ConstantValue(), nullptr); |
| EXPECT_TYPE(sem->ConstantValue()->Type(), target_sem_ty); |
| |
| auto expected_values = expected.Get().value.args; |
| auto got_values = ScalarsFrom(sem->ConstantValue()); |
| EXPECT_EQ(expected_values, got_values); |
| } else { |
| ASSERT_FALSE(r()->Resolve()); |
| EXPECT_THAT(r()->error(), testing::StartsWith("12:34 error:")); |
| EXPECT_THAT(r()->error(), testing::HasSubstr("cannot be represented as")); |
| } |
| } |
| |
| const u32 nan_as_u32 = tint::Bitcast<u32>(std::numeric_limits<float>::quiet_NaN()); |
| const i32 nan_as_i32 = tint::Bitcast<i32>(std::numeric_limits<float>::quiet_NaN()); |
| const u32 inf_as_u32 = tint::Bitcast<u32>(std::numeric_limits<float>::infinity()); |
| const i32 inf_as_i32 = tint::Bitcast<i32>(std::numeric_limits<float>::infinity()); |
| const u32 neg_inf_as_u32 = tint::Bitcast<u32>(-std::numeric_limits<float>::infinity()); |
| const i32 neg_inf_as_i32 = tint::Bitcast<i32>(-std::numeric_limits<float>::infinity()); |
| const AInt u32_highest_plus_one = AInt(AInt(u32::kHighestValue).value + 1); |
| const AInt i32_lowest_minus_one = AInt(AInt(i32::kLowestValue).value - 1); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| Bitcast, |
| ConstEvalBitcastTest, |
| testing::ValuesIn({ |
| // Bitcast to same (concrete) type, no change |
| Success(Val(0_u), Val(0_u)), // |
| Success(Val(0_i), Val(0_i)), // |
| Success(Val(0_f), Val(0_f)), // |
| Success(Val(123_u), Val(123_u)), // |
| Success(Val(123_i), Val(123_i)), // |
| Success(Val(123.456_f), Val(123.456_f)), // |
| Success(Val(u32::Highest()), Val(u32::Highest())), // |
| Success(Val(u32::Lowest()), Val(u32::Lowest())), // |
| Success(Val(i32::Highest()), Val(i32::Highest())), // |
| Success(Val(i32::Lowest()), Val(i32::Lowest())), // |
| Success(Val(f32::Highest()), Val(f32::Highest())), // |
| Success(Val(f32::Lowest()), Val(f32::Lowest())), // |
| |
| // Bitcast to different type |
| Success(Val(0_u), Val(0_i)), // |
| Success(Val(0_u), Val(0_f)), // |
| Success(Val(0_i), Val(0_u)), // |
| Success(Val(0_i), Val(0_f)), // |
| Success(Val(0.0_f), Val(0_i)), // |
| Success(Val(0.0_f), Val(0_u)), // |
| Success(Val(1_u), Val(1_i)), // |
| Success(Val(1_u), Val(1.4013e-45_f)), // |
| Success(Val(1_i), Val(1_u)), // |
| Success(Val(1_i), Val(1.4013e-45_f)), // |
| Success(Val(1.0_f), Val(0x3F800000_u)), // |
| Success(Val(1.0_f), Val(0x3F800000_i)), // |
| Success(Val(123_u), Val(123_i)), // |
| Success(Val(123_u), Val(1.7236e-43_f)), // |
| Success(Val(123_i), Val(123_u)), // |
| Success(Val(123_i), Val(1.7236e-43_f)), // |
| Success(Val(123.0_f), Val(0x42F60000_u)), // |
| Success(Val(123.0_f), Val(0x42F60000_i)), // |
| |
| // Abstracts |
| Success(Val(0_a), Val(0_i)), // |
| Success(Val(0_a), Val(0_f)), // |
| Success(Val(0_a), Val(0_u)), // |
| Success(Val(0_a), Val(0_f)), // |
| Success(Val(0_a), Val(0_i)), // |
| Success(Val(0_a), Val(0_u)), // |
| Success(Val(1_a), Val(1_i)), // |
| Success(Val(1_a), Val(1.4013e-45_f)), // |
| Success(Val(1_a), Val(1_u)), // |
| Success(Val(1_a), Val(1.4013e-45_f)), // |
| Success(Val(1.0_a), Val(0x3F800000_u)), // |
| Success(Val(1.0_a), Val(0x3F800000_i)), // |
| Success(Val(123_a), Val(123_i)), // |
| Success(Val(123_a), Val(1.7236e-43_f)), // |
| Success(Val(123_a), Val(123_u)), // |
| Success(Val(123_a), Val(1.7236e-43_f)), // |
| Success(Val(123.0_a), Val(0x42F60000_u)), // |
| Success(Val(123.0_a), Val(0x42F60000_i)), // |
| Success(Val(AInt(u32::Highest())), Val(u32::Highest())), // |
| Success(Val(AInt(u32::Lowest())), Val(u32::Lowest())), // |
| Success(Val(AInt(i32::Highest())), Val(tint::Bitcast<u32>(i32::Highest()))), // |
| Success(Val(AInt(i32::Lowest())), Val(tint::Bitcast<u32>(i32::Lowest()))), // |
| Success(Val(AInt(i32::Highest())), Val(i32::Highest())), // |
| Success(Val(AInt(i32::Lowest())), Val(i32::Lowest())), // |
| |
| // u32 <-> i32 sign bit |
| Success(Val(0xFFFFFFFF_u), Val(-1_i)), // |
| Success(Val(-1_i), Val(0xFFFFFFFF_u)), // |
| Success(Val(0x80000000_u), Val(i32::Lowest())), // |
| Success(Val(i32::Lowest()), Val(0x80000000_u)), // |
| |
| // Vector tests |
| Success(Vec(0_u, 1_u, 123_u), Vec(0_i, 1_i, 123_i)), |
| Success(Vec(0.0_f, 1.0_f, 123.0_f), Vec(0_i, 0x3F800000_i, 0x42F60000_i)), |
| Success(Vec(0xffffffff_a, -1_a), Vec(0xffffffff_u, 0xffffffff_u)), |
| |
| // Unrepresentable |
| Failure<f32>(Val(nan_as_u32)), // |
| Failure<f32>(Val(nan_as_i32)), // |
| Failure<f32>(Val(inf_as_u32)), // |
| Failure<f32>(Val(inf_as_i32)), // |
| Failure<f32>(Val(neg_inf_as_u32)), // |
| Failure<f32>(Val(neg_inf_as_i32)), // |
| Failure<vec2<f32>>(Vec(nan_as_u32, 0_u)), // |
| Failure<vec2<f32>>(Vec(nan_as_i32, 0_i)), // |
| Failure<vec2<f32>>(Vec(inf_as_u32, 0_u)), // |
| Failure<vec2<f32>>(Vec(inf_as_i32, 0_i)), // |
| Failure<vec2<f32>>(Vec(neg_inf_as_u32, 0_u)), // |
| Failure<vec2<f32>>(Vec(neg_inf_as_i32, 0_i)), // |
| Failure<vec2<f32>>(Vec(0_u, nan_as_u32)), // |
| Failure<vec2<f32>>(Vec(0_i, nan_as_i32)), // |
| Failure<vec2<f32>>(Vec(0_u, inf_as_u32)), // |
| Failure<vec2<f32>>(Vec(0_i, inf_as_i32)), // |
| Failure<vec2<f32>>(Vec(0_u, neg_inf_as_u32)), // |
| Failure<vec2<f32>>(Vec(0_i, neg_inf_as_i32)), // |
| |
| // Abstract too large |
| Failure<u32>(Val(u32_highest_plus_one)), // |
| Failure<u32>(Val(i32_lowest_minus_one)), // |
| Failure<vec2<u32>>(Vec(0_a, u32_highest_plus_one)), // |
| Failure<vec2<u32>>(Vec(i32_lowest_minus_one, 0_a)), // |
| })); |
| |
| } // namespace |
| } // namespace tint::core::constant::test |
