AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-12-29 03:01:08 +00:00
Code Issues Packages Projects Releases Wiki Activity
1f3fb506e8
SPIRV-Tools/test/ParseNumber.cpp
qining 5ac63523d7 Guard against nullptr in number parsing utilities 
ParseNumber(): Returns false if the given string is a nullptr.
ParseAndEncodeXXXX(): Returns kInvalidText and populate error message:
  "The given text is a nullptr", if the givne string is a nullptr.
2016-09-13 12:12:31 -04:00

971 lines
40 KiB
C++
Raw Blame History

// 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
Reference in New Issue View Git Blame Copy Permalink