base/strings/string_util_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/strings/string_util.h"
   6
   7 #include <math.h>
   8 #include <stdarg.h>
   9
  10 #include <algorithm>
  11
  12 #include "base/basictypes.h"
  13 #include "base/strings/string16.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using ::testing::ElementsAre;
  19
  20 namespace base {
  21
  22 static const struct trim_case {
  23   const wchar_t* input;
  24   const TrimPositions positions;
  25   const wchar_t* output;
  26   const TrimPositions return_value;
  27 } trim_cases[] = {
  28   {L" Google Video ", TRIM_LEADING, L"Google Video ", TRIM_LEADING},
  29   {L" Google Video ", TRIM_TRAILING, L" Google Video", TRIM_TRAILING},
  30   {L" Google Video ", TRIM_ALL, L"Google Video", TRIM_ALL},
  31   {L"Google Video", TRIM_ALL, L"Google Video", TRIM_NONE},
  32   {L"", TRIM_ALL, L"", TRIM_NONE},
  33   {L"  ", TRIM_LEADING, L"", TRIM_LEADING},
  34   {L"  ", TRIM_TRAILING, L"", TRIM_TRAILING},
  35   {L"  ", TRIM_ALL, L"", TRIM_ALL},
  36   {L"\t\rTest String\n", TRIM_ALL, L"Test String", TRIM_ALL},
  37   {L"\x2002Test String\x00A0\x3000", TRIM_ALL, L"Test String", TRIM_ALL},
  38 };
  39
  40 static const struct trim_case_ascii {
  41   const char* input;
  42   const TrimPositions positions;
  43   const char* output;
  44   const TrimPositions return_value;
  45 } trim_cases_ascii[] = {
  46   {" Google Video ", TRIM_LEADING, "Google Video ", TRIM_LEADING},
  47   {" Google Video ", TRIM_TRAILING, " Google Video", TRIM_TRAILING},
  48   {" Google Video ", TRIM_ALL, "Google Video", TRIM_ALL},
  49   {"Google Video", TRIM_ALL, "Google Video", TRIM_NONE},
  50   {"", TRIM_ALL, "", TRIM_NONE},
  51   {"  ", TRIM_LEADING, "", TRIM_LEADING},
  52   {"  ", TRIM_TRAILING, "", TRIM_TRAILING},
  53   {"  ", TRIM_ALL, "", TRIM_ALL},
  54   {"\t\rTest String\n", TRIM_ALL, "Test String", TRIM_ALL},
  55 };
  56
  57 namespace {
  58
  59 // Helper used to test TruncateUTF8ToByteSize.
  60 bool Truncated(const std::string& input,
  61                const size_t byte_size,
  62                std::string* output) {
  63     size_t prev = input.length();
  64     TruncateUTF8ToByteSize(input, byte_size, output);
  65     return prev != output->length();
  66 }
  67
  68 }  // namespace
  69
  70 TEST(StringUtilTest, TruncateUTF8ToByteSize) {
  71   std::string output;
  72
  73   // Empty strings and invalid byte_size arguments
  74   EXPECT_FALSE(Truncated(std::string(), 0, &output));
  75   EXPECT_EQ(output, "");
  76   EXPECT_TRUE(Truncated("\xe1\x80\xbf", 0, &output));
  77   EXPECT_EQ(output, "");
  78   EXPECT_FALSE(Truncated("\xe1\x80\xbf", static_cast<size_t>(-1), &output));
  79   EXPECT_FALSE(Truncated("\xe1\x80\xbf", 4, &output));
  80
  81   // Testing the truncation of valid UTF8 correctly
  82   EXPECT_TRUE(Truncated("abc", 2, &output));
  83   EXPECT_EQ(output, "ab");
  84   EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 2, &output));
  85   EXPECT_EQ(output.compare("\xc2\x81"), 0);
  86   EXPECT_TRUE(Truncated("\xc2\x81\xc2\x81", 3, &output));
  87   EXPECT_EQ(output.compare("\xc2\x81"), 0);
  88   EXPECT_FALSE(Truncated("\xc2\x81\xc2\x81", 4, &output));
  89   EXPECT_EQ(output.compare("\xc2\x81\xc2\x81"), 0);
  90
  91   {
  92     const char array[] = "\x00\x00\xc2\x81\xc2\x81";
  93     const std::string array_string(array, arraysize(array));
  94     EXPECT_TRUE(Truncated(array_string, 4, &output));
  95     EXPECT_EQ(output.compare(std::string("\x00\x00\xc2\x81", 4)), 0);
  96   }
  97
  98   {
  99     const char array[] = "\x00\xc2\x81\xc2\x81";
 100     const std::string array_string(array, arraysize(array));
 101     EXPECT_TRUE(Truncated(array_string, 4, &output));
 102     EXPECT_EQ(output.compare(std::string("\x00\xc2\x81", 3)), 0);
 103   }
 104
 105   // Testing invalid UTF8
 106   EXPECT_TRUE(Truncated("\xed\xa0\x80\xed\xbf\xbf", 6, &output));
 107   EXPECT_EQ(output.compare(""), 0);
 108   EXPECT_TRUE(Truncated("\xed\xa0\x8f", 3, &output));
 109   EXPECT_EQ(output.compare(""), 0);
 110   EXPECT_TRUE(Truncated("\xed\xbf\xbf", 3, &output));
 111   EXPECT_EQ(output.compare(""), 0);
 112
 113   // Testing invalid UTF8 mixed with valid UTF8
 114   EXPECT_FALSE(Truncated("\xe1\x80\xbf", 3, &output));
 115   EXPECT_EQ(output.compare("\xe1\x80\xbf"), 0);
 116   EXPECT_FALSE(Truncated("\xf1\x80\xa0\xbf", 4, &output));
 117   EXPECT_EQ(output.compare("\xf1\x80\xa0\xbf"), 0);
 118   EXPECT_FALSE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf",
 119               10, &output));
 120   EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"), 0);
 121   EXPECT_TRUE(Truncated("a\xc2\x81\xe1\x80\xbf\xf1""a""\x80\xa0",
 122               10, &output));
 123   EXPECT_EQ(output.compare("a\xc2\x81\xe1\x80\xbf\xf1""a"), 0);
 124   EXPECT_FALSE(Truncated("\xef\xbb\xbf" "abc", 6, &output));
 125   EXPECT_EQ(output.compare("\xef\xbb\xbf" "abc"), 0);
 126
 127   // Overlong sequences
 128   EXPECT_TRUE(Truncated("\xc0\x80", 2, &output));
 129   EXPECT_EQ(output.compare(""), 0);
 130   EXPECT_TRUE(Truncated("\xc1\x80\xc1\x81", 4, &output));
 131   EXPECT_EQ(output.compare(""), 0);
 132   EXPECT_TRUE(Truncated("\xe0\x80\x80", 3, &output));
 133   EXPECT_EQ(output.compare(""), 0);
 134   EXPECT_TRUE(Truncated("\xe0\x82\x80", 3, &output));
 135   EXPECT_EQ(output.compare(""), 0);
 136   EXPECT_TRUE(Truncated("\xe0\x9f\xbf", 3, &output));
 137   EXPECT_EQ(output.compare(""), 0);
 138   EXPECT_TRUE(Truncated("\xf0\x80\x80\x8D", 4, &output));
 139   EXPECT_EQ(output.compare(""), 0);
 140   EXPECT_TRUE(Truncated("\xf0\x80\x82\x91", 4, &output));
 141   EXPECT_EQ(output.compare(""), 0);
 142   EXPECT_TRUE(Truncated("\xf0\x80\xa0\x80", 4, &output));
 143   EXPECT_EQ(output.compare(""), 0);
 144   EXPECT_TRUE(Truncated("\xf0\x8f\xbb\xbf", 4, &output));
 145   EXPECT_EQ(output.compare(""), 0);
 146   EXPECT_TRUE(Truncated("\xf8\x80\x80\x80\xbf", 5, &output));
 147   EXPECT_EQ(output.compare(""), 0);
 148   EXPECT_TRUE(Truncated("\xfc\x80\x80\x80\xa0\xa5", 6, &output));
 149   EXPECT_EQ(output.compare(""), 0);
 150
 151   // Beyond U+10FFFF (the upper limit of Unicode codespace)
 152   EXPECT_TRUE(Truncated("\xf4\x90\x80\x80", 4, &output));
 153   EXPECT_EQ(output.compare(""), 0);
 154   EXPECT_TRUE(Truncated("\xf8\xa0\xbf\x80\xbf", 5, &output));
 155   EXPECT_EQ(output.compare(""), 0);
 156   EXPECT_TRUE(Truncated("\xfc\x9c\xbf\x80\xbf\x80", 6, &output));
 157   EXPECT_EQ(output.compare(""), 0);
 158
 159   // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
 160   EXPECT_TRUE(Truncated("\xfe\xff", 2, &output));
 161   EXPECT_EQ(output.compare(""), 0);
 162   EXPECT_TRUE(Truncated("\xff\xfe", 2, &output));
 163   EXPECT_EQ(output.compare(""), 0);
 164
 165   {
 166     const char array[] = "\x00\x00\xfe\xff";
 167     const std::string array_string(array, arraysize(array));
 168     EXPECT_TRUE(Truncated(array_string, 4, &output));
 169     EXPECT_EQ(output.compare(std::string("\x00\x00", 2)), 0);
 170   }
 171
 172   // Variants on the previous test
 173   {
 174     const char array[] = "\xff\xfe\x00\x00";
 175     const std::string array_string(array, 4);
 176     EXPECT_FALSE(Truncated(array_string, 4, &output));
 177     EXPECT_EQ(output.compare(std::string("\xff\xfe\x00\x00", 4)), 0);
 178   }
 179   {
 180     const char array[] = "\xff\x00\x00\xfe";
 181     const std::string array_string(array, arraysize(array));
 182     EXPECT_TRUE(Truncated(array_string, 4, &output));
 183     EXPECT_EQ(output.compare(std::string("\xff\x00\x00", 3)), 0);
 184   }
 185
 186   // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
 187   EXPECT_TRUE(Truncated("\xef\xbf\xbe", 3, &output));
 188   EXPECT_EQ(output.compare(""), 0);
 189   EXPECT_TRUE(Truncated("\xf0\x8f\xbf\xbe", 4, &output));
 190   EXPECT_EQ(output.compare(""), 0);
 191   EXPECT_TRUE(Truncated("\xf3\xbf\xbf\xbf", 4, &output));
 192   EXPECT_EQ(output.compare(""), 0);
 193   EXPECT_TRUE(Truncated("\xef\xb7\x90", 3, &output));
 194   EXPECT_EQ(output.compare(""), 0);
 195   EXPECT_TRUE(Truncated("\xef\xb7\xaf", 3, &output));
 196   EXPECT_EQ(output.compare(""), 0);
 197
 198   // Strings in legacy encodings that are valid in UTF-8, but
 199   // are invalid as UTF-8 in real data.
 200   EXPECT_TRUE(Truncated("caf\xe9", 4, &output));
 201   EXPECT_EQ(output.compare("caf"), 0);
 202   EXPECT_TRUE(Truncated("\xb0\xa1\xb0\xa2", 4, &output));
 203   EXPECT_EQ(output.compare(""), 0);
 204   EXPECT_FALSE(Truncated("\xa7\x41\xa6\x6e", 4, &output));
 205   EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
 206   EXPECT_TRUE(Truncated("\xa7\x41\xa6\x6e\xd9\xee\xe4\xee", 7,
 207               &output));
 208   EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
 209
 210   // Testing using the same string as input and output.
 211   EXPECT_FALSE(Truncated(output, 4, &output));
 212   EXPECT_EQ(output.compare("\xa7\x41\xa6\x6e"), 0);
 213   EXPECT_TRUE(Truncated(output, 3, &output));
 214   EXPECT_EQ(output.compare("\xa7\x41"), 0);
 215
 216   // "abc" with U+201[CD] in windows-125[0-8]
 217   EXPECT_TRUE(Truncated("\x93" "abc\x94", 5, &output));
 218   EXPECT_EQ(output.compare("\x93" "abc"), 0);
 219
 220   // U+0639 U+064E U+0644 U+064E in ISO-8859-6
 221   EXPECT_TRUE(Truncated("\xd9\xee\xe4\xee", 4, &output));
 222   EXPECT_EQ(output.compare(""), 0);
 223
 224   // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
 225   EXPECT_TRUE(Truncated("\xe3\xe5\xe9\xdC", 4, &output));
 226   EXPECT_EQ(output.compare(""), 0);
 227 }
 228
 229 TEST(StringUtilTest, TrimWhitespace) {
 230   string16 output;  // Allow contents to carry over to next testcase
 231   for (size_t i = 0; i < arraysize(trim_cases); ++i) {
 232     const trim_case& value = trim_cases[i];
 233     EXPECT_EQ(value.return_value,
 234               TrimWhitespace(WideToUTF16(value.input), value.positions,
 235                              &output));
 236     EXPECT_EQ(WideToUTF16(value.output), output);
 237   }
 238
 239   // Test that TrimWhitespace() can take the same string for input and output
 240   output = ASCIIToUTF16("  This is a test \r\n");
 241   EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
 242   EXPECT_EQ(ASCIIToUTF16("This is a test"), output);
 243
 244   // Once more, but with a string of whitespace
 245   output = ASCIIToUTF16("  \r\n");
 246   EXPECT_EQ(TRIM_ALL, TrimWhitespace(output, TRIM_ALL, &output));
 247   EXPECT_EQ(string16(), output);
 248
 249   std::string output_ascii;
 250   for (size_t i = 0; i < arraysize(trim_cases_ascii); ++i) {
 251     const trim_case_ascii& value = trim_cases_ascii[i];
 252     EXPECT_EQ(value.return_value,
 253               TrimWhitespace(value.input, value.positions, &output_ascii));
 254     EXPECT_EQ(value.output, output_ascii);
 255   }
 256 }
 257
 258 static const struct collapse_case {
 259   const wchar_t* input;
 260   const bool trim;
 261   const wchar_t* output;
 262 } collapse_cases[] = {
 263   {L" Google Video ", false, L"Google Video"},
 264   {L"Google Video", false, L"Google Video"},
 265   {L"", false, L""},
 266   {L"  ", false, L""},
 267   {L"\t\rTest String\n", false, L"Test String"},
 268   {L"\x2002Test String\x00A0\x3000", false, L"Test String"},
 269   {L"    Test     \n  \t String    ", false, L"Test String"},
 270   {L"\x2002Test\x1680 \x2028 \tString\x00A0\x3000", false, L"Test String"},
 271   {L"   Test String", false, L"Test String"},
 272   {L"Test String    ", false, L"Test String"},
 273   {L"Test String", false, L"Test String"},
 274   {L"", true, L""},
 275   {L"\n", true, L""},
 276   {L"  \r  ", true, L""},
 277   {L"\nFoo", true, L"Foo"},
 278   {L"\r  Foo  ", true, L"Foo"},
 279   {L" Foo bar ", true, L"Foo bar"},
 280   {L"  \tFoo  bar  \n", true, L"Foo bar"},
 281   {L" a \r b\n c \r\n d \t\re \t f \n ", true, L"abcde f"},
 282 };
 283
 284 TEST(StringUtilTest, CollapseWhitespace) {
 285   for (size_t i = 0; i < arraysize(collapse_cases); ++i) {
 286     const collapse_case& value = collapse_cases[i];
 287     EXPECT_EQ(WideToUTF16(value.output),
 288               CollapseWhitespace(WideToUTF16(value.input), value.trim));
 289   }
 290 }
 291
 292 static const struct collapse_case_ascii {
 293   const char* input;
 294   const bool trim;
 295   const char* output;
 296 } collapse_cases_ascii[] = {
 297   {" Google Video ", false, "Google Video"},
 298   {"Google Video", false, "Google Video"},
 299   {"", false, ""},
 300   {"  ", false, ""},
 301   {"\t\rTest String\n", false, "Test String"},
 302   {"    Test     \n  \t String    ", false, "Test String"},
 303   {"   Test String", false, "Test String"},
 304   {"Test String    ", false, "Test String"},
 305   {"Test String", false, "Test String"},
 306   {"", true, ""},
 307   {"\n", true, ""},
 308   {"  \r  ", true, ""},
 309   {"\nFoo", true, "Foo"},
 310   {"\r  Foo  ", true, "Foo"},
 311   {" Foo bar ", true, "Foo bar"},
 312   {"  \tFoo  bar  \n", true, "Foo bar"},
 313   {" a \r b\n c \r\n d \t\re \t f \n ", true, "abcde f"},
 314 };
 315
 316 TEST(StringUtilTest, CollapseWhitespaceASCII) {
 317   for (size_t i = 0; i < arraysize(collapse_cases_ascii); ++i) {
 318     const collapse_case_ascii& value = collapse_cases_ascii[i];
 319     EXPECT_EQ(value.output, CollapseWhitespaceASCII(value.input, value.trim));
 320   }
 321 }
 322
 323 TEST(StringUtilTest, IsStringUTF8) {
 324   EXPECT_TRUE(IsStringUTF8("abc"));
 325   EXPECT_TRUE(IsStringUTF8("\xc2\x81"));
 326   EXPECT_TRUE(IsStringUTF8("\xe1\x80\xbf"));
 327   EXPECT_TRUE(IsStringUTF8("\xf1\x80\xa0\xbf"));
 328   EXPECT_TRUE(IsStringUTF8("a\xc2\x81\xe1\x80\xbf\xf1\x80\xa0\xbf"));
 329   EXPECT_TRUE(IsStringUTF8("\xef\xbb\xbf" "abc"));  // UTF-8 BOM
 330
 331   // surrogate code points
 332   EXPECT_FALSE(IsStringUTF8("\xed\xa0\x80\xed\xbf\xbf"));
 333   EXPECT_FALSE(IsStringUTF8("\xed\xa0\x8f"));
 334   EXPECT_FALSE(IsStringUTF8("\xed\xbf\xbf"));
 335
 336   // overlong sequences
 337   EXPECT_FALSE(IsStringUTF8("\xc0\x80"));  // U+0000
 338   EXPECT_FALSE(IsStringUTF8("\xc1\x80\xc1\x81"));  // "AB"
 339   EXPECT_FALSE(IsStringUTF8("\xe0\x80\x80"));  // U+0000
 340   EXPECT_FALSE(IsStringUTF8("\xe0\x82\x80"));  // U+0080
 341   EXPECT_FALSE(IsStringUTF8("\xe0\x9f\xbf"));  // U+07ff
 342   EXPECT_FALSE(IsStringUTF8("\xf0\x80\x80\x8D"));  // U+000D
 343   EXPECT_FALSE(IsStringUTF8("\xf0\x80\x82\x91"));  // U+0091
 344   EXPECT_FALSE(IsStringUTF8("\xf0\x80\xa0\x80"));  // U+0800
 345   EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbb\xbf"));  // U+FEFF (BOM)
 346   EXPECT_FALSE(IsStringUTF8("\xf8\x80\x80\x80\xbf"));  // U+003F
 347   EXPECT_FALSE(IsStringUTF8("\xfc\x80\x80\x80\xa0\xa5"));  // U+00A5
 348
 349   // Beyond U+10FFFF (the upper limit of Unicode codespace)
 350   EXPECT_FALSE(IsStringUTF8("\xf4\x90\x80\x80"));  // U+110000
 351   EXPECT_FALSE(IsStringUTF8("\xf8\xa0\xbf\x80\xbf"));  // 5 bytes
 352   EXPECT_FALSE(IsStringUTF8("\xfc\x9c\xbf\x80\xbf\x80"));  // 6 bytes
 353
 354   // BOMs in UTF-16(BE|LE) and UTF-32(BE|LE)
 355   EXPECT_FALSE(IsStringUTF8("\xfe\xff"));
 356   EXPECT_FALSE(IsStringUTF8("\xff\xfe"));
 357   EXPECT_FALSE(IsStringUTF8(std::string("\x00\x00\xfe\xff", 4)));
 358   EXPECT_FALSE(IsStringUTF8("\xff\xfe\x00\x00"));
 359
 360   // Non-characters : U+xxFFF[EF] where xx is 0x00 through 0x10 and <FDD0,FDEF>
 361   EXPECT_FALSE(IsStringUTF8("\xef\xbf\xbe"));  // U+FFFE)
 362   EXPECT_FALSE(IsStringUTF8("\xf0\x8f\xbf\xbe"));  // U+1FFFE
 363   EXPECT_FALSE(IsStringUTF8("\xf3\xbf\xbf\xbf"));  // U+10FFFF
 364   EXPECT_FALSE(IsStringUTF8("\xef\xb7\x90"));  // U+FDD0
 365   EXPECT_FALSE(IsStringUTF8("\xef\xb7\xaf"));  // U+FDEF
 366   // Strings in legacy encodings. We can certainly make up strings
 367   // in a legacy encoding that are valid in UTF-8, but in real data,
 368   // most of them are invalid as UTF-8.
 369   EXPECT_FALSE(IsStringUTF8("caf\xe9"));  // cafe with U+00E9 in ISO-8859-1
 370   EXPECT_FALSE(IsStringUTF8("\xb0\xa1\xb0\xa2"));  // U+AC00, U+AC001 in EUC-KR
 371   EXPECT_FALSE(IsStringUTF8("\xa7\x41\xa6\x6e"));  // U+4F60 U+597D in Big5
 372   // "abc" with U+201[CD] in windows-125[0-8]
 373   EXPECT_FALSE(IsStringUTF8("\x93" "abc\x94"));
 374   // U+0639 U+064E U+0644 U+064E in ISO-8859-6
 375   EXPECT_FALSE(IsStringUTF8("\xd9\xee\xe4\xee"));
 376   // U+03B3 U+03B5 U+03B9 U+03AC in ISO-8859-7
 377   EXPECT_FALSE(IsStringUTF8("\xe3\xe5\xe9\xdC"));
 378
 379   // Check that we support Embedded Nulls. The first uses the canonical UTF-8
 380   // representation, and the second uses a 2-byte sequence. The second version
 381   // is invalid UTF-8 since UTF-8 states that the shortest encoding for a
 382   // given codepoint must be used.
 383   static const char kEmbeddedNull[] = "embedded\0null";
 384   EXPECT_TRUE(IsStringUTF8(
 385       std::string(kEmbeddedNull, sizeof(kEmbeddedNull))));
 386   EXPECT_FALSE(IsStringUTF8("embedded\xc0\x80U+0000"));
 387 }
 388
 389 TEST(StringUtilTest, IsStringASCII) {
 390   static char char_ascii[] =
 391       "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
 392   static char16 char16_ascii[] = {
 393       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A',
 394       'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6',
 395       '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F', 0 };
 396   static std::wstring wchar_ascii(
 397       L"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF");
 398
 399   // Test a variety of the fragment start positions and lengths in order to make
 400   // sure that bit masking in IsStringASCII works correctly.
 401   // Also, test that a non-ASCII character will be detected regardless of its
 402   // position inside the string.
 403   {
 404     const size_t string_length = arraysize(char_ascii) - 1;
 405     for (size_t offset = 0; offset < 8; ++offset) {
 406       for (size_t len = 0, max_len = string_length - offset; len < max_len;
 407            ++len) {
 408         EXPECT_TRUE(IsStringASCII(StringPiece(char_ascii + offset, len)));
 409         for (size_t char_pos = offset; char_pos < len; ++char_pos) {
 410           char_ascii[char_pos] |= '\x80';
 411           EXPECT_FALSE(IsStringASCII(StringPiece(char_ascii + offset, len)));
 412           char_ascii[char_pos] &= ~'\x80';
 413         }
 414       }
 415     }
 416   }
 417
 418   {
 419     const size_t string_length = arraysize(char16_ascii) - 1;
 420     for (size_t offset = 0; offset < 4; ++offset) {
 421       for (size_t len = 0, max_len = string_length - offset; len < max_len;
 422            ++len) {
 423         EXPECT_TRUE(IsStringASCII(StringPiece16(char16_ascii + offset, len)));
 424         for (size_t char_pos = offset; char_pos < len; ++char_pos) {
 425           char16_ascii[char_pos] |= 0x80;
 426           EXPECT_FALSE(
 427               IsStringASCII(StringPiece16(char16_ascii + offset, len)));
 428           char16_ascii[char_pos] &= ~0x80;
 429           // Also test when the upper half is non-zero.
 430           char16_ascii[char_pos] |= 0x100;
 431           EXPECT_FALSE(
 432               IsStringASCII(StringPiece16(char16_ascii + offset, len)));
 433           char16_ascii[char_pos] &= ~0x100;
 434         }
 435       }
 436     }
 437   }
 438
 439   {
 440     const size_t string_length = wchar_ascii.length();
 441     for (size_t len = 0; len < string_length; ++len) {
 442       EXPECT_TRUE(IsStringASCII(wchar_ascii.substr(0, len)));
 443       for (size_t char_pos = 0; char_pos < len; ++char_pos) {
 444         wchar_ascii[char_pos] |= 0x80;
 445         EXPECT_FALSE(
 446             IsStringASCII(wchar_ascii.substr(0, len)));
 447         wchar_ascii[char_pos] &= ~0x80;
 448         wchar_ascii[char_pos] |= 0x100;
 449         EXPECT_FALSE(
 450             IsStringASCII(wchar_ascii.substr(0, len)));
 451         wchar_ascii[char_pos] &= ~0x100;
 452 #if defined(WCHAR_T_IS_UTF32)
 453         wchar_ascii[char_pos] |= 0x10000;
 454         EXPECT_FALSE(
 455             IsStringASCII(wchar_ascii.substr(0, len)));
 456         wchar_ascii[char_pos] &= ~0x10000;
 457 #endif  // WCHAR_T_IS_UTF32
 458       }
 459     }
 460   }
 461 }
 462
 463 TEST(StringUtilTest, ConvertASCII) {
 464   static const char* const char_cases[] = {
 465     "Google Video",
 466     "Hello, world\n",
 467     "0123ABCDwxyz \a\b\t\r\n!+,.~"
 468   };
 469
 470   static const wchar_t* const wchar_cases[] = {
 471     L"Google Video",
 472     L"Hello, world\n",
 473     L"0123ABCDwxyz \a\b\t\r\n!+,.~"
 474   };
 475
 476   for (size_t i = 0; i < arraysize(char_cases); ++i) {
 477     EXPECT_TRUE(IsStringASCII(char_cases[i]));
 478     string16 utf16 = ASCIIToUTF16(char_cases[i]);
 479     EXPECT_EQ(WideToUTF16(wchar_cases[i]), utf16);
 480
 481     std::string ascii = UTF16ToASCII(WideToUTF16(wchar_cases[i]));
 482     EXPECT_EQ(char_cases[i], ascii);
 483   }
 484
 485   EXPECT_FALSE(IsStringASCII("Google \x80Video"));
 486
 487   // Convert empty strings.
 488   string16 empty16;
 489   std::string empty;
 490   EXPECT_EQ(empty, UTF16ToASCII(empty16));
 491   EXPECT_EQ(empty16, ASCIIToUTF16(empty));
 492
 493   // Convert strings with an embedded NUL character.
 494   const char chars_with_nul[] = "test\0string";
 495   const int length_with_nul = arraysize(chars_with_nul) - 1;
 496   std::string string_with_nul(chars_with_nul, length_with_nul);
 497   string16 string16_with_nul = ASCIIToUTF16(string_with_nul);
 498   EXPECT_EQ(static_cast<string16::size_type>(length_with_nul),
 499             string16_with_nul.length());
 500   std::string narrow_with_nul = UTF16ToASCII(string16_with_nul);
 501   EXPECT_EQ(static_cast<std::string::size_type>(length_with_nul),
 502             narrow_with_nul.length());
 503   EXPECT_EQ(0, string_with_nul.compare(narrow_with_nul));
 504 }
 505
 506 TEST(StringUtilTest, ToUpperASCII) {
 507   EXPECT_EQ('C', ToUpperASCII('C'));
 508   EXPECT_EQ('C', ToUpperASCII('c'));
 509   EXPECT_EQ('2', ToUpperASCII('2'));
 510
 511   EXPECT_EQ(L'C', ToUpperASCII(L'C'));
 512   EXPECT_EQ(L'C', ToUpperASCII(L'c'));
 513   EXPECT_EQ(L'2', ToUpperASCII(L'2'));
 514
 515   std::string in_place_a("Cc2");
 516   StringToUpperASCII(&in_place_a);
 517   EXPECT_EQ("CC2", in_place_a);
 518
 519   std::wstring in_place_w(L"Cc2");
 520   StringToUpperASCII(&in_place_w);
 521   EXPECT_EQ(L"CC2", in_place_w);
 522
 523   std::string original_a("Cc2");
 524   std::string upper_a = StringToUpperASCII(original_a);
 525   EXPECT_EQ("CC2", upper_a);
 526
 527   std::wstring original_w(L"Cc2");
 528   std::wstring upper_w = StringToUpperASCII(original_w);
 529   EXPECT_EQ(L"CC2", upper_w);
 530 }
 531
 532 TEST(StringUtilTest, LowerCaseEqualsASCII) {
 533   static const struct {
 534     const char*    src_a;
 535     const char*    dst;
 536   } lowercase_cases[] = {
 537     { "FoO", "foo" },
 538     { "foo", "foo" },
 539     { "FOO", "foo" },
 540   };
 541
 542   for (size_t i = 0; i < arraysize(lowercase_cases); ++i) {
 543     EXPECT_TRUE(LowerCaseEqualsASCII(ASCIIToUTF16(lowercase_cases[i].src_a),
 544                                      lowercase_cases[i].dst));
 545     EXPECT_TRUE(LowerCaseEqualsASCII(lowercase_cases[i].src_a,
 546                                      lowercase_cases[i].dst));
 547   }
 548 }
 549
 550 TEST(StringUtilTest, FormatBytesUnlocalized) {
 551   static const struct {
 552     int64 bytes;
 553     const char* expected;
 554   } cases[] = {
 555     // Expected behavior: we show one post-decimal digit when we have
 556     // under two pre-decimal digits, except in cases where it makes no
 557     // sense (zero or bytes).
 558     // Since we switch units once we cross the 1000 mark, this keeps
 559     // the display of file sizes or bytes consistently around three
 560     // digits.
 561     {0, "0 B"},
 562     {512, "512 B"},
 563     {1024*1024, "1.0 MB"},
 564     {1024*1024*1024, "1.0 GB"},
 565     {10LL*1024*1024*1024, "10.0 GB"},
 566     {99LL*1024*1024*1024, "99.0 GB"},
 567     {105LL*1024*1024*1024, "105 GB"},
 568     {105LL*1024*1024*1024 + 500LL*1024*1024, "105 GB"},
 569     {~(1LL << 63), "8192 PB"},
 570
 571     {99*1024 + 103, "99.1 kB"},
 572     {1024*1024 + 103, "1.0 MB"},
 573     {1024*1024 + 205 * 1024, "1.2 MB"},
 574     {1024*1024*1024 + (927 * 1024*1024), "1.9 GB"},
 575     {10LL*1024*1024*1024, "10.0 GB"},
 576     {100LL*1024*1024*1024, "100 GB"},
 577   };
 578
 579   for (size_t i = 0; i < arraysize(cases); ++i) {
 580     EXPECT_EQ(ASCIIToUTF16(cases[i].expected),
 581               FormatBytesUnlocalized(cases[i].bytes));
 582   }
 583 }
 584 TEST(StringUtilTest, ReplaceSubstringsAfterOffset) {
 585   static const struct {
 586     const char* str;
 587     string16::size_type start_offset;
 588     const char* find_this;
 589     const char* replace_with;
 590     const char* expected;
 591   } cases[] = {
 592     {"aaa", 0, "a", "b", "bbb"},
 593     {"abb", 0, "ab", "a", "ab"},
 594     {"Removing some substrings inging", 0, "ing", "", "Remov some substrs "},
 595     {"Not found", 0, "x", "0", "Not found"},
 596     {"Not found again", 5, "x", "0", "Not found again"},
 597     {" Making it much longer ", 0, " ", "Four score and seven years ago",
 598      "Four score and seven years agoMakingFour score and seven years agoit"
 599      "Four score and seven years agomuchFour score and seven years agolonger"
 600      "Four score and seven years ago"},
 601     {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
 602     {"Replace me only me once", 9, "me ", "", "Replace me only once"},
 603     {"abababab", 2, "ab", "c", "abccc"},
 604   };
 605
 606   for (size_t i = 0; i < arraysize(cases); i++) {
 607     string16 str = ASCIIToUTF16(cases[i].str);
 608     ReplaceSubstringsAfterOffset(&str, cases[i].start_offset,
 609                                  ASCIIToUTF16(cases[i].find_this),
 610                                  ASCIIToUTF16(cases[i].replace_with));
 611     EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
 612   }
 613 }
 614
 615 TEST(StringUtilTest, ReplaceFirstSubstringAfterOffset) {
 616   static const struct {
 617     const char* str;
 618     string16::size_type start_offset;
 619     const char* find_this;
 620     const char* replace_with;
 621     const char* expected;
 622   } cases[] = {
 623     {"aaa", 0, "a", "b", "baa"},
 624     {"abb", 0, "ab", "a", "ab"},
 625     {"Removing some substrings inging", 0, "ing", "",
 626       "Remov some substrings inging"},
 627     {"Not found", 0, "x", "0", "Not found"},
 628     {"Not found again", 5, "x", "0", "Not found again"},
 629     {" Making it much longer ", 0, " ", "Four score and seven years ago",
 630      "Four score and seven years agoMaking it much longer "},
 631     {"Invalid offset", 9999, "t", "foobar", "Invalid offset"},
 632     {"Replace me only me once", 4, "me ", "", "Replace only me once"},
 633     {"abababab", 2, "ab", "c", "abcabab"},
 634   };
 635
 636   for (size_t i = 0; i < arraysize(cases); i++) {
 637     string16 str = ASCIIToUTF16(cases[i].str);
 638     ReplaceFirstSubstringAfterOffset(&str, cases[i].start_offset,
 639                                      ASCIIToUTF16(cases[i].find_this),
 640                                      ASCIIToUTF16(cases[i].replace_with));
 641     EXPECT_EQ(ASCIIToUTF16(cases[i].expected), str);
 642   }
 643 }
 644
 645 TEST(StringUtilTest, HexDigitToInt) {
 646   EXPECT_EQ(0, HexDigitToInt('0'));
 647   EXPECT_EQ(1, HexDigitToInt('1'));
 648   EXPECT_EQ(2, HexDigitToInt('2'));
 649   EXPECT_EQ(3, HexDigitToInt('3'));
 650   EXPECT_EQ(4, HexDigitToInt('4'));
 651   EXPECT_EQ(5, HexDigitToInt('5'));
 652   EXPECT_EQ(6, HexDigitToInt('6'));
 653   EXPECT_EQ(7, HexDigitToInt('7'));
 654   EXPECT_EQ(8, HexDigitToInt('8'));
 655   EXPECT_EQ(9, HexDigitToInt('9'));
 656   EXPECT_EQ(10, HexDigitToInt('A'));
 657   EXPECT_EQ(11, HexDigitToInt('B'));
 658   EXPECT_EQ(12, HexDigitToInt('C'));
 659   EXPECT_EQ(13, HexDigitToInt('D'));
 660   EXPECT_EQ(14, HexDigitToInt('E'));
 661   EXPECT_EQ(15, HexDigitToInt('F'));
 662
 663   // Verify the lower case as well.
 664   EXPECT_EQ(10, HexDigitToInt('a'));
 665   EXPECT_EQ(11, HexDigitToInt('b'));
 666   EXPECT_EQ(12, HexDigitToInt('c'));
 667   EXPECT_EQ(13, HexDigitToInt('d'));
 668   EXPECT_EQ(14, HexDigitToInt('e'));
 669   EXPECT_EQ(15, HexDigitToInt('f'));
 670 }
 671
 672 // Test for Tokenize
 673 template <typename STR>
 674 void TokenizeTest() {
 675   std::vector<STR> r;
 676   size_t size;
 677
 678   size = Tokenize(STR("This is a string"), STR(" "), &r);
 679   EXPECT_EQ(4U, size);
 680   ASSERT_EQ(4U, r.size());
 681   EXPECT_EQ(r[0], STR("This"));
 682   EXPECT_EQ(r[1], STR("is"));
 683   EXPECT_EQ(r[2], STR("a"));
 684   EXPECT_EQ(r[3], STR("string"));
 685   r.clear();
 686
 687   size = Tokenize(STR("one,two,three"), STR(","), &r);
 688   EXPECT_EQ(3U, size);
 689   ASSERT_EQ(3U, r.size());
 690   EXPECT_EQ(r[0], STR("one"));
 691   EXPECT_EQ(r[1], STR("two"));
 692   EXPECT_EQ(r[2], STR("three"));
 693   r.clear();
 694
 695   size = Tokenize(STR("one,two:three;four"), STR(",:"), &r);
 696   EXPECT_EQ(3U, size);
 697   ASSERT_EQ(3U, r.size());
 698   EXPECT_EQ(r[0], STR("one"));
 699   EXPECT_EQ(r[1], STR("two"));
 700   EXPECT_EQ(r[2], STR("three;four"));
 701   r.clear();
 702
 703   size = Tokenize(STR("one,two:three;four"), STR(";,:"), &r);
 704   EXPECT_EQ(4U, size);
 705   ASSERT_EQ(4U, r.size());
 706   EXPECT_EQ(r[0], STR("one"));
 707   EXPECT_EQ(r[1], STR("two"));
 708   EXPECT_EQ(r[2], STR("three"));
 709   EXPECT_EQ(r[3], STR("four"));
 710   r.clear();
 711
 712   size = Tokenize(STR("one, two, three"), STR(","), &r);
 713   EXPECT_EQ(3U, size);
 714   ASSERT_EQ(3U, r.size());
 715   EXPECT_EQ(r[0], STR("one"));
 716   EXPECT_EQ(r[1], STR(" two"));
 717   EXPECT_EQ(r[2], STR(" three"));
 718   r.clear();
 719
 720   size = Tokenize(STR("one, two, three, "), STR(","), &r);
 721   EXPECT_EQ(4U, size);
 722   ASSERT_EQ(4U, r.size());
 723   EXPECT_EQ(r[0], STR("one"));
 724   EXPECT_EQ(r[1], STR(" two"));
 725   EXPECT_EQ(r[2], STR(" three"));
 726   EXPECT_EQ(r[3], STR(" "));
 727   r.clear();
 728
 729   size = Tokenize(STR("one, two, three,"), STR(","), &r);
 730   EXPECT_EQ(3U, size);
 731   ASSERT_EQ(3U, r.size());
 732   EXPECT_EQ(r[0], STR("one"));
 733   EXPECT_EQ(r[1], STR(" two"));
 734   EXPECT_EQ(r[2], STR(" three"));
 735   r.clear();
 736
 737   size = Tokenize(STR(), STR(","), &r);
 738   EXPECT_EQ(0U, size);
 739   ASSERT_EQ(0U, r.size());
 740   r.clear();
 741
 742   size = Tokenize(STR(","), STR(","), &r);
 743   EXPECT_EQ(0U, size);
 744   ASSERT_EQ(0U, r.size());
 745   r.clear();
 746
 747   size = Tokenize(STR(",;:."), STR(".:;,"), &r);
 748   EXPECT_EQ(0U, size);
 749   ASSERT_EQ(0U, r.size());
 750   r.clear();
 751
 752   size = Tokenize(STR("\t\ta\t"), STR("\t"), &r);
 753   EXPECT_EQ(1U, size);
 754   ASSERT_EQ(1U, r.size());
 755   EXPECT_EQ(r[0], STR("a"));
 756   r.clear();
 757
 758   size = Tokenize(STR("\ta\t\nb\tcc"), STR("\n"), &r);
 759   EXPECT_EQ(2U, size);
 760   ASSERT_EQ(2U, r.size());
 761   EXPECT_EQ(r[0], STR("\ta\t"));
 762   EXPECT_EQ(r[1], STR("b\tcc"));
 763   r.clear();
 764 }
 765
 766 TEST(StringUtilTest, TokenizeStdString) {
 767   TokenizeTest<std::string>();
 768 }
 769
 770 TEST(StringUtilTest, TokenizeStringPiece) {
 771   TokenizeTest<StringPiece>();
 772 }
 773
 774 // Test for JoinString
 775 TEST(StringUtilTest, JoinString) {
 776   std::vector<std::string> in;
 777   EXPECT_EQ("", JoinString(in, ','));
 778
 779   in.push_back("a");
 780   EXPECT_EQ("a", JoinString(in, ','));
 781
 782   in.push_back("b");
 783   in.push_back("c");
 784   EXPECT_EQ("a,b,c", JoinString(in, ','));
 785
 786   in.push_back(std::string());
 787   EXPECT_EQ("a,b,c,", JoinString(in, ','));
 788   in.push_back(" ");
 789   EXPECT_EQ("a|b|c|| ", JoinString(in, '|'));
 790 }
 791
 792 // Test for JoinString overloaded with std::string separator
 793 TEST(StringUtilTest, JoinStringWithString) {
 794   std::string separator(", ");
 795   std::vector<std::string> parts;
 796   EXPECT_EQ(std::string(), JoinString(parts, separator));
 797
 798   parts.push_back("a");
 799   EXPECT_EQ("a", JoinString(parts, separator));
 800
 801   parts.push_back("b");
 802   parts.push_back("c");
 803   EXPECT_EQ("a, b, c", JoinString(parts, separator));
 804
 805   parts.push_back(std::string());
 806   EXPECT_EQ("a, b, c, ", JoinString(parts, separator));
 807   parts.push_back(" ");
 808   EXPECT_EQ("a|b|c|| ", JoinString(parts, "|"));
 809 }
 810
 811 // Test for JoinString overloaded with string16 separator
 812 TEST(StringUtilTest, JoinStringWithString16) {
 813   string16 separator = ASCIIToUTF16(", ");
 814   std::vector<string16> parts;
 815   EXPECT_EQ(string16(), JoinString(parts, separator));
 816
 817   parts.push_back(ASCIIToUTF16("a"));
 818   EXPECT_EQ(ASCIIToUTF16("a"), JoinString(parts, separator));
 819
 820   parts.push_back(ASCIIToUTF16("b"));
 821   parts.push_back(ASCIIToUTF16("c"));
 822   EXPECT_EQ(ASCIIToUTF16("a, b, c"), JoinString(parts, separator));
 823
 824   parts.push_back(ASCIIToUTF16(""));
 825   EXPECT_EQ(ASCIIToUTF16("a, b, c, "), JoinString(parts, separator));
 826   parts.push_back(ASCIIToUTF16(" "));
 827   EXPECT_EQ(ASCIIToUTF16("a|b|c|| "), JoinString(parts, ASCIIToUTF16("|")));
 828 }
 829
 830 TEST(StringUtilTest, StartsWith) {
 831   EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", true));
 832   EXPECT_FALSE(StartsWithASCII("JavaScript:url", "javascript", true));
 833   EXPECT_TRUE(StartsWithASCII("javascript:url", "javascript", false));
 834   EXPECT_TRUE(StartsWithASCII("JavaScript:url", "javascript", false));
 835   EXPECT_FALSE(StartsWithASCII("java", "javascript", true));
 836   EXPECT_FALSE(StartsWithASCII("java", "javascript", false));
 837   EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", false));
 838   EXPECT_FALSE(StartsWithASCII(std::string(), "javascript", true));
 839   EXPECT_TRUE(StartsWithASCII("java", std::string(), false));
 840   EXPECT_TRUE(StartsWithASCII("java", std::string(), true));
 841
 842   EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
 843                          ASCIIToUTF16("javascript"), true));
 844   EXPECT_FALSE(StartsWith(ASCIIToUTF16("JavaScript:url"),
 845                           ASCIIToUTF16("javascript"), true));
 846   EXPECT_TRUE(StartsWith(ASCIIToUTF16("javascript:url"),
 847                          ASCIIToUTF16("javascript"), false));
 848   EXPECT_TRUE(StartsWith(ASCIIToUTF16("JavaScript:url"),
 849                          ASCIIToUTF16("javascript"), false));
 850   EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
 851                           ASCIIToUTF16("javascript"), true));
 852   EXPECT_FALSE(StartsWith(ASCIIToUTF16("java"),
 853                           ASCIIToUTF16("javascript"), false));
 854   EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), false));
 855   EXPECT_FALSE(StartsWith(string16(), ASCIIToUTF16("javascript"), true));
 856   EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), false));
 857   EXPECT_TRUE(StartsWith(ASCIIToUTF16("java"), string16(), true));
 858 }
 859
 860 TEST(StringUtilTest, EndsWith) {
 861   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
 862                        ASCIIToUTF16(".plugin"), true));
 863   EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
 864                         ASCIIToUTF16(".plugin"), true));
 865   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"),
 866                        ASCIIToUTF16(".plugin"), false));
 867   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.Plugin"),
 868                        ASCIIToUTF16(".plugin"), false));
 869   EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), true));
 870   EXPECT_FALSE(EndsWith(ASCIIToUTF16(".plug"), ASCIIToUTF16(".plugin"), false));
 871   EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
 872                         ASCIIToUTF16(".plugin"), true));
 873   EXPECT_FALSE(EndsWith(ASCIIToUTF16("Foo.plugin Bar"),
 874                         ASCIIToUTF16(".plugin"), false));
 875   EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), false));
 876   EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), true));
 877   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), false));
 878   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), true));
 879   EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"),
 880                        ASCIIToUTF16(".plugin"), false));
 881   EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"), true));
 882   EXPECT_TRUE(EndsWith(string16(), string16(), false));
 883   EXPECT_TRUE(EndsWith(string16(), string16(), true));
 884 }
 885
 886 TEST(StringUtilTest, GetStringFWithOffsets) {
 887   std::vector<string16> subst;
 888   subst.push_back(ASCIIToUTF16("1"));
 889   subst.push_back(ASCIIToUTF16("2"));
 890   std::vector<size_t> offsets;
 891
 892   ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $1. Your number is $2."),
 893                             subst,
 894                             &offsets);
 895   EXPECT_EQ(2U, offsets.size());
 896   EXPECT_EQ(7U, offsets[0]);
 897   EXPECT_EQ(25U, offsets[1]);
 898   offsets.clear();
 899
 900   ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $2. Your number is $1."),
 901                             subst,
 902                             &offsets);
 903   EXPECT_EQ(2U, offsets.size());
 904   EXPECT_EQ(25U, offsets[0]);
 905   EXPECT_EQ(7U, offsets[1]);
 906   offsets.clear();
 907 }
 908
 909 TEST(StringUtilTest, ReplaceStringPlaceholdersTooFew) {
 910   // Test whether replacestringplaceholders works as expected when there
 911   // are fewer inputs than outputs.
 912   std::vector<string16> subst;
 913   subst.push_back(ASCIIToUTF16("9a"));
 914   subst.push_back(ASCIIToUTF16("8b"));
 915   subst.push_back(ASCIIToUTF16("7c"));
 916
 917   string16 formatted =
 918       ReplaceStringPlaceholders(
 919           ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$1g,$2h,$3i"), subst, NULL);
 920
 921   EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,d,e,f,9ag,8bh,7ci"));
 922 }
 923
 924 TEST(StringUtilTest, ReplaceStringPlaceholders) {
 925   std::vector<string16> subst;
 926   subst.push_back(ASCIIToUTF16("9a"));
 927   subst.push_back(ASCIIToUTF16("8b"));
 928   subst.push_back(ASCIIToUTF16("7c"));
 929   subst.push_back(ASCIIToUTF16("6d"));
 930   subst.push_back(ASCIIToUTF16("5e"));
 931   subst.push_back(ASCIIToUTF16("4f"));
 932   subst.push_back(ASCIIToUTF16("3g"));
 933   subst.push_back(ASCIIToUTF16("2h"));
 934   subst.push_back(ASCIIToUTF16("1i"));
 935
 936   string16 formatted =
 937       ReplaceStringPlaceholders(
 938           ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i"), subst, NULL);
 939
 940   EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii"));
 941 }
 942
 943 TEST(StringUtilTest, ReplaceStringPlaceholdersMoreThan9Replacements) {
 944   std::vector<string16> subst;
 945   subst.push_back(ASCIIToUTF16("9a"));
 946   subst.push_back(ASCIIToUTF16("8b"));
 947   subst.push_back(ASCIIToUTF16("7c"));
 948   subst.push_back(ASCIIToUTF16("6d"));
 949   subst.push_back(ASCIIToUTF16("5e"));
 950   subst.push_back(ASCIIToUTF16("4f"));
 951   subst.push_back(ASCIIToUTF16("3g"));
 952   subst.push_back(ASCIIToUTF16("2h"));
 953   subst.push_back(ASCIIToUTF16("1i"));
 954   subst.push_back(ASCIIToUTF16("0j"));
 955   subst.push_back(ASCIIToUTF16("-1k"));
 956   subst.push_back(ASCIIToUTF16("-2l"));
 957   subst.push_back(ASCIIToUTF16("-3m"));
 958   subst.push_back(ASCIIToUTF16("-4n"));
 959
 960   string16 formatted =
 961       ReplaceStringPlaceholders(
 962           ASCIIToUTF16("$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i,"
 963                        "$10j,$11k,$12l,$13m,$14n,$1"), subst, NULL);
 964
 965   EXPECT_EQ(formatted, ASCIIToUTF16("9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,"
 966                                     "1ii,0jj,-1kk,-2ll,-3mm,-4nn,9a"));
 967 }
 968
 969 TEST(StringUtilTest, StdStringReplaceStringPlaceholders) {
 970   std::vector<std::string> subst;
 971   subst.push_back("9a");
 972   subst.push_back("8b");
 973   subst.push_back("7c");
 974   subst.push_back("6d");
 975   subst.push_back("5e");
 976   subst.push_back("4f");
 977   subst.push_back("3g");
 978   subst.push_back("2h");
 979   subst.push_back("1i");
 980
 981   std::string formatted =
 982       ReplaceStringPlaceholders(
 983           "$1a,$2b,$3c,$4d,$5e,$6f,$7g,$8h,$9i", subst, NULL);
 984
 985   EXPECT_EQ(formatted, "9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii");
 986 }
 987
 988 TEST(StringUtilTest, ReplaceStringPlaceholdersConsecutiveDollarSigns) {
 989   std::vector<std::string> subst;
 990   subst.push_back("a");
 991   subst.push_back("b");
 992   subst.push_back("c");
 993   EXPECT_EQ(ReplaceStringPlaceholders("$$1 $$$2 $$$$3", subst, NULL),
 994             "$1 $$2 $$$3");
 995 }
 996
 997 TEST(StringUtilTest, LcpyTest) {
 998   // Test the normal case where we fit in our buffer.
 999   {
1000     char dst[10];
1001     wchar_t wdst[10];
1002     EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
1003     EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
1004     EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
1005     EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
1006   }
1007
1008   // Test dst_size == 0, nothing should be written to |dst| and we should
1009   // have the equivalent of strlen(src).
1010   {
1011     char dst[2] = {1, 2};
1012     wchar_t wdst[2] = {1, 2};
1013     EXPECT_EQ(7U, strlcpy(dst, "abcdefg", 0));
1014     EXPECT_EQ(1, dst[0]);
1015     EXPECT_EQ(2, dst[1]);
1016     EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", 0));
1017     EXPECT_EQ(static_cast<wchar_t>(1), wdst[0]);
1018     EXPECT_EQ(static_cast<wchar_t>(2), wdst[1]);
1019   }
1020
1021   // Test the case were we _just_ competely fit including the null.
1022   {
1023     char dst[8];
1024     wchar_t wdst[8];
1025     EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
1026     EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
1027     EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
1028     EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
1029   }
1030
1031   // Test the case were we we are one smaller, so we can't fit the null.
1032   {
1033     char dst[7];
1034     wchar_t wdst[7];
1035     EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
1036     EXPECT_EQ(0, memcmp(dst, "abcdef", 7));
1037     EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
1038     EXPECT_EQ(0, memcmp(wdst, L"abcdef", sizeof(wchar_t) * 7));
1039   }
1040
1041   // Test the case were we are just too small.
1042   {
1043     char dst[3];
1044     wchar_t wdst[3];
1045     EXPECT_EQ(7U, strlcpy(dst, "abcdefg", arraysize(dst)));
1046     EXPECT_EQ(0, memcmp(dst, "ab", 3));
1047     EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", arraysize(wdst)));
1048     EXPECT_EQ(0, memcmp(wdst, L"ab", sizeof(wchar_t) * 3));
1049   }
1050 }
1051
1052 TEST(StringUtilTest, WprintfFormatPortabilityTest) {
1053   static const struct {
1054     const wchar_t* input;
1055     bool portable;
1056   } cases[] = {
1057     { L"%ls", true },
1058     { L"%s", false },
1059     { L"%S", false },
1060     { L"%lS", false },
1061     { L"Hello, %s", false },
1062     { L"%lc", true },
1063     { L"%c", false },
1064     { L"%C", false },
1065     { L"%lC", false },
1066     { L"%ls %s", false },
1067     { L"%s %ls", false },
1068     { L"%s %ls %s", false },
1069     { L"%f", true },
1070     { L"%f %F", false },
1071     { L"%d %D", false },
1072     { L"%o %O", false },
1073     { L"%u %U", false },
1074     { L"%f %d %o %u", true },
1075     { L"%-8d (%02.1f%)", true },
1076     { L"% 10s", false },
1077     { L"% 10ls", true }
1078   };
1079   for (size_t i = 0; i < arraysize(cases); ++i)
1080     EXPECT_EQ(cases[i].portable, IsWprintfFormatPortable(cases[i].input));
1081 }
1082
1083 TEST(StringUtilTest, RemoveChars) {
1084   const char kRemoveChars[] = "-/+*";
1085   std::string input = "A-+bc/d!*";
1086   EXPECT_TRUE(RemoveChars(input, kRemoveChars, &input));
1087   EXPECT_EQ("Abcd!", input);
1088
1089   // No characters match kRemoveChars.
1090   EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
1091   EXPECT_EQ("Abcd!", input);
1092
1093   // Empty string.
1094   input.clear();
1095   EXPECT_FALSE(RemoveChars(input, kRemoveChars, &input));
1096   EXPECT_EQ(std::string(), input);
1097 }
1098
1099 TEST(StringUtilTest, ReplaceChars) {
1100   struct TestData {
1101     const char* input;
1102     const char* replace_chars;
1103     const char* replace_with;
1104     const char* output;
1105     bool result;
1106   } cases[] = {
1107     { "", "", "", "", false },
1108     { "test", "", "", "test", false },
1109     { "test", "", "!", "test", false },
1110     { "test", "z", "!", "test", false },
1111     { "test", "e", "!", "t!st", true },
1112     { "test", "e", "!?", "t!?st", true },
1113     { "test", "ez", "!", "t!st", true },
1114     { "test", "zed", "!?", "t!?st", true },
1115     { "test", "t", "!?", "!?es!?", true },
1116     { "test", "et", "!>", "!>!>s!>", true },
1117     { "test", "zest", "!", "!!!!", true },
1118     { "test", "szt", "!", "!e!!", true },
1119     { "test", "t", "test", "testestest", true },
1120   };
1121
1122   for (size_t i = 0; i < arraysize(cases); ++i) {
1123     std::string output;
1124     bool result = ReplaceChars(cases[i].input,
1125                                cases[i].replace_chars,
1126                                cases[i].replace_with,
1127                                &output);
1128     EXPECT_EQ(cases[i].result, result);
1129     EXPECT_EQ(cases[i].output, output);
1130   }
1131 }
1132
1133 TEST(StringUtilTest, ContainsOnlyChars) {
1134   // Providing an empty list of characters should return false but for the empty
1135   // string.
1136   EXPECT_TRUE(ContainsOnlyChars(std::string(), std::string()));
1137   EXPECT_FALSE(ContainsOnlyChars("Hello", std::string()));
1138
1139   EXPECT_TRUE(ContainsOnlyChars(std::string(), "1234"));
1140   EXPECT_TRUE(ContainsOnlyChars("1", "1234"));
1141   EXPECT_TRUE(ContainsOnlyChars("1", "4321"));
1142   EXPECT_TRUE(ContainsOnlyChars("123", "4321"));
1143   EXPECT_FALSE(ContainsOnlyChars("123a", "4321"));
1144
1145   EXPECT_TRUE(ContainsOnlyChars(std::string(), kWhitespaceASCII));
1146   EXPECT_TRUE(ContainsOnlyChars(" ", kWhitespaceASCII));
1147   EXPECT_TRUE(ContainsOnlyChars("\t", kWhitespaceASCII));
1148   EXPECT_TRUE(ContainsOnlyChars("\t \r \n  ", kWhitespaceASCII));
1149   EXPECT_FALSE(ContainsOnlyChars("a", kWhitespaceASCII));
1150   EXPECT_FALSE(ContainsOnlyChars("\thello\r \n  ", kWhitespaceASCII));
1151
1152   EXPECT_TRUE(ContainsOnlyChars(string16(), kWhitespaceUTF16));
1153   EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16(" "), kWhitespaceUTF16));
1154   EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t"), kWhitespaceUTF16));
1155   EXPECT_TRUE(ContainsOnlyChars(ASCIIToUTF16("\t \r \n  "), kWhitespaceUTF16));
1156   EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("a"), kWhitespaceUTF16));
1157   EXPECT_FALSE(ContainsOnlyChars(ASCIIToUTF16("\thello\r \n  "),
1158                                   kWhitespaceUTF16));
1159 }
1160
1161 class WriteIntoTest : public testing::Test {
1162  protected:
1163   static void WritesCorrectly(size_t num_chars) {
1164     std::string buffer;
1165     char kOriginal[] = "supercali";
1166     strncpy(WriteInto(&buffer, num_chars + 1), kOriginal, num_chars);
1167     // Using std::string(buffer.c_str()) instead of |buffer| truncates the
1168     // string at the first \0.
1169     EXPECT_EQ(std::string(kOriginal,
1170                           std::min(num_chars, arraysize(kOriginal) - 1)),
1171               std::string(buffer.c_str()));
1172     EXPECT_EQ(num_chars, buffer.size());
1173   }
1174 };
1175
1176 TEST_F(WriteIntoTest, WriteInto) {
1177   // Validate that WriteInto reserves enough space and
1178   // sizes a string correctly.
1179   WritesCorrectly(1);
1180   WritesCorrectly(2);
1181   WritesCorrectly(5000);
1182
1183   // Validate that WriteInto doesn't modify other strings
1184   // when using a Copy-on-Write implementation.
1185   const char kLive[] = "live";
1186   const char kDead[] = "dead";
1187   const std::string live = kLive;
1188   std::string dead = live;
1189   strncpy(WriteInto(&dead, 5), kDead, 4);
1190   EXPECT_EQ(kDead, dead);
1191   EXPECT_EQ(4u, dead.size());
1192   EXPECT_EQ(kLive, live);
1193   EXPECT_EQ(4u, live.size());
1194 }
1195
1196 }  // namespace base