| OLD | NEW |
|---|
| (Empty) |
| 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¶m2=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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master