//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14, c++17

// <iterator>
//
// reverse_iterator
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template <class Iterator1, class Iterator2>
// constexpr bool                          // constexpr in C++17
// operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
//
// template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
//  constexpr compare_three_way_result_t<Iterator1, Iterator2>
//    operator<=>(const reverse_iterator<Iterator1>& x,
//                const reverse_iterator<Iterator2>& y);

#include <iterator>
#include <cassert>
#include <cstddef>

#include "test_macros.h"

struct IterBase {
  using iterator_category = std::bidirectional_iterator_tag;
  using value_type = int;
  using difference_type = std::ptrdiff_t;
  using pointer = int*;
  using reference = int&;

  reference operator*() const;
  pointer operator->() const;
};

template<class T> concept HasEqual = requires (T t) { t == t; };
template<class T> concept HasNotEqual = requires (T t) { t != t; };
template<class T> concept HasLess = requires (T t) { t < t; };
template<class T> concept HasLessOrEqual = requires (T t) { t <= t; };
template<class T> concept HasGreater = requires (T t) { t > t; };
template<class T> concept HasGreaterOrEqual = requires (T t) { t >= t; };
template<class T> concept HasSpaceship = requires (T t) { t <=> t; };

// operator ==

struct NoEqualityCompIter : IterBase {
  bool operator!=(NoEqualityCompIter) const;
  bool operator<(NoEqualityCompIter) const;
  bool operator>(NoEqualityCompIter) const;
  bool operator<=(NoEqualityCompIter) const;
  bool operator>=(NoEqualityCompIter) const;
};

static_assert( HasEqual<std::reverse_iterator<int*>>);
static_assert(!HasEqual<std::reverse_iterator<NoEqualityCompIter>>);
static_assert( HasNotEqual<std::reverse_iterator<NoEqualityCompIter>>);
static_assert( HasLess<std::reverse_iterator<NoEqualityCompIter>>);
static_assert( HasLessOrEqual<std::reverse_iterator<NoEqualityCompIter>>);
static_assert( HasGreater<std::reverse_iterator<NoEqualityCompIter>>);
static_assert( HasGreaterOrEqual<std::reverse_iterator<NoEqualityCompIter>>);

void Foo() {
  std::reverse_iterator<NoEqualityCompIter> i;
  (void)i;
}

// operator !=

struct NoInequalityCompIter : IterBase {
  bool operator<(NoInequalityCompIter) const;
  bool operator>(NoInequalityCompIter) const;
  bool operator<=(NoInequalityCompIter) const;
  bool operator>=(NoInequalityCompIter) const;
};

static_assert( HasNotEqual<std::reverse_iterator<int*>>);
static_assert(!HasNotEqual<std::reverse_iterator<NoInequalityCompIter>>);
static_assert(!HasEqual<std::reverse_iterator<NoInequalityCompIter>>);
static_assert( HasLess<std::reverse_iterator<NoInequalityCompIter>>);
static_assert( HasLessOrEqual<std::reverse_iterator<NoInequalityCompIter>>);
static_assert( HasGreater<std::reverse_iterator<NoInequalityCompIter>>);
static_assert( HasGreaterOrEqual<std::reverse_iterator<NoInequalityCompIter>>);

// operator <

struct NoGreaterCompIter : IterBase {
  bool operator==(NoGreaterCompIter) const;
  bool operator!=(NoGreaterCompIter) const;
  bool operator<(NoGreaterCompIter) const;
  bool operator<=(NoGreaterCompIter) const;
  bool operator>=(NoGreaterCompIter) const;
};

static_assert( HasLess<std::reverse_iterator<int*>>);
static_assert(!HasLess<std::reverse_iterator<NoGreaterCompIter>>);
static_assert( HasEqual<std::reverse_iterator<NoGreaterCompIter>>);
static_assert( HasNotEqual<std::reverse_iterator<NoGreaterCompIter>>);
static_assert( HasLessOrEqual<std::reverse_iterator<NoGreaterCompIter>>);
static_assert( HasGreater<std::reverse_iterator<NoGreaterCompIter>>);
static_assert( HasGreaterOrEqual<std::reverse_iterator<NoGreaterCompIter>>);

// operator >

struct NoLessCompIter : IterBase {
  bool operator==(NoLessCompIter) const;
  bool operator!=(NoLessCompIter) const;
  bool operator>(NoLessCompIter) const;
  bool operator<=(NoLessCompIter) const;
  bool operator>=(NoLessCompIter) const;
};

static_assert( HasGreater<std::reverse_iterator<int*>>);
static_assert(!HasGreater<std::reverse_iterator<NoLessCompIter>>);
static_assert( HasEqual<std::reverse_iterator<NoLessCompIter>>);
static_assert( HasNotEqual<std::reverse_iterator<NoLessCompIter>>);
static_assert( HasLess<std::reverse_iterator<NoLessCompIter>>);
static_assert( HasLessOrEqual<std::reverse_iterator<NoLessCompIter>>);
static_assert( HasGreaterOrEqual<std::reverse_iterator<NoLessCompIter>>);

// operator <=

struct NoGreaterOrEqualCompIter : IterBase {
  bool operator==(NoGreaterOrEqualCompIter) const;
  bool operator!=(NoGreaterOrEqualCompIter) const;
  bool operator<(NoGreaterOrEqualCompIter) const;
  bool operator>(NoGreaterOrEqualCompIter) const;
  bool operator<=(NoGreaterOrEqualCompIter) const;
};

static_assert( HasLessOrEqual<std::reverse_iterator<int*>>);
static_assert(!HasLessOrEqual<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert( HasEqual<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert( HasNotEqual<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert( HasLess<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert( HasGreater<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert( HasGreaterOrEqual<std::reverse_iterator<NoGreaterOrEqualCompIter>>);

// operator >=

struct NoLessOrEqualCompIter : IterBase {
  bool operator==(NoLessOrEqualCompIter) const;
  bool operator!=(NoLessOrEqualCompIter) const;
  bool operator<(NoLessOrEqualCompIter) const;
  bool operator>(NoLessOrEqualCompIter) const;
  bool operator>=(NoLessOrEqualCompIter) const;
};

static_assert( HasGreaterOrEqual<std::reverse_iterator<int*>>);
static_assert(!HasGreaterOrEqual<std::reverse_iterator<NoLessOrEqualCompIter>>);
static_assert( HasEqual<std::reverse_iterator<NoLessOrEqualCompIter>>);
static_assert( HasNotEqual<std::reverse_iterator<NoLessOrEqualCompIter>>);
static_assert( HasLess<std::reverse_iterator<NoLessOrEqualCompIter>>);
static_assert( HasLessOrEqual<std::reverse_iterator<NoLessOrEqualCompIter>>);
static_assert( HasGreater<std::reverse_iterator<NoLessOrEqualCompIter>>);

// operator <=>

static_assert( std::three_way_comparable_with<int*, int*>);
static_assert( HasSpaceship<std::reverse_iterator<int*>>);
static_assert(!std::three_way_comparable_with<NoEqualityCompIter, NoEqualityCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoEqualityCompIter>>);
static_assert(!std::three_way_comparable_with<NoInequalityCompIter, NoInequalityCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoInequalityCompIter>>);
static_assert(!std::three_way_comparable_with<NoGreaterCompIter, NoGreaterCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoGreaterCompIter>>);
static_assert(!std::three_way_comparable_with<NoLessCompIter, NoLessCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoLessCompIter>>);
static_assert(!std::three_way_comparable_with<NoGreaterOrEqualCompIter, NoGreaterOrEqualCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoGreaterOrEqualCompIter>>);
static_assert(!std::three_way_comparable_with<NoLessOrEqualCompIter, NoLessOrEqualCompIter>);
static_assert(!HasSpaceship<std::reverse_iterator<NoLessOrEqualCompIter>>);
