PlzNavigate: Improvements to RFHM commit logic.
[chromium-blink-merge.git] / net / base / escape_unittest.cc
blob4d3bcbdd40c029025f0881c9b102e5bd4e80b344
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.
5 #include <algorithm>
6 #include <string>
8 #include "net/base/escape.h"
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"
16 namespace net {
17 namespace {
19 struct EscapeCase {
20 const char* input;
21 const char* output;
24 struct UnescapeURLCase {
25 const wchar_t* input;
26 UnescapeRule::Type rules;
27 const wchar_t* output;
30 struct UnescapeURLCaseASCII {
31 const char* input;
32 UnescapeRule::Type rules;
33 const char* output;
36 struct UnescapeAndDecodeCase {
37 const char* input;
39 // The expected output when run through UnescapeURL.
40 const char* url_unescaped;
42 // The expected output when run through UnescapeQuery.
43 const char* query_unescaped;
45 // The expected output when run through UnescapeAndDecodeURLComponent.
46 const wchar_t* decoded;
49 struct AdjustOffsetCase {
50 const char* input;
51 size_t input_offset;
52 size_t output_offset;
55 struct EscapeForHTMLCase {
56 const char* input;
57 const char* expected_output;
60 TEST(EscapeTest, EscapeTextForFormSubmission) {
61 const EscapeCase escape_cases[] = {
62 {"foo", "foo"},
63 {"foo bar", "foo+bar"},
64 {"foo++", "foo%2B%2B"}
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));
71 const EscapeCase escape_cases_no_plus[] = {
72 {"foo", "foo"},
73 {"foo bar", "foo%20bar"},
74 {"foo++", "foo%2B%2B"}
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));
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);
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");
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";
127 base::OffsetAdjuster::Adjustments adjustments;
128 net::UnescapeAndDecodeUTF8URLComponentWithAdjustments(
129 url, UnescapeRule::SPACES, &adjustments);
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");
147 TEST(EscapeTest, EscapeUrlEncodedDataSpace) {
148 ASSERT_EQ(EscapeUrlEncodedData("a b", true), "a+b");
149 ASSERT_EQ(EscapeUrlEncodedData("a b", false), "a%20b");
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"},
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));
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");
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));
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));
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"},
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"},
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"},
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));
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"));
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));
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));
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.
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);
385 unescaped = UnescapeURLComponent(unescape_cases[i].input,
386 UnescapeRule::REPLACE_PLUS_WITH_SPACE);
387 EXPECT_EQ(std::string(unescape_cases[i].query_unescaped), unescaped);
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);
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},
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},
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},
435 {"%ED%B0%80+%E5%A5%BD", 6, 6}, // not convertable to UTF-8
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;
450 TEST(EscapeTest, EscapeForHTML) {
451 const EscapeForHTMLCase tests[] = {
452 { "hello", "hello" },
453 { "<hello>", "&lt;hello&gt;" },
454 { "don\'t mess with me", "don&#39;t mess with me" },
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);
462 TEST(EscapeTest, UnescapeForHTML) {
463 const EscapeForHTMLCase tests[] = {
464 { "", "" },
465 { "&lt;hello&gt;", "<hello>" },
466 { "don&#39;t mess with me", "don\'t mess with me" },
467 { "&lt;&gt;&amp;&quot;&#39;", "<>&\"'" },
468 { "& lt; &amp ; &; '", "& lt; &amp ; &; '" },
469 { "&amp;", "&" },
470 { "&quot;", "\"" },
471 { "&#39;", "'" },
472 { "&lt;", "<" },
473 { "&gt;", ">" },
474 { "&amp; &", "& &" },
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);
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"));
496 ASSERT_EQ(
497 "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_"
498 "abcdefghijklmnopqrstuvwxyz~",
499 EscapeExternalHandlerValue(
500 "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_"
501 "abcdefghijklmnopqrstuvwxyz~"));
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"));
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"));
520 } // namespace
521 } // namespace net