Revert 114929 - Standardize StringToInt{,64} interface.

base/string_number_conversions_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <math.h>
 
 #include <limits>
 
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 87 matching lines @@
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-2147483649", INT_MIN, false},
     {"-99999999999", INT_MIN, false},
     {"2147483648", INT_MAX, false},
     {"99999999999", INT_MAX, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(cases[i].input.begin(),
+                                            cases[i].input.end(),
+                                            &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
+    const char16* utf16_chars = utf16_input.c_str();
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(utf16_input.begin(),
+                                            utf16_input.end(),
+                                            &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(
+        utf16_chars, utf16_chars + utf16_input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "6\06";
   std::string input_string(input, arraysize(input) - 1);
   int output;
   EXPECT_FALSE(StringToInt(input_string, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(input_string.begin(), input_string.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(input, input + arraysize(input), &output));
+  EXPECT_EQ(6, output);
 
   string16 utf16_input = UTF8ToUTF16(input_string);
+  const char16* utf16_chars = utf16_input.c_str();
   output = 0;
   EXPECT_FALSE(StringToInt(utf16_input, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(utf16_input.begin(), utf16_input.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(utf16_chars,
+                           utf16_chars + utf16_input.length(),
+                           &output));
+  EXPECT_EQ(6, output);
 
   output = 0;
   const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
   EXPECT_FALSE(StringToInt(string16(negative_wide_input), &output));
   EXPECT_EQ(0, output);
 }
 
 TEST(StringNumberConversionsTest, StringToInt64) {
   static const struct {
     std::string input;
@@ skipping 27 matching lines @@
     {"-+123", 0, false},
     {"+-123", 0, false},
     {"-", 0, false},
     {"-9223372036854775809", kint64min, false},
     {"-99999999999999999999", kint64min, false},
     {"9223372036854775808", kint64max, false},
     {"99999999999999999999", kint64max, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int64 output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input.begin(),
+                                              cases[i].input.end(),
+                                              &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
+    const char16* utf16_chars = utf16_input.c_str();
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(utf16_input.begin(),
+                                              utf16_input.end(),
+                                              &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(
+        utf16_chars, utf16_chars + utf16_input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "6\06";
   std::string input_string(input, arraysize(input) - 1);
   int64 output;
   EXPECT_FALSE(StringToInt64(input_string, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(input_string.begin(),
+                             input_string.end(),
+                             &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(input, input + arraysize(input), &output));
+  EXPECT_EQ(6, output);
 
   string16 utf16_input = UTF8ToUTF16(input_string);
+  const char16* utf16_chars = utf16_input.c_str();
   output = 0;
   EXPECT_FALSE(StringToInt64(utf16_input, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(utf16_input.begin(), utf16_input.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(utf16_chars,
+                             utf16_chars + utf16_input.length(),
+                             &output));
+  EXPECT_EQ(6, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToInt) {
   static const struct {
     std::string input;
     int output;
     bool success;
   } cases[] = {
     {"0", 0, true},
     {"42", 66, true},
@@ skipping 20 matching lines @@
     {"efgh", 0xef, false},
     {"0xefgh", 0xef, false},
     {"hgfe", 0, false},
     {"100000000", -1, false},  // don't care about |output|, just |success|
     {"-", 0, false},
     {"", 0, false},
     {"0x", 0, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input.begin(),
+                                               cases[i].input.end(),
+                                               &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, HexStringToInt(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
   const char input[] = "0xc0ffee\09";
   std::string input_string(input, arraysize(input) - 1);
   int output;
   EXPECT_FALSE(HexStringToInt(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
+  output = 0;
+  EXPECT_FALSE(HexStringToInt(input_string.begin(),
+                              input_string.end(),
+                              &output));
+  EXPECT_EQ(0xc0ffee, output);
+  output = 0;
+  EXPECT_FALSE(HexStringToInt(input, input + arraysize(input), &output));
+  EXPECT_EQ(0xc0ffee, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToBytes) {
   static const struct {
     const std::string input;
     const char* output;
     size_t output_len;
     bool success;
   } cases[] = {
     {"0", "", 0, false},  // odd number of characters fails
@@ skipping 83 matching lines @@
 
 TEST(StringNumberConversionsTest, HexEncode) {
   std::string hex(HexEncode(NULL, 0));
   EXPECT_EQ(hex.length(), 0U);
   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
   hex = HexEncode(bytes, sizeof(bytes));
   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 }
 
 }  // namespace base