src/net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc

   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/registry_controlled_domains/registry_controlled_domain.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7 #include "url/gurl.h"
   8
   9 namespace {
  10 namespace test1 {
  11 #include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc"
  12 }
  13 namespace test2 {
  14 #include "net/base/registry_controlled_domains/effective_tld_names_unittest2-inc.cc"
  15 }
  16 namespace test3 {
  17 #include "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc.cc"
  18 }
  19 namespace test4 {
  20 #include "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc.cc"
  21 }
  22 namespace test5 {
  23 #include "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc.cc"
  24 }
  25 namespace test6 {
  26 #include "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc.cc"
  27 }
  28 }  // namespace
  29
  30 namespace net {
  31 namespace registry_controlled_domains {
  32 namespace {
  33
  34 std::string GetDomainFromURL(const std::string& url) {
  35   return GetDomainAndRegistry(GURL(url), EXCLUDE_PRIVATE_REGISTRIES);
  36 }
  37
  38 std::string GetDomainFromHost(const std::string& host) {
  39   return GetDomainAndRegistry(host, EXCLUDE_PRIVATE_REGISTRIES);
  40 }
  41
  42 size_t GetRegistryLengthFromURL(
  43     const std::string& url,
  44     UnknownRegistryFilter unknown_filter) {
  45   return GetRegistryLength(GURL(url),
  46                            unknown_filter,
  47                            EXCLUDE_PRIVATE_REGISTRIES);
  48 }
  49
  50 size_t GetRegistryLengthFromURLIncludingPrivate(
  51     const std::string& url,
  52     UnknownRegistryFilter unknown_filter) {
  53   return GetRegistryLength(GURL(url),
  54                            unknown_filter,
  55                            INCLUDE_PRIVATE_REGISTRIES);
  56 }
  57
  58 size_t GetRegistryLengthFromHost(
  59     const std::string& host,
  60     UnknownRegistryFilter unknown_filter) {
  61   return GetRegistryLength(host, unknown_filter, EXCLUDE_PRIVATE_REGISTRIES);
  62 }
  63
  64 size_t GetRegistryLengthFromHostIncludingPrivate(
  65     const std::string& host,
  66     UnknownRegistryFilter unknown_filter) {
  67   return GetRegistryLength(host, unknown_filter, INCLUDE_PRIVATE_REGISTRIES);
  68 }
  69
  70 bool CompareDomains(const std::string& url1, const std::string& url2) {
  71   GURL g1 = GURL(url1);
  72   GURL g2 = GURL(url2);
  73   return SameDomainOrHost(g1, g2, EXCLUDE_PRIVATE_REGISTRIES);
  74 }
  75
  76 }  // namespace
  77
  78 class RegistryControlledDomainTest : public testing::Test {
  79  protected:
  80   template <typename Graph>
  81   void UseDomainData(const Graph& graph) {
  82     SetFindDomainGraph(graph, sizeof(Graph));
  83   }
  84
  85   void TearDown() override { SetFindDomainGraph(); }
  86 };
  87
  88 TEST_F(RegistryControlledDomainTest, TestGetDomainAndRegistry) {
  89   UseDomainData(test1::kDafsa);
  90
  91   // Test GURL version of GetDomainAndRegistry().
  92   EXPECT_EQ("baz.jp", GetDomainFromURL("http://a.baz.jp/file.html"));    // 1
  93   EXPECT_EQ("baz.jp.", GetDomainFromURL("http://a.baz.jp./file.html"));  // 1
  94   EXPECT_EQ("", GetDomainFromURL("http://ac.jp"));                       // 2
  95   EXPECT_EQ("", GetDomainFromURL("http://a.bar.jp"));                    // 3
  96   EXPECT_EQ("", GetDomainFromURL("http://bar.jp"));                      // 3
  97   EXPECT_EQ("", GetDomainFromURL("http://baz.bar.jp"));                  // 3 4
  98   EXPECT_EQ("a.b.baz.bar.jp", GetDomainFromURL("http://a.b.baz.bar.jp"));
  99                                                                          // 4
 100   EXPECT_EQ("pref.bar.jp", GetDomainFromURL("http://baz.pref.bar.jp"));  // 5
 101   EXPECT_EQ("b.bar.baz.com.", GetDomainFromURL("http://a.b.bar.baz.com."));
 102                                                                          // 6
 103   EXPECT_EQ("a.d.c", GetDomainFromURL("http://a.d.c"));                  // 7
 104   EXPECT_EQ("a.d.c", GetDomainFromURL("http://.a.d.c"));                 // 7
 105   EXPECT_EQ("a.d.c", GetDomainFromURL("http://..a.d.c"));                // 7
 106   EXPECT_EQ("b.c", GetDomainFromURL("http://a.b.c"));                    // 7 8
 107   EXPECT_EQ("baz.com", GetDomainFromURL("http://baz.com"));              // none
 108   EXPECT_EQ("baz.com.", GetDomainFromURL("http://baz.com."));            // none
 109
 110   EXPECT_EQ("", GetDomainFromURL(std::string()));
 111   EXPECT_EQ("", GetDomainFromURL("http://"));
 112   EXPECT_EQ("", GetDomainFromURL("file:///C:/file.html"));
 113   EXPECT_EQ("", GetDomainFromURL("http://foo.com.."));
 114   EXPECT_EQ("", GetDomainFromURL("http://..."));
 115   EXPECT_EQ("", GetDomainFromURL("http://192.168.0.1"));
 116   EXPECT_EQ("", GetDomainFromURL("http://localhost"));
 117   EXPECT_EQ("", GetDomainFromURL("http://localhost."));
 118   EXPECT_EQ("", GetDomainFromURL("http:////Comment"));
 119
 120   // Test std::string version of GetDomainAndRegistry().  Uses the same
 121   // underpinnings as the GURL version, so this is really more of a check of
 122   // CanonicalizeHost().
 123   EXPECT_EQ("baz.jp", GetDomainFromHost("a.baz.jp"));                  // 1
 124   EXPECT_EQ("baz.jp.", GetDomainFromHost("a.baz.jp."));                // 1
 125   EXPECT_EQ("", GetDomainFromHost("ac.jp"));                           // 2
 126   EXPECT_EQ("", GetDomainFromHost("a.bar.jp"));                        // 3
 127   EXPECT_EQ("", GetDomainFromHost("bar.jp"));                          // 3
 128   EXPECT_EQ("", GetDomainFromHost("baz.bar.jp"));                      // 3 4
 129   EXPECT_EQ("a.b.baz.bar.jp", GetDomainFromHost("a.b.baz.bar.jp"));    // 3 4
 130   EXPECT_EQ("pref.bar.jp", GetDomainFromHost("baz.pref.bar.jp"));      // 5
 131   EXPECT_EQ("b.bar.baz.com.", GetDomainFromHost("a.b.bar.baz.com."));  // 6
 132   EXPECT_EQ("a.d.c", GetDomainFromHost("a.d.c"));                      // 7
 133   EXPECT_EQ("a.d.c", GetDomainFromHost(".a.d.c"));                     // 7
 134   EXPECT_EQ("a.d.c", GetDomainFromHost("..a.d.c"));                    // 7
 135   EXPECT_EQ("b.c", GetDomainFromHost("a.b.c"));                        // 7 8
 136   EXPECT_EQ("baz.com", GetDomainFromHost("baz.com"));                  // none
 137   EXPECT_EQ("baz.com.", GetDomainFromHost("baz.com."));                // none
 138
 139   EXPECT_EQ("", GetDomainFromHost(std::string()));
 140   EXPECT_EQ("", GetDomainFromHost("foo.com.."));
 141   EXPECT_EQ("", GetDomainFromHost("..."));
 142   EXPECT_EQ("", GetDomainFromHost("192.168.0.1"));
 143   EXPECT_EQ("", GetDomainFromHost("localhost."));
 144   EXPECT_EQ("", GetDomainFromHost(".localhost."));
 145 }
 146
 147 TEST_F(RegistryControlledDomainTest, TestGetRegistryLength) {
 148   UseDomainData(test1::kDafsa);
 149
 150   // Test GURL version of GetRegistryLength().
 151   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://a.baz.jp/file.html",
 152                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 1
 153   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://a.baz.jp./file.html",
 154                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 1
 155   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://ac.jp",
 156                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 2
 157   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://a.bar.jp",
 158                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 3
 159   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://bar.jp",
 160                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 3
 161   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://baz.bar.jp",
 162                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 3 4
 163   EXPECT_EQ(12U, GetRegistryLengthFromURL("http://a.b.baz.bar.jp",
 164                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 4
 165   EXPECT_EQ(6U, GetRegistryLengthFromURL("http://baz.pref.bar.jp",
 166                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 5
 167   EXPECT_EQ(11U, GetRegistryLengthFromURL("http://a.b.bar.baz.com",
 168                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 6
 169   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://a.d.c",
 170                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 7
 171   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://.a.d.c",
 172                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 7
 173   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://..a.d.c",
 174                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 7
 175   EXPECT_EQ(1U, GetRegistryLengthFromURL("http://a.b.c",
 176                                          EXCLUDE_UNKNOWN_REGISTRIES)); // 7 8
 177   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://baz.com",
 178                                          EXCLUDE_UNKNOWN_REGISTRIES)); // none
 179   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://baz.com.",
 180                                          EXCLUDE_UNKNOWN_REGISTRIES)); // none
 181   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://baz.com",
 182                                          INCLUDE_UNKNOWN_REGISTRIES)); // none
 183   EXPECT_EQ(4U, GetRegistryLengthFromURL("http://baz.com.",
 184                                          INCLUDE_UNKNOWN_REGISTRIES)); // none
 185
 186   EXPECT_EQ(std::string::npos,
 187       GetRegistryLengthFromURL(std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
 188   EXPECT_EQ(std::string::npos,
 189       GetRegistryLengthFromURL("http://", EXCLUDE_UNKNOWN_REGISTRIES));
 190   EXPECT_EQ(std::string::npos,
 191       GetRegistryLengthFromURL("file:///C:/file.html",
 192                                EXCLUDE_UNKNOWN_REGISTRIES));
 193   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://foo.com..",
 194                                          EXCLUDE_UNKNOWN_REGISTRIES));
 195   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://...",
 196                                          EXCLUDE_UNKNOWN_REGISTRIES));
 197   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://192.168.0.1",
 198                                          EXCLUDE_UNKNOWN_REGISTRIES));
 199   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost",
 200                                          EXCLUDE_UNKNOWN_REGISTRIES));
 201   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost",
 202                                          INCLUDE_UNKNOWN_REGISTRIES));
 203   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
 204                                          EXCLUDE_UNKNOWN_REGISTRIES));
 205   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://localhost.",
 206                                          INCLUDE_UNKNOWN_REGISTRIES));
 207   EXPECT_EQ(0U, GetRegistryLengthFromURL("http:////Comment",
 208                                          EXCLUDE_UNKNOWN_REGISTRIES));
 209
 210   // Test std::string version of GetRegistryLength().  Uses the same
 211   // underpinnings as the GURL version, so this is really more of a check of
 212   // CanonicalizeHost().
 213   EXPECT_EQ(2U, GetRegistryLengthFromHost("a.baz.jp",
 214                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 1
 215   EXPECT_EQ(3U, GetRegistryLengthFromHost("a.baz.jp.",
 216                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 1
 217   EXPECT_EQ(0U, GetRegistryLengthFromHost("ac.jp",
 218                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 2
 219   EXPECT_EQ(0U, GetRegistryLengthFromHost("a.bar.jp",
 220                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 3
 221   EXPECT_EQ(0U, GetRegistryLengthFromHost("bar.jp",
 222                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 3
 223   EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.bar.jp",
 224                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 3 4
 225   EXPECT_EQ(12U, GetRegistryLengthFromHost("a.b.baz.bar.jp",
 226                                            EXCLUDE_UNKNOWN_REGISTRIES)); // 4
 227   EXPECT_EQ(6U, GetRegistryLengthFromHost("baz.pref.bar.jp",
 228                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 5
 229   EXPECT_EQ(11U, GetRegistryLengthFromHost("a.b.bar.baz.com",
 230                                            EXCLUDE_UNKNOWN_REGISTRIES)); // 6
 231   EXPECT_EQ(3U, GetRegistryLengthFromHost("a.d.c",
 232                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 7
 233   EXPECT_EQ(3U, GetRegistryLengthFromHost(".a.d.c",
 234                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 7
 235   EXPECT_EQ(3U, GetRegistryLengthFromHost("..a.d.c",
 236                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 7
 237   EXPECT_EQ(1U, GetRegistryLengthFromHost("a.b.c",
 238                                           EXCLUDE_UNKNOWN_REGISTRIES));  // 7 8
 239   EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com",
 240                                           EXCLUDE_UNKNOWN_REGISTRIES));  // none
 241   EXPECT_EQ(0U, GetRegistryLengthFromHost("baz.com.",
 242                                           EXCLUDE_UNKNOWN_REGISTRIES));  // none
 243   EXPECT_EQ(3U, GetRegistryLengthFromHost("baz.com",
 244                                           INCLUDE_UNKNOWN_REGISTRIES));  // none
 245   EXPECT_EQ(4U, GetRegistryLengthFromHost("baz.com.",
 246                                           INCLUDE_UNKNOWN_REGISTRIES));  // none
 247
 248   EXPECT_EQ(std::string::npos,
 249       GetRegistryLengthFromHost(std::string(), EXCLUDE_UNKNOWN_REGISTRIES));
 250   EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..",
 251                                           EXCLUDE_UNKNOWN_REGISTRIES));
 252   EXPECT_EQ(0U, GetRegistryLengthFromHost("..",
 253                                           EXCLUDE_UNKNOWN_REGISTRIES));
 254   EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1",
 255                                           EXCLUDE_UNKNOWN_REGISTRIES));
 256   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
 257                                           EXCLUDE_UNKNOWN_REGISTRIES));
 258   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost",
 259                                           INCLUDE_UNKNOWN_REGISTRIES));
 260   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
 261                                           EXCLUDE_UNKNOWN_REGISTRIES));
 262   EXPECT_EQ(0U, GetRegistryLengthFromHost("localhost.",
 263                                           INCLUDE_UNKNOWN_REGISTRIES));
 264 }
 265
 266 TEST_F(RegistryControlledDomainTest, TestSameDomainOrHost) {
 267   UseDomainData(test2::kDafsa);
 268
 269   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
 270                              "http://a.b.bar.jp/file.html"));  // b.bar.jp
 271   EXPECT_TRUE(CompareDomains("http://a.b.bar.jp/file.html",
 272                              "http://b.b.bar.jp/file.html"));  // b.bar.jp
 273   EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",     // foo.jp
 274                               "http://a.not.jp/file.html"));   // not.jp
 275   EXPECT_FALSE(CompareDomains("http://a.foo.jp/file.html",     // foo.jp
 276                               "http://a.foo.jp./file.html"));  // foo.jp.
 277   EXPECT_FALSE(CompareDomains("http://a.com/file.html",        // a.com
 278                               "http://b.com/file.html"));      // b.com
 279   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
 280                              "http://b.x.com/file.html"));     // x.com
 281   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
 282                              "http://.x.com/file.html"));      // x.com
 283   EXPECT_TRUE(CompareDomains("http://a.x.com/file.html",
 284                              "http://..b.x.com/file.html"));   // x.com
 285   EXPECT_TRUE(CompareDomains("http://intranet/file.html",
 286                              "http://intranet/file.html"));    // intranet
 287   EXPECT_TRUE(CompareDomains("http://127.0.0.1/file.html",
 288                              "http://127.0.0.1/file.html"));   // 127.0.0.1
 289   EXPECT_FALSE(CompareDomains("http://192.168.0.1/file.html",  // 192.168.0.1
 290                               "http://127.0.0.1/file.html"));  // 127.0.0.1
 291   EXPECT_FALSE(CompareDomains("file:///C:/file.html",
 292                               "file:///C:/file.html"));        // no host
 293 }
 294
 295 TEST_F(RegistryControlledDomainTest, TestDefaultData) {
 296   // Note that no data is set: we're using the default rules.
 297   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://google.com",
 298                                          EXCLUDE_UNKNOWN_REGISTRIES));
 299   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://stanford.edu",
 300                                          EXCLUDE_UNKNOWN_REGISTRIES));
 301   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://ustreas.gov",
 302                                          EXCLUDE_UNKNOWN_REGISTRIES));
 303   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://icann.net",
 304                                          EXCLUDE_UNKNOWN_REGISTRIES));
 305   EXPECT_EQ(3U, GetRegistryLengthFromURL("http://ferretcentral.org",
 306                                          EXCLUDE_UNKNOWN_REGISTRIES));
 307   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://nowhere.notavaliddomain",
 308                                          EXCLUDE_UNKNOWN_REGISTRIES));
 309   EXPECT_EQ(15U, GetRegistryLengthFromURL("http://nowhere.notavaliddomain",
 310                                          INCLUDE_UNKNOWN_REGISTRIES));
 311 }
 312
 313 TEST_F(RegistryControlledDomainTest, TestPrivateRegistryHandling) {
 314   UseDomainData(test1::kDafsa);
 315
 316   // Testing the same dataset for INCLUDE_PRIVATE_REGISTRIES and
 317   // EXCLUDE_PRIVATE_REGISTRIES arguments.
 318   // For the domain data used for this test, the private registries are
 319   // 'priv.no' and 'private'.
 320
 321   // Non-private registries.
 322   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://priv.no",
 323                                          EXCLUDE_UNKNOWN_REGISTRIES));
 324   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://foo.priv.no",
 325                                          EXCLUDE_UNKNOWN_REGISTRIES));
 326   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://foo.jp",
 327                                          EXCLUDE_UNKNOWN_REGISTRIES));
 328   EXPECT_EQ(2U, GetRegistryLengthFromURL("http://www.foo.jp",
 329                                          EXCLUDE_UNKNOWN_REGISTRIES));
 330   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://private",
 331                                          EXCLUDE_UNKNOWN_REGISTRIES));
 332   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://foo.private",
 333                                          EXCLUDE_UNKNOWN_REGISTRIES));
 334   EXPECT_EQ(0U, GetRegistryLengthFromURL("http://private",
 335                                          INCLUDE_UNKNOWN_REGISTRIES));
 336   EXPECT_EQ(7U, GetRegistryLengthFromURL("http://foo.private",
 337                                          INCLUDE_UNKNOWN_REGISTRIES));
 338
 339   // Private registries.
 340   EXPECT_EQ(0U,
 341       GetRegistryLengthFromURLIncludingPrivate("http://priv.no",
 342                                                EXCLUDE_UNKNOWN_REGISTRIES));
 343   EXPECT_EQ(7U,
 344       GetRegistryLengthFromURLIncludingPrivate("http://foo.priv.no",
 345                                                EXCLUDE_UNKNOWN_REGISTRIES));
 346   EXPECT_EQ(2U,
 347       GetRegistryLengthFromURLIncludingPrivate("http://foo.jp",
 348                                                EXCLUDE_UNKNOWN_REGISTRIES));
 349   EXPECT_EQ(2U,
 350       GetRegistryLengthFromURLIncludingPrivate("http://www.foo.jp",
 351                                                EXCLUDE_UNKNOWN_REGISTRIES));
 352   EXPECT_EQ(0U,
 353       GetRegistryLengthFromURLIncludingPrivate("http://private",
 354                                                EXCLUDE_UNKNOWN_REGISTRIES));
 355   EXPECT_EQ(7U,
 356       GetRegistryLengthFromURLIncludingPrivate("http://foo.private",
 357                                                EXCLUDE_UNKNOWN_REGISTRIES));
 358   EXPECT_EQ(0U,
 359       GetRegistryLengthFromURLIncludingPrivate("http://private",
 360                                                INCLUDE_UNKNOWN_REGISTRIES));
 361   EXPECT_EQ(7U,
 362       GetRegistryLengthFromURLIncludingPrivate("http://foo.private",
 363                                                INCLUDE_UNKNOWN_REGISTRIES));
 364 }
 365
 366 TEST_F(RegistryControlledDomainTest, TestDafsaTwoByteOffsets) {
 367   UseDomainData(test3::kDafsa);
 368
 369   // Testing to lookup keys in a DAFSA with two byte offsets.
 370   // This DAFSA is constructed so that labels begin and end with unique
 371   // characters, which makes it impossible to merge labels. Each inner node
 372   // is about 100 bytes and a one byte offset can at most add 64 bytes to
 373   // previous offset. Thus the paths must go over two byte offsets.
 374
 375   const char* key0 =
 376       "a.b.6____________________________________________________"
 377       "________________________________________________6";
 378   const char* key1 =
 379       "a.b.7____________________________________________________"
 380       "________________________________________________7";
 381   const char* key2 =
 382       "a.b.a____________________________________________________"
 383       "________________________________________________8";
 384
 385   EXPECT_EQ(102U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
 386   EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
 387   EXPECT_EQ(102U,
 388             GetRegistryLengthFromHostIncludingPrivate(
 389                 key1, EXCLUDE_UNKNOWN_REGISTRIES));
 390   EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 391 }
 392
 393 TEST_F(RegistryControlledDomainTest, TestDafsaThreeByteOffsets) {
 394   UseDomainData(test4::kDafsa);
 395
 396   // Testing to lookup keys in a DAFSA with three byte offsets.
 397   // This DAFSA is constructed so that labels begin and end with unique
 398   // characters, which makes it impossible to merge labels. The byte array
 399   // has a size of ~54k. A two byte offset can add at most add 8k to the
 400   // previous offset. Since we can skip only forward in memory, the nodes
 401   // representing the return values must be located near the end of the byte
 402   // array. The probability that we can reach from an arbitrary inner node to
 403   // a return value without using a three byte offset is small (but not zero).
 404   // The test is repeated with some different keys and with a reasonable
 405   // probability at least one of the tested paths has go over a three byte
 406   // offset.
 407
 408   const char* key0 =
 409       "a.b.Z6___________________________________________________"
 410       "_________________________________________________Z6";
 411   const char* key1 =
 412       "a.b.Z7___________________________________________________"
 413       "_________________________________________________Z7";
 414   const char* key2 =
 415       "a.b.Za___________________________________________________"
 416       "_________________________________________________Z8";
 417
 418   EXPECT_EQ(104U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
 419   EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
 420   EXPECT_EQ(104U,
 421             GetRegistryLengthFromHostIncludingPrivate(
 422                 key1, EXCLUDE_UNKNOWN_REGISTRIES));
 423   EXPECT_EQ(0U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 424 }
 425
 426 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedPrefixes) {
 427   UseDomainData(test5::kDafsa);
 428
 429   // Testing to lookup keys in a DAFSA with compressed prefixes.
 430   // This DAFSA is constructed from words with similar prefixes but distinct
 431   // suffixes. The DAFSA will then form a trie with the implicit source node
 432   // as root.
 433
 434   const char* key0 = "a.b.ai";
 435   const char* key1 = "a.b.bj";
 436   const char* key2 = "a.b.aak";
 437   const char* key3 = "a.b.bbl";
 438   const char* key4 = "a.b.aaa";
 439   const char* key5 = "a.b.bbb";
 440   const char* key6 = "a.b.aaaam";
 441   const char* key7 = "a.b.bbbbn";
 442
 443   EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
 444   EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
 445   EXPECT_EQ(2U,
 446             GetRegistryLengthFromHostIncludingPrivate(
 447                 key1, EXCLUDE_UNKNOWN_REGISTRIES));
 448   EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 449   EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
 450   EXPECT_EQ(3U,
 451             GetRegistryLengthFromHostIncludingPrivate(
 452                 key3, EXCLUDE_UNKNOWN_REGISTRIES));
 453   EXPECT_EQ(0U,
 454             GetRegistryLengthFromHostIncludingPrivate(
 455                 key4, EXCLUDE_UNKNOWN_REGISTRIES));
 456   EXPECT_EQ(0U,
 457             GetRegistryLengthFromHostIncludingPrivate(
 458                 key5, EXCLUDE_UNKNOWN_REGISTRIES));
 459   EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
 460   EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 461 }
 462
 463 TEST_F(RegistryControlledDomainTest, TestDafsaJoinedSuffixes) {
 464   UseDomainData(test6::kDafsa);
 465
 466   // Testing to lookup keys in a DAFSA with compressed suffixes.
 467   // This DAFSA is constructed from words with similar suffixes but distinct
 468   // prefixes. The DAFSA will then form a trie with the implicit sink node as
 469   // root.
 470
 471   const char* key0 = "a.b.ia";
 472   const char* key1 = "a.b.jb";
 473   const char* key2 = "a.b.kaa";
 474   const char* key3 = "a.b.lbb";
 475   const char* key4 = "a.b.aaa";
 476   const char* key5 = "a.b.bbb";
 477   const char* key6 = "a.b.maaaa";
 478   const char* key7 = "a.b.nbbbb";
 479
 480   EXPECT_EQ(2U, GetRegistryLengthFromHost(key0, EXCLUDE_UNKNOWN_REGISTRIES));
 481   EXPECT_EQ(0U, GetRegistryLengthFromHost(key1, EXCLUDE_UNKNOWN_REGISTRIES));
 482   EXPECT_EQ(2U,
 483             GetRegistryLengthFromHostIncludingPrivate(
 484                 key1, EXCLUDE_UNKNOWN_REGISTRIES));
 485   EXPECT_EQ(3U, GetRegistryLengthFromHost(key2, EXCLUDE_UNKNOWN_REGISTRIES));
 486   EXPECT_EQ(0U, GetRegistryLengthFromHost(key3, EXCLUDE_UNKNOWN_REGISTRIES));
 487   EXPECT_EQ(3U,
 488             GetRegistryLengthFromHostIncludingPrivate(
 489                 key3, EXCLUDE_UNKNOWN_REGISTRIES));
 490   EXPECT_EQ(0U,
 491             GetRegistryLengthFromHostIncludingPrivate(
 492                 key4, EXCLUDE_UNKNOWN_REGISTRIES));
 493   EXPECT_EQ(0U,
 494             GetRegistryLengthFromHostIncludingPrivate(
 495                 key5, EXCLUDE_UNKNOWN_REGISTRIES));
 496   EXPECT_EQ(5U, GetRegistryLengthFromHost(key6, EXCLUDE_UNKNOWN_REGISTRIES));
 497   EXPECT_EQ(5U, GetRegistryLengthFromHost(key7, EXCLUDE_UNKNOWN_REGISTRIES));
 498 }
 499 }  // namespace registry_controlled_domains
 500 }  // namespace net