[libc++] Refactor the ranges::prev and ranges::next tests

[ldionne]

Summary

This started as an attempt to fix a GCC 11 warning of misplaced parentheses.
I then noticed that trying to fix the parentheses warning actually triggered
errors in the tests, showing that we were incorrectly assuming that the
implementation of ranges::advance was using operator+= or operator-=.

This commit fixes that issue and makes the tests easier to follow by
localizing the assertions it makes. It also doesn't try to pretend that
we can use ranges::next with a straight output_iterator, which isn't
the case in reality.

[• Quuxplusone]

Partly reviewed, but had to step away in the middle.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/constraints.verify.cpp

0

It would be even nicer to make this a real SFINAE test and enable it for gcc-10/gcc-11.

[zoecarver]

LGTM, thanks for the cleanup.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/constraints.verify.cpp

0

I agree. I think wherever possible we should move away from .verify tests. This could just be is_invocable_v.

The only place we should really use the .verify tests is when we're checking a static_assert.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

81

Do we want to add other checks for output_iterator? Why did you remove this check?

[ldionne]

Apply review comments.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

81

Those overloads of std::ranges::next can't be used with an output_iterator out of the box, since output_iterator is missing a comparison operator (we need to compare against the sentinel). I'm still testing against output_iterators for the next(iter) and next(iter, n) overloads, though.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

49–64

Ooh, this test is super subtle. I recommend rewriting it as

template <class It>
constexpr void check_assignable_sentinel_case() {
  int range[] = {1, 2, 3, 4};
  It first = It(stride_counting_iterator<int*>(range + 1));
  It last = It(stride_counting_iterator<int*>(range + 4));
  It result = std::ranges::next(std::move(first), std::move(last));
  assert(base(result).base() == range + 4);  // i.e. last
  assert(result.stride_count() == 0);  // because we got here by copying last's value, not by incrementing
}
[...]
check_assignable_sentinel_case<cpp17_input_iterator<stride_counting_iterator<int*>>>();
check_assignable_sentinel_case<cpp20_input_iterator<stride_counting_iterator<int*>>>();
check_assignable_sentinel_case<output_iterator<stride_counting_iterator<int*>>>();
check_assignable_sentinel_case<forward_iterator<stride_counting_iterator<int*>>>();

etc. etc. In particular, I'm willing to believe sans tests that cpp17_input_iterator<stride_counting_iterator<int*>> is a cpp17_input_iterator, but I'm not willing to believe the same of stride_counting_iterator<cpp17_input_iterator<int*>>.

81

+1; I don't understand the bit of @ldionne's summary about not being able to use next on straight output iterators. cppreference thinks you can increment an output iterator just fine. So why was this line removed? And why weren't similar lines in other tests removed? (Grep the right side for output_iterator — we're still using it in plenty of places, e.g. line 32 of range.iter.ops.next/iterator.pass.cpp.) So I don't get it.

112–113

Please replace cpp17_input_iterator<range_t::const_iterator> with cpp17_input_iterator<const int*> and so on, throughout this file and anywhere else you see this pattern happening.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator.pass.cpp

19–32

FWIW, I'd prefer to see this simplified down to

template<class It>
constexpr bool test() {
  int range[] = {0, 1, 2, 3, 4, 5};
  assert(std::ranges::prev(It(range+1)) == It(range));
  assert(std::ranges::prev(It(range+5)) == It(range+4));
  assert(std::ranges::prev(It(range+6)) == It(range+5));
  return true;
}

int main(int, char**) {
  static_assert(test<bidirectional_iterator<int*>>());
  static_assert(test<random_access_iterator<int*>>());
  static_assert(test<contiguous_iterator<int*>>());
  static_assert(test<int*>());
  test<bidirectional_iterator<int*>>();
  test<random_access_iterator<int*>>();
  test<contiguous_iterator<int*>>();
  test<int*>();
}

This shortens the line lengths, and makes sure we hit the "one-past-the-end" case in constexpr for all kinds of iterators including raw pointers.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

81

Our comments crossed in the ether (and also my understanding of this test is evolving). check_assignable_case is super subtle: it does not depend on comparing iterators at all. It simply says, "Ah, output_iterator is assignable from output_iterator, so std::ranges::next(it1, it2) is simply the result of it1 = it2, full stop." There is no comparison involved.
See the sample implementation of advance here: https://en.cppreference.com/w/cpp/iterator/ranges/advance , the part that mentions std::assignable_from. (The sample implementation of next is done in terms of advance.)

[ldionne]

Address review comments and tweak tests for advance too.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

81

This is the signature of next(it, sent):

template<input_­or_­output_­iterator I, sentinel_­for<I> S>
constexpr I ranges::next(I x, S bound);

In particular, it requires sentinel_­for<I> S, which is not satisfied here because output_iterator<T> is not a sentinel for output_iterator<T> (it's missing the comparison). So it's simply invalid to try and call next(it, sent) when both it and sent are an output iterator archetype - we'd have to add something to the archetype to make it model sentinel_for.

It is true the implementation doesn't technically require comparing against the sentinel, but the signature still requires it.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator.pass.cpp

22–28

Simply:

int range[4] = {};
assert(base(std::ranges::next(It(range))) == range+1);
assert(base(std::ranges::next(It(range+3))) == range+4);

43–45

Bikeshed: Traditionally we put the runtime test first and the longer static_assert second.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

52–53

Here and throughout this function, the autos are really confusing. Is this auto the same thing as I?
Is &*result the same thing as base(result)? (base being an overload set defined in "test_iterators.h".)

81

OK, I buy that. I think there should be a runtime test verifying that (although operator==/!= is required to exist) nothing except operator= assignment is ever actually called in this case.

120

Since you're changing this code anyway, FWIW I'd prefer
forward_iterator<int*>(range+k)
rather than
forward_iterator(&range[k])
throughout. (And I doubt that the variation of k — 0, 1, ... 7 — is pulling its weight. I'd leave them all as FooIter<int*>(range) for brevity, or else FooIter<int*>(range+10) for verification-that-these-pointers-are-never-dereferenced. And there's no reason range has to be so big; making it, say, size-4 instead of size-10 would be fine.)

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/constraints.compile.pass.cpp

23

I think you intended Args&&... args here. Otherwise the forward below should just be move (and it's certainly redundant either way, given that Args... here are always scalar types).

32–33

I'd do this by

using Jt = bidirectional_iterator<int*>;
static_assert(has_ranges_prev<Jt>);
static_assert(has_ranges_prev<Jt, std::ptrdiff_t>);
static_assert(has_ranges_prev<Jt, std::ptrdiff_t, Jt>);

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator.pass.cpp

22–25

int range[4] = {};
assert(std::ranges::prev(It(range+1)) == It(range));
assert(std::ranges::prev(It(range+4)) == It(range+3));

It turns out I'm never happy. ;)

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator_count.pass.cpp

30

s/auto const/std::ptrdiff_t/ for sanity's sake.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator_count_sentinel.pass.cpp

31

Please declare one variable per line.
This smells like CTAD — is stride_counting_iterator a template? if so, could we write out its arguments?

libcxx/test/support/test_iterators.h

732–734

While you're here, you might remove the [[nodiscard]].

[ldionne]

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator.pass.cpp

22–28

I wanted the test to be agnostic to the fact that It is an iterator archetype or not.

43–45

Indeed, will fix throughout.

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

52–53

As I said elsewhere, &* is to avoid relying on the fact that it's an iterator archetype. Will fix auto.

libcxx/include/__iterator/advance.h

 }
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
 namespace ranges {
 // [range.iter.op.advance]
 struct __advance_fn final : __function_like {
 private:
-  template <signed_integral _Tp>
-  static constexpr make_unsigned_t<_Tp> __abs(_Tp const __n) noexcept {
-    auto const __unsigned_n = __to_unsigned_like(__n);
-    auto const __complement = ~__unsigned_n + 1;
-    return __n < 0 ? __complement : __unsigned_n;
+  template <class _Tp>
+  static constexpr _Tp __abs(_Tp __n) noexcept {
+    return __n < 0 ? -__n : __n;
   }
 
   template <class _Ip>
   static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n) {
     while (__n > 0) {
       --__n;
       ++__i;
     }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/advance.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
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: gcc-10
-
-// ranges::advance
-
-#include <iterator>
-
-#include <array>
-#include <cassert>
-
-#include "test_standard_function.h"
-#include "test_iterators.h"
-
-static_assert(is_function_like<decltype(std::ranges::advance)>());
-
-using range_t = std::array<int, 10>;
-
-[[nodiscard]] constexpr bool operator==(output_iterator<int*> const x, output_iterator<int*> const y) {
-  return x.base() == y.base();
-}
-
-template <std::input_or_output_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  auto const distance = n < 0 ? -n : n;
-  assert(i.stride_count() == distance);
-  assert(i.stride_displacement() == n);
-}
-
-template <std::random_access_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  assert(i.stride_count() == 0 || i.stride_count() == 1);
-  assert(i.stride_displacement() == n < 0 ? -1 : 1);
-}
-
-namespace iterator_count {
-template <std::input_or_output_iterator I>
-constexpr void check_move_forward(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(I(range.begin()));
-  std::ranges::advance(first, n);
-  assert(std::move(first).base().base() == range.begin() + n);
-  check_round_trip(first, n);
-}
-
-template <std::bidirectional_iterator I>
-constexpr void check_move_backward(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(I(range.begin() + n));
-  std::ranges::advance(first, -n);
-  assert(std::move(first).base().base() == range.begin());
-  check_round_trip(first, -n);
-}
-
-[[nodiscard]] constexpr bool test() {
-  check_move_forward<cpp17_input_iterator<range_t::const_iterator> >(1);
-  check_move_forward<cpp20_input_iterator<range_t::const_iterator> >(2);
-  check_move_forward<forward_iterator<range_t::const_iterator> >(3);
-  check_move_forward<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_move_forward<random_access_iterator<range_t::const_iterator> >(5);
-  check_move_forward<contiguous_iterator<range_t::const_iterator> >(6);
-  check_move_forward<output_iterator<range_t::iterator> >(7);
-
-  check_move_backward<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_move_backward<random_access_iterator<range_t::const_iterator> >(5);
-  check_move_backward<contiguous_iterator<range_t::const_iterator> >(6);
-
-  // Zero should be checked for each case and each overload
-  check_move_forward<cpp17_input_iterator<range_t::const_iterator> >(0);
-  check_move_forward<cpp20_input_iterator<range_t::const_iterator> >(0);
-  check_move_forward<forward_iterator<range_t::const_iterator> >(0);
-  check_move_forward<bidirectional_iterator<range_t::const_iterator> >(0);
-  check_move_forward<random_access_iterator<range_t::const_iterator> >(0);
-  check_move_forward<output_iterator<range_t::iterator> >(0);
-  check_move_backward<bidirectional_iterator<range_t::const_iterator> >(0);
-  check_move_backward<random_access_iterator<range_t::const_iterator> >(0);
-
-  return true;
-}
-} // namespace iterator_count
-
-class distance_apriori_sentinel {
-public:
-  distance_apriori_sentinel() = default;
-  constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
-
-  [[nodiscard]] constexpr bool operator==(std::input_or_output_iterator auto const&) const {
-    assert(false && "difference op should take precedence");
-    return false;
-  }
-
-  [[nodiscard]] constexpr friend std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
-                                                          distance_apriori_sentinel const y) {
-    return -y.count_;
-  }
-
-  [[nodiscard]] constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
-                                                          std::input_or_output_iterator auto const&) {
-    return x.count_;
-  }
-
-private:
-  std::ptrdiff_t count_ = 0;
-};
-
-namespace iterator_sentinel {
-template <std::input_or_output_iterator I, std::sentinel_for<I> S = I>
-constexpr void check_assignable_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(I(range.begin()));
-  std::ranges::advance(first, stride_counting_iterator(S(I(range.begin() + n))));
-  assert(std::move(first).base().base() == range.begin() + n);
-  assert(first.stride_count() == 0); // always zero, so don't use `check_round_trip`
-}
-
-template <std::input_or_output_iterator I>
-constexpr void check_sized_sentinel_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(I(range.begin()));
-  std::ranges::advance(first, distance_apriori_sentinel(n));
-  assert(std::move(first).base().base() == range.begin() + n);
-  check_round_trip(first, n);
-}
-
-template <std::input_or_output_iterator I>
-constexpr void check_sentinel_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(I(range.begin()));
-  auto const last = I(range.begin() + n);
-  std::ranges::advance(first, sentinel_wrapper(last));
-  assert(first.base() == last);
-  assert(first.stride_count() == n); // always `n`, so don't use `check_round_trip`
-}
-
-[[nodiscard]] constexpr bool test() {
-  check_assignable_case<cpp17_input_iterator<range_t::const_iterator> >(1);
-  check_assignable_case<forward_iterator<range_t::const_iterator> >(3);
-  check_assignable_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_assignable_case<random_access_iterator<range_t::const_iterator> >(5);
-  check_assignable_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_assignable_case<output_iterator<range_t::iterator> >(7);
-
-  check_sized_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(7);
-  check_sized_sentinel_case<cpp20_input_iterator<range_t::const_iterator> >(6);
-  check_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(5);
-  check_sized_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(3);
-  check_sized_sentinel_case<contiguous_iterator<range_t::const_iterator> >(2);
-  check_sized_sentinel_case<output_iterator<range_t::iterator> >(1);
-
-  check_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(1);
-  // cpp20_input_iterator not copyable, so is omitted
-  check_sentinel_case<forward_iterator<range_t::const_iterator> >(3);
-  check_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_sentinel_case<random_access_iterator<range_t::const_iterator> >(5);
-  check_sentinel_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_sentinel_case<output_iterator<range_t::iterator> >(7);
-  return true;
-}
-} // namespace iterator_sentinel
-
-namespace iterator_count_sentinel {
-struct expected_t {
-  range_t::const_iterator coordinate;
-  std::ptrdiff_t result;
-};
-
-template <std::input_or_output_iterator I>
-constexpr void check_forward_sized_sentinel_case(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
-  auto current = stride_counting_iterator(I(range.begin()));
-  auto const result = std::ranges::advance(current, n, distance_apriori_sentinel(range.size()));
-  assert(current.base().base() == expected.coordinate);
-  assert(result == expected.result);
-  check_round_trip(current, n - expected.result);
-}
-
-template <std::random_access_iterator I>
-constexpr void check_backward_sized_sentinel_case(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
-  auto current = stride_counting_iterator(I(range.end()));
-  auto const result = std::ranges::advance(current, -n, stride_counting_iterator(I(range.begin())));
-  assert(current.base().base() == expected.coordinate);
-  assert(result == expected.result);
-  check_round_trip(current, n - expected.result);
-}
-
-template <std::input_or_output_iterator I>
-constexpr void check_forward_case(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
-  auto current = stride_counting_iterator(I(range.begin()));
-  auto const result = std::ranges::advance(current, n, sentinel_wrapper(I(range.end())));
-  assert(current.base().base() == expected.coordinate);
-  assert(result == expected.result);
-  assert(current.stride_count() == n - expected.result);
-}
-
-template <std::bidirectional_iterator I>
-constexpr void check_backward_case(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
-  auto current = stride_counting_iterator(I(range.end()));
-  auto const result = std::ranges::advance(current, -n, stride_counting_iterator(I(range.begin())));
-  assert(current.base().base() == expected.coordinate);
-  assert(result == expected.result);
-  assert(current.stride_count() == n + expected.result);
-  assert(current.stride_count() == -current.stride_displacement());
-}
-
-[[nodiscard]] constexpr bool test() {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  check_forward_sized_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(1, {range.begin() + 1, 0}, range);
-  // cpp20_input_iterator not copyable, so is omitted
-  check_forward_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(3, {range.begin() + 3, 0}, range);
-  check_forward_sized_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4, {range.begin() + 4, 0}, range);
-  check_forward_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0}, range);
-  check_forward_sized_sentinel_case<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 6, 0}, range);
-  check_forward_sized_sentinel_case<output_iterator<range_t::iterator> >(7, {range.begin() + 7, 0}, range);
-
-  // bidirectional_iterator omitted because `n < 0` case requires `same_as<I, S>`
-  check_backward_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0},
-                                                                                       range);
-  check_backward_sized_sentinel_case<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 4, 0}, range);
-
-  // disntance == range.size()
-  check_forward_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(10, {range.end(), 0}, range);
-  check_forward_sized_sentinel_case<output_iterator<range_t::iterator> >(10, {range.end(), 0}, range);
-  check_backward_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(10, {range.begin(), 0}, range);
-
-  // distance > range.size()
-  check_forward_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(1000, {range.end(), 990}, range);
-  check_forward_sized_sentinel_case<output_iterator<range_t::iterator> >(1000, {range.end(), 990}, range);
-  check_backward_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(1000, {range.begin(), -990},
-                                                                                       range);
-
-  check_forward_case<cpp17_input_iterator<range_t::const_iterator> >(1, {range.begin() + 1, 0}, range);
-  check_forward_case<forward_iterator<range_t::const_iterator> >(3, {range.begin() + 3, 0}, range);
-  check_forward_case<bidirectional_iterator<range_t::const_iterator> >(4, {range.begin() + 4, 0}, range);
-  check_forward_case<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0}, range);
-  check_forward_case<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 6, 0}, range);
-  check_forward_case<output_iterator<range_t::iterator> >(7, {range.begin() + 7, 0}, range);
-  check_backward_case<bidirectional_iterator<range_t::const_iterator> >(8, {range.begin() + 2, 0}, range);
-
-  // disntance == range.size()
-  check_forward_case<forward_iterator<range_t::const_iterator> >(10, {range.end(), 0}, range);
-  check_forward_case<output_iterator<range_t::iterator> >(10, {range.end(), 0}, range);
-  check_backward_case<bidirectional_iterator<range_t::const_iterator> >(10, {range.begin(), 0}, range);
-
-  // distance > range.size()
-  check_forward_case<forward_iterator<range_t::const_iterator> >(1000, {range.end(), 990}, range);
-  check_forward_case<output_iterator<range_t::iterator> >(1000, {range.end(), 990}, range);
-  check_backward_case<bidirectional_iterator<range_t::const_iterator> >(1000, {range.begin(), -990}, range);
-
-  return true;
-}
-} // namespace iterator_count_sentinel
-
-int main(int, char**) {
-  static_assert(iterator_count::test());
-  assert(iterator_count::test());
-
-  static_assert(iterator_sentinel::test());
-  assert(iterator_sentinel::test());
-
-  static_assert(iterator_count_sentinel::test());
-  assert(iterator_count_sentinel::test());
-
-  return 0;
-}

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count.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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::advance(it, n)
+
+#include <iterator>
+
+#include <array>
+#include <cassert>
+
+#include "test_standard_function.h"
+#include "test_iterators.h"
+
+static_assert(is_function_like<decltype(std::ranges::advance)>());
+
+using range_t = std::array<int, 10>;
+
+template <std::input_or_output_iterator I>
+constexpr void check_move_forward(std::ptrdiff_t const n) {
+  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  auto first = stride_counting_iterator(I(range.begin()));
+  std::ranges::advance(first, n);
+
+  assert(first.base().base() == range.begin() + n);
+  if constexpr (std::random_access_iterator<I>) {
+    assert(first.stride_count() == 0 || first.stride_count() == 1);
+    assert(first.stride_displacement() == 1);
+  } else {
+    assert(first.stride_count() == n);
+    assert(first.stride_displacement() == n);
+  }
+}
+
+template <std::bidirectional_iterator I>
+constexpr void check_move_backward(std::ptrdiff_t const n) {
+  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  auto first = stride_counting_iterator(I(range.begin() + n));
+  std::ranges::advance(first, -n);
+  assert(first.base().base() == range.begin());
+
+  if constexpr (std::random_access_iterator<I>) {
+    assert(first.stride_count() == 0 || first.stride_count() == 1);
+    assert(first.stride_displacement() == 1);
+  } else {
+    assert(first.stride_count() == n);
+    assert(first.stride_displacement() == -n);
+  }
+}
+
+constexpr bool test() {
+  check_move_forward<cpp17_input_iterator<range_t::const_iterator> >(1);
+  check_move_forward<cpp20_input_iterator<range_t::const_iterator> >(2);
+  check_move_forward<forward_iterator<range_t::const_iterator> >(3);
+  check_move_forward<bidirectional_iterator<range_t::const_iterator> >(4);
+  check_move_forward<random_access_iterator<range_t::const_iterator> >(5);
+  check_move_forward<contiguous_iterator<range_t::const_iterator> >(6);
+  check_move_forward<output_iterator<range_t::iterator> >(7);
+
+  check_move_backward<bidirectional_iterator<range_t::const_iterator> >(4);
+  check_move_backward<random_access_iterator<range_t::const_iterator> >(5);
+  check_move_backward<contiguous_iterator<range_t::const_iterator> >(6);
+
+  // Zero should be checked for each case and each overload
+  check_move_forward<cpp17_input_iterator<range_t::const_iterator> >(0);
+  check_move_forward<cpp20_input_iterator<range_t::const_iterator> >(0);
+  check_move_forward<forward_iterator<range_t::const_iterator> >(0);
+  check_move_forward<bidirectional_iterator<range_t::const_iterator> >(0);
+  check_move_forward<random_access_iterator<range_t::const_iterator> >(0);
+  check_move_forward<output_iterator<range_t::iterator> >(0);
+  check_move_backward<bidirectional_iterator<range_t::const_iterator> >(0);
+  check_move_backward<random_access_iterator<range_t::const_iterator> >(0);
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  assert(test());
+  return 0;
+}

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::advance(it, n, sent)
+
+#include <iterator>
+
+#include <array>
+#include <cassert>
+
+#include "test_standard_function.h"
+#include "test_iterators.h"
+
+static_assert(is_function_like<decltype(std::ranges::advance)>());
+
+using range_t = std::array<int, 10>;
+
+class distance_apriori_sentinel {
+public:
+  distance_apriori_sentinel() = default;
+  constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
+
+  constexpr bool operator==(std::input_or_output_iterator auto const&) const {
+    assert(false && "difference op should take precedence");
+    return false;
+  }
+
+  constexpr friend std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
+                                            distance_apriori_sentinel const y) {
+    return -y.count_;
+  }
+
+  constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
+                                            std::input_or_output_iterator auto const&) {
+    return x.count_;
+  }
+
+private:
+  std::ptrdiff_t count_ = 0;
+};
+
+struct expected_t {
+  range_t::const_iterator coordinate;
+  std::ptrdiff_t result;
+};
+
+template <std::input_or_output_iterator I>
+constexpr void check_forward_sized_sentinel(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
+  auto current = stride_counting_iterator(I(range.begin()));
+  auto const result = std::ranges::advance(current, n, distance_apriori_sentinel(range.size()));
+  assert(current.base().base() == expected.coordinate);
+  assert(result == expected.result);
+
+  if constexpr (std::random_access_iterator<I>) {
+    assert(current.stride_count() == 0 || current.stride_count() == 1);
+    assert(current.stride_displacement() == current.stride_count());
+  } else {
+    assert(current.stride_count() == (n - result));
+    assert(current.stride_displacement() == (n - result));
+  }
+}
+
+template <std::random_access_iterator I>
+constexpr void check_backward_sized_sentinel(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
+  auto current = stride_counting_iterator(I(range.end()));
+  auto const result = std::ranges::advance(current, -n, stride_counting_iterator(I(range.begin())));
+  assert(current.base().base() == expected.coordinate);
+  assert(result == expected.result);
+
+  assert(current.stride_count() == 0 || current.stride_count() == 1);
+  assert(current.stride_displacement() == current.stride_count());
+}
+
+template <std::input_or_output_iterator I>
+constexpr void check_forward(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
+  auto current = stride_counting_iterator(I(range.begin()));
+  auto const result = std::ranges::advance(current, n, sentinel_wrapper(I(range.end())));
+  assert(current.base().base() == expected.coordinate);
+  assert(result == expected.result);
+  assert(current.stride_count() == n - result);
+}
+
+template <std::bidirectional_iterator I>
+constexpr void check_backward(std::ptrdiff_t const n, expected_t const expected, range_t& range) {
+  auto current = stride_counting_iterator(I(range.end()));
+  auto const result = std::ranges::advance(current, -n, stride_counting_iterator(I(range.begin())));
+  assert(current.base().base() == expected.coordinate);
+  assert(result == expected.result);
+  assert(current.stride_count() == n + result);
+  assert(current.stride_count() == -current.stride_displacement());
+}
+
+constexpr bool test() {
+  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  check_forward_sized_sentinel<cpp17_input_iterator<range_t::const_iterator> >(1, {range.begin() + 1, 0}, range);
+  // cpp20_input_iterator not copyable, so is omitted
+  check_forward_sized_sentinel<forward_iterator<range_t::const_iterator> >(3, {range.begin() + 3, 0}, range);
+  check_forward_sized_sentinel<bidirectional_iterator<range_t::const_iterator> >(4, {range.begin() + 4, 0}, range);
+  check_forward_sized_sentinel<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0}, range);
+  check_forward_sized_sentinel<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 6, 0}, range);
+
+  // bidirectional_iterator omitted because the `n < 0` case requires `same_as<I, S>`
+  check_backward_sized_sentinel<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0}, range);
+  check_backward_sized_sentinel<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 4, 0}, range);
+
+  // distance == range.size()
+  check_forward_sized_sentinel<forward_iterator<range_t::const_iterator> >(10, {range.end(), 0}, range);
+  check_backward_sized_sentinel<random_access_iterator<range_t::const_iterator> >(10, {range.begin(), 0}, range);
+
+  // distance > range.size()
+  check_forward_sized_sentinel<forward_iterator<range_t::const_iterator> >(1000, {range.end(), 990}, range);
+  check_backward_sized_sentinel<random_access_iterator<range_t::const_iterator> >(1000, {range.begin(), -990}, range);
+
+  check_forward<cpp17_input_iterator<range_t::const_iterator> >(1, {range.begin() + 1, 0}, range);
+  check_forward<forward_iterator<range_t::const_iterator> >(3, {range.begin() + 3, 0}, range);
+  check_forward<bidirectional_iterator<range_t::const_iterator> >(4, {range.begin() + 4, 0}, range);
+  check_forward<random_access_iterator<range_t::const_iterator> >(5, {range.begin() + 5, 0}, range);
+  check_forward<contiguous_iterator<range_t::const_iterator> >(6, {range.begin() + 6, 0}, range);
+  check_backward<bidirectional_iterator<range_t::const_iterator> >(8, {range.begin() + 2, 0}, range);
+
+  // distance == range.size()
+  check_forward<forward_iterator<range_t::const_iterator> >(10, {range.end(), 0}, range);
+  check_backward<bidirectional_iterator<range_t::const_iterator> >(10, {range.begin(), 0}, range);
+
+  // distance > range.size()
+  check_forward<forward_iterator<range_t::const_iterator> >(1000, {range.end(), 990}, range);
+  check_backward<bidirectional_iterator<range_t::const_iterator> >(1000, {range.begin(), -990}, range);
+
+  return true;
+}
+
+int main(int, char**) {
+  static_assert(test());
+  assert(test());
+  return 0;
+}

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next
+// ranges::advance(it, sent)
 
 #include <iterator>
 
 #include <array>
 #include <cassert>
 
-#include "check_round_trip.h"
+#include "test_standard_function.h"
 #include "test_iterators.h"
 
+static_assert(is_function_like<decltype(std::ranges::advance)>());
+
 using range_t = std::array<int, 10>;
 
 class distance_apriori_sentinel {
 public:
   distance_apriori_sentinel() = default;
   constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
 
   constexpr bool operator==(std::input_or_output_iterator auto const&) const {
constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
                                             std::input_or_output_iterator auto const&) {
     return x.count_;
   }
 
 private:
   std::ptrdiff_t count_ = 0;
 };
 
-template <std::input_or_output_iterator I>
+template <std::input_or_output_iterator I, std::sentinel_for<I> S = I>
 constexpr void check_assignable_case(std::ptrdiff_t const n) {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto result =
-      std::ranges::next(stride_counting_iterator(I(range.begin())), stride_counting_iterator(I(range.begin() + n)));
-  assert(result.base().base() == range.begin() + n);
-  assert(result.stride_count() == 0); // always zero, so don't use `check_round_trip`
+  auto first = stride_counting_iterator(I(range.begin()));
+  std::ranges::advance(first, stride_counting_iterator(S(I(range.begin() + n))));
+  assert(first.base().base() == range.begin() + n);
+  assert(first.stride_count() == 0); // because we got here by assigning from last, not by incrementing
 }
 
 template <std::input_or_output_iterator I>
 constexpr void check_sized_sentinel_case(std::ptrdiff_t const n) {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto result = std::ranges::next(stride_counting_iterator(I(range.begin())), distance_apriori_sentinel(n));
-  assert(std::move(result).base().base() == range.begin() + n);
-  check_round_trip(result, n);
+  auto first = stride_counting_iterator(I(range.begin()));
+  std::ranges::advance(first, distance_apriori_sentinel(n));
+
+  assert(first.base().base() == range.begin() + n);
+  if constexpr (std::random_access_iterator<I>) {
+    assert(first.stride_count() == 1);
+    assert(first.stride_displacement() == 1);
+  } else {
+    assert(first.stride_count() == n);
+    assert(first.stride_displacement() == n);
+  }
 }
 
 template <std::input_or_output_iterator I>
 constexpr void check_sentinel_case(std::ptrdiff_t const n) {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  auto first = stride_counting_iterator(I(range.begin()));
   auto const last = I(range.begin() + n);
-  auto result = std::ranges::next(stride_counting_iterator(I(range.begin())), sentinel_wrapper(last));
-  assert(std::move(result).base() == last);
-  assert(result.stride_count() == n); // always `n`, so don't use `check_round_trip`
+  std::ranges::advance(first, sentinel_wrapper(last));
+  assert(first.base() == last);
+  assert(first.stride_count() == n);
 }
 
-constexpr bool check_iterator_sentinel() {
+constexpr bool test() {
   check_assignable_case<cpp17_input_iterator<range_t::const_iterator> >(1);
   check_assignable_case<forward_iterator<range_t::const_iterator> >(3);
   check_assignable_case<bidirectional_iterator<range_t::const_iterator> >(4);
   check_assignable_case<random_access_iterator<range_t::const_iterator> >(5);
   check_assignable_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_assignable_case<output_iterator<range_t::iterator> >(7);
 
   check_sized_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(7);
   check_sized_sentinel_case<cpp20_input_iterator<range_t::const_iterator> >(6);
   check_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(5);
   check_sized_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
   check_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(3);
   check_sized_sentinel_case<contiguous_iterator<range_t::const_iterator> >(2);
-  check_sized_sentinel_case<output_iterator<range_t::iterator> >(1);
 
   check_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(1);
   // cpp20_input_iterator not copyable, so is omitted
   check_sentinel_case<forward_iterator<range_t::const_iterator> >(3);
   check_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
   check_sentinel_case<random_access_iterator<range_t::const_iterator> >(5);
   check_sentinel_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_sentinel_case<output_iterator<range_t::iterator> >(7);
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_sentinel());
-  check_iterator_sentinel();
+  static_assert(test());
+  assert(test());
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/check_round_trip.h

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef LIBCXX_TEST_CHECK_ROUND_TRIP_H
-#define LIBCXX_TEST_CHECK_ROUND_TRIP_H
-
-#include "test_iterators.h"
-
-template <std::input_or_output_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  auto const distance = n < 0 ? -n : n;
-  assert(i.stride_count() == distance);
-  assert(i.stride_displacement() == n);
-}
-
-template <std::random_access_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  assert(i.stride_count() <= 1);
-  assert(i.stride_displacement() == n < 0 ? -1 : 1);
-}
-
-template <std::input_or_output_iterator I>
-constexpr bool operator==(output_iterator<I> const& x, output_iterator<I> const& y) {
-  return x.base() == y.base();
-}
-
-#endif // LIBCXX_TEST_CHECK_ROUND_TRIP_H

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/constraints.compile.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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::next
+// Make sure we're SFINAE-friendly when the template argument constraints are not met.
+
+#include <iterator>
+
+#include <cstddef>
+#include <memory>
+#include <utility>
+
+template <class ...Args>
+concept has_ranges_next = requires (Args ...args) {
+  { std::ranges::next(std::forward<Args>(args)...) };
+};
+
+using It = std::unique_ptr<int>;
+static_assert(!has_ranges_next<It>);
+static_assert(!has_ranges_next<It, std::ptrdiff_t>);
+static_assert(!has_ranges_next<It, It>);
+static_assert(!has_ranges_next<It, std::ptrdiff_t, It>);
+
+// Test the test
+static_assert(has_ranges_next<int*, std::ptrdiff_t, int*>);

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/constraints.verify.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
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: gcc-10
-
-// ranges::next
-
-#include <iterator>
-
-#include <memory>
-
-#include "test_iterators.h"
-
-void proper_constraints() {
-  auto p = std::unique_ptr<int>();
-  std::ranges::next(p);    // expected-error {{no matching function for call}}
-  std::ranges::next(p, p); // expected-error {{no matching function for call}}
-  std::ranges::next(p, 5); // expected-error {{no matching function for call}}
-  std::ranges::next(p, 7); // expected-error {{no matching function for call}}
-}

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next(first, n)
+// ranges::next(it)
 
 #include <iterator>
-
-#include <array>
 #include <cassert>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
-using range_t = std::array<int, 10>;
+template <class It>
+constexpr void check() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(&*std::ranges::next(It(&range[0])) == &range[1]);
+  assert(&*std::ranges::next(It(&range[1])) == &range[2]);
+  assert(&*std::ranges::next(It(&range[2])) == &range[3]);
+  assert(&*std::ranges::next(It(&range[3])) == &range[4]);
+  assert(&*std::ranges::next(It(&range[4])) == &range[5]);
+  assert(&*std::ranges::next(It(&range[5])) == &range[6]);
+}
 
-constexpr bool check_iterator() {
-  constexpr auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  assert(std::ranges::next(cpp17_input_iterator(&range[0])) == cpp17_input_iterator(&range[1]));
-  assert(std::ranges::next(cpp20_input_iterator(&range[1])).base() == &range[2]);
-  assert(std::ranges::next(forward_iterator(&range[2])) == forward_iterator(&range[3]));
-  assert(std::ranges::next(bidirectional_iterator(&range[3])) == bidirectional_iterator(&range[4]));
-  assert(std::ranges::next(random_access_iterator(&range[4])) == random_access_iterator(&range[5]));
-  assert(std::ranges::next(contiguous_iterator(&range[5])) == contiguous_iterator(&range[6]));
-  assert(std::ranges::next(output_iterator(&range[6])).base() == &range[7]);
+constexpr bool test() {
+  check<cpp17_input_iterator<int*>>();
+  check<cpp20_input_iterator<int*>>();
+  check<forward_iterator<int*>>();
+  check<bidirectional_iterator<int*>>();
+  check<random_access_iterator<int*>>();
+  check<contiguous_iterator<int*>>();
+  check<output_iterator<int*>>();
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator());
-  check_iterator();
+  static_assert(test());
+  test();
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_count.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next(first, n)
+// ranges::next(it, n)
 
 #include <iterator>
 
-#include <array>
 #include <cassert>
+#include <utility>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
-using range_t = std::array<int, 10>;
-
 template <std::input_or_output_iterator I>
-constexpr void iterator_count_impl(I first, std::ptrdiff_t const n, range_t::const_iterator const expected) {
-  auto result = std::ranges::next(stride_counting_iterator(std::move(first)), n);
-  assert(std::move(result).base().base() == expected);
-  check_round_trip(result, n);
+constexpr void check_steps(I it, std::ptrdiff_t n, int const* expected) {
+  {
+    auto result = std::ranges::next(std::move(it), n);
+    assert(&*result == expected);
   }
-
-constexpr bool check_iterator_count() {
-  constexpr auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-
-  iterator_count_impl(cpp17_input_iterator(&range[0]), 1, &range[1]);
-  iterator_count_impl(cpp20_input_iterator(&range[6]), 2, &range[8]);
-  iterator_count_impl(forward_iterator(&range[0]), 3, &range[3]);
-  iterator_count_impl(bidirectional_iterator(&range[2]), 6, &range[8]);
-  iterator_count_impl(random_access_iterator(&range[3]), 4, &range[7]);
-  iterator_count_impl(contiguous_iterator(&range[0]), 5, &range[5]);
-  iterator_count_impl(output_iterator(&range[0]), 6, &range[6]);
-
-  iterator_count_impl(cpp17_input_iterator(&range[0]), 0, &range[0]);
-  iterator_count_impl(cpp20_input_iterator(&range[6]), 0, &range[6]);
-  iterator_count_impl(forward_iterator(&range[0]), 0, &range[0]);
-  iterator_count_impl(bidirectional_iterator(&range[2]), 0, &range[2]);
-  iterator_count_impl(random_access_iterator(&range[3]), 0, &range[3]);
-  iterator_count_impl(contiguous_iterator(&range[0]), 0, &range[0]);
-  iterator_count_impl(output_iterator(&range[0]), 0, &range[0]);
-
-  iterator_count_impl(bidirectional_iterator(&range[8]), -5, &range[3]);
-  iterator_count_impl(random_access_iterator(&range[6]), -3, &range[3]);
-  iterator_count_impl(contiguous_iterator(&range[4]), -1, &range[3]);
+
+  // Count the number of operations
+  {
+    stride_counting_iterator strided_it(std::move(it));
+    auto result = std::ranges::next(std::move(strided_it), n);
+    assert(&*result == expected);
+    if constexpr (std::random_access_iterator<I>) {
+      assert(result.stride_count() == 1); // uses += exactly once
+      assert(result.stride_displacement() == 1);
+    } else {
+      auto const abs_n = n < 0 ? -n : n;
+      assert(result.stride_count() == abs_n);
+      assert(result.stride_displacement() == n);
+    }
+  }
+}
+
+constexpr bool test() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  check_steps(cpp17_input_iterator(&range[0]), 1, &range[1]);
+  check_steps(cpp20_input_iterator(&range[6]), 2, &range[8]);
+  check_steps(forward_iterator(&range[0]), 3, &range[3]);
+  check_steps(bidirectional_iterator(&range[2]), 6, &range[8]);
+  check_steps(random_access_iterator(&range[3]), 4, &range[7]);
+  check_steps(contiguous_iterator(&range[0]), 5, &range[5]);
+  check_steps(output_iterator(&range[0]), 6, &range[6]);
+
+  check_steps(cpp17_input_iterator(&range[0]), 0, &range[0]);
+  check_steps(cpp20_input_iterator(&range[6]), 0, &range[6]);
+  check_steps(forward_iterator(&range[0]), 0, &range[0]);
+  check_steps(bidirectional_iterator(&range[2]), 0, &range[2]);
+  check_steps(random_access_iterator(&range[3]), 0, &range[3]);
+  check_steps(contiguous_iterator(&range[0]), 0, &range[0]);
+  check_steps(output_iterator(&range[0]), 0, &range[0]);
+
+  check_steps(bidirectional_iterator(&range[8]), -5, &range[3]);
+  check_steps(random_access_iterator(&range[6]), -3, &range[3]);
+  check_steps(contiguous_iterator(&range[4]), -1, &range[3]);
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_count());
-  check_iterator_count();
+  static_assert(test());
+  test();
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_count_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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next
+// ranges::next(it, n, bound)
 
 #include <iterator>
-
-#include <array>
 #include <cassert>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
 template <std::input_or_output_iterator I>
-constexpr void check_iterator_count_sentinel_impl(I first, std::ptrdiff_t const steps, I const last) {
-  auto result = std::ranges::next(stride_counting_iterator(first), steps, stride_counting_iterator(last));
+constexpr void check(I it, std::ptrdiff_t n, I last) {
+  {
+    auto result = std::ranges::next(it, n, last);
     assert(result == last);
-  check_round_trip(result, steps);
   }
 
-constexpr bool check_iterator_count_sentinel() {
-  constexpr auto range = std::array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  check_iterator_count_sentinel_impl(cpp17_input_iterator(&range[0]), 1, cpp17_input_iterator(&range[1]));
-  check_iterator_count_sentinel_impl(forward_iterator(&range[0]), 2, forward_iterator(&range[2]));
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[2]), 6, bidirectional_iterator(&range[8]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[3]), 2, random_access_iterator(&range[5]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[0]), 5, contiguous_iterator(&range[5]));
-  check_iterator_count_sentinel_impl(output_iterator(&range[3]), 2, output_iterator(&range[5]));
-
-  check_iterator_count_sentinel_impl(cpp17_input_iterator(&range[0]), 0, cpp17_input_iterator(&range[0]));
-  check_iterator_count_sentinel_impl(forward_iterator(&range[0]), 0, forward_iterator(&range[0]));
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[2]), 0, bidirectional_iterator(&range[2]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[3]), 0, random_access_iterator(&range[3]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[0]), 0, contiguous_iterator(&range[0]));
-  check_iterator_count_sentinel_impl(output_iterator(&range[3]), 0, output_iterator(&range[3]));
-
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[6]), -1, bidirectional_iterator(&range[5]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[7]), -2, random_access_iterator(&range[5]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[8]), -3, contiguous_iterator(&range[5]));
+  // Count the number of operations
+  {
+    stride_counting_iterator strided_it(it), strided_last(last);
+    auto result = std::ranges::next(strided_it, n, strided_last);
+    assert(result == strided_last);
+    if constexpr (std::random_access_iterator<I>) {
+      if (n == 0 || n >= (last - it)) {
+        assert(result.stride_count() == 0); // uses the assign-from-sentinel codepath
+      } else {
+        assert(result.stride_count() == 1); // uses += exactly once
+      }
+    } else {
+      auto const abs_n = n < 0 ? -n : n;
+      assert(result.stride_count() == abs_n);
+      assert(result.stride_displacement() == n);
+    }
+  }
+}
+
+constexpr bool test() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  check(cpp17_input_iterator(&range[0]), 1, cpp17_input_iterator(&range[1]));
+  check(forward_iterator(&range[0]), 2, forward_iterator(&range[2]));
+  check(bidirectional_iterator(&range[2]), 6, bidirectional_iterator(&range[8]));
+  check(random_access_iterator(&range[3]), 2, random_access_iterator(&range[5]));
+  check(contiguous_iterator(&range[0]), 5, contiguous_iterator(&range[5]));
+
+  check(cpp17_input_iterator(&range[0]), 0, cpp17_input_iterator(&range[0]));
+  check(forward_iterator(&range[0]), 0, forward_iterator(&range[0]));
+  check(bidirectional_iterator(&range[2]), 0, bidirectional_iterator(&range[2]));
+  check(random_access_iterator(&range[3]), 0, random_access_iterator(&range[3]));
+  check(contiguous_iterator(&range[0]), 0, contiguous_iterator(&range[0]));
+
+  check(bidirectional_iterator(&range[6]), -1, bidirectional_iterator(&range[5]));
+  check(random_access_iterator(&range[7]), -2, random_access_iterator(&range[5]));
+  check(contiguous_iterator(&range[8]), -3, contiguous_iterator(&range[5]));
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_count_sentinel());
-  assert(check_iterator_count_sentinel());
+  static_assert(test());
+  assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next
+// ranges::next(it, bound)
 
 #include <iterator>
 
 #include <array>
 #include <cassert>
+#include <utility>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
 using range_t = std::array<int, 10>;
 
 class distance_apriori_sentinel {
 public:
   distance_apriori_sentinel() = default;
   constexpr explicit distance_apriori_sentinel(std::ptrdiff_t const count) : count_(count) {}
constexpr friend std::ptrdiff_t operator-(distance_apriori_sentinel const x,
                                             std::input_or_output_iterator auto const&) {
     return x.count_;
   }
 
 private:
   std::ptrdiff_t count_ = 0;
 };
 
 template <std::input_or_output_iterator I>
-constexpr void check_assignable_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto result =
-      std::ranges::next(stride_counting_iterator(I(range.begin())), stride_counting_iterator(I(range.begin() + n)));
-  assert(result.base().base() == range.begin() + n);
-  assert(result.stride_count() == 0); // always zero, so don't use `check_round_trip`
+constexpr void check_assignable(I it, I last, int const* expected) {
+  {
+    auto result = std::ranges::next(std::move(it), std::move(last));
+    assert(&*result == expected);
+  }
+
+  // Count operations
+  {
+    auto strided_it = stride_counting_iterator(std::move(it));
+    auto strided_last = stride_counting_iterator(std::move(last));
+    auto result = std::ranges::next(std::move(strided_it), std::move(strided_last));
+    assert(&*result == expected);
+    assert(result.stride_count() == 0); // because we got here by assigning from last, not by incrementing
+  }
 }
 
 template <std::input_or_output_iterator I>
-constexpr void check_sized_sentinel_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto result = std::ranges::next(stride_counting_iterator(I(range.begin())), distance_apriori_sentinel(n));
-  assert(std::move(result).base().base() == range.begin() + n);
-  check_round_trip(result, n);
+constexpr void check_sized_sentinel(I it, I last, int const* expected) {
+  auto n = (last.base() - it.base());
+
+  {
+    auto sent = distance_apriori_sentinel(n);
+    auto result = std::ranges::next(std::move(it), sent);
+    assert(&*result == expected);
+  }
+
+  // Count operations
+  {
+    auto strided_it = stride_counting_iterator(std::move(it));
+    auto sent = distance_apriori_sentinel(n);
+    auto result = std::ranges::next(std::move(strided_it), sent);
+    assert(&*result == expected);
+
+    if constexpr (std::random_access_iterator<I>) {
+      assert(result.stride_count() == 1); // should have used exactly one +=
+      assert(result.stride_displacement() == 1);
+    } else {
+      assert(result.stride_count() == n);
+      assert(result.stride_displacement() == n);
+    }
+  }
 }
 
 template <std::input_or_output_iterator I>
-constexpr void check_sentinel_case(std::ptrdiff_t const n) {
-  auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto const last = I(range.begin() + n);
-  auto result = std::ranges::next(stride_counting_iterator(I(range.begin())), sentinel_wrapper(last));
-  assert(std::move(result).base() == last);
-  assert(result.stride_count() == n); // always `n`, so don't use `check_round_trip`
-}
-
-constexpr bool check_iterator_sentinel() {
-  check_assignable_case<cpp17_input_iterator<range_t::const_iterator> >(1);
-  check_assignable_case<forward_iterator<range_t::const_iterator> >(3);
-  check_assignable_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_assignable_case<random_access_iterator<range_t::const_iterator> >(5);
-  check_assignable_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_assignable_case<output_iterator<range_t::iterator> >(7);
-
-  check_sized_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(7);
-  check_sized_sentinel_case<cpp20_input_iterator<range_t::const_iterator> >(6);
-  check_sized_sentinel_case<forward_iterator<range_t::const_iterator> >(5);
-  check_sized_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_sized_sentinel_case<random_access_iterator<range_t::const_iterator> >(3);
-  check_sized_sentinel_case<contiguous_iterator<range_t::const_iterator> >(2);
-  check_sized_sentinel_case<output_iterator<range_t::iterator> >(1);
+constexpr void check_sentinel(I it, I last, int const* expected) {
+  auto n = (last.base() - it.base());
+
+  {
+    auto sent = sentinel_wrapper(last);
+    auto result = std::ranges::next(std::move(it), sent);
+    assert(&*result == expected);
+  }
+
+  // Count operations
+  {
+    auto strided_it = stride_counting_iterator(it);
+    auto sent = sentinel_wrapper(stride_counting_iterator(last));
+    auto result = std::ranges::next(std::move(strided_it), sent);
+    assert(&*result == expected);
+    assert(result.stride_count() == n); // must have used ++ until it hit the sentinel
+  }
+}
+
+constexpr bool test() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  check_assignable(cpp17_input_iterator(&range[0]), cpp17_input_iterator(&range[2]), &range[2]);
+  check_assignable(forward_iterator(&range[0]), forward_iterator(&range[3]), &range[3]);
+  check_assignable(bidirectional_iterator(&range[0]), bidirectional_iterator(&range[4]), &range[4]);
+  check_assignable(random_access_iterator(&range[0]), random_access_iterator(&range[5]), &range[5]);
+  check_assignable(contiguous_iterator(&range[0]), contiguous_iterator(&range[6]), &range[6]);
+
+  check_sized_sentinel(cpp17_input_iterator(&range[0]), cpp17_input_iterator(&range[7]), &range[7]);
+  check_sized_sentinel(cpp20_input_iterator(&range[0]), cpp20_input_iterator(&range[6]), &range[6]);
+  check_sized_sentinel(forward_iterator(&range[0]), forward_iterator(&range[5]), &range[5]);
+  check_sized_sentinel(bidirectional_iterator(&range[0]), bidirectional_iterator(&range[4]), &range[4]);
+  check_sized_sentinel(random_access_iterator(&range[0]), random_access_iterator(&range[3]), &range[3]);
+  check_sized_sentinel(contiguous_iterator(&range[0]), contiguous_iterator(&range[2]), &range[2]);
 
-  check_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(1);
+  check_sentinel(cpp17_input_iterator(&range[0]), cpp17_input_iterator(&range[1]), &range[1]);
   // cpp20_input_iterator not copyable, so is omitted
-  check_sentinel_case<forward_iterator<range_t::const_iterator> >(3);
-  check_sentinel_case<bidirectional_iterator<range_t::const_iterator> >(4);
-  check_sentinel_case<random_access_iterator<range_t::const_iterator> >(5);
-  check_sentinel_case<contiguous_iterator<range_t::const_iterator> >(6);
-  check_sentinel_case<output_iterator<range_t::iterator> >(7);
+  check_sentinel(forward_iterator(&range[0]), forward_iterator(&range[3]), &range[3]);
+  check_sentinel(bidirectional_iterator(&range[0]), bidirectional_iterator(&range[4]), &range[4]);
+  check_sentinel(random_access_iterator(&range[0]), random_access_iterator(&range[5]), &range[5]);
+  check_sentinel(contiguous_iterator(&range[0]), contiguous_iterator(&range[6]), &range[6]);
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_sentinel());
-  check_iterator_sentinel();
+  static_assert(test());
+  test();
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/check_round_trip.h

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef LIBCXX_TEST_PREV_CHECK_ROUND_TRIP_H
-#define LIBCXX_TEST_PREV_CHECK_ROUND_TRIP_H
-
-#include "test_iterators.h"
-
-template <std::input_or_output_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  auto const distance = n < 0 ? -n : n;
-  assert(i.stride_count() == distance);
-  assert(i.stride_displacement() == -n);
-}
-
-template <std::random_access_iterator I>
-constexpr void check_round_trip(stride_counting_iterator<I> const& i, std::ptrdiff_t const n) {
-  assert(i.stride_count() <= 1);
-  assert(i.stride_displacement() == n < 0 ? -1 : 1);
-}
-
-#endif // LIBCXX_TEST_PREV_CHECK_ROUND_TRIP_H

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/constraints.compile.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
 // ranges::prev
+// Make sure we're SFINAE-friendly when the template argument constraints are not met.
 
 #include <iterator>
 
-#include <array>
-
+#include <cstddef>
+#include <utility>
 #include "test_iterators.h"
 
-void proper_constraints() {
-  auto a = std::array{0, 1, 2};
-  (void)std::ranges::prev(forward_iterator(a.begin()));    // expected-error {{no matching function for call}}
-  (void)std::ranges::prev(forward_iterator(a.begin()), 5); // expected-error {{no matching function for call}}
-  (void)std::ranges::prev(forward_iterator(a.begin()), 7); // expected-error {{no matching function for call}}
-}
+template <class ...Args>
+concept has_ranges_prev = requires (Args ...args) {
+  { std::ranges::prev(std::forward<Args>(args)...) };
+};
+
+using It = forward_iterator<int*>;
+static_assert(!has_ranges_prev<It>);
+static_assert(!has_ranges_prev<It, std::ptrdiff_t>);
+static_assert(!has_ranges_prev<It, std::ptrdiff_t, It>);
+
+// Test the test
+static_assert(has_ranges_prev<int*, std::ptrdiff_t, int*>);

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::prev(iterator)
+// ranges::prev(it)
 
 #include <iterator>
-
-#include <array>
 #include <cassert>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
-constexpr bool check_iterator() {
-  constexpr auto range = std::array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  assert(std::ranges::prev(bidirectional_iterator(&range[4])) == bidirectional_iterator(&range[3]));
-  assert(std::ranges::prev(random_access_iterator(&range[5])) == random_access_iterator(&range[4]));
-  assert(std::ranges::prev(contiguous_iterator(&range[6])) == contiguous_iterator(&range[5]));
+template <class It>
+constexpr void check() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  assert(std::ranges::prev(It(&range[4])) == It(&range[3]));
+  assert(std::ranges::prev(It(&range[5])) == It(&range[4]));
+  assert(std::ranges::prev(It(&range[6])) == It(&range[5]));
+}
+
+constexpr bool test() {
+  check<bidirectional_iterator<int*>>();
+  check<random_access_iterator<int*>>();
+  check<contiguous_iterator<int*>>();
+  check<int*>();
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator());
-  check_iterator();
+  static_assert(test());
+  test();
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator_count.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::prev(iterator, count)
+// ranges::prev(it, n)
 
 #include <iterator>
-
-#include <array>
 #include <cassert>
+#include <utility>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
-using range_t = std::array<int, 10>;
-
 template <std::input_or_output_iterator I>
-constexpr void iterator_count_impl(I first, std::ptrdiff_t const n, range_t::const_iterator const expected) {
-  auto result = std::ranges::prev(stride_counting_iterator(std::move(first)), n);
-  assert(std::move(result).base().base() == expected);
-  check_round_trip(result, n);
+constexpr void check(I it, std::ptrdiff_t n, int const* expected) {
+  auto result = std::ranges::prev(stride_counting_iterator(std::move(it)), n);
+  assert(result.base().base() == expected);
+
+  if constexpr (std::random_access_iterator<I>) {
+    assert(result.stride_count() <= 1);
+    // we can't say anything about the stride displacement, cause we could be using -= or +=.
+  } else {
+    auto const distance = n < 0 ? -n : n;
+    assert(result.stride_count() == distance);
+    assert(result.stride_displacement() == -n);
   }
+}
+
+constexpr bool test() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
-constexpr bool check_iterator_count() {
-  constexpr auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  iterator_count_impl(bidirectional_iterator(&range[8]), 6, &range[2]);
-  iterator_count_impl(random_access_iterator(&range[7]), 4, &range[3]);
-  iterator_count_impl(contiguous_iterator(&range[5]), 5, &range[0]);
-
-  iterator_count_impl(bidirectional_iterator(&range[2]), 0, &range[2]);
-  iterator_count_impl(random_access_iterator(&range[3]), 0, &range[3]);
-  iterator_count_impl(contiguous_iterator(&range[0]), 0, &range[0]);
-
-  iterator_count_impl(bidirectional_iterator(&range[3]), -5, &range[8]);
-  iterator_count_impl(random_access_iterator(&range[3]), -3, &range[6]);
-  iterator_count_impl(contiguous_iterator(&range[3]), -1, &range[4]);
+  check(bidirectional_iterator(&range[8]), 6, &range[2]);
+  check(random_access_iterator(&range[7]), 4, &range[3]);
+  check(contiguous_iterator(&range[5]), 5, &range[0]);
+
+  check(bidirectional_iterator(&range[2]), 0, &range[2]);
+  check(random_access_iterator(&range[3]), 0, &range[3]);
+  check(contiguous_iterator(&range[0]), 0, &range[0]);
+
+  check(bidirectional_iterator(&range[3]), -5, &range[8]);
+  check(random_access_iterator(&range[3]), -3, &range[6]);
+  check(contiguous_iterator(&range[3]), -1, &range[4]);
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_count());
-  check_iterator_count();
+  static_assert(test());
+  test();
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/iterator_count_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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::prev(iterator, count, sentinel)
+// ranges::prev(it, n, bound)
 
 #include <iterator>
-
-#include <array>
 #include <cassert>
 
-#include "check_round_trip.h"
 #include "test_iterators.h"
 
-template <std::input_or_output_iterator I>
-constexpr void check_iterator_count_sentinel_impl(I first, std::ptrdiff_t const steps, I const last) {
-  auto result = std::ranges::prev(stride_counting_iterator(first), steps, stride_counting_iterator(last));
+template <std::bidirectional_iterator I>
+constexpr void check(I it, std::ptrdiff_t n, I last) {
+  auto abs = [](auto x) { return x < 0 ? -x : x; };
+
+  {
+    auto result = std::ranges::prev(it, n, last);
     assert(result == last);
-  check_round_trip(result, steps);
   }
 
-constexpr bool check_iterator_count_sentinel() {
-  constexpr auto range = std::array{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[8]), 6, bidirectional_iterator(&range[2]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[5]), 2, random_access_iterator(&range[3]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[5]), 5, contiguous_iterator(&range[0]));
-
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[2]), 0, bidirectional_iterator(&range[2]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[3]), 0, random_access_iterator(&range[3]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[0]), 0, contiguous_iterator(&range[0]));
-
-  check_iterator_count_sentinel_impl(bidirectional_iterator(&range[5]), -1, bidirectional_iterator(&range[6]));
-  check_iterator_count_sentinel_impl(random_access_iterator(&range[5]), -2, random_access_iterator(&range[7]));
-  check_iterator_count_sentinel_impl(contiguous_iterator(&range[5]), -3, contiguous_iterator(&range[8]));
+  // Count the number of operations
+  {
+    stride_counting_iterator strided_it(it), strided_last(last);
+    auto result = std::ranges::prev(strided_it, n, strided_last);
+    assert(result == strided_last);
+    if constexpr (std::random_access_iterator<I>) {
+      if (n == 0 || abs(n) >= abs(last - it)) {
+        assert(result.stride_count() == 0); // uses the assign-from-sentinel codepath
+      } else {
+        assert(result.stride_count() == 1); // uses += exactly once
+      }
+    } else {
+      assert(result.stride_count() == abs(n));
+      assert(result.stride_displacement() == -n);
+    }
+  }
+}
+
+constexpr bool test() {
+  int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  check(bidirectional_iterator(&range[8]), 6, bidirectional_iterator(&range[2]));
+  check(random_access_iterator(&range[5]), 2, random_access_iterator(&range[3]));
+  check(contiguous_iterator(&range[5]), 5, contiguous_iterator(&range[0]));
+
+  check(bidirectional_iterator(&range[2]), 0, bidirectional_iterator(&range[2]));
+  check(random_access_iterator(&range[3]), 0, random_access_iterator(&range[3]));
+  check(contiguous_iterator(&range[0]), 0, contiguous_iterator(&range[0]));
+
+  check(bidirectional_iterator(&range[5]), -1, bidirectional_iterator(&range[6]));
+  check(random_access_iterator(&range[5]), -2, random_access_iterator(&range[7]));
+  check(contiguous_iterator(&range[5]), -3, contiguous_iterator(&range[8]));
   return true;
 }
 
 int main(int, char**) {
-  static_assert(check_iterator_count_sentinel());
-  assert(check_iterator_count_sentinel());
+  static_assert(test());
+  assert(test());
 
   return 0;
 }

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.prev/special_function.compile.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
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// ranges::next
+// ranges::prev
 
 #include <iterator>
 
 #include "test_iterators.h"
 #include "test_standard_function.h"
 
 static_assert(is_function_like<decltype(std::ranges::prev)>());
 

libcxx/test/support/test_iterators.h

public:
   using value_type = typename iter_value_or_void<I>::type;
   using difference_type = std::iter_difference_t<I>;
   using iterator_concept = iterator_concept_t<I>;
 
   stride_counting_iterator() = default;
 
   constexpr explicit stride_counting_iterator(I current) : base_(std::move(current)) {}
 
-  [[nodiscard]] constexpr I const& base() const& requires std::copyable<I> { return base_; }
+  [[nodiscard]] constexpr I const& base() const& { return base_; }
 
   [[nodiscard]] constexpr I base() && { return std::move(base_); }
 
   constexpr difference_type stride_count() const { return stride_count_; }
 
   constexpr difference_type stride_displacement() const { return stride_displacement_; }
 
   constexpr decltype(auto) operator*() const { return *base_; }
 
   constexpr decltype(auto) operator[](difference_type const n) const { return base_[n]; }