base/strings/string_number_conversions_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/strings/string_number_conversions.h"
   6
   7 #include <errno.h>
   8 #include <stdint.h>
   9 #include <stdio.h>
  10
  11 #include <cmath>
  12 #include <limits>
  13
  14 #include "base/format_macros.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace base {
  20
  21 namespace {
  22
  23 template <typename INT>
  24 struct IntToStringTest {
  25   INT num;
  26   const char* sexpected;
  27   const char* uexpected;
  28 };
  29
  30 }  // namespace
  31
  32 TEST(StringNumberConversionsTest, IntToString) {
  33   static const IntToStringTest<int> int_tests[] = {
  34       { 0, "0", "0" },
  35       { -1, "-1", "4294967295" },
  36       { std::numeric_limits<int>::max(), "2147483647", "2147483647" },
  37       { std::numeric_limits<int>::min(), "-2147483648", "2147483648" },
  38   };
  39   static const IntToStringTest<int64> int64_tests[] = {
  40       { 0, "0", "0" },
  41       { -1, "-1", "18446744073709551615" },
  42       { std::numeric_limits<int64>::max(),
  43         "9223372036854775807",
  44         "9223372036854775807", },
  45       { std::numeric_limits<int64>::min(),
  46         "-9223372036854775808",
  47         "9223372036854775808" },
  48   };
  49
  50   for (size_t i = 0; i < arraysize(int_tests); ++i) {
  51     const IntToStringTest<int>* test = &int_tests[i];
  52     EXPECT_EQ(IntToString(test->num), test->sexpected);
  53     EXPECT_EQ(IntToString16(test->num), UTF8ToUTF16(test->sexpected));
  54     EXPECT_EQ(UintToString(test->num), test->uexpected);
  55     EXPECT_EQ(UintToString16(test->num), UTF8ToUTF16(test->uexpected));
  56   }
  57   for (size_t i = 0; i < arraysize(int64_tests); ++i) {
  58     const IntToStringTest<int64>* test = &int64_tests[i];
  59     EXPECT_EQ(Int64ToString(test->num), test->sexpected);
  60     EXPECT_EQ(Int64ToString16(test->num), UTF8ToUTF16(test->sexpected));
  61     EXPECT_EQ(Uint64ToString(test->num), test->uexpected);
  62     EXPECT_EQ(Uint64ToString16(test->num), UTF8ToUTF16(test->uexpected));
  63   }
  64 }
  65
  66 TEST(StringNumberConversionsTest, Uint64ToString) {
  67   static const struct {
  68     uint64 input;
  69     std::string output;
  70   } cases[] = {
  71     {0, "0"},
  72     {42, "42"},
  73     {INT_MAX, "2147483647"},
  74     {kuint64max, "18446744073709551615"},
  75   };
  76
  77   for (size_t i = 0; i < arraysize(cases); ++i)
  78     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
  79 }
  80
  81 TEST(StringNumberConversionsTest, SizeTToString) {
  82   size_t size_t_max = std::numeric_limits<size_t>::max();
  83   std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
  84
  85   static const struct {
  86     size_t input;
  87     std::string output;
  88   } cases[] = {
  89     {0, "0"},
  90     {9, "9"},
  91     {42, "42"},
  92     {INT_MAX, "2147483647"},
  93     {2147483648U, "2147483648"},
  94 #if SIZE_MAX > 4294967295U
  95     {99999999999U, "99999999999"},
  96 #endif
  97     {size_t_max, size_t_max_string},
  98   };
  99
 100   for (size_t i = 0; i < arraysize(cases); ++i)
 101     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
 102 }
 103
 104 TEST(StringNumberConversionsTest, StringToInt) {
 105   static const struct {
 106     std::string input;
 107     int output;
 108     bool success;
 109   } cases[] = {
 110     {"0", 0, true},
 111     {"42", 42, true},
 112     {"42\x99", 42, false},
 113     {"\x99" "42\x99", 0, false},
 114     {"-2147483648", INT_MIN, true},
 115     {"2147483647", INT_MAX, true},
 116     {"", 0, false},
 117     {" 42", 42, false},
 118     {"42 ", 42, false},
 119     {"\t\n\v\f\r 42", 42, false},
 120     {"blah42", 0, false},
 121     {"42blah", 42, false},
 122     {"blah42blah", 0, false},
 123     {"-273.15", -273, false},
 124     {"+98.6", 98, false},
 125     {"--123", 0, false},
 126     {"++123", 0, false},
 127     {"-+123", 0, false},
 128     {"+-123", 0, false},
 129     {"-", 0, false},
 130     {"-2147483649", INT_MIN, false},
 131     {"-99999999999", INT_MIN, false},
 132     {"2147483648", INT_MAX, false},
 133     {"99999999999", INT_MAX, false},
 134   };
 135
 136   for (size_t i = 0; i < arraysize(cases); ++i) {
 137     int output = 0;
 138     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
 139     EXPECT_EQ(cases[i].output, output);
 140
 141     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 142     output = 0;
 143     EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
 144     EXPECT_EQ(cases[i].output, output);
 145   }
 146
 147   // One additional test to verify that conversion of numbers in strings with
 148   // embedded NUL characters.  The NUL and extra data after it should be
 149   // interpreted as junk after the number.
 150   const char input[] = "6\06";
 151   std::string input_string(input, arraysize(input) - 1);
 152   int output;
 153   EXPECT_FALSE(StringToInt(input_string, &output));
 154   EXPECT_EQ(6, output);
 155
 156   string16 utf16_input = UTF8ToUTF16(input_string);
 157   output = 0;
 158   EXPECT_FALSE(StringToInt(utf16_input, &output));
 159   EXPECT_EQ(6, output);
 160
 161   output = 0;
 162   const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
 163   EXPECT_FALSE(StringToInt(string16(negative_wide_input), &output));
 164   EXPECT_EQ(0, output);
 165 }
 166
 167 TEST(StringNumberConversionsTest, StringToUint) {
 168   static const struct {
 169     std::string input;
 170     unsigned output;
 171     bool success;
 172   } cases[] = {
 173     {"0", 0, true},
 174     {"42", 42, true},
 175     {"42\x99", 42, false},
 176     {"\x99" "42\x99", 0, false},
 177     {"-2147483648", 0, false},
 178     {"2147483647", INT_MAX, true},
 179     {"", 0, false},
 180     {" 42", 42, false},
 181     {"42 ", 42, false},
 182     {"\t\n\v\f\r 42", 42, false},
 183     {"blah42", 0, false},
 184     {"42blah", 42, false},
 185     {"blah42blah", 0, false},
 186     {"-273.15", 0, false},
 187     {"+98.6", 98, false},
 188     {"--123", 0, false},
 189     {"++123", 0, false},
 190     {"-+123", 0, false},
 191     {"+-123", 0, false},
 192     {"-", 0, false},
 193     {"-2147483649", 0, false},
 194     {"-99999999999", 0, false},
 195     {"4294967295", UINT_MAX, true},
 196     {"4294967296", UINT_MAX, false},
 197     {"99999999999", UINT_MAX, false},
 198   };
 199
 200   for (size_t i = 0; i < arraysize(cases); ++i) {
 201     unsigned output = 0;
 202     EXPECT_EQ(cases[i].success, StringToUint(cases[i].input, &output));
 203     EXPECT_EQ(cases[i].output, output);
 204
 205     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 206     output = 0;
 207     EXPECT_EQ(cases[i].success, StringToUint(utf16_input, &output));
 208     EXPECT_EQ(cases[i].output, output);
 209   }
 210
 211   // One additional test to verify that conversion of numbers in strings with
 212   // embedded NUL characters.  The NUL and extra data after it should be
 213   // interpreted as junk after the number.
 214   const char input[] = "6\06";
 215   std::string input_string(input, arraysize(input) - 1);
 216   unsigned output;
 217   EXPECT_FALSE(StringToUint(input_string, &output));
 218   EXPECT_EQ(6U, output);
 219
 220   string16 utf16_input = UTF8ToUTF16(input_string);
 221   output = 0;
 222   EXPECT_FALSE(StringToUint(utf16_input, &output));
 223   EXPECT_EQ(6U, output);
 224
 225   output = 0;
 226   const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
 227   EXPECT_FALSE(StringToUint(string16(negative_wide_input), &output));
 228   EXPECT_EQ(0U, output);
 229 }
 230
 231 TEST(StringNumberConversionsTest, StringToInt64) {
 232   static const struct {
 233     std::string input;
 234     int64 output;
 235     bool success;
 236   } cases[] = {
 237     {"0", 0, true},
 238     {"42", 42, true},
 239     {"-2147483648", INT_MIN, true},
 240     {"2147483647", INT_MAX, true},
 241     {"-2147483649", INT64_C(-2147483649), true},
 242     {"-99999999999", INT64_C(-99999999999), true},
 243     {"2147483648", INT64_C(2147483648), true},
 244     {"99999999999", INT64_C(99999999999), true},
 245     {"9223372036854775807", kint64max, true},
 246     {"-9223372036854775808", kint64min, true},
 247     {"09", 9, true},
 248     {"-09", -9, true},
 249     {"", 0, false},
 250     {" 42", 42, false},
 251     {"42 ", 42, false},
 252     {"0x42", 0, false},
 253     {"\t\n\v\f\r 42", 42, false},
 254     {"blah42", 0, false},
 255     {"42blah", 42, false},
 256     {"blah42blah", 0, false},
 257     {"-273.15", -273, false},
 258     {"+98.6", 98, false},
 259     {"--123", 0, false},
 260     {"++123", 0, false},
 261     {"-+123", 0, false},
 262     {"+-123", 0, false},
 263     {"-", 0, false},
 264     {"-9223372036854775809", kint64min, false},
 265     {"-99999999999999999999", kint64min, false},
 266     {"9223372036854775808", kint64max, false},
 267     {"99999999999999999999", kint64max, false},
 268   };
 269
 270   for (size_t i = 0; i < arraysize(cases); ++i) {
 271     int64 output = 0;
 272     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
 273     EXPECT_EQ(cases[i].output, output);
 274
 275     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 276     output = 0;
 277     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
 278     EXPECT_EQ(cases[i].output, output);
 279   }
 280
 281   // One additional test to verify that conversion of numbers in strings with
 282   // embedded NUL characters.  The NUL and extra data after it should be
 283   // interpreted as junk after the number.
 284   const char input[] = "6\06";
 285   std::string input_string(input, arraysize(input) - 1);
 286   int64 output;
 287   EXPECT_FALSE(StringToInt64(input_string, &output));
 288   EXPECT_EQ(6, output);
 289
 290   string16 utf16_input = UTF8ToUTF16(input_string);
 291   output = 0;
 292   EXPECT_FALSE(StringToInt64(utf16_input, &output));
 293   EXPECT_EQ(6, output);
 294 }
 295
 296 TEST(StringNumberConversionsTest, StringToUint64) {
 297   static const struct {
 298     std::string input;
 299     uint64 output;
 300     bool success;
 301   } cases[] = {
 302     {"0", 0, true},
 303     {"42", 42, true},
 304     {"-2147483648", 0, false},
 305     {"2147483647", INT_MAX, true},
 306     {"-2147483649", 0, false},
 307     {"-99999999999", 0, false},
 308     {"2147483648", UINT64_C(2147483648), true},
 309     {"99999999999", UINT64_C(99999999999), true},
 310     {"9223372036854775807", kint64max, true},
 311     {"-9223372036854775808", 0, false},
 312     {"09", 9, true},
 313     {"-09", 0, false},
 314     {"", 0, false},
 315     {" 42", 42, false},
 316     {"42 ", 42, false},
 317     {"0x42", 0, false},
 318     {"\t\n\v\f\r 42", 42, false},
 319     {"blah42", 0, false},
 320     {"42blah", 42, false},
 321     {"blah42blah", 0, false},
 322     {"-273.15", 0, false},
 323     {"+98.6", 98, false},
 324     {"--123", 0, false},
 325     {"++123", 0, false},
 326     {"-+123", 0, false},
 327     {"+-123", 0, false},
 328     {"-", 0, false},
 329     {"-9223372036854775809", 0, false},
 330     {"-99999999999999999999", 0, false},
 331     {"9223372036854775808", UINT64_C(9223372036854775808), true},
 332     {"99999999999999999999", kuint64max, false},
 333     {"18446744073709551615", kuint64max, true},
 334     {"18446744073709551616", kuint64max, false},
 335   };
 336
 337   for (size_t i = 0; i < arraysize(cases); ++i) {
 338     uint64 output = 0;
 339     EXPECT_EQ(cases[i].success, StringToUint64(cases[i].input, &output));
 340     EXPECT_EQ(cases[i].output, output);
 341
 342     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 343     output = 0;
 344     EXPECT_EQ(cases[i].success, StringToUint64(utf16_input, &output));
 345     EXPECT_EQ(cases[i].output, output);
 346   }
 347
 348   // One additional test to verify that conversion of numbers in strings with
 349   // embedded NUL characters.  The NUL and extra data after it should be
 350   // interpreted as junk after the number.
 351   const char input[] = "6\06";
 352   std::string input_string(input, arraysize(input) - 1);
 353   uint64 output;
 354   EXPECT_FALSE(StringToUint64(input_string, &output));
 355   EXPECT_EQ(6U, output);
 356
 357   string16 utf16_input = UTF8ToUTF16(input_string);
 358   output = 0;
 359   EXPECT_FALSE(StringToUint64(utf16_input, &output));
 360   EXPECT_EQ(6U, output);
 361 }
 362
 363 TEST(StringNumberConversionsTest, StringToSizeT) {
 364   size_t size_t_max = std::numeric_limits<size_t>::max();
 365   std::string size_t_max_string = StringPrintf("%" PRIuS, size_t_max);
 366
 367   static const struct {
 368     std::string input;
 369     size_t output;
 370     bool success;
 371   } cases[] = {
 372     {"0", 0, true},
 373     {"42", 42, true},
 374     {"-2147483648", 0, false},
 375     {"2147483647", INT_MAX, true},
 376     {"-2147483649", 0, false},
 377     {"-99999999999", 0, false},
 378     {"2147483648", 2147483648U, true},
 379 #if SIZE_MAX > 4294967295U
 380     {"99999999999", 99999999999U, true},
 381 #endif
 382     {"-9223372036854775808", 0, false},
 383     {"09", 9, true},
 384     {"-09", 0, false},
 385     {"", 0, false},
 386     {" 42", 42, false},
 387     {"42 ", 42, false},
 388     {"0x42", 0, false},
 389     {"\t\n\v\f\r 42", 42, false},
 390     {"blah42", 0, false},
 391     {"42blah", 42, false},
 392     {"blah42blah", 0, false},
 393     {"-273.15", 0, false},
 394     {"+98.6", 98, false},
 395     {"--123", 0, false},
 396     {"++123", 0, false},
 397     {"-+123", 0, false},
 398     {"+-123", 0, false},
 399     {"-", 0, false},
 400     {"-9223372036854775809", 0, false},
 401     {"-99999999999999999999", 0, false},
 402     {"999999999999999999999999", size_t_max, false},
 403     {size_t_max_string, size_t_max, true},
 404   };
 405
 406   for (size_t i = 0; i < arraysize(cases); ++i) {
 407     size_t output = 0;
 408     EXPECT_EQ(cases[i].success, StringToSizeT(cases[i].input, &output));
 409     EXPECT_EQ(cases[i].output, output);
 410
 411     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 412     output = 0;
 413     EXPECT_EQ(cases[i].success, StringToSizeT(utf16_input, &output));
 414     EXPECT_EQ(cases[i].output, output);
 415   }
 416
 417   // One additional test to verify that conversion of numbers in strings with
 418   // embedded NUL characters.  The NUL and extra data after it should be
 419   // interpreted as junk after the number.
 420   const char input[] = "6\06";
 421   std::string input_string(input, arraysize(input) - 1);
 422   size_t output;
 423   EXPECT_FALSE(StringToSizeT(input_string, &output));
 424   EXPECT_EQ(6U, output);
 425
 426   string16 utf16_input = UTF8ToUTF16(input_string);
 427   output = 0;
 428   EXPECT_FALSE(StringToSizeT(utf16_input, &output));
 429   EXPECT_EQ(6U, output);
 430 }
 431
 432 TEST(StringNumberConversionsTest, HexStringToInt) {
 433   static const struct {
 434     std::string input;
 435     int64 output;
 436     bool success;
 437   } cases[] = {
 438     {"0", 0, true},
 439     {"42", 66, true},
 440     {"-42", -66, true},
 441     {"+42", 66, true},
 442     {"7fffffff", INT_MAX, true},
 443     {"-80000000", INT_MIN, true},
 444     {"80000000", INT_MAX, false},  // Overflow test.
 445     {"-80000001", INT_MIN, false},  // Underflow test.
 446     {"0x42", 66, true},
 447     {"-0x42", -66, true},
 448     {"+0x42", 66, true},
 449     {"0x7fffffff", INT_MAX, true},
 450     {"-0x80000000", INT_MIN, true},
 451     {"-80000000", INT_MIN, true},
 452     {"80000000", INT_MAX, false},  // Overflow test.
 453     {"-80000001", INT_MIN, false},  // Underflow test.
 454     {"0x0f", 15, true},
 455     {"0f", 15, true},
 456     {" 45", 0x45, false},
 457     {"\t\n\v\f\r 0x45", 0x45, false},
 458     {" 45", 0x45, false},
 459     {"45 ", 0x45, false},
 460     {"45:", 0x45, false},
 461     {"efgh", 0xef, false},
 462     {"0xefgh", 0xef, false},
 463     {"hgfe", 0, false},
 464     {"-", 0, false},
 465     {"", 0, false},
 466     {"0x", 0, false},
 467   };
 468
 469   for (size_t i = 0; i < arraysize(cases); ++i) {
 470     int output = 0;
 471     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
 472     EXPECT_EQ(cases[i].output, output);
 473   }
 474   // One additional test to verify that conversion of numbers in strings with
 475   // embedded NUL characters.  The NUL and extra data after it should be
 476   // interpreted as junk after the number.
 477   const char input[] = "0xc0ffee\0" "9";
 478   std::string input_string(input, arraysize(input) - 1);
 479   int output;
 480   EXPECT_FALSE(HexStringToInt(input_string, &output));
 481   EXPECT_EQ(0xc0ffee, output);
 482 }
 483
 484 TEST(StringNumberConversionsTest, HexStringToUInt) {
 485   static const struct {
 486     std::string input;
 487     uint32 output;
 488     bool success;
 489   } cases[] = {
 490     {"0", 0, true},
 491     {"42", 0x42, true},
 492     {"-42", 0, false},
 493     {"+42", 0x42, true},
 494     {"7fffffff", INT_MAX, true},
 495     {"-80000000", 0, false},
 496     {"ffffffff", 0xffffffff, true},
 497     {"DeadBeef", 0xdeadbeef, true},
 498     {"0x42", 0x42, true},
 499     {"-0x42", 0, false},
 500     {"+0x42", 0x42, true},
 501     {"0x7fffffff", INT_MAX, true},
 502     {"-0x80000000", 0, false},
 503     {"0xffffffff", kuint32max, true},
 504     {"0XDeadBeef", 0xdeadbeef, true},
 505     {"0x7fffffffffffffff", kuint32max, false},  // Overflow test.
 506     {"-0x8000000000000000", 0, false},
 507     {"0x8000000000000000", kuint32max, false},  // Overflow test.
 508     {"-0x8000000000000001", 0, false},
 509     {"0xFFFFFFFFFFFFFFFF", kuint32max, false},  // Overflow test.
 510     {"FFFFFFFFFFFFFFFF", kuint32max, false},  // Overflow test.
 511     {"0x0000000000000000", 0, true},
 512     {"0000000000000000", 0, true},
 513     {"1FFFFFFFFFFFFFFFF", kuint32max, false}, // Overflow test.
 514     {"0x0f", 0x0f, true},
 515     {"0f", 0x0f, true},
 516     {" 45", 0x45, false},
 517     {"\t\n\v\f\r 0x45", 0x45, false},
 518     {" 45", 0x45, false},
 519     {"45 ", 0x45, false},
 520     {"45:", 0x45, false},
 521     {"efgh", 0xef, false},
 522     {"0xefgh", 0xef, false},
 523     {"hgfe", 0, false},
 524     {"-", 0, false},
 525     {"", 0, false},
 526     {"0x", 0, false},
 527   };
 528
 529   for (size_t i = 0; i < arraysize(cases); ++i) {
 530     uint32 output = 0;
 531     EXPECT_EQ(cases[i].success, HexStringToUInt(cases[i].input, &output));
 532     EXPECT_EQ(cases[i].output, output);
 533   }
 534   // One additional test to verify that conversion of numbers in strings with
 535   // embedded NUL characters.  The NUL and extra data after it should be
 536   // interpreted as junk after the number.
 537   const char input[] = "0xc0ffee\0" "9";
 538   std::string input_string(input, arraysize(input) - 1);
 539   uint32 output;
 540   EXPECT_FALSE(HexStringToUInt(input_string, &output));
 541   EXPECT_EQ(0xc0ffeeU, output);
 542 }
 543
 544 TEST(StringNumberConversionsTest, HexStringToInt64) {
 545   static const struct {
 546     std::string input;
 547     int64 output;
 548     bool success;
 549   } cases[] = {
 550     {"0", 0, true},
 551     {"42", 66, true},
 552     {"-42", -66, true},
 553     {"+42", 66, true},
 554     {"40acd88557b", INT64_C(4444444448123), true},
 555     {"7fffffff", INT_MAX, true},
 556     {"-80000000", INT_MIN, true},
 557     {"ffffffff", 0xffffffff, true},
 558     {"DeadBeef", 0xdeadbeef, true},
 559     {"0x42", 66, true},
 560     {"-0x42", -66, true},
 561     {"+0x42", 66, true},
 562     {"0x40acd88557b", INT64_C(4444444448123), true},
 563     {"0x7fffffff", INT_MAX, true},
 564     {"-0x80000000", INT_MIN, true},
 565     {"0xffffffff", 0xffffffff, true},
 566     {"0XDeadBeef", 0xdeadbeef, true},
 567     {"0x7fffffffffffffff", kint64max, true},
 568     {"-0x8000000000000000", kint64min, true},
 569     {"0x8000000000000000", kint64max, false},  // Overflow test.
 570     {"-0x8000000000000001", kint64min, false},  // Underflow test.
 571     {"0x0f", 15, true},
 572     {"0f", 15, true},
 573     {" 45", 0x45, false},
 574     {"\t\n\v\f\r 0x45", 0x45, false},
 575     {" 45", 0x45, false},
 576     {"45 ", 0x45, false},
 577     {"45:", 0x45, false},
 578     {"efgh", 0xef, false},
 579     {"0xefgh", 0xef, false},
 580     {"hgfe", 0, false},
 581     {"-", 0, false},
 582     {"", 0, false},
 583     {"0x", 0, false},
 584   };
 585
 586   for (size_t i = 0; i < arraysize(cases); ++i) {
 587     int64 output = 0;
 588     EXPECT_EQ(cases[i].success, HexStringToInt64(cases[i].input, &output));
 589     EXPECT_EQ(cases[i].output, output);
 590   }
 591   // One additional test to verify that conversion of numbers in strings with
 592   // embedded NUL characters.  The NUL and extra data after it should be
 593   // interpreted as junk after the number.
 594   const char input[] = "0xc0ffee\0" "9";
 595   std::string input_string(input, arraysize(input) - 1);
 596   int64 output;
 597   EXPECT_FALSE(HexStringToInt64(input_string, &output));
 598   EXPECT_EQ(0xc0ffee, output);
 599 }
 600
 601 TEST(StringNumberConversionsTest, HexStringToUInt64) {
 602   static const struct {
 603     std::string input;
 604     uint64 output;
 605     bool success;
 606   } cases[] = {
 607     {"0", 0, true},
 608     {"42", 66, true},
 609     {"-42", 0, false},
 610     {"+42", 66, true},
 611     {"40acd88557b", INT64_C(4444444448123), true},
 612     {"7fffffff", INT_MAX, true},
 613     {"-80000000", 0, false},
 614     {"ffffffff", 0xffffffff, true},
 615     {"DeadBeef", 0xdeadbeef, true},
 616     {"0x42", 66, true},
 617     {"-0x42", 0, false},
 618     {"+0x42", 66, true},
 619     {"0x40acd88557b", INT64_C(4444444448123), true},
 620     {"0x7fffffff", INT_MAX, true},
 621     {"-0x80000000", 0, false},
 622     {"0xffffffff", 0xffffffff, true},
 623     {"0XDeadBeef", 0xdeadbeef, true},
 624     {"0x7fffffffffffffff", kint64max, true},
 625     {"-0x8000000000000000", 0, false},
 626     {"0x8000000000000000", UINT64_C(0x8000000000000000), true},
 627     {"-0x8000000000000001", 0, false},
 628     {"0xFFFFFFFFFFFFFFFF", kuint64max, true},
 629     {"FFFFFFFFFFFFFFFF", kuint64max, true},
 630     {"0x0000000000000000", 0, true},
 631     {"0000000000000000", 0, true},
 632     {"1FFFFFFFFFFFFFFFF", kuint64max, false}, // Overflow test.
 633     {"0x0f", 15, true},
 634     {"0f", 15, true},
 635     {" 45", 0x45, false},
 636     {"\t\n\v\f\r 0x45", 0x45, false},
 637     {" 45", 0x45, false},
 638     {"45 ", 0x45, false},
 639     {"45:", 0x45, false},
 640     {"efgh", 0xef, false},
 641     {"0xefgh", 0xef, false},
 642     {"hgfe", 0, false},
 643     {"-", 0, false},
 644     {"", 0, false},
 645     {"0x", 0, false},
 646   };
 647
 648   for (size_t i = 0; i < arraysize(cases); ++i) {
 649     uint64 output = 0;
 650     EXPECT_EQ(cases[i].success, HexStringToUInt64(cases[i].input, &output));
 651     EXPECT_EQ(cases[i].output, output);
 652   }
 653   // One additional test to verify that conversion of numbers in strings with
 654   // embedded NUL characters.  The NUL and extra data after it should be
 655   // interpreted as junk after the number.
 656   const char input[] = "0xc0ffee\0" "9";
 657   std::string input_string(input, arraysize(input) - 1);
 658   uint64 output;
 659   EXPECT_FALSE(HexStringToUInt64(input_string, &output));
 660   EXPECT_EQ(0xc0ffeeU, output);
 661 }
 662
 663 TEST(StringNumberConversionsTest, HexStringToBytes) {
 664   static const struct {
 665     const std::string input;
 666     const char* output;
 667     size_t output_len;
 668     bool success;
 669   } cases[] = {
 670     {"0", "", 0, false},  // odd number of characters fails
 671     {"00", "\0", 1, true},
 672     {"42", "\x42", 1, true},
 673     {"-42", "", 0, false},  // any non-hex value fails
 674     {"+42", "", 0, false},
 675     {"7fffffff", "\x7f\xff\xff\xff", 4, true},
 676     {"80000000", "\x80\0\0\0", 4, true},
 677     {"deadbeef", "\xde\xad\xbe\xef", 4, true},
 678     {"DeadBeef", "\xde\xad\xbe\xef", 4, true},
 679     {"0x42", "", 0, false},  // leading 0x fails (x is not hex)
 680     {"0f", "\xf", 1, true},
 681     {"45  ", "\x45", 1, false},
 682     {"efgh", "\xef", 1, false},
 683     {"", "", 0, false},
 684     {"0123456789ABCDEF", "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8, true},
 685     {"0123456789ABCDEF012345",
 686      "\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
 687   };
 688
 689
 690   for (size_t i = 0; i < arraysize(cases); ++i) {
 691     std::vector<uint8> output;
 692     std::vector<uint8> compare;
 693     EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
 694         i << ": " << cases[i].input;
 695     for (size_t j = 0; j < cases[i].output_len; ++j)
 696       compare.push_back(static_cast<uint8>(cases[i].output[j]));
 697     ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
 698     EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
 699         i << ": " << cases[i].input;
 700   }
 701 }
 702
 703 TEST(StringNumberConversionsTest, StringToDouble) {
 704   static const struct {
 705     std::string input;
 706     double output;
 707     bool success;
 708   } cases[] = {
 709     {"0", 0.0, true},
 710     {"42", 42.0, true},
 711     {"-42", -42.0, true},
 712     {"123.45", 123.45, true},
 713     {"-123.45", -123.45, true},
 714     {"+123.45", 123.45, true},
 715     {"2.99792458e8", 299792458.0, true},
 716     {"149597870.691E+3", 149597870691.0, true},
 717     {"6.", 6.0, true},
 718     {"9e99999999999999999999", HUGE_VAL, false},
 719     {"-9e99999999999999999999", -HUGE_VAL, false},
 720     {"1e-2", 0.01, true},
 721     {"42 ", 42.0, false},
 722     {" 1e-2", 0.01, false},
 723     {"1e-2 ", 0.01, false},
 724     {"-1E-7", -0.0000001, true},
 725     {"01e02", 100, true},
 726     {"2.3e15", 2.3e15, true},
 727     {"\t\n\v\f\r -123.45e2", -12345.0, false},
 728     {"+123 e4", 123.0, false},
 729     {"123e ", 123.0, false},
 730     {"123e", 123.0, false},
 731     {" 2.99", 2.99, false},
 732     {"1e3.4", 1000.0, false},
 733     {"nothing", 0.0, false},
 734     {"-", 0.0, false},
 735     {"+", 0.0, false},
 736     {"", 0.0, false},
 737   };
 738
 739   for (size_t i = 0; i < arraysize(cases); ++i) {
 740     double output;
 741     errno = 1;
 742     EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
 743     if (cases[i].success)
 744       EXPECT_EQ(1, errno) << i;  // confirm that errno is unchanged.
 745     EXPECT_DOUBLE_EQ(cases[i].output, output);
 746   }
 747
 748   // One additional test to verify that conversion of numbers in strings with
 749   // embedded NUL characters.  The NUL and extra data after it should be
 750   // interpreted as junk after the number.
 751   const char input[] = "3.14\0" "159";
 752   std::string input_string(input, arraysize(input) - 1);
 753   double output;
 754   EXPECT_FALSE(StringToDouble(input_string, &output));
 755   EXPECT_DOUBLE_EQ(3.14, output);
 756 }
 757
 758 TEST(StringNumberConversionsTest, DoubleToString) {
 759   static const struct {
 760     double input;
 761     const char* expected;
 762   } cases[] = {
 763     {0.0, "0"},
 764     {1.25, "1.25"},
 765     {1.33518e+012, "1.33518e+12"},
 766     {1.33489e+012, "1.33489e+12"},
 767     {1.33505e+012, "1.33505e+12"},
 768     {1.33545e+009, "1335450000"},
 769     {1.33503e+009, "1335030000"},
 770   };
 771
 772   for (size_t i = 0; i < arraysize(cases); ++i) {
 773     EXPECT_EQ(cases[i].expected, DoubleToString(cases[i].input));
 774   }
 775
 776   // The following two values were seen in crashes in the wild.
 777   const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
 778   double input = 0;
 779   memcpy(&input, input_bytes, arraysize(input_bytes));
 780   EXPECT_EQ("1335179083776", DoubleToString(input));
 781   const char input_bytes2[8] =
 782       {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
 783   input = 0;
 784   memcpy(&input, input_bytes2, arraysize(input_bytes2));
 785   EXPECT_EQ("1334890332160", DoubleToString(input));
 786 }
 787
 788 TEST(StringNumberConversionsTest, HexEncode) {
 789   std::string hex(HexEncode(NULL, 0));
 790   EXPECT_EQ(hex.length(), 0U);
 791   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
 792   hex = HexEncode(bytes, sizeof(bytes));
 793   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 794 }
 795
 796 }  // namespace base