Cleanup: Remove many unused wstring string_utils.

base/strings/string_util_unittest.cc

 // Copyright 2013 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 "base/strings/string_util.h"
 
 #include <math.h>
 #include <stdarg.h>
 
-#include <limits>
-#include <sstream>
+#include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::ElementsAre;
 
 namespace base {
@@ skipping 255 matching lines @@
   {L"\nFoo", true, L"Foo"},
   {L"\r  Foo  ", true, L"Foo"},
   {L" Foo bar ", true, L"Foo bar"},
   {L"  \tFoo  bar  \n", true, L"Foo bar"},
   {L" a \r b\n c \r\n d \t\re \t f \n ", true, L"abcde f"},
 };
 
 TEST(StringUtilTest, CollapseWhitespace) {
   for (size_t i = 0; i < arraysize(collapse_cases); ++i) {
     const collapse_case& value = collapse_cases[i];
-    EXPECT_EQ(value.output, CollapseWhitespace(value.input, value.trim));
+    EXPECT_EQ(WideToUTF16(value.output),
+              CollapseWhitespace(WideToUTF16(value.input), value.trim));
   }
 }
 
 static const struct collapse_case_ascii {
   const char* input;
   const bool trim;
   const char* output;
 } collapse_cases_ascii[] = {
   {" Google Video ", false, "Google Video"},
   {"Google Video", false, "Google Video"},
@@ skipping 116 matching lines @@
     L"Google Video",
     L"Hello, world\n",
     L"0123ABCDwxyz \a\b\t\r\n!+,.~"
   };
 
   for (size_t i = 0; i < arraysize(char_cases); ++i) {
     EXPECT_TRUE(IsStringASCII(char_cases[i]));
     std::wstring wide = ASCIIToWide(char_cases[i]);
     EXPECT_EQ(wchar_cases[i], wide);
 
-    EXPECT_TRUE(IsStringASCII(wchar_cases[i]));
     std::string ascii = WideToASCII(wchar_cases[i]);
     EXPECT_EQ(char_cases[i], ascii);
   }
 
   EXPECT_FALSE(IsStringASCII("Google \x80Video"));
-  EXPECT_FALSE(IsStringASCII(L"Google \x80Video"));
 
   // Convert empty strings.
   std::wstring wempty;
   std::string empty;
   EXPECT_EQ(empty, WideToASCII(wempty));
   EXPECT_EQ(wempty, ASCIIToWide(empty));
 
   // Convert strings with an embedded NUL character.
   const char chars_with_nul[] = "test\0string";
   const int length_with_nul = arraysize(chars_with_nul) - 1;
@@ skipping 28 matching lines @@
   std::string upper_a = StringToUpperASCII(original_a);
   EXPECT_EQ("CC2", upper_a);
 
   std::wstring original_w(L"Cc2");
   std::wstring upper_w = StringToUpperASCII(original_w);
   EXPECT_EQ(L"CC2", upper_w);
 }
 
 TEST(StringUtilTest, LowerCaseEqualsASCII) {
   static const struct {
-    const wchar_t* src_w;
     const char*    src_a;
     const char*    dst;
   } lowercase_cases[] = {
-    { L"FoO", "FoO", "foo" },
-    { L"foo", "foo", "foo" },
-    { L"FOO", "FOO", "foo" },
+    { "FoO", "foo" },
+    { "foo", "foo" },
+    { "FOO", "foo" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(lowercase_cases); ++i) {
-    EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_w,
+    EXPECT_TRUE(LowerCaseEqualsASCII(ASCIIToUTF16(lowercase_cases[i].src_a),
                                      lowercase_cases[i].dst));
     EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_a,
                                      lowercase_cases[i].dst));
   }
 }
 
 TEST(StringUtilTest, FormatBytesUnlocalized) {
   static const struct {
     int64 bytes;
     const char* expected;
@@ skipping 311 matching lines @@
   EXPECT_FALSE(StartsWithASCII("JavaScript:url", "javascript", true));
   EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", false));
   EXPECT_TRUE(StartsWithASCII("JavaScript:url", "javascript", false));
   EXPECT_FALSE(StartsWithASCII("java", "javascript", true));
   EXPECT_FALSE(StartsWithASCII("java", "javascript", false));
   EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", false));
   EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", true));
   EXPECT_TRUE(StartsWithASCII("java", std::string(), false));
   EXPECT_TRUE(StartsWithASCII("java", std::string(), true));
 
-  EXPECT_TRUE(StartsWith(L"javascript:url", L"javascript", true));
-  EXPECT_FALSE(StartsWith(L"JavaScript:url", L"javascript", true));
-  EXPECT_TRUE(StartsWith(L"javascript:url", L"javascript", false));
-  EXPECT_TRUE(StartsWith(L"JavaScript:url", L"javascript", false));
-  EXPECT_FALSE(StartsWith(L"java", L"javascript", true));
-  EXPECT_FALSE(StartsWith(L"java", L"javascript", false));
-  EXPECT_FALSE(StartsWith(std::wstring(), L"javascript", false));
-  EXPECT_FALSE(StartsWith(std::wstring(), L"javascript", true));
-  EXPECT_TRUE(StartsWith(L"java", std::wstring(), false));
-  EXPECT_TRUE(StartsWith(L"java", std::wstring(), true));
+  EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
+                         ASCIIToUTF16("javascript"), true));
+  EXPECT_FALSE(StartsWith(ASCIIToUTF16("JavaScript:url"),
+                          ASCIIToUTF16("javascript"), true));
+  EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
+                         ASCIIToUTF16("javascript"), false));
+  EXPECT_TRUE(StartsWith(ASCIIToUTF16("JavaScript:url"),
+                         ASCIIToUTF16("javascript"), false));
+  EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
+                          ASCIIToUTF16("javascript"), true));
+  EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
+                          ASCIIToUTF16("javascript"), false));
+  EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), false));
+  EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), true));
+  EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), false));
+  EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), true));
 }
 
 TEST(StringUtilTest, EndsWith) {
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", L".plugin", true));
-  EXPECT_FALSE(EndsWith(L"Foo.Plugin", L".plugin", true));
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", L".plugin", false));
-  EXPECT_TRUE(EndsWith(L"Foo.Plugin", L".plugin", false));
-  EXPECT_FALSE(EndsWith(L".plug", L".plugin", true));
-  EXPECT_FALSE(EndsWith(L".plug", L".plugin", false));
-  EXPECT_FALSE(EndsWith(L"Foo.plugin Bar", L".plugin", true));
-  EXPECT_FALSE(EndsWith(L"Foo.plugin Bar", L".plugin", false));
-  EXPECT_FALSE(EndsWith(std::wstring(), L".plugin", false));
-  EXPECT_FALSE(EndsWith(std::wstring(), L".plugin", true));
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", std::wstring(), false));
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", std::wstring(), true));
-  EXPECT_TRUE(EndsWith(L".plugin", L".plugin", false));
-  EXPECT_TRUE(EndsWith(L".plugin", L".plugin", true));
-  EXPECT_TRUE(EndsWith(std::wstring(), std::wstring(), false));
-  EXPECT_TRUE(EndsWith(std::wstring(), std::wstring(), true));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
+                       ASCIIToUTF16(".plugin"), true));
+  EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
+                        ASCIIToUTF16(".plugin"), true));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
+                       ASCIIToUTF16(".plugin"), false));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
+                       ASCIIToUTF16(".plugin"), false));
+  EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), true));
+  EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), false));
+  EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
+                        ASCIIToUTF16(".plugin"), true));
+  EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
+                        ASCIIToUTF16(".plugin"), false));
+  EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), false));
+  EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), true));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), false));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), true));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"),
+                       ASCIIToUTF16(".plugin"), false));
+  EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"), true));
+  EXPECT_TRUE(EndsWith(string16(), string16(), false));
+  EXPECT_TRUE(EndsWith(string16(), string16(), true));
 }
 
 TEST(StringUtilTest, GetStringFWithOffsets) {
   std::vector<string16> subst;
   subst.push_back(ASCIIToUTF16("1"));
   subst.push_back(ASCIIToUTF16("2"));
   std::vector<size_t> offsets;
 
   ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $1. Your number is $2."),
                             subst,
@@ skipping 322 matching lines @@
   const std::string live = kLive;
   std::string dead = live;
   strncpy(WriteInto(&dead, 5), kDead, 4);
   EXPECT_EQ(kDead, dead);
   EXPECT_EQ(4u, dead.size());
   EXPECT_EQ(kLive, live);
   EXPECT_EQ(4u, live.size());
 }
 
 }  // namespace base