src/reader/wgsl/parser_impl_const_literal_test.cc - tint - Git at Google

 // Copyright 2020 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "src/reader/wgsl/parser_impl_test_helper.h"

 #include <cmath>
 #include <cstring>

 namespace tint {
 namespace reader {
 namespace wgsl {
 namespace {

 // Makes an IEEE 754 binary32 floating point number with
 // - 0 sign if sign is 0, 1 otherwise
 // - 'exponent_bits' is placed in the exponent space.
 //   So, the exponent bias must already be included.
 float MakeFloat(int sign, int biased_exponent, int mantissa) {
   const uint32_t sign_bit = sign ? 0x80000000u : 0u;
   // The binary32 exponent is 8 bits, just below the sign.
   const uint32_t exponent_bits = (biased_exponent & 0xffu) << 23;
   // The mantissa is the bottom 23 bits.
   const uint32_t mantissa_bits = (mantissa & 0x7fffffu);

   uint32_t bits = sign_bit | exponent_bits | mantissa_bits;
   float result = 0.0f;
   static_assert(sizeof(result) == sizeof(bits),
                 "expected float and uint32_t to be the same size");
   std::memcpy(&result, &bits, sizeof(bits));
   return result;
 }

 TEST_F(ParserImplTest, ConstLiteral_Int) {
   auto p = parser("-234");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::SintLiteral>());
   EXPECT_EQ(c->As<ast::SintLiteral>()->value(), -234);
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_Uint) {
   auto p = parser("234u");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::UintLiteral>());
   EXPECT_EQ(c->As<ast::UintLiteral>()->value(), 234u);
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_Float) {
   auto p = parser("234.e12");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::FloatLiteral>());
   EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(), 234e12f);
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 8u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_InvalidFloat) {
   auto p = parser("1.2e+256");
   auto c = p->const_literal();
   EXPECT_FALSE(c.matched);
   EXPECT_TRUE(c.errored);
   EXPECT_EQ(p->error(), "1:1: f32 (1.2e+256) too large");
   ASSERT_EQ(c.value, nullptr);
 }

 struct FloatLiteralTestCase {
   const char* input;
   float expected;
 };

 inline std::ostream& operator<<(std::ostream& out, FloatLiteralTestCase data) {
   out << data.input;
   return out;
 }

 class ParserImplFloatLiteralTest
     : public ParserImplTestWithParam<FloatLiteralTestCase> {};
 TEST_P(ParserImplFloatLiteralTest, Parse) {
   auto params = GetParam();
   SCOPED_TRACE(params.input);
   auto p = parser(params.input);
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::FloatLiteral>());
   EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(), params.expected);
 }

 FloatLiteralTestCase float_literal_test_cases[] = {
     {"0.0", 0.0f},                         // Zero
     {"1.0", 1.0f},                         // One
     {"-1.0", -1.0f},                       // MinusOne
     {"1000000000.0", 1e9f},                // Billion
     {"-0.0", std::copysign(0.0f, -5.0f)},  // NegativeZero
     {"0.0", MakeFloat(0, 0, 0)},           // Zero
     {"-0.0", MakeFloat(1, 0, 0)},          // NegativeZero
     {"1.0", MakeFloat(0, 127, 0)},         // One
     {"-1.0", MakeFloat(1, 127, 0)},        // NegativeOne
 };
 INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float,
                          ParserImplFloatLiteralTest,
                          testing::ValuesIn(float_literal_test_cases));

 const float NegInf = MakeFloat(1, 255, 0);
 const float PosInf = MakeFloat(0, 255, 0);
 FloatLiteralTestCase hexfloat_literal_test_cases[] = {
     // Regular numbers
     {"0x0p+0", 0.f},
     {"0x1p+0", 1.f},
     {"0x1p+1", 2.f},
     {"0x1.8p+1", 3.f},
     {"0x1.99999ap-4", 0.1f},
     {"0x1p-1", 0.5f},
     {"0x1p-2", 0.25f},
     {"0x1.8p-1", 0.75f},
     {"-0x0p+0", -0.f},
     {"-0x1p+0", -1.f},
     {"-0x1p-1", -0.5f},
     {"-0x1p-2", -0.25f},
     {"-0x1.8p-1", -0.75f},

     // Large numbers
     {"0x1p+9", 512.f},
     {"0x1p+10", 1024.f},
     {"0x1.02p+10", 1024.f + 8.f},
     {"-0x1p+9", -512.f},
     {"-0x1p+10", -1024.f},
     {"-0x1.02p+10", -1024.f - 8.f},

     // Small numbers
     {"0x1p-9", 1.0f / 512.f},
     {"0x1p-10", 1.0f / 1024.f},
     {"0x1.02p-3", 1.0f / 1024.f + 1.0f / 8.f},
     {"-0x1p-9", 1.0f / -512.f},
     {"-0x1p-10", 1.0f / -1024.f},
     {"-0x1.02p-3", 1.0f / -1024.f - 1.0f / 8.f},

     // Near lowest non-denorm
     {"0x1p-124", std::ldexp(1.f * 8.f, -127)},
     {"0x1p-125", std::ldexp(1.f * 4.f, -127)},
     {"-0x1p-124", -std::ldexp(1.f * 8.f, -127)},
     {"-0x1p-125", -std::ldexp(1.f * 4.f, -127)},

     // Lowest non-denorm
     {"0x1p-126", std::ldexp(1.f * 2.f, -127)},
     {"-0x1p-126", -std::ldexp(1.f * 2.f, -127)},

     // Denormalized values
     {"0x1p-127", std::ldexp(1.f, -127)},
     {"0x1p-128", std::ldexp(1.f / 2.f, -127)},
     {"0x1p-129", std::ldexp(1.f / 4.f, -127)},
     {"0x1p-130", std::ldexp(1.f / 8.f, -127)},
     {"-0x1p-127", -std::ldexp(1.f, -127)},
     {"-0x1p-128", -std::ldexp(1.f / 2.f, -127)},
     {"-0x1p-129", -std::ldexp(1.f / 4.f, -127)},
     {"-0x1p-130", -std::ldexp(1.f / 8.f, -127)},

     {"0x1.8p-127", std::ldexp(1.f, -127) + (std::ldexp(1.f, -127) / 2.f)},
     {"0x1.8p-128", std::ldexp(1.f, -127) / 2.f + (std::ldexp(1.f, -127) / 4.f)},

     {"0x1p-149", MakeFloat(0, 0, 1)},                 // +SmallestDenormal
     {"0x1p-148", MakeFloat(0, 0, 2)},                 // +BiggerDenormal
     {"0x1.fffffcp-127", MakeFloat(0, 0, 0x7fffff)},   // +LargestDenormal
     {"-0x1p-149", MakeFloat(1, 0, 1)},                // -SmallestDenormal
     {"-0x1p-148", MakeFloat(1, 0, 2)},                // -BiggerDenormal
     {"-0x1.fffffcp-127", MakeFloat(1, 0, 0x7fffff)},  // -LargestDenormal

     {"0x1.2bfaf8p-127", MakeFloat(0, 0, 0xcafebe)},   // +Subnormal
     {"-0x1.2bfaf8p-127", MakeFloat(1, 0, 0xcafebe)},  // -Subnormal
     {"0x1.55554p-130", MakeFloat(0, 0, 0xaaaaa)},     // +Subnormal
     {"-0x1.55554p-130", MakeFloat(1, 0, 0xaaaaa)},    // -Subnormal

     // Nan -> Infinity
     {"0x1.8p+128", PosInf},
     {"0x1.0002p+128", PosInf},
     {"0x1.0018p+128", PosInf},
     {"0x1.01ep+128", PosInf},
     {"0x1.fffffep+128", PosInf},
     {"-0x1.8p+128", NegInf},
     {"-0x1.0002p+128", NegInf},
     {"-0x1.0018p+128", NegInf},
     {"-0x1.01ep+128", NegInf},
     {"-0x1.fffffep+128", NegInf},

     // Infinity
     {"0x1p+128", PosInf},
     {"-0x1p+128", NegInf},
     {"0x32p+127", PosInf},
     {"0x32p+500", PosInf},
     {"-0x32p+127", NegInf},
     {"-0x32p+500", NegInf},

     // Overflow -> Infinity
     {"0x1p+129", PosInf},
     {"0x1.1p+128", PosInf},
     {"-0x1p+129", NegInf},
     {"-0x1.1p+128", NegInf},

     // Underflow -> Zero
     {"0x1p-500", 0.f},  // Exponent underflows
     {"-0x1p-500", -0.f},
     {"0x0.00000000001p-126", 0.f},  // Fraction causes underflow
     {"-0x0.0000000001p-127", -0.f},
     {"0x0.01p-142", 0.f},
     {"-0x0.01p-142", -0.f},  // Fraction causes additional underflow

     // Zero with non-zero exponent -> Zero
     {"0x0p+0", 0.f},
     {"0x0p+1", 0.f},
     {"0x0p-1", 0.f},
     {"0x0p+9999999999", 0.f},
     {"0x0p-9999999999", 0.f},

     // Test parsing
     {"0x0p0", 0.f},
     {"0x0p-0", 0.f},
     {"0x0p+000", 0.f},
     {"0x00000000000000p+000000000000000", 0.f},
     {"0x00000000000000p-000000000000000", 0.f},
     {"0x00000000000001p+000000000000000", 1.f},
     {"0x00000000000001p-000000000000000", 1.f},
     {"0x0000000000000000000001.99999ap-000000000000000004", 0.1f},
     {"0x2p+0", 2.f},
     {"0xFFp+0", 255.f},
     {"0x0.8p+0", 0.5f},
     {"0x0.4p+0", 0.25f},
     {"0x0.4p+1", 2 * 0.25f},
     {"0x0.4p+2", 4 * 0.25f},
     {"0x123Ep+1", 9340.f},
     {"-0x123Ep+1", -9340.f},
     {"0x1a2b3cP12", 7.024656e+09f},
     {"-0x1a2b3cP12", -7.024656e+09f},
 };
 INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_HexFloat,
                          ParserImplFloatLiteralTest,
                          testing::ValuesIn(hexfloat_literal_test_cases));

 struct InvalidLiteralTestCase {
   const char* input;
   const char* error_msg;
 };
 class ParserImplInvalidLiteralTest
     : public ParserImplTestWithParam<InvalidLiteralTestCase> {};
 TEST_P(ParserImplInvalidLiteralTest, Parse) {
   auto params = GetParam();
   SCOPED_TRACE(params.input);
   auto p = parser(params.input);
   auto c = p->const_literal();
   EXPECT_FALSE(c.matched);
   EXPECT_TRUE(c.errored);
   EXPECT_EQ(p->error(), params.error_msg);
   ASSERT_EQ(c.value, nullptr);
 }

 InvalidLiteralTestCase invalid_hexfloat_mantissa_too_large_cases[] = {
     {"0x1.ffffffff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1f.fffffff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1ff.ffffff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1fff.fffff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1ffff.ffff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1fffff.fff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1ffffff.ff8p0", "1:1: mantissa is too large for hex float"},
     {"0x1fffffff.f8p0", "1:1: mantissa is too large for hex float"},
     {"0x1ffffffff.8p0", "1:1: mantissa is too large for hex float"},
     {"0x1ffffffff8.p0", "1:1: mantissa is too large for hex float"},
 };
 INSTANTIATE_TEST_SUITE_P(
     ParserImplInvalidLiteralTest_HexFloatMantissaTooLarge,
     ParserImplInvalidLiteralTest,
     testing::ValuesIn(invalid_hexfloat_mantissa_too_large_cases));

 InvalidLiteralTestCase invalid_hexfloat_exponent_too_large_cases[] = {
     {"0x0p+4294967296", "1:1: exponent is too large for hex float"},
     {"0x0p-4294967296", "1:1: exponent is too large for hex float"},
 };
 INSTANTIATE_TEST_SUITE_P(
     ParserImplInvalidLiteralTest_HexFloatExponentTooLarge,
     ParserImplInvalidLiteralTest,
     testing::ValuesIn(invalid_hexfloat_exponent_too_large_cases));

 InvalidLiteralTestCase invalid_hexfloat_exponent_missing_cases[] = {
     {"0x0p", "1:1: expected an exponent value for hex float"},
     {"0x1.0p", "1:1: expected an exponent value for hex float"},
     {"0x0.1p", "1:1: expected an exponent value for hex float"},
 };
 INSTANTIATE_TEST_SUITE_P(
     ParserImplInvalidLiteralTest_HexFloatExponentMissing,
     ParserImplInvalidLiteralTest,
     testing::ValuesIn(invalid_hexfloat_exponent_missing_cases));

 TEST_F(ParserImplTest, ConstLiteral_FloatHighest) {
   const auto highest = std::numeric_limits<float>::max();
   const auto expected_highest = 340282346638528859811704183484516925440.0f;
   if (highest < expected_highest || highest > expected_highest) {
     GTEST_SKIP() << "std::numeric_limits<float>::max() is not as expected for "
                     "this target";
   }
   auto p = parser("340282346638528859811704183484516925440.0");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::FloatLiteral>());
   EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(),
                   std::numeric_limits<float>::max());
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 42u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_FloatLowest) {
   // Some compilers complain if you test floating point numbers for equality.
   // So say it via two inequalities.
   const auto lowest = std::numeric_limits<float>::lowest();
   const auto expected_lowest = -340282346638528859811704183484516925440.0f;
   if (lowest < expected_lowest || lowest > expected_lowest) {
     GTEST_SKIP()
         << "std::numeric_limits<float>::lowest() is not as expected for "
            "this target";
   }

   auto p = parser("-340282346638528859811704183484516925440.0");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::FloatLiteral>());
   EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(),
                   std::numeric_limits<float>::lowest());
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 43u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_True) {
   auto p = parser("true");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::BoolLiteral>());
   EXPECT_TRUE(c->As<ast::BoolLiteral>()->IsTrue());
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_False) {
   auto p = parser("false");
   auto c = p->const_literal();
   EXPECT_TRUE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(c.value, nullptr);
   ASSERT_TRUE(c->Is<ast::BoolLiteral>());
   EXPECT_TRUE(c->As<ast::BoolLiteral>()->IsFalse());
   EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 6u}}));
 }

 TEST_F(ParserImplTest, ConstLiteral_NoMatch) {
   auto p = parser("another-token");
   auto c = p->const_literal();
   EXPECT_FALSE(c.matched);
   EXPECT_FALSE(c.errored);
   EXPECT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(c.value, nullptr);
 }

 }  // namespace
 }  // namespace wgsl
 }  // namespace reader
 }  // namespace tint
	// Copyright 2020 The Tint Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "src/reader/wgsl/parser_impl_test_helper.h"

	#include <cmath>
	#include <cstring>

	namespace tint {
	namespace reader {
	namespace wgsl {
	namespace {

	// Makes an IEEE 754 binary32 floating point number with
	// - 0 sign if sign is 0, 1 otherwise
	// - 'exponent_bits' is placed in the exponent space.
	// So, the exponent bias must already be included.
	float MakeFloat(int sign, int biased_exponent, int mantissa) {
	const uint32_t sign_bit = sign ? 0x80000000u : 0u;
	// The binary32 exponent is 8 bits, just below the sign.
	const uint32_t exponent_bits = (biased_exponent & 0xffu) << 23;
	// The mantissa is the bottom 23 bits.
	const uint32_t mantissa_bits = (mantissa & 0x7fffffu);

	uint32_t bits = sign_bit \| exponent_bits \| mantissa_bits;
	float result = 0.0f;
	static_assert(sizeof(result) == sizeof(bits),
	"expected float and uint32_t to be the same size");
	std::memcpy(&result, &bits, sizeof(bits));
	return result;
	}

	TEST_F(ParserImplTest, ConstLiteral_Int) {
	auto p = parser("-234");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::SintLiteral>());
	EXPECT_EQ(c->As<ast::SintLiteral>()->value(), -234);
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_Uint) {
	auto p = parser("234u");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::UintLiteral>());
	EXPECT_EQ(c->As<ast::UintLiteral>()->value(), 234u);
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_Float) {
	auto p = parser("234.e12");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::FloatLiteral>());
	EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(), 234e12f);
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 8u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_InvalidFloat) {
	auto p = parser("1.2e+256");
	auto c = p->const_literal();
	EXPECT_FALSE(c.matched);
	EXPECT_TRUE(c.errored);
	EXPECT_EQ(p->error(), "1:1: f32 (1.2e+256) too large");
	ASSERT_EQ(c.value, nullptr);
	}

	struct FloatLiteralTestCase {
	const char* input;
	float expected;
	};

	inline std::ostream& operator<<(std::ostream& out, FloatLiteralTestCase data) {
	out << data.input;
	return out;
	}

	class ParserImplFloatLiteralTest
	: public ParserImplTestWithParam<FloatLiteralTestCase> {};
	TEST_P(ParserImplFloatLiteralTest, Parse) {
	auto params = GetParam();
	SCOPED_TRACE(params.input);
	auto p = parser(params.input);
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::FloatLiteral>());
	EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(), params.expected);
	}

	FloatLiteralTestCase float_literal_test_cases[] = {
	{"0.0", 0.0f}, // Zero
	{"1.0", 1.0f}, // One
	{"-1.0", -1.0f}, // MinusOne
	{"1000000000.0", 1e9f}, // Billion
	{"-0.0", std::copysign(0.0f, -5.0f)}, // NegativeZero
	{"0.0", MakeFloat(0, 0, 0)}, // Zero
	{"-0.0", MakeFloat(1, 0, 0)}, // NegativeZero
	{"1.0", MakeFloat(0, 127, 0)}, // One
	{"-1.0", MakeFloat(1, 127, 0)}, // NegativeOne
	};
	INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_Float,
	ParserImplFloatLiteralTest,
	testing::ValuesIn(float_literal_test_cases));

	const float NegInf = MakeFloat(1, 255, 0);
	const float PosInf = MakeFloat(0, 255, 0);
	FloatLiteralTestCase hexfloat_literal_test_cases[] = {
	// Regular numbers
	{"0x0p+0", 0.f},
	{"0x1p+0", 1.f},
	{"0x1p+1", 2.f},
	{"0x1.8p+1", 3.f},
	{"0x1.99999ap-4", 0.1f},
	{"0x1p-1", 0.5f},
	{"0x1p-2", 0.25f},
	{"0x1.8p-1", 0.75f},
	{"-0x0p+0", -0.f},
	{"-0x1p+0", -1.f},
	{"-0x1p-1", -0.5f},
	{"-0x1p-2", -0.25f},
	{"-0x1.8p-1", -0.75f},

	// Large numbers
	{"0x1p+9", 512.f},
	{"0x1p+10", 1024.f},
	{"0x1.02p+10", 1024.f + 8.f},
	{"-0x1p+9", -512.f},
	{"-0x1p+10", -1024.f},
	{"-0x1.02p+10", -1024.f - 8.f},

	// Small numbers
	{"0x1p-9", 1.0f / 512.f},
	{"0x1p-10", 1.0f / 1024.f},
	{"0x1.02p-3", 1.0f / 1024.f + 1.0f / 8.f},
	{"-0x1p-9", 1.0f / -512.f},
	{"-0x1p-10", 1.0f / -1024.f},
	{"-0x1.02p-3", 1.0f / -1024.f - 1.0f / 8.f},

	// Near lowest non-denorm
	{"0x1p-124", std::ldexp(1.f * 8.f, -127)},
	{"0x1p-125", std::ldexp(1.f * 4.f, -127)},
	{"-0x1p-124", -std::ldexp(1.f * 8.f, -127)},
	{"-0x1p-125", -std::ldexp(1.f * 4.f, -127)},

	// Lowest non-denorm
	{"0x1p-126", std::ldexp(1.f * 2.f, -127)},
	{"-0x1p-126", -std::ldexp(1.f * 2.f, -127)},

	// Denormalized values
	{"0x1p-127", std::ldexp(1.f, -127)},
	{"0x1p-128", std::ldexp(1.f / 2.f, -127)},
	{"0x1p-129", std::ldexp(1.f / 4.f, -127)},
	{"0x1p-130", std::ldexp(1.f / 8.f, -127)},
	{"-0x1p-127", -std::ldexp(1.f, -127)},
	{"-0x1p-128", -std::ldexp(1.f / 2.f, -127)},
	{"-0x1p-129", -std::ldexp(1.f / 4.f, -127)},
	{"-0x1p-130", -std::ldexp(1.f / 8.f, -127)},

	{"0x1.8p-127", std::ldexp(1.f, -127) + (std::ldexp(1.f, -127) / 2.f)},
	{"0x1.8p-128", std::ldexp(1.f, -127) / 2.f + (std::ldexp(1.f, -127) / 4.f)},

	{"0x1p-149", MakeFloat(0, 0, 1)}, // +SmallestDenormal
	{"0x1p-148", MakeFloat(0, 0, 2)}, // +BiggerDenormal
	{"0x1.fffffcp-127", MakeFloat(0, 0, 0x7fffff)}, // +LargestDenormal
	{"-0x1p-149", MakeFloat(1, 0, 1)}, // -SmallestDenormal
	{"-0x1p-148", MakeFloat(1, 0, 2)}, // -BiggerDenormal
	{"-0x1.fffffcp-127", MakeFloat(1, 0, 0x7fffff)}, // -LargestDenormal

	{"0x1.2bfaf8p-127", MakeFloat(0, 0, 0xcafebe)}, // +Subnormal
	{"-0x1.2bfaf8p-127", MakeFloat(1, 0, 0xcafebe)}, // -Subnormal
	{"0x1.55554p-130", MakeFloat(0, 0, 0xaaaaa)}, // +Subnormal
	{"-0x1.55554p-130", MakeFloat(1, 0, 0xaaaaa)}, // -Subnormal

	// Nan -> Infinity
	{"0x1.8p+128", PosInf},
	{"0x1.0002p+128", PosInf},
	{"0x1.0018p+128", PosInf},
	{"0x1.01ep+128", PosInf},
	{"0x1.fffffep+128", PosInf},
	{"-0x1.8p+128", NegInf},
	{"-0x1.0002p+128", NegInf},
	{"-0x1.0018p+128", NegInf},
	{"-0x1.01ep+128", NegInf},
	{"-0x1.fffffep+128", NegInf},

	// Infinity
	{"0x1p+128", PosInf},
	{"-0x1p+128", NegInf},
	{"0x32p+127", PosInf},
	{"0x32p+500", PosInf},
	{"-0x32p+127", NegInf},
	{"-0x32p+500", NegInf},

	// Overflow -> Infinity
	{"0x1p+129", PosInf},
	{"0x1.1p+128", PosInf},
	{"-0x1p+129", NegInf},
	{"-0x1.1p+128", NegInf},

	// Underflow -> Zero
	{"0x1p-500", 0.f}, // Exponent underflows
	{"-0x1p-500", -0.f},
	{"0x0.00000000001p-126", 0.f}, // Fraction causes underflow
	{"-0x0.0000000001p-127", -0.f},
	{"0x0.01p-142", 0.f},
	{"-0x0.01p-142", -0.f}, // Fraction causes additional underflow

	// Zero with non-zero exponent -> Zero
	{"0x0p+0", 0.f},
	{"0x0p+1", 0.f},
	{"0x0p-1", 0.f},
	{"0x0p+9999999999", 0.f},
	{"0x0p-9999999999", 0.f},

	// Test parsing
	{"0x0p0", 0.f},
	{"0x0p-0", 0.f},
	{"0x0p+000", 0.f},
	{"0x00000000000000p+000000000000000", 0.f},
	{"0x00000000000000p-000000000000000", 0.f},
	{"0x00000000000001p+000000000000000", 1.f},
	{"0x00000000000001p-000000000000000", 1.f},
	{"0x0000000000000000000001.99999ap-000000000000000004", 0.1f},
	{"0x2p+0", 2.f},
	{"0xFFp+0", 255.f},
	{"0x0.8p+0", 0.5f},
	{"0x0.4p+0", 0.25f},
	{"0x0.4p+1", 2 * 0.25f},
	{"0x0.4p+2", 4 * 0.25f},
	{"0x123Ep+1", 9340.f},
	{"-0x123Ep+1", -9340.f},
	{"0x1a2b3cP12", 7.024656e+09f},
	{"-0x1a2b3cP12", -7.024656e+09f},
	};
	INSTANTIATE_TEST_SUITE_P(ParserImplFloatLiteralTest_HexFloat,
	ParserImplFloatLiteralTest,
	testing::ValuesIn(hexfloat_literal_test_cases));

	struct InvalidLiteralTestCase {
	const char* input;
	const char* error_msg;
	};
	class ParserImplInvalidLiteralTest
	: public ParserImplTestWithParam<InvalidLiteralTestCase> {};
	TEST_P(ParserImplInvalidLiteralTest, Parse) {
	auto params = GetParam();
	SCOPED_TRACE(params.input);
	auto p = parser(params.input);
	auto c = p->const_literal();
	EXPECT_FALSE(c.matched);
	EXPECT_TRUE(c.errored);
	EXPECT_EQ(p->error(), params.error_msg);
	ASSERT_EQ(c.value, nullptr);
	}

	InvalidLiteralTestCase invalid_hexfloat_mantissa_too_large_cases[] = {
	{"0x1.ffffffff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1f.fffffff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1ff.ffffff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1fff.fffff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1ffff.ffff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1fffff.fff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1ffffff.ff8p0", "1:1: mantissa is too large for hex float"},
	{"0x1fffffff.f8p0", "1:1: mantissa is too large for hex float"},
	{"0x1ffffffff.8p0", "1:1: mantissa is too large for hex float"},
	{"0x1ffffffff8.p0", "1:1: mantissa is too large for hex float"},
	};
	INSTANTIATE_TEST_SUITE_P(
	ParserImplInvalidLiteralTest_HexFloatMantissaTooLarge,
	ParserImplInvalidLiteralTest,
	testing::ValuesIn(invalid_hexfloat_mantissa_too_large_cases));

	InvalidLiteralTestCase invalid_hexfloat_exponent_too_large_cases[] = {
	{"0x0p+4294967296", "1:1: exponent is too large for hex float"},
	{"0x0p-4294967296", "1:1: exponent is too large for hex float"},
	};
	INSTANTIATE_TEST_SUITE_P(
	ParserImplInvalidLiteralTest_HexFloatExponentTooLarge,
	ParserImplInvalidLiteralTest,
	testing::ValuesIn(invalid_hexfloat_exponent_too_large_cases));

	InvalidLiteralTestCase invalid_hexfloat_exponent_missing_cases[] = {
	{"0x0p", "1:1: expected an exponent value for hex float"},
	{"0x1.0p", "1:1: expected an exponent value for hex float"},
	{"0x0.1p", "1:1: expected an exponent value for hex float"},
	};
	INSTANTIATE_TEST_SUITE_P(
	ParserImplInvalidLiteralTest_HexFloatExponentMissing,
	ParserImplInvalidLiteralTest,
	testing::ValuesIn(invalid_hexfloat_exponent_missing_cases));

	TEST_F(ParserImplTest, ConstLiteral_FloatHighest) {
	const auto highest = std::numeric_limits<float>::max();
	const auto expected_highest = 340282346638528859811704183484516925440.0f;
	if (highest < expected_highest \|\| highest > expected_highest) {
	GTEST_SKIP() << "std::numeric_limits<float>::max() is not as expected for "
	"this target";
	}
	auto p = parser("340282346638528859811704183484516925440.0");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::FloatLiteral>());
	EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(),
	std::numeric_limits<float>::max());
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 42u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_FloatLowest) {
	// Some compilers complain if you test floating point numbers for equality.
	// So say it via two inequalities.
	const auto lowest = std::numeric_limits<float>::lowest();
	const auto expected_lowest = -340282346638528859811704183484516925440.0f;
	if (lowest < expected_lowest \|\| lowest > expected_lowest) {
	GTEST_SKIP()
	<< "std::numeric_limits<float>::lowest() is not as expected for "
	"this target";
	}

	auto p = parser("-340282346638528859811704183484516925440.0");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::FloatLiteral>());
	EXPECT_FLOAT_EQ(c->As<ast::FloatLiteral>()->value(),
	std::numeric_limits<float>::lowest());
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 43u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_True) {
	auto p = parser("true");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::BoolLiteral>());
	EXPECT_TRUE(c->As<ast::BoolLiteral>()->IsTrue());
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 5u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_False) {
	auto p = parser("false");
	auto c = p->const_literal();
	EXPECT_TRUE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_NE(c.value, nullptr);
	ASSERT_TRUE(c->Is<ast::BoolLiteral>());
	EXPECT_TRUE(c->As<ast::BoolLiteral>()->IsFalse());
	EXPECT_EQ(c->source().range, (Source::Range{{1u, 1u}, {1u, 6u}}));
	}

	TEST_F(ParserImplTest, ConstLiteral_NoMatch) {
	auto p = parser("another-token");
	auto c = p->const_literal();
	EXPECT_FALSE(c.matched);
	EXPECT_FALSE(c.errored);
	EXPECT_FALSE(p->has_error()) << p->error();
	ASSERT_EQ(c.value, nullptr);
	}

	} // namespace
	} // namespace wgsl
	} // namespace reader
	} // namespace tint