flags_test_helpers.cc | Explore in Territory

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

#include "components/flags_ui/flags_test_helpers.h"

#include <gtest/gtest.h>

#include <map>
#include <string>
#include <string_view>
#include <vector>

#include "base/base_paths.h"
#include "base/containers/contains.h"
#include "base/files/file_path.h"
#include "base/json/json_file_value_serializer.h"
#include "base/path_service.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/values.h"
#include "components/flags_ui/feature_entry.h"
#include "components/flags_ui/flags_state.h"

namespace {

constexpr char kMetadataFileName[] = …;
constexpr char kNeverExpireFileName[] = …;

// Returns the file contents of a named file under $SRC/chrome/browser
// interpreted as a JSON value.
base::Value ReadFileContentsAsJSON(const std::string& filename) { … }

// Data structure capturing the metadata of the flag.
struct FlagMetadataEntry { … };

// Lookup of metadata by flag name.
FlagMetadataMap;

// Reads the flag metadata file.
FlagMetadataMap LoadFlagMetadata() { … }

std::vector<std::string> LoadFlagNeverExpireList() { … }

bool IsValidLookingOwner(std::string_view owner) { … }

std::string NormalizeName(const std::string& name) { … }

constexpr char kStartSentinel[] = …;

NameNameMap;
NameVector;

// Given a NameVector, returns a map from each name n to the name preceding n in
// the NameVector. The returned map maps the first name to kStartSentinel.
// Preconditions:
//   * There are no duplicates in |strings|
//   * No entry in |strings| equals kStartSentinel
// Postconditions:
//   * Every entry in |strings| appears as a key in the result map
//   * Every entry in |strings| maps to another entry in |strings| or to
//     kStartSentinel in the result map
NameNameMap BuildAfterMap(const NameVector& strings) { … }

// Given a vector of names, returns a vector of normalized names, and an inverse
// mapping from normalized name to previous name. The inverse mapping is
// populated only for names which were altered when normalized.
// Preconditions: none
// Postconditions:
//   * Every (key, value) pair in |denormalized| have key != value
//   * Every (key, value) pair in |denormalized| have key = NormalizeName(value)
std::pair<NameVector, NameNameMap> NormalizeNames(const NameVector& names) { … }

// Given a list of flag names, adds test failures for any that do not appear in
// alphabetical order. This is more complex than simply sorting the list and
// checking whether the order changed - this function is supposed to emit error
// messages which tell the user specifically which flags need to be moved and to
// where in the file.
void EnsureNamesAreAlphabetical(const NameVector& names,
                                const std::string& filename) { … }

bool IsUnexpireFlagFor(const flags_ui::FeatureEntry& entry, int milestone) { … }

}  // namespace

namespace flags_ui {

namespace testing {

void EnsureEveryFlagHasMetadata(
    const base::span<const flags_ui::FeatureEntry>& entries) { … }

void EnsureOnlyPermittedFlagsNeverExpire() { … }

void EnsureEveryFlagHasNonEmptyOwners() { … }

void EnsureOwnersLookValid() { … }

void EnsureFlagsAreListedInAlphabeticalOrder() { … }

// TODO(crbug.com/40785799): Call this from the iOS flags unittests once
// flag expiration is supported there.
void EnsureRecentUnexpireFlagsArePresent(
    const base::span<const flags_ui::FeatureEntry>& entries,
    int current_milestone) { … }

}  // namespace testing

}  // namespace flags_ui
chromium/components/flags_ui/flags_test_helpers.cc
