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("", EXCLUDE_UNKNOWN_REGISTRIES, | |
Peter Kasting
2016/10/25 01:33:32
Nit: "" -> std::string() (general Chromium pattern
| |
294 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 |