?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
isolate_driver: Enable ninja parsing code all the time.
[chromium-blink-merge.git] / net / base / net_util_unittest.cc
blobebc330754fd929a395d4ae2b6bc22ed40a02d2b3
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 "net/base/net_util.h"
6
7 #include <string.h>
8
9 #include <algorithm>
10
11 #include "base/files/file_path.h"
12 #include "base/format_macros.h"
13 #include "base/scoped_native_library.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/string_util.h"
16 #include "base/strings/stringprintf.h"
17 #include "base/strings/sys_string_conversions.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/sys_byteorder.h"
20 #include "base/time/time.h"
21 #include "testing/gtest/include/gtest/gtest.h"
22 #include "url/gurl.h"
23
24 #if defined(OS_WIN)
25 #include <iphlpapi.h>
26 #include <objbase.h>
27 #include "base/win/windows_version.h"
28 #elif !defined(OS_ANDROID)
29 #include <net/if.h>
30 #endif // OS_WIN
31
32 using base::ASCIIToUTF16;
33 using base::WideToUTF16;
34
35 namespace net {
36
37 namespace {
38
39 static const size_t kNpos = base::string16::npos;
40
41 struct HeaderCase {
42 const char* header_name;
43 const char* expected;
44 };
45
46 struct HeaderParamCase {
47 const char* header_name;
48 const char* param_name;
49 const char* expected;
50 };
51
52 const char* kLanguages[] = {
53 "", "en", "zh-CN", "ja", "ko",
54 "he", "ar", "ru", "el", "fr",
55 "de", "pt", "sv", "th", "hi",
56 "de,en", "el,en", "zh-TW,en", "ko,ja", "he,ru,en",
57 "zh,ru,en"
58 };
59
60 struct IDNTestCase {
61 const char* input;
62 const wchar_t* unicode_output;
63 const bool unicode_allowed[arraysize(kLanguages)];
64 };
65
66 // TODO(jungshik) This is just a random sample of languages and is far
67 // from exhaustive. We may have to generate all the combinations
68 // of languages (powerset of a set of all the languages).
69 const IDNTestCase idn_cases[] = {
70 // No IDN
71 {"www.google.com", L"www.google.com",
72 {true, true, true, true, true,
73 true, true, true, true, true,
74 true, true, true, true, true,
75 true, true, true, true, true,
76 true}},
77 {"www.google.com.", L"www.google.com.",
78 {true, true, true, true, true,
79 true, true, true, true, true,
80 true, true, true, true, true,
81 true, true, true, true, true,
82 true}},
83 {".", L".",
84 {true, true, true, true, true,
85 true, true, true, true, true,
86 true, true, true, true, true,
87 true, true, true, true, true,
88 true}},
89 {"", L"",
90 {true, true, true, true, true,
91 true, true, true, true, true,
92 true, true, true, true, true,
93 true, true, true, true, true,
94 true}},
95 // IDN
96 // Hanzi (Traditional Chinese)
97 {"xn--1lq90ic7f1rc.cn", L"\x5317\x4eac\x5927\x5b78.cn",
98 {true, false, true, true, false,
99 false, false, false, false, false,
100 false, false, false, false, false,
101 false, false, true, true, false,
102 true}},
103 // Hanzi ('video' in Simplified Chinese : will pass only in zh-CN,zh)
104 {"xn--cy2a840a.com", L"\x89c6\x9891.com",
105 {true, false, true, false, false,
106 false, false, false, false, false,
107 false, false, false, false, false,
108 false, false, false, false, false,
109 true}},
110 // Hanzi + '123'
111 {"www.xn--123-p18d.com", L"www.\x4e00" L"123.com",
112 {true, false, true, true, false,
113 false, false, false, false, false,
114 false, false, false, false, false,
115 false, false, true, true, false,
116 true}},
117 // Hanzi + Latin : U+56FD is simplified and is regarded
118 // as not supported in zh-TW.
119 {"www.xn--hello-9n1hm04c.com", L"www.hello\x4e2d\x56fd.com",
120 {false, false, true, true, false,
121 false, false, false, false, false,
122 false, false, false, false, false,
123 false, false, false, true, false,
124 true}},
125 // Kanji + Kana (Japanese)
126 {"xn--l8jvb1ey91xtjb.jp", L"\x671d\x65e5\x3042\x3055\x3072.jp",
127 {true, false, false, true, false,
128 false, false, false, false, false,
129 false, false, false, false, false,
130 false, false, false, true, false,
131 false}},
132 // Katakana including U+30FC
133 {"xn--tckm4i2e.jp", L"\x30b3\x30de\x30fc\x30b9.jp",
134 {true, false, false, true, false,
135 false, false, false, false, false,
136 false, false, false, false, false,
137 false, false, false, true, false,
138 }},
139 {"xn--3ck7a7g.jp", L"\u30ce\u30f3\u30bd.jp",
140 {true, false, false, true, false,
141 false, false, false, false, false,
142 false, false, false, false, false,
143 false, false, false, true, false,
144 }},
145 // Katakana + Latin (Japanese)
146 // TODO(jungshik): Change 'false' in the first element to 'true'
147 // after upgrading to ICU 4.2.1 to use new uspoof_* APIs instead
148 // of our IsIDNComponentInSingleScript().
149 {"xn--e-efusa1mzf.jp", L"e\x30b3\x30de\x30fc\x30b9.jp",
150 {false, false, false, true, false,
151 false, false, false, false, false,
152 false, false, false, false, false,
153 false, false, false, true, false,
154 }},
155 {"xn--3bkxe.jp", L"\x30c8\x309a.jp",
156 {false, false, false, true, false,
157 false, false, false, false, false,
158 false, false, false, false, false,
159 false, false, false, true, false,
160 }},
161 // Hangul (Korean)
162 {"www.xn--or3b17p6jjc.kr", L"www.\xc804\xc790\xc815\xbd80.kr",
163 {true, false, false, false, true,
164 false, false, false, false, false,
165 false, false, false, false, false,
166 false, false, false, true, false,
167 false}},
168 // b<u-umlaut>cher (German)
169 {"xn--bcher-kva.de", L"b\x00fc" L"cher.de",
170 {true, false, false, false, false,
171 false, false, false, false, true,
172 true, false, false, false, false,
173 true, false, false, false, false,
174 false}},
175 // a with diaeresis
176 {"www.xn--frgbolaget-q5a.se", L"www.f\x00e4rgbolaget.se",
177 {true, false, false, false, false,
178 false, false, false, false, false,
179 true, false, true, false, false,
180 true, false, false, false, false,
181 false}},
182 // c-cedilla (French)
183 {"www.xn--alliancefranaise-npb.fr", L"www.alliancefran\x00e7" L"aise.fr",
184 {true, false, false, false, false,
185 false, false, false, false, true,
186 false, true, false, false, false,
187 false, false, false, false, false,
188 false}},
189 // caf'e with acute accent' (French)
190 {"xn--caf-dma.fr", L"caf\x00e9.fr",
191 {true, false, false, false, false,
192 false, false, false, false, true,
193 false, true, true, false, false,
194 false, false, false, false, false,
195 false}},
196 // c-cedillla and a with tilde (Portuguese)
197 {"xn--poema-9qae5a.com.br", L"p\x00e3oema\x00e7\x00e3.com.br",
198 {true, false, false, false, false,
199 false, false, false, false, false,
200 false, true, false, false, false,
201 false, false, false, false, false,
202 false}},
203 // s with caron
204 {"xn--achy-f6a.com", L"\x0161" L"achy.com",
205 {true, false, false, false, false,
206 false, false, false, false, false,
207 false, false, false, false, false,
208 false, false, false, false, false,
209 false}},
210 // TODO(jungshik) : Add examples with Cyrillic letters
211 // only used in some languages written in Cyrillic.
212 // Eutopia (Greek)
213 {"xn--kxae4bafwg.gr", L"\x03bf\x03c5\x03c4\x03bf\x03c0\x03af\x03b1.gr",
214 {true, false, false, false, false,
215 false, false, false, true, false,
216 false, false, false, false, false,
217 false, true, false, false, false,
218 false}},
219 // Eutopia + 123 (Greek)
220 {"xn---123-pldm0haj2bk.gr",
221 L"\x03bf\x03c5\x03c4\x03bf\x03c0\x03af\x03b1-123.gr",
222 {true, false, false, false, false,
223 false, false, false, true, false,
224 false, false, false, false, false,
225 false, true, false, false, false,
226 false}},
227 // Cyrillic (Russian)
228 {"xn--n1aeec9b.ru", L"\x0442\x043e\x0440\x0442\x044b.ru",
229 {true, false, false, false, false,
230 false, false, true, false, false,
231 false, false, false, false, false,
232 false, false, false, false, true,
233 true}},
234 // Cyrillic + 123 (Russian)
235 {"xn---123-45dmmc5f.ru", L"\x0442\x043e\x0440\x0442\x044b-123.ru",
236 {true, false, false, false, false,
237 false, false, true, false, false,
238 false, false, false, false, false,
239 false, false, false, false, true,
240 true}},
241 // Arabic
242 {"xn--mgba1fmg.ar", L"\x0627\x0641\x0644\x0627\x0645.ar",
243 {true, false, false, false, false,
244 false, true, false, false, false,
245 false, false, false, false, false,
246 false, false, false, false, false,
247 false}},
248 // Hebrew
249 {"xn--4dbib.he", L"\x05d5\x05d0\x05d4.he",
250 {true, false, false, false, false,
251 true, false, false, false, false,
252 false, false, false, false, false,
253 false, false, false, false, true,
254 false}},
255 // Thai
256 {"xn--12c2cc4ag3b4ccu.th",
257 L"\x0e2a\x0e32\x0e22\x0e01\x0e32\x0e23\x0e1a\x0e34\x0e19.th",
258 {true, false, false, false, false,
259 false, false, false, false, false,
260 false, false, false, true, false,
261 false, false, false, false, false,
262 false}},
263 // Devangari (Hindi)
264 {"www.xn--l1b6a9e1b7c.in", L"www.\x0905\x0915\x094b\x0932\x093e.in",
265 {true, false, false, false, false,
266 false, false, false, false, false,
267 false, false, false, false, true,
268 false, false, false, false, false,
269 false}},
270 // Invalid IDN
271 {"xn--hello?world.com", NULL,
272 {false, false, false, false, false,
273 false, false, false, false, false,
274 false, false, false, false, false,
275 false, false, false, false, false,
276 false}},
277 // Unsafe IDNs
278 // "payp<alpha>l.com"
279 {"www.xn--paypl-g9d.com", L"payp\x03b1l.com",
280 {false, false, false, false, false,
281 false, false, false, false, false,
282 false, false, false, false, false,
283 false, false, false, false, false,
284 false}},
285 // google.gr with Greek omicron and epsilon
286 {"xn--ggl-6xc1ca.gr", L"g\x03bf\x03bfgl\x03b5.gr",
287 {false, false, false, false, false,
288 false, false, false, false, false,
289 false, false, false, false, false,
290 false, false, false, false, false,
291 false}},
292 // google.ru with Cyrillic o
293 {"xn--ggl-tdd6ba.ru", L"g\x043e\x043egl\x0435.ru",
294 {false, false, false, false, false,
295 false, false, false, false, false,
296 false, false, false, false, false,
297 false, false, false, false, false,
298 false}},
299 // h<e with acute>llo<China in Han>.cn
300 {"xn--hllo-bpa7979ih5m.cn", L"h\x00e9llo\x4e2d\x56fd.cn",
301 {false, false, false, false, false,
302 false, false, false, false, false,
303 false, false, false, false, false,
304 false, false, false, false, false,
305 false}},
306 // <Greek rho><Cyrillic a><Cyrillic u>.ru
307 {"xn--2xa6t2b.ru", L"\x03c1\x0430\x0443.ru",
308 {false, false, false, false, false,
309 false, false, false, false, false,
310 false, false, false, false, false,
311 false, false, false, false, false,
312 false}},
313 // One that's really long that will force a buffer realloc
314 {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
315 "aaaaaaa",
316 L"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
317 L"aaaaaaaa",
318 {true, true, true, true, true,
319 true, true, true, true, true,
320 true, true, true, true, true,
321 true, true, true, true, true,
322 true}},
323 // Test cases for characters we blacklisted although allowed in IDN.
324 // Embedded spaces will be turned to %20 in the display.
325 // TODO(jungshik): We need to have more cases. This is a typical
326 // data-driven trap. The following test cases need to be separated
327 // and tested only for a couple of languages.
328 {"xn--osd3820f24c.kr", L"\xac00\xb098\x115f.kr",
329 {false, false, false, false, false,
330 false, false, false, false, false,
331 false, false, false, false, false,
332 false, false, false, false, false,
333 false}},
334 {"www.xn--google-ho0coa.com", L"www.\x2039google\x203a.com",
335 {false, false, false, false, false,
336 false, false, false, false, false,
337 false, false, false, false, false,
338 false, false, false, false, false,
339 }},
340 {"google.xn--comabc-k8d", L"google.com\x0338" L"abc",
341 {false, false, false, false, false,
342 false, false, false, false, false,
343 false, false, false, false, false,
344 false, false, false, false, false,
345 }},
346 {"google.xn--com-oh4ba.evil.jp", L"google.com\x309a\x309a.evil.jp",
347 {false, false, false, false, false,
348 false, false, false, false, false,
349 false, false, false, false, false,
350 false, false, false, false, false,
351 }},
352 {"google.xn--comevil-v04f.jp", L"google.com\x30ce" L"evil.jp",
353 {false, false, false, false, false,
354 false, false, false, false, false,
355 false, false, false, false, false,
356 false, false, false, false, false,
357 }},
358 #if 0
359 // These two cases are special. We need a separate test.
360 // U+3000 and U+3002 are normalized to ASCII space and dot.
361 {"xn-- -kq6ay5z.cn", L"\x4e2d\x56fd\x3000.cn",
362 {false, false, true, false, false,
363 false, false, false, false, false,
364 false, false, false, false, false,
365 false, false, true, false, false,
366 true}},
367 {"xn--fiqs8s.cn", L"\x4e2d\x56fd\x3002" L"cn",
368 {false, false, true, false, false,
369 false, false, false, false, false,
370 false, false, false, false, false,
371 false, false, true, false, false,
372 true}},
373 #endif
374 };
375
376 struct AdjustOffsetCase {
377 size_t input_offset;
378 size_t output_offset;
379 };
380
381 struct CompliantHostCase {
382 const char* host;
383 const char* desired_tld;
384 bool expected_output;
385 };
386
387 struct UrlTestData {
388 const char* description;
389 const char* input;
390 const char* languages;
391 FormatUrlTypes format_types;
392 UnescapeRule::Type escape_rules;
393 const wchar_t* output; // Use |wchar_t| to handle Unicode constants easily.
394 size_t prefix_len;
395 };
396
397 // Fills in sockaddr for the given 32-bit address (IPv4.)
398 // |bytes| should be an array of length 4.
399 void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
400 memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
401 storage->addr_len = sizeof(struct sockaddr_in);
402 struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
403 addr4->sin_port = base::HostToNet16(port);
404 addr4->sin_family = AF_INET;
405 memcpy(&addr4->sin_addr, bytes, 4);
406 }
407
408 // Fills in sockaddr for the given 128-bit address (IPv6.)
409 // |bytes| should be an array of length 16.
410 void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
411 memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
412 storage->addr_len = sizeof(struct sockaddr_in6);
413 struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
414 addr6->sin6_port = base::HostToNet16(port);
415 addr6->sin6_family = AF_INET6;
416 memcpy(&addr6->sin6_addr, bytes, 16);
417 }
418
419 // A helper for IDN*{Fast,Slow}.
420 // Append "::<language list>" to |expected| and |actual| to make it
421 // easy to tell which sub-case fails without debugging.
422 void AppendLanguagesToOutputs(const char* languages,
423 base::string16* expected,
424 base::string16* actual) {
425 base::string16 to_append = ASCIIToUTF16("::") + ASCIIToUTF16(languages);
426 expected->append(to_append);
427 actual->append(to_append);
428 }
429
430 // A pair of helpers for the FormatUrlWithOffsets() test.
431 void VerboseExpect(size_t expected,
432 size_t actual,
433 const std::string& original_url,
434 size_t position,
435 const base::string16& formatted_url) {
436 EXPECT_EQ(expected, actual) << "Original URL: " << original_url
437 << " (at char " << position << ")\nFormatted URL: " << formatted_url;
438 }
439
440 void CheckAdjustedOffsets(const std::string& url_string,
441 const std::string& languages,
442 FormatUrlTypes format_types,
443 UnescapeRule::Type unescape_rules,
444 const size_t* output_offsets) {
445 GURL url(url_string);
446 size_t url_length = url_string.length();
447 std::vector<size_t> offsets;
448 for (size_t i = 0; i <= url_length + 1; ++i)
449 offsets.push_back(i);
450 offsets.push_back(500000); // Something larger than any input length.
451 offsets.push_back(std::string::npos);
452 base::string16 formatted_url = FormatUrlWithOffsets(url, languages,
453 format_types, unescape_rules, NULL, NULL, &offsets);
454 for (size_t i = 0; i < url_length; ++i)
455 VerboseExpect(output_offsets[i], offsets[i], url_string, i, formatted_url);
456 VerboseExpect(formatted_url.length(), offsets[url_length], url_string,
457 url_length, formatted_url);
458 VerboseExpect(base::string16::npos, offsets[url_length + 1], url_string,
459 500000, formatted_url);
460 VerboseExpect(base::string16::npos, offsets[url_length + 2], url_string,
461 std::string::npos, formatted_url);
462 }
463
464 // Helper to strignize an IP number (used to define expectations).
465 std::string DumpIPNumber(const IPAddressNumber& v) {
466 std::string out;
467 for (size_t i = 0; i < v.size(); ++i) {
468 if (i != 0)
469 out.append(",");
470 out.append(base::IntToString(static_cast<int>(v[i])));
471 }
472 return out;
473 }
474
475 } // anonymous namespace
476
477 TEST(NetUtilTest, GetIdentityFromURL) {
478 struct {
479 const char* input_url;
480 const char* expected_username;
481 const char* expected_password;
482 } tests[] = {
483 {
484 "http://username:password@google.com",
485 "username",
486 "password",
487 },
488 { // Test for http://crbug.com/19200
489 "http://username:p@ssword@google.com",
490 "username",
491 "p@ssword",
492 },
493 { // Special URL characters should be unescaped.
494 "http://username:p%3fa%26s%2fs%23@google.com",
495 "username",
496 "p?a&s/s#",
497 },
498 { // Username contains %20.
499 "http://use rname:password@google.com",
500 "use rname",
501 "password",
502 },
503 { // Keep %00 as is.
504 "http://use%00rname:password@google.com",
505 "use%00rname",
506 "password",
507 },
508 { // Use a '+' in the username.
509 "http://use+rname:password@google.com",
510 "use+rname",
511 "password",
512 },
513 { // Use a '&' in the password.
514 "http://username:p&ssword@google.com",
515 "username",
516 "p&ssword",
517 },
518 };
519 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
520 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
521 tests[i].input_url));
522 GURL url(tests[i].input_url);
523
524 base::string16 username, password;
525 GetIdentityFromURL(url, &username, &password);
526
527 EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
528 EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
529 }
530 }
531
532 // Try extracting a username which was encoded with UTF8.
533 TEST(NetUtilTest, GetIdentityFromURL_UTF8) {
534 GURL url(WideToUTF16(L"http://foo:\x4f60\x597d@blah.com"));
535
536 EXPECT_EQ("foo", url.username());
537 EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password());
538
539 // Extract the unescaped identity.
540 base::string16 username, password;
541 GetIdentityFromURL(url, &username, &password);
542
543 // Verify that it was decoded as UTF8.
544 EXPECT_EQ(ASCIIToUTF16("foo"), username);
545 EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password);
546 }
547
548 // Just a bunch of fake headers.
549 const char* google_headers =
550 "HTTP/1.1 200 OK\n"
551 "Content-TYPE: text/html; charset=utf-8\n"
552 "Content-disposition: attachment; filename=\"download.pdf\"\n"
553 "Content-Length: 378557\n"
554 "X-Google-Google1: 314159265\n"
555 "X-Google-Google2: aaaa2:7783,bbb21:9441\n"
556 "X-Google-Google4: home\n"
557 "Transfer-Encoding: chunked\n"
558 "Set-Cookie: HEHE_AT=6666x66beef666x6-66xx6666x66; Path=/mail\n"
559 "Set-Cookie: HEHE_HELP=owned:0;Path=/\n"
560 "Set-Cookie: S=gmail=Xxx-beefbeefbeef_beefb:gmail_yj=beefbeef000beefbee"
561 "fbee:gmproxy=bee-fbeefbe; Domain=.google.com; Path=/\n"
562 "X-Google-Google2: /one/two/three/four/five/six/seven-height/nine:9411\n"
563 "Server: GFE/1.3\n"
564 "Transfer-Encoding: chunked\n"
565 "Date: Mon, 13 Nov 2006 21:38:09 GMT\n"
566 "Expires: Tue, 14 Nov 2006 19:23:58 GMT\n"
567 "X-Malformed: bla; arg=test\"\n"
568 "X-Malformed2: bla; arg=\n"
569 "X-Test: bla; arg1=val1; arg2=val2";
570
571 TEST(NetUtilTest, GetSpecificHeader) {
572 const HeaderCase tests[] = {
573 {"content-type", "text/html; charset=utf-8"},
574 {"CONTENT-LENGTH", "378557"},
575 {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
576 {"Bad-Header", ""},
577 {"", ""},
578 };
579
580 // Test first with google_headers.
581 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
582 std::string result =
583 GetSpecificHeader(google_headers, tests[i].header_name);
584 EXPECT_EQ(result, tests[i].expected);
585 }
586
587 // Test again with empty headers.
588 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
589 std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
590 EXPECT_EQ(result, std::string());
591 }
592 }
593
594 TEST(NetUtilTest, IDNToUnicodeFast) {
595 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(idn_cases); i++) {
596 for (size_t j = 0; j < arraysize(kLanguages); j++) {
597 // ja || zh-TW,en || ko,ja -> IDNToUnicodeSlow
598 if (j == 3 || j == 17 || j == 18)
599 continue;
600 base::string16 output(IDNToUnicode(idn_cases[i].input, kLanguages[j]));
601 base::string16 expected(idn_cases[i].unicode_allowed[j] ?
602 WideToUTF16(idn_cases[i].unicode_output) :
603 ASCIIToUTF16(idn_cases[i].input));
604 AppendLanguagesToOutputs(kLanguages[j], &expected, &output);
605 EXPECT_EQ(expected, output);
606 }
607 }
608 }
609
610 TEST(NetUtilTest, IDNToUnicodeSlow) {
611 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(idn_cases); i++) {
612 for (size_t j = 0; j < arraysize(kLanguages); j++) {
613 // !(ja || zh-TW,en || ko,ja) -> IDNToUnicodeFast
614 if (!(j == 3 || j == 17 || j == 18))
615 continue;
616 base::string16 output(IDNToUnicode(idn_cases[i].input, kLanguages[j]));
617 base::string16 expected(idn_cases[i].unicode_allowed[j] ?
618 WideToUTF16(idn_cases[i].unicode_output) :
619 ASCIIToUTF16(idn_cases[i].input));
620 AppendLanguagesToOutputs(kLanguages[j], &expected, &output);
621 EXPECT_EQ(expected, output);
622 }
623 }
624 }
625
626 TEST(NetUtilTest, CompliantHost) {
627 const CompliantHostCase compliant_host_cases[] = {
628 {"", "", false},
629 {"a", "", true},
630 {"-", "", false},
631 {".", "", false},
632 {"9", "", true},
633 {"9a", "", true},
634 {"a.", "", true},
635 {"a.a", "", true},
636 {"9.a", "", true},
637 {"a.9", "", true},
638 {"_9a", "", false},
639 {"-9a", "", false},
640 {"-9a", "a", true},
641 {"a.a9", "", true},
642 {"a.-a9", "", false},
643 {"a+9a", "", false},
644 {"-a.a9", "", true},
645 {"1-.a-b", "", true},
646 {"1_.a-b", "", false},
647 {"1-2.a_b", "", true},
648 {"a.b.c.d.e", "", true},
649 {"1.2.3.4.5", "", true},
650 {"1.2.3.4.5.", "", true},
651 };
652
653 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(compliant_host_cases); ++i) {
654 EXPECT_EQ(compliant_host_cases[i].expected_output,
655 IsCanonicalizedHostCompliant(compliant_host_cases[i].host,
656 compliant_host_cases[i].desired_tld));
657 }
658 }
659
660 TEST(NetUtilTest, StripWWW) {
661 EXPECT_EQ(base::string16(), StripWWW(base::string16()));
662 EXPECT_EQ(base::string16(), StripWWW(ASCIIToUTF16("www.")));
663 EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("www.blah")));
664 EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("blah")));
665 }
666
667 // This is currently a windows specific function.
668 #if defined(OS_WIN)
669 namespace {
670
671 struct GetDirectoryListingEntryCase {
672 const wchar_t* name;
673 const char* raw_bytes;
674 bool is_dir;
675 int64 filesize;
676 base::Time time;
677 const char* expected;
678 };
679
680 } // namespace
681 TEST(NetUtilTest, GetDirectoryListingEntry) {
682 const GetDirectoryListingEntryCase test_cases[] = {
683 {L"Foo",
684 "",
685 false,
686 10000,
687 base::Time(),
688 "<script>addRow(\"Foo\",\"Foo\",0,\"9.8 kB\",\"\");</script>\n"},
689 {L"quo\"tes",
690 "",
691 false,
692 10000,
693 base::Time(),
694 "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
695 "\n"},
696 {L"quo\"tes",
697 "quo\"tes",
698 false,
699 10000,
700 base::Time(),
701 "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
702 "\n"},
703 // U+D55C0 U+AE00. raw_bytes is empty (either a local file with
704 // UTF-8/UTF-16 encoding or a remote file on an ftp server using UTF-8
705 {L"\xD55C\xAE00.txt",
706 "",
707 false,
708 10000,
709 base::Time(),
710 "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\","
711 "\"%ED%95%9C%EA%B8%80.txt\",0,\"9.8 kB\",\"\");</script>\n"},
712 // U+D55C0 U+AE00. raw_bytes is the corresponding EUC-KR sequence:
713 // a local or remote file in EUC-KR.
714 {L"\xD55C\xAE00.txt",
715 "\xC7\xD1\xB1\xDB.txt",
716 false,
717 10000,
718 base::Time(),
719 "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\",\"%C7%D1%B1%DB.txt\""
720 ",0,\"9.8 kB\",\"\");</script>\n"},
721 };
722
723 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
724 const std::string results = GetDirectoryListingEntry(
725 WideToUTF16(test_cases[i].name),
726 test_cases[i].raw_bytes,
727 test_cases[i].is_dir,
728 test_cases[i].filesize,
729 test_cases[i].time);
730 EXPECT_EQ(test_cases[i].expected, results);
731 }
732 }
733
734 #endif
735
736 TEST(NetUtilTest, ParseHostAndPort) {
737 const struct {
738 const char* input;
739 bool success;
740 const char* expected_host;
741 int expected_port;
742 } tests[] = {
743 // Valid inputs:
744 {"foo:10", true, "foo", 10},
745 {"foo", true, "foo", -1},
746 {
747 "[1080:0:0:0:8:800:200C:4171]:11",
748 true,
749 "[1080:0:0:0:8:800:200C:4171]",
750 11,
751 },
752 // Invalid inputs:
753 {"foo:bar", false, "", -1},
754 {"foo:", false, "", -1},
755 {":", false, "", -1},
756 {":80", false, "", -1},
757 {"", false, "", -1},
758 {"porttoolong:300000", false, "", -1},
759 {"usrname@host", false, "", -1},
760 {"usrname:password@host", false, "", -1},
761 {":password@host", false, "", -1},
762 {":password@host:80", false, "", -1},
763 {":password@host", false, "", -1},
764 {"@host", false, "", -1},
765 };
766
767 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
768 std::string host;
769 int port;
770 bool ok = ParseHostAndPort(tests[i].input, &host, &port);
771
772 EXPECT_EQ(tests[i].success, ok);
773
774 if (tests[i].success) {
775 EXPECT_EQ(tests[i].expected_host, host);
776 EXPECT_EQ(tests[i].expected_port, port);
777 }
778 }
779 }
780
781 TEST(NetUtilTest, GetHostAndPort) {
782 const struct {
783 GURL url;
784 const char* expected_host_and_port;
785 } tests[] = {
786 { GURL("http://www.foo.com/x"), "www.foo.com:80"},
787 { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
788
789 // For IPv6 literals should always include the brackets.
790 { GURL("http://[1::2]/x"), "[1::2]:80"},
791 { GURL("http://[::a]:33/x"), "[::a]:33"},
792 };
793 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
794 std::string host_and_port = GetHostAndPort(tests[i].url);
795 EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
796 }
797 }
798
799 TEST(NetUtilTest, GetHostAndOptionalPort) {
800 const struct {
801 GURL url;
802 const char* expected_host_and_port;
803 } tests[] = {
804 { GURL("http://www.foo.com/x"), "www.foo.com"},
805 { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
806
807 // For IPv6 literals should always include the brackets.
808 { GURL("http://[1::2]/x"), "[1::2]"},
809 { GURL("http://[::a]:33/x"), "[::a]:33"},
810 };
811 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
812 std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
813 EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
814 }
815 }
816
817 TEST(NetUtilTest, IPAddressToString) {
818 uint8 addr1[4] = {0, 0, 0, 0};
819 EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
820
821 uint8 addr2[4] = {192, 168, 0, 1};
822 EXPECT_EQ("192.168.0.1", IPAddressToString(addr2, sizeof(addr2)));
823
824 uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
825 EXPECT_EQ("fedc:ba98::", IPAddressToString(addr3, sizeof(addr3)));
826 }
827
828 TEST(NetUtilTest, IPAddressToStringWithPort) {
829 uint8 addr1[4] = {0, 0, 0, 0};
830 EXPECT_EQ("0.0.0.0:3", IPAddressToStringWithPort(addr1, sizeof(addr1), 3));
831
832 uint8 addr2[4] = {192, 168, 0, 1};
833 EXPECT_EQ("192.168.0.1:99",
834 IPAddressToStringWithPort(addr2, sizeof(addr2), 99));
835
836 uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
837 EXPECT_EQ("[fedc:ba98::]:8080",
838 IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
839 }
840
841 TEST(NetUtilTest, NetAddressToString_IPv4) {
842 const struct {
843 uint8 addr[4];
844 const char* result;
845 } tests[] = {
846 {{0, 0, 0, 0}, "0.0.0.0"},
847 {{127, 0, 0, 1}, "127.0.0.1"},
848 {{192, 168, 0, 1}, "192.168.0.1"},
849 };
850
851 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
852 SockaddrStorage storage;
853 MakeIPv4Address(tests[i].addr, 80, &storage);
854 std::string result = NetAddressToString(storage.addr, storage.addr_len);
855 EXPECT_EQ(std::string(tests[i].result), result);
856 }
857 }
858
859 TEST(NetUtilTest, NetAddressToString_IPv6) {
860 const struct {
861 uint8 addr[16];
862 const char* result;
863 } tests[] = {
864 {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
865 0x98, 0x76, 0x54, 0x32, 0x10},
866 "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
867 };
868
869 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
870 SockaddrStorage storage;
871 MakeIPv6Address(tests[i].addr, 80, &storage);
872 EXPECT_EQ(std::string(tests[i].result),
873 NetAddressToString(storage.addr, storage.addr_len));
874 }
875 }
876
877 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
878 uint8 addr[] = {127, 0, 0, 1};
879 SockaddrStorage storage;
880 MakeIPv4Address(addr, 166, &storage);
881 std::string result = NetAddressToStringWithPort(storage.addr,
882 storage.addr_len);
883 EXPECT_EQ("127.0.0.1:166", result);
884 }
885
886 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
887 uint8 addr[] = {
888 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
889 0x98, 0x76, 0x54, 0x32, 0x10
890 };
891 SockaddrStorage storage;
892 MakeIPv6Address(addr, 361, &storage);
893 std::string result = NetAddressToStringWithPort(storage.addr,
894 storage.addr_len);
895
896 // May fail on systems that don't support IPv6.
897 if (!result.empty())
898 EXPECT_EQ("[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:361", result);
899 }
900
901 TEST(NetUtilTest, GetHostName) {
902 // We can't check the result of GetHostName() directly, since the result
903 // will differ across machines. Our goal here is to simply exercise the
904 // code path, and check that things "look about right".
905 std::string hostname = GetHostName();
906 EXPECT_FALSE(hostname.empty());
907 }
908
909 TEST(NetUtilTest, FormatUrl) {
910 FormatUrlTypes default_format_type = kFormatUrlOmitUsernamePassword;
911 const UrlTestData tests[] = {
912 {"Empty URL", "", "", default_format_type, UnescapeRule::NORMAL, L"", 0},
913
914 {"Simple URL",
915 "http://www.google.com/", "", default_format_type, UnescapeRule::NORMAL,
916 L"http://www.google.com/", 7},
917
918 {"With a port number and a reference",
919 "http://www.google.com:8080/#\xE3\x82\xB0", "", default_format_type,
920 UnescapeRule::NORMAL,
921 L"http://www.google.com:8080/#\x30B0", 7},
922
923 // -------- IDN tests --------
924 {"Japanese IDN with ja",
925 "http://xn--l8jvb1ey91xtjb.jp", "ja", default_format_type,
926 UnescapeRule::NORMAL, L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
927
928 {"Japanese IDN with en",
929 "http://xn--l8jvb1ey91xtjb.jp", "en", default_format_type,
930 UnescapeRule::NORMAL, L"http://xn--l8jvb1ey91xtjb.jp/", 7},
931
932 {"Japanese IDN without any languages",
933 "http://xn--l8jvb1ey91xtjb.jp", "", default_format_type,
934 UnescapeRule::NORMAL,
935 // Single script is safe for empty languages.
936 L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
937
938 {"mailto: with Japanese IDN",
939 "mailto:foo@xn--l8jvb1ey91xtjb.jp", "ja", default_format_type,
940 UnescapeRule::NORMAL,
941 // GURL doesn't assume an email address's domain part as a host name.
942 L"mailto:foo@xn--l8jvb1ey91xtjb.jp", 7},
943
944 {"file: with Japanese IDN",
945 "file://xn--l8jvb1ey91xtjb.jp/config.sys", "ja", default_format_type,
946 UnescapeRule::NORMAL,
947 L"file://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 7},
948
949 {"ftp: with Japanese IDN",
950 "ftp://xn--l8jvb1ey91xtjb.jp/config.sys", "ja", default_format_type,
951 UnescapeRule::NORMAL,
952 L"ftp://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 6},
953
954 // -------- omit_username_password flag tests --------
955 {"With username and password, omit_username_password=false",
956 "http://user:passwd@example.com/foo", "",
957 kFormatUrlOmitNothing, UnescapeRule::NORMAL,
958 L"http://user:passwd@example.com/foo", 19},
959
960 {"With username and password, omit_username_password=true",
961 "http://user:passwd@example.com/foo", "", default_format_type,
962 UnescapeRule::NORMAL, L"http://example.com/foo", 7},
963
964 {"With username and no password",
965 "http://user@example.com/foo", "", default_format_type,
966 UnescapeRule::NORMAL, L"http://example.com/foo", 7},
967
968 {"Just '@' without username and password",
969 "http://@example.com/foo", "", default_format_type, UnescapeRule::NORMAL,
970 L"http://example.com/foo", 7},
971
972 // GURL doesn't think local-part of an email address is username for URL.
973 {"mailto:, omit_username_password=true",
974 "mailto:foo@example.com", "", default_format_type, UnescapeRule::NORMAL,
975 L"mailto:foo@example.com", 7},
976
977 // -------- unescape flag tests --------
978 {"Do not unescape",
979 "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
980 "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
981 "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", "en", default_format_type,
982 UnescapeRule::NONE,
983 // GURL parses %-encoded hostnames into Punycode.
984 L"http://xn--qcka1pmc.jp/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
985 L"?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", 7},
986
987 {"Unescape normally",
988 "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
989 "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
990 "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", "en", default_format_type,
991 UnescapeRule::NORMAL,
992 L"http://xn--qcka1pmc.jp/\x30B0\x30FC\x30B0\x30EB"
993 L"?q=\x30B0\x30FC\x30B0\x30EB", 7},
994
995 {"Unescape normally with BiDi control character",
996 "http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", "en", default_format_type,
997 UnescapeRule::NORMAL, L"http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", 7},
998
999 {"Unescape normally including unescape spaces",
1000 "http://www.google.com/search?q=Hello%20World", "en", default_format_type,
1001 UnescapeRule::SPACES, L"http://www.google.com/search?q=Hello World", 7},
1002
1003 /*
1004 {"unescape=true with some special characters",
1005 "http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", "",
1006 kFormatUrlOmitNothing, UnescapeRule::NORMAL,
1007 L"http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", 25},
1008 */
1009 // Disabled: the resultant URL becomes "...user%253A:%2540passwd...".
1010
1011 // -------- omit http: --------
1012 {"omit http with user name",
1013 "http://user@example.com/foo", "", kFormatUrlOmitAll,
1014 UnescapeRule::NORMAL, L"example.com/foo", 0},
1015
1016 {"omit http",
1017 "http://www.google.com/", "en", kFormatUrlOmitHTTP,
1018 UnescapeRule::NORMAL, L"www.google.com/",
1019 0},
1020
1021 {"omit http with https",
1022 "https://www.google.com/", "en", kFormatUrlOmitHTTP,
1023 UnescapeRule::NORMAL, L"https://www.google.com/",
1024 8},
1025
1026 {"omit http starts with ftp.",
1027 "http://ftp.google.com/", "en", kFormatUrlOmitHTTP,
1028 UnescapeRule::NORMAL, L"http://ftp.google.com/",
1029 7},
1030
1031 // -------- omit trailing slash on bare hostname --------
1032 {"omit slash when it's the entire path",
1033 "http://www.google.com/", "en",
1034 kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
1035 L"http://www.google.com", 7},
1036 {"omit slash when there's a ref",
1037 "http://www.google.com/#ref", "en",
1038 kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
1039 L"http://www.google.com/#ref", 7},
1040 {"omit slash when there's a query",
1041 "http://www.google.com/?", "en",
1042 kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
1043 L"http://www.google.com/?", 7},
1044 {"omit slash when it's not the entire path",
1045 "http://www.google.com/foo", "en",
1046 kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
1047 L"http://www.google.com/foo", 7},
1048 {"omit slash for nonstandard URLs",
1049 "data:/", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
1050 UnescapeRule::NORMAL, L"data:/", 5},
1051 {"omit slash for file URLs",
1052 "file:///", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
1053 UnescapeRule::NORMAL, L"file:///", 7},
1054
1055 // -------- view-source: --------
1056 {"view-source",
1057 "view-source:http://xn--qcka1pmc.jp/", "ja", default_format_type,
1058 UnescapeRule::NORMAL, L"view-source:http://\x30B0\x30FC\x30B0\x30EB.jp/",
1059 19},
1060
1061 {"view-source of view-source",
1062 "view-source:view-source:http://xn--qcka1pmc.jp/", "ja",
1063 default_format_type, UnescapeRule::NORMAL,
1064 L"view-source:view-source:http://xn--qcka1pmc.jp/", 12},
1065
1066 // view-source should omit http and trailing slash where non-view-source
1067 // would.
1068 {"view-source omit http",
1069 "view-source:http://a.b/c", "en", kFormatUrlOmitAll,
1070 UnescapeRule::NORMAL, L"view-source:a.b/c",
1071 12},
1072 {"view-source omit http starts with ftp.",
1073 "view-source:http://ftp.b/c", "en", kFormatUrlOmitAll,
1074 UnescapeRule::NORMAL, L"view-source:http://ftp.b/c",
1075 19},
1076 {"view-source omit slash when it's the entire path",
1077 "view-source:http://a.b/", "en", kFormatUrlOmitAll,
1078 UnescapeRule::NORMAL, L"view-source:a.b",
1079 12},
1080 };
1081
1082 for (size_t i = 0; i < arraysize(tests); ++i) {
1083 size_t prefix_len;
1084 base::string16 formatted = FormatUrl(
1085 GURL(tests[i].input), tests[i].languages, tests[i].format_types,
1086 tests[i].escape_rules, NULL, &prefix_len, NULL);
1087 EXPECT_EQ(WideToUTF16(tests[i].output), formatted) << tests[i].description;
1088 EXPECT_EQ(tests[i].prefix_len, prefix_len) << tests[i].description;
1089 }
1090 }
1091
1092 TEST(NetUtilTest, FormatUrlParsed) {
1093 // No unescape case.
1094 url::Parsed parsed;
1095 base::string16 formatted = FormatUrl(
1096 GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
1097 "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
1098 "ja", kFormatUrlOmitNothing, UnescapeRule::NONE, &parsed, NULL,
1099 NULL);
1100 EXPECT_EQ(WideToUTF16(
1101 L"http://%E3%82%B0:%E3%83%BC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
1102 L"/%E3%82%B0/?q=%E3%82%B0#\x30B0"), formatted);
1103 EXPECT_EQ(WideToUTF16(L"%E3%82%B0"),
1104 formatted.substr(parsed.username.begin, parsed.username.len));
1105 EXPECT_EQ(WideToUTF16(L"%E3%83%BC"),
1106 formatted.substr(parsed.password.begin, parsed.password.len));
1107 EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
1108 formatted.substr(parsed.host.begin, parsed.host.len));
1109 EXPECT_EQ(WideToUTF16(L"8080"),
1110 formatted.substr(parsed.port.begin, parsed.port.len));
1111 EXPECT_EQ(WideToUTF16(L"/%E3%82%B0/"),
1112 formatted.substr(parsed.path.begin, parsed.path.len));
1113 EXPECT_EQ(WideToUTF16(L"q=%E3%82%B0"),
1114 formatted.substr(parsed.query.begin, parsed.query.len));
1115 EXPECT_EQ(WideToUTF16(L"\x30B0"),
1116 formatted.substr(parsed.ref.begin, parsed.ref.len));
1117
1118 // Unescape case.
1119 formatted = FormatUrl(
1120 GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
1121 "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
1122 "ja", kFormatUrlOmitNothing, UnescapeRule::NORMAL, &parsed, NULL,
1123 NULL);
1124 EXPECT_EQ(WideToUTF16(L"http://\x30B0:\x30FC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
1125 L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
1126 EXPECT_EQ(WideToUTF16(L"\x30B0"),
1127 formatted.substr(parsed.username.begin, parsed.username.len));
1128 EXPECT_EQ(WideToUTF16(L"\x30FC"),
1129 formatted.substr(parsed.password.begin, parsed.password.len));
1130 EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
1131 formatted.substr(parsed.host.begin, parsed.host.len));
1132 EXPECT_EQ(WideToUTF16(L"8080"),
1133 formatted.substr(parsed.port.begin, parsed.port.len));
1134 EXPECT_EQ(WideToUTF16(L"/\x30B0/"),
1135 formatted.substr(parsed.path.begin, parsed.path.len));
1136 EXPECT_EQ(WideToUTF16(L"q=\x30B0"),
1137 formatted.substr(parsed.query.begin, parsed.query.len));
1138 EXPECT_EQ(WideToUTF16(L"\x30B0"),
1139 formatted.substr(parsed.ref.begin, parsed.ref.len));
1140
1141 // Omit_username_password + unescape case.
1142 formatted = FormatUrl(
1143 GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
1144 "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
1145 "ja", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed,
1146 NULL, NULL);
1147 EXPECT_EQ(WideToUTF16(L"http://\x30B0\x30FC\x30B0\x30EB.jp:8080"
1148 L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
1149 EXPECT_FALSE(parsed.username.is_valid());
1150 EXPECT_FALSE(parsed.password.is_valid());
1151 EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
1152 formatted.substr(parsed.host.begin, parsed.host.len));
1153 EXPECT_EQ(WideToUTF16(L"8080"),
1154 formatted.substr(parsed.port.begin, parsed.port.len));
1155 EXPECT_EQ(WideToUTF16(L"/\x30B0/"),
1156 formatted.substr(parsed.path.begin, parsed.path.len));
1157 EXPECT_EQ(WideToUTF16(L"q=\x30B0"),
1158 formatted.substr(parsed.query.begin, parsed.query.len));
1159 EXPECT_EQ(WideToUTF16(L"\x30B0"),
1160 formatted.substr(parsed.ref.begin, parsed.ref.len));
1161
1162 // View-source case.
1163 formatted =
1164 FormatUrl(GURL("view-source:http://user:passwd@host:81/path?query#ref"),
1165 std::string(),
1166 kFormatUrlOmitUsernamePassword,
1167 UnescapeRule::NORMAL,
1168 &parsed,
1169 NULL,
1170 NULL);
1171 EXPECT_EQ(WideToUTF16(L"view-source:http://host:81/path?query#ref"),
1172 formatted);
1173 EXPECT_EQ(WideToUTF16(L"view-source:http"),
1174 formatted.substr(parsed.scheme.begin, parsed.scheme.len));
1175 EXPECT_FALSE(parsed.username.is_valid());
1176 EXPECT_FALSE(parsed.password.is_valid());
1177 EXPECT_EQ(WideToUTF16(L"host"),
1178 formatted.substr(parsed.host.begin, parsed.host.len));
1179 EXPECT_EQ(WideToUTF16(L"81"),
1180 formatted.substr(parsed.port.begin, parsed.port.len));
1181 EXPECT_EQ(WideToUTF16(L"/path"),
1182 formatted.substr(parsed.path.begin, parsed.path.len));
1183 EXPECT_EQ(WideToUTF16(L"query"),
1184 formatted.substr(parsed.query.begin, parsed.query.len));
1185 EXPECT_EQ(WideToUTF16(L"ref"),
1186 formatted.substr(parsed.ref.begin, parsed.ref.len));
1187
1188 // omit http case.
1189 formatted = FormatUrl(GURL("http://host:8000/a?b=c#d"),
1190 std::string(),
1191 kFormatUrlOmitHTTP,
1192 UnescapeRule::NORMAL,
1193 &parsed,
1194 NULL,
1195 NULL);
1196 EXPECT_EQ(WideToUTF16(L"host:8000/a?b=c#d"), formatted);
1197 EXPECT_FALSE(parsed.scheme.is_valid());
1198 EXPECT_FALSE(parsed.username.is_valid());
1199 EXPECT_FALSE(parsed.password.is_valid());
1200 EXPECT_EQ(WideToUTF16(L"host"),
1201 formatted.substr(parsed.host.begin, parsed.host.len));
1202 EXPECT_EQ(WideToUTF16(L"8000"),
1203 formatted.substr(parsed.port.begin, parsed.port.len));
1204 EXPECT_EQ(WideToUTF16(L"/a"),
1205 formatted.substr(parsed.path.begin, parsed.path.len));
1206 EXPECT_EQ(WideToUTF16(L"b=c"),
1207 formatted.substr(parsed.query.begin, parsed.query.len));
1208 EXPECT_EQ(WideToUTF16(L"d"),
1209 formatted.substr(parsed.ref.begin, parsed.ref.len));
1210
1211 // omit http starts with ftp case.
1212 formatted = FormatUrl(GURL("http://ftp.host:8000/a?b=c#d"),
1213 std::string(),
1214 kFormatUrlOmitHTTP,
1215 UnescapeRule::NORMAL,
1216 &parsed,
1217 NULL,
1218 NULL);
1219 EXPECT_EQ(WideToUTF16(L"http://ftp.host:8000/a?b=c#d"), formatted);
1220 EXPECT_TRUE(parsed.scheme.is_valid());
1221 EXPECT_FALSE(parsed.username.is_valid());
1222 EXPECT_FALSE(parsed.password.is_valid());
1223 EXPECT_EQ(WideToUTF16(L"http"),
1224 formatted.substr(parsed.scheme.begin, parsed.scheme.len));
1225 EXPECT_EQ(WideToUTF16(L"ftp.host"),
1226 formatted.substr(parsed.host.begin, parsed.host.len));
1227 EXPECT_EQ(WideToUTF16(L"8000"),
1228 formatted.substr(parsed.port.begin, parsed.port.len));
1229 EXPECT_EQ(WideToUTF16(L"/a"),
1230 formatted.substr(parsed.path.begin, parsed.path.len));
1231 EXPECT_EQ(WideToUTF16(L"b=c"),
1232 formatted.substr(parsed.query.begin, parsed.query.len));
1233 EXPECT_EQ(WideToUTF16(L"d"),
1234 formatted.substr(parsed.ref.begin, parsed.ref.len));
1235
1236 // omit http starts with 'f' case.
1237 formatted = FormatUrl(GURL("http://f/"),
1238 std::string(),
1239 kFormatUrlOmitHTTP,
1240 UnescapeRule::NORMAL,
1241 &parsed,
1242 NULL,
1243 NULL);
1244 EXPECT_EQ(WideToUTF16(L"f/"), formatted);
1245 EXPECT_FALSE(parsed.scheme.is_valid());
1246 EXPECT_FALSE(parsed.username.is_valid());
1247 EXPECT_FALSE(parsed.password.is_valid());
1248 EXPECT_FALSE(parsed.port.is_valid());
1249 EXPECT_TRUE(parsed.path.is_valid());
1250 EXPECT_FALSE(parsed.query.is_valid());
1251 EXPECT_FALSE(parsed.ref.is_valid());
1252 EXPECT_EQ(WideToUTF16(L"f"),
1253 formatted.substr(parsed.host.begin, parsed.host.len));
1254 EXPECT_EQ(WideToUTF16(L"/"),
1255 formatted.substr(parsed.path.begin, parsed.path.len));
1256 }
1257
1258 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
1259 // results in the original GURL, for each ASCII character in the path.
1260 TEST(NetUtilTest, FormatUrlRoundTripPathASCII) {
1261 for (unsigned char test_char = 32; test_char < 128; ++test_char) {
1262 GURL url(std::string("http://www.google.com/") +
1263 static_cast<char>(test_char));
1264 size_t prefix_len;
1265 base::string16 formatted = FormatUrl(url,
1266 std::string(),
1267 kFormatUrlOmitUsernamePassword,
1268 UnescapeRule::NORMAL,
1269 NULL,
1270 &prefix_len,
1271 NULL);
1272 EXPECT_EQ(url.spec(), GURL(formatted).spec());
1273 }
1274 }
1275
1276 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
1277 // results in the original GURL, for each escaped ASCII character in the path.
1278 TEST(NetUtilTest, FormatUrlRoundTripPathEscaped) {
1279 for (unsigned char test_char = 32; test_char < 128; ++test_char) {
1280 std::string original_url("http://www.google.com/");
1281 original_url.push_back('%');
1282 original_url.append(base::HexEncode(&test_char, 1));
1283
1284 GURL url(original_url);
1285 size_t prefix_len;
1286 base::string16 formatted = FormatUrl(url,
1287 std::string(),
1288 kFormatUrlOmitUsernamePassword,
1289 UnescapeRule::NORMAL,
1290 NULL,
1291 &prefix_len,
1292 NULL);
1293 EXPECT_EQ(url.spec(), GURL(formatted).spec());
1294 }
1295 }
1296
1297 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
1298 // results in the original GURL, for each ASCII character in the query.
1299 TEST(NetUtilTest, FormatUrlRoundTripQueryASCII) {
1300 for (unsigned char test_char = 32; test_char < 128; ++test_char) {
1301 GURL url(std::string("http://www.google.com/?") +
1302 static_cast<char>(test_char));
1303 size_t prefix_len;
1304 base::string16 formatted = FormatUrl(url,
1305 std::string(),
1306 kFormatUrlOmitUsernamePassword,
1307 UnescapeRule::NORMAL,
1308 NULL,
1309 &prefix_len,
1310 NULL);
1311 EXPECT_EQ(url.spec(), GURL(formatted).spec());
1312 }
1313 }
1314
1315 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
1316 // only results in a different GURL for certain characters.
1317 TEST(NetUtilTest, FormatUrlRoundTripQueryEscaped) {
1318 // A full list of characters which FormatURL should unescape and GURL should
1319 // not escape again, when they appear in a query string.
1320 const char* kUnescapedCharacters =
1321 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~";
1322 for (unsigned char test_char = 0; test_char < 128; ++test_char) {
1323 std::string original_url("http://www.google.com/?");
1324 original_url.push_back('%');
1325 original_url.append(base::HexEncode(&test_char, 1));
1326
1327 GURL url(original_url);
1328 size_t prefix_len;
1329 base::string16 formatted = FormatUrl(url,
1330 std::string(),
1331 kFormatUrlOmitUsernamePassword,
1332 UnescapeRule::NORMAL,
1333 NULL,
1334 &prefix_len,
1335 NULL);
1336
1337 if (test_char &&
1338 strchr(kUnescapedCharacters, static_cast<char>(test_char))) {
1339 EXPECT_NE(url.spec(), GURL(formatted).spec());
1340 } else {
1341 EXPECT_EQ(url.spec(), GURL(formatted).spec());
1342 }
1343 }
1344 }
1345
1346 TEST(NetUtilTest, FormatUrlWithOffsets) {
1347 CheckAdjustedOffsets(std::string(), "en", kFormatUrlOmitNothing,
1348 UnescapeRule::NORMAL, NULL);
1349
1350 const size_t basic_offsets[] = {
1351 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1352 21, 22, 23, 24, 25
1353 };
1354 CheckAdjustedOffsets("http://www.google.com/foo/", "en",
1355 kFormatUrlOmitNothing, UnescapeRule::NORMAL,
1356 basic_offsets);
1357
1358 const size_t omit_auth_offsets_1[] = {
1359 0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 7,
1360 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
1361 };
1362 CheckAdjustedOffsets("http://foo:bar@www.google.com/", "en",
1363 kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
1364 omit_auth_offsets_1);
1365
1366 const size_t omit_auth_offsets_2[] = {
1367 0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, 7, 8, 9, 10, 11, 12, 13, 14,
1368 15, 16, 17, 18, 19, 20, 21
1369 };
1370 CheckAdjustedOffsets("http://foo@www.google.com/", "en",
1371 kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
1372 omit_auth_offsets_2);
1373
1374 const size_t dont_omit_auth_offsets[] = {
1375 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
1376 kNpos, kNpos, 11, 12, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
1377 kNpos, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1378 30, 31
1379 };
1380 // Unescape to "http://foo\x30B0:\x30B0bar@www.google.com".
1381 CheckAdjustedOffsets("http://foo%E3%82%B0:%E3%82%B0bar@www.google.com/", "en",
1382 kFormatUrlOmitNothing, UnescapeRule::NORMAL,
1383 dont_omit_auth_offsets);
1384
1385 const size_t view_source_offsets[] = {
1386 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, kNpos,
1387 kNpos, kNpos, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33
1388 };
1389 CheckAdjustedOffsets("view-source:http://foo@www.google.com/", "en",
1390 kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
1391 view_source_offsets);
1392
1393 const size_t idn_hostname_offsets_1[] = {
1394 0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
1395 kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 12,
1396 13, 14, 15, 16, 17, 18, 19
1397 };
1398 // Convert punycode to "http://\x671d\x65e5\x3042\x3055\x3072.jp/foo/".
1399 CheckAdjustedOffsets("http://xn--l8jvb1ey91xtjb.jp/foo/", "ja",
1400 kFormatUrlOmitNothing, UnescapeRule::NORMAL,
1401 idn_hostname_offsets_1);
1402
1403 const size_t idn_hostname_offsets_2[] = {
1404 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, kNpos, kNpos, kNpos, kNpos, kNpos,
1405 kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 14, 15, kNpos, kNpos, kNpos,
1406 kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
1407 kNpos, 19, 20, 21, 22, 23, 24
1408 };
1409 // Convert punycode to
1410 // "http://test.\x89c6\x9891.\x5317\x4eac\x5927\x5b78.test/".
1411 CheckAdjustedOffsets("http://test.xn--cy2a840a.xn--1lq90ic7f1rc.test/",
1412 "zh-CN", kFormatUrlOmitNothing, UnescapeRule::NORMAL,
1413 idn_hostname_offsets_2);
1414
1415 const size_t unescape_offsets[] = {
1416 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1417 21, 22, 23, 24, 25, kNpos, kNpos, 26, 27, 28, 29, 30, kNpos, kNpos, kNpos,
1418 kNpos, kNpos, kNpos, kNpos, kNpos, 31, kNpos, kNpos, kNpos, kNpos, kNpos,
1419 kNpos, kNpos, kNpos, 32, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
1420 kNpos, 33, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos
1421 };
1422 // Unescape to "http://www.google.com/foo bar/\x30B0\x30FC\x30B0\x30EB".
1423 CheckAdjustedOffsets(
1424 "http://www.google.com/foo%20bar/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB",
1425 "en", kFormatUrlOmitNothing, UnescapeRule::SPACES, unescape_offsets);
1426
1427 const size_t ref_offsets[] = {
1428 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1429 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, kNpos, kNpos, 32, kNpos, kNpos,
1430 33
1431 };
1432 // Unescape to "http://www.google.com/foo.html#\x30B0\x30B0z".
1433 CheckAdjustedOffsets(
1434 "http://www.google.com/foo.html#\xE3\x82\xB0\xE3\x82\xB0z", "en",
1435 kFormatUrlOmitNothing, UnescapeRule::NORMAL, ref_offsets);
1436
1437 const size_t omit_http_offsets[] = {
1438 0, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1439 10, 11, 12, 13, 14
1440 };
1441 CheckAdjustedOffsets("http://www.google.com/", "en", kFormatUrlOmitHTTP,
1442 UnescapeRule::NORMAL, omit_http_offsets);
1443
1444 const size_t omit_http_start_with_ftp_offsets[] = {
1445 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
1446 };
1447 CheckAdjustedOffsets("http://ftp.google.com/", "en", kFormatUrlOmitHTTP,
1448 UnescapeRule::NORMAL, omit_http_start_with_ftp_offsets);
1449
1450 const size_t omit_all_offsets[] = {
1451 0, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 0, kNpos, kNpos, kNpos, kNpos,
1452 0, 1, 2, 3, 4, 5, 6, 7
1453 };
1454 CheckAdjustedOffsets("http://user@foo.com/", "en", kFormatUrlOmitAll,
1455 UnescapeRule::NORMAL, omit_all_offsets);
1456 }
1457
1458 TEST(NetUtilTest, SimplifyUrlForRequest) {
1459 struct {
1460 const char* input_url;
1461 const char* expected_simplified_url;
1462 } tests[] = {
1463 {
1464 // Reference section should be stripped.
1465 "http://www.google.com:78/foobar?query=1#hash",
1466 "http://www.google.com:78/foobar?query=1",
1467 },
1468 {
1469 // Reference section can itself contain #.
1470 "http://192.168.0.1?query=1#hash#10#11#13#14",
1471 "http://192.168.0.1?query=1",
1472 },
1473 { // Strip username/password.
1474 "http://user:pass@google.com",
1475 "http://google.com/",
1476 },
1477 { // Strip both the reference and the username/password.
1478 "http://user:pass@google.com:80/sup?yo#X#X",
1479 "http://google.com/sup?yo",
1480 },
1481 { // Try an HTTPS URL -- strip both the reference and the username/password.
1482 "https://user:pass@google.com:80/sup?yo#X#X",
1483 "https://google.com:80/sup?yo",
1484 },
1485 { // Try an FTP URL -- strip both the reference and the username/password.
1486 "ftp://user:pass@google.com:80/sup?yo#X#X",
1487 "ftp://google.com:80/sup?yo",
1488 },
1489 { // Try a nonstandard URL
1490 "foobar://user:pass@google.com:80/sup?yo#X#X",
1491 "foobar://user:pass@google.com:80/sup?yo",
1492 },
1493 };
1494 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
1495 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
1496 tests[i].input_url));
1497 GURL input_url(GURL(tests[i].input_url));
1498 GURL expected_url(GURL(tests[i].expected_simplified_url));
1499 EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
1500 }
1501 }
1502
1503 TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
1504 std::string invalid[] = { "1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12" };
1505 std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
1506
1507 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(invalid); ++i) {
1508 SetExplicitlyAllowedPorts(invalid[i]);
1509 EXPECT_EQ(0, static_cast<int>(GetCountOfExplicitlyAllowedPorts()));
1510 }
1511
1512 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid); ++i) {
1513 SetExplicitlyAllowedPorts(valid[i]);
1514 EXPECT_EQ(i, GetCountOfExplicitlyAllowedPorts());
1515 }
1516 }
1517
1518 TEST(NetUtilTest, GetHostOrSpecFromURL) {
1519 EXPECT_EQ("example.com",
1520 GetHostOrSpecFromURL(GURL("http://example.com/test")));
1521 EXPECT_EQ("example.com",
1522 GetHostOrSpecFromURL(GURL("http://example.com./test")));
1523 EXPECT_EQ("file:///tmp/test.html",
1524 GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
1525 }
1526
1527 TEST(NetUtilTest, GetAddressFamily) {
1528 IPAddressNumber number;
1529 EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
1530 EXPECT_EQ(ADDRESS_FAMILY_IPV4, GetAddressFamily(number));
1531 EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
1532 EXPECT_EQ(ADDRESS_FAMILY_IPV6, GetAddressFamily(number));
1533 }
1534
1535 // Test that invalid IP literals fail to parse.
1536 TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) {
1537 IPAddressNumber number;
1538
1539 EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number));
1540 EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number));
1541 EXPECT_FALSE(ParseIPLiteralToNumber(std::string(), &number));
1542 EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number));
1543 EXPECT_FALSE(ParseIPLiteralToNumber(" 192.168.0.1 ", &number));
1544 EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number));
1545 }
1546
1547 // Test parsing an IPv4 literal.
1548 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv4) {
1549 IPAddressNumber number;
1550 EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
1551 EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
1552 EXPECT_EQ("192.168.0.1", IPAddressToString(number));
1553 }
1554
1555 // Test parsing an IPv6 literal.
1556 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv6) {
1557 IPAddressNumber number;
1558 EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
1559 EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
1560 EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
1561 }
1562
1563 // Test mapping an IPv4 address to an IPv6 address.
1564 TEST(NetUtilTest, ConvertIPv4NumberToIPv6Number) {
1565 IPAddressNumber ipv4_number;
1566 EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
1567
1568 IPAddressNumber ipv6_number =
1569 ConvertIPv4NumberToIPv6Number(ipv4_number);
1570
1571 // ::ffff:192.168.0.1
1572 EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
1573 DumpIPNumber(ipv6_number));
1574 EXPECT_EQ("::ffff:c0a8:1", IPAddressToString(ipv6_number));
1575 }
1576
1577 TEST(NetUtilTest, IsIPv4Mapped) {
1578 IPAddressNumber ipv4_number;
1579 EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
1580 EXPECT_FALSE(IsIPv4Mapped(ipv4_number));
1581
1582 IPAddressNumber ipv6_number;
1583 EXPECT_TRUE(ParseIPLiteralToNumber("::1", &ipv4_number));
1584 EXPECT_FALSE(IsIPv4Mapped(ipv6_number));
1585
1586 IPAddressNumber ipv4mapped_number;
1587 EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
1588 EXPECT_TRUE(IsIPv4Mapped(ipv4mapped_number));
1589 }
1590
1591 TEST(NetUtilTest, ConvertIPv4MappedToIPv4) {
1592 IPAddressNumber ipv4mapped_number;
1593 EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
1594 IPAddressNumber expected;
1595 EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
1596 IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
1597 EXPECT_EQ(expected, result);
1598 }
1599
1600 // Test parsing invalid CIDR notation literals.
1601 TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
1602 const char* bad_literals[] = {
1603 "foobar",
1604 "",
1605 "192.168.0.1",
1606 "::1",
1607 "/",
1608 "/1",
1609 "1",
1610 "192.168.1.1/-1",
1611 "192.168.1.1/33",
1612 "::1/-3",
1613 "a::3/129",
1614 "::1/x",
1615 "192.168.0.1//11"
1616 };
1617
1618 for (size_t i = 0; i < arraysize(bad_literals); ++i) {
1619 IPAddressNumber ip_number;
1620 size_t prefix_length_in_bits;
1621
1622 EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
1623 &ip_number,
1624 &prefix_length_in_bits));
1625 }
1626 }
1627
1628 // Test parsing a valid CIDR notation literal.
1629 TEST(NetUtilTest, ParseCIDRBlock_Valid) {
1630 IPAddressNumber ip_number;
1631 size_t prefix_length_in_bits;
1632
1633 EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
1634 &ip_number,
1635 &prefix_length_in_bits));
1636
1637 EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
1638 EXPECT_EQ(11u, prefix_length_in_bits);
1639 }
1640
1641 TEST(NetUtilTest, IPNumberMatchesPrefix) {
1642 struct {
1643 const char* cidr_literal;
1644 const char* ip_literal;
1645 bool expected_to_match;
1646 } tests[] = {
1647 // IPv4 prefix with IPv4 inputs.
1648 {
1649 "10.10.1.32/27",
1650 "10.10.1.44",
1651 true
1652 },
1653 {
1654 "10.10.1.32/27",
1655 "10.10.1.90",
1656 false
1657 },
1658 {
1659 "10.10.1.32/27",
1660 "10.10.1.90",
1661 false
1662 },
1663
1664 // IPv6 prefix with IPv6 inputs.
1665 {
1666 "2001:db8::/32",
1667 "2001:DB8:3:4::5",
1668 true
1669 },
1670 {
1671 "2001:db8::/32",
1672 "2001:c8::",
1673 false
1674 },
1675
1676 // IPv6 prefix with IPv4 inputs.
1677 {
1678 "2001:db8::/33",
1679 "192.168.0.1",
1680 false
1681 },
1682 {
1683 "::ffff:192.168.0.1/112",
1684 "192.168.33.77",
1685 true
1686 },
1687
1688 // IPv4 prefix with IPv6 inputs.
1689 {
1690 "10.11.33.44/16",
1691 "::ffff:0a0b:89",
1692 true
1693 },
1694 {
1695 "10.11.33.44/16",
1696 "::ffff:10.12.33.44",
1697 false
1698 },
1699 };
1700 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
1701 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
1702 tests[i].cidr_literal,
1703 tests[i].ip_literal));
1704
1705 IPAddressNumber ip_number;
1706 EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
1707
1708 IPAddressNumber ip_prefix;
1709 size_t prefix_length_in_bits;
1710
1711 EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
1712 &ip_prefix,
1713 &prefix_length_in_bits));
1714
1715 EXPECT_EQ(tests[i].expected_to_match,
1716 IPNumberMatchesPrefix(ip_number,
1717 ip_prefix,
1718 prefix_length_in_bits));
1719 }
1720 }
1721
1722 TEST(NetUtilTest, IsLocalhost) {
1723 EXPECT_TRUE(net::IsLocalhost("localhost"));
1724 EXPECT_TRUE(net::IsLocalhost("localhost.localdomain"));
1725 EXPECT_TRUE(net::IsLocalhost("localhost6"));
1726 EXPECT_TRUE(net::IsLocalhost("localhost6.localdomain6"));
1727 EXPECT_TRUE(net::IsLocalhost("127.0.0.1"));
1728 EXPECT_TRUE(net::IsLocalhost("127.0.1.0"));
1729 EXPECT_TRUE(net::IsLocalhost("127.1.0.0"));
1730 EXPECT_TRUE(net::IsLocalhost("127.0.0.255"));
1731 EXPECT_TRUE(net::IsLocalhost("127.0.255.0"));
1732 EXPECT_TRUE(net::IsLocalhost("127.255.0.0"));
1733 EXPECT_TRUE(net::IsLocalhost("::1"));
1734 EXPECT_TRUE(net::IsLocalhost("0:0:0:0:0:0:0:1"));
1735
1736 EXPECT_FALSE(net::IsLocalhost("localhostx"));
1737 EXPECT_FALSE(net::IsLocalhost("foo.localdomain"));
1738 EXPECT_FALSE(net::IsLocalhost("localhost6x"));
1739 EXPECT_FALSE(net::IsLocalhost("localhost.localdomain6"));
1740 EXPECT_FALSE(net::IsLocalhost("localhost6.localdomain"));
1741 EXPECT_FALSE(net::IsLocalhost("127.0.0.1.1"));
1742 EXPECT_FALSE(net::IsLocalhost(".127.0.0.255"));
1743 EXPECT_FALSE(net::IsLocalhost("::2"));
1744 EXPECT_FALSE(net::IsLocalhost("::1:1"));
1745 EXPECT_FALSE(net::IsLocalhost("0:0:0:0:1:0:0:1"));
1746 EXPECT_FALSE(net::IsLocalhost("::1:1"));
1747 EXPECT_FALSE(net::IsLocalhost("0:0:0:0:0:0:0:0:1"));
1748 }
1749
1750 // Verify GetNetworkList().
1751 TEST(NetUtilTest, GetNetworkList) {
1752 NetworkInterfaceList list;
1753 ASSERT_TRUE(GetNetworkList(&list, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES));
1754 for (NetworkInterfaceList::iterator it = list.begin();
1755 it != list.end(); ++it) {
1756 // Verify that the names are not empty.
1757 EXPECT_FALSE(it->name.empty());
1758 EXPECT_FALSE(it->friendly_name.empty());
1759
1760 // Verify that the address is correct.
1761 EXPECT_TRUE(it->address.size() == kIPv4AddressSize ||
1762 it->address.size() == kIPv6AddressSize)
1763 << "Invalid address of size " << it->address.size();
1764 bool all_zeroes = true;
1765 for (size_t i = 0; i < it->address.size(); ++i) {
1766 if (it->address[i] != 0) {
1767 all_zeroes = false;
1768 break;
1769 }
1770 }
1771 EXPECT_FALSE(all_zeroes);
1772 EXPECT_GT(it->network_prefix, 1u);
1773 EXPECT_LE(it->network_prefix, it->address.size() * 8);
1774
1775 #if defined(OS_WIN)
1776 // On Windows |name| is NET_LUID.
1777 base::ScopedNativeLibrary phlpapi_lib(
1778 base::FilePath(FILE_PATH_LITERAL("iphlpapi.dll")));
1779 ASSERT_TRUE(phlpapi_lib.is_valid());
1780 typedef NETIO_STATUS (WINAPI* ConvertInterfaceIndexToLuid)(NET_IFINDEX,
1781 PNET_LUID);
1782 ConvertInterfaceIndexToLuid interface_to_luid =
1783 reinterpret_cast<ConvertInterfaceIndexToLuid>(
1784 phlpapi_lib.GetFunctionPointer("ConvertInterfaceIndexToLuid"));
1785
1786 typedef NETIO_STATUS (WINAPI* ConvertInterfaceLuidToGuid)(NET_LUID*,
1787 GUID*);
1788 ConvertInterfaceLuidToGuid luid_to_guid =
1789 reinterpret_cast<ConvertInterfaceLuidToGuid>(
1790 phlpapi_lib.GetFunctionPointer("ConvertInterfaceLuidToGuid"));
1791
1792 if (interface_to_luid && luid_to_guid) {
1793 NET_LUID luid;
1794 EXPECT_EQ(interface_to_luid(it->interface_index, &luid), NO_ERROR);
1795 GUID guid;
1796 EXPECT_EQ(luid_to_guid(&luid, &guid), NO_ERROR);
1797 LPOLESTR name;
1798 StringFromCLSID(guid, &name);
1799 EXPECT_STREQ(base::UTF8ToWide(it->name).c_str(), name);
1800 CoTaskMemFree(name);
1801 continue;
1802 } else {
1803 EXPECT_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
1804 EXPECT_LT(it->interface_index, 1u << 24u); // Must fit 0.x.x.x.
1805 EXPECT_NE(it->interface_index, 0u); // 0 means to use default.
1806 }
1807 if (it->type == NetworkChangeNotifier::CONNECTION_WIFI) {
1808 EXPECT_NE(WIFI_PHY_LAYER_PROTOCOL_NONE, GetWifiPHYLayerProtocol());
1809 }
1810 #elif !defined(OS_ANDROID)
1811 char name[IF_NAMESIZE];
1812 EXPECT_TRUE(if_indextoname(it->interface_index, name));
1813 EXPECT_STREQ(it->name.c_str(), name);
1814 #endif
1815 }
1816 }
1817
1818 struct NonUniqueNameTestData {
1819 bool is_unique;
1820 const char* hostname;
1821 };
1822
1823 // Google Test pretty-printer.
1824 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
1825 ASSERT_TRUE(data.hostname);
1826 *os << " hostname: " << testing::PrintToString(data.hostname)
1827 << "; is_unique: " << testing::PrintToString(data.is_unique);
1828 }
1829
1830 const NonUniqueNameTestData kNonUniqueNameTestData[] = {
1831 // Domains under ICANN-assigned domains.
1832 { true, "google.com" },
1833 { true, "google.co.uk" },
1834 // Domains under private registries.
1835 { true, "appspot.com" },
1836 { true, "test.appspot.com" },
1837 // Unreserved IPv4 addresses (in various forms).
1838 { true, "8.8.8.8" },
1839 { true, "99.64.0.0" },
1840 { true, "212.15.0.0" },
1841 { true, "212.15" },
1842 { true, "212.15.0" },
1843 { true, "3557752832" },
1844 // Reserved IPv4 addresses (in various forms).
1845 { false, "192.168.0.0" },
1846 { false, "192.168.0.6" },
1847 { false, "10.0.0.5" },
1848 { false, "10.0" },
1849 { false, "10.0.0" },
1850 { false, "3232235526" },
1851 // Unreserved IPv6 addresses.
1852 { true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1853 { true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210" },
1854 // Reserved IPv6 addresses.
1855 { false, "::192.9.5.5" },
1856 { false, "FEED::BEEF" },
1857 { false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1858 // 'internal'/non-IANA assigned domains.
1859 { false, "intranet" },
1860 { false, "intranet." },
1861 { false, "intranet.example" },
1862 { false, "host.intranet.example" },
1863 // gTLDs under discussion, but not yet assigned.
1864 { false, "intranet.corp" },
1865 { false, "example.tech" },
1866 { false, "intranet.internal" },
1867 // Invalid host names are treated as unique - but expected to be
1868 // filtered out before then.
1869 { true, "junk)(£)$*!@~#" },
1870 { true, "w$w.example.com" },
1871 { true, "nocolonsallowed:example" },
1872 { true, "[::4.5.6.9]" },
1873 };
1874
1875 class NetUtilNonUniqueNameTest
1876 : public testing::TestWithParam<NonUniqueNameTestData> {
1877 public:
1878 virtual ~NetUtilNonUniqueNameTest() {}
1879
1880 protected:
1881 bool IsUnique(const std::string& hostname) {
1882 return !IsHostnameNonUnique(hostname);
1883 }
1884 };
1885
1886 // Test that internal/non-unique names are properly identified as such, but
1887 // that IP addresses and hosts beneath registry-controlled domains are flagged
1888 // as unique names.
1889 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
1890 const NonUniqueNameTestData& test_data = GetParam();
1891
1892 EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
1893 }
1894
1895 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
1896 testing::ValuesIn(kNonUniqueNameTestData));
1897
1898 } // namespace net