// 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.

#include <new>
#include <type_traits>
#include <utility>

#include "gtest/gtest.h"
#include "absl/meta/type_traits.h"
#include "absl/types/internal/conformance_aliases.h"

namespace {

namespace ti = absl::types_internal;

template <class T>
using DefaultConstructibleWithNewImpl = decltype(::new (std::nothrow) T);

template <class T>
using DefaultConstructibleWithNew =
    absl::type_traits_internal::is_detected<DefaultConstructibleWithNewImpl, T>;

template <class T>
using MoveConstructibleWithNewImpl =
    decltype(::new (std::nothrow) T(std::declval<T>()));

template <class T>
using MoveConstructibleWithNew =
    absl::type_traits_internal::is_detected<MoveConstructibleWithNewImpl, T>;

template <class T>
using CopyConstructibleWithNewImpl =
    decltype(::new (std::nothrow) T(std::declval<const T&>()));

template <class T>
using CopyConstructibleWithNew =
    absl::type_traits_internal::is_detected<CopyConstructibleWithNewImpl, T>;

template <class T,
          class Result =
              std::integral_constant<bool, noexcept(::new (std::nothrow) T)>>
using NothrowDefaultConstructibleWithNewImpl =
    typename std::enable_if<Result::value>::type;

template <class T>
using NothrowDefaultConstructibleWithNew =
    absl::type_traits_internal::is_detected<
        NothrowDefaultConstructibleWithNewImpl, T>;

template <class T,
          class Result = std::integral_constant<
              bool, noexcept(::new (std::nothrow) T(std::declval<T>()))>>
using NothrowMoveConstructibleWithNewImpl =
    typename std::enable_if<Result::value>::type;

template <class T>
using NothrowMoveConstructibleWithNew =
    absl::type_traits_internal::is_detected<NothrowMoveConstructibleWithNewImpl,
                                            T>;

template <class T,
          class Result = std::integral_constant<
              bool, noexcept(::new (std::nothrow) T(std::declval<const T&>()))>>
using NothrowCopyConstructibleWithNewImpl =
    typename std::enable_if<Result::value>::type;

template <class T>
using NothrowCopyConstructibleWithNew =
    absl::type_traits_internal::is_detected<NothrowCopyConstructibleWithNewImpl,
                                            T>;

// NOTE: ?: is used to verify contextually-convertible to bool and not simply
//       implicit or explicit convertibility.
#define ABSL_INTERNAL_COMPARISON_OP_EXPR(op) \
  ((std::declval<const T&>() op std::declval<const T&>()) ? true : true)

#define ABSL_INTERNAL_COMPARISON_OP_TRAIT(name, op)                         \
  template <class T>                                                        \
  using name##Impl = decltype(ABSL_INTERNAL_COMPARISON_OP_EXPR(op));        \
                                                                            \
  template <class T>                                                        \
  using name = absl::type_traits_internal::is_detected<name##Impl, T>;      \
                                                                            \
  template <class T,                                                        \
            class Result = std::integral_constant<                          \
                bool, noexcept(ABSL_INTERNAL_COMPARISON_OP_EXPR(op))>>      \
  using Nothrow##name##Impl = typename std::enable_if<Result::value>::type; \
                                                                            \
  template <class T>                                                        \
  using Nothrow##name =                                                     \
      absl::type_traits_internal::is_detected<Nothrow##name##Impl, T>

ABSL_INTERNAL_COMPARISON_OP_TRAIT(EqualityComparable, ==);
ABSL_INTERNAL_COMPARISON_OP_TRAIT(InequalityComparable, !=);
ABSL_INTERNAL_COMPARISON_OP_TRAIT(LessThanComparable, <);
ABSL_INTERNAL_COMPARISON_OP_TRAIT(LessEqualComparable, <=);
ABSL_INTERNAL_COMPARISON_OP_TRAIT(GreaterEqualComparable, >=);
ABSL_INTERNAL_COMPARISON_OP_TRAIT(GreaterThanComparable, >);

#undef ABSL_INTERNAL_COMPARISON_OP_TRAIT

template <class T>
class ProfileTest : public ::testing::Test {};

TYPED_TEST_SUITE_P(ProfileTest);

TYPED_TEST_P(ProfileTest, HasAppropriateConstructionProperties) {
  using profile = typename TypeParam::profile;
  using arch = typename TypeParam::arch;
  using expected_profile = typename TypeParam::expected_profile;

  using props = ti::PropertiesOfT<profile>;
  using arch_props = ti::PropertiesOfArchetypeT<arch>;
  using expected_props = ti::PropertiesOfT<expected_profile>;

  // Make sure all of the properties are as expected.
  // There are seemingly redundant tests here to make it easier to diagnose
  // the specifics of the failure if something were to go wrong.
  EXPECT_TRUE((std::is_same<props, arch_props>::value));
  EXPECT_TRUE((std::is_same<props, expected_props>::value));
  EXPECT_TRUE((std::is_same<arch_props, expected_props>::value));

  EXPECT_EQ(props::default_constructible_support,
            expected_props::default_constructible_support);

  EXPECT_EQ(props::move_constructible_support,
            expected_props::move_constructible_support);

  EXPECT_EQ(props::copy_constructible_support,
            expected_props::copy_constructible_support);

  EXPECT_EQ(props::destructible_support, expected_props::destructible_support);

  // Avoid additional error message noise when profile and archetype match with
  // each other but were not what was expected.
  if (!std::is_same<props, arch_props>::value) {
    EXPECT_EQ(arch_props::default_constructible_support,
              expected_props::default_constructible_support);

    EXPECT_EQ(arch_props::move_constructible_support,
              expected_props::move_constructible_support);

    EXPECT_EQ(arch_props::copy_constructible_support,
              expected_props::copy_constructible_support);

    EXPECT_EQ(arch_props::destructible_support,
              expected_props::destructible_support);
  }

  //////////////////////////////////////////////////////////////////////////////
  //                       Default constructor checks                         //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::default_constructible_support,
            expected_props::default_constructible_support);

  switch (expected_props::default_constructible_support) {
    case ti::default_constructible::maybe:
      EXPECT_FALSE(DefaultConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowDefaultConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_FALSE(std::is_default_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_default_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value);
      }
      break;
    case ti::default_constructible::yes:
      EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowDefaultConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_default_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_default_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value);
      }
      break;
    case ti::default_constructible::nothrow:
      EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowDefaultConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_default_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_default_constructible<arch>::value);

        // Constructor traits also check the destructor.
        if (std::is_nothrow_destructible<arch>::value) {
          EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value);
        }
      }
      break;
    case ti::default_constructible::trivial:
      EXPECT_TRUE(DefaultConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowDefaultConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_default_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_default_constructible<arch>::value);

        // Constructor triviality traits require trivially destructible types.
        if (absl::is_trivially_destructible<arch>::value) {
          EXPECT_TRUE(absl::is_trivially_default_constructible<arch>::value);
        }
      }
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                         Move constructor checks                          //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::move_constructible_support,
            expected_props::move_constructible_support);

  switch (expected_props::move_constructible_support) {
    case ti::move_constructible::maybe:
      EXPECT_FALSE(MoveConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowMoveConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_FALSE(std::is_move_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_move_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value);
      }
      break;
    case ti::move_constructible::yes:
      EXPECT_TRUE(MoveConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowMoveConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_move_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_move_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value);
      }
      break;
    case ti::move_constructible::nothrow:
      EXPECT_TRUE(MoveConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowMoveConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_move_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_move_constructible<arch>::value);

        // Constructor traits also check the destructor.
        if (std::is_nothrow_destructible<arch>::value) {
          EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value);
        }
      }
      break;
    case ti::move_constructible::trivial:
      EXPECT_TRUE(MoveConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowMoveConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_move_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_move_constructible<arch>::value);

        // Constructor triviality traits require trivially destructible types.
        if (absl::is_trivially_destructible<arch>::value) {
          EXPECT_TRUE(absl::is_trivially_move_constructible<arch>::value);
        }
      }
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                         Copy constructor checks                          //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::copy_constructible_support,
            expected_props::copy_constructible_support);

  switch (expected_props::copy_constructible_support) {
    case ti::copy_constructible::maybe:
      EXPECT_FALSE(CopyConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowCopyConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_FALSE(std::is_copy_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_copy_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value);
      }
      break;
    case ti::copy_constructible::yes:
      EXPECT_TRUE(CopyConstructibleWithNew<arch>::value);
      EXPECT_FALSE(NothrowCopyConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_copy_constructible<arch>::value);
        EXPECT_FALSE(std::is_nothrow_copy_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value);
      }
      break;
    case ti::copy_constructible::nothrow:
      EXPECT_TRUE(CopyConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowCopyConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_copy_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value);
        EXPECT_FALSE(absl::is_trivially_copy_constructible<arch>::value);

        // Constructor traits also check the destructor.
        if (std::is_nothrow_destructible<arch>::value) {
          EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value);
        }
      }
      break;
    case ti::copy_constructible::trivial:
      EXPECT_TRUE(CopyConstructibleWithNew<arch>::value);
      EXPECT_TRUE(NothrowCopyConstructibleWithNew<arch>::value);

      // Standard constructible traits depend on the destructor.
      if (std::is_destructible<arch>::value) {
        EXPECT_TRUE(std::is_copy_constructible<arch>::value);
        EXPECT_TRUE(std::is_nothrow_copy_constructible<arch>::value);

        // Constructor triviality traits require trivially destructible types.
        if (absl::is_trivially_destructible<arch>::value) {
          EXPECT_TRUE(absl::is_trivially_copy_constructible<arch>::value);
        }
      }
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                           Destructible checks                            //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::destructible_support, expected_props::destructible_support);

  switch (expected_props::destructible_support) {
    case ti::destructible::maybe:
      EXPECT_FALSE(std::is_destructible<arch>::value);
      EXPECT_FALSE(std::is_nothrow_destructible<arch>::value);
      EXPECT_FALSE(absl::is_trivially_destructible<arch>::value);
      break;
    case ti::destructible::yes:
      EXPECT_TRUE(std::is_destructible<arch>::value);
      EXPECT_FALSE(std::is_nothrow_destructible<arch>::value);
      EXPECT_FALSE(absl::is_trivially_destructible<arch>::value);
      break;
    case ti::destructible::nothrow:
      EXPECT_TRUE(std::is_destructible<arch>::value);
      EXPECT_TRUE(std::is_nothrow_destructible<arch>::value);
      EXPECT_FALSE(absl::is_trivially_destructible<arch>::value);
      break;
    case ti::destructible::trivial:
      EXPECT_TRUE(std::is_destructible<arch>::value);
      EXPECT_TRUE(std::is_nothrow_destructible<arch>::value);
      EXPECT_TRUE(absl::is_trivially_destructible<arch>::value);
      break;
  }
}

TYPED_TEST_P(ProfileTest, HasAppropriateAssignmentProperties) {
  using profile = typename TypeParam::profile;
  using arch = typename TypeParam::arch;
  using expected_profile = typename TypeParam::expected_profile;

  using props = ti::PropertiesOfT<profile>;
  using arch_props = ti::PropertiesOfArchetypeT<arch>;
  using expected_props = ti::PropertiesOfT<expected_profile>;

  // Make sure all of the properties are as expected.
  // There are seemingly redundant tests here to make it easier to diagnose
  // the specifics of the failure if something were to go wrong.
  EXPECT_TRUE((std::is_same<props, arch_props>::value));
  EXPECT_TRUE((std::is_same<props, expected_props>::value));
  EXPECT_TRUE((std::is_same<arch_props, expected_props>::value));

  EXPECT_EQ(props::move_assignable_support,
            expected_props::move_assignable_support);

  EXPECT_EQ(props::copy_assignable_support,
            expected_props::copy_assignable_support);

  // Avoid additional error message noise when profile and archetype match with
  // each other but were not what was expected.
  if (!std::is_same<props, arch_props>::value) {
    EXPECT_EQ(arch_props::move_assignable_support,
              expected_props::move_assignable_support);

    EXPECT_EQ(arch_props::copy_assignable_support,
              expected_props::copy_assignable_support);
  }

  //////////////////////////////////////////////////////////////////////////////
  //                          Move assignment checks                          //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::move_assignable_support,
            expected_props::move_assignable_support);

  switch (expected_props::move_assignable_support) {
    case ti::move_assignable::maybe:
      EXPECT_FALSE(std::is_move_assignable<arch>::value);
      EXPECT_FALSE(std::is_nothrow_move_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value);
      break;
    case ti::move_assignable::yes:
      EXPECT_TRUE(std::is_move_assignable<arch>::value);
      EXPECT_FALSE(std::is_nothrow_move_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value);
      break;
    case ti::move_assignable::nothrow:
      EXPECT_TRUE(std::is_move_assignable<arch>::value);
      EXPECT_TRUE(std::is_nothrow_move_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_move_assignable<arch>::value);
      break;
    case ti::move_assignable::trivial:
      EXPECT_TRUE(std::is_move_assignable<arch>::value);
      EXPECT_TRUE(std::is_nothrow_move_assignable<arch>::value);
      EXPECT_TRUE(absl::is_trivially_move_assignable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                          Copy assignment checks                          //
  //////////////////////////////////////////////////////////////////////////////
  EXPECT_EQ(props::copy_assignable_support,
            expected_props::copy_assignable_support);

  switch (expected_props::copy_assignable_support) {
    case ti::copy_assignable::maybe:
      EXPECT_FALSE(std::is_copy_assignable<arch>::value);
      EXPECT_FALSE(std::is_nothrow_copy_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value);
      break;
    case ti::copy_assignable::yes:
      EXPECT_TRUE(std::is_copy_assignable<arch>::value);
      EXPECT_FALSE(std::is_nothrow_copy_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value);
      break;
    case ti::copy_assignable::nothrow:
      EXPECT_TRUE(std::is_copy_assignable<arch>::value);
      EXPECT_TRUE(std::is_nothrow_copy_assignable<arch>::value);
      EXPECT_FALSE(absl::is_trivially_copy_assignable<arch>::value);
      break;
    case ti::copy_assignable::trivial:
      EXPECT_TRUE(std::is_copy_assignable<arch>::value);
      EXPECT_TRUE(std::is_nothrow_copy_assignable<arch>::value);
      EXPECT_TRUE(absl::is_trivially_copy_assignable<arch>::value);
      break;
  }
}

TYPED_TEST_P(ProfileTest, HasAppropriateComparisonProperties) {
  using profile = typename TypeParam::profile;
  using arch = typename TypeParam::arch;
  using expected_profile = typename TypeParam::expected_profile;

  using props = ti::PropertiesOfT<profile>;
  using arch_props = ti::PropertiesOfArchetypeT<arch>;
  using expected_props = ti::PropertiesOfT<expected_profile>;

  // Make sure all of the properties are as expected.
  // There are seemingly redundant tests here to make it easier to diagnose
  // the specifics of the failure if something were to go wrong.
  EXPECT_TRUE((std::is_same<props, arch_props>::value));
  EXPECT_TRUE((std::is_same<props, expected_props>::value));
  EXPECT_TRUE((std::is_same<arch_props, expected_props>::value));

  EXPECT_EQ(props::equality_comparable_support,
            expected_props::equality_comparable_support);

  EXPECT_EQ(props::inequality_comparable_support,
            expected_props::inequality_comparable_support);

  EXPECT_EQ(props::less_than_comparable_support,
            expected_props::less_than_comparable_support);

  EXPECT_EQ(props::less_equal_comparable_support,
            expected_props::less_equal_comparable_support);

  EXPECT_EQ(props::greater_equal_comparable_support,
            expected_props::greater_equal_comparable_support);

  EXPECT_EQ(props::greater_than_comparable_support,
            expected_props::greater_than_comparable_support);

  // Avoid additional error message noise when profile and archetype match with
  // each other but were not what was expected.
  if (!std::is_same<props, arch_props>::value) {
    EXPECT_EQ(arch_props::equality_comparable_support,
              expected_props::equality_comparable_support);

    EXPECT_EQ(arch_props::inequality_comparable_support,
              expected_props::inequality_comparable_support);

    EXPECT_EQ(arch_props::less_than_comparable_support,
              expected_props::less_than_comparable_support);

    EXPECT_EQ(arch_props::less_equal_comparable_support,
              expected_props::less_equal_comparable_support);

    EXPECT_EQ(arch_props::greater_equal_comparable_support,
              expected_props::greater_equal_comparable_support);

    EXPECT_EQ(arch_props::greater_than_comparable_support,
              expected_props::greater_than_comparable_support);
  }

  //////////////////////////////////////////////////////////////////////////////
  //                        Equality comparable checks                        //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::equality_comparable_support) {
    case ti::equality_comparable::maybe:
      EXPECT_FALSE(EqualityComparable<arch>::value);
      EXPECT_FALSE(NothrowEqualityComparable<arch>::value);
      break;
    case ti::equality_comparable::yes:
      EXPECT_TRUE(EqualityComparable<arch>::value);
      EXPECT_FALSE(NothrowEqualityComparable<arch>::value);
      break;
    case ti::equality_comparable::nothrow:
      EXPECT_TRUE(EqualityComparable<arch>::value);
      EXPECT_TRUE(NothrowEqualityComparable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                       Inequality comparable checks                       //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::inequality_comparable_support) {
    case ti::inequality_comparable::maybe:
      EXPECT_FALSE(InequalityComparable<arch>::value);
      EXPECT_FALSE(NothrowInequalityComparable<arch>::value);
      break;
    case ti::inequality_comparable::yes:
      EXPECT_TRUE(InequalityComparable<arch>::value);
      EXPECT_FALSE(NothrowInequalityComparable<arch>::value);
      break;
    case ti::inequality_comparable::nothrow:
      EXPECT_TRUE(InequalityComparable<arch>::value);
      EXPECT_TRUE(NothrowInequalityComparable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                       Less than comparable checks                        //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::less_than_comparable_support) {
    case ti::less_than_comparable::maybe:
      EXPECT_FALSE(LessThanComparable<arch>::value);
      EXPECT_FALSE(NothrowLessThanComparable<arch>::value);
      break;
    case ti::less_than_comparable::yes:
      EXPECT_TRUE(LessThanComparable<arch>::value);
      EXPECT_FALSE(NothrowLessThanComparable<arch>::value);
      break;
    case ti::less_than_comparable::nothrow:
      EXPECT_TRUE(LessThanComparable<arch>::value);
      EXPECT_TRUE(NothrowLessThanComparable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                      Less equal comparable checks                        //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::less_equal_comparable_support) {
    case ti::less_equal_comparable::maybe:
      EXPECT_FALSE(LessEqualComparable<arch>::value);
      EXPECT_FALSE(NothrowLessEqualComparable<arch>::value);
      break;
    case ti::less_equal_comparable::yes:
      EXPECT_TRUE(LessEqualComparable<arch>::value);
      EXPECT_FALSE(NothrowLessEqualComparable<arch>::value);
      break;
    case ti::less_equal_comparable::nothrow:
      EXPECT_TRUE(LessEqualComparable<arch>::value);
      EXPECT_TRUE(NothrowLessEqualComparable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                     Greater equal comparable checks                      //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::greater_equal_comparable_support) {
    case ti::greater_equal_comparable::maybe:
      EXPECT_FALSE(GreaterEqualComparable<arch>::value);
      EXPECT_FALSE(NothrowGreaterEqualComparable<arch>::value);
      break;
    case ti::greater_equal_comparable::yes:
      EXPECT_TRUE(GreaterEqualComparable<arch>::value);
      EXPECT_FALSE(NothrowGreaterEqualComparable<arch>::value);
      break;
    case ti::greater_equal_comparable::nothrow:
      EXPECT_TRUE(GreaterEqualComparable<arch>::value);
      EXPECT_TRUE(NothrowGreaterEqualComparable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                     Greater than comparable checks                       //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::greater_than_comparable_support) {
    case ti::greater_than_comparable::maybe:
      EXPECT_FALSE(GreaterThanComparable<arch>::value);
      EXPECT_FALSE(NothrowGreaterThanComparable<arch>::value);
      break;
    case ti::greater_than_comparable::yes:
      EXPECT_TRUE(GreaterThanComparable<arch>::value);
      EXPECT_FALSE(NothrowGreaterThanComparable<arch>::value);
      break;
    case ti::greater_than_comparable::nothrow:
      EXPECT_TRUE(GreaterThanComparable<arch>::value);
      EXPECT_TRUE(NothrowGreaterThanComparable<arch>::value);
      break;
  }
}

TYPED_TEST_P(ProfileTest, HasAppropriateAuxilliaryProperties) {
  using profile = typename TypeParam::profile;
  using arch = typename TypeParam::arch;
  using expected_profile = typename TypeParam::expected_profile;

  using props = ti::PropertiesOfT<profile>;
  using arch_props = ti::PropertiesOfArchetypeT<arch>;
  using expected_props = ti::PropertiesOfT<expected_profile>;

  // Make sure all of the properties are as expected.
  // There are seemingly redundant tests here to make it easier to diagnose
  // the specifics of the failure if something were to go wrong.
  EXPECT_TRUE((std::is_same<props, arch_props>::value));
  EXPECT_TRUE((std::is_same<props, expected_props>::value));
  EXPECT_TRUE((std::is_same<arch_props, expected_props>::value));

  EXPECT_EQ(props::swappable_support, expected_props::swappable_support);

  EXPECT_EQ(props::hashable_support, expected_props::hashable_support);

  // Avoid additional error message noise when profile and archetype match with
  // each other but were not what was expected.
  if (!std::is_same<props, arch_props>::value) {
    EXPECT_EQ(arch_props::swappable_support, expected_props::swappable_support);

    EXPECT_EQ(arch_props::hashable_support, expected_props::hashable_support);
  }

  //////////////////////////////////////////////////////////////////////////////
  //                            Swappable checks                              //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::swappable_support) {
    case ti::swappable::maybe:
      EXPECT_FALSE(absl::type_traits_internal::IsSwappable<arch>::value);
      EXPECT_FALSE(absl::type_traits_internal::IsNothrowSwappable<arch>::value);
      break;
    case ti::swappable::yes:
      EXPECT_TRUE(absl::type_traits_internal::IsSwappable<arch>::value);
      EXPECT_FALSE(absl::type_traits_internal::IsNothrowSwappable<arch>::value);
      break;
    case ti::swappable::nothrow:
      EXPECT_TRUE(absl::type_traits_internal::IsSwappable<arch>::value);
      EXPECT_TRUE(absl::type_traits_internal::IsNothrowSwappable<arch>::value);
      break;
  }

  //////////////////////////////////////////////////////////////////////////////
  //                             Hashable checks                              //
  //////////////////////////////////////////////////////////////////////////////
  switch (expected_props::hashable_support) {
    case ti::hashable::maybe:
#if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
      EXPECT_FALSE(absl::type_traits_internal::IsHashable<arch>::value);
#endif  // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
      break;
    case ti::hashable::yes:
      EXPECT_TRUE(absl::type_traits_internal::IsHashable<arch>::value);
      break;
  }
}

REGISTER_TYPED_TEST_SUITE_P(ProfileTest, HasAppropriateConstructionProperties,
                            HasAppropriateAssignmentProperties,
                            HasAppropriateComparisonProperties,
                            HasAppropriateAuxilliaryProperties);

template <class Profile, class Arch, class ExpectedProfile>
struct ProfileAndExpectation {
  using profile = Profile;
  using arch = Arch;
  using expected_profile = ExpectedProfile;
};

using CoreProfilesToTest = ::testing::Types<
    // The terminating case of combine (all properties are "maybe").
    ProfileAndExpectation<ti::CombineProfiles<>,
                          ti::Archetype<ti::CombineProfiles<>>,
                          ti::ConformanceProfile<>>,

    // Core default constructor profiles
    ProfileAndExpectation<
        ti::HasDefaultConstructorProfile, ti::HasDefaultConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowDefaultConstructorProfile,
        ti::HasNothrowDefaultConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialDefaultConstructorProfile,
        ti::HasTrivialDefaultConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::trivial>>,

    // Core move constructor profiles
    ProfileAndExpectation<
        ti::HasMoveConstructorProfile, ti::HasMoveConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowMoveConstructorProfile,
        ti::HasNothrowMoveConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialMoveConstructorProfile,
        ti::HasTrivialMoveConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::trivial>>,

    // Core copy constructor profiles
    ProfileAndExpectation<
        ti::HasCopyConstructorProfile, ti::HasCopyConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::maybe,
                               ti::copy_constructible::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowCopyConstructorProfile,
        ti::HasNothrowCopyConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::maybe,
                               ti::copy_constructible::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialCopyConstructorProfile,
        ti::HasTrivialCopyConstructorArchetype,
        ti::ConformanceProfile<ti::default_constructible::maybe,
                               ti::move_constructible::maybe,
                               ti::copy_constructible::trivial>>,

    // Core move assignment profiles
    ProfileAndExpectation<
        ti::HasMoveAssignProfile, ti::HasMoveAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowMoveAssignProfile, ti::HasNothrowMoveAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialMoveAssignProfile, ti::HasTrivialMoveAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::trivial>>,

    // Core copy assignment profiles
    ProfileAndExpectation<
        ti::HasCopyAssignProfile, ti::HasCopyAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowCopyAssignProfile, ti::HasNothrowCopyAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialCopyAssignProfile, ti::HasTrivialCopyAssignArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::trivial>>,

    // Core destructor profiles
    ProfileAndExpectation<
        ti::HasDestructorProfile, ti::HasDestructorArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowDestructorProfile, ti::HasNothrowDestructorArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow>>,
    ProfileAndExpectation<
        ti::HasTrivialDestructorProfile, ti::HasTrivialDestructorArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::trivial>>,

    // Core equality comparable profiles
    ProfileAndExpectation<
        ti::HasEqualityProfile, ti::HasEqualityArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowEqualityProfile, ti::HasNothrowEqualityArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::nothrow>>,

    // Core inequality comparable profiles
    ProfileAndExpectation<
        ti::HasInequalityProfile, ti::HasInequalityArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowInequalityProfile, ti::HasNothrowInequalityArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe,
            ti::inequality_comparable::nothrow>>,

    // Core less than comparable profiles
    ProfileAndExpectation<
        ti::HasLessThanProfile, ti::HasLessThanArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowLessThanProfile, ti::HasNothrowLessThanArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::nothrow>>,

    // Core less equal comparable profiles
    ProfileAndExpectation<
        ti::HasLessEqualProfile, ti::HasLessEqualArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowLessEqualProfile, ti::HasNothrowLessEqualArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe,
            ti::less_equal_comparable::nothrow>>,

    // Core greater equal comparable profiles
    ProfileAndExpectation<
        ti::HasGreaterEqualProfile, ti::HasGreaterEqualArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowGreaterEqualProfile, ti::HasNothrowGreaterEqualArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::nothrow>>,

    // Core greater than comparable profiles
    ProfileAndExpectation<
        ti::HasGreaterThanProfile, ti::HasGreaterThanArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowGreaterThanProfile, ti::HasNothrowGreaterThanArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::nothrow>>,

    // Core swappable profiles
    ProfileAndExpectation<
        ti::HasSwapProfile, ti::HasSwapArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::yes>>,
    ProfileAndExpectation<
        ti::HasNothrowSwapProfile, ti::HasNothrowSwapArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>,

    // Core hashable profiles
    ProfileAndExpectation<
        ti::HasStdHashSpecializationProfile,
        ti::HasStdHashSpecializationArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::maybe,
            ti::hashable::yes>>>;

using CommonProfilesToTest = ::testing::Types<
    // NothrowMoveConstructible
    ProfileAndExpectation<
        ti::NothrowMoveConstructibleProfile,
        ti::NothrowMoveConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow>>,

    // CopyConstructible
    ProfileAndExpectation<
        ti::CopyConstructibleProfile, ti::CopyConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow>>,

    // NothrowMovable
    ProfileAndExpectation<
        ti::NothrowMovableProfile, ti::NothrowMovableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::nothrow,
            ti::copy_assignable::maybe, ti::destructible::nothrow,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>,

    // Value
    ProfileAndExpectation<
        ti::ValueProfile, ti::ValueArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::nothrow,
            ti::copy_assignable::yes, ti::destructible::nothrow,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>,

    ////////////////////////////////////////////////////////////////////////////
    //                  Common but also DefaultConstructible                  //
    ////////////////////////////////////////////////////////////////////////////

    // DefaultConstructibleNothrowMoveConstructible
    ProfileAndExpectation<
        ti::DefaultConstructibleNothrowMoveConstructibleProfile,
        ti::DefaultConstructibleNothrowMoveConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::yes, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow>>,

    // DefaultConstructibleCopyConstructible
    ProfileAndExpectation<
        ti::DefaultConstructibleCopyConstructibleProfile,
        ti::DefaultConstructibleCopyConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::yes, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow>>,

    // DefaultConstructibleNothrowMovable
    ProfileAndExpectation<
        ti::DefaultConstructibleNothrowMovableProfile,
        ti::DefaultConstructibleNothrowMovableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::yes, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::nothrow,
            ti::copy_assignable::maybe, ti::destructible::nothrow,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>,

    // DefaultConstructibleValue
    ProfileAndExpectation<
        ti::DefaultConstructibleValueProfile,
        ti::DefaultConstructibleValueArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::yes, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::nothrow,
            ti::copy_assignable::yes, ti::destructible::nothrow,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>>;

using ComparableHelpersProfilesToTest = ::testing::Types<
    // Equatable
    ProfileAndExpectation<
        ti::EquatableProfile, ti::EquatableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::yes, ti::inequality_comparable::yes>>,

    // Comparable
    ProfileAndExpectation<
        ti::ComparableProfile, ti::ComparableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes,
            ti::greater_than_comparable::yes>>,

    // NothrowEquatable
    ProfileAndExpectation<
        ti::NothrowEquatableProfile, ti::NothrowEquatableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::nothrow,
            ti::inequality_comparable::nothrow>>,

    // NothrowComparable
    ProfileAndExpectation<
        ti::NothrowComparableProfile, ti::NothrowComparableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::maybe,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::maybe,
            ti::equality_comparable::nothrow,
            ti::inequality_comparable::nothrow,
            ti::less_than_comparable::nothrow,
            ti::less_equal_comparable::nothrow,
            ti::greater_equal_comparable::nothrow,
            ti::greater_than_comparable::nothrow>>>;

using CommonComparableProfilesToTest = ::testing::Types<
    // ComparableNothrowMoveConstructible
    ProfileAndExpectation<
        ti::ComparableNothrowMoveConstructibleProfile,
        ti::ComparableNothrowMoveConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes,
            ti::greater_than_comparable::yes>>,

    // ComparableCopyConstructible
    ProfileAndExpectation<
        ti::ComparableCopyConstructibleProfile,
        ti::ComparableCopyConstructibleArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::maybe,
            ti::copy_assignable::maybe, ti::destructible::nothrow,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes,
            ti::greater_than_comparable::yes>>,

    // ComparableNothrowMovable
    ProfileAndExpectation<
        ti::ComparableNothrowMovableProfile,
        ti::ComparableNothrowMovableArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::maybe, ti::move_assignable::nothrow,
            ti::copy_assignable::maybe, ti::destructible::nothrow,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes,
            ti::swappable::nothrow>>,

    // ComparableValue
    ProfileAndExpectation<
        ti::ComparableValueProfile, ti::ComparableValueArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::maybe, ti::move_constructible::nothrow,
            ti::copy_constructible::yes, ti::move_assignable::nothrow,
            ti::copy_assignable::yes, ti::destructible::nothrow,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes,
            ti::swappable::nothrow>>>;

using TrivialProfilesToTest = ::testing::Types<
    ProfileAndExpectation<
        ti::TrivialSpecialMemberFunctionsProfile,
        ti::TrivialSpecialMemberFunctionsArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::trivial, ti::move_constructible::trivial,
            ti::copy_constructible::trivial, ti::move_assignable::trivial,
            ti::copy_assignable::trivial, ti::destructible::trivial,
            ti::equality_comparable::maybe, ti::inequality_comparable::maybe,
            ti::less_than_comparable::maybe, ti::less_equal_comparable::maybe,
            ti::greater_equal_comparable::maybe,
            ti::greater_than_comparable::maybe, ti::swappable::nothrow>>,

    ProfileAndExpectation<
        ti::TriviallyCompleteProfile, ti::TriviallyCompleteArchetype,
        ti::ConformanceProfile<
            ti::default_constructible::trivial, ti::move_constructible::trivial,
            ti::copy_constructible::trivial, ti::move_assignable::trivial,
            ti::copy_assignable::trivial, ti::destructible::trivial,
            ti::equality_comparable::yes, ti::inequality_comparable::yes,
            ti::less_than_comparable::yes, ti::less_equal_comparable::yes,
            ti::greater_equal_comparable::yes, ti::greater_than_comparable::yes,
            ti::swappable::nothrow, ti::hashable::yes>>>;

INSTANTIATE_TYPED_TEST_SUITE_P(Core, ProfileTest, CoreProfilesToTest);
INSTANTIATE_TYPED_TEST_SUITE_P(Common, ProfileTest, CommonProfilesToTest);
INSTANTIATE_TYPED_TEST_SUITE_P(ComparableHelpers, ProfileTest,
                               ComparableHelpersProfilesToTest);
INSTANTIATE_TYPED_TEST_SUITE_P(CommonComparable, ProfileTest,
                               CommonComparableProfilesToTest);
INSTANTIATE_TYPED_TEST_SUITE_P(Trivial, ProfileTest, TrivialProfilesToTest);

// TODO(calabrese) Test runtime results

}  // namespace