| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 <algorithm> | |
| 6 #include <string> | |
| 7 | |
| 8 #include "net/base/escape.h" | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/strings/stringprintf.h" | |
| 13 #include "base/strings/utf_string_conversions.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 | |
| 16 namespace net { | |
| 17 namespace { | |
| 18 | |
| 19 struct EscapeCase { | |
| 20 const char* input; | |
| 21 const char* output; | |
| 22 }; | |
| 23 | |
| 24 struct UnescapeURLCase { | |
| 25 const wchar_t* input; | |
| 26 UnescapeRule::Type rules; | |
| 27 const wchar_t* output; | |
| 28 }; | |
| 29 | |
| 30 struct UnescapeURLCaseASCII { | |
| 31 const char* input; | |
| 32 UnescapeRule::Type rules; | |
| 33 const char* output; | |
| 34 }; | |
| 35 | |
| 36 struct UnescapeAndDecodeCase { | |
| 37 const char* input; | |
| 38 | |
| 39 // The expected output when run through UnescapeURL. | |
| 40 const char* url_unescaped; | |
| 41 | |
| 42 // The expected output when run through UnescapeQuery. | |
| 43 const char* query_unescaped; | |
| 44 | |
| 45 // The expected output when run through UnescapeAndDecodeURLComponent. | |
| 46 const wchar_t* decoded; | |
| 47 }; | |
| 48 | |
| 49 struct AdjustOffsetCase { | |
| 50 const char* input; | |
| 51 size_t input_offset; | |
| 52 size_t output_offset; | |
| 53 }; | |
| 54 | |
| 55 struct EscapeForHTMLCase { | |
| 56 const char* input; | |
| 57 const char* expected_output; | |
| 58 }; | |
| 59 | |
| 60 TEST(EscapeTest, EscapeTextForFormSubmission) { | |
| 61 const EscapeCase escape_cases[] = { | |
| 62 {"foo", "foo"}, | |
| 63 {"foo bar", "foo+bar"}, | |
| 64 {"foo++", "foo%2B%2B"} | |
| 65 }; | |
| 66 for (size_t i = 0; i < arraysize(escape_cases); ++i) { | |
| 67 EscapeCase value = escape_cases[i]; | |
| 68 EXPECT_EQ(value.output, EscapeQueryParamValue(value.input, true)); | |
| 69 } | |
| 70 | |
| 71 const EscapeCase escape_cases_no_plus[] = { | |
| 72 {"foo", "foo"}, | |
| 73 {"foo bar", "foo%20bar"}, | |
| 74 {"foo++", "foo%2B%2B"} | |
| 75 }; | |
| 76 for (size_t i = 0; i < arraysize(escape_cases_no_plus); ++i) { | |
| 77 EscapeCase value = escape_cases_no_plus[i]; | |
| 78 EXPECT_EQ(value.output, EscapeQueryParamValue(value.input, false)); | |
| 79 } | |
| 80 | |
| 81 // Test all the values in we're supposed to be escaping. | |
| 82 const std::string no_escape( | |
| 83 "abcdefghijklmnopqrstuvwxyz" | |
| 84 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 85 "0123456789" | |
| 86 "!'()*-._~"); | |
| 87 for (int i = 0; i < 256; ++i) { | |
| 88 std::string in; | |
| 89 in.push_back(i); | |
| 90 std::string out = EscapeQueryParamValue(in, true); | |
| 91 if (0 == i) { | |
| 92 EXPECT_EQ(out, std::string("%00")); | |
| 93 } else if (32 == i) { | |
| 94 // Spaces are plus escaped like web forms. | |
| 95 EXPECT_EQ(out, std::string("+")); | |
| 96 } else if (no_escape.find(in) == std::string::npos) { | |
| 97 // Check %hex escaping | |
| 98 std::string expected = base::StringPrintf("%%%02X", i); | |
| 99 EXPECT_EQ(expected, out); | |
| 100 } else { | |
| 101 // No change for things in the no_escape list. | |
| 102 EXPECT_EQ(out, in); | |
| 103 } | |
| 104 } | |
| 105 } | |
| 106 | |
| 107 TEST(EscapeTest, EscapePath) { | |
| 108 ASSERT_EQ( | |
| 109 // Most of the character space we care about, un-escaped | |
| 110 EscapePath( | |
| 111 "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;" | |
| 112 "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 113 "[\\]^_`abcdefghijklmnopqrstuvwxyz" | |
| 114 "{|}~\x7f\x80\xff"), | |
| 115 // Escaped | |
| 116 "%02%0A%1D%20!%22%23$%25&'()*+,-./0123456789%3A;" | |
| 117 "%3C=%3E%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 118 "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz" | |
| 119 "%7B%7C%7D~%7F%80%FF"); | |
| 120 } | |
| 121 | |
| 122 TEST(EscapeTest, DataURLWithAccentedCharacters) { | |
| 123 const std::string url = | |
| 124 "text/html;charset=utf-8,%3Chtml%3E%3Cbody%3ETonton,%20ton%20th%C3" | |
| 125 "%A9%20t'a-t-il%20%C3%B4t%C3%A9%20ta%20toux%20"; | |
| 126 | |
| 127 base::OffsetAdjuster::Adjustments adjustments; | |
| 128 net::UnescapeAndDecodeUTF8URLComponentWithAdjustments( | |
| 129 url, UnescapeRule::SPACES, &adjustments); | |
| 130 } | |
| 131 | |
| 132 TEST(EscapeTest, EscapeUrlEncodedData) { | |
| 133 ASSERT_EQ( | |
| 134 // Most of the character space we care about, un-escaped | |
| 135 EscapeUrlEncodedData( | |
| 136 "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;" | |
| 137 "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 138 "[\\]^_`abcdefghijklmnopqrstuvwxyz" | |
| 139 "{|}~\x7f\x80\xff", true), | |
| 140 // Escaped | |
| 141 "%02%0A%1D+!%22%23%24%25%26%27()*%2B,-./0123456789:%3B" | |
| 142 "%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 143 "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz" | |
| 144 "%7B%7C%7D~%7F%80%FF"); | |
| 145 } | |
| 146 | |
| 147 TEST(EscapeTest, EscapeUrlEncodedDataSpace) { | |
| 148 ASSERT_EQ(EscapeUrlEncodedData("a b", true), "a+b"); | |
| 149 ASSERT_EQ(EscapeUrlEncodedData("a b", false), "a%20b"); | |
| 150 } | |
| 151 | |
| 152 TEST(EscapeTest, UnescapeURLComponentASCII) { | |
| 153 const UnescapeURLCaseASCII unescape_cases[] = { | |
| 154 {"", UnescapeRule::NORMAL, ""}, | |
| 155 {"%2", UnescapeRule::NORMAL, "%2"}, | |
| 156 {"%%%%%%", UnescapeRule::NORMAL, "%%%%%%"}, | |
| 157 {"Don't escape anything", UnescapeRule::NORMAL, "Don't escape anything"}, | |
| 158 {"Invalid %escape %2", UnescapeRule::NORMAL, "Invalid %escape %2"}, | |
| 159 {"Some%20random text %25%2dOK", UnescapeRule::NONE, | |
| 160 "Some%20random text %25%2dOK"}, | |
| 161 {"Some%20random text %25%2dOK", UnescapeRule::NORMAL, | |
| 162 "Some%20random text %25-OK"}, | |
| 163 {"Some%20random text %25%2dOK", UnescapeRule::SPACES, | |
| 164 "Some random text %25-OK"}, | |
| 165 {"Some%20random text %25%2dOK", UnescapeRule::URL_SPECIAL_CHARS, | |
| 166 "Some%20random text %-OK"}, | |
| 167 {"Some%20random text %25%2dOK", | |
| 168 UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS, | |
| 169 "Some random text %-OK"}, | |
| 170 {"%A0%B1%C2%D3%E4%F5", UnescapeRule::NORMAL, "\xA0\xB1\xC2\xD3\xE4\xF5"}, | |
| 171 {"%Aa%Bb%Cc%Dd%Ee%Ff", UnescapeRule::NORMAL, "\xAa\xBb\xCc\xDd\xEe\xFf"}, | |
| 172 // Certain URL-sensitive characters should not be unescaped unless asked. | |
| 173 {"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+", UnescapeRule::SPACES, | |
| 174 "Hello %13%10world %23# %3F? %3D= %26& %25% %2B+"}, | |
| 175 {"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+", | |
| 176 UnescapeRule::URL_SPECIAL_CHARS, | |
| 177 "Hello%20%13%10world ## ?? == && %% ++"}, | |
| 178 // We can neither escape nor unescape '@' since some websites expect it to | |
| 179 // be preserved as either '@' or "%40". | |
| 180 // See http://b/996720 and http://crbug.com/23933 . | |
| 181 {"me@my%40example", UnescapeRule::NORMAL, "me@my%40example"}, | |
| 182 // Control characters. | |
| 183 {"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::URL_SPECIAL_CHARS, | |
| 184 "%01%02%03%04%05%06%07%08%09 %"}, | |
| 185 {"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::CONTROL_CHARS, | |
| 186 "\x01\x02\x03\x04\x05\x06\x07\x08\x09 %25"}, | |
| 187 {"Hello%20%13%10%02", UnescapeRule::SPACES, "Hello %13%10%02"}, | |
| 188 {"Hello%20%13%10%02", UnescapeRule::CONTROL_CHARS, "Hello%20\x13\x10\x02"}, | |
| 189 }; | |
| 190 | |
| 191 for (size_t i = 0; i < arraysize(unescape_cases); i++) { | |
| 192 std::string str(unescape_cases[i].input); | |
| 193 EXPECT_EQ(std::string(unescape_cases[i].output), | |
| 194 UnescapeURLComponent(str, unescape_cases[i].rules)); | |
| 195 } | |
| 196 | |
| 197 // Test the NULL character unescaping (which wouldn't work above since those | |
| 198 // are just char pointers). | |
| 199 std::string input("Null"); | |
| 200 input.push_back(0); // Also have a NULL in the input. | |
| 201 input.append("%00%39Test"); | |
| 202 | |
| 203 // When we're unescaping NULLs | |
| 204 std::string expected("Null"); | |
| 205 expected.push_back(0); | |
| 206 expected.push_back(0); | |
| 207 expected.append("9Test"); | |
| 208 EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::CONTROL_CHARS)); | |
| 209 | |
| 210 // When we're not unescaping NULLs. | |
| 211 expected = "Null"; | |
| 212 expected.push_back(0); | |
| 213 expected.append("%009Test"); | |
| 214 EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::NORMAL)); | |
| 215 } | |
| 216 | |
| 217 TEST(EscapeTest, UnescapeURLComponent) { | |
| 218 const UnescapeURLCase unescape_cases[] = { | |
| 219 {L"", UnescapeRule::NORMAL, L""}, | |
| 220 {L"%2", UnescapeRule::NORMAL, L"%2"}, | |
| 221 {L"%%%%%%", UnescapeRule::NORMAL, L"%%%%%%"}, | |
| 222 {L"Don't escape anything", UnescapeRule::NORMAL, L"Don't escape anything"}, | |
| 223 {L"Invalid %escape %2", UnescapeRule::NORMAL, L"Invalid %escape %2"}, | |
| 224 {L"Some%20random text %25%2dOK", UnescapeRule::NONE, | |
| 225 L"Some%20random text %25%2dOK"}, | |
| 226 {L"Some%20random text %25%2dOK", UnescapeRule::NORMAL, | |
| 227 L"Some%20random text %25-OK"}, | |
| 228 {L"Some%20random text %25%E2%80", UnescapeRule::NORMAL, | |
| 229 L"Some%20random text %25\xE2\x80"}, | |
| 230 {L"Some%20random text %25%E2%80OK", UnescapeRule::NORMAL, | |
| 231 L"Some%20random text %25\xE2\x80OK"}, | |
| 232 {L"Some%20random text %25%E2%80%84OK", UnescapeRule::NORMAL, | |
| 233 L"Some%20random text %25\xE2\x80\x84OK"}, | |
| 234 | |
| 235 // BiDi Control characters should not be unescaped unless explicity told to | |
| 236 // do so with UnescapeRule::CONTROL_CHARS | |
| 237 {L"Some%20random text %25%D8%9COK", UnescapeRule::NORMAL, | |
| 238 L"Some%20random text %25%D8%9COK"}, | |
| 239 {L"Some%20random text %25%E2%80%8EOK", UnescapeRule::NORMAL, | |
| 240 L"Some%20random text %25%E2%80%8EOK"}, | |
| 241 {L"Some%20random text %25%E2%80%8FOK", UnescapeRule::NORMAL, | |
| 242 L"Some%20random text %25%E2%80%8FOK"}, | |
| 243 {L"Some%20random text %25%E2%80%AAOK", UnescapeRule::NORMAL, | |
| 244 L"Some%20random text %25%E2%80%AAOK"}, | |
| 245 {L"Some%20random text %25%E2%80%ABOK", UnescapeRule::NORMAL, | |
| 246 L"Some%20random text %25%E2%80%ABOK"}, | |
| 247 {L"Some%20random text %25%E2%80%AEOK", UnescapeRule::NORMAL, | |
| 248 L"Some%20random text %25%E2%80%AEOK"}, | |
| 249 {L"Some%20random text %25%E2%81%A6OK", UnescapeRule::NORMAL, | |
| 250 L"Some%20random text %25%E2%81%A6OK"}, | |
| 251 {L"Some%20random text %25%E2%81%A9OK", UnescapeRule::NORMAL, | |
| 252 L"Some%20random text %25%E2%81%A9OK"}, | |
| 253 // UnescapeRule::CONTROL_CHARS should unescape BiDi Control characters. | |
| 254 {L"Some%20random text %25%D8%9COK", | |
| 255 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 256 L"Some%20random text %25\xD8\x9COK"}, | |
| 257 {L"Some%20random text %25%E2%80%8EOK", | |
| 258 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 259 L"Some%20random text %25\xE2\x80\x8EOK"}, | |
| 260 {L"Some%20random text %25%E2%80%8FOK", | |
| 261 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 262 L"Some%20random text %25\xE2\x80\x8FOK"}, | |
| 263 {L"Some%20random text %25%E2%80%AAOK", | |
| 264 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 265 L"Some%20random text %25\xE2\x80\xAAOK"}, | |
| 266 {L"Some%20random text %25%E2%80%ABOK", | |
| 267 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 268 L"Some%20random text %25\xE2\x80\xABOK"}, | |
| 269 {L"Some%20random text %25%E2%80%AEOK", | |
| 270 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 271 L"Some%20random text %25\xE2\x80\xAEOK"}, | |
| 272 {L"Some%20random text %25%E2%81%A6OK", | |
| 273 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 274 L"Some%20random text %25\xE2\x81\xA6OK"}, | |
| 275 {L"Some%20random text %25%E2%81%A9OK", | |
| 276 UnescapeRule::NORMAL | UnescapeRule::CONTROL_CHARS, | |
| 277 L"Some%20random text %25\xE2\x81\xA9OK"}, | |
| 278 | |
| 279 {L"Some%20random text %25%2dOK", UnescapeRule::SPACES, | |
| 280 L"Some random text %25-OK"}, | |
| 281 {L"Some%20random text %25%2dOK", UnescapeRule::URL_SPECIAL_CHARS, | |
| 282 L"Some%20random text %-OK"}, | |
| 283 {L"Some%20random text %25%2dOK", | |
| 284 UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS, | |
| 285 L"Some random text %-OK"}, | |
| 286 {L"%A0%B1%C2%D3%E4%F5", UnescapeRule::NORMAL, L"\xA0\xB1\xC2\xD3\xE4\xF5"}, | |
| 287 {L"%Aa%Bb%Cc%Dd%Ee%Ff", UnescapeRule::NORMAL, L"\xAa\xBb\xCc\xDd\xEe\xFf"}, | |
| 288 // Certain URL-sensitive characters should not be unescaped unless asked. | |
| 289 {L"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+", UnescapeRule::SPACES, | |
| 290 L"Hello %13%10world %23# %3F? %3D= %26& %25% %2B+"}, | |
| 291 {L"Hello%20%13%10world %23# %3F? %3D= %26& %25% %2B+", | |
| 292 UnescapeRule::URL_SPECIAL_CHARS, | |
| 293 L"Hello%20%13%10world ## ?? == && %% ++"}, | |
| 294 // We can neither escape nor unescape '@' since some websites expect it to | |
| 295 // be preserved as either '@' or "%40". | |
| 296 // See http://b/996720 and http://crbug.com/23933 . | |
| 297 {L"me@my%40example", UnescapeRule::NORMAL, L"me@my%40example"}, | |
| 298 // Control characters. | |
| 299 {L"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::URL_SPECIAL_CHARS, | |
| 300 L"%01%02%03%04%05%06%07%08%09 %"}, | |
| 301 {L"%01%02%03%04%05%06%07%08%09 %25", UnescapeRule::CONTROL_CHARS, | |
| 302 L"\x01\x02\x03\x04\x05\x06\x07\x08\x09 %25"}, | |
| 303 {L"Hello%20%13%10%02", UnescapeRule::SPACES, L"Hello %13%10%02"}, | |
| 304 {L"Hello%20%13%10%02", UnescapeRule::CONTROL_CHARS, | |
| 305 L"Hello%20\x13\x10\x02"}, | |
| 306 {L"Hello\x9824\x9827", UnescapeRule::CONTROL_CHARS, | |
| 307 L"Hello\x9824\x9827"}, | |
| 308 }; | |
| 309 | |
| 310 for (size_t i = 0; i < arraysize(unescape_cases); i++) { | |
| 311 base::string16 str(base::WideToUTF16(unescape_cases[i].input)); | |
| 312 EXPECT_EQ(base::WideToUTF16(unescape_cases[i].output), | |
| 313 UnescapeURLComponent(str, unescape_cases[i].rules)); | |
| 314 } | |
| 315 | |
| 316 // Test the NULL character unescaping (which wouldn't work above since those | |
| 317 // are just char pointers). | |
| 318 base::string16 input(base::WideToUTF16(L"Null")); | |
| 319 input.push_back(0); // Also have a NULL in the input. | |
| 320 input.append(base::WideToUTF16(L"%00%39Test")); | |
| 321 | |
| 322 // When we're unescaping NULLs | |
| 323 base::string16 expected(base::WideToUTF16(L"Null")); | |
| 324 expected.push_back(0); | |
| 325 expected.push_back(0); | |
| 326 expected.append(base::ASCIIToUTF16("9Test")); | |
| 327 EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::CONTROL_CHARS)); | |
| 328 | |
| 329 // When we're not unescaping NULLs. | |
| 330 expected = base::WideToUTF16(L"Null"); | |
| 331 expected.push_back(0); | |
| 332 expected.append(base::WideToUTF16(L"%009Test")); | |
| 333 EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::NORMAL)); | |
| 334 } | |
| 335 | |
| 336 TEST(EscapeTest, UnescapeAndDecodeUTF8URLComponent) { | |
| 337 const UnescapeAndDecodeCase unescape_cases[] = { | |
| 338 { "%", | |
| 339 "%", | |
| 340 "%", | |
| 341 L"%"}, | |
| 342 { "+", | |
| 343 "+", | |
| 344 " ", | |
| 345 L"+"}, | |
| 346 { "%2+", | |
| 347 "%2+", | |
| 348 "%2 ", | |
| 349 L"%2+"}, | |
| 350 { "+%%%+%%%", | |
| 351 "+%%%+%%%", | |
| 352 " %%% %%%", | |
| 353 L"+%%%+%%%"}, | |
| 354 { "Don't escape anything", | |
| 355 "Don't escape anything", | |
| 356 "Don't escape anything", | |
| 357 L"Don't escape anything"}, | |
| 358 { "+Invalid %escape %2+", | |
| 359 "+Invalid %escape %2+", | |
| 360 " Invalid %escape %2 ", | |
| 361 L"+Invalid %escape %2+"}, | |
| 362 { "Some random text %25%2dOK", | |
| 363 "Some random text %25-OK", | |
| 364 "Some random text %25-OK", | |
| 365 L"Some random text %25-OK"}, | |
| 366 { "%01%02%03%04%05%06%07%08%09", | |
| 367 "%01%02%03%04%05%06%07%08%09", | |
| 368 "%01%02%03%04%05%06%07%08%09", | |
| 369 L"%01%02%03%04%05%06%07%08%09"}, | |
| 370 { "%E4%BD%A0+%E5%A5%BD", | |
| 371 "\xE4\xBD\xA0+\xE5\xA5\xBD", | |
| 372 "\xE4\xBD\xA0 \xE5\xA5\xBD", | |
| 373 L"\x4f60+\x597d"}, | |
| 374 { "%ED%ED", // Invalid UTF-8. | |
| 375 "\xED\xED", | |
| 376 "\xED\xED", | |
| 377 L"%ED%ED"}, // Invalid UTF-8 -> kept unescaped. | |
| 378 }; | |
| 379 | |
| 380 for (size_t i = 0; i < arraysize(unescape_cases); i++) { | |
| 381 std::string unescaped = UnescapeURLComponent(unescape_cases[i].input, | |
| 382 UnescapeRule::NORMAL); | |
| 383 EXPECT_EQ(std::string(unescape_cases[i].url_unescaped), unescaped); | |
| 384 | |
| 385 unescaped = UnescapeURLComponent(unescape_cases[i].input, | |
| 386 UnescapeRule::REPLACE_PLUS_WITH_SPACE); | |
| 387 EXPECT_EQ(std::string(unescape_cases[i].query_unescaped), unescaped); | |
| 388 | |
| 389 // TODO: Need to test unescape_spaces and unescape_percent. | |
| 390 base::string16 decoded = UnescapeAndDecodeUTF8URLComponent( | |
| 391 unescape_cases[i].input, UnescapeRule::NORMAL); | |
| 392 EXPECT_EQ(base::WideToUTF16(unescape_cases[i].decoded), decoded); | |
| 393 } | |
| 394 } | |
| 395 | |
| 396 TEST(EscapeTest, AdjustOffset) { | |
| 397 const AdjustOffsetCase adjust_cases[] = { | |
| 398 {"", 0, 0}, | |
| 399 {"test", 0, 0}, | |
| 400 {"test", 2, 2}, | |
| 401 {"test", 4, 4}, | |
| 402 {"test", std::string::npos, std::string::npos}, | |
| 403 {"%2dtest", 6, 4}, | |
| 404 {"%2dtest", 3, 1}, | |
| 405 {"%2dtest", 2, std::string::npos}, | |
| 406 {"%2dtest", 1, std::string::npos}, | |
| 407 {"%2dtest", 0, 0}, | |
| 408 {"test%2d", 2, 2}, | |
| 409 {"%E4%BD%A0+%E5%A5%BD", 9, 1}, | |
| 410 {"%E4%BD%A0+%E5%A5%BD", 6, std::string::npos}, | |
| 411 {"%E4%BD%A0+%E5%A5%BD", 0, 0}, | |
| 412 {"%E4%BD%A0+%E5%A5%BD", 10, 2}, | |
| 413 {"%E4%BD%A0+%E5%A5%BD", 19, 3}, | |
| 414 | |
| 415 {"hi%41test%E4%BD%A0+%E5%A5%BD", 18, 8}, | |
| 416 {"hi%41test%E4%BD%A0+%E5%A5%BD", 15, std::string::npos}, | |
| 417 {"hi%41test%E4%BD%A0+%E5%A5%BD", 9, 7}, | |
| 418 {"hi%41test%E4%BD%A0+%E5%A5%BD", 19, 9}, | |
| 419 {"hi%41test%E4%BD%A0+%E5%A5%BD", 28, 10}, | |
| 420 {"hi%41test%E4%BD%A0+%E5%A5%BD", 0, 0}, | |
| 421 {"hi%41test%E4%BD%A0+%E5%A5%BD", 2, 2}, | |
| 422 {"hi%41test%E4%BD%A0+%E5%A5%BD", 3, std::string::npos}, | |
| 423 {"hi%41test%E4%BD%A0+%E5%A5%BD", 5, 3}, | |
| 424 | |
| 425 {"%E4%BD%A0+%E5%A5%BDhi%41test", 9, 1}, | |
| 426 {"%E4%BD%A0+%E5%A5%BDhi%41test", 6, std::string::npos}, | |
| 427 {"%E4%BD%A0+%E5%A5%BDhi%41test", 0, 0}, | |
| 428 {"%E4%BD%A0+%E5%A5%BDhi%41test", 10, 2}, | |
| 429 {"%E4%BD%A0+%E5%A5%BDhi%41test", 19, 3}, | |
| 430 {"%E4%BD%A0+%E5%A5%BDhi%41test", 21, 5}, | |
| 431 {"%E4%BD%A0+%E5%A5%BDhi%41test", 22, std::string::npos}, | |
| 432 {"%E4%BD%A0+%E5%A5%BDhi%41test", 24, 6}, | |
| 433 {"%E4%BD%A0+%E5%A5%BDhi%41test", 28, 10}, | |
| 434 | |
| 435 {"%ED%B0%80+%E5%A5%BD", 6, 6}, // not convertable to UTF-8 | |
| 436 }; | |
| 437 | |
| 438 for (size_t i = 0; i < arraysize(adjust_cases); i++) { | |
| 439 size_t offset = adjust_cases[i].input_offset; | |
| 440 base::OffsetAdjuster::Adjustments adjustments; | |
| 441 UnescapeAndDecodeUTF8URLComponentWithAdjustments( | |
| 442 adjust_cases[i].input, UnescapeRule::NORMAL, &adjustments); | |
| 443 base::OffsetAdjuster::AdjustOffset(adjustments, &offset); | |
| 444 EXPECT_EQ(adjust_cases[i].output_offset, offset) | |
| 445 << "input=" << adjust_cases[i].input | |
| 446 << " offset=" << adjust_cases[i].input_offset; | |
| 447 } | |
| 448 } | |
| 449 | |
| 450 TEST(EscapeTest, EscapeForHTML) { | |
| 451 const EscapeForHTMLCase tests[] = { | |
| 452 { "hello", "hello" }, | |
| 453 { "<hello>", "<hello>" }, | |
| 454 { "don\'t mess with me", "don't mess with me" }, | |
| 455 }; | |
| 456 for (size_t i = 0; i < arraysize(tests); ++i) { | |
| 457 std::string result = EscapeForHTML(std::string(tests[i].input)); | |
| 458 EXPECT_EQ(std::string(tests[i].expected_output), result); | |
| 459 } | |
| 460 } | |
| 461 | |
| 462 TEST(EscapeTest, UnescapeForHTML) { | |
| 463 const EscapeForHTMLCase tests[] = { | |
| 464 { "", "" }, | |
| 465 { "<hello>", "<hello>" }, | |
| 466 { "don't mess with me", "don\'t mess with me" }, | |
| 467 { "<>&"'", "<>&\"'" }, | |
| 468 { "& lt; & ; &; '", "& lt; & ; &; '" }, | |
| 469 { "&", "&" }, | |
| 470 { """, "\"" }, | |
| 471 { "'", "'" }, | |
| 472 { "<", "<" }, | |
| 473 { ">", ">" }, | |
| 474 { "& &", "& &" }, | |
| 475 }; | |
| 476 for (size_t i = 0; i < arraysize(tests); ++i) { | |
| 477 base::string16 result = UnescapeForHTML(base::ASCIIToUTF16(tests[i].input)); | |
| 478 EXPECT_EQ(base::ASCIIToUTF16(tests[i].expected_output), result); | |
| 479 } | |
| 480 } | |
| 481 | |
| 482 TEST(EscapeTest, EscapeExternalHandlerValue) { | |
| 483 ASSERT_EQ( | |
| 484 // Escaped | |
| 485 "%02%0A%1D%20!%22#$%25&'()*+,-./0123456789:;" | |
| 486 "%3C=%3E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 487 "[%5C]%5E_%60abcdefghijklmnopqrstuvwxyz" | |
| 488 "%7B%7C%7D~%7F%80%FF", | |
| 489 // Most of the character space we care about, un-escaped | |
| 490 EscapeExternalHandlerValue( | |
| 491 "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;" | |
| 492 "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ" | |
| 493 "[\\]^_`abcdefghijklmnopqrstuvwxyz" | |
| 494 "{|}~\x7f\x80\xff")); | |
| 495 | |
| 496 ASSERT_EQ( | |
| 497 "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_" | |
| 498 "abcdefghijklmnopqrstuvwxyz~", | |
| 499 EscapeExternalHandlerValue( | |
| 500 "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_" | |
| 501 "abcdefghijklmnopqrstuvwxyz~")); | |
| 502 | |
| 503 ASSERT_EQ("%258k", EscapeExternalHandlerValue("%8k")); | |
| 504 ASSERT_EQ("a%25", EscapeExternalHandlerValue("a%")); | |
| 505 ASSERT_EQ("%25a", EscapeExternalHandlerValue("%a")); | |
| 506 ASSERT_EQ("a%258", EscapeExternalHandlerValue("a%8")); | |
| 507 ASSERT_EQ("%ab", EscapeExternalHandlerValue("%ab")); | |
| 508 ASSERT_EQ("%AB", EscapeExternalHandlerValue("%AB")); | |
| 509 | |
| 510 ASSERT_EQ("http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C", | |
| 511 EscapeExternalHandlerValue( | |
| 512 "http://example.com/path/sub?q=a|b|c&q=1|2|3#ref|")); | |
| 513 ASSERT_EQ("http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C", | |
| 514 EscapeExternalHandlerValue( | |
| 515 "http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C")); | |
| 516 ASSERT_EQ("http://[2001:db8:0:1]:80", | |
| 517 EscapeExternalHandlerValue("http://[2001:db8:0:1]:80")); | |
| 518 } | |
| 519 | |
| 520 } // namespace | |
| 521 } // namespace net | |
| 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