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

base/strings/string_split_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 "base/strings/string_split.h"
 
 #include "base/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 18 matching lines @@
 
 }  // anonymous namespace
 
 class SplitStringIntoKeyValuesTest : public testing::Test {
  protected:
   std::string key;
   std::vector<std::string> values;
 };
 
 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) {
-  EXPECT_FALSE(SplitStringIntoKeyValues("",     // Empty input
-                                        '\t',   // Key separators
-                                        &key, &values));
+  EXPECT_FALSE(SplitStringIntoKeyValues(std::string(),  // Empty input
+                                        '\t',           // Key separators
+                                        &key,
+                                        &values));
   EXPECT_TRUE(key.empty());
   EXPECT_TRUE(values.empty());
 }
 
 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) {
   EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
                                         '\t',  // Key separators
                                         &key, &values));
   EXPECT_EQ("key_with_no_value", key);
   EXPECT_TRUE(values.empty());
@@ skipping 10 matching lines @@
 TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) {
   EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1,   value2   value3",
                                        '\t',  // Key separators
                                        &key, &values));
   EXPECT_EQ("key1", key);
   ASSERT_EQ(1U, values.size());
   EXPECT_EQ("value1,   value2   value3", values[0]);
 }
 
 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) {
-  EXPECT_FALSE(SplitStringIntoKeyValues("",     // Empty input
-                                        '\t',   // Key separators
-                                        &key, &values));
+  EXPECT_FALSE(SplitStringIntoKeyValues(std::string(),  // Empty input
+                                        '\t',           // Key separators
+                                        &key,
+                                        &values));
   EXPECT_TRUE(key.empty());
   EXPECT_TRUE(values.empty());
 }
 
 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) {
   EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
                                         '\t',  // Key separators
                                         &key, &values));
   EXPECT_EQ("key_with_no_value", key);
   EXPECT_TRUE(values.empty());
@@ skipping 16 matching lines @@
   ASSERT_EQ(1U, values.size());
   EXPECT_EQ("value1,   value2   value3", values[0]);
 }
 
 class SplitStringIntoKeyValuePairsTest : public testing::Test {
  protected:
   std::vector<std::pair<std::string, std::string> > kv_pairs;
 };
 
 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) {
-  EXPECT_TRUE(SplitStringIntoKeyValuePairs("",
-                                           ':',   // Key-value delimiters
-                                           ',',   // Key-value pair delims
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(),
+                                           ':',  // Key-value delimiters
+                                           ',',  // Key-value pair delims
                                            &kv_pairs));
   EXPECT_TRUE(kv_pairs.empty());
 }
 
 TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) {
   EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
                                            ':',   // Key-value delimiters
                                            ',',   // Key-value pair delims
                                            &kv_pairs));
   ASSERT_EQ(2U, kv_pairs.size());
@@ skipping 22 matching lines @@
                                            &kv_pairs));
   ASSERT_EQ(2U, kv_pairs.size());
   EXPECT_EQ("key1", kv_pairs[0].first);
   EXPECT_EQ("va:ue1", kv_pairs[0].second);
   EXPECT_EQ("key2", kv_pairs[1].first);
   EXPECT_EQ("value2", kv_pairs[1].second);
 }
 
 TEST(SplitStringUsingSubstrTest, EmptyString) {
   std::vector<std::string> results;
-  SplitStringUsingSubstr("", "DELIMITER", &results);
+  SplitStringUsingSubstr(std::string(), "DELIMITER", &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_THAT(results, ElementsAre(""));
 }
 
 // Test for SplitString
 TEST(StringUtilTest, SplitString) {
   std::vector<std::wstring> r;
 
-  SplitString(L"", L',', &r);
+  SplitString(std::wstring(), L',', &r);
   EXPECT_EQ(0U, r.size());
   r.clear();
 
   SplitString(L"a,b,c", L',', &r);
   ASSERT_EQ(3U, r.size());
   EXPECT_EQ(r[0], L"a");
   EXPECT_EQ(r[1], L"b");
   EXPECT_EQ(r[2], L"c");
   r.clear();
 
@@ skipping 131 matching lines @@
     SplitStringAlongWhitespace(data[i].input, &results);
     ASSERT_EQ(data[i].expected_result_count, results.size());
     if (data[i].expected_result_count > 0)
       ASSERT_EQ(data[i].output1, results[0]);
     if (data[i].expected_result_count > 1)
       ASSERT_EQ(data[i].output2, results[1]);
   }
 }
 
 }  // namespace base