[libc++] [test] Use hidden friends consistently in the test iterators

[philnik]

LGTM % comment

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

26225

Not in this PR, but maybe this test should be split into multiple tests? 26k lines might be a bit to long.

libcxx/test/support/test_iterators.h

132–133

Please put this below operator!= to be consistent with the others.

[• Quuxplusone]

Fix the C++03 test failure (reverse_iterator's operator- is not SFINAEd away in C++03 mode).
non_default_constructible_iterator is redundant and should be removed entirely, but I'll make a separate PR for that.

[• Quuxplusone]

Fix https://reviews.llvm.org/harbormaster/unit/view/1854834/

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp

 #include "test_iterators.h"
 
 template <class It, class U>
 void
 test(U u)
 {
     const std::move_iterator<U> r2(u);
     std::move_iterator<It> r1 = r2;
-    assert(r1.base() == u);
+    assert(base(r1.base()) == base(u));
 }
 
 struct Base {};
 struct Derived : Base {};
 
 int main(int, char**)
 {
     Derived d;

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp

 
 template <class It, class U>
 void
 test(U u)
 {
     const std::move_iterator<U> r2(u);
     std::move_iterator<It> r1(It(nullptr));
     std::move_iterator<It>& rr = (r1 = r2);
-    assert(r1.base() == u);
+    assert(base(r1.base()) == base(u));
     assert(&rr == &r1);
 }
 
 struct Base {};
 struct Derived : Base {};
 
 struct ToIter {
     typedef std::forward_iterator_tag iterator_category;

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cons/assign.pass.cpp

 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>
 TEST_CONSTEXPR_CXX17 void test(U u) {
     const std::reverse_iterator<U> r2(u);
     std::reverse_iterator<It> r1;
     std::reverse_iterator<It>& rr = r1 = r2;
-    assert(r1.base() == u);
+    assert(base(r1.base()) == base(u));
     assert(&rr == &r1);
 }
 
 struct Base { };
 struct Derived : Base { };
 
 struct ToIter {
     typedef std::bidirectional_iterator_tag iterator_category;

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cons/ctor.reverse_iterator.pass.cpp

 
 struct Base { };
 struct Derived : Base { };
 
 template <class It, class U>
 TEST_CONSTEXPR_CXX17 void test(U u) {
     const std::reverse_iterator<U> r2(u);
     std::reverse_iterator<It> r1 = r2;
-    assert(r1.base() == u);
+    assert(base(r1.base()) == base(u));
 }
 
 TEST_CONSTEXPR_CXX17 bool tests() {
     Derived d;
     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
     return true;

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/minus.pass.cpp

 // template <RandomAccessIterator Iter1, RandomAccessIterator Iter2>
 //   requires HasMinus<Iter2, Iter1>
 // auto operator-(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y) // constexpr in C++17
 //  -> decltype(y.base() - x.base());
 
 #include <iterator>
 #include <cstddef>
 #include <cassert>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
+template <class, class, class = void> struct HasMinus : std::false_type {};
+template <class R1, class R2> struct HasMinus<R1, R2, decltype((R1() - R2(), void()))> : std::true_type {};
+
 template <class It1, class It2>
 TEST_CONSTEXPR_CXX17 void test(It1 l, It2 r, std::ptrdiff_t x) {
     const std::reverse_iterator<It1> r1(l);
     const std::reverse_iterator<It2> r2(r);
     assert((r1 - r2) == x);
 }
 
 TEST_CONSTEXPR_CXX17 bool tests() {
+    using PC = const char*;
     char s[3] = {0};
-    test(random_access_iterator<const char*>(s), random_access_iterator<char*>(s), 0);
-    test(random_access_iterator<char*>(s), random_access_iterator<const char*>(s+1), 1);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<char*>(s), -1);
+
+    // Test same base iterator type
     test(s, s, 0);
     test(s, s+1, 1);
     test(s+1, s, -1);
+
+    // Test different (but subtractable) base iterator types
+    test(PC(s), s, 0);
+    test(PC(s), s+1, 1);
+    test(PC(s+1), s, -1);
+
+    // Test non-subtractable base iterator types
+    static_assert( HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<int*> >::value, "");
+    static_assert( HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<const int*> >::value, "");
+#if TEST_STD_VER >= 11
+    static_assert(!HasMinus<std::reverse_iterator<int*>, std::reverse_iterator<char*> >::value, "");
+    static_assert(!HasMinus<std::reverse_iterator<bidirectional_iterator<int*> >, std::reverse_iterator<bidirectional_iterator<int*> > >::value, "");
+#endif
+
     return true;
 }
 
 int main(int, char**) {
     tests();
 #if TEST_STD_VER > 14
     static_assert(tests(), "");
 #endif
     return 0;
 }

libcxx/test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

             {
             }
         }
     }
 }
 
 void test12()
 {
-    output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
 #if defined(__APPLE__) && defined(__x86_64__)
 // This test is failing on FreeBSD, possibly due to different representations
 // of the floating point numbers.
+    output_iterator<char*> iter;
     const my_facet f(1);
     char str[200];
     {
         long double v = 1234567890.125;
         std::ios ios(0);
         hexfloat(ios);
         // %a
         {
int main(int, char**)
     test5();
     test6();
     test7();
     test8();
     test9();
     test10();
     test11();
     test12();
-    output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
     const my_facet f(1);
     {
         long double v = -INFINITY; ((void)v);
     }
     {
         long double v = std::nan(""); ((void)v);
     }

libcxx/test/support/test_iterators.h

class output_iterator
     template <class U> friend class output_iterator;
 public:
     typedef          std::output_iterator_tag                  iterator_category;
     typedef void                                               value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
-    TEST_CONSTEXPR_CXX14 output_iterator() {}
-    explicit TEST_CONSTEXPR_CXX14 output_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR output_iterator() : it_() {}
+    TEST_CONSTEXPR explicit output_iterator(It it) : it_(std::move(it)) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 output_iterator(const output_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR output_iterator(const output_iterator<U>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
 
     TEST_CONSTEXPR_CXX14 output_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
-        {output_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 output_iterator operator++(int) {return output_iterator(it_++);}
 
+    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const output_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 // This is the Cpp17InputIterator requirement as described in Table 87 ([input.iterators]),
 // formerly known as InputIterator prior to C++20.
 template <class It, class ItTraits = It>
 class cpp17_input_iterator
 {
     typedef std::iterator_traits<ItTraits> Traits;
     It it_;
 
     template <class U, class T> friend class cpp17_input_iterator;
 public:
     typedef          std::input_iterator_tag                   iterator_category;
     typedef typename Traits::value_type                        value_type;
     typedef typename Traits::difference_type                   difference_type;
     typedef It                                                 pointer;
     typedef typename Traits::reference                         reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
-    explicit TEST_CONSTEXPR_CXX14 cpp17_input_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR explicit cpp17_input_iterator(It it) : it_(it) {}
     template <class U, class T>
-        TEST_CONSTEXPR_CXX14 cpp17_input_iterator(const cpp17_input_iterator<U, T>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR cpp17_input_iterator(const cpp17_input_iterator<U, T>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
-    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 cpp17_input_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int)
-        {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 cpp17_input_iterator operator++(int) {return cpp17_input_iterator(it_++);}
 
-    friend TEST_CONSTEXPR_CXX14 bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
-        {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
-        {return !(x == y);}
+    friend TEST_CONSTEXPR bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y) {return x.it_ != y.it_;}
 
+    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const cpp17_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
-template <class T, class TV, class U, class UV>
-bool operator==(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
-{
-    return x.base() == y.base();
-}
-
-template <class T, class TV, class U, class UV>
-bool operator!=(const cpp17_input_iterator<T, TV>& x, const cpp17_input_iterator<U, UV>& y)
-{
-    return !(x == y);
-}
-
 template <class It>
 class forward_iterator
 {
     It it_;
 
     template <class U> friend class forward_iterator;
 public:
     typedef          std::forward_iterator_tag                 iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
-    TEST_CONSTEXPR_CXX14 forward_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 forward_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR forward_iterator() : it_() {}
+    TEST_CONSTEXPR explicit forward_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR forward_iterator(const forward_iterator<U>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
-    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 forward_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 forward_iterator operator++(int)
-        {forward_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 forward_iterator operator++(int) {return forward_iterator(it_++);}
 
-    friend TEST_CONSTEXPR_CXX14 bool operator==(const forward_iterator& x, const forward_iterator& y)
-        {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(const forward_iterator& x, const forward_iterator& y)
-        {return !(x == y);}
+    friend TEST_CONSTEXPR bool operator==(const forward_iterator& x, const forward_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const forward_iterator& x, const forward_iterator& y) {return x.it_ != y.it_;}
 
+    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const forward_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
-{
-    return x.base() == y.base();
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
-{
-    return !(x == y);
-}
-
 template <class It>
 class non_default_constructible_iterator
 {
     It it_;
 
     template <class U> friend class non_default_constructible_iterator;
 public:
     typedef          std::input_iterator_tag                   iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
     non_default_constructible_iterator() = delete;
 
-    explicit TEST_CONSTEXPR_CXX14 non_default_constructible_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR explicit non_default_constructible_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 non_default_constructible_iterator(const non_default_constructible_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR non_default_constructible_iterator(const non_default_constructible_iterator<U>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
-    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 non_default_constructible_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 non_default_constructible_iterator operator++(int)
-        {non_default_constructible_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 non_default_constructible_iterator operator++(int) {return non_default_constructible_iterator(it_++);}
 
-    friend TEST_CONSTEXPR_CXX14 bool operator==(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y)
-        {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y)
-        {return !(x == y);}
+    friend TEST_CONSTEXPR bool operator==(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y) {return x.it_ != y.it_;}
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator==(const non_default_constructible_iterator<T>& x, const non_default_constructible_iterator<U>& y)
-{
-    return x.base() == y.base();
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator!=(const non_default_constructible_iterator<T>& x, const non_default_constructible_iterator<U>& y)
-{
-    return !(x == y);
-}
-
 template <class It>
 class bidirectional_iterator
 {
     It it_;
 
     template <class U> friend class bidirectional_iterator;
 public:
     typedef          std::bidirectional_iterator_tag           iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 bidirectional_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR bidirectional_iterator() : it_() {}
+    TEST_CONSTEXPR explicit bidirectional_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR bidirectional_iterator(const bidirectional_iterator<U>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
-    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int)
-        {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
-
     TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int)
-        {bidirectional_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int) {return bidirectional_iterator(it_++);}
+    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int) {return bidirectional_iterator(it_--);}
 
+    friend TEST_CONSTEXPR bool operator==(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const bidirectional_iterator& x, const bidirectional_iterator& y) {return x.it_ != y.it_;}
+
+    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const bidirectional_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
-{
-    return x.base() == y.base();
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
-{
-    return !(x == y);
-}
-
 template <class It>
 class random_access_iterator
 {
     It it_;
 
     template <class U> friend class random_access_iterator;
 public:
     typedef          std::random_access_iterator_tag           iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
-
-    TEST_CONSTEXPR_CXX14 random_access_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 random_access_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR random_access_iterator() : it_() {}
+    TEST_CONSTEXPR explicit random_access_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR random_access_iterator(const random_access_iterator<U>& u) : it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
 
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator++(int)
-        {random_access_iterator tmp(*this); ++(*this); return tmp;}
-
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator--(int)
-        {random_access_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 random_access_iterator operator++(int) {return random_access_iterator(it_++);}
+    TEST_CONSTEXPR_CXX14 random_access_iterator operator--(int) {return random_access_iterator(it_--);}
 
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n) const
-        {random_access_iterator tmp(*this); tmp += n; return tmp;}
-    friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n, random_access_iterator x)
-        {x += n; return x;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator& operator-=(difference_type n) {return *this += -n;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator-(difference_type n) const
-        {random_access_iterator tmp(*this); tmp -= n; return tmp;}
-
-    TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
+    TEST_CONSTEXPR_CXX14 random_access_iterator& operator-=(difference_type n) {it_ -= n; return *this;}
+    friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(random_access_iterator x, difference_type n) {x += n; return x;}
+    friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n, random_access_iterator x) {x += n; return x;}
+    friend TEST_CONSTEXPR_CXX14 random_access_iterator operator-(random_access_iterator x, difference_type n) {x -= n; return x;}
+    friend TEST_CONSTEXPR difference_type operator-(random_access_iterator x, random_access_iterator y) {return x.it_ - y.it_;}
+
+    friend TEST_CONSTEXPR bool operator==(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ != y.it_;}
+    friend TEST_CONSTEXPR bool operator< (const random_access_iterator& x, const random_access_iterator& y) {return x.it_ <  y.it_;}
+    friend TEST_CONSTEXPR bool operator<=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ <= y.it_;}
+    friend TEST_CONSTEXPR bool operator> (const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >  y.it_;}
+    friend TEST_CONSTEXPR bool operator>=(const random_access_iterator& x, const random_access_iterator& y) {return x.it_ >= y.it_;}
 
+    TEST_CONSTEXPR It base() const {return it_;} // TODO remove me
     friend TEST_CONSTEXPR It base(const random_access_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return x.base() == y.base();
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return !(x == y);
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return x.base() < y.base();
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return !(y < x);
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return y < x;
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-bool operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return !(x < y);
-}
-
-template <class T, class U>
-TEST_CONSTEXPR_CXX14
-typename std::iterator_traits<T>::difference_type
-operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
-{
-    return x.base() - y.base();
-}
-
 #if TEST_STD_VER > 17
 template <class It>
 class contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
     It it_;
 
     template <class U> friend class contiguous_iterator;
 public:
     typedef          std::contiguous_iterator_tag              iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
     typedef typename std::iterator_traits<It>::difference_type difference_type;
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
     typedef typename std::remove_pointer<It>::type             element_type;
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 contiguous_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 explicit contiguous_iterator(It it) : it_(it) {}
     template <class U>
         TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) : it_(u.it_) {}
 
-    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
-    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
+    TEST_CONSTEXPR reference operator[](difference_type n) const {return it_[n];}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator++(int)
-        {contiguous_iterator tmp(*this); ++(*this); return tmp;}
-
     TEST_CONSTEXPR_CXX14 contiguous_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator--(int)
-        {contiguous_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 contiguous_iterator operator++(int) {return contiguous_iterator(it_++);}
+    TEST_CONSTEXPR_CXX14 contiguous_iterator operator--(int) {return contiguous_iterator(it_--);}
 
     TEST_CONSTEXPR_CXX14 contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n) const
-        {contiguous_iterator tmp(*this); tmp += n; return tmp;}
-    friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n, contiguous_iterator x)
-        {x += n; return x;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator-(difference_type n) const
-        {contiguous_iterator tmp(*this); tmp -= n; return tmp;}
+    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator-=(difference_type n) {it_ -= n; return *this;}
+    friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(contiguous_iterator x, difference_type n) {x += n; return x;}
+    friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n, contiguous_iterator x) {x += n; return x;}
+    friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator-(contiguous_iterator x, difference_type n) {x -= n; return x;}
+    friend TEST_CONSTEXPR difference_type operator-(contiguous_iterator x, contiguous_iterator y) {return x.it_ - y.it_;}
+
+    friend TEST_CONSTEXPR bool operator==(const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ != y.it_;}
+    friend TEST_CONSTEXPR bool operator< (const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ <  y.it_;}
+    friend TEST_CONSTEXPR bool operator<=(const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ <= y.it_;}
+    friend TEST_CONSTEXPR bool operator> (const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ >  y.it_;}
+    friend TEST_CONSTEXPR bool operator>=(const contiguous_iterator& x, const contiguous_iterator& y) {return x.it_ >= y.it_;}
 
-    TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
+    friend TEST_CONSTEXPR It base(const contiguous_iterator& i) { return i.it_; }
 
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator-(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() - y.base();
-    }
-
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator<(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() < y.base();
-    }
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator>(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() > y.base();
-    }
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator<=(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() <= y.base();
-    }
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator>=(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() >= y.base();
-    }
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator==(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() == y.base();
-    }
-    friend TEST_CONSTEXPR_CXX14
-    difference_type operator!=(const contiguous_iterator& x, const contiguous_iterator& y) {
-        return x.base() != y.base();
-    }
+    template <class T>
+    void operator,(T const &) = delete;
+};
 
-    friend TEST_CONSTEXPR It base(const contiguous_iterator& i) { return i.it_; }
+template <class It>
+class three_way_contiguous_iterator
+{
+    static_assert(std::is_pointer_v<It>, "Things probably break in this case");
+
+    It it_;
+
+    template <class U> friend class three_way_contiguous_iterator;
+public:
+    typedef          std::contiguous_iterator_tag              iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+    typedef typename std::remove_pointer<It>::type             element_type;
+
+    constexpr It base() const {return it_;}
+
+    constexpr three_way_contiguous_iterator() : it_() {}
+    constexpr explicit three_way_contiguous_iterator(It it) : it_(it) {}
+    template <class U>
+    constexpr three_way_contiguous_iterator(const three_way_contiguous_iterator<U>& u) : it_(u.it_) {}
+
+    constexpr reference operator*() const {return *it_;}
+    constexpr pointer operator->() const {return it_;}
+    constexpr reference operator[](difference_type n) const {return it_[n];}
+
+    constexpr three_way_contiguous_iterator& operator++() {++it_; return *this;}
+    constexpr three_way_contiguous_iterator& operator--() {--it_; return *this;}
+    constexpr three_way_contiguous_iterator operator++(int) {return three_way_contiguous_iterator(it_++);}
+    constexpr three_way_contiguous_iterator operator--(int) {return three_way_contiguous_iterator(it_--);}
+
+    constexpr three_way_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+    constexpr three_way_contiguous_iterator& operator-=(difference_type n) {it_ -= n; return *this;}
+    friend constexpr three_way_contiguous_iterator operator+(three_way_contiguous_iterator x, difference_type n) {x += n; return x;}
+    friend constexpr three_way_contiguous_iterator operator+(difference_type n, three_way_contiguous_iterator x) {x += n; return x;}
+    friend constexpr three_way_contiguous_iterator operator-(three_way_contiguous_iterator x, difference_type n) {x -= n; return x;}
+    friend constexpr difference_type operator-(three_way_contiguous_iterator x, three_way_contiguous_iterator y) {return x.it_ - y.it_;}
+
+    friend constexpr auto operator<=>(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {return x.it_ <=> y.it_;}
+    friend constexpr bool operator==(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {return x.it_ == y.it_;}
 
     template <class T>
     void operator,(T const &) = delete;
 };
-#endif
+#endif // TEST_STD_VER > 17
 
 template <class Iter> // ADL base() for everything else (including pointers)
-TEST_CONSTEXPR_CXX14 Iter base(Iter i) { return i; }
+TEST_CONSTEXPR Iter base(Iter i) { return i; }
 
 template <typename T>
 struct ThrowingIterator {
     typedef std::bidirectional_iterator_tag iterator_category;
     typedef ptrdiff_t                       difference_type;
     typedef const T                         value_type;
     typedef const T *                       pointer;
     typedef const T &                       reference;

 
 private:
     const T *begin_;
     const T *end_;
     const T *current_;
 };
 
 #ifdef TEST_SUPPORTS_RANGES
-
 template <class It>
 class cpp20_input_iterator
 {
     It it_;
 
 public:
     using value_type = std::iter_value_t<It>;
     using difference_type = std::iter_difference_t<It>;
     using iterator_concept = std::input_iterator_tag;
 
     constexpr explicit cpp20_input_iterator(It it) : it_(it) {}
     cpp20_input_iterator(cpp20_input_iterator&&) = default;
     cpp20_input_iterator& operator=(cpp20_input_iterator&&) = default;
     constexpr decltype(auto) operator*() const { return *it_; }
     constexpr cpp20_input_iterator& operator++() { ++it_; return *this; }
     constexpr void operator++(int) { ++it_; }
 
-    constexpr const It& base() const& { return it_; }
-    constexpr It base() && { return std::move(it_); }
-
+    constexpr const It& base() const& { return it_; } // TODO remove me
     friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
 
 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };
public:
     template <class T>
     void operator,(T const &) = delete;
 
 private:
     decltype(base(std::declval<It>())) base_;
     difference_type stride_count_ = 0;
     difference_type stride_displacement_ = 0;
 };
+#endif // TEST_SUPPORTS_RANGES
 
+#if TEST_STD_VER > 17
 template <class It>
 class sentinel_wrapper {
 public:
     explicit sentinel_wrapper() = default;
     constexpr explicit sentinel_wrapper(const It& it) : base_(base(it)) {}
     constexpr bool operator==(const It& other) const { return base_ == base(other); }
     friend constexpr It base(const sentinel_wrapper& s) { return It(s.base_); }
 private:
     decltype(base(std::declval<It>())) base_;
 };
 
 template <class It>
 class sized_sentinel {
 public:
     explicit sized_sentinel() = default;
     constexpr explicit sized_sentinel(const It& it) : base_(base(it)) {}
     constexpr bool operator==(const It& other) const { return base_ == base(other); }
     friend constexpr auto operator-(const sized_sentinel& s, const It& i) { return s.base_ - base(i); }
     friend constexpr auto operator-(const It& i, const sized_sentinel& s) { return base(i) - s.base_; }
     friend constexpr It base(const sized_sentinel& s) { return It(s.base_); }
 private:
     decltype(base(std::declval<It>())) base_;
 };
-
-template <class It>
-class three_way_contiguous_iterator
-{
-    static_assert(std::is_pointer_v<It>, "Things probably break in this case");
-
-    It it_;
-
-    template <class U> friend class three_way_contiguous_iterator;
-public:
-    typedef          std::contiguous_iterator_tag              iterator_category;
-    typedef typename std::iterator_traits<It>::value_type      value_type;
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
-    typedef It                                                 pointer;
-    typedef typename std::iterator_traits<It>::reference       reference;
-    typedef typename std::remove_pointer<It>::type             element_type;
-
-    constexpr It base() const {return it_;}
-
-    constexpr three_way_contiguous_iterator() : it_() {}
-    constexpr explicit three_way_contiguous_iterator(It it) : it_(it) {}
-    template <class U>
-    constexpr three_way_contiguous_iterator(const three_way_contiguous_iterator<U>& u) : it_(u.it_) {}
-
-    constexpr reference operator*() const {return *it_;}
-    constexpr pointer operator->() const {return it_;}
-
-    constexpr three_way_contiguous_iterator& operator++() {++it_; return *this;}
-    constexpr three_way_contiguous_iterator operator++(int) {auto tmp = *this; ++(*this); return tmp;}
-
-    constexpr three_way_contiguous_iterator& operator--() {--it_; return *this;}
-    constexpr three_way_contiguous_iterator operator--(int) {auto tmp = *this; --(*this); return tmp;}
-
-    constexpr three_way_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
-    constexpr auto operator+(difference_type n) const {auto tmp = *this; tmp += n; return tmp;}
-    friend constexpr auto operator+(difference_type n, three_way_contiguous_iterator x) {x += n; return x;}
-    constexpr three_way_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
-    constexpr auto operator-(difference_type n) const {auto tmp = *this; tmp -= n; return tmp;}
-
-    constexpr reference operator[](difference_type n) const {return it_[n];}
-
-    friend constexpr
-    difference_type operator-(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {
-        return x.base() - y.base();
-    }
-
-    friend auto operator<=>(const three_way_contiguous_iterator&, const three_way_contiguous_iterator&) = default;
-
-    template <class T>
-    void operator,(T const &) = delete;
-};
-
-#endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)
+#endif // TEST_STD_VER > 17
 
 #endif // SUPPORT_TEST_ITERATORS_H