[libc++] Remove incorrect default constructor in cpp17_input_iterator

[ldionne]

Summary

AFAICT, Cpp17InputIterators are not required to be default constructible,
so our archetype should not be default constructible. Removing that
constructor has a ripple effect on a couple of tests that were making
incorrect assumptions. Notably:

• Some tests were using cpp17_input_iterator to form a common_range using test_common_range. That is not valid, because a cpp17_input_iterator is not a sentinel for itself after the change (it's not semiregular anymore).

• Some tests were using cpp17_input_iterator as a sentinel for itself (basically the same problem as above), which is invalid for the same reason.

• This change required modifying sentinel_wrapper so that it can work with non-default-constructible iterators like cpp17_input_iterator. Otherwise, there would be no way to test most utilities on those iterators.

[ldionne]

Rebase onto main and fix additional tests. Everything should pass now.

[• Quuxplusone]

FYI I'm still not sold on the benefits of the stated goal (removing default-constructibility from cpp17_input_iterator), but I like (almost) all the drive-by cleanups that fell out of this.

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.addressof.compile.pass.cpp

22

Can you change this to cpp17_input_iterator<operator_hijacker*> i at the same time? I think that's what was intended here: we just need a non-forward iterator whose value_type is operator_hijacker, and the rest doesn't matter. (Honestly I don't see why it needs to be a non-forward iterator — operator_hijacker *i might do just as well — but I dunno.)
@Mordante, who I believe wrote this code originally: does that sound right to you?

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

50–51

Given that range_t is hard-coded to array<int,10> on line 22, do you have the appetite to change this to a simple

int a[10] = {};

and then replace range.begin() with a throughout lines 54–65? Since you're rewriting this test (for the better) anyway...

54–55

FWIW, here I'd prefer to see

auto first = It(range.begin());  // or It(a) after the refactoring above
auto last = Sent(It(range.begin() + n));  // or Sent(It(a + n)) after the refactoring above

125–139

After the /range/a/ refactoring above, this becomes using It = int*; (unless the constness is important for some reason, and I don't think it is), at which point you don't really need the name It anymore.

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

50–64

(I note that all of these lines depend on CTAD, which is not thrilling. But that's a pre-existing issue. Just wanted to complain about it.)

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

62–77

I believe this change is wrong. IIUC your goal is to get some coverage for sentinels. I'm generally opposed to the current state of your rewrite only because it seems to hard-code the assumption that stride_counting_iterator<X> is necessarily a sentinel for stride_counting_iterator<Y>. I think it needs to use sentinel_wrapper instead. It should IMO look like

template <std::input_or_output_iterator It>
constexpr void check_assignable(It it, int *last) {
  {
    It result = std::ranges::next(std::move(it), It(last));
    assert(base(result) == last);
  }

  // Count operations
  {
    auto strided_it = stride_counting_iterator<It>(std::move(it));
    auto strided_last = sentinel_wrapper(stride_counting_iterator<It>(It(last)));  // CTAD alert!
    auto result = std::ranges::next(std::move(strided_it), std::move(strided_last));
    assert(result.stride_count() == 0); // because we got here by assigning from last, not by incrementing
    assert(base(result.base()) == last);  // .base() on the strided_iterator, ADL base() on the test iterator itself
  }
}

except what is this test talking about, "assigning from last"? In general sentinels (e.g. sentinel_wrapper) cannot be assigned to their iterator types, only compared against them. It sounds like this test file needs an ad-hoc struct assignable_sentinel and also a struct assignable_sized_sentinel, both of which should trigger https://eel.is/c++draft/iterators#range.iter.op.advance-4.1 .

(I'm totally OK with marking this TODO and coming back to it in a later PR, since the bulk of this PR is a huge improvement.)

90

Might be moot if you take my advice above: Could this just be if constexpr (std::is_copyable_v<It>), instead of introducing bool Count? Or what is the thing physically preventing this codepath from working for cpp17_input_iterator?

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

77

But this isn't a test for the default constructor — it's a test for the assignment operator. Input iterators must be assignable, right?
Perhaps change line 31 to std::move_iterator<It> move_ti(It(nullptr)); instead.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

23–25

Any appetite to make this

template<class T>
struct ForwardView : std::ranges::view_base {
    forward_iterator<T*> begin() const;
    sentinel_wrapper<forward_iterator<T*>> end() const;
};

while you're here? Ditto below. (If that's a bridge too far, then OK, forget it.)

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

43–49

Here I believe we're losing test coverage of std::ranges::common_range<R> where R happens to be a common range with input iterators. However, this test is also bad (pre-existing issue). Maybe drop a TODO comment here? test_common_range should go away, and this test should look more like

template<class It> struct Common { It begin(); It end(); };
template<class It, class Sent> struct NonCommon { It begin(); Sent end(); };

static_assert(std::ranges::common_range<Common<cpp17_input_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>>);
static_assert(std::ranges::common_range<Common<cpp20_input_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>>);
static_assert(std::ranges::common_range<Common<forward_iterator<int*>>>);
static_assert(std::ranges::common_range<NonCommon<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>>);
~~~
static_assert(std::ranges::common_range<Common<int*>>);
static_assert(std::ranges::common_range<NonCommon<int*, const int*>>);
static_assert(std::ranges::common_range<NonCommon<int*, sentinel_wrapper<int*>>>);
static_assert(std::ranges::common_range<NonCommon<int*, sized_sentinel<int*>>>);

(notice that this includes the subtly_not_common case as well)

[ldionne]

In D115806#3212758, @Quuxplusone wrote:

FYI I'm still not sold on the benefits of the stated goal (removing default-constructibility from cpp17_input_iterator), but I like (almost) all the drive-by cleanups that fell out of this.

Well, if cpp17_input_iterator is default constructible, then it is not an archetype for Cpp17InputIterator anymore. And being an archetype for Cpp17InputIterator is the very reason for that type's existence.

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.addressof.compile.pass.cpp

22

Yeah, I think that makes sense.

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

50–51

I suggest doing that in a separate PR and changing all the tests under range.iter.ops if we really want to do it. Otherwise, I'll just be introducing inconsistency with the neighboring tests.

54–55

What criteria do you use for determining auto vs classic variable declarations? Why are you fine with e.g. the stride_counting_iterator<It> declarations below but not with these?

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

77

You're right, that's entirely better since it doesn't force us to reduce test coverage.

[ldionne]

Apply most review comments.

[• Quuxplusone]

My comment in range.iter.ops.next/iterator_sentinel.pass.cpp is still unaddressed, but I'm also fine with a TODO comment there. Again, my goal there is that we should never instantiate any foo_iterator<T> where T is a non-iterator (sentinel) type.

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

50–51

Ping me when this lands and I'll volunteer to do it. :)

54–55

"What criteria do you use" — Largely random. Probably affected by "how hard is it for my eyes to pick out the name of the variable among all the other tokens" (so arguably It first( is more lost-in-the-woods than It> first( on line 62). Probably affected by "how much is it obvious whether the explicit-cast behavior is intentional or not," e.g. It first(range.begin()) could plausibly be a "typo" for It first = range.begin(), but stride_counting_iterator<It> first(It(range.begin())) is clearly not intended to be the same as stride_counting_iterator<It> first = It(range.begin()). Mostly affected by the phase of the moon. :)
In an ideal world I'd absolutely use = for all initializations, but that weighs against consistency with existing test code (where a lot of tests use parens-initialization), so when I comment inconsistently, you're not seeing inconsistency of my preference so much as inconsistency of my inclination to leave a nitty comment. :)

[ldionne]

Address remaining comments. I thought I had done everything for some reason, but didn't.

[ldionne]

Geez, I've been having issues with Phabricator. Submitting comments.

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

54–55

I've returned to auto x = Foo(...) because it's what's done elsewhere in this test.

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

62–77

Sorry, I forgot to address this comment. It should be addressed in the latest update.

90

This one can actually be removed entirely.

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

43–49

I actually went a bit further and refactored this whole thing some more. I'll update it, let me know if you want it in a separate review.

I don't think we're losing important coverage here by removing the check for common_range<Common<cpp17_input_iterator>>, since if someone wants to make a cpp17_input_iterator that's also a sentinel for itself, they have basically created a forward_iterator (that's not 100% accurate, but it's pretty close).

[• Quuxplusone]

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

64–67

(1, throughout) &*result would be better spelled base(result).

(2) Lines 50–53 now seem pointless, or at least unrelated to the "assignable" aspect of this function. Vice versa, lines 56–62 are checking that the assignment happens, but they're no longer checking the It-Sent case: they're checking only the It-It case.
Per my old comment below, I can't think of any good way to fix this except to introduce a new assignable_sentinel type in this file.

106–109

This could be simplified to

template <bool Count, class It>
constexpr void check_sentinel(It it, int n) {
  It last = It(base(it) + n);
  {
    auto sent = sentinel_wrapper<It>(last);
    It result = std::ranges::next(it, sent);
    assert(base(result) == base(last));
  }

and so on. This would vastly simplify the callers, I think, e.g.

check_sentinel<true,  forward_iterator<int*>>(      &range[0], &range[3], &range[3]);

becomes

check_sentinel<true>(forward_iterator<int*>(range), 3);

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

32

"There's no such thing as an archetype" alert! :) This comment is describing lack of test coverage, so it would be better worded as

// we no longer have a test iterator that is both input and default-constructible, so not testing that case

You could use something like test<std::istream_iterator<int>>(); here, to avoid losing test coverage, but that might require dragging in <istream> to get it to compile. Really I'm just carping about the excuse-making wording of the proposed comment. It's not like it's C++'s fault that we lost this coverage.

[ldionne]

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

64–67

Done both, but I will wait for adding a friend base() function to stride_counting_iterator because it breaks in weirds ways and this patch is already complicated enough. For now I'll be using it.base() instead of base(it) to unwrap the stride_counting_iterator.

106–109

Let's keep this refactoring for a subsequent patch, the same where I can remove range_t.

[ldionne]

Address review comments

[• Quuxplusone]

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

31

Argh, gross. I guess there's really no good way to make a type that says "I am assignable to this unrelated type." Making it implicitly-convertible is the best we can do. OK.

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.default.pass.cpp

32–35

Optional: leave a TODO comment here that we ought to get rid of these bogus operator== in a later patch.

[ldionne]

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.default.pass.cpp

32–35

I already have another patch in the works to rewrite that whole test.

[ldionne]

The CI failure seems like a flake due to the new (and slow) nodes we're using right now. Shipping this.

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.addressof.compile.pass.cpp

 // Validate whether the container can be copy-assigned with an ADL-hijacking operator&
 
 #include <vector>
 
 #include "test_macros.h"
 #include "operator_hijacker.h"
 #include "test_iterators.h"
 
-void test() {
+void test(cpp17_input_iterator<operator_hijacker*> i) {
   {
     std::vector<operator_hijacker> v;
-    cpp17_input_iterator<std::vector<operator_hijacker>::iterator> i;
     v.insert(v.end(), i, i);
   }
   {
     std::vector<operator_hijacker> v;
     v.insert(v.end(), v.begin(), v.end());
   }
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

#if TEST_STD_VER >= 11
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
 #endif
 
     {
         std::vector<adl::S> s;
-        s.insert(s.end(), cpp17_input_iterator<adl::S*>(), cpp17_input_iterator<adl::S*>());
+        s.insert(s.end(), cpp17_input_iterator<adl::S*>(nullptr), cpp17_input_iterator<adl::S*>(nullptr));
     }
 
   return 0;
 }

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

 // UNSUPPORTED: libcpp-no-concepts
 
 // ranges::advance(it, sent)
 
 #include <iterator>
 
 #include <array>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 
 using range_t = std::array<int, 10>;
 
 class distance_apriori_sentinel {
 public:
   distance_apriori_sentinel() = default;
friend constexpr 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 It, std::sentinel_for<It> Sent = It>
-constexpr void check_assignable_case(std::ptrdiff_t const n) {
+template <class It, class Sent = It>
+constexpr void check_assignable_case() {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(It(range.begin()));
-  std::ranges::advance(first, stride_counting_iterator(Sent(It(range.begin() + n))));
+
+  for (std::ptrdiff_t n = 0; n != 9; ++n) {
+    {
+      It first(range.begin());
+      Sent last(It(range.begin() + n));
+      std::ranges::advance(first, last);
+      assert(base(first) == range.begin() + n);
+    }
+
+    // Count operations
+    if constexpr (std::is_same_v<It, Sent>) {
+      stride_counting_iterator<It> first(It(range.begin()));
+      stride_counting_iterator<It> last(It(range.begin() + n));
+      std::ranges::advance(first, last);
       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 It>
-constexpr void check_sized_sentinel_case(std::ptrdiff_t const n) {
+template <class It>
+constexpr void check_sized_sentinel_case() {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(It(range.begin()));
-  std::ranges::advance(first, distance_apriori_sentinel(n));
+
+  for (std::ptrdiff_t n = 0; n != 9; ++n) {
+    {
+      It first(range.begin());
+      distance_apriori_sentinel last(n);
+      std::ranges::advance(first, last);
+      assert(base(first) == range.begin() + n);
+    }
+
+    // Count operations
+    {
+      stride_counting_iterator<It> first(It(range.begin()));
+      distance_apriori_sentinel last(n);
+      std::ranges::advance(first, last);
 
       assert(first.base().base() == range.begin() + n);
       if constexpr (std::random_access_iterator<It>) {
         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 It>
-constexpr void check_sentinel_case(std::ptrdiff_t const n) {
+template <class It>
+constexpr void check_sentinel_case() {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-  auto first = stride_counting_iterator(It(range.begin()));
-  auto const last = It(range.begin() + n);
-  std::ranges::advance(first, sentinel_wrapper(last));
+
+  for (std::ptrdiff_t n = 0; n != 9; ++n) {
+    {
+      It first(range.begin());
+      sentinel_wrapper<It> last(It(range.begin() + n));
+      std::ranges::advance(first, last);
+      assert(base(first) == range.begin() + n);
+    }
+
+    // Count operations
+    {
+      stride_counting_iterator<It> first(It(range.begin()));
+      sentinel_wrapper<It> last(It(range.begin() + n));
+      std::ranges::advance(first, last);
       assert(first.base() == last);
       assert(first.stride_count() == n);
     }
+  }
+}
 
 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_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);
+  using It = range_t::const_iterator;
+  check_assignable_case<cpp17_input_iterator<It>, sentinel_wrapper<cpp17_input_iterator<It>>>();
+  check_assignable_case<forward_iterator<It>>();
+  check_assignable_case<bidirectional_iterator<It>>();
+  check_assignable_case<random_access_iterator<It>>();
+  check_assignable_case<contiguous_iterator<It>>();
+
+  check_sized_sentinel_case<cpp17_input_iterator<It>>();
+  check_sized_sentinel_case<cpp20_input_iterator<It>>();
+  check_sized_sentinel_case<forward_iterator<It>>();
+  check_sized_sentinel_case<bidirectional_iterator<It>>();
+  check_sized_sentinel_case<random_access_iterator<It>>();
+  check_sized_sentinel_case<contiguous_iterator<It>>();
 
-  check_sentinel_case<cpp17_input_iterator<range_t::const_iterator> >(1);
+  check_sentinel_case<cpp17_input_iterator<It>>();
   // 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<forward_iterator<It>>();
+  check_sentinel_case<bidirectional_iterator<It>>();
+  check_sentinel_case<random_access_iterator<It>>();
+  check_sentinel_case<contiguous_iterator<It>>();
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(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
 
 // ranges::next(it, n, bound)
 
 #include <iterator>
 #include <cassert>
+#include <type_traits>
 
 #include "test_iterators.h"
 
-template <std::input_or_output_iterator It>
-constexpr void check(It it, std::ptrdiff_t n, It last) {
+template <class It, class Sent = It>
+constexpr void check(It it, std::ptrdiff_t n, Sent last) {
   {
     It result = std::ranges::next(it, n, last);
     assert(result == last);
   }
 
   // Count the number of operations
-  {
+  if constexpr (std::is_same_v<It, Sent>) {
     stride_counting_iterator<It> strided_it(it);
     stride_counting_iterator<It> strided_last(last);
     stride_counting_iterator<It> result = std::ranges::next(strided_it, n, strided_last);
     assert(result == strided_last);
     if constexpr (std::random_access_iterator<It>) {
       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 {
       std::ptrdiff_t 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(cpp17_input_iterator(&range[0]), 1, sentinel_wrapper(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(cpp17_input_iterator(&range[0]), 0, sentinel_wrapper(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**) {
   assert(test());
   static_assert(test());
   return 0;
 }

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

 #include <array>
 #include <cassert>
 #include <utility>
 
 #include "test_iterators.h"
 
 using range_t = std::array<int, 10>;
 
+// Sentinel type that can be assigned to an iterator. This is to test the case where
+// std::ranges::next uses assignment instead of successive increments below.
+template <class It>
+class assignable_sentinel {
+public:
+    explicit assignable_sentinel() = default;
+    constexpr explicit assignable_sentinel(const It& it) : base_(base(it)) {}
+    constexpr operator It() const { return It(base_); }
+    constexpr bool operator==(const It& other) const { return base_ == base(other); }
+    friend constexpr It base(const assignable_sentinel& s) { return It(s.base_); }
+private:
+    decltype(base(std::declval<It>())) base_;
+};
+
 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;
   }
 
   friend constexpr std::ptrdiff_t operator-(std::input_or_output_iterator auto const&,
                                             distance_apriori_sentinel const y) {
     return -y.count_;
   }
 
   friend constexpr 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 It>
-constexpr void check_assignable(It it, It last, int const* expected) {
+template <bool Count, typename It>
+constexpr void check_assignable(int* it, int* last, int const* expected) {
   {
-    It result = std::ranges::next(std::move(it), std::move(last));
-    assert(&*result == expected);
+    It result = std::ranges::next(It(it), assignable_sentinel(It(last)));
+    assert(base(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);
+  if constexpr (Count) {
+    auto strided_it = stride_counting_iterator(It(it));
+    auto strided_last = assignable_sentinel(stride_counting_iterator(It(last)));
+    stride_counting_iterator<It> result = std::ranges::next(std::move(strided_it), std::move(strided_last));
+    assert(base(result.base()) == expected);
     assert(result.stride_count() == 0); // because we got here by assigning from last, not by incrementing
   }
 }
 
-template <std::input_or_output_iterator It>
-constexpr void check_sized_sentinel(It it, It last, int const* expected) {
-  auto n = (last.base() - it.base());
+template <typename It>
+constexpr void check_sized_sentinel(int* it, int* last, int const* expected) {
+  auto n = (last - it);
 
   {
     auto sent = distance_apriori_sentinel(n);
-    auto result = std::ranges::next(std::move(it), sent);
-    assert(&*result == expected);
+    auto result = std::ranges::next(It(it), sent);
+    assert(base(result) == expected);
   }
 
   // Count operations
   {
-    auto strided_it = stride_counting_iterator(std::move(it));
+    auto strided_it = stride_counting_iterator(It(it));
     auto sent = distance_apriori_sentinel(n);
     auto result = std::ranges::next(std::move(strided_it), sent);
-    assert(&*result == expected);
+    assert(base(result.base()) == expected);
 
     if constexpr (std::random_access_iterator<It>) {
       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 It>
-constexpr void check_sentinel(It it, It last, int const* expected) {
-  auto n = (last.base() - it.base());
+template <bool Count, typename It>
+constexpr void check_sentinel(int* it, int* last, int const* expected) {
+  auto n = (last - it);
 
   {
-    auto sent = sentinel_wrapper(last);
-    It result = std::ranges::next(std::move(it), sent);
-    assert(&*result == expected);
+    auto sent = sentinel_wrapper(It(last));
+    It result = std::ranges::next(It(it), sent);
+    assert(base(result) == expected);
   }
 
   // Count operations
-  {
-    auto strided_it = stride_counting_iterator(it);
-    auto sent = sentinel_wrapper(stride_counting_iterator(last));
+  if constexpr (Count) {
+    auto strided_it = stride_counting_iterator(It(it));
+    auto sent = sentinel_wrapper(stride_counting_iterator(It(last)));
     stride_counting_iterator result = std::ranges::next(std::move(strided_it), sent);
-    assert(&*result == expected);
+    assert(base(result.base()) == 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_assignable<false, cpp17_input_iterator<int*>>(  &range[0], &range[2], &range[2]);
+  check_assignable<true,  forward_iterator<int*>>(      &range[0], &range[3], &range[3]);
+  check_assignable<true,  bidirectional_iterator<int*>>(&range[0], &range[4], &range[4]);
+  check_assignable<true,  random_access_iterator<int*>>(&range[0], &range[5], &range[5]);
+  check_assignable<true,  contiguous_iterator<int*>>(   &range[0], &range[6], &range[6]);
+
+  check_sized_sentinel<cpp17_input_iterator<int*>>(  &range[0], &range[7], &range[7]);
+  check_sized_sentinel<cpp20_input_iterator<int*>>(  &range[0], &range[6], &range[6]);
+  check_sized_sentinel<forward_iterator<int*>>(      &range[0], &range[5], &range[5]);
+  check_sized_sentinel<bidirectional_iterator<int*>>(&range[0], &range[4], &range[4]);
+  check_sized_sentinel<random_access_iterator<int*>>(&range[0], &range[3], &range[3]);
+  check_sized_sentinel<contiguous_iterator<int*>>(   &range[0], &range[2], &range[2]);
 
-  check_sentinel(cpp17_input_iterator(&range[0]), cpp17_input_iterator(&range[1]), &range[1]);
+  check_sentinel<false, cpp17_input_iterator<int*>>(  &range[0], &range[1], &range[1]);
   // cpp20_input_iterator not copyable, so is omitted
-  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]);
+  check_sentinel<true,  forward_iterator<int*>>(      &range[0], &range[3], &range[3]);
+  check_sentinel<true,  bidirectional_iterator<int*>>(&range[0], &range[4], &range[4]);
+  check_sentinel<true,  random_access_iterator<int*>>(&range[0], &range[5], &range[5]);
+  check_sentinel<true,  contiguous_iterator<int*>>(   &range[0], &range[6], &range[6]);
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/counted.iterator/ctor.default.pass.cpp

 // constexpr counted_iterator() requires default_initializable<I> = default;
 
 #include <iterator>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 constexpr bool test() {
-  static_assert( std::default_initializable<std::counted_iterator<cpp17_input_iterator<int*>>>);
-  static_assert(!std::default_initializable<std::counted_iterator<cpp20_input_iterator<int*>>>);
+  static_assert(!std::default_initializable<std::counted_iterator<cpp17_input_iterator<int*>>>);
+  static_assert( std::default_initializable<std::counted_iterator<forward_iterator<int*>>>);
 
-  std::counted_iterator<cpp17_input_iterator<int*>> iter;
-  assert(iter.base() == cpp17_input_iterator<int*>());
+  std::counted_iterator<forward_iterator<int*>> iter;
+  assert(iter.base() == forward_iterator<int*>());
   assert(iter.count() == 0);
 
   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

 test()
 {
     std::move_iterator<It> r;
     (void)r;
 }
 
 int main(int, char**)
 {
-    test<cpp17_input_iterator<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*>();
 
 #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=/move_iterator.pass.cpp

 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class It, class U>
 void
 test(U u)
 {
     const std::move_iterator<U> r2(u);
-    std::move_iterator<It> r1;
+    std::move_iterator<It> r1(It(nullptr));
     std::move_iterator<It>& rr = (r1 = r2);
     assert(r1.base() == u);
     assert(&rr == &r1);
 }
 
 struct Base {};
 struct Derived : Base {};
 
TEST_CONSTEXPR_CXX17 bool test_conv_assign()
     assert(move_ti.base().m_value == fi);
     return true;
 }
 
 int main(int, char**)
 {
     Derived d;
 
     test<cpp17_input_iterator<Base*> >(cpp17_input_iterator<Derived*>(&d));
     test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
     test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
     test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
     test_conv_assign();
 #if TEST_STD_VER > 14
     {
     using BaseIter    = std::move_iterator<const Base *>;

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/ctor.default.pass.cpp

 #include "test_macros.h"
 #include "../types.h"
 
 template<class T>
 struct DefaultCtorParent : std::ranges::view_base {
   T *ptr_;
   constexpr DefaultCtorParent(T *ptr) : ptr_(ptr) {}
 
-  constexpr cpp17_input_iterator<T *> begin() { return cpp17_input_iterator<T *>(ptr_); }
-  constexpr cpp17_input_iterator<const T *> begin() const { return cpp17_input_iterator<const T *>(ptr_); }
+  constexpr forward_iterator<T *> begin() { return forward_iterator<T *>(ptr_); }
+  constexpr forward_iterator<const T *> begin() const { return forward_iterator<const T *>(ptr_); }
   constexpr T *end() { return ptr_ + 4; }
   constexpr const T *end() const { return ptr_ + 4; }
 };
 
 template<class T>
-constexpr bool operator==(const cpp17_input_iterator<T*> &lhs, const T *rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(const forward_iterator<T*> &lhs, const T *rhs) { return lhs.base() == rhs; }
 template<class T>
-constexpr bool operator==(const T *lhs, const cpp17_input_iterator<T*> &rhs) { return rhs.base() == lhs; }
+constexpr bool operator==(const T *lhs, const forward_iterator<T*> &rhs) { return rhs.base() == lhs; }
 
 constexpr bool test() {
   using Base = DefaultCtorParent<ChildView>;
   // Note, only the outer iterator is default_initializable:
   static_assert( std::default_initializable<std::ranges::iterator_t<Base>>);
   static_assert(!std::default_initializable<std::ranges::iterator_t<std::ranges::range_reference_t<Base>>>);
 
   std::ranges::iterator_t<std::ranges::join_view<Base>> iter1;

libcxx/test/std/ranges/range.adaptors/range.join.view/iterator/member_types.compile.pass.cpp

 #include <ranges>
 
 #include "test_iterators.h"
 #include "test_macros.h"
 #include "../types.h"
 
 template<class T>
 struct ForwardView : std::ranges::view_base {
-  friend forward_iterator<T*> begin(ForwardView&) { return forward_iterator<T*>(nullptr); }
-  friend forward_iterator<T*> begin(ForwardView const&) { return forward_iterator<T*>(nullptr); }
-  friend forward_iterator<T*> end(ForwardView&) { return forward_iterator<T*>(nullptr); }
-  friend forward_iterator<T*> end(ForwardView const&) { return forward_iterator<T*>(nullptr); }
+  forward_iterator<T*> begin() const;
+  sentinel_wrapper<forward_iterator<T*>> end() const;
 };
 
 template<class T>
 struct InputView : std::ranges::view_base {
-  friend cpp17_input_iterator<T*> begin(InputView&) { return cpp17_input_iterator<T*>(nullptr); }
-  friend cpp17_input_iterator<T*> begin(InputView const&) { return cpp17_input_iterator<T*>(nullptr); }
-  friend cpp17_input_iterator<T*> end(InputView&) { return cpp17_input_iterator<T*>(nullptr); }
-  friend cpp17_input_iterator<T*> end(InputView const&) { return cpp17_input_iterator<T*>(nullptr); }
+  cpp17_input_iterator<T*> begin() const;
+  sentinel_wrapper<cpp17_input_iterator<T*>> end() const;
 };
 
 template<class T>
 concept HasIterCategory = requires { typename T::iterator_category; };
 
 void test() {
   {
     int buffer[4][4];

libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp

 #include "test_iterators.h"
 #include "test_range.h"
 
 
 
 static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
 static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
 static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<forward_iterator> >, forward_iterator<int*> >);
+static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<forward_iterator> const>, forward_iterator<int const*> >);
+static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<forward_iterator> >, forward_iterator<int*> >);

libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp

 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R>
 // concept common_range;
 
 #include <ranges>
 
 #include "test_iterators.h"
-#include "test_range.h"
 
+template<class It>             struct Common { It begin() const; It end() const; };
+template<class It>             struct NonCommon { It begin() const; sentinel_wrapper<It> end() const; };
+template<class It, class Sent> struct Range { It begin() const; Sent end() const; };
+
+static_assert(!std::ranges::common_range<Common<cpp17_input_iterator<int*>>>); // not a sentinel for itself
+static_assert(!std::ranges::common_range<Common<cpp20_input_iterator<int*>>>); // not a sentinel for itself
+static_assert( std::ranges::common_range<Common<forward_iterator<int*>>>);
+static_assert( std::ranges::common_range<Common<bidirectional_iterator<int*>>>);
+static_assert( std::ranges::common_range<Common<random_access_iterator<int*>>>);
+static_assert( std::ranges::common_range<Common<contiguous_iterator<int*>>>);
+static_assert( std::ranges::common_range<Common<int*>>);
+
+static_assert(!std::ranges::common_range<NonCommon<cpp17_input_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<cpp20_input_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<forward_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<bidirectional_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<random_access_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<contiguous_iterator<int*>>>);
+static_assert(!std::ranges::common_range<NonCommon<int*>>);
+
+// Test when begin() and end() only differ by their constness.
+static_assert(!std::ranges::common_range<Range<int*, int const*>>);
+
+// Simple test with a sized_sentinel.
+static_assert(!std::ranges::common_range<Range<int*, sized_sentinel<int*>>>);
+
+// Make sure cv-qualification doesn't impact the concept when begin() and end() have matching qualifiers.
+static_assert( std::ranges::common_range<Common<forward_iterator<int*>> const>);
+static_assert(!std::ranges::common_range<NonCommon<forward_iterator<int*>> const>);
 
-
-static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> >);
-static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> const>);
-
-static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> >);
-static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> const>);
-
-static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> >);
-static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> const>);
-
-static_assert(std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> >);
-static_assert(!std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
-
-struct subtly_not_common {
-  int* begin() const;
+// Test with a range that's a common_range only when const-qualified.
+struct Range1 {
+  int* begin();
+  int const* begin() const;
   int const* end() const;
 };
-static_assert(std::ranges::range<subtly_not_common> && !std::ranges::common_range<subtly_not_common>);
-static_assert(std::ranges::range<subtly_not_common const> && !std::ranges::common_range<subtly_not_common const>);
+static_assert(!std::ranges::common_range<Range1>);
+static_assert( std::ranges::common_range<Range1 const>);
 
-struct common_range_non_const_only {
+// Test with a range that's a common_range only when not const-qualified.
+struct Range2 {
   int* begin() const;
   int* end();
   int const* end() const;
 };
-static_assert(std::ranges::range<common_range_non_const_only>&& std::ranges::common_range<common_range_non_const_only>);
-static_assert(std::ranges::range<common_range_non_const_only const> && !std::ranges::common_range<common_range_non_const_only const>);
-
-struct common_range_const_only {
-  int* begin();
-  int const* begin() const;
-  int const* end() const;
-};
-static_assert(std::ranges::range<common_range_const_only> && !std::ranges::common_range<common_range_const_only>);
-static_assert(std::ranges::range<common_range_const_only const>&& std::ranges::common_range<common_range_const_only const>);
+static_assert( std::ranges::common_range<Range2>);
+static_assert(!std::ranges::common_range<Range2 const>);

libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp

 static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>);
 
 static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >);
 static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >);
 
 static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>);
 static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>);
 
-static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> >);
+static_assert(std::ranges::input_range<test_common_range<forward_iterator> >);
 static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >);
 
-static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> const>);
+static_assert(std::ranges::input_range<test_common_range<forward_iterator> const>);
 static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>);
 
-static_assert(std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> >);
+static_assert(std::ranges::input_range<test_non_const_common_range<forward_iterator> >);
 static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >);
 
-static_assert(!std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::input_range<test_non_const_common_range<forward_iterator> const>);
 static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>);

libcxx/test/std/ranges/range.utility/range.subrange/advance.pass.cpp

constexpr bool test() {
   assert(a1.size() == 7);
   auto a5 = a.next(5);
   assert(a5.begin() == globalBuff + 5);
   assert(a5.size() == 3);
   auto a4 = a5.prev();
   assert(a4.begin() == globalBuff + 4);
   assert(a4.size() == 4);
 
-  std::ranges::subrange<InputIter> b(InputIter(globalBuff), InputIter(globalBuff + 8));
+  std::ranges::subrange<InputIter, sentinel_wrapper<InputIter>> b(InputIter(globalBuff), sentinel_wrapper(InputIter(globalBuff + 8)));
   auto b1 = std::move(b).next();
   assert(b1.begin().base() == globalBuff + 1);
 
   std::ranges::subrange<BidirIter> c(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
   auto c1 = c.prev();
   assert(c1.begin().base() == globalBuff + 3);
   auto c2 = c.prev(4);
   assert(c2.begin().base() == globalBuff);

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

#if TEST_STD_VER >= 11
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
-    test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
-    test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
+    test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w+100);
     }

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

#if TEST_STD_VER >= 11
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
-    test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
-    test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
+    test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S(), IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), w, w+100);
     }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

#if TEST_STD_VER >= 11
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
-    test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
-    test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
+    test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S(), 0, w, w+100);
     }

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

#if TEST_STD_VER >= 11
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef cpp17_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
-    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
-    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
+    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter(TIter()));
+    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter(TIter()));
+    test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter(TIter()));
 
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
 
     Widget w[100];
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, w, w+100);
     }

libcxx/test/support/test_iterators.h

public:
     typedef          std::input_iterator_tag                   iterator_category;
     typedef typename Traits::value_type                        value_type;
     typedef typename Traits::difference_type                   difference_type;
     typedef It                                                 pointer;
     typedef typename Traits::reference                         reference;
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 cpp17_input_iterator() : it_() {}
     explicit TEST_CONSTEXPR_CXX14 cpp17_input_iterator(It it) : it_(it) {}
     template <class U, class T>
         TEST_CONSTEXPR_CXX14 cpp17_input_iterator(const cpp17_input_iterator<U, T>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 cpp17_input_iterator& operator++() {++it_; return *this;}