Pull the new r369476 of base library from Chromium The merge was done against r369476 which corresponds to git commit 0471d0e2e2ef4a544a63481a389e1df33ea7c00a of Jan 14, 2016 Change-Id: Ie6894cf65424cc5ad115110faccd51602b2d1234 Reviewed-on: https://weave-review.googlesource.com/2225 Reviewed-by: Alex Vakulenko <avakulenko@google.com>
diff --git a/third_party/chromium/base/strings/string_number_conversions_unittest.cc b/third_party/chromium/base/strings/string_number_conversions_unittest.cc index 80d1471..1cfb2c8 100644 --- a/third_party/chromium/base/strings/string_number_conversions_unittest.cc +++ b/third_party/chromium/base/strings/string_number_conversions_unittest.cc
@@ -5,6 +5,8 @@ #include "base/strings/string_number_conversions.h" #include <errno.h> +#include <limits.h> +#include <stddef.h> #include <stdint.h> #include <stdio.h> @@ -13,6 +15,7 @@ #include <gtest/gtest.h> +#include "base/macros.h" #include "base/strings/stringprintf.h" #include "base/strings/utf_string_conversion_utils.h" @@ -36,15 +39,15 @@ { std::numeric_limits<int>::max(), "2147483647", "2147483647" }, { std::numeric_limits<int>::min(), "-2147483648", "2147483648" }, }; - static const IntToStringTest<int64> int64_tests[] = { - { 0, "0", "0" }, - { -1, "-1", "18446744073709551615" }, - { std::numeric_limits<int64>::max(), - "9223372036854775807", - "9223372036854775807", }, - { std::numeric_limits<int64>::min(), - "-9223372036854775808", - "9223372036854775808" }, + static const IntToStringTest<int64_t> int64_tests[] = { + {0, "0", "0"}, + {-1, "-1", "18446744073709551615"}, + { + std::numeric_limits<int64_t>::max(), "9223372036854775807", + "9223372036854775807", + }, + {std::numeric_limits<int64_t>::min(), "-9223372036854775808", + "9223372036854775808"}, }; for (size_t i = 0; i < arraysize(int_tests); ++i) { @@ -53,7 +56,7 @@ EXPECT_EQ(UintToString(test->num), test->uexpected); } for (size_t i = 0; i < arraysize(int64_tests); ++i) { - const IntToStringTest<int64>* test = &int64_tests[i]; + const IntToStringTest<int64_t>* test = &int64_tests[i]; EXPECT_EQ(Int64ToString(test->num), test->sexpected); EXPECT_EQ(Uint64ToString(test->num), test->uexpected); } @@ -61,13 +64,13 @@ TEST(StringNumberConversionsTest, Uint64ToString) { static const struct { - uint64 input; + uint64_t input; std::string output; } cases[] = { - {0, "0"}, - {42, "42"}, - {INT_MAX, "2147483647"}, - {kuint64max, "18446744073709551615"}, + {0, "0"}, + {42, "42"}, + {INT_MAX, "2147483647"}, + {std::numeric_limits<uint64_t>::max(), "18446744073709551615"}, }; for (size_t i = 0; i < arraysize(cases); ++i) @@ -197,44 +200,44 @@ TEST(StringNumberConversionsTest, StringToInt64) { static const struct { std::string input; - int64 output; + int64_t output; bool success; } cases[] = { - {"0", 0, true}, - {"42", 42, true}, - {"-2147483648", INT_MIN, true}, - {"2147483647", INT_MAX, true}, - {"-2147483649", INT64_C(-2147483649), true}, - {"-99999999999", INT64_C(-99999999999), true}, - {"2147483648", INT64_C(2147483648), true}, - {"99999999999", INT64_C(99999999999), true}, - {"9223372036854775807", kint64max, true}, - {"-9223372036854775808", kint64min, true}, - {"09", 9, true}, - {"-09", -9, true}, - {"", 0, false}, - {" 42", 42, false}, - {"42 ", 42, false}, - {"0x42", 0, false}, - {"\t\n\v\f\r 42", 42, false}, - {"blah42", 0, false}, - {"42blah", 42, false}, - {"blah42blah", 0, false}, - {"-273.15", -273, false}, - {"+98.6", 98, false}, - {"--123", 0, false}, - {"++123", 0, false}, - {"-+123", 0, false}, - {"+-123", 0, false}, - {"-", 0, false}, - {"-9223372036854775809", kint64min, false}, - {"-99999999999999999999", kint64min, false}, - {"9223372036854775808", kint64max, false}, - {"99999999999999999999", kint64max, false}, + {"0", 0, true}, + {"42", 42, true}, + {"-2147483648", INT_MIN, true}, + {"2147483647", INT_MAX, true}, + {"-2147483649", INT64_C(-2147483649), true}, + {"-99999999999", INT64_C(-99999999999), true}, + {"2147483648", INT64_C(2147483648), true}, + {"99999999999", INT64_C(99999999999), true}, + {"9223372036854775807", std::numeric_limits<int64_t>::max(), true}, + {"-9223372036854775808", std::numeric_limits<int64_t>::min(), true}, + {"09", 9, true}, + {"-09", -9, true}, + {"", 0, false}, + {" 42", 42, false}, + {"42 ", 42, false}, + {"0x42", 0, false}, + {"\t\n\v\f\r 42", 42, false}, + {"blah42", 0, false}, + {"42blah", 42, false}, + {"blah42blah", 0, false}, + {"-273.15", -273, false}, + {"+98.6", 98, false}, + {"--123", 0, false}, + {"++123", 0, false}, + {"-+123", 0, false}, + {"+-123", 0, false}, + {"-", 0, false}, + {"-9223372036854775809", std::numeric_limits<int64_t>::min(), false}, + {"-99999999999999999999", std::numeric_limits<int64_t>::min(), false}, + {"9223372036854775808", std::numeric_limits<int64_t>::max(), false}, + {"99999999999999999999", std::numeric_limits<int64_t>::max(), false}, }; for (size_t i = 0; i < arraysize(cases); ++i) { - int64 output = 0; + int64_t output = 0; EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output)); EXPECT_EQ(cases[i].output, output); } @@ -244,7 +247,7 @@ // interpreted as junk after the number. const char input[] = "6\06"; std::string input_string(input, arraysize(input) - 1); - int64 output; + int64_t output; EXPECT_FALSE(StringToInt64(input_string, &output)); EXPECT_EQ(6, output); } @@ -252,46 +255,46 @@ TEST(StringNumberConversionsTest, StringToUint64) { static const struct { std::string input; - uint64 output; + uint64_t output; bool success; } cases[] = { - {"0", 0, true}, - {"42", 42, true}, - {"-2147483648", 0, false}, - {"2147483647", INT_MAX, true}, - {"-2147483649", 0, false}, - {"-99999999999", 0, false}, - {"2147483648", UINT64_C(2147483648), true}, - {"99999999999", UINT64_C(99999999999), true}, - {"9223372036854775807", kint64max, true}, - {"-9223372036854775808", 0, false}, - {"09", 9, true}, - {"-09", 0, false}, - {"", 0, false}, - {" 42", 42, false}, - {"42 ", 42, false}, - {"0x42", 0, false}, - {"\t\n\v\f\r 42", 42, false}, - {"blah42", 0, false}, - {"42blah", 42, false}, - {"blah42blah", 0, false}, - {"-273.15", 0, false}, - {"+98.6", 98, false}, - {"--123", 0, false}, - {"++123", 0, false}, - {"-+123", 0, false}, - {"+-123", 0, false}, - {"-", 0, false}, - {"-9223372036854775809", 0, false}, - {"-99999999999999999999", 0, false}, - {"9223372036854775808", UINT64_C(9223372036854775808), true}, - {"99999999999999999999", kuint64max, false}, - {"18446744073709551615", kuint64max, true}, - {"18446744073709551616", kuint64max, false}, + {"0", 0, true}, + {"42", 42, true}, + {"-2147483648", 0, false}, + {"2147483647", INT_MAX, true}, + {"-2147483649", 0, false}, + {"-99999999999", 0, false}, + {"2147483648", UINT64_C(2147483648), true}, + {"99999999999", UINT64_C(99999999999), true}, + {"9223372036854775807", std::numeric_limits<int64_t>::max(), true}, + {"-9223372036854775808", 0, false}, + {"09", 9, true}, + {"-09", 0, false}, + {"", 0, false}, + {" 42", 42, false}, + {"42 ", 42, false}, + {"0x42", 0, false}, + {"\t\n\v\f\r 42", 42, false}, + {"blah42", 0, false}, + {"42blah", 42, false}, + {"blah42blah", 0, false}, + {"-273.15", 0, false}, + {"+98.6", 98, false}, + {"--123", 0, false}, + {"++123", 0, false}, + {"-+123", 0, false}, + {"+-123", 0, false}, + {"-", 0, false}, + {"-9223372036854775809", 0, false}, + {"-99999999999999999999", 0, false}, + {"9223372036854775808", UINT64_C(9223372036854775808), true}, + {"99999999999999999999", std::numeric_limits<uint64_t>::max(), false}, + {"18446744073709551615", std::numeric_limits<uint64_t>::max(), true}, + {"18446744073709551616", std::numeric_limits<uint64_t>::max(), false}, }; for (size_t i = 0; i < arraysize(cases); ++i) { - uint64 output = 0; + uint64_t output = 0; EXPECT_EQ(cases[i].success, StringToUint64(cases[i].input, &output)); EXPECT_EQ(cases[i].output, output); } @@ -301,7 +304,7 @@ // interpreted as junk after the number. const char input[] = "6\06"; std::string input_string(input, arraysize(input) - 1); - uint64 output; + uint64_t output; EXPECT_FALSE(StringToUint64(input_string, &output)); EXPECT_EQ(6U, output); } @@ -368,7 +371,7 @@ TEST(StringNumberConversionsTest, HexStringToInt) { static const struct { std::string input; - int64 output; + int64_t output; bool success; } cases[] = { {"0", 0, true}, @@ -420,50 +423,55 @@ TEST(StringNumberConversionsTest, HexStringToUInt) { static const struct { std::string input; - uint32 output; + uint32_t output; bool success; } cases[] = { - {"0", 0, true}, - {"42", 0x42, true}, - {"-42", 0, false}, - {"+42", 0x42, true}, - {"7fffffff", INT_MAX, true}, - {"-80000000", 0, false}, - {"ffffffff", 0xffffffff, true}, - {"DeadBeef", 0xdeadbeef, true}, - {"0x42", 0x42, true}, - {"-0x42", 0, false}, - {"+0x42", 0x42, true}, - {"0x7fffffff", INT_MAX, true}, - {"-0x80000000", 0, false}, - {"0xffffffff", kuint32max, true}, - {"0XDeadBeef", 0xdeadbeef, true}, - {"0x7fffffffffffffff", kuint32max, false}, // Overflow test. - {"-0x8000000000000000", 0, false}, - {"0x8000000000000000", kuint32max, false}, // Overflow test. - {"-0x8000000000000001", 0, false}, - {"0xFFFFFFFFFFFFFFFF", kuint32max, false}, // Overflow test. - {"FFFFFFFFFFFFFFFF", kuint32max, false}, // Overflow test. - {"0x0000000000000000", 0, true}, - {"0000000000000000", 0, true}, - {"1FFFFFFFFFFFFFFFF", kuint32max, false}, // Overflow test. - {"0x0f", 0x0f, true}, - {"0f", 0x0f, true}, - {" 45", 0x45, false}, - {"\t\n\v\f\r 0x45", 0x45, false}, - {" 45", 0x45, false}, - {"45 ", 0x45, false}, - {"45:", 0x45, false}, - {"efgh", 0xef, false}, - {"0xefgh", 0xef, false}, - {"hgfe", 0, false}, - {"-", 0, false}, - {"", 0, false}, - {"0x", 0, false}, + {"0", 0, true}, + {"42", 0x42, true}, + {"-42", 0, false}, + {"+42", 0x42, true}, + {"7fffffff", INT_MAX, true}, + {"-80000000", 0, false}, + {"ffffffff", 0xffffffff, true}, + {"DeadBeef", 0xdeadbeef, true}, + {"0x42", 0x42, true}, + {"-0x42", 0, false}, + {"+0x42", 0x42, true}, + {"0x7fffffff", INT_MAX, true}, + {"-0x80000000", 0, false}, + {"0xffffffff", std::numeric_limits<uint32_t>::max(), true}, + {"0XDeadBeef", 0xdeadbeef, true}, + {"0x7fffffffffffffff", std::numeric_limits<uint32_t>::max(), + false}, // Overflow test. + {"-0x8000000000000000", 0, false}, + {"0x8000000000000000", std::numeric_limits<uint32_t>::max(), + false}, // Overflow test. + {"-0x8000000000000001", 0, false}, + {"0xFFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(), + false}, // Overflow test. + {"FFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(), + false}, // Overflow test. + {"0x0000000000000000", 0, true}, + {"0000000000000000", 0, true}, + {"1FFFFFFFFFFFFFFFF", std::numeric_limits<uint32_t>::max(), + false}, // Overflow test. + {"0x0f", 0x0f, true}, + {"0f", 0x0f, true}, + {" 45", 0x45, false}, + {"\t\n\v\f\r 0x45", 0x45, false}, + {" 45", 0x45, false}, + {"45 ", 0x45, false}, + {"45:", 0x45, false}, + {"efgh", 0xef, false}, + {"0xefgh", 0xef, false}, + {"hgfe", 0, false}, + {"-", 0, false}, + {"", 0, false}, + {"0x", 0, false}, }; for (size_t i = 0; i < arraysize(cases); ++i) { - uint32 output = 0; + uint32_t output = 0; EXPECT_EQ(cases[i].success, HexStringToUInt(cases[i].input, &output)); EXPECT_EQ(cases[i].output, output); } @@ -472,7 +480,7 @@ // interpreted as junk after the number. const char input[] = "0xc0ffee\0" "9"; std::string input_string(input, arraysize(input) - 1); - uint32 output; + uint32_t output; EXPECT_FALSE(HexStringToUInt(input_string, &output)); EXPECT_EQ(0xc0ffeeU, output); } @@ -480,47 +488,49 @@ TEST(StringNumberConversionsTest, HexStringToInt64) { static const struct { std::string input; - int64 output; + int64_t output; bool success; } cases[] = { - {"0", 0, true}, - {"42", 66, true}, - {"-42", -66, true}, - {"+42", 66, true}, - {"40acd88557b", INT64_C(4444444448123), true}, - {"7fffffff", INT_MAX, true}, - {"-80000000", INT_MIN, true}, - {"ffffffff", 0xffffffff, true}, - {"DeadBeef", 0xdeadbeef, true}, - {"0x42", 66, true}, - {"-0x42", -66, true}, - {"+0x42", 66, true}, - {"0x40acd88557b", INT64_C(4444444448123), true}, - {"0x7fffffff", INT_MAX, true}, - {"-0x80000000", INT_MIN, true}, - {"0xffffffff", 0xffffffff, true}, - {"0XDeadBeef", 0xdeadbeef, true}, - {"0x7fffffffffffffff", kint64max, true}, - {"-0x8000000000000000", kint64min, true}, - {"0x8000000000000000", kint64max, false}, // Overflow test. - {"-0x8000000000000001", kint64min, false}, // Underflow test. - {"0x0f", 15, true}, - {"0f", 15, true}, - {" 45", 0x45, false}, - {"\t\n\v\f\r 0x45", 0x45, false}, - {" 45", 0x45, false}, - {"45 ", 0x45, false}, - {"45:", 0x45, false}, - {"efgh", 0xef, false}, - {"0xefgh", 0xef, false}, - {"hgfe", 0, false}, - {"-", 0, false}, - {"", 0, false}, - {"0x", 0, false}, + {"0", 0, true}, + {"42", 66, true}, + {"-42", -66, true}, + {"+42", 66, true}, + {"40acd88557b", INT64_C(4444444448123), true}, + {"7fffffff", INT_MAX, true}, + {"-80000000", INT_MIN, true}, + {"ffffffff", 0xffffffff, true}, + {"DeadBeef", 0xdeadbeef, true}, + {"0x42", 66, true}, + {"-0x42", -66, true}, + {"+0x42", 66, true}, + {"0x40acd88557b", INT64_C(4444444448123), true}, + {"0x7fffffff", INT_MAX, true}, + {"-0x80000000", INT_MIN, true}, + {"0xffffffff", 0xffffffff, true}, + {"0XDeadBeef", 0xdeadbeef, true}, + {"0x7fffffffffffffff", std::numeric_limits<int64_t>::max(), true}, + {"-0x8000000000000000", std::numeric_limits<int64_t>::min(), true}, + {"0x8000000000000000", std::numeric_limits<int64_t>::max(), + false}, // Overflow test. + {"-0x8000000000000001", std::numeric_limits<int64_t>::min(), + false}, // Underflow test. + {"0x0f", 15, true}, + {"0f", 15, true}, + {" 45", 0x45, false}, + {"\t\n\v\f\r 0x45", 0x45, false}, + {" 45", 0x45, false}, + {"45 ", 0x45, false}, + {"45:", 0x45, false}, + {"efgh", 0xef, false}, + {"0xefgh", 0xef, false}, + {"hgfe", 0, false}, + {"-", 0, false}, + {"", 0, false}, + {"0x", 0, false}, }; for (size_t i = 0; i < arraysize(cases); ++i) { - int64 output = 0; + int64_t output = 0; EXPECT_EQ(cases[i].success, HexStringToInt64(cases[i].input, &output)); EXPECT_EQ(cases[i].output, output); } @@ -529,7 +539,7 @@ // interpreted as junk after the number. const char input[] = "0xc0ffee\0" "9"; std::string input_string(input, arraysize(input) - 1); - int64 output; + int64_t output; EXPECT_FALSE(HexStringToInt64(input_string, &output)); EXPECT_EQ(0xc0ffee, output); } @@ -537,52 +547,53 @@ TEST(StringNumberConversionsTest, HexStringToUInt64) { static const struct { std::string input; - uint64 output; + uint64_t output; bool success; } cases[] = { - {"0", 0, true}, - {"42", 66, true}, - {"-42", 0, false}, - {"+42", 66, true}, - {"40acd88557b", INT64_C(4444444448123), true}, - {"7fffffff", INT_MAX, true}, - {"-80000000", 0, false}, - {"ffffffff", 0xffffffff, true}, - {"DeadBeef", 0xdeadbeef, true}, - {"0x42", 66, true}, - {"-0x42", 0, false}, - {"+0x42", 66, true}, - {"0x40acd88557b", INT64_C(4444444448123), true}, - {"0x7fffffff", INT_MAX, true}, - {"-0x80000000", 0, false}, - {"0xffffffff", 0xffffffff, true}, - {"0XDeadBeef", 0xdeadbeef, true}, - {"0x7fffffffffffffff", kint64max, true}, - {"-0x8000000000000000", 0, false}, - {"0x8000000000000000", UINT64_C(0x8000000000000000), true}, - {"-0x8000000000000001", 0, false}, - {"0xFFFFFFFFFFFFFFFF", kuint64max, true}, - {"FFFFFFFFFFFFFFFF", kuint64max, true}, - {"0x0000000000000000", 0, true}, - {"0000000000000000", 0, true}, - {"1FFFFFFFFFFFFFFFF", kuint64max, false}, // Overflow test. - {"0x0f", 15, true}, - {"0f", 15, true}, - {" 45", 0x45, false}, - {"\t\n\v\f\r 0x45", 0x45, false}, - {" 45", 0x45, false}, - {"45 ", 0x45, false}, - {"45:", 0x45, false}, - {"efgh", 0xef, false}, - {"0xefgh", 0xef, false}, - {"hgfe", 0, false}, - {"-", 0, false}, - {"", 0, false}, - {"0x", 0, false}, + {"0", 0, true}, + {"42", 66, true}, + {"-42", 0, false}, + {"+42", 66, true}, + {"40acd88557b", INT64_C(4444444448123), true}, + {"7fffffff", INT_MAX, true}, + {"-80000000", 0, false}, + {"ffffffff", 0xffffffff, true}, + {"DeadBeef", 0xdeadbeef, true}, + {"0x42", 66, true}, + {"-0x42", 0, false}, + {"+0x42", 66, true}, + {"0x40acd88557b", INT64_C(4444444448123), true}, + {"0x7fffffff", INT_MAX, true}, + {"-0x80000000", 0, false}, + {"0xffffffff", 0xffffffff, true}, + {"0XDeadBeef", 0xdeadbeef, true}, + {"0x7fffffffffffffff", std::numeric_limits<int64_t>::max(), true}, + {"-0x8000000000000000", 0, false}, + {"0x8000000000000000", UINT64_C(0x8000000000000000), true}, + {"-0x8000000000000001", 0, false}, + {"0xFFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(), true}, + {"FFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(), true}, + {"0x0000000000000000", 0, true}, + {"0000000000000000", 0, true}, + {"1FFFFFFFFFFFFFFFF", std::numeric_limits<uint64_t>::max(), + false}, // Overflow test. + {"0x0f", 15, true}, + {"0f", 15, true}, + {" 45", 0x45, false}, + {"\t\n\v\f\r 0x45", 0x45, false}, + {" 45", 0x45, false}, + {"45 ", 0x45, false}, + {"45:", 0x45, false}, + {"efgh", 0xef, false}, + {"0xefgh", 0xef, false}, + {"hgfe", 0, false}, + {"-", 0, false}, + {"", 0, false}, + {"0x", 0, false}, }; for (size_t i = 0; i < arraysize(cases); ++i) { - uint64 output = 0; + uint64_t output = 0; EXPECT_EQ(cases[i].success, HexStringToUInt64(cases[i].input, &output)); EXPECT_EQ(cases[i].output, output); } @@ -591,7 +602,7 @@ // interpreted as junk after the number. const char input[] = "0xc0ffee\0" "9"; std::string input_string(input, arraysize(input) - 1); - uint64 output; + uint64_t output; EXPECT_FALSE(HexStringToUInt64(input_string, &output)); EXPECT_EQ(0xc0ffeeU, output); } @@ -624,12 +635,12 @@ for (size_t i = 0; i < arraysize(cases); ++i) { - std::vector<uint8> output; - std::vector<uint8> compare; + std::vector<uint8_t> output; + std::vector<uint8_t> compare; EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) << i << ": " << cases[i].input; for (size_t j = 0; j < cases[i].output_len; ++j) - compare.push_back(static_cast<uint8>(cases[i].output[j])); + compare.push_back(static_cast<uint8_t>(cases[i].output[j])); ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input; EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) << i << ": " << cases[i].input; @@ -651,8 +662,10 @@ {"2.99792458e8", 299792458.0, true}, {"149597870.691E+3", 149597870691.0, true}, {"6.", 6.0, true}, - {"9e99999999999999999999", HUGE_VAL, false}, - {"-9e99999999999999999999", -HUGE_VAL, false}, + {"9e99999999999999999999", std::numeric_limits<double>::infinity(), + false}, + {"-9e99999999999999999999", -std::numeric_limits<double>::infinity(), + false}, {"1e-2", 0.01, true}, {"42 ", 42.0, false}, {" 1e-2", 0.01, false}, @@ -675,7 +688,8 @@ for (size_t i = 0; i < arraysize(cases); ++i) { double output; errno = 1; - EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output)); + EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output)) + << "for input=" << cases[i].input << "got output=" << output; if (cases[i].success) EXPECT_EQ(1, errno) << i; // confirm that errno is unchanged. EXPECT_DOUBLE_EQ(cases[i].output, output); @@ -696,13 +710,13 @@ double input; const char* expected; } cases[] = { - {0.0, "0"}, + {0.0, "0.0"}, {1.25, "1.25"}, - {1.33518e+012, "1.33518e+12"}, - {1.33489e+012, "1.33489e+12"}, - {1.33505e+012, "1.33505e+12"}, - {1.33545e+009, "1335450000"}, - {1.33503e+009, "1335030000"}, + {1.33518e+012, "1335180000000.0"}, + {1.33489e+012, "1334890000000.0"}, + {1.33505e+012, "1335050000000.0"}, + {1.33545e+009, "1335450000.0"}, + {1.33503e+009, "1335030000.0"}, }; for (size_t i = 0; i < arraysize(cases); ++i) { @@ -713,12 +727,12 @@ const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'}; double input = 0; memcpy(&input, input_bytes, arraysize(input_bytes)); - EXPECT_EQ("1335179083776", DoubleToString(input)); + EXPECT_EQ("1335179083776.0", DoubleToString(input)); const char input_bytes2[8] = {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'}; input = 0; memcpy(&input, input_bytes2, arraysize(input_bytes2)); - EXPECT_EQ("1334890332160", DoubleToString(input)); + EXPECT_EQ("1334890332160.0", DoubleToString(input)); } TEST(StringNumberConversionsTest, HexEncode) {