aboutsummaryrefslogtreecommitdiff
path: root/test/parse_number_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/parse_number_test.cpp')
-rw-r--r--test/parse_number_test.cpp970
1 files changed, 970 insertions, 0 deletions
diff --git a/test/parse_number_test.cpp b/test/parse_number_test.cpp
new file mode 100644
index 00000000..9c8850b4
--- /dev/null
+++ b/test/parse_number_test.cpp
@@ -0,0 +1,970 @@
+// Copyright (c) 2015-2016 The Khronos Group Inc.
+//
+// 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 <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "source/util/parse_number.h"
+#include "spirv-tools/libspirv.h"
+
+namespace {
+using spvutils::NumberType;
+using spvutils::EncodeNumberStatus;
+using spvutils::ParseNumber;
+using spvutils::ParseAndEncodeIntegerNumber;
+using spvutils::ParseAndEncodeFloatingPointNumber;
+using spvutils::ParseAndEncodeNumber;
+using testing::Eq;
+using testing::IsNull;
+using testing::NotNull;
+
+TEST(ParseNarrowSignedIntegers, Sample) {
+ int16_t i16;
+
+ EXPECT_FALSE(ParseNumber(nullptr, &i16));
+ EXPECT_FALSE(ParseNumber("", &i16));
+ EXPECT_FALSE(ParseNumber("0=", &i16));
+
+ EXPECT_TRUE(ParseNumber("0", &i16));
+ EXPECT_EQ(0, i16);
+ EXPECT_TRUE(ParseNumber("32767", &i16));
+ EXPECT_EQ(32767, i16);
+ EXPECT_TRUE(ParseNumber("-32768", &i16));
+ EXPECT_EQ(-32768, i16);
+ EXPECT_TRUE(ParseNumber("-0", &i16));
+ EXPECT_EQ(0, i16);
+
+ // These are out of range, so they should return an error.
+ // The error code depends on whether this is an optional value.
+ EXPECT_FALSE(ParseNumber("32768", &i16));
+ EXPECT_FALSE(ParseNumber("65535", &i16));
+
+ // Check hex parsing.
+ EXPECT_TRUE(ParseNumber("0x7fff", &i16));
+ EXPECT_EQ(32767, i16);
+ // This is out of range.
+ EXPECT_FALSE(ParseNumber("0xffff", &i16));
+}
+
+TEST(ParseNarrowUnsignedIntegers, Sample) {
+ uint16_t u16;
+
+ EXPECT_FALSE(ParseNumber(nullptr, &u16));
+ EXPECT_FALSE(ParseNumber("", &u16));
+ EXPECT_FALSE(ParseNumber("0=", &u16));
+
+ EXPECT_TRUE(ParseNumber("0", &u16));
+ EXPECT_EQ(0, u16);
+ EXPECT_TRUE(ParseNumber("65535", &u16));
+ EXPECT_EQ(65535, u16);
+ EXPECT_FALSE(ParseNumber("65536", &u16));
+
+ // We don't care about -0 since it's rejected at a higher level.
+ EXPECT_FALSE(ParseNumber("-1", &u16));
+ EXPECT_TRUE(ParseNumber("0xffff", &u16));
+ EXPECT_EQ(0xffff, u16);
+ EXPECT_FALSE(ParseNumber("0x10000", &u16));
+}
+
+TEST(ParseSignedIntegers, Sample) {
+ int32_t i32;
+
+ // Invalid parse.
+ EXPECT_FALSE(ParseNumber(nullptr, &i32));
+ EXPECT_FALSE(ParseNumber("", &i32));
+ EXPECT_FALSE(ParseNumber("0=", &i32));
+
+ // Decimal values.
+ EXPECT_TRUE(ParseNumber("0", &i32));
+ EXPECT_EQ(0, i32);
+ EXPECT_TRUE(ParseNumber("2147483647", &i32));
+ EXPECT_EQ(std::numeric_limits<int32_t>::max(), i32);
+ EXPECT_FALSE(ParseNumber("2147483648", &i32));
+ EXPECT_TRUE(ParseNumber("-0", &i32));
+ EXPECT_EQ(0, i32);
+ EXPECT_TRUE(ParseNumber("-1", &i32));
+ EXPECT_EQ(-1, i32);
+ EXPECT_TRUE(ParseNumber("-2147483648", &i32));
+ EXPECT_EQ(std::numeric_limits<int32_t>::min(), i32);
+
+ // Hex values.
+ EXPECT_TRUE(ParseNumber("0x7fffffff", &i32));
+ EXPECT_EQ(std::numeric_limits<int32_t>::max(), i32);
+ EXPECT_FALSE(ParseNumber("0x80000000", &i32));
+ EXPECT_TRUE(ParseNumber("-0x000", &i32));
+ EXPECT_EQ(0, i32);
+ EXPECT_TRUE(ParseNumber("-0x001", &i32));
+ EXPECT_EQ(-1, i32);
+ EXPECT_TRUE(ParseNumber("-0x80000000", &i32));
+ EXPECT_EQ(std::numeric_limits<int32_t>::min(), i32);
+}
+
+TEST(ParseUnsignedIntegers, Sample) {
+ uint32_t u32;
+
+ // Invalid parse.
+ EXPECT_FALSE(ParseNumber(nullptr, &u32));
+ EXPECT_FALSE(ParseNumber("", &u32));
+ EXPECT_FALSE(ParseNumber("0=", &u32));
+
+ // Valid values.
+ EXPECT_TRUE(ParseNumber("0", &u32));
+ EXPECT_EQ(0u, u32);
+ EXPECT_TRUE(ParseNumber("4294967295", &u32));
+ EXPECT_EQ(std::numeric_limits<uint32_t>::max(), u32);
+ EXPECT_FALSE(ParseNumber("4294967296", &u32));
+
+ // Hex values.
+ EXPECT_TRUE(ParseNumber("0xffffffff", &u32));
+ EXPECT_EQ(std::numeric_limits<uint32_t>::max(), u32);
+
+ // We don't care about -0 since it's rejected at a higher level.
+ EXPECT_FALSE(ParseNumber("-1", &u32));
+}
+
+TEST(ParseWideSignedIntegers, Sample) {
+ int64_t i64;
+ EXPECT_FALSE(ParseNumber(nullptr, &i64));
+ EXPECT_FALSE(ParseNumber("", &i64));
+ EXPECT_FALSE(ParseNumber("0=", &i64));
+ EXPECT_TRUE(ParseNumber("0", &i64));
+ EXPECT_EQ(0, i64);
+ EXPECT_TRUE(ParseNumber("0x7fffffffffffffff", &i64));
+ EXPECT_EQ(0x7fffffffffffffff, i64);
+ EXPECT_TRUE(ParseNumber("-0", &i64));
+ EXPECT_EQ(0, i64);
+ EXPECT_TRUE(ParseNumber("-1", &i64));
+ EXPECT_EQ(-1, i64);
+}
+
+TEST(ParseWideUnsignedIntegers, Sample) {
+ uint64_t u64;
+ EXPECT_FALSE(ParseNumber(nullptr, &u64));
+ EXPECT_FALSE(ParseNumber("", &u64));
+ EXPECT_FALSE(ParseNumber("0=", &u64));
+ EXPECT_TRUE(ParseNumber("0", &u64));
+ EXPECT_EQ(0u, u64);
+ EXPECT_TRUE(ParseNumber("0xffffffffffffffff", &u64));
+ EXPECT_EQ(0xffffffffffffffffULL, u64);
+
+ // We don't care about -0 since it's rejected at a higher level.
+ EXPECT_FALSE(ParseNumber("-1", &u64));
+}
+
+TEST(ParseFloat, Sample) {
+ float f;
+
+ EXPECT_FALSE(ParseNumber(nullptr, &f));
+ EXPECT_FALSE(ParseNumber("", &f));
+ EXPECT_FALSE(ParseNumber("0=", &f));
+
+ // These values are exactly representatble.
+ EXPECT_TRUE(ParseNumber("0", &f));
+ EXPECT_EQ(0.0f, f);
+ EXPECT_TRUE(ParseNumber("42", &f));
+ EXPECT_EQ(42.0f, f);
+ EXPECT_TRUE(ParseNumber("2.5", &f));
+ EXPECT_EQ(2.5f, f);
+ EXPECT_TRUE(ParseNumber("-32.5", &f));
+ EXPECT_EQ(-32.5f, f);
+ EXPECT_TRUE(ParseNumber("1e38", &f));
+ EXPECT_EQ(1e38f, f);
+ EXPECT_TRUE(ParseNumber("-1e38", &f));
+ EXPECT_EQ(-1e38f, f);
+}
+
+TEST(ParseFloat, Overflow) {
+ // The assembler parses using HexFloat<FloatProxy<float>>. Make
+ // sure that succeeds for in-range values, and fails for out of
+ // range values. When it does overflow, the value is set to the
+ // nearest finite value, matching C++11 behavior for operator>>
+ // on floating point.
+ spvutils::HexFloat<spvutils::FloatProxy<float>> f(0.0f);
+
+ EXPECT_TRUE(ParseNumber("1e38", &f));
+ EXPECT_EQ(1e38f, f.value().getAsFloat());
+ EXPECT_TRUE(ParseNumber("-1e38", &f));
+ EXPECT_EQ(-1e38f, f.value().getAsFloat());
+ EXPECT_FALSE(ParseNumber("1e40", &f));
+ EXPECT_FALSE(ParseNumber("-1e40", &f));
+ EXPECT_FALSE(ParseNumber("1e400", &f));
+ EXPECT_FALSE(ParseNumber("-1e400", &f));
+}
+
+TEST(ParseDouble, Sample) {
+ double f;
+
+ EXPECT_FALSE(ParseNumber(nullptr, &f));
+ EXPECT_FALSE(ParseNumber("", &f));
+ EXPECT_FALSE(ParseNumber("0=", &f));
+
+ // These values are exactly representatble.
+ EXPECT_TRUE(ParseNumber("0", &f));
+ EXPECT_EQ(0.0, f);
+ EXPECT_TRUE(ParseNumber("42", &f));
+ EXPECT_EQ(42.0, f);
+ EXPECT_TRUE(ParseNumber("2.5", &f));
+ EXPECT_EQ(2.5, f);
+ EXPECT_TRUE(ParseNumber("-32.5", &f));
+ EXPECT_EQ(-32.5, f);
+ EXPECT_TRUE(ParseNumber("1e38", &f));
+ EXPECT_EQ(1e38, f);
+ EXPECT_TRUE(ParseNumber("-1e38", &f));
+ EXPECT_EQ(-1e38, f);
+ // These are out of range for 32-bit float, but in range for 64-bit float.
+ EXPECT_TRUE(ParseNumber("1e40", &f));
+ EXPECT_EQ(1e40, f);
+ EXPECT_TRUE(ParseNumber("-1e40", &f));
+ EXPECT_EQ(-1e40, f);
+}
+
+TEST(ParseDouble, Overflow) {
+ // The assembler parses using HexFloat<FloatProxy<double>>. Make
+ // sure that succeeds for in-range values, and fails for out of
+ // range values. When it does overflow, the value is set to the
+ // nearest finite value, matching C++11 behavior for operator>>
+ // on floating point.
+ spvutils::HexFloat<spvutils::FloatProxy<double>> f(0.0);
+
+ EXPECT_TRUE(ParseNumber("1e38", &f));
+ EXPECT_EQ(1e38, f.value().getAsFloat());
+ EXPECT_TRUE(ParseNumber("-1e38", &f));
+ EXPECT_EQ(-1e38, f.value().getAsFloat());
+ EXPECT_TRUE(ParseNumber("1e40", &f));
+ EXPECT_EQ(1e40, f.value().getAsFloat());
+ EXPECT_TRUE(ParseNumber("-1e40", &f));
+ EXPECT_EQ(-1e40, f.value().getAsFloat());
+ EXPECT_FALSE(ParseNumber("1e400", &f));
+ EXPECT_FALSE(ParseNumber("-1e400", &f));
+}
+
+TEST(ParseFloat16, Overflow) {
+ // The assembler parses using HexFloat<FloatProxy<Float16>>. Make
+ // sure that succeeds for in-range values, and fails for out of
+ // range values. When it does overflow, the value is set to the
+ // nearest finite value, matching C++11 behavior for operator>>
+ // on floating point.
+ spvutils::HexFloat<spvutils::FloatProxy<spvutils::Float16>> f(0);
+
+ EXPECT_FALSE(ParseNumber(nullptr, &f));
+ EXPECT_TRUE(ParseNumber("-0.0", &f));
+ EXPECT_EQ(uint16_t{0x8000}, f.value().getAsFloat().get_value());
+ EXPECT_TRUE(ParseNumber("1.0", &f));
+ EXPECT_EQ(uint16_t{0x3c00}, f.value().getAsFloat().get_value());
+
+ // Overflows 16-bit but not 32-bit
+ EXPECT_FALSE(ParseNumber("1e38", &f));
+ EXPECT_FALSE(ParseNumber("-1e38", &f));
+
+ // Overflows 32-bit but not 64-bit
+ EXPECT_FALSE(ParseNumber("1e40", &f));
+ EXPECT_FALSE(ParseNumber("-1e40", &f));
+
+ // Overflows 64-bit
+ EXPECT_FALSE(ParseNumber("1e400", &f));
+ EXPECT_FALSE(ParseNumber("-1e400", &f));
+}
+
+void AssertEmitFunc(uint32_t) {
+ ASSERT_FALSE(true)
+ << "Should not call emit() function when the number can not be parsed.";
+ return;
+}
+
+TEST(ParseAndEncodeNarrowSignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {16, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid signed integer literal: -", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+}
+
+TEST(ParseAndEncodeNarrowSignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {16, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber("32768", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer 32768 does not fit in a 16-bit signed integer", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-32769", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer -32769 does not fit in a 16-bit signed integer", err_msg);
+}
+
+TEST(ParseAndEncodeNarrowSignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {16, SPV_NUMBER_SIGNED_INT};
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber(
+ "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "-0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "32767", type, [](uint32_t word) { EXPECT_EQ(0x00007fffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "-32768", type, [](uint32_t word) { EXPECT_EQ(0xffff8000u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber(
+ "0x7fff", type, [](uint32_t word) { EXPECT_EQ(0x00007fffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "0xffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+}
+
+TEST(ParseAndEncodeNarrowUnsignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {16, SPV_NUMBER_UNSIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+}
+
+TEST(ParseAndEncodeNarrowUnsignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg("random content");
+ NumberType type = {16, SPV_NUMBER_UNSIGNED_INT};
+
+ // Overflow
+ rc = ParseAndEncodeIntegerNumber("65536", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer 65536 does not fit in a 16-bit unsigned integer", err_msg);
+}
+
+TEST(ParseAndEncodeNarrowUnsignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {16, SPV_NUMBER_UNSIGNED_INT};
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber(
+ "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "65535", type, [](uint32_t word) { EXPECT_EQ(0x0000ffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber(
+ "0xffff", type, [](uint32_t word) { EXPECT_EQ(0x0000ffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+}
+
+TEST(ParseAndEncodeSignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid signed integer literal: -", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+}
+
+TEST(ParseAndEncodeSignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ rc =
+ ParseAndEncodeIntegerNumber("2147483648", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer 2147483648 does not fit in a 32-bit signed integer",
+ err_msg);
+ rc = ParseAndEncodeIntegerNumber("-2147483649", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer -2147483649 does not fit in a 32-bit signed integer",
+ err_msg);
+}
+
+TEST(ParseAndEncodeSignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber(
+ "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "-0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "2147483647", type, [](uint32_t word) { EXPECT_EQ(0x7fffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "-2147483648", type, [](uint32_t word) { EXPECT_EQ(0x80000000u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber(
+ "0x7fffffff", type, [](uint32_t word) { EXPECT_EQ(0x7fffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "0xffffffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+}
+
+TEST(ParseAndEncodeUnsignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_UNSIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+}
+
+TEST(ParseAndEncodeUnsignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg("random content");
+ NumberType type = {32, SPV_NUMBER_UNSIGNED_INT};
+
+ // Overflow
+ rc =
+ ParseAndEncodeIntegerNumber("4294967296", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Integer 4294967296 does not fit in a 32-bit unsigned integer",
+ err_msg);
+}
+
+TEST(ParseAndEncodeUnsignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {32, SPV_NUMBER_UNSIGNED_INT};
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber(
+ "0", type, [](uint32_t word) { EXPECT_EQ(0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeIntegerNumber(
+ "4294967295", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber(
+ "0xffffffff", type, [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+}
+
+TEST(ParseAndEncodeWideSignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {64, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid signed integer literal: -", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+}
+
+TEST(ParseAndEncodeWideSignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {64, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber("9223372036854775808", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ(
+ "Integer 9223372036854775808 does not fit in a 64-bit signed integer",
+ err_msg);
+ rc = ParseAndEncodeIntegerNumber("-9223372036854775809", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid signed integer literal: -9223372036854775809", err_msg);
+}
+
+TEST(ParseAndEncodeWideSignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {64, SPV_NUMBER_SIGNED_INT};
+ std::vector<uint32_t> word_buffer;
+ auto emit = [&word_buffer](uint32_t word) {
+ if (word_buffer.size() == 2) word_buffer.clear();
+ word_buffer.push_back(word);
+ };
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber("0", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0u}));
+ rc = ParseAndEncodeIntegerNumber("-0", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0u}));
+ rc = ParseAndEncodeIntegerNumber("9223372036854775807", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0x7fffffffu}));
+ rc = ParseAndEncodeIntegerNumber("-9223372036854775808", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0x80000000u}));
+ rc = ParseAndEncodeIntegerNumber("-1", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0xffffffffu}));
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber("0x7fffffffffffffff", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0x7fffffffu}));
+ rc = ParseAndEncodeIntegerNumber("0xffffffffffffffff", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0xffffffffu}));
+}
+
+TEST(ParseAndEncodeWideUnsignedIntegers, Invalid) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {64, SPV_NUMBER_UNSIGNED_INT};
+
+ // Invalid
+ rc = ParseAndEncodeIntegerNumber(nullptr, type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("The given text is a nullptr", err_msg);
+ rc = ParseAndEncodeIntegerNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: ", err_msg);
+ rc = ParseAndEncodeIntegerNumber("=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: =", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 0=", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-0", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+ rc = ParseAndEncodeIntegerNumber("-1", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("Cannot put a negative number in an unsigned literal", err_msg);
+}
+
+TEST(ParseAndEncodeWideUnsignedIntegers, Overflow) {
+ // The error message should be overwritten after each parsing call.
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {64, SPV_NUMBER_UNSIGNED_INT};
+
+ // Overflow
+ rc = ParseAndEncodeIntegerNumber("18446744073709551616", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: 18446744073709551616", err_msg);
+}
+
+TEST(ParseAndEncodeWideUnsignedIntegers, Success) {
+ // Don't care the error message in this case.
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ NumberType type = {64, SPV_NUMBER_UNSIGNED_INT};
+ std::vector<uint32_t> word_buffer;
+ auto emit = [&word_buffer](uint32_t word) {
+ if (word_buffer.size() == 2) word_buffer.clear();
+ word_buffer.push_back(word);
+ };
+
+ // Zero, maximum, and minimum value
+ rc = ParseAndEncodeIntegerNumber("0", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0u}));
+ rc = ParseAndEncodeIntegerNumber("18446744073709551615", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0xffffffffu}));
+
+ // Hex parsing
+ rc = ParseAndEncodeIntegerNumber("0xffffffffffffffff", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xffffffffu, 0xffffffffu}));
+}
+
+TEST(ParseAndEncodeIntegerNumber, TypeNone) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_NONE};
+
+ rc = ParseAndEncodeIntegerNumber(
+ "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("The expected type is not a integer type", err_msg);
+}
+
+TEST(ParseAndEncodeIntegerNumber, InvalidCaseWithoutErrorMessageString) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber("invalid", type, AssertEmitFunc, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+}
+
+TEST(ParseAndEncodeIntegerNumber, DoNotTouchErrorMessageStringOnSuccess) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ std::string err_msg("random content");
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ rc = ParseAndEncodeIntegerNumber(
+ "100", type, [](uint32_t word) { EXPECT_EQ(100u, word); }, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_EQ("random content", err_msg);
+}
+
+TEST(ParseAndEncodeFloat, Sample) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_FLOATING};
+
+ // Invalid
+ rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: ", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: 0=", err_msg);
+
+ // Representative samples
+ rc = ParseAndEncodeFloatingPointNumber(
+ "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "-0.0", type, [](uint32_t word) { EXPECT_EQ(0x80000000u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "42", type, [](uint32_t word) { EXPECT_EQ(0x42280000u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "2.5", type, [](uint32_t word) { EXPECT_EQ(0x40200000u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "-32.5", type, [](uint32_t word) { EXPECT_EQ(0xc2020000u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "1e38", type, [](uint32_t word) { EXPECT_EQ(0x7e967699u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "-1e38", type, [](uint32_t word) { EXPECT_EQ(0xfe967699u, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Overflow
+ rc =
+ ParseAndEncodeFloatingPointNumber("1e40", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: 1e40", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e40", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: -1e40", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: 1e400", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 32-bit float literal: -1e400", err_msg);
+}
+
+TEST(ParseAndEncodeDouble, Sample) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {64, SPV_NUMBER_FLOATING};
+ std::vector<uint32_t> word_buffer;
+ auto emit = [&word_buffer](uint32_t word) {
+ if (word_buffer.size() == 2) word_buffer.clear();
+ word_buffer.push_back(word);
+ };
+
+ // Invalid
+ rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 64-bit float literal: ", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 64-bit float literal: 0=", err_msg);
+
+ // Representative samples
+ rc = ParseAndEncodeFloatingPointNumber("0.0", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0u}));
+ rc = ParseAndEncodeFloatingPointNumber("-0.0", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0x80000000u}));
+ rc = ParseAndEncodeFloatingPointNumber("42", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0x40450000u}));
+ rc = ParseAndEncodeFloatingPointNumber("2.5", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0x40040000u}));
+ rc = ParseAndEncodeFloatingPointNumber("32.5", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0u, 0x40404000u}));
+ rc = ParseAndEncodeFloatingPointNumber("1e38", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0x2a16a1b1u, 0x47d2ced3u}));
+ rc = ParseAndEncodeFloatingPointNumber("-1e38", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0x2a16a1b1u, 0xc7d2ced3u}));
+ rc = ParseAndEncodeFloatingPointNumber("1e40", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xf1c35ca5u, 0x483d6329u}));
+ rc = ParseAndEncodeFloatingPointNumber("-1e40", type, emit, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_THAT(word_buffer, Eq(std::vector<uint32_t>{0xf1c35ca5u, 0xc83d6329u}));
+
+ // Overflow
+ rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 64-bit float literal: 1e400", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 64-bit float literal: -1e400", err_msg);
+}
+
+TEST(ParseAndEncodeFloat16, Sample) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {16, SPV_NUMBER_FLOATING};
+
+ // Invalid
+ rc = ParseAndEncodeFloatingPointNumber("", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: ", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("0=", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: 0=", err_msg);
+
+ // Representative samples
+ rc = ParseAndEncodeFloatingPointNumber(
+ "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "-0.0", type, [](uint32_t word) { EXPECT_EQ(0x8000u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "1.0", type, [](uint32_t word) { EXPECT_EQ(0x3c00u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "2.5", type, [](uint32_t word) { EXPECT_EQ(0x4100u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ rc = ParseAndEncodeFloatingPointNumber(
+ "32.5", type, [](uint32_t word) { EXPECT_EQ(0x5010u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Overflow
+ rc =
+ ParseAndEncodeFloatingPointNumber("1e38", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: 1e38", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e38", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: -1e38", err_msg);
+ rc =
+ ParseAndEncodeFloatingPointNumber("1e40", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: 1e40", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e40", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: -1e40", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: 1e400", err_msg);
+ rc = ParseAndEncodeFloatingPointNumber("-1e400", type, AssertEmitFunc,
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid 16-bit float literal: -1e400", err_msg);
+}
+
+TEST(ParseAndEncodeFloatingPointNumber, TypeNone) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_NONE};
+
+ rc = ParseAndEncodeFloatingPointNumber(
+ "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidUsage, rc);
+ EXPECT_EQ("The expected type is not a float type", err_msg);
+}
+
+TEST(ParseAndEncodeFloatingPointNumber, InvalidCaseWithoutErrorMessageString) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ NumberType type = {32, SPV_NUMBER_FLOATING};
+
+ rc = ParseAndEncodeFloatingPointNumber("invalid", type, AssertEmitFunc,
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+}
+
+TEST(ParseAndEncodeFloatingPointNumber, DoNotTouchErrorMessageStringOnSuccess) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kInvalidText;
+ std::string err_msg("random content");
+ NumberType type = {32, SPV_NUMBER_FLOATING};
+
+ rc = ParseAndEncodeFloatingPointNumber(
+ "0.0", type, [](uint32_t word) { EXPECT_EQ(0x0u, word); }, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_EQ("random content", err_msg);
+}
+
+TEST(ParseAndEncodeNumber, Sample) {
+ EncodeNumberStatus rc = EncodeNumberStatus::kSuccess;
+ std::string err_msg;
+ NumberType type = {32, SPV_NUMBER_SIGNED_INT};
+
+ // Invalid with error message string
+ rc = ParseAndEncodeNumber("something wrong", type, AssertEmitFunc, &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+ EXPECT_EQ("Invalid unsigned integer literal: something wrong", err_msg);
+
+ // Invalid without error message string
+ rc = ParseAndEncodeNumber("something wrong", type, AssertEmitFunc, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kInvalidText, rc);
+
+ // Signed integer, should not touch the error message string.
+ err_msg = "random content";
+ rc = ParseAndEncodeNumber("-1", type,
+ [](uint32_t word) { EXPECT_EQ(0xffffffffu, word); },
+ &err_msg);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+ EXPECT_EQ("random content", err_msg);
+
+ // Unsigned integer
+ type = {32, SPV_NUMBER_UNSIGNED_INT};
+ rc = ParseAndEncodeNumber(
+ "1", type, [](uint32_t word) { EXPECT_EQ(1u, word); }, nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+
+ // Float
+ type = {32, SPV_NUMBER_FLOATING};
+ rc = ParseAndEncodeNumber("-1.0", type,
+ [](uint32_t word) { EXPECT_EQ(0xbf800000, word); },
+ nullptr);
+ EXPECT_EQ(EncodeNumberStatus::kSuccess, rc);
+}
+
+} // anonymous namespace