Implement part of P0031; adding `constexpr` to `move_iterator`

[mclow.lists]

Summary

This just does the move_iterator bits of http://wg21.link/P0031 - not any of the other parts.
This duplicates some (but not all) of the work that was done in D20915 and D22584.

Again, the whole reason for this is all the tests.

[mclow.lists]

include/iterator

1559

These changes are just getting rid of tabs.

[mclow.lists]

Committed as revision 285818

include/iterator

     typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
     typedef value_type&&                                          reference;
  
-    move_iterator();
-    explicit move_iterator(Iterator i);
-    template <class U> move_iterator(const move_iterator<U>& u);
-    template <class U> move_iterator& operator=(const move_iterator<U>& u);
-    iterator_type base() const;
-    reference operator*() const;
-    pointer operator->() const;
-    move_iterator& operator++();
-    move_iterator operator++(int);
-    move_iterator& operator--();
-    move_iterator operator--(int);
-    move_iterator operator+(difference_type n) const; 
-    move_iterator& operator+=(difference_type n); 
-    move_iterator operator-(difference_type n) const; 
-    move_iterator& operator-=(difference_type n); 
-    unspecified operator[](difference_type n) const;
+    constexpr move_iterator();  // all the constexprs are in C++17
+    constexpr explicit move_iterator(Iterator i);
+    template <class U>
+      constexpr move_iterator(const move_iterator<U>& u);
+    template <class U>
+      constexpr move_iterator& operator=(const move_iterator<U>& u);
+    constexpr iterator_type base() const;
+    constexpr reference operator*() const;
+    constexpr pointer operator->() const;
+    constexpr move_iterator& operator++();
+    constexpr move_iterator operator++(int);
+    constexpr move_iterator& operator--();
+    constexpr move_iterator operator--(int);
+    constexpr move_iterator operator+(difference_type n) const; 
+    constexpr move_iterator& operator+=(difference_type n); 
+    constexpr move_iterator operator-(difference_type n) const; 
+    constexpr move_iterator& operator-=(difference_type n); 
+    constexpr unspecified operator[](difference_type n) const;
 private:
     Iterator current; // exposition only
 };
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-bool
+constexpr bool   // constexpr in C++17
 operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
 template <class Iterator1, class Iterator2>
-auto
+constexpr auto   // constexpr in C++17
 operator-(const move_iterator<Iterator1>& x,
           const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
 
 template <class Iterator>
-move_iterator<Iterator> operator+(typename move_iterator<Iterator>::difference_type n, 
-                                     const move_iterator<Iterator>& x);
+constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
+            typename move_iterator<Iterator>::difference_type n, 
+            const move_iterator<Iterator>& x);
 
-template <class Iterator>
-move_iterator<Iterator> make_move_iterator(const Iterator& i);
+template <class Iterator>   // constexpr in C++17
+constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
 
 
 template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>

 template <class _Tp>
 struct __is_exactly_input_iterator
     : public integral_constant<bool, 
-       __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value && 
-      !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};
+         __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value && 
+        !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};
 
 template<class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>

     typedef typename iterator_traits<iterator_type>::reference reference;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY move_iterator() : __i() {}
-    _LIBCPP_INLINE_VISIBILITY explicit move_iterator(_Iter __x) : __i(__x) {}
-    template <class _Up> _LIBCPP_INLINE_VISIBILITY move_iterator(const move_iterator<_Up>& __u)
-        : __i(__u.base()) {}
-    _LIBCPP_INLINE_VISIBILITY _Iter base() const {return __i;}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {
-      return static_cast<reference>(*__i);
-    }
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const { return __i;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator& operator++() {++__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator  operator++(int)
-        {move_iterator __tmp(*this); ++__i; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator& operator--() {--__i; return *this;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator  operator--(int)
-        {move_iterator __tmp(*this); --__i; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator  operator+ (difference_type __n) const
-        {return move_iterator(__i + __n);}
-    _LIBCPP_INLINE_VISIBILITY move_iterator& operator+=(difference_type __n)
-        {__i += __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY move_iterator  operator- (difference_type __n) const
-        {return move_iterator(__i - __n);}
-    _LIBCPP_INLINE_VISIBILITY move_iterator& operator-=(difference_type __n)
-        {__i -= __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reference         operator[](difference_type __n) const
-    {
-      return static_cast<reference>(__i[__n]);
-    }
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator() : __i() {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    explicit move_iterator(_Iter __x) : __i(__x) {}
+    template <class _Up>
+      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+      move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 
+    reference operator*() const { return static_cast<reference>(*__i); }
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    pointer  operator->() const { return __i;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator& operator++() {++__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator  operator++(int) {move_iterator __tmp(*this); ++__i; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator& operator--() {--__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator  operator--(int) {move_iterator __tmp(*this); --__i; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator  operator+ (difference_type __n) const {return move_iterator(__i + __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator& operator+=(difference_type __n) {__i += __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator  operator- (difference_type __n) const {return move_iterator(__i - __n);}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator& operator-=(difference_type __n) {__i -= __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reference operator[](difference_type __n) const { return static_cast<reference>(__i[__n]); }
 };
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 bool
 operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 {

 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 auto
 operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
 -> decltype(__x.base() - __y.base())

 #endif
 
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 move_iterator<_Iter>
 operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
 {

 }
 
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 move_iterator<_Iter>
 make_move_iterator(_Iter __i)
 {

 
 template <class _Iter>
 struct __libcpp_is_trivial_iterator
-  : public _LIBCPP_BOOL_CONSTANT(is_pointer<_Iter>::value) {};
-  
+    : public _LIBCPP_BOOL_CONSTANT(is_pointer<_Iter>::value) {};
+    
 template <class _Iter>
 struct __libcpp_is_trivial_iterator<move_iterator<_Iter> >
-  : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
+    : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
 
 template <class _Iter>
 struct __libcpp_is_trivial_iterator<reverse_iterator<_Iter> >
-  : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
+    : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
 
 template <class _Iter>
 struct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> >
-  : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
+    : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};
 
 
 template <class _Tp, size_t _Np>

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp

 // template <InputIterator Iter>
 //   move_iterator<Iter>
 //   make_move_iterator(const Iter& i);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     std::make_move_iterator(a+4);
     std::make_move_iterator(a); // test for LWG issue 2061
     }
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    constexpr auto iter = std::make_move_iterator<const char *>(p);
+    static_assert(iter.base() == p);
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp

 //   auto
 //   operator-(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y)
 //   -> decltype(x.base() - y.base());
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), random_access_iterator<char*>(s), 5);
     test(s+5, s, 5);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert( it1 - it2 == -1, "");
+    static_assert( it2 - it1 ==  1, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp

 // template <RandomAccessIterator Iter>
 //   move_iterator<Iter>
 //   operator+(Iter::difference_type n, const move_iterator<Iter>& x);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     char s[] = "1234567890";
     test(random_access_iterator<char*>(s+5), 5, random_access_iterator<char*>(s+10));
     test(s+5, 5, s+10);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = it1 + 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp

 
 // requires RandomAccessIterator<Iter>
 //   move_iterator operator+(difference_type n) const;
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = it1 + 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp

 
 // requires RandomAccessIterator<Iter>
 //   move_iterator& operator+=(difference_type n);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p) += 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp

 
 // requires RandomAccessIterator<Iter>
 //   move_iterator operator-(difference_type n) const;
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
     test(s+5, 5, s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = it2 - 5;
+    static_assert(it1 != it2, "");
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp

 
 // requires RandomAccessIterator<Iter>
 //   move_iterator& operator-=(difference_type n);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     const char* s = "1234567890";
     test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
     test(s+5, 5, s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    constexpr auto it1 = std::make_move_iterator(p);
+    constexpr auto it2 = std::make_move_iterator(p+5) -= 5;
+    static_assert(it1 == it2, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp

 //   requires HasEqualTo<Iter1, Iter2>
 //   bool
 //   operator==(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert(!(it1 == it2), "");
+    static_assert( (it1 == it3), "");
+    static_assert(!(it2 == it3), "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp

 //   requires HasLess<Iter2, Iter1>
 //   bool
 //   operator>(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, false);
     test(s, s+1, false);
     test(s+1, s, true);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert(!(it1 > it2), "");
+    static_assert(!(it1 > it3), "");
+    static_assert( (it2 > it3), "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp

 //   requires HasLess<Iter1, Iter2>
 //   bool
 //   operator>=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, true);
     test(s, s+1, false);
     test(s+1, s, true);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert(!(it1 >= it2), "");
+    static_assert( (it1 >= it3), "");
+    static_assert( (it2 >= it3), "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp

 //   requires HasLess<Iter1, Iter2>
 //   bool
 //   operator<(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, false);
     test(s, s+1, true);
     test(s+1, s, false);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert( (it1 < it2), "");
+    static_assert(!(it1 < it3), "");
+    static_assert(!(it2 < it3), "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp

 //   requires HasLess<Iter2, Iter1>
 //   bool
 //   operator<=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(s, s, true);
     test(s, s+1, true);
     test(s+1, s, false);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert( (it1 <= it2), "");
+    static_assert( (it1 <= it3), "");
+    static_assert(!(it2 <= it3), "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp

 //   requires HasEqualTo<Iter1, Iter2>
 //   bool
 //   operator!=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
     test(s, s, false);
     test(s, s+1, true);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p + 5);
+    constexpr MI it3 = std::make_move_iterator(p);
+    static_assert( (it1 != it2), "");
+    static_assert(!(it1 != it3), "");
+    static_assert( (it2 != it3), "");
+    }
+#endif
 }

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

 // template <class U>
 //   requires HasConstructor<Iter, const U&>
 //   move_iterator(const move_iterator<U> &u);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>

     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const Derived *p = nullptr;
+    constexpr std::move_iterator<const Derived *>     it1 = std::make_move_iterator(p);
+    constexpr std::move_iterator<const Base *>        it2(it1);
+    static_assert(it2.base() == p);
+    }
+#endif
 }

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

 // move_iterator
 
 // move_iterator();
+//
+//  constexpr in C++17
 
 #include <iterator>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test<bidirectional_iterator<char*> >();
     test<random_access_iterator<char*> >();
     test<char*>();
+
+#if TEST_STD_VER > 14
+    {
+    constexpr std::move_iterator<const char *> it;
+    }
+#endif
 }

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

 // move_iterator
 
 // explicit move_iterator(Iter i);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<char*>(s));
     test(random_access_iterator<char*>(s));
     test(s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    constexpr std::move_iterator<const char *> it(p);
+    static_assert(it.base() == p);
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp

 // move_iterator
 
 // move_iterator operator--(int);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
     test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
     test(s+1, s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr MI it3 = std::make_move_iterator(p+1) --;
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp

 // move_iterator
 
 // move_iterator& operator--();
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
     test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
     test(s+1, s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr MI it3 = -- std::make_move_iterator(p+1);
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp

 // move_iterator
 
 // move_iterator operator++(int);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
     test(s, s+1);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr MI it3 = std::make_move_iterator(p) ++;
+    static_assert(it1 == it3, "");
+    static_assert(it2 != it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp

 // move_iterator
 
 // move_iterator& operator++();
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

     test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
     test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
     test(s, s+1);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(it1 != it2, "");
+    constexpr MI it3 = ++ std::make_move_iterator(p);
+    static_assert(it1 != it3, "");
+    static_assert(it2 == it3, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp

 
 // requires RandomAccessIterator<Iter>
 //   unspecified operator[](difference_type n) const;
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>

 #include <memory>
 #endif
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It>

         p[j].reset(i+j);
     test(p, 3, Ptr(i+3));
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    static_assert(it1[0] == '1', "");
+    static_assert(it1[5] == '6', "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.ref/op_arrow.pass.cpp

 // move_iterator
 
 // pointer operator->() const;
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class It>
 void
 test(It i)

 {
     char s[] = "123";
     test(s);
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(it1.operator->() == p, "");
+    static_assert(it2.operator->() == p + 1, "");
+    }
+#endif
 }

test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp

 // move_iterator
 
 // reference operator*() const;
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>

 #include <memory>
 #endif
 
+#include "test_macros.h"
+
 class A
 {
     int data_;

     std::unique_ptr<int, do_nothing> p(&i);
     test(&p, std::unique_ptr<int, do_nothing>(&i));
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+#if TEST_STD_VER > 14
+    {
+    constexpr const char *p = "123456789";
+    typedef std::move_iterator<const char *> MI;
+    constexpr MI it1 = std::make_move_iterator(p);
+    constexpr MI it2 = std::make_move_iterator(p+1);
+    static_assert(*it1 == p[0], "");
+    static_assert(*it2 == p[1], "");
+    }
+#endif
 }

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

 //   requires HasAssign<Iter, const U&>
 //   move_iterator&
 //   operator=(const move_iterator<U>& u);
+//
+//  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>

     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
+#if TEST_STD_VER > 14
+    {
+    using BaseIter    = std::move_iterator<const Base *>;
+    using DerivedIter = std::move_iterator<const Derived *>;
+    constexpr const Derived *p = nullptr;
+    constexpr DerivedIter     it1 = std::make_move_iterator(p);
+    constexpr BaseIter        it2 = (BaseIter{nullptr} = it1);
+    static_assert(it2.base() == p, "");
+    }
+#endif
 }