chromium/third_party/abseil-cpp/absl/container/internal/hash_generator_testing.h

// Copyright 2018 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Generates random values for testing. Specialized only for the few types we
// care about.

#ifndef ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
#define ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_

#include <stdint.h>

#include <algorithm>
#include <cassert>
#include <iosfwd>
#include <random>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

#include "absl/container/internal/hash_policy_testing.h"
#include "absl/memory/memory.h"
#include "absl/meta/type_traits.h"
#include "absl/strings/string_view.h"

namespace absl {
ABSL_NAMESPACE_BEGIN
namespace container_internal {
namespace hash_internal {
namespace generator_internal {

template <class Container, class = void>
struct IsMap : std::false_type { … };

IsMap<Map, absl::void_t<typename Map::mapped_type>>;

}  // namespace generator_internal

std::mt19937_64* GetSharedRng();

enum Enum { … };

enum class EnumClass : uint64_t { … };

inline std::ostream& operator<<(std::ostream& o, const EnumClass& ec) { … }

template <class T, class E = void>
struct Generator;

Generator<T, typename std::enable_if<std::is_integral<T>::value>::type>;

template <>
struct Generator<Enum> { … };

template <>
struct Generator<EnumClass> { … };

template <>
struct Generator<std::string> { … };

template <>
struct Generator<absl::string_view> { … };

template <>
struct Generator<NonStandardLayout> { … };

Generator<std::pair<K, V>>;

Generator<std::tuple<Ts...>>;

Generator<std::unique_ptr<T>>;

Generator<U, absl::void_t<decltype(std::declval<U &>().key()), decltype(std::declval<U &>().value())>>;

GeneratedType;

// Naive wrapper that performs a linear search of previous values.
// Beware this is O(SQR), which is reasonable for smaller kMaxValues.
template <class T, size_t kMaxValues = 64, class E = void>
struct UniqueGenerator { … };

}  // namespace hash_internal
}  // namespace container_internal
ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_