net/tools/dump_cache/url_to_filename_encoder_unittest.cc

   1 // Copyright (c) 2010 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 "net/tools/dump_cache/url_to_filename_encoder.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/strings/string_piece.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using base::StringPiece;
  16 using std::string;
  17
  18 namespace net {
  19
  20 #ifdef WIN32
  21 char kDirSeparator = '\\';
  22 char kOtherDirSeparator = '/';
  23 #else
  24 char kDirSeparator = '/';
  25 char kOtherDirSeparator = '\\';
  26 #endif
  27
  28 class UrlToFilenameEncoderTest : public ::testing::Test {
  29  protected:
  30   UrlToFilenameEncoderTest() : escape_(1, UrlToFilenameEncoder::kEscapeChar),
  31                                dir_sep_(1, kDirSeparator) {
  32   }
  33
  34   void CheckSegmentLength(const StringPiece& escaped_word) {
  35     std::vector<StringPiece> components;
  36     Tokenize(escaped_word, StringPiece("/"), &components);
  37     for (size_t i = 0; i < components.size(); ++i) {
  38       EXPECT_GE(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
  39                 components[i].size());
  40     }
  41   }
  42
  43   void CheckValidChars(const StringPiece& escaped_word, char invalid_slash) {
  44     // These characters are invalid in Windows.  We add in ', as that's pretty
  45     // inconvenient in a Unix filename.
  46     //
  47     // See http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
  48     const string kInvalidChars = "<>:\"|?*'";
  49     for (size_t i = 0; i < escaped_word.size(); ++i) {
  50       char c = escaped_word[i];
  51       EXPECT_EQ(string::npos, kInvalidChars.find(c));
  52       EXPECT_NE(invalid_slash, c);
  53       EXPECT_NE('\0', c);  // only invalid character in Posix
  54       EXPECT_GT(0x7E, c);  // only English printable characters
  55     }
  56   }
  57
  58   void Validate(const string& in_word, const string& gold_word) {
  59     string escaped_word, url;
  60     UrlToFilenameEncoder::EncodeSegment(
  61         std::string(), in_word, '/', &escaped_word);
  62     EXPECT_EQ(gold_word, escaped_word);
  63     CheckSegmentLength(escaped_word);
  64     CheckValidChars(escaped_word, '\\');
  65     UrlToFilenameEncoder::Decode(escaped_word, '/', &url);
  66     EXPECT_EQ(in_word, url);
  67   }
  68
  69   void ValidateAllSegmentsSmall(const string& in_word) {
  70     string escaped_word, url;
  71     UrlToFilenameEncoder::EncodeSegment(
  72         std::string(), in_word, '/', &escaped_word);
  73     CheckSegmentLength(escaped_word);
  74     CheckValidChars(escaped_word, '\\');
  75     UrlToFilenameEncoder::Decode(escaped_word, '/', &url);
  76     EXPECT_EQ(in_word, url);
  77   }
  78
  79   void ValidateNoChange(const string& word) {
  80     // We always suffix the leaf with kEscapeChar, unless the leaf is empty.
  81     Validate(word, word + escape_);
  82   }
  83
  84   void ValidateEscaped(unsigned char ch) {
  85     // We always suffix the leaf with kEscapeChar, unless the leaf is empty.
  86     char escaped[100];
  87     const char escape = UrlToFilenameEncoder::kEscapeChar;
  88     base::snprintf(escaped, sizeof(escaped), "%c%02X%c", escape, ch, escape);
  89     Validate(string(1, ch), escaped);
  90   }
  91
  92   void ValidateUrl(const string& url, const string& base_path,
  93                    bool legacy_escape, const string& gold_filename) {
  94     string encoded_filename = UrlToFilenameEncoder::Encode(
  95         url, base_path, legacy_escape);
  96     EXPECT_EQ(gold_filename, encoded_filename);
  97     if (!legacy_escape) {
  98       CheckSegmentLength(encoded_filename);
  99       CheckValidChars(encoded_filename, kOtherDirSeparator);
 100       string decoded_url;
 101       UrlToFilenameEncoder::Decode(encoded_filename, kDirSeparator,
 102                                    &decoded_url);
 103       if (url != decoded_url) {
 104         EXPECT_EQ(url, "http://" + decoded_url);
 105       }
 106     }
 107   }
 108
 109   void ValidateUrlOldNew(const string& url, const string& gold_old_filename,
 110                          const string& gold_new_filename) {
 111     ValidateUrl(url, std::string(), true, gold_old_filename);
 112     ValidateUrl(url, std::string(), false, gold_new_filename);
 113   }
 114
 115   void ValidateEncodeSame(const string& url1, const string& url2) {
 116     string filename1 = UrlToFilenameEncoder::Encode(url1, std::string(), false);
 117     string filename2 = UrlToFilenameEncoder::Encode(url2, std::string(), false);
 118     EXPECT_EQ(filename1, filename2);
 119   }
 120
 121   string escape_;
 122   string dir_sep_;
 123 };
 124
 125 TEST_F(UrlToFilenameEncoderTest, DoesNotEscape) {
 126   ValidateNoChange(std::string());
 127   ValidateNoChange("abcdefg");
 128   ValidateNoChange("abcdefghijklmnopqrstuvwxyz");
 129   ValidateNoChange("ZYXWVUT");
 130   ValidateNoChange("ZYXWVUTSRQPONMLKJIHGFEDCBA");
 131   ValidateNoChange("01234567689");
 132   ValidateNoChange("_.=+-");
 133   ValidateNoChange("abcdefghijklmnopqrstuvwxyzZYXWVUTSRQPONMLKJIHGFEDCBA"
 134                    "01234567689_.=+-");
 135   ValidateNoChange("index.html");
 136   ValidateNoChange("/");
 137   ValidateNoChange("/.");
 138   ValidateNoChange(".");
 139   ValidateNoChange("..");
 140 }
 141
 142 TEST_F(UrlToFilenameEncoderTest, Escapes) {
 143   const string bad_chars =
 144       "<>:\"\\|?*"      // Illegal on Windows
 145       "~`!$^&(){}[]';"  // Bad for Unix shells
 146       "^@"              // Build tool doesn't like
 147       "#%"              // Tool doesn't like
 148       ",";              // The escape char has to be escaped
 149
 150   for (size_t i = 0; i < bad_chars.size(); ++i) {
 151     ValidateEscaped(bad_chars[i]);
 152   }
 153
 154   // Check non-printable characters.
 155   ValidateEscaped('\0');
 156   for (size_t i = 127; i < 256; ++i) {
 157     ValidateEscaped(static_cast<char>(i));
 158   }
 159 }
 160
 161 TEST_F(UrlToFilenameEncoderTest, DoesEscapeCorrectly) {
 162   Validate("mysite.com&x", "mysite.com" + escape_ + "26x" + escape_);
 163   Validate("/./", "/" + escape_ + "./" + escape_);
 164   Validate("/../", "/" + escape_ + "../" + escape_);
 165   Validate("//", "/" + escape_ + "2F" + escape_);
 166   Validate("/./leaf", "/" + escape_ + "./leaf" + escape_);
 167   Validate("/../leaf", "/" + escape_ + "../leaf" + escape_);
 168   Validate("//leaf", "/" + escape_ + "2Fleaf" + escape_);
 169   Validate("mysite/u?param1=x&param2=y",
 170            "mysite/u" + escape_ + "3Fparam1=x" + escape_ + "26param2=y" +
 171            escape_);
 172   Validate("search?q=dogs&go=&form=QBLH&qs=n",  // from Latency Labs bing test.
 173            "search" + escape_ + "3Fq=dogs" + escape_ + "26go=" + escape_ +
 174            "26form=QBLH" + escape_ + "26qs=n" + escape_);
 175   Validate("~joebob/my_neeto-website+with_stuff.asp?id=138&content=true",
 176            "" + escape_ + "7Ejoebob/my_neeto-website+with_stuff.asp" + escape_ +
 177            "3Fid=138" + escape_ + "26content=true" + escape_);
 178 }
 179
 180 TEST_F(UrlToFilenameEncoderTest, EncodeUrlCorrectly) {
 181   ValidateUrlOldNew("http://www.google.com/index.html",
 182                     "www.google.com" + dir_sep_ + "indexx2Ehtml",
 183                     "www.google.com" + dir_sep_ + "index.html" + escape_);
 184   ValidateUrlOldNew("http://www.google.com/x/search?hl=en&q=dogs&oq=",
 185                     "www.google.com" + dir_sep_ + "x" + dir_sep_ +
 186                     "searchx3Fhlx3Denx26qx3Ddogsx26oqx3D",
 187
 188                     "www.google.com" + dir_sep_ + "x" + dir_sep_ + "search" +
 189                     escape_ + "3Fhl=en" + escape_ + "26q=dogs" + escape_ +
 190                     "26oq=" + escape_);
 191   ValidateUrlOldNew("http://www.foo.com/a//",
 192                     "www.foo.com" + dir_sep_ + "ax255Cx255Cindexx2Ehtml",
 193                     "www.foo.com" + dir_sep_ + "a" + dir_sep_ + escape_ + "2F" +
 194                     escape_);
 195
 196   // From bug: Double slash preserved.
 197   ValidateUrl("http://www.foo.com/u?site=http://www.google.com/index.html",
 198               std::string(),
 199               false,
 200               "www.foo.com" + dir_sep_ + "u" + escape_ + "3Fsite=http" +
 201               escape_ + "3A" + dir_sep_ + escape_ + "2Fwww.google.com" +
 202               dir_sep_ + "index.html" + escape_);
 203   ValidateUrlOldNew(
 204       "http://blogutils.net/olct/online.php?"
 205       "site=http://thelwordfanfics.blogspot.&interval=600",
 206
 207       "blogutils.net" + dir_sep_ + "olct" + dir_sep_ + "onlinex2Ephpx3F"
 208       "sitex3Dhttpx3Ax255Cx255Cthelwordfanficsx2Eblogspotx2Ex26intervalx3D600",
 209
 210       "blogutils.net" + dir_sep_ + "olct" + dir_sep_ + "online.php" + escape_ +
 211       "3Fsite=http" + escape_ + "3A" + dir_sep_ + escape_ +
 212       "2Fthelwordfanfics.blogspot." + escape_ + "26interval=600" + escape_);
 213 }
 214
 215 // From bug: Escapes treated the same as normal char.
 216 TEST_F(UrlToFilenameEncoderTest, UnescapeUrlsBeforeEncode) {
 217   for (int i = 0; i < 128; ++i) {
 218     string unescaped(1, static_cast<char>(i));
 219     string escaped = base::StringPrintf("%%%02X", i);
 220     ValidateEncodeSame(unescaped, escaped);
 221   }
 222
 223   ValidateEncodeSame(
 224       "http://www.blogger.com/navbar.g?bName=God!&Mode=FOO&searchRoot"
 225       "=http%3A%2F%2Fsurvivorscanthrive.blogspot.com%2Fsearch",
 226
 227       "http://www.blogger.com/navbar.g?bName=God%21&Mode=FOO&searchRoot"
 228       "=http%3A%2F%2Fsurvivorscanthrive.blogspot.com%2Fsearch");
 229 }
 230
 231 // From bug: Filename encoding is not prefix-free.
 232 TEST_F(UrlToFilenameEncoderTest, EscapeSecondSlash) {
 233   Validate("/", "/" + escape_);
 234   Validate("//", "/" + escape_ + "2F" + escape_);
 235   Validate("///", "/" + escape_ + "2F" + "/" + escape_);
 236 }
 237
 238 TEST_F(UrlToFilenameEncoderTest, LongTail) {
 239   static char long_word[] =
 240       "~joebob/briggs/12345678901234567890123456789012345678901234567890"
 241       "1234567890123456789012345678901234567890123456789012345678901234567890"
 242       "1234567890123456789012345678901234567890123456789012345678901234567890"
 243       "1234567890123456789012345678901234567890123456789012345678901234567890"
 244       "1234567890123456789012345678901234567890123456789012345678901234567890"
 245       "1234567890123456789012345678901234567890123456789012345678901234567890";
 246
 247   // the long lines in the string below are 64 characters, so we can see
 248   // the slashes every 128.
 249   string gold_long_word =
 250       escape_ + "7Ejoebob/briggs/"
 251       "1234567890123456789012345678901234567890123456789012345678901234"
 252       "56789012345678901234567890123456789012345678901234567890123456" +
 253       escape_ + "-/"
 254       "7890123456789012345678901234567890123456789012345678901234567890"
 255       "12345678901234567890123456789012345678901234567890123456789012" +
 256       escape_ + "-/"
 257       "3456789012345678901234567890123456789012345678901234567890123456"
 258       "78901234567890123456789012345678901234567890123456789012345678" +
 259       escape_ + "-/"
 260       "9012345678901234567890" + escape_;
 261   EXPECT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
 262             sizeof(long_word));
 263   Validate(long_word, gold_long_word);
 264 }
 265
 266 TEST_F(UrlToFilenameEncoderTest, LongTailQuestion) {
 267   // Here the '?' in the last path segment expands to @3F, making
 268   // it hit 128 chars before the input segment gets that big.
 269   static char long_word[] =
 270       "~joebob/briggs/1234567?1234567?1234567?1234567?1234567?"
 271       "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
 272       "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
 273       "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
 274       "1234567?1234567?1234567?1234567?1234567?1234567?1234567?"
 275       "1234567?1234567?1234567?1234567?1234567?1234567?1234567?";
 276
 277   // Notice that at the end of the third segment, we avoid splitting
 278   // the (escape_ + "3F") that was generated from the "?", so that segment is
 279   // only 127 characters.
 280   string pattern = "1234567" + escape_ + "3F";  // 10 characters
 281   string gold_long_word =
 282       escape_ + "7Ejoebob/briggs/" +
 283       pattern + pattern + pattern + pattern + pattern + pattern + "1234"
 284       "567" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern +
 285        "123456" + escape_ + "-/"
 286       "7" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern +
 287       pattern + pattern + pattern + pattern + pattern + pattern + pattern +
 288       "12" +
 289       escape_ + "-/"
 290       "34567" + escape_ + "3F" + pattern + pattern + pattern + pattern + pattern
 291       + "1234567" + escape_ + "3F" + pattern + pattern + pattern + pattern
 292       + pattern + "1234567" +
 293       escape_ + "-/" +
 294       escape_ + "3F" + pattern + pattern + escape_;
 295   EXPECT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
 296             sizeof(long_word));
 297   Validate(long_word, gold_long_word);
 298 }
 299
 300 TEST_F(UrlToFilenameEncoderTest, CornerCasesNearMaxLenNoEscape) {
 301   // hit corner cases, +/- 4 characters from kMaxLen
 302   for (int i = -4; i <= 4; ++i) {
 303     string input;
 304     input.append(i + UrlToFilenameEncoder::kMaximumSubdirectoryLength, 'x');
 305     ValidateAllSegmentsSmall(input);
 306   }
 307 }
 308
 309 TEST_F(UrlToFilenameEncoderTest, CornerCasesNearMaxLenWithEscape) {
 310   // hit corner cases, +/- 4 characters from kMaxLen.  This time we
 311   // leave off the last 'x' and put in a '.', which ensures that we
 312   // are truncating with '/' *after* the expansion.
 313   for (int i = -4; i <= 4; ++i) {
 314     string input;
 315     input.append(i + UrlToFilenameEncoder::kMaximumSubdirectoryLength - 1, 'x');
 316     input.append(1, '.');  // this will expand to 3 characters.
 317     ValidateAllSegmentsSmall(input);
 318   }
 319 }
 320
 321 TEST_F(UrlToFilenameEncoderTest, LeafBranchAlias) {
 322   Validate("/a/b/c", "/a/b/c" + escape_);        // c is leaf file "c,"
 323   Validate("/a/b/c/d", "/a/b/c/d" + escape_);    // c is directory "c"
 324   Validate("/a/b/c/d/", "/a/b/c/d/" + escape_);
 325 }
 326
 327
 328 TEST_F(UrlToFilenameEncoderTest, BackslashSeparator) {
 329   string long_word;
 330   string escaped_word;
 331   long_word.append(UrlToFilenameEncoder::kMaximumSubdirectoryLength + 1, 'x');
 332   UrlToFilenameEncoder::EncodeSegment(
 333       std::string(), long_word, '\\', &escaped_word);
 334
 335   // check that one backslash, plus the escape ",-", and the ending , got added.
 336   EXPECT_EQ(long_word.size() + 4, escaped_word.size());
 337   ASSERT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
 338             escaped_word.size());
 339   // Check that the backslash got inserted at the correct spot.
 340   EXPECT_EQ('\\', escaped_word[
 341       UrlToFilenameEncoder::kMaximumSubdirectoryLength]);
 342 }
 343
 344 }  // namespace net
 345