Rewrite std::string("") to std::string(), Linux edition.

base/string_util_unittest.cc

 // Copyright (c) 2012 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 52 matching lines @@
     TruncateUTF8ToByteSize(input, byte_size, output);
     return prev != output->length();
 }
 
 }  // namespace
 
 TEST(StringUtilTest, TruncateUTF8ToByteSize) {
   std::string output;
 
   // Empty strings and invalid byte_size arguments
-  EXPECT_FALSE(Truncated("", 0, &output));
+  EXPECT_FALSE(Truncated(std::string(), 0, &output));
   EXPECT_EQ(output, "");
   EXPECT_TRUE(Truncated("\xe1\x80\xbf", 0, &output));
   EXPECT_EQ(output, "");
   EXPECT_FALSE(Truncated("\xe1\x80\xbf", -1, &output));
   EXPECT_FALSE(Truncated("\xe1\x80\xbf", 4, &output));
 
   // Testing the truncation of valid UTF8 correctly
   EXPECT_TRUE(Truncated("abc", 2, &output));
   EXPECT_EQ(output, "ab");
   EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 2, &output));
@@ skipping 228 matching lines @@
 };
 
 TEST(StringUtilTest, CollapseWhitespaceASCII) {
   for (size_t i = 0; i < arraysize(collapse_cases_ascii); ++i) {
     const collapse_case_ascii& value = collapse_cases_ascii[i];
     EXPECT_EQ(value.output, CollapseWhitespaceASCII(value.input, value.trim));
   }
 }
 
 TEST(StringUtilTest, ContainsOnlyWhitespaceASCII) {
-  EXPECT_TRUE(ContainsOnlyWhitespaceASCII(""));
+  EXPECT_TRUE(ContainsOnlyWhitespaceASCII(std::string()));
   EXPECT_TRUE(ContainsOnlyWhitespaceASCII(" "));
   EXPECT_TRUE(ContainsOnlyWhitespaceASCII("\t"));
   EXPECT_TRUE(ContainsOnlyWhitespaceASCII("\t \r \n  "));
   EXPECT_FALSE(ContainsOnlyWhitespaceASCII("a"));
   EXPECT_FALSE(ContainsOnlyWhitespaceASCII("\thello\r \n  "));
 }
 
 TEST(StringUtilTest, ContainsOnlyWhitespace) {
   EXPECT_TRUE(ContainsOnlyWhitespace(string16()));
   EXPECT_TRUE(ContainsOnlyWhitespace(ASCIIToUTF16(" ")));
@@ skipping 372 matching lines @@
   r.clear();
 
   size = Tokenize(STR("one, two, three,"), STR(","), &r);
   EXPECT_EQ(3U, size);
   ASSERT_EQ(3U, r.size());
   EXPECT_EQ(r[0], STR("one"));
   EXPECT_EQ(r[1], STR(" two"));
   EXPECT_EQ(r[2], STR(" three"));
   r.clear();
 
-  size = Tokenize(STR(""), STR(","), &r);
+  size = Tokenize(STR(), STR(","), &r);
   EXPECT_EQ(0U, size);
   ASSERT_EQ(0U, r.size());
   r.clear();
 
   size = Tokenize(STR(","), STR(","), &r);
   EXPECT_EQ(0U, size);
   ASSERT_EQ(0U, r.size());
   r.clear();
 
   size = Tokenize(STR(",;:."), STR(".:;,"), &r);
@@ skipping 28 matching lines @@
   std::vector<std::string> in;
   EXPECT_EQ("", JoinString(in, ','));
 
   in.push_back("a");
   EXPECT_EQ("a", JoinString(in, ','));
 
   in.push_back("b");
   in.push_back("c");
   EXPECT_EQ("a,b,c", JoinString(in, ','));
 
-  in.push_back("");
+  in.push_back(std::string());
   EXPECT_EQ("a,b,c,", JoinString(in, ','));
   in.push_back(" ");
   EXPECT_EQ("a|b|c|| ", JoinString(in, '|'));
 }
 
 // Test for JoinString overloaded with std::string separator
 TEST(StringUtilTest, JoinStringWithString) {
   std::string separator(", ");
   std::vector<std::string> parts;
   EXPECT_EQ(std::string(), JoinString(parts, separator));
 
   parts.push_back("a");
   EXPECT_EQ("a", JoinString(parts, separator));
 
   parts.push_back("b");
   parts.push_back("c");
   EXPECT_EQ("a, b, c", JoinString(parts, separator));
 
-  parts.push_back("");
+  parts.push_back(std::string());
   EXPECT_EQ("a, b, c, ", JoinString(parts, separator));
   parts.push_back(" ");
   EXPECT_EQ("a|b|c|| ", JoinString(parts, "|"));
 }
 
 // Test for JoinString overloaded with string16 separator
 TEST(StringUtilTest, JoinStringWithString16) {
   string16 separator = ASCIIToUTF16(", ");
   std::vector<string16> parts;
   EXPECT_EQ(string16(), JoinString(parts, separator));
@@ skipping 11 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("a|b|c|| "), JoinString(parts, ASCIIToUTF16("|")));
 }
 
 TEST(StringUtilTest, StartsWith) {
   EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", true));
   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("", "javascript", false));
-  EXPECT_FALSE(StartsWithASCII("", "javascript", true));
-  EXPECT_TRUE(StartsWithASCII("java", "", false));
-  EXPECT_TRUE(StartsWithASCII("java", "", true));
+  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(L"", L"javascript", false));
-  EXPECT_FALSE(StartsWith(L"", L"javascript", true));
-  EXPECT_TRUE(StartsWith(L"java", L"", false));
-  EXPECT_TRUE(StartsWith(L"java", L"", true));
+  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));
 }
 
 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(L"", L".plugin", false));
-  EXPECT_FALSE(EndsWith(L"", L".plugin", true));
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", L"", false));
-  EXPECT_TRUE(EndsWith(L"Foo.plugin", L"", true));
+  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(L"", L"", false));
-  EXPECT_TRUE(EndsWith(L"", L"", true));
+  EXPECT_TRUE(EndsWith(std::wstring(), std::wstring(), false));
+  EXPECT_TRUE(EndsWith(std::wstring(), std::wstring(), 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 276 matching lines @@
                                cases[i].replace_with,
                                &output);
     EXPECT_EQ(cases[i].result, result);
     EXPECT_EQ(cases[i].output, output);
   }
 }
 
 TEST(StringUtilTest, ContainsOnlyChars) {
   // Providing an empty list of characters should return false but for the empty
   // string.
-  EXPECT_TRUE(ContainsOnlyChars("", ""));
-  EXPECT_FALSE(ContainsOnlyChars("Hello", ""));
+  EXPECT_TRUE(ContainsOnlyChars(std::string(), std::string()));
+  EXPECT_FALSE(ContainsOnlyChars("Hello", std::string()));
 
-  EXPECT_TRUE(ContainsOnlyChars("", "1234"));
+  EXPECT_TRUE(ContainsOnlyChars(std::string(), "1234"));
   EXPECT_TRUE(ContainsOnlyChars("1", "1234"));
   EXPECT_TRUE(ContainsOnlyChars("1", "4321"));
   EXPECT_TRUE(ContainsOnlyChars("123", "4321"));
   EXPECT_FALSE(ContainsOnlyChars("123a", "4321"));
 }
 
 class WriteIntoTest : public testing::Test {
  protected:
   static void WritesCorrectly(size_t num_chars) {
     std::string buffer;
@@ skipping 22 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