// 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 "absl/types/internal/conformance_testing.h"

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

#include "gtest/gtest.h"
#include "absl/meta/type_traits.h"
#include "absl/types/internal/conformance_aliases.h"
#include "absl/types/internal/conformance_profile.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);

TEST(ConformanceTestingTest, Basic) {
  using profile = ti::CombineProfiles<ti::TriviallyCompleteProfile,
                                      ti::NothrowComparableProfile>;

  using lim = std::numeric_limits<float>;

  ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(float)
      .INITIALIZER(-lim::infinity())
      .INITIALIZER(lim::lowest())
      .INITIALIZER(-1.f)
      .INITIALIZER(-lim::min())
      .EQUIVALENCE_CLASS(INITIALIZER(-0.f), INITIALIZER(0.f))
      .INITIALIZER(lim::min())
      .INITIALIZER(1.f)
      .INITIALIZER(lim::max())
      .INITIALIZER(lim::infinity())
      .WITH_STRICT_PROFILE(absl::types_internal::RegularityDomain, profile);
}

struct BadMoveConstruct {
  BadMoveConstruct() = default;
  BadMoveConstruct(BadMoveConstruct&& other) noexcept
      : value(other.value + 1) {}
  BadMoveConstruct& operator=(BadMoveConstruct&& other) noexcept = default;
  int value = 0;

  friend bool operator==(BadMoveConstruct const& lhs,
                         BadMoveConstruct const& rhs) {
    return lhs.value == rhs.value;
  }
  friend bool operator!=(BadMoveConstruct const& lhs,
                         BadMoveConstruct const& rhs) {
    return lhs.value != rhs.value;
  }
};

struct BadMoveAssign {
  BadMoveAssign() = default;
  BadMoveAssign(BadMoveAssign&& other) noexcept = default;
  BadMoveAssign& operator=(BadMoveAssign&& other) noexcept {
    int new_value = other.value + 1;
    value = new_value;
    return *this;
  }
  int value = 0;

  friend bool operator==(BadMoveAssign const& lhs, BadMoveAssign const& rhs) {
    return lhs.value == rhs.value;
  }
  friend bool operator!=(BadMoveAssign const& lhs, BadMoveAssign const& rhs) {
    return lhs.value != rhs.value;
  }
};

enum class WhichCompIsBad { eq, ne, lt, le, ge, gt };

template <WhichCompIsBad Which>
struct BadCompare {
  int value;

  friend bool operator==(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::eq ? lhs.value != rhs.value
                                       : lhs.value == rhs.value;
  }

  friend bool operator!=(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::ne ? lhs.value == rhs.value
                                       : lhs.value != rhs.value;
  }

  friend bool operator<(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::lt ? lhs.value >= rhs.value
                                       : lhs.value < rhs.value;
  }

  friend bool operator<=(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::le ? lhs.value > rhs.value
                                       : lhs.value <= rhs.value;
  }

  friend bool operator>=(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::ge ? lhs.value < rhs.value
                                       : lhs.value >= rhs.value;
  }

  friend bool operator>(BadCompare const& lhs, BadCompare const& rhs) {
    return Which == WhichCompIsBad::gt ? lhs.value <= rhs.value
                                       : lhs.value > rhs.value;
  }
};

TEST(ConformanceTestingDeathTest, Failures) {
  {
    using profile = ti::CombineProfiles<ti::TriviallyCompleteProfile,
                                        ti::NothrowComparableProfile>;

    // Note: The initializers are intentionally in the wrong order.
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(float)
        .INITIALIZER(1.f)
        .INITIALIZER(0.f)
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using profile =
        ti::CombineProfiles<ti::NothrowMovableProfile, ti::EquatableProfile>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadMoveConstruct)
        .DUE_TO("Move construction")
        .INITIALIZER(BadMoveConstruct())
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using profile =
        ti::CombineProfiles<ti::NothrowMovableProfile, ti::EquatableProfile>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadMoveAssign)
        .DUE_TO("Move assignment")
        .INITIALIZER(BadMoveAssign())
        .WITH_LOOSE_PROFILE(profile);
  }
}

TEST(ConformanceTestingDeathTest, CompFailures) {
  using profile = ti::ComparableProfile;

  {
    using BadComp = BadCompare<WhichCompIsBad::eq>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using BadComp = BadCompare<WhichCompIsBad::ne>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using BadComp = BadCompare<WhichCompIsBad::lt>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using BadComp = BadCompare<WhichCompIsBad::le>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using BadComp = BadCompare<WhichCompIsBad::ge>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }

  {
    using BadComp = BadCompare<WhichCompIsBad::gt>;

    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadComp)
        .DUE_TO("Comparison")
        .INITIALIZER(BadComp{0})
        .INITIALIZER(BadComp{1})
        .WITH_LOOSE_PROFILE(profile);
  }
}

struct BadSelfMove {
  BadSelfMove() = default;
  BadSelfMove(BadSelfMove&&) = default;
  BadSelfMove& operator=(BadSelfMove&& other) noexcept {
    if (this == &other) {
      broken_state = true;
    }
    return *this;
  }

  friend bool operator==(const BadSelfMove& lhs, const BadSelfMove& rhs) {
    return !(lhs.broken_state || rhs.broken_state);
  }

  friend bool operator!=(const BadSelfMove& lhs, const BadSelfMove& rhs) {
    return lhs.broken_state || rhs.broken_state;
  }

  bool broken_state = false;
};

TEST(ConformanceTestingDeathTest, SelfMoveFailure) {
  using profile = ti::EquatableNothrowMovableProfile;

  {
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfMove)
        .DUE_TO("Move assignment")
        .INITIALIZER(BadSelfMove())
        .WITH_LOOSE_PROFILE(profile);
  }
}

struct BadSelfCopy {
  BadSelfCopy() = default;
  BadSelfCopy(BadSelfCopy&&) = default;
  BadSelfCopy(const BadSelfCopy&) = default;
  BadSelfCopy& operator=(BadSelfCopy&&) = default;
  BadSelfCopy& operator=(BadSelfCopy const& other) {
    if (this == &other) {
      broken_state = true;
    }
    return *this;
  }

  friend bool operator==(const BadSelfCopy& lhs, const BadSelfCopy& rhs) {
    return !(lhs.broken_state || rhs.broken_state);
  }

  friend bool operator!=(const BadSelfCopy& lhs, const BadSelfCopy& rhs) {
    return lhs.broken_state || rhs.broken_state;
  }

  bool broken_state = false;
};

TEST(ConformanceTestingDeathTest, SelfCopyFailure) {
  using profile = ti::EquatableValueProfile;

  {
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfCopy)
        .DUE_TO("Copy assignment")
        .INITIALIZER(BadSelfCopy())
        .WITH_LOOSE_PROFILE(profile);
  }
}

struct BadSelfSwap {
  friend void swap(BadSelfSwap& lhs, BadSelfSwap& rhs) noexcept {
    if (&lhs == &rhs) lhs.broken_state = true;
  }

  friend bool operator==(const BadSelfSwap& lhs, const BadSelfSwap& rhs) {
    return !(lhs.broken_state || rhs.broken_state);
  }

  friend bool operator!=(const BadSelfSwap& lhs, const BadSelfSwap& rhs) {
    return lhs.broken_state || rhs.broken_state;
  }

  bool broken_state = false;
};

TEST(ConformanceTestingDeathTest, SelfSwapFailure) {
  using profile = ti::EquatableNothrowMovableProfile;

  {
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadSelfSwap)
        .DUE_TO("Swap")
        .INITIALIZER(BadSelfSwap())
        .WITH_LOOSE_PROFILE(profile);
  }
}

struct BadDefaultInitializedMoveAssign {
  BadDefaultInitializedMoveAssign() : default_initialized(true) {}
  explicit BadDefaultInitializedMoveAssign(int v) : value(v) {}
  BadDefaultInitializedMoveAssign(
      BadDefaultInitializedMoveAssign&& other) noexcept
      : value(other.value) {}
  BadDefaultInitializedMoveAssign& operator=(
      BadDefaultInitializedMoveAssign&& other) noexcept {
    value = other.value;
    if (default_initialized) ++value;  // Bad move if lhs is default initialized
    return *this;
  }

  friend bool operator==(const BadDefaultInitializedMoveAssign& lhs,
                         const BadDefaultInitializedMoveAssign& rhs) {
    return lhs.value == rhs.value;
  }

  friend bool operator!=(const BadDefaultInitializedMoveAssign& lhs,
                         const BadDefaultInitializedMoveAssign& rhs) {
    return lhs.value != rhs.value;
  }

  bool default_initialized = false;
  int value = 0;
};

TEST(ConformanceTestingDeathTest, DefaultInitializedMoveAssignFailure) {
  using profile =
      ti::CombineProfiles<ti::DefaultConstructibleNothrowMovableProfile,
                          ti::EquatableProfile>;

  {
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadDefaultInitializedMoveAssign)
        .DUE_TO("move assignment")
        .INITIALIZER(BadDefaultInitializedMoveAssign(0))
        .WITH_LOOSE_PROFILE(profile);
  }
}

struct BadDefaultInitializedCopyAssign {
  BadDefaultInitializedCopyAssign() : default_initialized(true) {}
  explicit BadDefaultInitializedCopyAssign(int v) : value(v) {}
  BadDefaultInitializedCopyAssign(
      BadDefaultInitializedCopyAssign&& other) noexcept
      : value(other.value) {}
  BadDefaultInitializedCopyAssign(const BadDefaultInitializedCopyAssign& other)
      : value(other.value) {}

  BadDefaultInitializedCopyAssign& operator=(
      BadDefaultInitializedCopyAssign&& other) noexcept {
    value = other.value;
    return *this;
  }

  BadDefaultInitializedCopyAssign& operator=(
      const BadDefaultInitializedCopyAssign& other) {
    value = other.value;
    if (default_initialized) ++value;  // Bad move if lhs is default initialized
    return *this;
  }

  friend bool operator==(const BadDefaultInitializedCopyAssign& lhs,
                         const BadDefaultInitializedCopyAssign& rhs) {
    return lhs.value == rhs.value;
  }

  friend bool operator!=(const BadDefaultInitializedCopyAssign& lhs,
                         const BadDefaultInitializedCopyAssign& rhs) {
    return lhs.value != rhs.value;
  }

  bool default_initialized = false;
  int value = 0;
};

TEST(ConformanceTestingDeathTest, DefaultInitializedAssignFailure) {
  using profile = ti::CombineProfiles<ti::DefaultConstructibleValueProfile,
                                      ti::EquatableProfile>;

  {
    ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(BadDefaultInitializedCopyAssign)
        .DUE_TO("copy assignment")
        .INITIALIZER(BadDefaultInitializedCopyAssign(0))
        .WITH_LOOSE_PROFILE(profile);
  }
}

}  // namespace