OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include "base/strings/utf_string_conversions.h" |
5 #include "net/base/registry_controlled_domains/registry_controlled_domain.h" | 6 #include "net/base/registry_controlled_domains/registry_controlled_domain.h" |
6 #include "testing/gtest/include/gtest/gtest.h" | 7 #include "testing/gtest/include/gtest/gtest.h" |
7 #include "url/gurl.h" | 8 #include "url/gurl.h" |
8 #include "url/origin.h" | 9 #include "url/origin.h" |
9 | 10 |
10 namespace { | 11 namespace { |
| 12 |
11 namespace test1 { | 13 namespace test1 { |
12 #include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc
.cc" | 14 #include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc
.cc" |
13 } | 15 } |
14 namespace test2 { | 16 namespace test2 { |
15 #include "net/base/registry_controlled_domains/effective_tld_names_unittest2-inc
.cc" | 17 #include "net/base/registry_controlled_domains/effective_tld_names_unittest2-inc
.cc" |
16 } | 18 } |
17 namespace test3 { | 19 namespace test3 { |
18 #include "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc
.cc" | 20 #include "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc
.cc" |
19 } | 21 } |
20 namespace test4 { | 22 namespace test4 { |
21 #include "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc
.cc" | 23 #include "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc
.cc" |
22 } | 24 } |
23 namespace test5 { | 25 namespace test5 { |
24 #include "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc
.cc" | 26 #include "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc
.cc" |
25 } | 27 } |
26 namespace test6 { | 28 namespace test6 { |
27 #include "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc
.cc" | 29 #include "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc
.cc" |
28 } | 30 } |
| 31 |
29 } // namespace | 32 } // namespace |
30 | 33 |
31 namespace net { | 34 namespace net { |
32 namespace registry_controlled_domains { | 35 namespace registry_controlled_domains { |
| 36 |
33 namespace { | 37 namespace { |
34 | 38 |
35 std::string GetDomainFromURL(const std::string& url) { | 39 std::string GetDomainFromURL(const std::string& url) { |
36 return GetDomainAndRegistry(GURL(url), EXCLUDE_PRIVATE_REGISTRIES); | 40 return GetDomainAndRegistry(GURL(url), EXCLUDE_PRIVATE_REGISTRIES); |
37 } | 41 } |
38 | 42 |
39 std::string GetDomainFromHost(const std::string& host) { | 43 std::string GetDomainFromHost(const std::string& host) { |
40 return GetDomainAndRegistry(host, EXCLUDE_PRIVATE_REGISTRIES); | 44 return GetDomainAndRegistry(host, EXCLUDE_PRIVATE_REGISTRIES); |
41 } | 45 } |
42 | 46 |
43 size_t GetRegistryLengthFromURL( | 47 size_t GetRegistryLengthFromURL( |
44 const std::string& url, | 48 const std::string& url, |
45 UnknownRegistryFilter unknown_filter) { | 49 UnknownRegistryFilter unknown_filter) { |
46 return GetRegistryLength(GURL(url), | 50 return GetRegistryLength(GURL(url), |
47 unknown_filter, | 51 unknown_filter, |
48 EXCLUDE_PRIVATE_REGISTRIES); | 52 EXCLUDE_PRIVATE_REGISTRIES); |
49 } | 53 } |
50 | 54 |
51 size_t GetRegistryLengthFromURLIncludingPrivate( | 55 size_t GetRegistryLengthFromURLIncludingPrivate( |
52 const std::string& url, | 56 const std::string& url, |
53 UnknownRegistryFilter unknown_filter) { | 57 UnknownRegistryFilter unknown_filter) { |
54 return GetRegistryLength(GURL(url), | 58 return GetRegistryLength(GURL(url), |
55 unknown_filter, | 59 unknown_filter, |
56 INCLUDE_PRIVATE_REGISTRIES); | 60 INCLUDE_PRIVATE_REGISTRIES); |
57 } | 61 } |
58 | 62 |
59 size_t GetRegistryLengthFromHost( | 63 size_t PermissiveGetHostRegistryLength(base::StringPiece host) { |
60 const std::string& host, | 64 return PermissiveGetHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES, |
61 UnknownRegistryFilter unknown_filter) { | 65 EXCLUDE_PRIVATE_REGISTRIES); |
62 return GetRegistryLength(host, unknown_filter, EXCLUDE_PRIVATE_REGISTRIES); | |
63 } | 66 } |
64 | 67 |
65 size_t GetRegistryLengthFromHostIncludingPrivate( | 68 size_t PermissiveGetHostRegistryLength(base::StringPiece16 host) { |
66 const std::string& host, | 69 return PermissiveGetHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES, |
67 UnknownRegistryFilter unknown_filter) { | 70 EXCLUDE_PRIVATE_REGISTRIES); |
68 return GetRegistryLength(host, unknown_filter, INCLUDE_PRIVATE_REGISTRIES); | 71 } |
| 72 |
| 73 size_t GetCanonicalHostRegistryLength(const std::string& host, |
| 74 UnknownRegistryFilter unknown_filter) { |
| 75 return GetCanonicalHostRegistryLength(host, unknown_filter, |
| 76 EXCLUDE_PRIVATE_REGISTRIES); |
| 77 } |
| 78 |
| 79 size_t GetCanonicalHostRegistryLengthIncludingPrivate(const std::string& host) { |
| 80 return GetCanonicalHostRegistryLength(host, EXCLUDE_UNKNOWN_REGISTRIES, |
| 81 INCLUDE_PRIVATE_REGISTRIES); |
69 } | 82 } |
70 | 83 |
71 } // namespace | 84 } // namespace |
72 | 85 |
73 class RegistryControlledDomainTest : public testing::Test { | 86 class RegistryControlledDomainTest : public testing::Test { |
74 protected: | 87 protected: |
75 template <typename Graph> | 88 template <typename Graph> |
76 void UseDomainData(const Graph& graph) { | 89 void UseDomainData(const Graph& graph) { |
77 SetFindDomainGraph(graph, sizeof(Graph)); | 90 SetFindDomainGraph(graph, sizeof(Graph)); |
78 } | 91 } |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
209 EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.", | 222 EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.", |
210 EXCLUDE_UNKNOWN_REGISTRIES)); | 223 EXCLUDE_UNKNOWN_REGISTRIES)); |
211 EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.", | 224 EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.", |
212 INCLUDE_UNKNOWN_REGISTRIES)); | 225 INCLUDE_UNKNOWN_REGISTRIES)); |
213 EXPECT_EQ(0U, GetRegistryLengthFromURL("http:////Comment", | 226 EXPECT_EQ(0U, GetRegistryLengthFromURL("http:////Comment", |
214 EXCLUDE_UNKNOWN_REGISTRIES)); | 227 EXCLUDE_UNKNOWN_REGISTRIES)); |
215 | 228 |
216 // Test std::string version of GetRegistryLength(). Uses the same | 229 // Test std::string version of GetRegistryLength(). Uses the same |
217 // underpinnings as the GURL version, so this is really more of a check of | 230 // underpinnings as the GURL version, so this is really more of a check of |
218 // CanonicalizeHost(). | 231 // CanonicalizeHost(). |
219 EXPECT_EQ(2U, GetRegistryLengthFromHost("a.baz.jp", | 232 EXPECT_EQ(2U, GetCanonicalHostRegistryLength( |
220 EXCLUDE_UNKNOWN_REGISTRIES)); // 1 | 233 "a.baz.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 1 |
221 EXPECT_EQ(3U, GetRegistryLengthFromHost("a.baz.jp.", | 234 EXPECT_EQ(3U, GetCanonicalHostRegistryLength( |
222 EXCLUDE_UNKNOWN_REGISTRIES)); // 1 | 235 "a.baz.jp.", EXCLUDE_UNKNOWN_REGISTRIES)); // 1 |
223 EXPECT_EQ(0U, GetRegistryLengthFromHost("ac.jp", | 236 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
224 EXCLUDE_UNKNOWN_REGISTRIES)); // 2 | 237 "ac.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 2 |
225 EXPECT_EQ(0U, GetRegistryLengthFromHost("a.bar.jp", | 238 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
226 EXCLUDE_UNKNOWN_REGISTRIES)); // 3 | 239 "a.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 3 |
227 EXPECT_EQ(0U, GetRegistryLengthFromHost("bar.jp", | 240 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
228 EXCLUDE_UNKNOWN_REGISTRIES)); // 3 | 241 "bar.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 3 |
229 EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.bar.jp", | 242 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
230 EXCLUDE_UNKNOWN_REGISTRIES)); // 3 4 | 243 "baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 3 4 |
231 EXPECT_EQ(12U, GetRegistryLengthFromHost("a.b.baz.bar.jp", | 244 EXPECT_EQ(12U, GetCanonicalHostRegistryLength( |
232 EXCLUDE_UNKNOWN_REGISTRIES)); // 4 | 245 "a.b.baz.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 4 |
233 EXPECT_EQ(6U, GetRegistryLengthFromHost("baz.pref.bar.jp", | 246 EXPECT_EQ(6U, GetCanonicalHostRegistryLength( |
234 EXCLUDE_UNKNOWN_REGISTRIES)); // 5 | 247 "baz.pref.bar.jp", EXCLUDE_UNKNOWN_REGISTRIES)); // 5 |
235 EXPECT_EQ(11U, GetRegistryLengthFromHost("a.b.bar.baz.com", | 248 EXPECT_EQ(11U, GetCanonicalHostRegistryLength( |
236 EXCLUDE_UNKNOWN_REGISTRIES)); // 6 | 249 "a.b.bar.baz.com", EXCLUDE_UNKNOWN_REGISTRIES)); // 6 |
237 EXPECT_EQ(3U, GetRegistryLengthFromHost("a.d.c", | 250 EXPECT_EQ(3U, GetCanonicalHostRegistryLength( |
238 EXCLUDE_UNKNOWN_REGISTRIES)); // 7 | 251 "a.d.c", EXCLUDE_UNKNOWN_REGISTRIES)); // 7 |
239 EXPECT_EQ(3U, GetRegistryLengthFromHost(".a.d.c", | 252 EXPECT_EQ(3U, GetCanonicalHostRegistryLength( |
240 EXCLUDE_UNKNOWN_REGISTRIES)); // 7 | 253 ".a.d.c", EXCLUDE_UNKNOWN_REGISTRIES)); // 7 |
241 EXPECT_EQ(3U, GetRegistryLengthFromHost("..a.d.c", | 254 EXPECT_EQ(3U, GetCanonicalHostRegistryLength( |
242 EXCLUDE_UNKNOWN_REGISTRIES)); // 7 | 255 "..a.d.c", EXCLUDE_UNKNOWN_REGISTRIES)); // 7 |
243 EXPECT_EQ(1U, GetRegistryLengthFromHost("a.b.c", | 256 EXPECT_EQ(1U, GetCanonicalHostRegistryLength( |
244 EXCLUDE_UNKNOWN_REGISTRIES)); // 7 8 | 257 "a.b.c", EXCLUDE_UNKNOWN_REGISTRIES)); // 7 8 |
245 EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com", | 258 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
246 EXCLUDE_UNKNOWN_REGISTRIES)); // none | 259 "baz.com", EXCLUDE_UNKNOWN_REGISTRIES)); // none |
247 EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com.", | 260 EXPECT_EQ(0U, GetCanonicalHostRegistryLength( |
248 EXCLUDE_UNKNOWN_REGISTRIES)); // none | 261 "baz.com.", EXCLUDE_UNKNOWN_REGISTRIES)); // none |
249 EXPECT_EQ(3U, GetRegistryLengthFromHost("baz.com", | 262 EXPECT_EQ(3U, GetCanonicalHostRegistryLength( |
250 INCLUDE_UNKNOWN_REGISTRIES)); // none | 263 "baz.com", INCLUDE_UNKNOWN_REGISTRIES)); // none |
251 EXPECT_EQ(4U, GetRegistryLengthFromHost("baz.com.", | 264 EXPECT_EQ(4U, GetCanonicalHostRegistryLength( |
252 INCLUDE_UNKNOWN_REGISTRIES)); // none | 265 "baz.com.", INCLUDE_UNKNOWN_REGISTRIES)); // none |
253 | 266 |
254 EXPECT_EQ(std::string::npos, | 267 EXPECT_EQ(std::string::npos, GetCanonicalHostRegistryLength( |
255 GetRegistryLengthFromHost(std::string(), EXCLUDE_UNKNOWN_REGISTRIES)); | 268 std::string(), EXCLUDE_UNKNOWN_REGISTRIES)); |
256 EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..", | 269 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("foo.com..", |
257 EXCLUDE_UNKNOWN_REGISTRIES)); | 270 EXCLUDE_UNKNOWN_REGISTRIES)); |
258 EXPECT_EQ(0U, GetRegistryLengthFromHost("..", | 271 EXPECT_EQ(0U, |
259 EXCLUDE_UNKNOWN_REGISTRIES)); | 272 GetCanonicalHostRegistryLength("..", EXCLUDE_UNKNOWN_REGISTRIES)); |
260 EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1", | 273 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("192.168.0.1", |
261 EXCLUDE_UNKNOWN_REGISTRIES)); | 274 EXCLUDE_UNKNOWN_REGISTRIES)); |
262 EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost", | 275 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost", |
263 EXCLUDE_UNKNOWN_REGISTRIES)); | 276 EXCLUDE_UNKNOWN_REGISTRIES)); |
264 EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost", | 277 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost", |
265 INCLUDE_UNKNOWN_REGISTRIES)); | 278 INCLUDE_UNKNOWN_REGISTRIES)); |
266 EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.", | 279 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost.", |
267 EXCLUDE_UNKNOWN_REGISTRIES)); | 280 EXCLUDE_UNKNOWN_REGISTRIES)); |
268 EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.", | 281 EXPECT_EQ(0U, GetCanonicalHostRegistryLength("localhost.", |
269 INCLUDE_UNKNOWN_REGISTRIES)); | 282 INCLUDE_UNKNOWN_REGISTRIES)); |
| 283 |
| 284 // IDN case. |
| 285 EXPECT_EQ(10U, GetCanonicalHostRegistryLength("foo.xn--fiqs8s", |
| 286 EXCLUDE_UNKNOWN_REGISTRIES)); |
| 287 } |
| 288 |
| 289 TEST_F(RegistryControlledDomainTest, HostHasRegistryControlledDomain) { |
| 290 UseDomainData(test1::kDafsa); |
| 291 |
| 292 // Invalid hosts. |
| 293 EXPECT_FALSE(HostHasRegistryControlledDomain( |
| 294 std::string(), EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES)); |
| 295 EXPECT_FALSE(HostHasRegistryControlledDomain( |
| 296 "%00asdf", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES)); |
| 297 |
| 298 // Invalid host but valid R.C.D. |
| 299 EXPECT_TRUE(HostHasRegistryControlledDomain( |
| 300 "%00foo.jp", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES)); |
| 301 |
| 302 // Valid R.C.D. when canonicalized, even with an invalid prefix and an |
| 303 // escaped dot. |
| 304 EXPECT_TRUE(HostHasRegistryControlledDomain("%00foo.Google%2EjP", |
| 305 EXCLUDE_UNKNOWN_REGISTRIES, |
| 306 EXCLUDE_PRIVATE_REGISTRIES)); |
| 307 |
| 308 // Regular, no match. |
| 309 EXPECT_FALSE(HostHasRegistryControlledDomain( |
| 310 "bar.notatld", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES)); |
| 311 |
| 312 // Regular, match. |
| 313 EXPECT_TRUE(HostHasRegistryControlledDomain( |
| 314 "www.Google.Jp", EXCLUDE_UNKNOWN_REGISTRIES, EXCLUDE_PRIVATE_REGISTRIES)); |
270 } | 315 } |
271 | 316 |
272 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) { | 317 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) { |
273 UseDomainData(test2::kDafsa); | 318 UseDomainData(test2::kDafsa); |
274 | 319 |
275 EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html", | 320 EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html", |
276 "http://a.b.bar.jp/file.html")); // b.bar.jp | 321 "http://a.b.bar.jp/file.html")); // b.bar.jp |
277 EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html", | 322 EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html", |
278 "http://b.b.bar.jp/file.html")); // b.bar.jp | 323 "http://b.b.bar.jp/file.html")); // b.bar.jp |
279 EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html", // foo.jp | 324 EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html", // foo.jp |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
381 const char key0[] = | 426 const char key0[] = |
382 "a.b.6____________________________________________________" | 427 "a.b.6____________________________________________________" |
383 "________________________________________________6"; | 428 "________________________________________________6"; |
384 const char key1[] = | 429 const char key1[] = |
385 "a.b.7____________________________________________________" | 430 "a.b.7____________________________________________________" |
386 "________________________________________________7"; | 431 "________________________________________________7"; |
387 const char key2[] = | 432 const char key2[] = |
388 "a.b.a____________________________________________________" | 433 "a.b.a____________________________________________________" |
389 "________________________________________________8"; | 434 "________________________________________________8"; |
390 | 435 |
391 EXPECT_EQ(102U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES)); | |
392 EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES)); | |
393 EXPECT_EQ(102U, | 436 EXPECT_EQ(102U, |
394 GetRegistryLengthFromHostIncludingPrivate( | 437 GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES)); |
395 key1, EXCLUDE_UNKNOWN_REGISTRIES)); | 438 EXPECT_EQ(0U, |
396 EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES)); | 439 GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES)); |
| 440 EXPECT_EQ(102U, GetCanonicalHostRegistryLengthIncludingPrivate(key1)); |
| 441 EXPECT_EQ(0U, |
| 442 GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES)); |
397 } | 443 } |
398 | 444 |
399 TEST_F(RegistryControlledDomainTest, TestDafsaThreeByteOffsets) { | 445 TEST_F(RegistryControlledDomainTest, TestDafsaThreeByteOffsets) { |
400 UseDomainData(test4::kDafsa); | 446 UseDomainData(test4::kDafsa); |
401 | 447 |
402 // Testing to lookup keys in a DAFSA with three byte offsets. | 448 // Testing to lookup keys in a DAFSA with three byte offsets. |
403 // This DAFSA is constructed so that labels begin and end with unique | 449 // This DAFSA is constructed so that labels begin and end with unique |
404 // characters, which makes it impossible to merge labels. The byte array | 450 // characters, which makes it impossible to merge labels. The byte array |
405 // has a size of ~54k. A two byte offset can add at most add 8k to the | 451 // has a size of ~54k. A two byte offset can add at most add 8k to the |
406 // previous offset. Since we can skip only forward in memory, the nodes | 452 // previous offset. Since we can skip only forward in memory, the nodes |
407 // representing the return values must be located near the end of the byte | 453 // representing the return values must be located near the end of the byte |
408 // array. The probability that we can reach from an arbitrary inner node to | 454 // array. The probability that we can reach from an arbitrary inner node to |
409 // a return value without using a three byte offset is small (but not zero). | 455 // a return value without using a three byte offset is small (but not zero). |
410 // The test is repeated with some different keys and with a reasonable | 456 // The test is repeated with some different keys and with a reasonable |
411 // probability at least one of the tested paths has go over a three byte | 457 // probability at least one of the tested paths has go over a three byte |
412 // offset. | 458 // offset. |
413 | 459 |
414 const char key0[] = | 460 const char key0[] = |
415 "a.b.Z6___________________________________________________" | 461 "a.b.z6___________________________________________________" |
416 "_________________________________________________Z6"; | 462 "_________________________________________________z6"; |
417 const char key1[] = | 463 const char key1[] = |
418 "a.b.Z7___________________________________________________" | 464 "a.b.z7___________________________________________________" |
419 "_________________________________________________Z7"; | 465 "_________________________________________________z7"; |
420 const char key2[] = | 466 const char key2[] = |
421 "a.b.Za___________________________________________________" | 467 "a.b.za___________________________________________________" |
422 "_________________________________________________Z8"; | 468 "_________________________________________________z8"; |
423 | 469 |
424 EXPECT_EQ(104U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES)); | |
425 EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES)); | |
426 EXPECT_EQ(104U, | 470 EXPECT_EQ(104U, |
427 GetRegistryLengthFromHostIncludingPrivate( | 471 GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES)); |
428 key1, EXCLUDE_UNKNOWN_REGISTRIES)); | 472 EXPECT_EQ(0U, |
429 EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES)); | 473 GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES)); |
| 474 EXPECT_EQ(104U, GetCanonicalHostRegistryLengthIncludingPrivate(key1)); |
| 475 EXPECT_EQ(0U, |
| 476 GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES)); |
430 } | 477 } |
431 | 478 |
432 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedPrefixes) { | 479 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedPrefixes) { |
433 UseDomainData(test5::kDafsa); | 480 UseDomainData(test5::kDafsa); |
434 | 481 |
435 // Testing to lookup keys in a DAFSA with compressed prefixes. | 482 // Testing to lookup keys in a DAFSA with compressed prefixes. |
436 // This DAFSA is constructed from words with similar prefixes but distinct | 483 // This DAFSA is constructed from words with similar prefixes but distinct |
437 // suffixes. The DAFSA will then form a trie with the implicit source node | 484 // suffixes. The DAFSA will then form a trie with the implicit source node |
438 // as root. | 485 // as root. |
439 | 486 |
440 const char key0[] = "a.b.ai"; | 487 const char key0[] = "a.b.ai"; |
441 const char key1[] = "a.b.bj"; | 488 const char key1[] = "a.b.bj"; |
442 const char key2[] = "a.b.aak"; | 489 const char key2[] = "a.b.aak"; |
443 const char key3[] = "a.b.bbl"; | 490 const char key3[] = "a.b.bbl"; |
444 const char key4[] = "a.b.aaa"; | 491 const char key4[] = "a.b.aaa"; |
445 const char key5[] = "a.b.bbb"; | 492 const char key5[] = "a.b.bbb"; |
446 const char key6[] = "a.b.aaaam"; | 493 const char key6[] = "a.b.aaaam"; |
447 const char key7[] = "a.b.bbbbn"; | 494 const char key7[] = "a.b.bbbbn"; |
448 | 495 |
449 EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES)); | |
450 EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES)); | |
451 EXPECT_EQ(2U, | 496 EXPECT_EQ(2U, |
452 GetRegistryLengthFromHostIncludingPrivate( | 497 GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES)); |
453 key1, EXCLUDE_UNKNOWN_REGISTRIES)); | 498 EXPECT_EQ(0U, |
454 EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES)); | 499 GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES)); |
455 EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES)); | 500 EXPECT_EQ(2U, GetCanonicalHostRegistryLengthIncludingPrivate(key1)); |
456 EXPECT_EQ(3U, | 501 EXPECT_EQ(3U, |
457 GetRegistryLengthFromHostIncludingPrivate( | 502 GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES)); |
458 key3, EXCLUDE_UNKNOWN_REGISTRIES)); | |
459 EXPECT_EQ(0U, | 503 EXPECT_EQ(0U, |
460 GetRegistryLengthFromHostIncludingPrivate( | 504 GetCanonicalHostRegistryLength(key3, EXCLUDE_UNKNOWN_REGISTRIES)); |
461 key4, EXCLUDE_UNKNOWN_REGISTRIES)); | 505 EXPECT_EQ(3U, GetCanonicalHostRegistryLengthIncludingPrivate(key3)); |
462 EXPECT_EQ(0U, | 506 EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key4)); |
463 GetRegistryLengthFromHostIncludingPrivate( | 507 EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key5)); |
464 key5, EXCLUDE_UNKNOWN_REGISTRIES)); | 508 EXPECT_EQ(5U, |
465 EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES)); | 509 GetCanonicalHostRegistryLength(key6, EXCLUDE_UNKNOWN_REGISTRIES)); |
466 EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES)); | 510 EXPECT_EQ(5U, |
| 511 GetCanonicalHostRegistryLength(key7, EXCLUDE_UNKNOWN_REGISTRIES)); |
467 } | 512 } |
468 | 513 |
469 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedSuffixes) { | 514 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedSuffixes) { |
470 UseDomainData(test6::kDafsa); | 515 UseDomainData(test6::kDafsa); |
471 | 516 |
472 // Testing to lookup keys in a DAFSA with compressed suffixes. | 517 // Testing to lookup keys in a DAFSA with compressed suffixes. |
473 // This DAFSA is constructed from words with similar suffixes but distinct | 518 // This DAFSA is constructed from words with similar suffixes but distinct |
474 // prefixes. The DAFSA will then form a trie with the implicit sink node as | 519 // prefixes. The DAFSA will then form a trie with the implicit sink node as |
475 // root. | 520 // root. |
476 | 521 |
477 const char key0[] = "a.b.ia"; | 522 const char key0[] = "a.b.ia"; |
478 const char key1[] = "a.b.jb"; | 523 const char key1[] = "a.b.jb"; |
479 const char key2[] = "a.b.kaa"; | 524 const char key2[] = "a.b.kaa"; |
480 const char key3[] = "a.b.lbb"; | 525 const char key3[] = "a.b.lbb"; |
481 const char key4[] = "a.b.aaa"; | 526 const char key4[] = "a.b.aaa"; |
482 const char key5[] = "a.b.bbb"; | 527 const char key5[] = "a.b.bbb"; |
483 const char key6[] = "a.b.maaaa"; | 528 const char key6[] = "a.b.maaaa"; |
484 const char key7[] = "a.b.nbbbb"; | 529 const char key7[] = "a.b.nbbbb"; |
485 | 530 |
486 EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES)); | |
487 EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES)); | |
488 EXPECT_EQ(2U, | 531 EXPECT_EQ(2U, |
489 GetRegistryLengthFromHostIncludingPrivate( | 532 GetCanonicalHostRegistryLength(key0, EXCLUDE_UNKNOWN_REGISTRIES)); |
490 key1, EXCLUDE_UNKNOWN_REGISTRIES)); | 533 EXPECT_EQ(0U, |
491 EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES)); | 534 GetCanonicalHostRegistryLength(key1, EXCLUDE_UNKNOWN_REGISTRIES)); |
492 EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES)); | 535 EXPECT_EQ(2U, GetCanonicalHostRegistryLengthIncludingPrivate(key1)); |
493 EXPECT_EQ(3U, | 536 EXPECT_EQ(3U, |
494 GetRegistryLengthFromHostIncludingPrivate( | 537 GetCanonicalHostRegistryLength(key2, EXCLUDE_UNKNOWN_REGISTRIES)); |
495 key3, EXCLUDE_UNKNOWN_REGISTRIES)); | |
496 EXPECT_EQ(0U, | 538 EXPECT_EQ(0U, |
497 GetRegistryLengthFromHostIncludingPrivate( | 539 GetCanonicalHostRegistryLength(key3, EXCLUDE_UNKNOWN_REGISTRIES)); |
498 key4, EXCLUDE_UNKNOWN_REGISTRIES)); | 540 EXPECT_EQ(3U, GetCanonicalHostRegistryLengthIncludingPrivate(key3)); |
499 EXPECT_EQ(0U, | 541 EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key4)); |
500 GetRegistryLengthFromHostIncludingPrivate( | 542 EXPECT_EQ(0U, GetCanonicalHostRegistryLengthIncludingPrivate(key5)); |
501 key5, EXCLUDE_UNKNOWN_REGISTRIES)); | 543 EXPECT_EQ(5U, |
502 EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES)); | 544 GetCanonicalHostRegistryLength(key6, EXCLUDE_UNKNOWN_REGISTRIES)); |
503 EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES)); | 545 EXPECT_EQ(5U, |
| 546 GetCanonicalHostRegistryLength(key7, EXCLUDE_UNKNOWN_REGISTRIES)); |
504 } | 547 } |
| 548 |
| 549 TEST_F(RegistryControlledDomainTest, Permissive) { |
| 550 UseDomainData(test1::kDafsa); |
| 551 |
| 552 EXPECT_EQ(std::string::npos, PermissiveGetHostRegistryLength("")); |
| 553 |
| 554 // Regular non-canonical host name. |
| 555 EXPECT_EQ(2U, PermissiveGetHostRegistryLength("Www.Google.Jp")); |
| 556 EXPECT_EQ(3U, PermissiveGetHostRegistryLength("Www.Google.Jp.")); |
| 557 |
| 558 // Empty returns npos. |
| 559 EXPECT_EQ(std::string::npos, PermissiveGetHostRegistryLength("")); |
| 560 |
| 561 // Trailing spaces are counted as part of the hostname, meaning this will |
| 562 // not match a known registry. |
| 563 EXPECT_EQ(0U, PermissiveGetHostRegistryLength("Www.Google.Jp ")); |
| 564 |
| 565 // Invalid characters at the beginning are OK if the suffix still matches. |
| 566 EXPECT_EQ(2U, PermissiveGetHostRegistryLength("*%00#?.Jp")); |
| 567 |
| 568 // IDN cases. |
| 569 EXPECT_EQ(10U, PermissiveGetHostRegistryLength("foo.xn--fiqs8s")); |
| 570 EXPECT_EQ(11U, PermissiveGetHostRegistryLength("foo.xn--fiqs8s.")); |
| 571 EXPECT_EQ(18U, PermissiveGetHostRegistryLength("foo.%E4%B8%AD%E5%9B%BD")); |
| 572 EXPECT_EQ(19U, PermissiveGetHostRegistryLength("foo.%E4%B8%AD%E5%9B%BD.")); |
| 573 EXPECT_EQ(6U, |
| 574 PermissiveGetHostRegistryLength("foo.\xE4\xB8\xAD\xE5\x9B\xBD")); |
| 575 EXPECT_EQ(7U, |
| 576 PermissiveGetHostRegistryLength("foo.\xE4\xB8\xAD\xE5\x9B\xBD.")); |
| 577 // UTF-16 IDN. |
| 578 EXPECT_EQ(2U, PermissiveGetHostRegistryLength( |
| 579 base::WideToUTF16(L"foo.\x4e2d\x56fd"))); |
| 580 |
| 581 // Escaped period, this will add new components. |
| 582 EXPECT_EQ(4U, PermissiveGetHostRegistryLength("Www.Googl%45%2e%4Ap")); |
| 583 |
| 584 // Fullwidth dot (u+FF0E) that will get canonicalized to a dot. |
| 585 EXPECT_EQ(2U, PermissiveGetHostRegistryLength("Www.Google\xEF\xBC\x8Ejp")); |
| 586 // Same but also ending in a fullwidth dot. |
| 587 EXPECT_EQ(5U, PermissiveGetHostRegistryLength( |
| 588 "Www.Google\xEF\xBC\x8Ejp\xEF\xBC\x8E")); |
| 589 // Escaped UTF-8, also with an escaped fullwidth "Jp". |
| 590 // "Jp" = U+FF2A, U+FF50, UTF-8 = EF BC AA EF BD 90 |
| 591 EXPECT_EQ(27U, PermissiveGetHostRegistryLength( |
| 592 "Www.Google%EF%BC%8E%EF%BC%AA%EF%BD%90%EF%BC%8E")); |
| 593 // UTF-16 (ending in a dot). |
| 594 EXPECT_EQ(3U, PermissiveGetHostRegistryLength( |
| 595 base::WideToUTF16(L"Www.Google\xFF0E\xFF2A\xFF50\xFF0E"))); |
| 596 } |
| 597 |
505 } // namespace registry_controlled_domains | 598 } // namespace registry_controlled_domains |
506 } // namespace net | 599 } // namespace net |
OLD | NEW |