base/string_number_conversions_unittest.cc

   1 // Copyright (c) 2010 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 <math.h>
   6
   7 #include <limits>
   8
   9 #include "base/string_number_conversions.h"
  10 #include "base/utf_string_conversions.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace base {
  14
  15 namespace {
  16
  17 template <typename INT>
  18 struct IntToStringTest {
  19   INT num;
  20   const char* sexpected;
  21   const char* uexpected;
  22 };
  23
  24 }  // namespace
  25
  26 TEST(StringNumberConversionsTest, IntToString) {
  27   static const IntToStringTest<int> int_tests[] = {
  28       { 0, "0", "0" },
  29       { -1, "-1", "4294967295" },
  30       { std::numeric_limits<int>::max(), "2147483647", "2147483647" },
  31       { std::numeric_limits<int>::min(), "-2147483648", "2147483648" },
  32   };
  33   static const IntToStringTest<int64> int64_tests[] = {
  34       { 0, "0", "0" },
  35       { -1, "-1", "18446744073709551615" },
  36       { std::numeric_limits<int64>::max(),
  37         "9223372036854775807",
  38         "9223372036854775807", },
  39       { std::numeric_limits<int64>::min(),
  40         "-9223372036854775808",
  41         "9223372036854775808" },
  42   };
  43
  44   for (size_t i = 0; i < arraysize(int_tests); ++i) {
  45     const IntToStringTest<int>* test = &int_tests[i];
  46     EXPECT_EQ(IntToString(test->num), test->sexpected);
  47     EXPECT_EQ(IntToString16(test->num), UTF8ToUTF16(test->sexpected));
  48     EXPECT_EQ(UintToString(test->num), test->uexpected);
  49     EXPECT_EQ(UintToString16(test->num), UTF8ToUTF16(test->uexpected));
  50   }
  51   for (size_t i = 0; i < arraysize(int64_tests); ++i) {
  52     const IntToStringTest<int64>* test = &int64_tests[i];
  53     EXPECT_EQ(Int64ToString(test->num), test->sexpected);
  54     EXPECT_EQ(Int64ToString16(test->num), UTF8ToUTF16(test->sexpected));
  55     EXPECT_EQ(Uint64ToString(test->num), test->uexpected);
  56     EXPECT_EQ(Uint64ToString16(test->num), UTF8ToUTF16(test->uexpected));
  57   }
  58 }
  59
  60 TEST(StringNumberConversionsTest, Uint64ToString) {
  61   static const struct {
  62     uint64 input;
  63     std::string output;
  64   } cases[] = {
  65     {0, "0"},
  66     {42, "42"},
  67     {INT_MAX, "2147483647"},
  68     {kuint64max, "18446744073709551615"},
  69   };
  70
  71   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i)
  72     EXPECT_EQ(cases[i].output, Uint64ToString(cases[i].input));
  73 }
  74
  75 TEST(StringNumberConversionsTest, StringToInt) {
  76   static const struct {
  77     std::string input;
  78     int output;
  79     bool success;
  80   } cases[] = {
  81     {"0", 0, true},
  82     {"42", 42, true},
  83     {"42\x99", 42, false},
  84     {"\x99" "42\x99", 0, false},
  85     {"-2147483648", INT_MIN, true},
  86     {"2147483647", INT_MAX, true},
  87     {"", 0, false},
  88     {" 42", 42, false},
  89     {"42 ", 42, false},
  90     {"\t\n\v\f\r 42", 42, false},
  91     {"blah42", 0, false},
  92     {"42blah", 42, false},
  93     {"blah42blah", 0, false},
  94     {"-273.15", -273, false},
  95     {"+98.6", 98, false},
  96     {"--123", 0, false},
  97     {"++123", 0, false},
  98     {"-+123", 0, false},
  99     {"+-123", 0, false},
 100     {"-", 0, false},
 101     {"-2147483649", INT_MIN, false},
 102     {"-99999999999", INT_MIN, false},
 103     {"2147483648", INT_MAX, false},
 104     {"99999999999", INT_MAX, false},
 105   };
 106
 107   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 108     const char* ascii_chars = cases[i].input.c_str();
 109     int output = 0;
 110     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
 111     EXPECT_EQ(cases[i].output, output);
 112     output = 0;
 113     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input.begin(),
 114                                             cases[i].input.end(),
 115                                             &output));
 116     EXPECT_EQ(cases[i].output, output);
 117     output = 0;
 118     EXPECT_EQ(cases[i].success, StringToInt(
 119         ascii_chars, ascii_chars + cases[i].input.length(), &output));
 120     EXPECT_EQ(cases[i].output, output);
 121
 122     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 123     const char16* utf16_chars = utf16_input.c_str();
 124     output = 0;
 125     EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
 126     EXPECT_EQ(cases[i].output, output);
 127     output = 0;
 128     EXPECT_EQ(cases[i].success, StringToInt(utf16_input.begin(),
 129                                             utf16_input.end(),
 130                                             &output));
 131     EXPECT_EQ(cases[i].output, output);
 132     output = 0;
 133     EXPECT_EQ(cases[i].success, StringToInt(
 134         utf16_chars, utf16_chars + utf16_input.length(), &output));
 135     EXPECT_EQ(cases[i].output, output);
 136   }
 137
 138   // One additional test to verify that conversion of numbers in strings with
 139   // embedded NUL characters.  The NUL and extra data after it should be
 140   // interpreted as junk after the number.
 141   const char input[] = "6\06";
 142   std::string input_string(input, arraysize(input) - 1);
 143   int output;
 144   EXPECT_FALSE(StringToInt(input_string, &output));
 145   EXPECT_EQ(6, output);
 146   output = 0;
 147   EXPECT_FALSE(StringToInt(input_string.begin(), input_string.end(), &output));
 148   EXPECT_EQ(6, output);
 149   output = 0;
 150   EXPECT_FALSE(StringToInt(input, input + arraysize(input), &output));
 151   EXPECT_EQ(6, output);
 152
 153   string16 utf16_input = UTF8ToUTF16(input_string);
 154   const char16* utf16_chars = utf16_input.c_str();
 155   output = 0;
 156   EXPECT_FALSE(StringToInt(utf16_input, &output));
 157   EXPECT_EQ(6, output);
 158   output = 0;
 159   EXPECT_FALSE(StringToInt(utf16_input.begin(), utf16_input.end(), &output));
 160   EXPECT_EQ(6, output);
 161   output = 0;
 162   EXPECT_FALSE(StringToInt(utf16_chars,
 163                            utf16_chars + utf16_input.length(),
 164                            &output));
 165   EXPECT_EQ(6, output);
 166
 167   output = 0;
 168   const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
 169   EXPECT_FALSE(StringToInt(string16(negative_wide_input), &output));
 170   EXPECT_EQ(0, output);
 171 }
 172
 173 TEST(StringNumberConversionsTest, StringToInt64) {
 174   static const struct {
 175     std::string input;
 176     int64 output;
 177     bool success;
 178   } cases[] = {
 179     {"0", 0, true},
 180     {"42", 42, true},
 181     {"-2147483648", INT_MIN, true},
 182     {"2147483647", INT_MAX, true},
 183     {"-2147483649", GG_INT64_C(-2147483649), true},
 184     {"-99999999999", GG_INT64_C(-99999999999), true},
 185     {"2147483648", GG_INT64_C(2147483648), true},
 186     {"99999999999", GG_INT64_C(99999999999), true},
 187     {"9223372036854775807", kint64max, true},
 188     {"-9223372036854775808", kint64min, true},
 189     {"09", 9, true},
 190     {"-09", -9, true},
 191     {"", 0, false},
 192     {" 42", 42, false},
 193     {"42 ", 42, false},
 194     {"0x42", 0, false},
 195     {"\t\n\v\f\r 42", 42, false},
 196     {"blah42", 0, false},
 197     {"42blah", 42, false},
 198     {"blah42blah", 0, false},
 199     {"-273.15", -273, false},
 200     {"+98.6", 98, false},
 201     {"--123", 0, false},
 202     {"++123", 0, false},
 203     {"-+123", 0, false},
 204     {"+-123", 0, false},
 205     {"-", 0, false},
 206     {"-9223372036854775809", kint64min, false},
 207     {"-99999999999999999999", kint64min, false},
 208     {"9223372036854775808", kint64max, false},
 209     {"99999999999999999999", kint64max, false},
 210   };
 211
 212   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 213     const char* ascii_chars = cases[i].input.c_str();
 214     int64 output = 0;
 215     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
 216     EXPECT_EQ(cases[i].output, output);
 217     output = 0;
 218     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input.begin(),
 219                                               cases[i].input.end(),
 220                                               &output));
 221     EXPECT_EQ(cases[i].output, output);
 222     output = 0;
 223     EXPECT_EQ(cases[i].success, StringToInt64(
 224         ascii_chars, ascii_chars + cases[i].input.length(), &output));
 225     EXPECT_EQ(cases[i].output, output);
 226
 227     string16 utf16_input = UTF8ToUTF16(cases[i].input);
 228     const char16* utf16_chars = utf16_input.c_str();
 229     output = 0;
 230     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
 231     EXPECT_EQ(cases[i].output, output);
 232     output = 0;
 233     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input.begin(),
 234                                               utf16_input.end(),
 235                                               &output));
 236     EXPECT_EQ(cases[i].output, output);
 237     output = 0;
 238     EXPECT_EQ(cases[i].success, StringToInt64(
 239         utf16_chars, utf16_chars + utf16_input.length(), &output));
 240     EXPECT_EQ(cases[i].output, output);
 241   }
 242
 243   // One additional test to verify that conversion of numbers in strings with
 244   // embedded NUL characters.  The NUL and extra data after it should be
 245   // interpreted as junk after the number.
 246   const char input[] = "6\06";
 247   std::string input_string(input, arraysize(input) - 1);
 248   int64 output;
 249   EXPECT_FALSE(StringToInt64(input_string, &output));
 250   EXPECT_EQ(6, output);
 251   output = 0;
 252   EXPECT_FALSE(StringToInt64(input_string.begin(),
 253                              input_string.end(),
 254                              &output));
 255   EXPECT_EQ(6, output);
 256   output = 0;
 257   EXPECT_FALSE(StringToInt64(input, input + arraysize(input), &output));
 258   EXPECT_EQ(6, output);
 259
 260   string16 utf16_input = UTF8ToUTF16(input_string);
 261   const char16* utf16_chars = utf16_input.c_str();
 262   output = 0;
 263   EXPECT_FALSE(StringToInt64(utf16_input, &output));
 264   EXPECT_EQ(6, output);
 265   output = 0;
 266   EXPECT_FALSE(StringToInt64(utf16_input.begin(), utf16_input.end(), &output));
 267   EXPECT_EQ(6, output);
 268   output = 0;
 269   EXPECT_FALSE(StringToInt64(utf16_chars,
 270                              utf16_chars + utf16_input.length(),
 271                              &output));
 272   EXPECT_EQ(6, output);
 273 }
 274
 275 TEST(StringNumberConversionsTest, HexStringToInt) {
 276   static const struct {
 277     std::string input;
 278     int output;
 279     bool success;
 280   } cases[] = {
 281     {"0", 0, true},
 282     {"42", 66, true},
 283     {"-42", -66, true},
 284     {"+42", 66, true},
 285     {"7fffffff", INT_MAX, true},
 286     {"80000000", INT_MIN, true},
 287     {"ffffffff", -1, true},
 288     {"DeadBeef", 0xdeadbeef, true},
 289     {"0x42", 66, true},
 290     {"-0x42", -66, true},
 291     {"+0x42", 66, true},
 292     {"0x7fffffff", INT_MAX, true},
 293     {"0x80000000", INT_MIN, true},
 294     {"0xffffffff", -1, true},
 295     {"0XDeadBeef", 0xdeadbeef, true},
 296     {"0x0f", 15, true},
 297     {"0f", 15, true},
 298     {" 45", 0x45, false},
 299     {"\t\n\v\f\r 0x45", 0x45, false},
 300     {" 45", 0x45, false},
 301     {"45 ", 0x45, false},
 302     {"45:", 0x45, false},
 303     {"efgh", 0xef, false},
 304     {"0xefgh", 0xef, false},
 305     {"hgfe", 0, false},
 306     {"100000000", -1, false},  // don't care about |output|, just |success|
 307     {"-", 0, false},
 308     {"", 0, false},
 309   };
 310
 311   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 312     const char* ascii_chars = cases[i].input.c_str();
 313     int output = 0;
 314     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
 315     EXPECT_EQ(cases[i].output, output);
 316     output = 0;
 317     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input.begin(),
 318                                                cases[i].input.end(),
 319                                                &output));
 320     EXPECT_EQ(cases[i].output, output);
 321     output = 0;
 322     EXPECT_EQ(cases[i].success, HexStringToInt(
 323         ascii_chars, ascii_chars + cases[i].input.length(), &output));
 324     EXPECT_EQ(cases[i].output, output);
 325   }
 326   // One additional test to verify that conversion of numbers in strings with
 327   // embedded NUL characters.  The NUL and extra data after it should be
 328   // interpreted as junk after the number.
 329   const char input[] = "0xc0ffee\09";
 330   std::string input_string(input, arraysize(input) - 1);
 331   int output;
 332   EXPECT_FALSE(HexStringToInt(input_string, &output));
 333   EXPECT_EQ(0xc0ffee, output);
 334   output = 0;
 335   EXPECT_FALSE(HexStringToInt(input_string.begin(),
 336                               input_string.end(),
 337                               &output));
 338   EXPECT_EQ(0xc0ffee, output);
 339   output = 0;
 340   EXPECT_FALSE(HexStringToInt(input, input + arraysize(input), &output));
 341   EXPECT_EQ(0xc0ffee, output);
 342 }
 343
 344 TEST(StringNumberConversionsTest, HexStringToBytes) {
 345   static const struct {
 346     const std::string input;
 347     const char* output;
 348     size_t output_len;
 349     bool success;
 350   } cases[] = {
 351     {"0", "", 0, false},  // odd number of characters fails
 352     {"00", "\0", 1, true},
 353     {"42", "\x42", 1, true},
 354     {"-42", "", 0, false},  // any non-hex value fails
 355     {"+42", "", 0, false},
 356     {"7fffffff", "\x7f\xff\xff\xff", 4, true},
 357     {"80000000", "\x80\0\0\0", 4, true},
 358     {"deadbeef", "\xde\xad\xbe\xef", 4, true},
 359     {"DeadBeef", "\xde\xad\xbe\xef", 4, true},
 360     {"0x42", "", 0, false},  // leading 0x fails (x is not hex)
 361     {"0f", "\xf", 1, true},
 362     {"45  ", "\x45", 1, false},
 363     {"efgh", "\xef", 1, false},
 364     {"", "", 0, false},
 365     {"0123456789ABCDEF", "\x01\x23\x45\x67\x89\xAB\xCD\xEF", 8, true},
 366     {"0123456789ABCDEF012345",
 367      "\x01\x23\x45\x67\x89\xAB\xCD\xEF\x01\x23\x45", 11, true},
 368   };
 369
 370
 371   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 372     std::vector<uint8> output;
 373     std::vector<uint8> compare;
 374     EXPECT_EQ(cases[i].success, HexStringToBytes(cases[i].input, &output)) <<
 375         i << ": " << cases[i].input;
 376     for (size_t j = 0; j < cases[i].output_len; ++j)
 377       compare.push_back(static_cast<uint8>(cases[i].output[j]));
 378     ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
 379     EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
 380         i << ": " << cases[i].input;
 381   }
 382 }
 383
 384 TEST(StringNumberConversionsTest, StringToDouble) {
 385   static const struct {
 386     std::string input;
 387     double output;
 388     bool success;
 389   } cases[] = {
 390     {"0", 0.0, true},
 391     {"42", 42.0, true},
 392     {"-42", -42.0, true},
 393     {"123.45", 123.45, true},
 394     {"-123.45", -123.45, true},
 395     {"+123.45", 123.45, true},
 396     {"2.99792458e8", 299792458.0, true},
 397     {"149597870.691E+3", 149597870691.0, true},
 398     {"6.", 6.0, true},
 399     {"9e99999999999999999999", HUGE_VAL, false},
 400     {"-9e99999999999999999999", -HUGE_VAL, false},
 401     {"1e-2", 0.01, true},
 402     {"42 ", 42.0, false},
 403     {" 1e-2", 0.01, false},
 404     {"1e-2 ", 0.01, false},
 405     {"-1E-7", -0.0000001, true},
 406     {"01e02", 100, true},
 407     {"2.3e15", 2.3e15, true},
 408     {"\t\n\v\f\r -123.45e2", -12345.0, false},
 409     {"+123 e4", 123.0, false},
 410     {"123e ", 123.0, false},
 411     {"123e", 123.0, false},
 412     {" 2.99", 2.99, false},
 413     {"1e3.4", 1000.0, false},
 414     {"nothing", 0.0, false},
 415     {"-", 0.0, false},
 416     {"+", 0.0, false},
 417     {"", 0.0, false},
 418   };
 419
 420   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
 421     double output;
 422     EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
 423     EXPECT_DOUBLE_EQ(cases[i].output, output);
 424   }
 425
 426   // One additional test to verify that conversion of numbers in strings with
 427   // embedded NUL characters.  The NUL and extra data after it should be
 428   // interpreted as junk after the number.
 429   const char input[] = "3.14\0159";
 430   std::string input_string(input, arraysize(input) - 1);
 431   double output;
 432   EXPECT_FALSE(StringToDouble(input_string, &output));
 433   EXPECT_DOUBLE_EQ(3.14, output);
 434 }
 435
 436 TEST(StringNumberConversionsTest, HexEncode) {
 437   std::string hex(HexEncode(NULL, 0));
 438   EXPECT_EQ(hex.length(), 0U);
 439   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
 440   hex = HexEncode(bytes, sizeof(bytes));
 441   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 442 }
 443
 444 }  // namespace base