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