chromium/net/base/lookup_string_in_fixed_set_unittest.cc

// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/base/lookup_string_in_fixed_set.h"

#include <string.h>

#include <algorithm>
#include <cstdint>
#include <limits>
#include <ostream>
#include <utility>
#include <vector>

#include "base/base_paths.h"
#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/path_service.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace net {
namespace {
namespace test1 {
#include "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc"
}
namespace test3 {
#include "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc.cc"
}
namespace test4 {
#include "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc.cc"
}
namespace test5 {
#include "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc.cc"
}
namespace test6 {
#include "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc.cc"
}

struct Expectation { … };

void PrintTo(const Expectation& expectation, std::ostream* os) { … }

class LookupStringInFixedSetTest : public testing::TestWithParam<Expectation> { … };

class Dafsa1Test : public LookupStringInFixedSetTest { … };

TEST_P(Dafsa1Test, BasicTest) { … }

const Expectation kBasicTestCases[] = …;

// Helper function for EnumerateDafsaLanaguage.
void RecursivelyEnumerateDafsaLanguage(const FixedSetIncrementalLookup& lookup,
                                       std::vector<char>* sequence,
                                       std::vector<std::string>* language) { … }

// Uses FixedSetIncrementalLookup to build a vector of every string in the
// language of the DAFSA.
std::vector<std::string> EnumerateDafsaLanguage(
    base::span<const uint8_t> graph) { … }

INSTANTIATE_TEST_SUITE_P(…);

class Dafsa3Test : public LookupStringInFixedSetTest { … };

// This DAFSA is constructed so that labels begin and end with unique
// characters, which makes it impossible to merge labels. Each inner node
// is about 100 bytes and a one byte offset can at most add 64 bytes to
// previous offset. Thus the paths must go over two byte offsets.
TEST_P(Dafsa3Test, TestDafsaTwoByteOffsets) { … }

const Expectation kTwoByteOffsetTestCases[] = …;

INSTANTIATE_TEST_SUITE_P(…);

class Dafsa4Test : public LookupStringInFixedSetTest { … };

// This DAFSA is constructed so that labels begin and end with unique
// characters, which makes it impossible to merge labels. The byte array
// has a size of ~54k. A two byte offset can add at most add 8k to the
// previous offset. Since we can skip only forward in memory, the nodes
// representing the return values must be located near the end of the byte
// array. The probability that we can reach from an arbitrary inner node to
// a return value without using a three byte offset is small (but not zero).
// The test is repeated with some different keys and with a reasonable
// probability at least one of the tested paths has go over a three byte
// offset.
TEST_P(Dafsa4Test, TestDafsaThreeByteOffsets) { … }

const Expectation kThreeByteOffsetTestCases[] = …;

INSTANTIATE_TEST_SUITE_P(…);

class Dafsa5Test : public LookupStringInFixedSetTest { … };

// This DAFSA is constructed from words with similar prefixes but distinct
// suffixes. The DAFSA will then form a trie with the implicit source node
// as root.
TEST_P(Dafsa5Test, TestDafsaJoinedPrefixes) { … }

const Expectation kJoinedPrefixesTestCases[] = …;

INSTANTIATE_TEST_SUITE_P(…);

class Dafsa6Test : public LookupStringInFixedSetTest { … };

// This DAFSA is constructed from words with similar suffixes but distinct
// prefixes. The DAFSA will then form a trie with the implicit sink node as
// root.
TEST_P(Dafsa6Test, TestDafsaJoinedSuffixes) { … }

const Expectation kJoinedSuffixesTestCases[] = …;

INSTANTIATE_TEST_SUITE_P(…);

// Validates that the generated DAFSA contains exactly the same information as
// effective_tld_names_unittest1.gperf.
TEST(LookupStringInFixedSetTest, Dafsa1EnumerateLanguage) { … }

// Validates that the generated DAFSA contains exactly the same information as
// effective_tld_names_unittest5.gperf.
TEST(LookupStringInFixedSetTest, Dafsa5EnumerateLanguage) { … }

// Validates that the generated DAFSA contains exactly the same information as
// effective_tld_names_unittest6.gperf.
TEST(LookupStringInFixedSetTest, Dafsa6EnumerateLanguage) { … }

}  // namespace
}  // namespace net