// Copyright 2019 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.
//
// -----------------------------------------------------------------------------
// conformance_profiles.h
// -----------------------------------------------------------------------------
//
// This file contains templates for representing "Regularity Profiles" and
// concisely-named versions of commonly used Regularity Profiles.
//
// A Regularity Profile is a compile-time description of the types of operations
// that a given type supports, along with properties of those operations when
// they do exist. For instance, a Regularity Profile may describe a type that
// has a move-constructor that is noexcept and a copy constructor that is not
// noexcept. This description can then be examined and passed around to other
// templates for the purposes of asserting expectations on user-defined types
// via a series trait checks, or for determining what kinds of run-time tests
// are able to be performed.
//
// Regularity Profiles are also used when creating "archetypes," which are
// minimum-conforming types that meet all of the requirements of a given
// Regularity Profile. For more information regarding archetypes, see
// "conformance_archetypes.h".
#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
#define ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
#include <set>
#include <type_traits>
#include <utility>
#include <vector>
#include "gtest/gtest.h"
#include "absl/algorithm/container.h"
#include "absl/meta/type_traits.h"
#include "absl/strings/ascii.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/types/internal/conformance_testing_helpers.h"
#include "absl/utility/utility.h"
// TODO(calabrese) Add support for extending profiles.
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace types_internal {
// Converts an enum to its underlying integral value.
template <typename Enum>
constexpr absl::underlying_type_t<Enum> UnderlyingValue(Enum value) {
return static_cast<absl::underlying_type_t<Enum>>(value);
}
// A tag type used in place of a matcher when checking that an assertion result
// does not actually contain any errors.
struct NoError {};
// -----------------------------------------------------------------------------
// ConformanceErrors
// -----------------------------------------------------------------------------
class ConformanceErrors {
public:
// Setup the error reporting mechanism by seeding it with the name of the type
// that is being tested.
explicit ConformanceErrors(std::string type_name)
: assertion_result_(false), type_name_(std::move(type_name)) {
assertion_result_ << "\n\n"
"Assuming the following type alias:\n"
"\n"
" using _T = "
<< type_name_ << ";\n\n";
outputDivider();
}
// Adds the test name to the list of successfully run tests iff it was not
// previously reported as failing. This behavior is useful for tests that
// have multiple parts, where failures and successes are reported individually
// with the same test name.
void addTestSuccess(absl::string_view test_name) {
auto normalized_test_name = absl::AsciiStrToLower(test_name);
// If the test is already reported as failing, do not add it to the list of
// successes.
if (test_failures_.find(normalized_test_name) == test_failures_.end()) {
test_successes_.insert(std::move(normalized_test_name));
}
}
// Streams a single error description into the internal buffer (a visual
// divider is automatically inserted after the error so that multiple errors
// are visibly distinct).
//
// This function increases the error count by 1.
//
// TODO(calabrese) Determine desired behavior when if this function throws.
template <class... P>
void addTestFailure(absl::string_view test_name, const P&... args) {
// Output a message related to the test failure.
assertion_result_ << "\n\n"
"Failed test: "
<< test_name << "\n\n";
addTestFailureImpl(args...);
assertion_result_ << "\n\n";
outputDivider();
auto normalized_test_name = absl::AsciiStrToLower(test_name);
// If previous parts of this test succeeded, remove it from that set.
test_successes_.erase(normalized_test_name);
// Add the test name to the list of failed tests.
test_failures_.insert(std::move(normalized_test_name));
has_error_ = true;
}
// Convert this object into a testing::AssertionResult instance such that it
// can be used with gtest.
::testing::AssertionResult assertionResult() const {
return has_error_ ? assertion_result_ : ::testing::AssertionSuccess();
}
// Convert this object into a testing::AssertionResult instance such that it
// can be used with gtest. This overload expects errors, using the specified
// matcher.
::testing::AssertionResult expectFailedTests(
const std::set<std::string>& test_names) const {
// Since we are expecting nonconformance, output an error message when the
// type actually conformed to the specified profile.
if (!has_error_) {
return ::testing::AssertionFailure()
<< "Unexpected conformance of type:\n"
" "
<< type_name_ << "\n\n";
}
// Get a list of all expected failures that did not actually fail
// (or that were not run).
std::vector<std::string> nonfailing_tests;
absl::c_set_difference(test_names, test_failures_,
std::back_inserter(nonfailing_tests));
// Get a list of all "expected failures" that were never actually run.
std::vector<std::string> unrun_tests;
absl::c_set_difference(nonfailing_tests, test_successes_,
std::back_inserter(unrun_tests));
// Report when the user specified tests that were not run.
if (!unrun_tests.empty()) {
const bool tests_were_run =
!(test_failures_.empty() && test_successes_.empty());
// Prepare an assertion result used in the case that tests pass that were
// expected to fail.
::testing::AssertionResult result = ::testing::AssertionFailure();
result << "When testing type:\n " << type_name_
<< "\n\nThe following tests were expected to fail but were not "
"run";
if (tests_were_run) result << " (was the test name spelled correctly?)";
result << ":\n\n";
// List all of the tests that unexpectedly passed.
for (const auto& test_name : unrun_tests) {
result << " " << test_name << "\n";
}
if (!tests_were_run) result << "\nNo tests were run.";
if (!test_failures_.empty()) {
// List test failures
result << "\nThe tests that were run and failed are:\n\n";
for (const auto& test_name : test_failures_) {
result << " " << test_name << "\n";
}
}
if (!test_successes_.empty()) {
// List test successes
result << "\nThe tests that were run and succeeded are:\n\n";
for (const auto& test_name : test_successes_) {
result << " " << test_name << "\n";
}
}
return result;
}
// If some tests passed when they were expected to fail, alert the caller.
if (nonfailing_tests.empty()) return ::testing::AssertionSuccess();
// Prepare an assertion result used in the case that tests pass that were
// expected to fail.
::testing::AssertionResult unexpected_successes =
::testing::AssertionFailure();
unexpected_successes << "When testing type:\n " << type_name_
<< "\n\nThe following tests passed when they were "
"expected to fail:\n\n";
// List all of the tests that unexpectedly passed.
for (const auto& test_name : nonfailing_tests) {
unexpected_successes << " " << test_name << "\n";
}
return unexpected_successes;
}
private:
void outputDivider() {
assertion_result_ << "========================================";
}
void addTestFailureImpl() {}
template <class H, class... T>
void addTestFailureImpl(const H& head, const T&... tail) {
assertion_result_ << head;
addTestFailureImpl(tail...);
}
::testing::AssertionResult assertion_result_;
std::set<std::string> test_failures_;
std::set<std::string> test_successes_;
std::string type_name_;
bool has_error_ = false;
};
template <class T, class /*Enabler*/ = void>
struct PropertiesOfImpl {};
template <class T>
struct PropertiesOfImpl<T, absl::void_t<typename T::properties>> {
using type = typename T::properties;
};
template <class T>
struct PropertiesOfImpl<T, absl::void_t<typename T::profile_alias_of>> {
using type = typename PropertiesOfImpl<typename T::profile_alias_of>::type;
};
template <class T>
struct PropertiesOf : PropertiesOfImpl<T> {};
template <class T>
using PropertiesOfT = typename PropertiesOf<T>::type;
// NOTE: These enums use this naming convention to be consistent with the
// standard trait names, which is useful since it allows us to match up each
// enum name with a corresponding trait name in macro definitions.
// An enum that describes the various expectations on an operations existence.
enum class function_support { maybe, yes, nothrow, trivial };
constexpr const char* PessimisticPropertyDescription(function_support v) {
return v == function_support::maybe
? "no"
: v == function_support::yes
? "yes, potentially throwing"
: v == function_support::nothrow ? "yes, nothrow"
: "yes, trivial";
}
// Return a string that describes the kind of property support that was
// expected.
inline std::string ExpectedFunctionKindList(function_support min,
function_support max) {
if (min == max) {
std::string result =
absl::StrCat("Expected:\n ",
PessimisticPropertyDescription(
static_cast<function_support>(UnderlyingValue(min))),
"\n");
return result;
}
std::string result = "Expected one of:\n";
for (auto curr_support = UnderlyingValue(min);
curr_support <= UnderlyingValue(max); ++curr_support) {
absl::StrAppend(&result, " ",
PessimisticPropertyDescription(
static_cast<function_support>(curr_support)),
"\n");
}
return result;
}
template <class Enum>
void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support,
Enum max_support, Enum kind) {
const auto kind_value = UnderlyingValue(kind);
const auto min_support_value = UnderlyingValue(min_support);
const auto max_support_value = UnderlyingValue(max_support);
if (!(kind_value >= min_support_value && kind_value <= max_support_value)) {
errors->addTestFailure(
PropertyName(kind), "**Failed property expectation**\n\n",
ExpectedFunctionKindList(
static_cast<function_support>(min_support_value),
static_cast<function_support>(max_support_value)),
'\n', "Actual:\n ",
PessimisticPropertyDescription(
static_cast<function_support>(kind_value)));
} else {
errors->addTestSuccess(PropertyName(kind));
}
}
#define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
enum class name { maybe, yes, nothrow, trivial }; \
\
constexpr const char* PropertyName(name v) { return description; } \
static_assert(true, "") // Force a semicolon when using this macro.
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
default_constructible);
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
move_constructible);
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
copy_constructible);
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
move_assignable);
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
copy_assignable);
ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
destructible);
#undef ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name) \
enum class name { maybe, yes, nothrow }; \
\
constexpr const char* PropertyName(name v) { return description; } \
static_assert(true, "") // Force a semicolon when using this macro.
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
greater_equal_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
#undef ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
enum class hashable { maybe, yes };
constexpr const char* PropertyName(hashable v) {
return "support for std::hash";
}
template <class T>
using AlwaysFalse = std::false_type;
#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property) \
template <class T> \
constexpr property property##_support_of() { \
return std::is_##property<T>::value \
? std::is_nothrow_##property<T>::value \
? absl::is_trivially_##property<T>::value \
? property::trivial \
: property::nothrow \
: property::yes \
: property::maybe; \
} \
\
template <class T, class MinProf, class MaxProf> \
void ExpectModelOf##name(ConformanceErrors* errors) { \
(ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \
PropertiesOfT<MaxProf>::property##_support, \
property##_support_of<T>()); \
}
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
default_constructible);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
move_constructible);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
copy_constructible);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
move_assignable);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
copy_assignable);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
void BoolFunction(bool) noexcept;
////////////////////////////////////////////////////////////////////////////////
//
// A metafunction for checking if an operation exists through SFINAE.
//
// `T` is the type to test and Op is an alias containing the expression to test.
template <class T, template <class...> class Op, class = void>
struct IsOpableImpl : std::false_type {};
template <class T, template <class...> class Op>
struct IsOpableImpl<T, Op, absl::void_t<Op<T>>> : std::true_type {};
template <template <class...> class Op>
struct IsOpable {
template <class T>
using apply = typename IsOpableImpl<T, Op>::type;
};
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// A metafunction for checking if an operation exists and is also noexcept
// through SFINAE and the noexcept operator.
///
// `T` is the type to test and Op is an alias containing the expression to test.
template <class T, template <class...> class Op, class = void>
struct IsNothrowOpableImpl : std::false_type {};
template <class T, template <class...> class Op>
struct IsNothrowOpableImpl<T, Op, absl::enable_if_t<Op<T>::value>>
: std::true_type {};
template <template <class...> class Op>
struct IsNothrowOpable {
template <class T>
using apply = typename IsNothrowOpableImpl<T, Op>::type;
};
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// A macro that produces the necessary function for reporting what kind of
// support a specific comparison operation has and a function for reporting an
// error if a given type's support for that operation does not meet the expected
// requirements.
#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op) \
template <class T, \
class Result = std::integral_constant< \
bool, noexcept((BoolFunction)(std::declval<const T&>() op \
std::declval<const T&>()))>> \
using name = Result; \
\
template <class T> \
constexpr property property##_support_of() { \
return IsOpable<name>::apply<T>::value \
? IsNothrowOpable<name>::apply<T>::value ? property::nothrow \
: property::yes \
: property::maybe; \
} \
\
template <class T, class MinProf, class MaxProf> \
void ExpectModelOf##name(ConformanceErrors* errors) { \
(ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \
PropertiesOfT<MaxProf>::property##_support, \
property##_support_of<T>()); \
}
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// Generate the necessary support-checking and error reporting functions for
// each of the comparison operators.
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
equality_comparable, ==);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
inequality_comparable, !=);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
less_than_comparable, <);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
less_equal_comparable, <=);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
greater_equal_comparable, >=);
ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
greater_than_comparable, >);
#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// The necessary support-checking and error-reporting functions for swap.
template <class T>
constexpr swappable swappable_support_of() {
return type_traits_internal::IsSwappable<T>::value
? type_traits_internal::IsNothrowSwappable<T>::value
? swappable::nothrow
: swappable::yes
: swappable::maybe;
}
template <class T, class MinProf, class MaxProf>
void ExpectModelOfSwappable(ConformanceErrors* errors) {
(ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support,
PropertiesOfT<MaxProf>::swappable_support,
swappable_support_of<T>());
}
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
// The necessary support-checking and error-reporting functions for std::hash.
template <class T>
constexpr hashable hashable_support_of() {
return type_traits_internal::IsHashable<T>::value ? hashable::yes
: hashable::maybe;
}
template <class T, class MinProf, class MaxProf>
void ExpectModelOfHashable(ConformanceErrors* errors) {
(ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support,
PropertiesOfT<MaxProf>::hashable_support,
hashable_support_of<T>());
}
//
////////////////////////////////////////////////////////////////////////////////
template <
default_constructible DefaultConstructibleValue =
default_constructible::maybe,
move_constructible MoveConstructibleValue = move_constructible::maybe,
copy_constructible CopyConstructibleValue = copy_constructible::maybe,
move_assignable MoveAssignableValue = move_assignable::maybe,
copy_assignable CopyAssignableValue = copy_assignable::maybe,
destructible DestructibleValue = destructible::maybe,
equality_comparable EqualityComparableValue = equality_comparable::maybe,
inequality_comparable InequalityComparableValue =
inequality_comparable::maybe,
less_than_comparable LessThanComparableValue = less_than_comparable::maybe,
less_equal_comparable LessEqualComparableValue =
less_equal_comparable::maybe,
greater_equal_comparable GreaterEqualComparableValue =
greater_equal_comparable::maybe,
greater_than_comparable GreaterThanComparableValue =
greater_than_comparable::maybe,
swappable SwappableValue = swappable::maybe,
hashable HashableValue = hashable::maybe>
struct ConformanceProfile {
using properties = ConformanceProfile;
static constexpr default_constructible
default_constructible_support = // NOLINT
DefaultConstructibleValue;
static constexpr move_constructible move_constructible_support = // NOLINT
MoveConstructibleValue;
static constexpr copy_constructible copy_constructible_support = // NOLINT
CopyConstructibleValue;
static constexpr move_assignable move_assignable_support = // NOLINT
MoveAssignableValue;
static constexpr copy_assignable copy_assignable_support = // NOLINT
CopyAssignableValue;
static constexpr destructible destructible_support = // NOLINT
DestructibleValue;
static constexpr equality_comparable equality_comparable_support = // NOLINT
EqualityComparableValue;
static constexpr inequality_comparable
inequality_comparable_support = // NOLINT
InequalityComparableValue;
static constexpr less_than_comparable
less_than_comparable_support = // NOLINT
LessThanComparableValue;
static constexpr less_equal_comparable
less_equal_comparable_support = // NOLINT
LessEqualComparableValue;
static constexpr greater_equal_comparable
greater_equal_comparable_support = // NOLINT
GreaterEqualComparableValue;
static constexpr greater_than_comparable
greater_than_comparable_support = // NOLINT
GreaterThanComparableValue;
static constexpr swappable swappable_support = SwappableValue; // NOLINT
static constexpr hashable hashable_support = HashableValue; // NOLINT
static constexpr bool is_default_constructible = // NOLINT
DefaultConstructibleValue != default_constructible::maybe;
static constexpr bool is_move_constructible = // NOLINT
MoveConstructibleValue != move_constructible::maybe;
static constexpr bool is_copy_constructible = // NOLINT
CopyConstructibleValue != copy_constructible::maybe;
static constexpr bool is_move_assignable = // NOLINT
MoveAssignableValue != move_assignable::maybe;
static constexpr bool is_copy_assignable = // NOLINT
CopyAssignableValue != copy_assignable::maybe;
static constexpr bool is_destructible = // NOLINT
DestructibleValue != destructible::maybe;
static constexpr bool is_equality_comparable = // NOLINT
EqualityComparableValue != equality_comparable::maybe;
static constexpr bool is_inequality_comparable = // NOLINT
InequalityComparableValue != inequality_comparable::maybe;
static constexpr bool is_less_than_comparable = // NOLINT
LessThanComparableValue != less_than_comparable::maybe;
static constexpr bool is_less_equal_comparable = // NOLINT
LessEqualComparableValue != less_equal_comparable::maybe;
static constexpr bool is_greater_equal_comparable = // NOLINT
GreaterEqualComparableValue != greater_equal_comparable::maybe;
static constexpr bool is_greater_than_comparable = // NOLINT
GreaterThanComparableValue != greater_than_comparable::maybe;
static constexpr bool is_swappable = // NOLINT
SwappableValue != swappable::maybe;
static constexpr bool is_hashable = // NOLINT
HashableValue != hashable::maybe;
};
////////////////////////////////////////////////////////////////////////////////
//
// Compliant SFINAE-friendliness is not always present on the standard library
// implementations that we support. This helper-struct (and associated enum) is
// used as a means to conditionally check the hashability support of a type.
enum class CheckHashability { no, yes };
template <class T, CheckHashability ShouldCheckHashability>
struct conservative_hashable_support_of;
template <class T>
struct conservative_hashable_support_of<T, CheckHashability::no> {
static constexpr hashable Invoke() { return hashable::maybe; }
};
template <class T>
struct conservative_hashable_support_of<T, CheckHashability::yes> {
static constexpr hashable Invoke() { return hashable_support_of<T>(); }
};
//
////////////////////////////////////////////////////////////////////////////////
// The ConformanceProfile that is expected based on introspection into the type
// by way of trait checks.
template <class T, CheckHashability ShouldCheckHashability>
struct SyntacticConformanceProfileOf {
using properties = ConformanceProfile<
default_constructible_support_of<T>(), move_constructible_support_of<T>(),
copy_constructible_support_of<T>(), move_assignable_support_of<T>(),
copy_assignable_support_of<T>(), destructible_support_of<T>(),
equality_comparable_support_of<T>(),
inequality_comparable_support_of<T>(),
less_than_comparable_support_of<T>(),
less_equal_comparable_support_of<T>(),
greater_equal_comparable_support_of<T>(),
greater_than_comparable_support_of<T>(), swappable_support_of<T>(),
conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
};
#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name) \
template <default_constructible DefaultConstructibleValue, \
move_constructible MoveConstructibleValue, \
copy_constructible CopyConstructibleValue, \
move_assignable MoveAssignableValue, \
copy_assignable CopyAssignableValue, \
destructible DestructibleValue, \
equality_comparable EqualityComparableValue, \
inequality_comparable InequalityComparableValue, \
less_than_comparable LessThanComparableValue, \
less_equal_comparable LessEqualComparableValue, \
greater_equal_comparable GreaterEqualComparableValue, \
greater_than_comparable GreaterThanComparableValue, \
swappable SwappableValue, hashable HashableValue> \
constexpr type ConformanceProfile< \
DefaultConstructibleValue, MoveConstructibleValue, \
CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue, \
DestructibleValue, EqualityComparableValue, InequalityComparableValue, \
LessThanComparableValue, LessEqualComparableValue, \
GreaterEqualComparableValue, GreaterThanComparableValue, SwappableValue, \
HashableValue>::name
#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type) \
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, \
type##_support); \
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
// Retrieve the enum with the minimum underlying value.
// Note: std::min is not constexpr in C++11, which is why this is necessary.
template <class H>
constexpr H MinEnum(H head) {
return head;
}
template <class H, class N, class... T>
constexpr H MinEnum(H head, N next, T... tail) {
return (UnderlyingValue)(head) < (UnderlyingValue)(next)
? (MinEnum)(head, tail...)
: (MinEnum)(next, tail...);
}
template <class... Profs>
struct MinimalProfiles {
static constexpr default_constructible
default_constructible_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::default_constructible_support...);
static constexpr move_constructible move_constructible_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::move_constructible_support...);
static constexpr copy_constructible copy_constructible_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
static constexpr move_assignable move_assignable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::move_assignable_support...);
static constexpr copy_assignable copy_assignable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
static constexpr destructible destructible_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::destructible_support...);
static constexpr equality_comparable equality_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
static constexpr inequality_comparable
inequality_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
static constexpr less_than_comparable
less_than_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
static constexpr less_equal_comparable
less_equal_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
static constexpr greater_equal_comparable
greater_equal_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
static constexpr greater_than_comparable
greater_than_comparable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
static constexpr swappable swappable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::swappable_support...);
static constexpr hashable hashable_support = // NOLINT
(MinEnum)(PropertiesOfT<Profs>::hashable_support...);
using properties = ConformanceProfile<
default_constructible_support, move_constructible_support,
copy_constructible_support, move_assignable_support,
copy_assignable_support, destructible_support,
equality_comparable_support, inequality_comparable_support,
less_than_comparable_support, less_equal_comparable_support,
greater_equal_comparable_support, greater_than_comparable_support,
swappable_support, hashable_support>;
};
// Retrieve the enum with the greatest underlying value.
// Note: std::max is not constexpr in C++11, which is why this is necessary.
template <class H>
constexpr H MaxEnum(H head) {
return head;
}
template <class H, class N, class... T>
constexpr H MaxEnum(H head, N next, T... tail) {
return (UnderlyingValue)(next) < (UnderlyingValue)(head)
? (MaxEnum)(head, tail...)
: (MaxEnum)(next, tail...);
}
template <class... Profs>
struct CombineProfilesImpl {
static constexpr default_constructible
default_constructible_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::default_constructible_support...);
static constexpr move_constructible move_constructible_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::move_constructible_support...);
static constexpr copy_constructible copy_constructible_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
static constexpr move_assignable move_assignable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::move_assignable_support...);
static constexpr copy_assignable copy_assignable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
static constexpr destructible destructible_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::destructible_support...);
static constexpr equality_comparable equality_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
static constexpr inequality_comparable
inequality_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
static constexpr less_than_comparable
less_than_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
static constexpr less_equal_comparable
less_equal_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
static constexpr greater_equal_comparable
greater_equal_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
static constexpr greater_than_comparable
greater_than_comparable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
static constexpr swappable swappable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::swappable_support...);
static constexpr hashable hashable_support = // NOLINT
(MaxEnum)(PropertiesOfT<Profs>::hashable_support...);
using properties = ConformanceProfile<
default_constructible_support, move_constructible_support,
copy_constructible_support, move_assignable_support,
copy_assignable_support, destructible_support,
equality_comparable_support, inequality_comparable_support,
less_than_comparable_support, less_equal_comparable_support,
greater_equal_comparable_support, greater_than_comparable_support,
swappable_support, hashable_support>;
};
// NOTE: We use this as opposed to a direct alias of CombineProfilesImpl so that
// when named aliases of CombineProfiles are created (such as in
// conformance_aliases.h), we only pay for the combination algorithm on the
// profiles that are actually used.
template <class... Profs>
struct CombineProfiles {
using profile_alias_of = CombineProfilesImpl<Profs...>;
};
template <>
struct CombineProfiles<> {
using properties = ConformanceProfile<>;
};
template <class Profile, class Tag>
struct StrongProfileTypedef {
using properties = PropertiesOfT<Profile>;
};
template <class T, class /*Enabler*/ = void>
struct IsProfileImpl : std::false_type {};
template <class T>
struct IsProfileImpl<T, absl::void_t<PropertiesOfT<T>>> : std::true_type {};
template <class T>
struct IsProfile : IsProfileImpl<T>::type {};
// A tag that describes which set of properties we will check when the user
// requires a strict match in conformance (as opposed to a loose match which
// allows more-refined support of any given operation).
//
// Currently only the RegularityDomain exists and it includes all operations
// that the conformance testing suite knows about. The intent is that if the
// suite is expanded to support extension, such as for checking conformance of
// concepts like Iterators or Containers, additional corresponding domains can
// be created.
struct RegularityDomain {};
} // namespace types_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
