[libc++][NFC] Add more tests to `move_{iterator,sentinel}`.

[var-const]

Summary

More test coverage for the parts added by the One Ranges Proposal.

[ldionne]

LGTM with passing tests (the issue looks fairly benign) and after you've investigated whether we can test with more archetypes. Thanks for adding these tests!

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

84–85

What about cpp20_input_iterator? And output_iterator? I think it may be possible to improve test coverage here and elsewhere by adding tests with a couple more archetypes.

[var-const]

Fix bad merge, should fix the CI.

[var-const]

Fix CI and rebase.

[var-const]

Fix old language modes.

[var-const]

Fix the CI.

[var-const]

Fix the CI

[var-const]

Fix the CI.

libcxx/include/__iterator/move_iterator.h

#else
     typedef typename iterator_traits<iterator_type>::reference __reference;
     typedef typename conditional<
             is_reference<__reference>::value,
             typename remove_reference<__reference>::type&&,
             __reference
         >::type reference;
 #endif // _LIBCPP_STD_VER > 17
 
-#if _LIBCPP_STD_VER > 17
-    _LIBCPP_HIDE_FROM_ABI constexpr
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
 
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
+    move_iterator& operator++() { ++__current_; return *this; }
+
+#if _LIBCPP_STD_VER > 17
     _LIBCPP_HIDE_FROM_ABI constexpr
     move_iterator() requires is_constructible_v<_Iter> : __current_() {}
 
     template <class _Up>
         requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
     _LIBCPP_HIDE_FROM_ABI constexpr
     move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
 
#if _LIBCPP_STD_VER > 17
     _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr
     reference operator*() const { return ranges::iter_move(__current_); }
     _LIBCPP_HIDE_FROM_ABI constexpr
     reference operator[](difference_type __n) const { return ranges::iter_move(__current_ + __n); }
 
     _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator& operator++() { ++__current_; return *this; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr
     auto operator++(int)
         requires forward_iterator<_Iter>
     {
         move_iterator __tmp(*this); ++__current_; return __tmp;
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr
     void operator++(int) { ++__current_; }
 #else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-    explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator() : __current_() {}
 
     template <class _Up, class = __enable_if_t<
         !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value
     > >
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
 
#else
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator*() const { return static_cast<reference>(*__current_); }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     pointer operator->() const { return __current_; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
-    move_iterator& operator++() { ++__current_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
 #endif // _LIBCPP_STD_VER > 17
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator& operator--() { --__current_; return *this; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
     move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14

libcxx/include/__iterator/move_sentinel.h

 template <semiregular _Sent>
 class _LIBCPP_TEMPLATE_VIS move_sentinel
 {
 public:
   _LIBCPP_HIDE_FROM_ABI
   move_sentinel() = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr
-  explicit move_sentinel(_Sent __s) : __last_(_VSTD::move(__s)) {}
+  explicit move_sentinel(_Sent __s) : __last_(std::move(__s)) {}
 
   template <class _S2>
     requires convertible_to<const _S2&, _Sent>
   _LIBCPP_HIDE_FROM_ABI constexpr
   move_sentinel(const move_sentinel<_S2>& __s) : __last_(__s.base()) {}
 
   template <class _S2>
     requires assignable_from<_Sent&, const _S2&>

libcxx/include/iterator

 template <class Container>
 insert_iterator<Container> inserter(Container& x, typename Container::iterator i);  // until C++20
 template <class Container>
 constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i);  // since C++20
 
 template <class Iterator>
 class move_iterator {
 public:
-    typedef Iterator                                              iterator_type;
-    typedef typename iterator_traits<Iterator>::difference_type   difference_type;
-    typedef Iterator                                              pointer;
-    typedef typename iterator_traits<Iterator>::value_type        value_type;
-    typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
-    typedef value_type&&                                          reference;
+    using iterator_type     = Iterator;
+    using iterator_concept  = input_iterator_tag; // From C++20
+    using iterator_category = see below; // not always present starting from C++20
+    using value_type        = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type
+    using difference_type   = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;
+    using pointer           = Iterator;
+    using reference         = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&
 
     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 iterator_type base() const; // Until C++20
+    constexpr const Iterator& base() const & noexcept; // From C++20
+    constexpr Iterator base() &&; // From C++20
+
     constexpr reference operator*() const;
-    constexpr pointer operator->() const;
+    constexpr pointer operator->() const; // Removed in C++20
     constexpr move_iterator& operator++();
-    constexpr move_iterator operator++(int);
+    constexpr auto operator++(int); // Return type was move_iterator until C++20
     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;
+    constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20
+
+    template<sentinel_for<Iterator> S>
+      friend constexpr bool
+        operator==(const move_iterator& x, const move_sentinel<S>& y); // Since C++20
+    template<sized_sentinel_for<Iterator> S>
+      friend constexpr iter_difference_t<Iterator>
+        operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20
+    template<sized_sentinel_for<Iterator> S>
+      friend constexpr iter_difference_t<Iterator>
+        operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20
+    friend constexpr iter_rvalue_reference_t<Iterator>
+      iter_move(const move_iterator& i)
+        noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20
+    template<indirectly_swappable<Iterator> Iterator2>
+      friend constexpr void
+        iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
+          noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20
+
 private:
     Iterator current; // exposition only
 };
 
 template <class Iterator1, class Iterator2>
 constexpr bool   // constexpr in C++17
 operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 

 template <class Iterator>
 constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
             typename move_iterator<Iterator>::difference_type n,
             const move_iterator<Iterator>& x);
 
 template <class Iterator>   // constexpr in C++17
 constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
 
+template<semiregular S>
+class move_sentinel {
+public:
+  constexpr move_sentinel();
+  constexpr explicit move_sentinel(S s);
+  template<class S2>
+    requires convertible_to<const S2&, S>
+      constexpr move_sentinel(const move_sentinel<S2>& s);
+  template<class S2>
+    requires assignable_from<S&, const S2&>
+      constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
+
+  constexpr S base() const;
+private:
+  S last;     // exposition only
+};
+
 // [default.sentinel], default sentinel
 struct default_sentinel_t;
 inline constexpr default_sentinel_t default_sentinel{};
 
 // [iterators.counted], counted iterators
 template<input_or_output_iterator I> class counted_iterator;
 
 template<input_iterator I>

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

+//===----------------------------------------------------------------------===//
+//
+// 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>
+//
+// friend constexpr iter_rvalue_reference_t<Iterator>
+//   iter_move(const move_iterator& i)
+//     noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20
+
+#include <iterator>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+
+int global;
+
+template <bool IsNoexcept>
+struct MaybeNoexceptMove {
+  int x;
+  using value_type = int;
+  using difference_type = ptrdiff_t;
+
+  constexpr friend value_type&& iter_move(MaybeNoexceptMove) noexcept(IsNoexcept) {
+    return std::move(global);
+  }
+
+  int& operator*() const { static int a; return a; }
+
+  MaybeNoexceptMove& operator++();
+  MaybeNoexceptMove operator++(int);
+};
+using ThrowingBase = MaybeNoexceptMove<false>;
+using NoexceptBase = MaybeNoexceptMove<true>;
+static_assert(std::input_iterator<ThrowingBase>);
+ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(std::declval<ThrowingBase>()));
+ASSERT_NOEXCEPT(std::ranges::iter_move(std::declval<NoexceptBase>()));
+
+constexpr bool test() {
+  // Can use `iter_move` with a regular array.
+  {
+    int a[] = {0, 1, 2};
+
+    std::move_iterator<int*> i(a);
+    static_assert(std::same_as<decltype(iter_move(i)), int&&>);
+    assert(iter_move(i) == 0);
+
+    ++i;
+    assert(iter_move(i) == 1);
+  }
+
+  // Check that the `iter_move` customization point is being used.
+  {
+    int a[] = {0, 1, 2};
+
+    int iter_move_invocations = 0;
+    adl::Iterator base = adl::Iterator::TrackMoves(a, iter_move_invocations);
+    std::move_iterator<adl::Iterator> i(base);
+    int x = iter_move(i);
+    assert(x == 0);
+    assert(iter_move_invocations == 1);
+  }
+
+  // Check the `noexcept` specification.
+  {
+    using ThrowingIter = std::move_iterator<ThrowingBase>;
+    ASSERT_NOT_NOEXCEPT(iter_move(std::declval<ThrowingIter>()));
+    using NoexceptIter = std::move_iterator<NoexceptBase>;
+    ASSERT_NOEXCEPT(iter_move(std::declval<NoexceptIter>()));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// 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>
+//
+// template<indirectly_swappable<Iterator> Iterator2>
+//   friend constexpr void
+//     iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
+//       noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20
+
+#include <iterator>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+
+template <bool IsNoexcept>
+struct MaybeNoexceptSwap {
+  using value_type = int;
+  using difference_type = ptrdiff_t;
+
+  constexpr friend void iter_swap(MaybeNoexceptSwap, MaybeNoexceptSwap) noexcept(IsNoexcept) {
+  }
+
+  int& operator*() const { static int x; return x; }
+
+  MaybeNoexceptSwap& operator++();
+  MaybeNoexceptSwap operator++(int);
+};
+using ThrowingBase = MaybeNoexceptSwap<false>;
+using NoexceptBase = MaybeNoexceptSwap<true>;
+static_assert(std::input_iterator<ThrowingBase>);
+ASSERT_NOT_NOEXCEPT(std::ranges::iter_swap(std::declval<ThrowingBase>(), std::declval<ThrowingBase>()));
+ASSERT_NOEXCEPT(std::ranges::iter_swap(std::declval<NoexceptBase>(), std::declval<NoexceptBase>()));
+
+constexpr bool test() {
+  // Can use `iter_swap` with a regular array.
+  {
+    int a[] = {0, 1, 2};
+
+    std::move_iterator b(a);
+    std::move_iterator e(a + 2);
+    assert(a[0] == 0);
+    assert(a[2] == 2);
+
+    static_assert(std::same_as<decltype(iter_swap(b, e)), void>);
+    iter_swap(b, e);
+    assert(a[0] == 2);
+    assert(a[2] == 0);
+  }
+
+  // Check that the `iter_swap` customization point is being used.
+  {
+    int iter_swap_invocations = 0;
+    adl::Iterator base1 = adl::Iterator::TrackSwaps(iter_swap_invocations);
+    adl::Iterator base2 = adl::Iterator::TrackSwaps(iter_swap_invocations);
+    std::move_iterator<adl::Iterator> i1(base1), i2(base2);
+    iter_swap(i1, i2);
+    assert(iter_swap_invocations == 1);
+
+    iter_swap(i2, i1);
+    assert(iter_swap_invocations == 2);
+  }
+
+  // Check the `noexcept` specification.
+  {
+    using ThrowingIter = std::move_iterator<ThrowingBase>;
+    ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<ThrowingIter>(), std::declval<ThrowingIter>()));
+    using NoexceptIter = std::move_iterator<NoexceptBase>;
+    ASSERT_NOEXCEPT(iter_swap(std::declval<NoexceptIter>(), std::declval<NoexceptIter>()));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// move_iterator
+
+// template<sized_sentinel_for<Iterator> S>
+//   friend constexpr iter_difference_t<Iterator>
+//     operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20
+// template<sized_sentinel_for<Iterator> S>
+//   friend constexpr iter_difference_t<Iterator>
+//     operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20
+
+#include <iterator>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// The `operator-` calls the underlying iterator and sentinel's `operator-`.
+
+struct CustomIt {
+  using value_type = int;
+  using difference_type = int;
+  using reference = int&;
+  using pointer = int*;
+  using iterator_category = std::input_iterator_tag;
+
+  CustomIt() = default;
+  TEST_CONSTEXPR_CXX17 explicit CustomIt(int* p) : p_(p) {}
+  int& operator*() const;
+  CustomIt& operator++();
+  CustomIt operator++(int);
+  constexpr friend difference_type operator-(const CustomIt& a, const CustomIt& b) { return a.p_ - b.p_; }
+  int *p_ = nullptr;
+};
+
+template <class It, class Sent = sized_sentinel<It>>
+constexpr void test_one() {
+  int arr[] = {3, 1, 4};
+
+  const std::move_iterator<It> it_a{It(arr)};
+  const std::move_iterator<It> it_b{It(arr + 1)};
+
+  const std::move_sentinel<Sent> sent_a{Sent(It(arr))};
+  const std::move_sentinel<Sent> sent_b{Sent(It(arr + 1))};
+  const std::move_sentinel<Sent> sent_c{Sent(It(arr + 2))};
+
+  ASSERT_SAME_TYPE(decltype(it_a - sent_a), std::iter_difference_t<It>);
+  ASSERT_SAME_TYPE(decltype(sent_a - it_a), std::iter_difference_t<It>);
+
+  // it_a
+  assert(it_a - sent_a == 0);
+  assert(sent_a - it_a == 0);
+
+  assert(it_a - sent_b == -1);
+  assert(sent_b - it_a == 1);
+
+  assert(it_a - sent_c == -2);
+  assert(sent_c - it_a == 2);
+
+  // it_b
+  assert(it_b - sent_a == 1);
+  assert(sent_a - it_b == -1);
+
+  assert(it_b - sent_b == 0);
+  assert(sent_b - it_b == 0);
+
+  assert(it_b - sent_c == -1);
+  assert(sent_c - it_b == 1);
+}
+
+constexpr bool test() {
+  test_one<CustomIt>();
+  test_one<cpp17_input_iterator<int*>>();
+  test_one<forward_iterator<int*>>();
+  test_one<bidirectional_iterator<int*>>();
+  test_one<random_access_iterator<int*>>();
+  test_one<int*>();
+  test_one<const int*>();
+  test_one<contiguous_iterator<int*>>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // move_iterator
 
 // move_iterator();
 //
 //  constexpr in C++17
+//
+//  requires the underlying iterator to be default-constructible (extension).
 
 #include <iterator>
 
+#include <type_traits>
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#if TEST_STD_VER > 17
+struct NoDefaultCtr : forward_iterator<int*> {
+  NoDefaultCtr() = delete;
+};
+
+LIBCPP_STATIC_ASSERT( std::is_default_constructible_v<std::move_iterator<forward_iterator<int*>>>);
+LIBCPP_STATIC_ASSERT(!std::is_default_constructible_v<std::move_iterator<NoDefaultCtr>>);
+#endif
+
 template <class It>
-void
-test()
-{
+void test() {
     std::move_iterator<It> r;
     (void)r;
 }
 
-int main(int, char**)
-{
-    // we don't have a test iterator that is both input and default-constructible, so not testing that case
-    test<forward_iterator<char*> >();
-    test<bidirectional_iterator<char*> >();
-    test<random_access_iterator<char*> >();
-    test<char*>();
+int main(int, char**) {
 
 #if TEST_STD_VER > 14
-    {
     constexpr std::move_iterator<const char *> it;
     (void)it;
-    }
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/base.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+//
+// constexpr iterator_type base() const; // Until C++20
+// constexpr const Iterator& base() const & noexcept; // From C++20
+// constexpr Iterator base() &&; // From C++20
+
+#include <iterator>
+
+#include <utility>
+#include "test_iterators.h"
+#include "test_macros.h"
+
+struct MoveOnlyIterator {
+  using It = int*;
+
+  It it_;
+
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using difference_type = std::ptrdiff_t;
+  using reference = int&;
+
+  TEST_CONSTEXPR explicit MoveOnlyIterator(It it) : it_(it) {}
+  MoveOnlyIterator(MoveOnlyIterator&&) = default;
+  MoveOnlyIterator& operator=(MoveOnlyIterator&&) = default;
+  MoveOnlyIterator(const MoveOnlyIterator&) = delete;
+  MoveOnlyIterator& operator=(const MoveOnlyIterator&) = delete;
+
+  TEST_CONSTEXPR reference operator*() const { return *it_; }
+
+  TEST_CONSTEXPR_CXX14 MoveOnlyIterator& operator++() { ++it_; return *this; }
+  TEST_CONSTEXPR_CXX14 MoveOnlyIterator operator++(int) { return MoveOnlyIterator(it_++); }
+
+  friend TEST_CONSTEXPR bool operator==(const MoveOnlyIterator& x, const MoveOnlyIterator& y) {return x.it_ == y.it_;}
+  friend TEST_CONSTEXPR bool operator!=(const MoveOnlyIterator& x, const MoveOnlyIterator& y) {return x.it_ != y.it_;}
+
+  friend TEST_CONSTEXPR It base(const MoveOnlyIterator& i) { return i.it_; }
+};
+
+#if TEST_STD_VER > 17
+static_assert( std::input_iterator<MoveOnlyIterator>);
+#endif
+static_assert(!std::is_copy_constructible<MoveOnlyIterator>::value, "");
+
+template <class It>
+TEST_CONSTEXPR_CXX14 void test_one() {
+  // Non-const lvalue.
+  {
+    int a[] = {1, 2, 3};
+
+    auto i = std::move_iterator<It>(It(a));
+#if TEST_STD_VER > 17
+    ASSERT_SAME_TYPE(decltype(i.base()), const It&);
+    ASSERT_NOEXCEPT(i.base());
+#else
+    ASSERT_SAME_TYPE(decltype(i.base()), It);
+#endif
+    assert(i.base() == It(a));
+
+    ++i;
+    assert(i.base() == It(a + 1));
+  }
+
+  // Const lvalue.
+  {
+    int a[] = {1, 2, 3};
+
+    const auto i = std::move_iterator<It>(It(a));
+#if TEST_STD_VER > 17
+    ASSERT_SAME_TYPE(decltype(i.base()), const It&);
+    ASSERT_NOEXCEPT(i.base());
+#else
+    ASSERT_SAME_TYPE(decltype(i.base()), It);
+#endif
+    assert(i.base() == It(a));
+  }
+
+  // Rvalue.
+  {
+    int a[] = {1, 2, 3};
+
+    auto i = std::move_iterator<It>(It(a));
+    ASSERT_SAME_TYPE(decltype(std::move(i).base()), It);
+    assert(std::move(i).base() == It(a));
+  }
+}
+
+TEST_CONSTEXPR_CXX14 bool test() {
+  test_one<cpp17_input_iterator<int*> >();
+  test_one<forward_iterator<int*> >();
+  test_one<bidirectional_iterator<int*> >();
+  test_one<random_access_iterator<int*> >();
+  test_one<int*>();
+  test_one<const int*>();
+#if TEST_STD_VER > 17
+  test_one<contiguous_iterator<int*>>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 14
+  static_assert(test());
+#endif
+
+  return 0;
+}

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.conv/tested_elsewhere.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-int main(int, char**)
-{
-
-  return 0;
-}

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // move_iterator
 
-// move_iterator operator++(int);
-//
-//  constexpr in C++17
+// constexpr auto operator++(int); // Return type was move_iterator until C++20
 
 #include <iterator>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 #if TEST_STD_VER > 17
 template <class It>
 void test_single_pass(It i, It x) {
   std::move_iterator<It> r(std::move(i));
   r++;
   assert(std::move(r).base() == x);
 }
 #endif
 
 template <class It>
-void
-test(It i, It x)
-{
+void test(It i, It x) {
     std::move_iterator<It> r(i);
     std::move_iterator<It> rr = r++;
     assert(r.base() == x);
     assert(rr.base() == i);
 }
 
-int main(int, char**)
-{
-    char s[] = "123";
+int main(int, char**) {
 #if TEST_STD_VER > 17
-    test_single_pass(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s + 1));
 #else
-    test(cpp17_input_iterator<char*>(s), cpp17_input_iterator<char*>(s+1));
 #endif
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
-    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
 
+#if TEST_STD_VER > 17
+  // Forward iterators return a copy.
+  {
+    int a[] = {1, 2, 3};
+    using MoveIter = std::move_iterator<forward_iterator<int*>>;
+
+    MoveIter i = MoveIter(forward_iterator<int*>(a));
+    ASSERT_SAME_TYPE(decltype(i++), MoveIter);
+    auto j = i++;
+    assert(base(j.base()) == a);
+    assert(base(i.base()) == a + 1);
+  }
+
+  // Non-forward iterators return void.
+  {
+    int a[] = {1, 2, 3};
+    using MoveIter = std::move_iterator<cpp20_input_iterator<int*>>;
+
+    MoveIter i = MoveIter(cpp20_input_iterator<int*>(a));
+    ASSERT_SAME_TYPE(decltype(i++), void);
+    i++;
+    assert(base(i.base()) == a + 1);
+  }
+#endif
+
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // move_iterator
 
-// requires RandomAccessIterator<Iter>
-//   unspecified operator[](difference_type n) const;
-//
-//  constexpr in C++17
+// constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20
 
 #include <iterator>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
#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
 
+#if TEST_STD_VER > 17
+  // Ensure the `iter_move` customization point is being used.
+  {
+    int a[] = {0, 1, 2};
+
+    int iter_moves = 0;
+    adl::Iterator i = adl::Iterator::TrackMoves(a, iter_moves);
+    std::move_iterator<adl::Iterator> mi(i);
+
+    auto x = mi[0];
+    assert(x == 0);
+    assert(iter_moves == 1);
+  }
+#endif
+
   return 0;
 }

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

 // reference operator*() const;
 //
 //  constexpr in C++17
 
 #include <iterator>
 #include <cassert>
 #include <memory>
 
+#include "test_iterators.h"
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
     ~A() {data_ = -1;}

 }
 
 struct do_nothing
 {
     void operator()(void*) const {}
 };
 
 
-int main(int, char**)
-{
-    {
-        A a;
-        test(&a, A());
-    }
+int main(int, char**) {
 #if TEST_STD_VER >= 11
-    {
-        int i;
-        std::unique_ptr<int, do_nothing> p(&i);
-        test(&p, std::unique_ptr<int, do_nothing>(&i));
-    }
 #endif
 #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
 
+#if TEST_STD_VER > 17
+  // Ensure the `iter_move` customization point is being used.
+  {
+    int a[] = {0, 1, 2};
+
+    int iter_moves = 0;
+    adl::Iterator i = adl::Iterator::TrackMoves(a, iter_moves);
+    std::move_iterator<adl::Iterator> mi(i);
+
+    auto x = *mi;
+    assert(x == 0);
+    assert(iter_moves == 1);
+  }
+#endif
+
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

 
 // move_iterator
 
 // Test nested types:
 
 // template <InputIterator Iter>
 // class move_iterator {
 // public:
-//   typedef Iter                  iterator_type;
-//   typedef Iter::difference_type difference_type;
-//   typedef Iter                  pointer;
-//   typedef Iter::value_type      value_type;
-//   typedef value_type&&          reference;
+//  using iterator_type     = Iterator;
+//  using iterator_concept  = input_iterator_tag; // From C++20
+//  using iterator_category = see below; // not always present starting from C++20
+//  using value_type        = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type
+//  using difference_type   = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;
+//  using pointer           = Iterator;
+//  using reference         = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&
 // };
 
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
+struct FooIter {
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = void*;
+  using difference_type = void*;
+  using pointer = void*;
+  using reference = char&;
+  bool& operator*() const;
+};
+
+#if TEST_STD_VER > 17
+template <>
+struct std::indirectly_readable_traits<FooIter> {
+  using value_type = int;
+};
+template <>
+struct std::incrementable_traits<FooIter> {
+  using difference_type = char;
+};
+#endif
+
+#if TEST_STD_VER > 17
+// Not using `FooIter::value_type`.
+static_assert(std::is_same_v<typename std::move_iterator<FooIter>::value_type, int>);
+// Not using `FooIter::difference_type`.
+static_assert(std::is_same_v<typename std::move_iterator<FooIter>::difference_type, char>);
+static_assert(std::is_same_v<typename std::reverse_iterator<FooIter>::reference, bool&>);
+
+#else
+static_assert(std::is_same<typename std::reverse_iterator<FooIter>::reference, char&>::value, "");
+#endif
+
 template <class ValueType, class Reference>
 struct DummyIt {
   typedef std::forward_iterator_tag iterator_category;
   typedef ValueType value_type;
   typedef std::ptrdiff_t difference_type;
   typedef ValueType* pointer;
   typedef Reference reference;
 
   Reference operator*() const;
 };
 
 template <class It>
-void
-test()
-{
-    typedef std::move_iterator<It> R;
-    typedef std::iterator_traits<It> T;
-    static_assert((std::is_same<typename R::iterator_type, It>::value), "");
-    static_assert((std::is_same<typename R::difference_type, typename T::difference_type>::value), "");
-    static_assert((std::is_same<typename R::pointer, It>::value), "");
-    static_assert((std::is_same<typename R::value_type, typename T::value_type>::value), "");
-    static_assert((std::is_same<typename R::reference, typename R::value_type&&>::value), "");
+void test() {
+
+#if TEST_STD_VER > 17
+  static_assert((std::is_same_v<typename R::reference, std::iter_rvalue_reference_t<It>>), "");
+#else
+#endif
+
 #if TEST_STD_VER > 17
-    if constexpr (std::is_same_v<typename T::iterator_category, std::contiguous_iterator_tag>) {
-        static_assert((std::is_same<typename R::iterator_category, std::random_access_iterator_tag>::value), "");
-    } else {
-        static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
-    }
 #else
-    static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
 #endif
+
+#if TEST_STD_VER > 17
+  static_assert(std::is_same_v<typename R::iterator_concept, std::input_iterator_tag>);
+#endif
 }
 
-int main(int, char**)
-{
-    test<cpp17_input_iterator<char*> >();
-    test<forward_iterator<char*> >();
-    test<bidirectional_iterator<char*> >();
-    test<random_access_iterator<char*> >();
-    test<char*>();
+int main(int, char**) {
+
 #if TEST_STD_VER >= 11
-    {
-        typedef DummyIt<int, int> T;
-        typedef std::move_iterator<T> It;
-        static_assert(std::is_same<It::reference, int>::value, "");
-    }
-    {
-        typedef DummyIt<int, std::reference_wrapper<int> > T;
-        typedef std::move_iterator<T> It;
-        static_assert(std::is_same<It::reference, std::reference_wrapper<int> >::value, "");
-    }
-    {
-        // Check that move_iterator uses whatever reference type it's given
-        // when it's not a reference.
-        typedef DummyIt<int, long > T;
-        typedef std::move_iterator<T> It;
-        static_assert(std::is_same<It::reference, long>::value, "");
-    }
-    {
-        typedef DummyIt<int, int&> T;
-        typedef std::move_iterator<T> It;
-        static_assert(std::is_same<It::reference, int&&>::value, "");
-    }
-    {
-        typedef DummyIt<int, int&&> T;
-        typedef std::move_iterator<T> It;
-        static_assert(std::is_same<It::reference, int&&>::value, "");
-    }
 #endif
 
 #if TEST_STD_VER > 17
-    test<contiguous_iterator<char*>>();
-    static_assert(std::is_same_v<typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<bidirectional_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<random_access_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<contiguous_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<char*>::iterator_concept, std::input_iterator_tag>);
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/assign.converting.pass.cpp

 //   requires assignable_from<S&, const S2&>
 //     constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
 
 #include <iterator>
 #include <cassert>
 #include <concepts>
 
 struct NonAssignable {
-    NonAssignable& operator=(int i);
 };
 static_assert(std::semiregular<NonAssignable>);
 static_assert(std::is_assignable_v<NonAssignable, int>);
 static_assert(!std::assignable_from<NonAssignable, int>);
 
 constexpr bool test()
 {
+  // Assigning from an lvalue.
   {
     std::move_sentinel<int> m(42);
     std::move_sentinel<long> m2;
     m2 = m;
     assert(m2.base() == 42L);
   }
+
+  // Assigning from an rvalue.
   {
     std::move_sentinel<long> m2;
     m2 = std::move_sentinel<int>(43);
     assert(m2.base() == 43L);
   }
+
+  // SFINAE checks.
   {
     static_assert( std::is_assignable_v<std::move_sentinel<int>, std::move_sentinel<long>>);
     static_assert(!std::is_assignable_v<std::move_sentinel<int*>, std::move_sentinel<const int*>>);
     static_assert( std::is_assignable_v<std::move_sentinel<const int*>, std::move_sentinel<int*>>);
     static_assert(!std::is_assignable_v<std::move_sentinel<NonAssignable>, std::move_sentinel<int>>);
   }
   return true;
 }
 
 int main(int, char**)
 {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/base.pass.cpp

 #include <cassert>
 #include <iterator>
 #include <utility>
 
 #include "test_macros.h"
 
 constexpr bool test()
 {
+  // The sentinel type is a value.
   {
     auto m = std::move_sentinel<int>(42);
     const auto& cm = m;
     assert(m.base() == 42);
     assert(cm.base() == 42);
     assert(std::move(m).base() == 42);
     assert(std::move(cm).base() == 42);
     ASSERT_SAME_TYPE(decltype(m.base()), int);
     ASSERT_SAME_TYPE(decltype(cm.base()), int);
     ASSERT_SAME_TYPE(decltype(std::move(m).base()), int);
     ASSERT_SAME_TYPE(decltype(std::move(cm).base()), int);
   }
+
+  // The sentinel type is a pointer.
   {
     int a[] = {1, 2, 3};
     auto m = std::move_sentinel<const int*>(a);
     const auto& cm = m;
     assert(m.base() == a);
     assert(cm.base() == a);
     assert(std::move(m).base() == a);
     assert(std::move(cm).base() == a);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/concept_conformance.compile.pass.cpp

 //   class move_sentinel;
 
 #include <iterator>
 
 #include "test_iterators.h"
 
 void test()
 {
+  // Pointer.
   {
     using It = int*;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `Cpp17InputIterator`.
   {
     using It = cpp17_input_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::input_iterator`.
   {
     using It = cpp20_input_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::forward_iterator`.
   {
     using It = forward_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::bidirectional_iterator`.
   {
     using It = bidirectional_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::random_access_iterator`.
   {
     using It = random_access_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::contiguous_iterator`.
   {
     using It = contiguous_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
+
+  // `std::contiguous_iterator` with the spaceship operator.
   {
     using It = three_way_contiguous_iterator<int*>;
     static_assert( std::sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<It>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert(!std::sized_sentinel_for<std::move_sentinel<sentinel_wrapper<It>>, std::move_iterator<It>>);
     static_assert( std::sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
     static_assert( std::sized_sentinel_for<std::move_sentinel<sized_sentinel<It>>, std::move_iterator<It>>);
   }
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/ctor.converting.pass.cpp

struct NonConvertible {
     explicit NonConvertible(long i) = delete;
 };
 static_assert(std::semiregular<NonConvertible>);
 static_assert(std::is_convertible_v<long, NonConvertible>);
 static_assert(!std::convertible_to<long, NonConvertible>);
 
 constexpr bool test()
 {
+  // Constructing from an lvalue.
   {
     std::move_sentinel<int> m(42);
     std::move_sentinel<long> m2 = m;
     assert(m2.base() == 42L);
   }
+
+  // Constructing from an rvalue.
   {
     std::move_sentinel<long> m2 = std::move_sentinel<int>(43);
     assert(m2.base() == 43L);
   }
+
+  // SFINAE checks.
   {
     static_assert( std::is_convertible_v<std::move_sentinel<int>, std::move_sentinel<long>>);
     static_assert( std::is_convertible_v<std::move_sentinel<int*>, std::move_sentinel<const int*>>);
     static_assert(!std::is_convertible_v<std::move_sentinel<const int*>, std::move_sentinel<int*>>);
     static_assert( std::is_convertible_v<std::move_sentinel<int>, std::move_sentinel<NonConvertible>>);
     static_assert(!std::is_convertible_v<std::move_sentinel<long>, std::move_sentinel<NonConvertible>>);
   }
   return true;

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/ctor.default.pass.cpp

 
 // constexpr move_sentinel();
 
 #include <iterator>
 #include <cassert>
 
 constexpr bool test()
 {
+
+  // The underlying sentinel is an integer.
   {
     std::move_sentinel<int> m;
     assert(m.base() == 0);
   }
+
+  // The underlying sentinel is a pointer.
   {
     std::move_sentinel<int*> m;
     assert(m.base() == nullptr);
   }
+
+  // The underlying sentinel is a user-defined type with an explicit default constructor.
   {
     struct S {
       explicit S() = default;
       int i = 3;
     };
     std::move_sentinel<S> m;
     assert(m.base().i == 3);
   }
+
   return true;
 }
 
 int main(int, char**)
 {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/ctor.sentinel.pass.cpp

 
 // constexpr explicit move_sentinel(S s);
 
 #include <iterator>
 #include <cassert>
 
 constexpr bool test()
 {
+  // The underlying sentinel is an integer.
   {
     static_assert(!std::is_convertible_v<int, std::move_sentinel<int>>);
     std::move_sentinel<int> m(42);
     assert(m.base() == 42);
   }
+
+  // The underlying sentinel is a pointer.
   {
     static_assert(!std::is_convertible_v<int*, std::move_sentinel<int*>>);
     int i = 42;
     std::move_sentinel<int*> m(&i);
     assert(m.base() == &i);
   }
+
+  // The underlying sentinel is a user-defined type with an explicit default constructor.
   {
     struct S {
       explicit S() = default;
       constexpr explicit S(int j) : i(j) {}
       int i = 3;
     };
     static_assert(!std::is_convertible_v<S, std::move_sentinel<S>>);
     std::move_sentinel<S> m(S(42));

libcxx/test/std/iterators/predef.iterators/move.iterators/move.sentinel/op_eq.pass.cpp

 static_assert( HasNotEquals<std::move_iterator<int*>, std::move_sentinel<const int*>>);
 static_assert(!HasLess<std::move_iterator<int*>, std::move_sentinel<const int*>>);
 
 static_assert( HasEquals<std::move_iterator<const int*>, std::move_sentinel<int*>>);
 static_assert( HasNotEquals<std::move_iterator<const int*>, std::move_sentinel<int*>>);
 static_assert(!HasLess<std::move_iterator<const int*>, std::move_sentinel<int*>>);
 
 template <class It>
-constexpr bool test_one()
-{
-  {
-    char s[] = "abc";
-    const auto it = std::move_iterator<It>(It(s));
-    const auto sent1 = std::move_sentinel<sentinel_wrapper<It>>(sentinel_wrapper<It>(It(s)));
-    const auto sent2 = std::move_sentinel<sentinel_wrapper<It>>(sentinel_wrapper<It>(It(s + 1)));
-    ASSERT_SAME_TYPE(decltype(it == sent1), bool);
-    assert( (it == sent1));
-    assert(!(it != sent1));
-    assert(!(it == sent2));
-    assert( (it != sent2));
-    assert( (sent1 == it));
-    assert(!(sent1 != it));
-    assert(!(sent2 == it));
-    assert( (sent2 != it));
-    static_assert(!HasEquals<decltype(sent1), decltype(sent1)>);
-    static_assert(!HasLess<decltype(sent1), decltype(sent1)>);
-  }
-  return true;
-}
+constexpr void test_one() {
 
-constexpr bool test()
-{
+constexpr bool test() {
   test_one<cpp17_input_iterator<char*>>();
   test_one<cpp20_input_iterator<char*>>();
   test_one<forward_iterator<char*>>();
   test_one<bidirectional_iterator<char*>>();
   test_one<random_access_iterator<char*>>();
   test_one<contiguous_iterator<char*>>();
   test_one<three_way_contiguous_iterator<char*>>();
   test_one<char*>();
   test_one<const char*>();
 
   return true;
 }
 
-int main(int, char**)
-{
+int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // friend constexpr iter_rvalue_reference_t<Iterator>
 //   iter_move(const reverse_iterator& i) noexcept(see below);
 
 #include <iterator>
 
 #include <cassert>
 #include <type_traits>
 #include <utility>
+#include "test_iterators.h"
 #include "test_macros.h"
 
-namespace adl {
-
-struct Iterator {
-  using value_type = int;
-  using difference_type = ptrdiff_t;
-
-  value_type* ptr_ = nullptr;
-  int* iter_move_invocations_ = nullptr;
-
-  constexpr Iterator() = default;
-  constexpr explicit Iterator(int* p, int& iter_moves) : ptr_(p), iter_move_invocations_(&iter_moves) {}
-
-  constexpr value_type& operator*() const { return *ptr_; }
-
-  Iterator& operator++() { ++ptr_; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
-    ++ptr_;
-    return prev;
-  }
-
-  constexpr Iterator& operator--() { --ptr_; return *this; }
-  constexpr Iterator operator--(int) {
-    Iterator prev = *this;
-    --ptr_;
-    return prev;
-  }
-
-  constexpr friend value_type&& iter_move(Iterator iter) {
-    if (iter.iter_move_invocations_) {
-      ++(*iter.iter_move_invocations_);
-    }
-    return std::move(*iter);
-  }
-
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
-};
-
-} // namespace adl
-
 constexpr bool test() {
   // Can use `iter_move` with a regular array.
   {
     constexpr int N = 3;
     int a[N] = {0, 1, 2};
 
     std::reverse_iterator<int*> ri(a + N);
     static_assert(std::same_as<decltype(iter_move(ri)), int&&>);
     assert(iter_move(ri) == 2);
 
     ++ri;
     assert(iter_move(ri) == 1);
   }
 
-  // Ensure the `iter_move` customization point is being used.
+  // Check that the `iter_move` customization point is being used.
   {
     constexpr int N = 3;
     int a[N] = {0, 1, 2};
 
     int iter_move_invocations = 0;
-    adl::Iterator i(a + N, iter_move_invocations);
+    adl::Iterator i = adl::Iterator::TrackMoves(a + N, iter_move_invocations);
     std::reverse_iterator<adl::Iterator> ri(i);
     int x = iter_move(ri);
     assert(x == 2);
     assert(iter_move_invocations == 1);
   }
 
   // Check the `noexcept` specification.
   {

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

 //     iter_swap(const reverse_iterator& x,
 //               const reverse_iterator<Iterator2>& y) noexcept(see below);
 
 #include <iterator>
 
 #include <cassert>
 #include <type_traits>
 #include <utility>
+#include "test_iterators.h"
 #include "test_macros.h"
 
-namespace adl {
-
-struct Iterator {
-  using value_type = int;
-  using difference_type = ptrdiff_t;
-
-  value_type* ptr_ = nullptr;
-  int* iter_swap_invocations_ = nullptr;
-
-  constexpr Iterator() = default;
-  constexpr explicit Iterator(int& iter_swaps) : iter_swap_invocations_(&iter_swaps) {}
-
-  value_type& operator*() const { return *ptr_; }
-
-  Iterator& operator++() { ++ptr_; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
-    ++ptr_;
-    return prev;
-  }
-
-  Iterator& operator--() { --ptr_; return *this; }
-  Iterator operator--(int) {
-    Iterator prev = *this;
-    --ptr_;
-    return prev;
-  }
-
-  constexpr friend void iter_swap(Iterator a, Iterator) {
-    if (a.iter_swap_invocations_) {
-      ++(*a.iter_swap_invocations_);
-    }
-  }
-
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
-};
-
-} // namespace adl
-
 constexpr bool test() {
   // Can use `iter_swap` with a regular array.
   {
     constexpr int N = 3;
     int a[N] = {0, 1, 2};
 
     std::reverse_iterator rb(a + N);
     std::reverse_iterator re(a + 1);
     assert(a[0] == 0);
     assert(a[2] == 2);
 
     static_assert(std::same_as<decltype(iter_swap(rb, re)), void>);
     iter_swap(rb, re);
     assert(a[0] == 2);
     assert(a[2] == 0);
   }
 
-  // Ensure the `iter_swap` customization point is being used.
+  // Check that the `iter_swap` customization point is being used.
   {
     int iter_swap_invocations = 0;
-    adl::Iterator i1(iter_swap_invocations), i2(iter_swap_invocations);
-    std::reverse_iterator<adl::Iterator> ri1(i1), ri2(i2);
-    iter_swap(i1, i2);
+    int a[] = {0, 1, 2};
+    adl::Iterator base1 = adl::Iterator::TrackSwaps(a + 1, iter_swap_invocations);
+    adl::Iterator base2 = adl::Iterator::TrackSwaps(a + 2, iter_swap_invocations);
+    std::reverse_iterator<adl::Iterator> ri1(base1), ri2(base2);
+    iter_swap(ri1, ri2);
     assert(iter_swap_invocations == 1);
 
-    iter_swap(i2, i1);
+    iter_swap(ri2, ri1);
     assert(iter_swap_invocations == 2);
   }
 
   // Check the `noexcept` specification.
   {
     {
       struct ThrowingCopyNoexceptDecrement {
         using value_type = int;

libcxx/test/std/iterators/predef.iterators/reverse.iterators/types.compile.pass.cpp

 struct std::indirectly_readable_traits<FooIter> {
   using value_type = int;
 };
 template <>
 struct std::incrementable_traits<FooIter> {
   using difference_type = char;
 };
 
+// Not using `FooIter::value_type`.
 static_assert(std::is_same_v<typename std::reverse_iterator<FooIter>::value_type, int>);
+// Not using `FooIter::difference_type`.
 static_assert(std::is_same_v<typename std::reverse_iterator<FooIter>::difference_type, char>);
 
 #endif
 
 struct BarIter {
   bool& operator*() const;
 };
 template <>

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp

 #include <cassert>
 #include <type_traits>
 #include <utility>
 #include "../types.h"
 
 namespace adl {
 
 template <bool IsNoexcept = false>
-struct Iterator {
+struct MaybeNoexceptIterator {
   using value_type = int;
   using difference_type = ptrdiff_t;
 
   value_type* ptr_ = nullptr;
   int* iter_move_invocations_ = nullptr;
 
-  constexpr Iterator() = default;
-  constexpr explicit Iterator(int* p, int& iter_moves) : ptr_(p), iter_move_invocations_(&iter_moves) {}
+  constexpr MaybeNoexceptIterator() = default;
+  constexpr explicit MaybeNoexceptIterator(int* p, int& iter_moves) : ptr_(p), iter_move_invocations_(&iter_moves) {}
 
   constexpr value_type& operator*() const { return *ptr_; }
 
-  Iterator& operator++() { ++ptr_; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
+  MaybeNoexceptIterator& operator++() { ++ptr_; return *this; }
+  MaybeNoexceptIterator operator++(int) {
+    MaybeNoexceptIterator prev = *this;
     ++ptr_;
     return prev;
   }
 
-  constexpr Iterator& operator--() { --ptr_; return *this; }
-  constexpr Iterator operator--(int) {
-    Iterator prev = *this;
+  constexpr MaybeNoexceptIterator& operator--() { --ptr_; return *this; }
+  constexpr MaybeNoexceptIterator operator--(int) {
+    MaybeNoexceptIterator prev = *this;
     --ptr_;
     return prev;
   }
 
-  constexpr friend value_type&& iter_move(Iterator iter) noexcept(IsNoexcept) {
+  constexpr friend value_type&& iter_move(MaybeNoexceptIterator iter) noexcept(IsNoexcept) {
     if (iter.iter_move_invocations_) {
       ++(*iter.iter_move_invocations_);
     }
     return std::move(*iter);
   }
 
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+  friend bool operator==(const MaybeNoexceptIterator& lhs, const MaybeNoexceptIterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
 };
 
 template <bool IsNoexcept = false>
 struct View : std::ranges::view_base {
   static constexpr int N = 3;
   int a[N] = {0, 1, 2};
   int* iter_moves = nullptr;
 
   constexpr View() = default;
   constexpr View(int& iter_move_invocations) : iter_moves(&iter_move_invocations) {
   }
 
-  constexpr adl::Iterator<IsNoexcept> begin() { return adl::Iterator<IsNoexcept>(a, *iter_moves); }
-  constexpr adl::Iterator<IsNoexcept> end() { return adl::Iterator<IsNoexcept>(a + N, *iter_moves); }
+  constexpr adl::MaybeNoexceptIterator<IsNoexcept> begin() {
+    return adl::MaybeNoexceptIterator<IsNoexcept>(a, *iter_moves);
+  }
+  constexpr adl::MaybeNoexceptIterator<IsNoexcept> end() {
+    return adl::MaybeNoexceptIterator<IsNoexcept>(a + N, *iter_moves);
+  }
 };
 
 } // namespace adl
 
 constexpr bool test() {
   // Can use `iter_move` with `inner-iterator`; `View` is a forward range.
   {
     SplitViewForward v("abc def", " ");
constexpr bool test() {
   }
 
   // Check the `noexcept` specification.
   {
     {
       using ThrowingSplitView = std::ranges::lazy_split_view<adl::View<false>, adl::View<false>>;
       using ThrowingValueType = std::ranges::iterator_t<ThrowingSplitView>::value_type;
       using ThrowingIter = std::ranges::iterator_t<ThrowingValueType>;
-      ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::Iterator<false>>()));
+      ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::MaybeNoexceptIterator<false>>()));
       ASSERT_NOT_NOEXCEPT(iter_move(std::declval<ThrowingIter>()));
     }
 
     {
       using NoexceptSplitView = std::ranges::lazy_split_view<adl::View<true>, adl::View<true>>;
       using NoexceptValueType = std::ranges::iterator_t<NoexceptSplitView>::value_type;
       using NoexceptIter = std::ranges::iterator_t<NoexceptValueType>;
-      ASSERT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::Iterator<true>>()));
+      ASSERT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::MaybeNoexceptIterator<true>>()));
       ASSERT_NOEXCEPT(iter_move(std::declval<NoexceptIter>()));
     }
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.pass.cpp

 #include <cassert>
 #include <type_traits>
 #include <utility>
 #include "../types.h"
 
 namespace adl {
 
 template <bool IsNoexcept = false>
-struct Iterator {
+struct MaybeNoexceptIterator {
   using value_type = int;
   using difference_type = ptrdiff_t;
 
   value_type* ptr_ = nullptr;
   int* iter_swap_invocations_ = nullptr;
 
-  constexpr Iterator() = default;
-  constexpr explicit Iterator(int& iter_swaps) : iter_swap_invocations_(&iter_swaps) {}
+  constexpr MaybeNoexceptIterator() = default;
+  constexpr explicit MaybeNoexceptIterator(int& iter_swaps) : iter_swap_invocations_(&iter_swaps) {}
 
   value_type& operator*() const { return *ptr_; }
 
-  Iterator& operator++() { ++ptr_; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
+  MaybeNoexceptIterator& operator++() { ++ptr_; return *this; }
+  MaybeNoexceptIterator operator++(int) {
+    MaybeNoexceptIterator prev = *this;
     ++ptr_;
     return prev;
   }
 
-  Iterator& operator--() { --ptr_; return *this; }
-  Iterator operator--(int) {
-    Iterator prev = *this;
+  MaybeNoexceptIterator& operator--() { --ptr_; return *this; }
+  MaybeNoexceptIterator operator--(int) {
+    MaybeNoexceptIterator prev = *this;
     --ptr_;
     return prev;
   }
 
-  constexpr friend void iter_swap(Iterator a, Iterator) noexcept(IsNoexcept) {
+  constexpr friend void iter_swap(MaybeNoexceptIterator a, MaybeNoexceptIterator) noexcept(IsNoexcept) {
     if (a.iter_swap_invocations_) {
       ++(*a.iter_swap_invocations_);
     }
   }
 
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+  friend bool operator==(const MaybeNoexceptIterator& lhs, const MaybeNoexceptIterator& rhs) {
+    return lhs.ptr_ == rhs.ptr_;
+  }
 };
 
 template <bool IsNoexcept = false>
 struct View : std::ranges::view_base {
   int* iter_swaps = nullptr;
 
   constexpr View() = default;
   constexpr View(int& iter_swap_invocations) : iter_swaps(&iter_swap_invocations) {
   }
 
-  constexpr adl::Iterator<IsNoexcept> begin() { return adl::Iterator<IsNoexcept>(*iter_swaps); }
-  constexpr adl::Iterator<IsNoexcept> end() { return adl::Iterator<IsNoexcept>(*iter_swaps); }
+  constexpr adl::MaybeNoexceptIterator<IsNoexcept> begin() {
+    return adl::MaybeNoexceptIterator<IsNoexcept>(*iter_swaps);
+  }
+  constexpr adl::MaybeNoexceptIterator<IsNoexcept> end() {
+    return adl::MaybeNoexceptIterator<IsNoexcept>(*iter_swaps);
+  }
 };
 
 } // namespace adl
 
 constexpr bool test() {
   // Can use `iter_swap` with `inner-iterator`; `View` is a forward range.
   {
     // Non-const iterator.
constexpr bool test() {
   }
 
   // Check the `noexcept` specification.
   {
     {
       using ThrowingSplitView = std::ranges::lazy_split_view<adl::View<false>, adl::View<false>>;
       using ThrowingValueType = std::ranges::iterator_t<ThrowingSplitView>::value_type;
       using ThrowingIter = std::ranges::iterator_t<ThrowingValueType>;
-      ASSERT_NOT_NOEXCEPT(
-          std::ranges::iter_swap(std::declval<adl::Iterator<false>>(), std::declval<adl::Iterator<false>>()));
+      ASSERT_NOT_NOEXCEPT(std::ranges::iter_swap(
+          std::declval<adl::MaybeNoexceptIterator<false>>(),
+          std::declval<adl::MaybeNoexceptIterator<false>>()));
       ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<ThrowingIter>(), std::declval<ThrowingIter>()));
     }
 
     {
       using NoexceptSplitView = std::ranges::lazy_split_view<adl::View<true>, adl::View<true>>;
       using NoexceptValueType = std::ranges::iterator_t<NoexceptSplitView>::value_type;
       using NoexceptIter = std::ranges::iterator_t<NoexceptValueType>;
-      ASSERT_NOEXCEPT(
-          std::ranges::iter_swap(std::declval<adl::Iterator<true>>(), std::declval<adl::Iterator<true>>()));
+      ASSERT_NOEXCEPT(std::ranges::iter_swap(
+          std::declval<adl::MaybeNoexceptIterator<true>>(),
+          std::declval<adl::MaybeNoexceptIterator<true>>()));
       ASSERT_NOEXCEPT(iter_swap(std::declval<NoexceptIter>(), std::declval<NoexceptIter>()));
     }
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp

 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_move)>);
 
 static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_move), int*, int*, long*, long*>);
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_move), int*, int*, NotConvertibleFromInt*,
                                    NotConvertibleFromInt*>);
 
-namespace adl {
-
-static int iter_move_invocations = 0;
-
-template <class T>
-struct Iterator {
-  using value_type = T;
-  using difference_type = int;
-  using iterator_concept = std::input_iterator_tag;
-
-  T* ptr = nullptr;
-
-  Iterator() = default;
-  explicit Iterator(int* p) : ptr(p) {}
-
-  T& operator*() const { return *ptr; }
-
-  Iterator& operator++() { ++ptr; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
-    ++ptr;
-    return prev;
-  }
-
-  friend T&& iter_move(Iterator iter) {
-    ++iter_move_invocations;
-    return std::move(*iter);
-  }
-
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
-};
-
-} // namespace adl
-
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     {
// Destination range is shorter than the source range, (range) overload.
     assert(result.out == out.end());
   }
 
   // Ensure the `iter_move` customization point is being used.
   {
     constexpr int N = 3;
     int in[N] = {1, 2, 3};
     Buffer<int, N> out;
-    adl::Iterator<int> begin(in);
-    adl::Iterator<int> end(in + N);
+    int iter_moves = 0;
+    adl::Iterator begin = adl::Iterator::TrackMoves(in, iter_moves);
+    adl::Iterator end = adl::Iterator::TrackMoves(in + N, iter_moves);
 
     std::ranges::uninitialized_move(begin, end, out.begin(), out.end());
-    assert(adl::iter_move_invocations == 3);
-    adl::iter_move_invocations = 0;
+    assert(iter_moves == 3);
+    iter_moves = 0;
 
     std::ranges::subrange range(begin, end);
     std::ranges::uninitialized_move(range, out);
-    assert(adl::iter_move_invocations == 3);
-    adl::iter_move_invocations = 0;
+    assert(iter_moves == 3);
+    iter_moves = 0;
   }
 
   return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp

 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <ranges>
 #include <type_traits>
 
 #include "../buffer.h"
 #include "../counted.h"
-#include "test_macros.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 
 // TODO(varconst): consolidate the ADL checks into a single file.
 // Because this is a variable and not a function, it's guaranteed that ADL won't be used. However,
 // implementations are allowed to use a different mechanism to achieve this effect, so this check is
 // libc++-specific.
 LIBCPP_STATIC_ASSERT(std::is_class_v<decltype(std::ranges::uninitialized_move_n)>);
 
 static_assert(std::is_invocable_v<decltype(std::ranges::uninitialized_move_n), int*, size_t, long*, long*>);
 struct NotConvertibleFromInt {};
 static_assert(!std::is_invocable_v<decltype(std::ranges::uninitialized_move_n), int*, size_t, NotConvertibleFromInt*,
                                    NotConvertibleFromInt*>);
 
-namespace adl {
-
-static int iter_move_invocations = 0;
-
-template <class T>
-struct Iterator {
-  using value_type = T;
-  using difference_type = int;
-  using iterator_concept = std::input_iterator_tag;
-
-  T* ptr = nullptr;
-
-  Iterator() = default;
-  explicit Iterator(int* p) : ptr(p) {}
-
-  T& operator*() const { return *ptr; }
-
-  Iterator& operator++() { ++ptr; return *this; }
-  Iterator operator++(int) {
-    Iterator prev = *this;
-    ++ptr;
-    return prev;
-  }
-
-  friend T&& iter_move(Iterator iter) {
-    ++iter_move_invocations;
-    return std::move(*iter);
-  }
-
-  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr == rhs.ptr; }
-};
-
-} // namespace adl
-
 int main(int, char**) {
   // An empty range -- no default constructors should be invoked.
   {
     Counted in[] = {Counted()};
     Buffer<Counted, 1> out;
     Counted::reset();
 
     auto result = std::ranges::uninitialized_move_n(in, 0, out.begin(), out.end());
// Destination range is shorter than the source range.
     assert(result.out == out.end());
   }
 
   // Ensure the `iter_move` customization point is being used.
   {
     constexpr int N = 3;
     int in[N] = {1, 2, 3};
     Buffer<int, N> out;
-    adl::Iterator<int> begin(in);
-    adl::Iterator<int> end(in + N);
+    int iter_moves = 0;
+    adl::Iterator begin = adl::Iterator::TrackMoves(in, iter_moves);
+    adl::Iterator end = adl::Iterator::TrackMoves(in + N, iter_moves);
 
     std::ranges::uninitialized_move(begin, end, out.begin(), out.end());
-    assert(adl::iter_move_invocations == 3);
-    adl::iter_move_invocations = 0;
+    assert(iter_moves == 3);
+    iter_moves = 0;
 
     std::ranges::subrange range(begin, end);
     std::ranges::uninitialized_move(range, out);
-    assert(adl::iter_move_invocations == 3);
-    adl::iter_move_invocations = 0;
+    assert(iter_moves == 3);
+    iter_moves = 0;
   }
 
   return 0;
 }

libcxx/test/support/test_iterators.h

public:
     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_;
 };
+
+namespace adl {
+
+class Iterator {
+ public:
+  using value_type = int;
+  using difference_type = ptrdiff_t;
+
+ private:
+  value_type* ptr_ = nullptr;
+  int* iter_moves_ = nullptr;
+  int* iter_swaps_ = nullptr;
+
+  constexpr Iterator(int* p, int* iter_moves, int* iter_swaps)
+    : ptr_(p)
+    , iter_moves_(iter_moves)
+    , iter_swaps_(iter_swaps) {}
+
+ public:
+  constexpr Iterator() = default;
+  static constexpr Iterator TrackMoves(int* p, int& iter_moves) {
+    return Iterator(p, &iter_moves, /*iter_swaps=*/nullptr);
+  }
+  static constexpr Iterator TrackSwaps(int& iter_swaps) {
+    return Iterator(/*p=*/nullptr, /*iter_moves=*/nullptr, &iter_swaps);
+  }
+  static constexpr Iterator TrackSwaps(int* p, int& iter_swaps) {
+    return Iterator(p, /*iter_moves=*/nullptr, &iter_swaps);
+  }
+
+  constexpr int iter_moves() const { assert(iter_moves_); return *iter_moves_; }
+  constexpr int iter_swaps() const { assert(iter_swaps_); return *iter_swaps_; }
+
+  constexpr value_type& operator*() const { return *ptr_; }
+
+  constexpr Iterator operator+(difference_type n) const {
+    return Iterator(ptr_ + n, iter_moves_, iter_swaps_);
+  }
+
+  constexpr Iterator& operator++() { ++ptr_; return *this; }
+  constexpr Iterator operator++(int) {
+    Iterator prev = *this;
+    ++ptr_;
+    return prev;
+  }
+
+  constexpr Iterator& operator--() { --ptr_; return *this; }
+  constexpr Iterator operator--(int) {
+    Iterator prev = *this;
+    --ptr_;
+    return prev;
+  }
+
+  constexpr friend void iter_swap(Iterator a, Iterator) {
+    if (a.iter_swaps_) {
+      ++(*a.iter_swaps_);
+    }
+  }
+
+  constexpr friend value_type&& iter_move(Iterator iter) {
+    if (iter.iter_moves_) {
+      ++(*iter.iter_moves_);
+    }
+    return std::move(*iter);
+  }
+
+  constexpr friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+};
+
+} // namespace adl
+
 #endif // TEST_STD_VER > 17
 
 #endif // SUPPORT_TEST_ITERATORS_H