Get rid of wstring variants of StringToFoo.

base/string_util_unittest.cc

 // Copyright (c) 2006-2008 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 <stdarg.h>
 
 #include <limits>
 #include <sstream>
 
@@ skipping 810 matching lines @@
     {"99999999999", INT_MAX, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     EXPECT_EQ(cases[i].output, StringToInt(cases[i].input));
     int output;
     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     std::wstring wide_input = ASCIIToWide(cases[i].input);
-    EXPECT_EQ(cases[i].output, StringToInt(wide_input));
-    EXPECT_EQ(cases[i].success, StringToInt(wide_input, &output));
+    EXPECT_EQ(cases[i].output, StringToInt(WideToUTF16Hack(wide_input)));
+    EXPECT_EQ(cases[i].success, StringToInt(WideToUTF16Hack(wide_input),
+                                            &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);
 
   std::wstring wide_input = ASCIIToWide(input_string);
-  EXPECT_FALSE(StringToInt(wide_input, &output));
+  EXPECT_FALSE(StringToInt(WideToUTF16Hack(wide_input), &output));
   EXPECT_EQ(6, output);
 }
 
 TEST(StringUtilTest, StringToInt64) {
   static const struct {
     std::string input;
     int64 output;
     bool success;
   } cases[] = {
     {"0", 0, true},
@@ skipping 28 matching lines @@
     {"99999999999999999999", kint64max, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     EXPECT_EQ(cases[i].output, StringToInt64(cases[i].input));
     int64 output;
     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     std::wstring wide_input = ASCIIToWide(cases[i].input);
-    EXPECT_EQ(cases[i].output, StringToInt64(wide_input));
-    EXPECT_EQ(cases[i].success, StringToInt64(wide_input, &output));
+    EXPECT_EQ(cases[i].output, StringToInt64(WideToUTF16Hack(wide_input)));
+    EXPECT_EQ(cases[i].success, StringToInt64(WideToUTF16Hack(wide_input),
+                                              &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);
 
   std::wstring wide_input = ASCIIToWide(input_string);
-  EXPECT_FALSE(StringToInt64(wide_input, &output));
+  EXPECT_FALSE(StringToInt64(WideToUTF16Hack(wide_input), &output));
   EXPECT_EQ(6, output);
 }
 
 TEST(StringUtilTest, HexStringToInt) {
   static const struct {
     std::string input;
     int output;
     bool success;
   } cases[] = {
     {"0", 0, true},
@@ skipping 25 matching lines @@
     {"", 0, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     EXPECT_EQ(cases[i].output, HexStringToInt(cases[i].input));
     int output;
     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
 
     std::wstring wide_input = ASCIIToWide(cases[i].input);
-    EXPECT_EQ(cases[i].output, HexStringToInt(wide_input));
-    EXPECT_EQ(cases[i].success, HexStringToInt(wide_input, &output));
+    EXPECT_EQ(cases[i].output, HexStringToInt(WideToUTF16Hack(wide_input)));
+    EXPECT_EQ(cases[i].success, HexStringToInt(WideToUTF16Hack(wide_input),
+                                               &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);
 
   std::wstring wide_input = ASCIIToWide(input_string);
-  EXPECT_FALSE(HexStringToInt(wide_input, &output));
+  EXPECT_FALSE(HexStringToInt(WideToUTF16Hack(wide_input), &output));
   EXPECT_EQ(0xc0ffee, output);
 }
 
 TEST(StringUtilTest, HexStringToBytes) {
   static const struct {
     const std::string input;
     const char* output;
     size_t output_len;
     bool success;
   } cases[] = {
@@ skipping 25 matching lines @@
     for (size_t j = 0; j < cases[i].output_len; ++j)
       compare.push_back(static_cast<uint8>(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;
 
     output.clear();
     compare.clear();
 
     std::wstring wide_input = ASCIIToWide(cases[i].input);
-    EXPECT_EQ(cases[i].success, HexStringToBytes(wide_input, &output)) <<
+    EXPECT_EQ(cases[i].success,
+              HexStringToBytes(WideToUTF16Hack(wide_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]));
     ASSERT_EQ(output.size(), compare.size()) << i << ": " << cases[i].input;
     EXPECT_TRUE(std::equal(output.begin(), output.end(), compare.begin())) <<
         i << ": " << cases[i].input;
   }
 }
 
 TEST(StringUtilTest, StringToDouble) {
@@ skipping 31 matching lines @@
     {"", 0.0, false},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     EXPECT_DOUBLE_EQ(cases[i].output, StringToDouble(cases[i].input));
     double output;
     EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
     EXPECT_DOUBLE_EQ(cases[i].output, output);
 
     std::wstring wide_input = ASCIIToWide(cases[i].input);
-    EXPECT_DOUBLE_EQ(cases[i].output, StringToDouble(wide_input));
-    EXPECT_EQ(cases[i].success, StringToDouble(wide_input, &output));
+    EXPECT_DOUBLE_EQ(cases[i].output,
+                     StringToDouble(WideToUTF16Hack(wide_input)));
+    EXPECT_EQ(cases[i].success, StringToDouble(WideToUTF16Hack(wide_input),
+                                               &output));
     EXPECT_DOUBLE_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[] = "3.14\0159";
   std::string input_string(input, arraysize(input) - 1);
   double output;
   EXPECT_FALSE(StringToDouble(input_string, &output));
   EXPECT_DOUBLE_EQ(3.14, output);
 
   std::wstring wide_input = ASCIIToWide(input_string);
-  EXPECT_FALSE(StringToDouble(wide_input, &output));
+  EXPECT_FALSE(StringToDouble(WideToUTF16Hack(wide_input), &output));
   EXPECT_DOUBLE_EQ(3.14, output);
 }
 
 // This checks where we can use the assignment operator for a va_list. We need
 // a way to do this since Visual C doesn't support va_copy, but assignment on
 // va_list is not guaranteed to be a copy. See StringAppendVT which uses this
 // capability.
 static void VariableArgsFunc(const char* format, ...) {
   va_list org;
   va_start(org, format);
@@ skipping 454 matching lines @@
   }
 }
 
 TEST(StringUtilTest, 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);
 }