Source code
Revision control
Copy as Markdown
Other Tools
/*
* 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
*
*
* 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');
}
}