| /* |
| * Copyright 2018 WebAssembly Community Group participants |
| * |
| * 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 <cassert> |
| #include <cstdio> |
| #include <thread> |
| #include <vector> |
| |
| #include "gtest/gtest.h" |
| |
| #include "wabt/literal.h" |
| |
| using namespace wabt; |
| |
| namespace { |
| |
| enum ParseIntTypeCombo { |
| UnsignedOnly, |
| SignedAndUnsigned, |
| Both, |
| }; |
| |
| template <typename T> |
| void AssertIntEquals( |
| T expected, |
| const char* s, |
| Result (*parse_int)(const char*, const char*, T*, ParseIntType), |
| ParseIntTypeCombo parse_type = Both) { |
| const char* const end = s + strlen(s); |
| T actual; |
| if (parse_type == UnsignedOnly || parse_type == Both) { |
| ASSERT_EQ(Result::Ok, |
| parse_int(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| ASSERT_EQ(expected, actual); |
| } else { |
| ASSERT_EQ(Result::Error, |
| parse_int(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| } |
| |
| if (parse_type == SignedAndUnsigned || parse_type == Both) { |
| ASSERT_EQ(Result::Ok, |
| parse_int(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| ASSERT_EQ(expected, actual); |
| } else { |
| ASSERT_EQ(Result::Error, |
| parse_int(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| } |
| } |
| |
| void AssertInt8Equals(uint8_t expected, |
| const char* s, |
| ParseIntTypeCombo parse_type = Both) { |
| AssertIntEquals(expected, s, ParseInt8, parse_type); |
| } |
| |
| void AssertInt16Equals(uint16_t expected, |
| const char* s, |
| ParseIntTypeCombo parse_type = Both) { |
| AssertIntEquals(expected, s, ParseInt16, parse_type); |
| } |
| |
| void AssertInt32Equals(uint32_t expected, |
| const char* s, |
| ParseIntTypeCombo parse_type = Both) { |
| AssertIntEquals(expected, s, ParseInt32, parse_type); |
| } |
| |
| void AssertInt64Equals(uint64_t expected, |
| const char* s, |
| ParseIntTypeCombo parse_type = Both) { |
| AssertIntEquals(expected, s, ParseInt64, parse_type); |
| } |
| |
| void AssertUint128Equals(v128 expected, const char* s) { |
| const char* const end = s + strlen(s); |
| v128 actual; |
| ASSERT_EQ(Result::Ok, ParseUint128(s, end, &actual)) << s; |
| ASSERT_EQ(expected, actual); |
| } |
| |
| void AssertInt8Fails(const char* s) { |
| const char* const end = s + strlen(s); |
| uint8_t actual; |
| ASSERT_EQ(Result::Error, |
| ParseInt8(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| ASSERT_EQ(Result::Error, |
| ParseInt8(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| } |
| |
| void AssertInt16Fails(const char* s) { |
| const char* const end = s + strlen(s); |
| uint16_t actual; |
| ASSERT_EQ(Result::Error, |
| ParseInt16(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| ASSERT_EQ(Result::Error, |
| ParseInt16(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| } |
| |
| void AssertInt32Fails(const char* s) { |
| const char* const end = s + strlen(s); |
| uint32_t actual; |
| ASSERT_EQ(Result::Error, |
| ParseInt32(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| ASSERT_EQ(Result::Error, |
| ParseInt32(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| } |
| |
| void AssertInt64Fails(const char* s) { |
| const char* const end = s + strlen(s); |
| uint64_t actual; |
| ASSERT_EQ(Result::Error, |
| ParseInt64(s, end, &actual, ParseIntType::SignedAndUnsigned)) |
| << s; |
| ASSERT_EQ(Result::Error, |
| ParseInt64(s, end, &actual, ParseIntType::UnsignedOnly)) |
| << s; |
| } |
| |
| void AssertUint64Equals(uint64_t expected, const char* s) { |
| uint64_t actual; |
| ASSERT_EQ(Result::Ok, ParseUint64(s, s + strlen(s), &actual)) << s; |
| ASSERT_EQ(expected, actual); |
| } |
| |
| void AssertUint64Fails(const char* s) { |
| uint64_t actual_bits; |
| ASSERT_EQ(Result::Error, ParseUint64(s, s + strlen(s), &actual_bits)) << s; |
| } |
| |
| void AssertUint128Fails(const char* s) { |
| v128 actual; |
| ASSERT_EQ(Result::Error, ParseUint128(s, s + strlen(s), &actual)) << s; |
| } |
| |
| void AssertHexFloatEquals(uint32_t expected_bits, const char* s) { |
| uint32_t actual_bits; |
| ASSERT_EQ(Result::Ok, |
| ParseFloat(LiteralType::Hexfloat, s, s + strlen(s), &actual_bits)) |
| << s; |
| ASSERT_EQ(expected_bits, actual_bits) << s; |
| } |
| |
| void AssertHexFloatFails(const char* s) { |
| uint32_t actual_bits; |
| ASSERT_EQ(Result::Error, |
| ParseFloat(LiteralType::Hexfloat, s, s + strlen(s), &actual_bits)) |
| << s; |
| } |
| |
| void AssertHexDoubleEquals(uint64_t expected_bits, const char* s) { |
| uint64_t actual_bits; |
| ASSERT_EQ(Result::Ok, |
| ParseDouble(LiteralType::Hexfloat, s, s + strlen(s), &actual_bits)) |
| << s; |
| ASSERT_EQ(expected_bits, actual_bits); |
| } |
| |
| void AssertHexDoubleFails(const char* s) { |
| uint64_t actual_bits; |
| ASSERT_EQ(Result::Error, |
| ParseDouble(LiteralType::Hexfloat, s, s + strlen(s), &actual_bits)) |
| << s; |
| } |
| |
| } // end anonymous namespace |
| |
| TEST(ParseInt8, Both) { |
| AssertInt8Equals(0, "0"); |
| AssertInt8Equals(100, "100"); |
| AssertInt8Equals(123, "123"); |
| AssertInt8Equals(127, "127"); |
| AssertInt8Equals(255, "255"); |
| AssertInt8Equals(0xca, "0xca"); |
| AssertInt8Equals(0x7f, "0x7f"); |
| AssertInt8Equals(0x80, "0x80"); |
| AssertInt8Equals(0xff, "0xff"); |
| } |
| |
| TEST(ParseInt8, SignedAndUnsigned) { |
| AssertInt8Equals(128, "-128", SignedAndUnsigned); |
| AssertInt8Equals(-0x80, "-0x80", SignedAndUnsigned); |
| AssertInt8Equals(255, "-1", SignedAndUnsigned); |
| AssertInt8Equals(-1, "-0x1", SignedAndUnsigned); |
| AssertInt8Equals(1, "+1", SignedAndUnsigned); |
| AssertInt8Equals(-0x7b, "-0x7B", SignedAndUnsigned); |
| AssertInt8Equals(0xab, "+0xab", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt8, Invalid) { |
| AssertInt8Fails(""); |
| AssertInt8Fails("-100hello"); |
| AssertInt8Fails("0XAB"); |
| AssertInt8Fails("0xga"); |
| AssertInt8Fails("two"); |
| } |
| |
| TEST(ParseInt8, Underscores) { |
| AssertInt8Equals(123, "12_3", Both); |
| AssertInt8Equals(123, "+12_3", SignedAndUnsigned); |
| AssertInt8Equals(-123, "-1_23", SignedAndUnsigned); |
| AssertInt8Equals(19, "1______9", Both); |
| AssertInt8Equals(0xab, "0xa_b", Both); |
| AssertInt8Equals(0xab, "+0xa_b", SignedAndUnsigned); |
| AssertInt8Equals(-0x7b, "-0x7_b", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt8, Overflow) { |
| AssertInt8Fails("256"); |
| AssertInt8Fails("-129"); |
| AssertInt8Fails("0x100"); |
| AssertInt8Fails("-0x81"); |
| AssertInt8Fails("1231231231231231231231"); |
| } |
| |
| TEST(ParseInt16, Both) { |
| AssertInt16Equals(0, "0"); |
| AssertInt16Equals(1000, "1000"); |
| AssertInt16Equals(12345, "12345"); |
| AssertInt16Equals(32767, "32767"); |
| AssertInt16Equals(65535, "65535"); |
| AssertInt16Equals(0xcafe, "0xcafe"); |
| AssertInt16Equals(0x7fff, "0x7fff"); |
| AssertInt16Equals(0x8000, "0x8000"); |
| AssertInt16Equals(0xffff, "0xffff"); |
| } |
| |
| TEST(ParseInt16, SignedAndUnsigned) { |
| AssertInt16Equals(32768, "-32768", SignedAndUnsigned); |
| AssertInt16Equals(-0x8000, "-0x8000", SignedAndUnsigned); |
| AssertInt16Equals(65535, "-1", SignedAndUnsigned); |
| AssertInt16Equals(-1, "-0x1", SignedAndUnsigned); |
| AssertInt16Equals(1, "+1", SignedAndUnsigned); |
| AssertInt16Equals(-0x7bcd, "-0x7BCD", SignedAndUnsigned); |
| AssertInt16Equals(0xabcd, "+0xabcd", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt16, Invalid) { |
| AssertInt16Fails(""); |
| AssertInt16Fails("-100hello"); |
| AssertInt16Fails("0XABCD"); |
| AssertInt16Fails("0xgabb"); |
| AssertInt16Fails("two"); |
| } |
| |
| TEST(ParseInt16, Underscores) { |
| AssertInt16Equals(12345, "12_345", Both); |
| AssertInt16Equals(12345, "+12_345", SignedAndUnsigned); |
| AssertInt16Equals(-12345, "-123_45", SignedAndUnsigned); |
| AssertInt16Equals(19, "1______9", Both); |
| AssertInt16Equals(0xabcd, "0xa_b_c_d", Both); |
| AssertInt16Equals(0xabcd, "+0xa_b_c_d", SignedAndUnsigned); |
| AssertInt16Equals(-0x7bcd, "-0x7_b_c_d", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt16, Overflow) { |
| AssertInt16Fails("65536"); |
| AssertInt16Fails("-32769"); |
| AssertInt16Fails("0x10000"); |
| AssertInt16Fails("-0x8001"); |
| AssertInt16Fails("1231231231231231231231"); |
| } |
| |
| TEST(ParseInt32, Both) { |
| AssertInt32Equals(0, "0"); |
| AssertInt32Equals(1000, "1000"); |
| AssertInt32Equals(123456789, "123456789"); |
| AssertInt32Equals(2147483647, "2147483647"); |
| AssertInt32Equals(4294967295u, "4294967295"); |
| AssertInt32Equals(0xcafef00du, "0xcafef00d"); |
| AssertInt32Equals(0x7fffffff, "0x7fffffff"); |
| AssertInt32Equals(0x80000000u, "0x80000000"); |
| AssertInt32Equals(0xffffffffu, "0xffffffff"); |
| } |
| |
| TEST(ParseInt32, SignedAndUnsigned) { |
| AssertInt32Equals(2147483648, "-2147483648", SignedAndUnsigned); |
| AssertInt32Equals(-0x80000000ll, "-0x80000000", SignedAndUnsigned); |
| AssertInt32Equals(4294967295u, "-1", SignedAndUnsigned); |
| AssertInt32Equals(-1, "-0x1", SignedAndUnsigned); |
| AssertInt32Equals(1, "+1", SignedAndUnsigned); |
| AssertInt32Equals(-0xabcd, "-0xABCD", SignedAndUnsigned); |
| AssertInt32Equals(0xabcd, "+0xabcd", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt32, Invalid) { |
| AssertInt32Fails(""); |
| AssertInt32Fails("-100hello"); |
| AssertInt32Fails("0XABCDEF"); |
| AssertInt32Fails("0xgabba"); |
| AssertInt32Fails("two"); |
| } |
| |
| TEST(ParseInt32, Underscores) { |
| AssertInt32Equals(123456789, "12_345_6789", Both); |
| AssertInt32Equals(123456789, "+12_345_6789", SignedAndUnsigned); |
| AssertInt32Equals(-123456789, "-12345_6789", SignedAndUnsigned); |
| AssertInt32Equals(19, "1______9", Both); |
| AssertInt32Equals(0xabcd, "0xa_b_c_d", Both); |
| AssertInt32Equals(0xabcd, "+0xa_b_c_d", SignedAndUnsigned); |
| AssertInt32Equals(-0xabcd, "-0xa_b_c_d", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt32, Overflow) { |
| AssertInt32Fails("4294967296"); |
| AssertInt32Fails("-2147483649"); |
| AssertInt32Fails("0x100000000"); |
| AssertInt32Fails("-0x80000001"); |
| AssertInt32Fails("1231231231231231231231"); |
| } |
| |
| TEST(ParseInt64, Both) { |
| AssertInt64Equals(0, "0"); |
| AssertInt64Equals(1000, "1000"); |
| AssertInt64Equals(123456789, "123456789"); |
| AssertInt64Equals(9223372036854775807ull, "9223372036854775807"); |
| AssertInt64Equals(18446744073709551615ull, "18446744073709551615"); |
| AssertInt64Equals(0x7fffffffffffffffull, "0x7fffffffffffffff"); |
| AssertInt64Equals(0x8000000000000000ull, "0x8000000000000000"); |
| AssertInt64Equals(0xffffffffffffffffull, "0xffffffffffffffff"); |
| } |
| |
| TEST(ParseInt64, SignedAndUnsigned) { |
| AssertInt64Equals(9223372036854775808ull, "-9223372036854775808", |
| SignedAndUnsigned); |
| AssertInt64Equals(18446744073709551615ull, "-1", SignedAndUnsigned); |
| AssertInt64Equals(-1, "-0x1", SignedAndUnsigned); |
| AssertInt64Equals(1, "+1", SignedAndUnsigned); |
| AssertInt64Equals(-0x0bcdefabcdefabcdll, "-0x0BCDEFABCDEFABCD", |
| SignedAndUnsigned); |
| AssertInt64Equals(0xabcdefabcdefabcdll, "+0xabcdefabcdefabcd", |
| SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt64, Invalid) { |
| AssertInt64Fails(""); |
| AssertInt64Fails("-100hello"); |
| AssertInt64Fails("0XABCDEF"); |
| AssertInt64Fails("0xgabba"); |
| AssertInt64Fails("two"); |
| } |
| |
| TEST(ParseInt64, Underscores) { |
| AssertInt64Equals(123456789, "12_345_6789", Both); |
| AssertInt64Equals(123456789, "+12_345_6789", SignedAndUnsigned); |
| AssertInt64Equals(-123456789, "-12345_6789", SignedAndUnsigned); |
| AssertInt64Equals(19, "1______9", Both); |
| AssertInt64Equals(0xabcd, "0xa_b_c_d", Both); |
| AssertInt64Equals(0xabcd, "+0xa_b_c_d", SignedAndUnsigned); |
| AssertInt64Equals(-0xabcd, "-0xa_b_c_d", SignedAndUnsigned); |
| } |
| |
| TEST(ParseInt64, Overflow) { |
| AssertInt64Fails("18446744073709551616"); |
| AssertInt64Fails("-9223372036854775809"); |
| AssertInt32Fails("0x10000000000000000"); |
| AssertInt32Fails("-0x80000000000000001"); |
| AssertInt64Fails("1231231231231231231231"); |
| } |
| |
| TEST(ParseUint64, Basic) { |
| AssertUint64Equals(0, "0"); |
| AssertUint64Equals(1000, "1000"); |
| AssertUint64Equals(123456789, "123456789"); |
| AssertUint64Equals(1844674407370955161ull, "1844674407370955161"); |
| AssertUint64Equals(18446744073709551615ull, "18446744073709551615"); |
| |
| AssertUint64Equals(0, "0x0"); |
| AssertUint64Equals(0x1000, "0x1000"); |
| AssertUint64Equals(0x123456789, "0x123456789"); |
| AssertUint64Equals(0xabcdef, "0xabcdef"); |
| AssertUint64Equals(0xffffffffffffffull, "0xffffffffffffff"); |
| AssertUint64Equals(0xfffffffffffffffull, "0xfffffffffffffff"); |
| |
| AssertUint64Equals(0xabcdefabcdefabcdull, "0xabcdefabcdefabcd"); |
| } |
| |
| TEST(ParseUint64, NoOctal) { |
| AssertUint64Equals(100, "0100"); |
| AssertUint64Equals(888, "0000888"); |
| } |
| |
| TEST(ParseUint64, Invalid) { |
| AssertUint64Fails(""); |
| AssertUint64Fails("-100"); |
| AssertUint64Fails("0XABCDEF"); |
| AssertUint64Fails("0xgabba"); |
| AssertUint64Fails("two"); |
| } |
| |
| TEST(ParseUint64, Underscores) { |
| AssertUint64Equals(123456789, "12_345_6789"); |
| AssertUint64Equals(19, "1______9"); |
| AssertUint64Equals(0xabcd, "0xa_b_c_d"); |
| } |
| |
| TEST(ParseUint64, Overflow) { |
| AssertUint64Fails("0x10000000000000000"); |
| AssertUint64Fails("18446744073709551616"); |
| AssertUint64Fails("62857453058642199420"); |
| AssertUint64Fails("82000999361882825820"); |
| AssertUint64Fails("126539114687237086210"); |
| AssertUint64Fails("10000000000000000000000000000000000000000"); |
| } |
| |
| TEST(ParseUint128, Basic) { |
| AssertUint128Equals({0, 0, 0, 0}, "0"); |
| AssertUint128Equals({1, 0, 0, 0}, "1"); |
| AssertUint128Equals({0x100f0e0d, 0x0c0b0a09, 0x08070605, 0x04030201}, |
| "5332529520247008778714484145835150861"); |
| AssertUint128Equals({0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, |
| "340282366920938463463374607431768211455"); |
| AssertUint128Equals({0, 0, 1, 0}, "18446744073709551616"); |
| } |
| |
| TEST(ParseUint128, Invalid) { |
| AssertUint128Fails(""); |
| AssertUint128Fails("-1"); |
| AssertUint128Fails("340282366920938463463374607431768211456"); |
| AssertUint128Fails("123a456"); |
| } |
| |
| TEST(ParseFloat, NonCanonical) { |
| AssertHexFloatEquals(0x3f800000, "0x00000000000000000000001.0p0"); |
| AssertHexFloatEquals(0x3f800000, "0x1.00000000000000000000000p0"); |
| AssertHexFloatEquals(0x3f800000, "0x0.0000000000000000000001p88"); |
| } |
| |
| TEST(ParseFloat, Basic) { |
| AssertHexFloatEquals(0, "0x0p0"); |
| AssertHexFloatEquals(0x3f800000, "0x1"); |
| } |
| |
| TEST(ParseFloat, Rounding) { |
| // |------- 23 bits -----| V-- extra bit |
| // |
| // 11111111111111111111101 0 ==> no rounding |
| AssertHexFloatEquals(0x7f7ffffd, "0x1.fffffap127"); |
| // 11111111111111111111101 1 ==> round up |
| AssertHexFloatEquals(0x7f7ffffe, "0x1.fffffbp127"); |
| // 11111111111111111111110 0 ==> no rounding |
| AssertHexFloatEquals(0x7f7ffffe, "0x1.fffffcp127"); |
| // 11111111111111111111110 1 ==> round down |
| AssertHexFloatEquals(0x7f7ffffe, "0x1.fffffdp127"); |
| // 11111111111111111111111 0 ==> no rounding |
| AssertHexFloatEquals(0x7f7fffff, "0x1.fffffep127"); |
| } |
| |
| // Duplicate the spec tests here for easier debugging. |
| TEST(ParseFloat, RoundingSpec) { |
| static const struct { |
| const char* input; |
| uint32_t output; |
| } kTests[] = { |
| {"+0x1.00000100000000000p-50", 0x26800000}, |
| {"-0x1.00000100000000000p-50", 0xa6800000}, |
| {"+0x1.00000100000000001p-50", 0x26800001}, |
| {"-0x1.00000100000000001p-50", 0xa6800001}, |
| {"+0x1.000001fffffffffffp-50", 0x26800001}, |
| {"-0x1.000001fffffffffffp-50", 0xa6800001}, |
| {"+0x1.00000200000000000p-50", 0x26800001}, |
| {"-0x1.00000200000000000p-50", 0xa6800001}, |
| {"+0x1.00000200000000001p-50", 0x26800001}, |
| {"-0x1.00000200000000001p-50", 0xa6800001}, |
| {"+0x1.000002fffffffffffp-50", 0x26800001}, |
| {"-0x1.000002fffffffffffp-50", 0xa6800001}, |
| {"+0x1.00000300000000000p-50", 0x26800002}, |
| {"-0x1.00000300000000000p-50", 0xa6800002}, |
| {"+0x1.00000300000000001p-50", 0x26800002}, |
| {"-0x1.00000300000000001p-50", 0xa6800002}, |
| {"+0x1.000003fffffffffffp-50", 0x26800002}, |
| {"-0x1.000003fffffffffffp-50", 0xa6800002}, |
| {"+0x1.00000400000000000p-50", 0x26800002}, |
| {"-0x1.00000400000000000p-50", 0xa6800002}, |
| {"+0x1.00000400000000001p-50", 0x26800002}, |
| {"-0x1.00000400000000001p-50", 0xa6800002}, |
| {"+0x1.000004fffffffffffp-50", 0x26800002}, |
| {"-0x1.000004fffffffffffp-50", 0xa6800002}, |
| {"+0x1.00000500000000000p-50", 0x26800002}, |
| {"-0x1.00000500000000000p-50", 0xa6800002}, |
| {"+0x1.00000500000000001p-50", 0x26800003}, |
| {"-0x1.00000500000000001p-50", 0xa6800003}, |
| {"+0x4000.004000000p-64", 0x26800000}, |
| {"-0x4000.004000000p-64", 0xa6800000}, |
| {"+0x4000.004000001p-64", 0x26800001}, |
| {"-0x4000.004000001p-64", 0xa6800001}, |
| {"+0x4000.007ffffffp-64", 0x26800001}, |
| {"-0x4000.007ffffffp-64", 0xa6800001}, |
| {"+0x4000.008000000p-64", 0x26800001}, |
| {"-0x4000.008000000p-64", 0xa6800001}, |
| {"+0x4000.008000001p-64", 0x26800001}, |
| {"-0x4000.008000001p-64", 0xa6800001}, |
| {"+0x4000.00bffffffp-64", 0x26800001}, |
| {"-0x4000.00bffffffp-64", 0xa6800001}, |
| {"+0x4000.00c000000p-64", 0x26800002}, |
| {"-0x4000.00c000000p-64", 0xa6800002}, |
| {"+0x4000.00c000001p-64", 0x26800002}, |
| {"-0x4000.00c000001p-64", 0xa6800002}, |
| {"+0x4000.00fffffffp-64", 0x26800002}, |
| {"-0x4000.00fffffffp-64", 0xa6800002}, |
| {"+0x4000.010000001p-64", 0x26800002}, |
| {"-0x4000.010000001p-64", 0xa6800002}, |
| {"+0x4000.013ffffffp-64", 0x26800002}, |
| {"-0x4000.013ffffffp-64", 0xa6800002}, |
| {"+0x4000.014000001p-64", 0x26800003}, |
| {"-0x4000.014000001p-64", 0xa6800003}, |
| {"+0x1.00000100000000000p+50", 0x58800000}, |
| {"-0x1.00000100000000000p+50", 0xd8800000}, |
| {"+0x1.00000100000000001p+50", 0x58800001}, |
| {"-0x1.00000100000000001p+50", 0xd8800001}, |
| {"+0x1.000001fffffffffffp+50", 0x58800001}, |
| {"-0x1.000001fffffffffffp+50", 0xd8800001}, |
| {"+0x1.00000200000000000p+50", 0x58800001}, |
| {"-0x1.00000200000000000p+50", 0xd8800001}, |
| {"+0x1.00000200000000001p+50", 0x58800001}, |
| {"-0x1.00000200000000001p+50", 0xd8800001}, |
| {"+0x1.000002fffffffffffp+50", 0x58800001}, |
| {"-0x1.000002fffffffffffp+50", 0xd8800001}, |
| {"+0x1.00000300000000000p+50", 0x58800002}, |
| {"-0x1.00000300000000000p+50", 0xd8800002}, |
| {"+0x1.00000300000000001p+50", 0x58800002}, |
| {"-0x1.00000300000000001p+50", 0xd8800002}, |
| {"+0x1.000003fffffffffffp+50", 0x58800002}, |
| {"-0x1.000003fffffffffffp+50", 0xd8800002}, |
| {"+0x1.00000400000000000p+50", 0x58800002}, |
| {"-0x1.00000400000000000p+50", 0xd8800002}, |
| {"+0x1.00000400000000001p+50", 0x58800002}, |
| {"-0x1.00000400000000001p+50", 0xd8800002}, |
| {"+0x1.000004fffffffffffp+50", 0x58800002}, |
| {"-0x1.000004fffffffffffp+50", 0xd8800002}, |
| {"+0x1.00000500000000000p+50", 0x58800002}, |
| {"-0x1.00000500000000000p+50", 0xd8800002}, |
| {"+0x1.00000500000000001p+50", 0x58800003}, |
| {"-0x1.00000500000000001p+50", 0xd8800003}, |
| {"+0x4000004000000", 0x58800000}, |
| {"-0x4000004000000", 0xd8800000}, |
| {"+0x4000004000001", 0x58800001}, |
| {"-0x4000004000001", 0xd8800001}, |
| {"+0x4000007ffffff", 0x58800001}, |
| {"-0x4000007ffffff", 0xd8800001}, |
| {"+0x4000008000000", 0x58800001}, |
| {"-0x4000008000000", 0xd8800001}, |
| {"+0x4000008000001", 0x58800001}, |
| {"-0x4000008000001", 0xd8800001}, |
| {"+0x400000bffffff", 0x58800001}, |
| {"-0x400000bffffff", 0xd8800001}, |
| {"+0x400000c000000", 0x58800002}, |
| {"-0x400000c000000", 0xd8800002}, |
| {"+0x0.00000100000000000p-126", 0x0}, |
| {"-0x0.00000100000000000p-126", 0x80000000}, |
| {"+0x0.00000100000000001p-126", 0x1}, |
| {"-0x0.00000100000000001p-126", 0x80000001}, |
| {"+0x0.00000101000000000p-126", 0x1}, |
| {"+0x0.000001fffffffffffp-126", 0x1}, |
| {"-0x0.000001fffffffffffp-126", 0x80000001}, |
| {"+0x0.00000200000000000p-126", 0x1}, |
| {"-0x0.00000200000000000p-126", 0x80000001}, |
| {"+0x0.00000200000000001p-126", 0x1}, |
| {"-0x0.00000200000000001p-126", 0x80000001}, |
| {"+0x0.000002fffffffffffp-126", 0x1}, |
| {"-0x0.000002fffffffffffp-126", 0x80000001}, |
| {"+0x0.00000300000000000p-126", 0x2}, |
| {"-0x0.00000300000000000p-126", 0x80000002}, |
| {"+0x0.00000300000000001p-126", 0x2}, |
| {"-0x0.00000300000000001p-126", 0x80000002}, |
| {"+0x0.000003fffffffffffp-126", 0x2}, |
| {"-0x0.000003fffffffffffp-126", 0x80000002}, |
| {"+0x0.00000400000000000p-126", 0x2}, |
| {"-0x0.00000400000000000p-126", 0x80000002}, |
| {"+0x0.00000400000000001p-126", 0x2}, |
| {"-0x0.00000400000000001p-126", 0x80000002}, |
| {"+0x0.000004fffffffffffp-126", 0x2}, |
| {"-0x0.000004fffffffffffp-126", 0x80000002}, |
| {"+0x0.00000500000000000p-126", 0x2}, |
| {"-0x0.00000500000000000p-126", 0x80000002}, |
| {"+0x0.00000500000000001p-126", 0x3}, |
| {"-0x0.00000500000000001p-126", 0x80000003}, |
| {"+0x1.fffffe8p127", 0x7f7fffff}, |
| {"-0x1.fffffe8p127", 0xff7fffff}, |
| {"+0x1.fffffefffffff8p127", 0x7f7fffff}, |
| {"-0x1.fffffefffffff8p127", 0xff7fffff}, |
| {"+0x1.fffffefffffffffffp127", 0x7f7fffff}, |
| {"-0x1.fffffefffffffffffp127", 0xff7fffff}, |
| }; |
| |
| for (auto test : kTests) { |
| AssertHexFloatEquals(test.output, test.input); |
| } |
| } |
| |
| TEST(ParseFloat, OutOfRange) { |
| AssertHexFloatFails("0x1p128"); |
| AssertHexFloatFails("-0x1p128"); |
| AssertHexFloatFails("0x1.ffffffp127"); |
| AssertHexFloatFails("-0x1.ffffffp127"); |
| } |
| |
| TEST(ParseDouble, NonCanonical) { |
| AssertHexDoubleEquals(0x3ff0000000000000, "0x00000000000000000000001.0p0"); |
| AssertHexDoubleEquals(0x3ff0000000000000, "0x1.00000000000000000000000p0"); |
| AssertHexDoubleEquals(0x3ff0000000000000, "0x0.0000000000000000000001p88"); |
| } |
| |
| TEST(ParseDouble, Rounding) { |
| // |-------------------- 52 bits ---------------------| V-- extra bit |
| // |
| // 1111111111111111111111111111111111111111111111111101 0 ==> no rounding |
| AssertHexDoubleEquals(0x7feffffffffffffd, "0x1.ffffffffffffd0p1023"); |
| // 1111111111111111111111111111111111111111111111111101 1 ==> round up |
| AssertHexDoubleEquals(0x7feffffffffffffe, "0x1.ffffffffffffd8p1023"); |
| // 1111111111111111111111111111111111111111111111111110 0 ==> no rounding |
| AssertHexDoubleEquals(0x7feffffffffffffe, "0x1.ffffffffffffe0p1023"); |
| // 1111111111111111111111111111111111111111111111111110 1 ==> round down |
| AssertHexDoubleEquals(0x7feffffffffffffe, "0x1.ffffffffffffe8p1023"); |
| // 1111111111111111111111111111111111111111111111111111 0 ==> no rounding |
| AssertHexDoubleEquals(0x7fefffffffffffff, "0x1.fffffffffffff0p1023"); |
| } |
| |
| TEST(ParseDouble, OutOfRange) { |
| AssertHexDoubleFails("0x1p1024"); |
| AssertHexDoubleFails("-0x1p1024"); |
| AssertHexDoubleFails("0x1.fffffffffffff8p1023"); |
| AssertHexDoubleFails("-0x1.fffffffffffff8p1023"); |
| } |
| |
| // Duplicate the spec tests here for easier debugging. |
| TEST(ParseDouble, RoundingSpec) { |
| static const struct { |
| const char* input; |
| uint64_t output; |
| } kTests[] = { |
| {"+0x1.000000000000080000000000p-600", 1905022642377719808ull}, |
| {"-0x1.000000000000080000000000p-600", 11128394679232495616ull}, |
| {"+0x1.000000000000080000000001p-600", 1905022642377719809ull}, |
| {"-0x1.000000000000080000000001p-600", 11128394679232495617ull}, |
| {"+0x1.0000000000000fffffffffffp-600", 1905022642377719809ull}, |
| {"-0x1.0000000000000fffffffffffp-600", 11128394679232495617ull}, |
| {"+0x1.000000000000100000000000p-600", 1905022642377719809ull}, |
| {"-0x1.000000000000100000000000p-600", 11128394679232495617ull}, |
| {"+0x1.000000000000100000000001p-600", 1905022642377719809ull}, |
| {"-0x1.000000000000100000000001p-600", 11128394679232495617ull}, |
| {"+0x1.00000000000017ffffffffffp-600", 1905022642377719809ull}, |
| {"-0x1.00000000000017ffffffffffp-600", 11128394679232495617ull}, |
| {"+0x1.000000000000180000000000p-600", 1905022642377719810ull}, |
| {"-0x1.000000000000180000000000p-600", 11128394679232495618ull}, |
| {"+0x1.000000000000180000000001p-600", 1905022642377719810ull}, |
| {"-0x1.000000000000180000000001p-600", 11128394679232495618ull}, |
| {"+0x1.0000000000001fffffffffffp-600", 1905022642377719810ull}, |
| {"-0x1.0000000000001fffffffffffp-600", 11128394679232495618ull}, |
| {"+0x1.000000000000200000000000p-600", 1905022642377719810ull}, |
| {"-0x1.000000000000200000000000p-600", 11128394679232495618ull}, |
| {"+0x1.000000000000200000000001p-600", 1905022642377719810ull}, |
| {"-0x1.000000000000200000000001p-600", 11128394679232495618ull}, |
| {"+0x1.00000000000027ffffffffffp-600", 1905022642377719810ull}, |
| {"-0x1.00000000000027ffffffffffp-600", 11128394679232495618ull}, |
| {"+0x1.000000000000280000000001p-600", 1905022642377719811ull}, |
| {"-0x1.000000000000280000000001p-600", 11128394679232495619ull}, |
| {"+0x8000000.000000400000000000p-627", 1905022642377719808ull}, |
| {"-0x8000000.000000400000000000p-627", 11128394679232495616ull}, |
| {"+0x8000000.000000400000000001p-627", 1905022642377719809ull}, |
| {"-0x8000000.000000400000000001p-627", 11128394679232495617ull}, |
| {"+0x8000000.0000007fffffffffffp-627", 1905022642377719809ull}, |
| {"-0x8000000.0000007fffffffffffp-627", 11128394679232495617ull}, |
| {"+0x8000000.000000800000000000p-627", 1905022642377719809ull}, |
| {"-0x8000000.000000800000000000p-627", 11128394679232495617ull}, |
| {"+0x8000000.000000800000000001p-627", 1905022642377719809ull}, |
| {"-0x8000000.000000800000000001p-627", 11128394679232495617ull}, |
| {"+0x8000000.000000bfffffffffffp-627", 1905022642377719809ull}, |
| {"-0x8000000.000000bfffffffffffp-627", 11128394679232495617ull}, |
| {"+0x8000000.000000c00000000000p-627", 1905022642377719810ull}, |
| {"-0x8000000.000000c00000000000p-627", 11128394679232495618ull}, |
| {"+0x8000000.000000c00000000001p-627", 1905022642377719810ull}, |
| {"-0x8000000.000000c00000000001p-627", 11128394679232495618ull}, |
| {"+0x8000000.000000ffffffffffffp-627", 1905022642377719810ull}, |
| {"-0x8000000.000000ffffffffffffp-627", 11128394679232495618ull}, |
| {"+0x8000000.000001000000000000p-627", 1905022642377719810ull}, |
| {"-0x8000000.000001000000000000p-627", 11128394679232495618ull}, |
| {"+0x8000000.000001000000000001p-627", 1905022642377719810ull}, |
| {"-0x8000000.000001000000000001p-627", 11128394679232495618ull}, |
| {"+0x8000000.0000013fffffffffffp-627", 1905022642377719810ull}, |
| {"-0x8000000.0000013fffffffffffp-627", 11128394679232495618ull}, |
| {"+0x8000000.000001400000000001p-627", 1905022642377719811ull}, |
| {"-0x8000000.000001400000000001p-627", 11128394679232495619ull}, |
| {"+0x1.000000000000080000000000p+600", 7309342195222315008ull}, |
| {"-0x1.000000000000080000000000p+600", 16532714232077090816ull}, |
| {"+0x1.000000000000080000000001p+600", 7309342195222315009ull}, |
| {"-0x1.000000000000080000000001p+600", 16532714232077090817ull}, |
| {"+0x1.0000000000000fffffffffffp+600", 7309342195222315009ull}, |
| {"-0x1.0000000000000fffffffffffp+600", 16532714232077090817ull}, |
| {"+0x1.000000000000100000000000p+600", 7309342195222315009ull}, |
| {"-0x1.000000000000100000000000p+600", 16532714232077090817ull}, |
| {"+0x1.000000000000100000000001p+600", 7309342195222315009ull}, |
| {"-0x1.000000000000100000000001p+600", 16532714232077090817ull}, |
| {"+0x1.00000000000017ffffffffffp+600", 7309342195222315009ull}, |
| {"-0x1.00000000000017ffffffffffp+600", 16532714232077090817ull}, |
| {"+0x1.000000000000180000000000p+600", 7309342195222315010ull}, |
| {"-0x1.000000000000180000000000p+600", 16532714232077090818ull}, |
| {"+0x1.000000000000180000000001p+600", 7309342195222315010ull}, |
| {"-0x1.000000000000180000000001p+600", 16532714232077090818ull}, |
| {"+0x1.0000000000001fffffffffffp+600", 7309342195222315010ull}, |
| {"-0x1.0000000000001fffffffffffp+600", 16532714232077090818ull}, |
| {"+0x1.000000000000200000000000p+600", 7309342195222315010ull}, |
| {"-0x1.000000000000200000000000p+600", 16532714232077090818ull}, |
| {"+0x1.000000000000200000000001p+600", 7309342195222315010ull}, |
| {"-0x1.000000000000200000000001p+600", 16532714232077090818ull}, |
| {"+0x1.00000000000027ffffffffffp+600", 7309342195222315010ull}, |
| {"-0x1.00000000000027ffffffffffp+600", 16532714232077090818ull}, |
| {"+0x1.000000000000280000000000p+600", 7309342195222315010ull}, |
| {"-0x1.000000000000280000000000p+600", 16532714232077090818ull}, |
| {"+0x1.000000000000280000000001p+600", 7309342195222315011ull}, |
| {"-0x1.000000000000280000000001p+600", 16532714232077090819ull}, |
| {"+0x2000000000000100000000000", 5044031582654955520ull}, |
| {"-0x2000000000000100000000000", 14267403619509731328ull}, |
| {"+0x2000000000000100000000001", 5044031582654955521ull}, |
| {"-0x2000000000000100000000001", 14267403619509731329ull}, |
| {"+0x20000000000001fffffffffff", 5044031582654955521ull}, |
| {"-0x20000000000001fffffffffff", 14267403619509731329ull}, |
| {"+0x2000000000000200000000000", 5044031582654955521ull}, |
| {"-0x2000000000000200000000000", 14267403619509731329ull}, |
| {"+0x2000000000000200000000001", 5044031582654955521ull}, |
| {"-0x2000000000000200000000001", 14267403619509731329ull}, |
| {"+0x20000000000002fffffffffff", 5044031582654955521ull}, |
| {"-0x20000000000002fffffffffff", 14267403619509731329ull}, |
| {"+0x2000000000000300000000000", 5044031582654955522ull}, |
| {"-0x2000000000000300000000000", 14267403619509731330ull}, |
| {"+0x2000000000000300000000001", 5044031582654955522ull}, |
| {"-0x2000000000000300000000001", 14267403619509731330ull}, |
| {"+0x20000000000003fffffffffff", 5044031582654955522ull}, |
| {"-0x20000000000003fffffffffff", 14267403619509731330ull}, |
| {"+0x2000000000000400000000000", 5044031582654955522ull}, |
| {"-0x2000000000000400000000000", 14267403619509731330ull}, |
| {"+0x2000000000000400000000001", 5044031582654955522ull}, |
| {"-0x2000000000000400000000001", 14267403619509731330ull}, |
| {"+0x20000000000004fffffffffff", 5044031582654955522ull}, |
| {"-0x20000000000004fffffffffff", 14267403619509731330ull}, |
| {"+0x2000000000000500000000000", 5044031582654955522ull}, |
| {"-0x2000000000000500000000000", 14267403619509731330ull}, |
| {"+0x2000000000000500000000001", 5044031582654955523ull}, |
| {"-0x2000000000000500000000001", 14267403619509731331ull}, |
| {"+0x0.000000000000080000000000p-1022", 0ull}, |
| {"-0x0.000000000000080000000000p-1022", 9223372036854775808ull}, |
| {"+0x0.000000000000080000000001p-1022", 1ull}, |
| {"-0x0.000000000000080000000001p-1022", 9223372036854775809ull}, |
| {"+0x0.0000000000000fffffffffffp-1022", 1ull}, |
| {"-0x0.0000000000000fffffffffffp-1022", 9223372036854775809ull}, |
| {"+0x0.000000000000100000000000p-1022", 1ull}, |
| {"-0x0.000000000000100000000000p-1022", 9223372036854775809ull}, |
| {"+0x0.000000000000100000000001p-1022", 1ull}, |
| {"-0x0.000000000000100000000001p-1022", 9223372036854775809ull}, |
| {"+0x0.00000000000017ffffffffffp-1022", 1ull}, |
| {"-0x0.00000000000017ffffffffffp-1022", 9223372036854775809ull}, |
| {"+0x0.000000000000180000000000p-1022", 2ull}, |
| {"-0x0.000000000000180000000000p-1022", 9223372036854775810ull}, |
| {"+0x0.000000000000180000000001p-1022", 2ull}, |
| {"-0x0.000000000000180000000001p-1022", 9223372036854775810ull}, |
| {"+0x0.0000000000001fffffffffffp-1022", 2ull}, |
| {"-0x0.0000000000001fffffffffffp-1022", 9223372036854775810ull}, |
| {"+0x0.000000000000200000000000p-1022", 2ull}, |
| {"-0x0.000000000000200000000000p-1022", 9223372036854775810ull}, |
| {"+0x0.000000000000200000000001p-1022", 2ull}, |
| {"-0x0.000000000000200000000001p-1022", 9223372036854775810ull}, |
| {"+0x0.00000000000027ffffffffffp-1022", 2ull}, |
| {"-0x0.00000000000027ffffffffffp-1022", 9223372036854775810ull}, |
| {"+0x0.000000000000280000000000p-1022", 2ull}, |
| {"-0x0.000000000000280000000000p-1022", 9223372036854775810ull}, |
| {"+0x1.000000000000280000000001p-1022", 4503599627370499ull}, |
| {"-0x1.000000000000280000000001p-1022", 9227875636482146307ull}, |
| {"+0x1.fffffffffffff4p1023", 9218868437227405311ull}, |
| {"-0x1.fffffffffffff4p1023", 18442240474082181119ull}, |
| {"+0x1.fffffffffffff7ffffffp1023", 9218868437227405311ull}, |
| {"-0x1.fffffffffffff7ffffffp1023", 18442240474082181119ull}, |
| }; |
| |
| for (auto test : kTests) { |
| AssertHexDoubleEquals(test.output, test.input); |
| } |
| } |
| |
| void AssertWriteUint128Equals(const v128& value, const std::string& expected) { |
| assert(expected.length() < 128); |
| char buffer[128]; |
| WriteUint128(buffer, 128, value); |
| std::string actual(buffer, buffer + expected.length()); |
| ASSERT_EQ(expected, actual); |
| ASSERT_EQ(buffer[expected.length()], '\0'); |
| } |
| |
| TEST(WriteUint128, Basic) { |
| AssertWriteUint128Equals({0, 0, 0, 0}, "0"); |
| AssertWriteUint128Equals({1, 0, 0, 0}, "1"); |
| AssertWriteUint128Equals({0x100f0e0d, 0x0c0b0a09, 0x08070605, 0x04030201}, |
| "5332529520247008778714484145835150861"); |
| AssertWriteUint128Equals({0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff}, |
| "272314856204801878456120017448021860915"); |
| AssertWriteUint128Equals({0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, |
| "340282366920938463463374607431768211455"); |
| AssertWriteUint128Equals({0, 0, 1, 0}, "18446744073709551616"); |
| } |
| |
| TEST(WriteUint128, BufferTooSmall) { |
| { |
| char buffer[20]; |
| WriteUint128(buffer, 20, {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}); |
| ASSERT_EQ(buffer[19], '\0'); |
| std::string actual(buffer, buffer + 19); |
| ASSERT_EQ("3402823669209384634", actual); |
| } |
| |
| { |
| char buffer[3]; |
| WriteUint128(buffer, 3, {123, 0, 0, 0}); |
| ASSERT_EQ(buffer[0], '1'); |
| ASSERT_EQ(buffer[1], '2'); |
| ASSERT_EQ(buffer[2], '\0'); |
| } |
| } |
