[libcxx][test] array and basic_string_view iterators are not portably pointers

[CaseyCarter]

Summary

Fixup tests that believe them to be so. Most notably including some heavy refactoring in std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp, which now detects pointers and validates that iterator_concept is present only for pointers.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

22–23

This initially struck me as the wrong fix — this test is supposed to be checking the iterator-sentinel ctor, not a pointer-sentinel ctor! But I see now that the old code was never trying to test any non-pointer iterator types anyway. Which is... also bad. :P

template<class CharT, class It, class Sent>
constexpr void test() {
  auto val = MAKE_STRING_VIEW(CharT, "test");
  It first = It(val.data());
  Sent last = Sent(It(val.data() + val.size());
  auto sv = std::basic_string_view<CharT>(first, last);
  assert(sv.data() == val.data());
  assert(sv.size() == 4);
}

and then we should test with, like,

  test<char, char*, char*>();
  test<char, char*, const char*>();
  test<char, const char*, sentinel<const char*>>();  // is this supposed to work?
  test<char, const char*, sized_sentinel<const char*>>();
  test<char, contiguous_iterator<char*>, contiguous_iterator<char*>>();
  test<char, contiguous_iterator<char*>, sized_sentinel<contiguous_iterator<char*>>>();

  // Test other character types
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
  test<wchar_t, wchar_t*>();
#endif
  test<char8_t, char8_t*>();
  test<char16_t, char16_t*>();
  test<char32_t, char32_t*>();

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

27

These added to_addresses seem uncontroversial to me. (@Mordante, these make sense to you too?) Maybe you want to pull them out into a separate PR and/or commit them immediately.

libcxx/test/support/test_iterators.h

359 ↗

(On Diff #400193)

What necessitated this? I'd prefer to fix the users, instead of legalizing what they're doing.

[CaseyCarter]

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

22–23

I've also just realized that the ASSERT_SAME_TYPE which intends to test the deduction guide is doing nothing since we don't use CTAD on this line. Cleanup time.

libcxx/test/support/test_iterators.h

359 ↗

(On Diff #400193)

Code wrapping array and/or string_view iterators in contiguous_iterator - I don't recall precisely where. If the intent is to only admit pointers, why are we using iterator_traits<It>?

[CaseyCarter]

Address some review comments.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

23–26

Surely string_view::iterator is never char* (because it would be const char*). But anyway this if is redundant because if iterator actually were a pointer, then val.begin() and val.data() would be the same value of the same type and thus completely interchangeable. Just use .data() (as you did above).
This test deserves the same refactoring that you did above, e.g. it should test contiguous_iterator<const char*> and so on.

libcxx/test/support/test_iterators.h

359 ↗

(On Diff #400193)

AIUI, the original intent of e.g. forward_iterator (which I'm going to use as the type specimen for all test iterators) was to permit wrapping weirder iterator types; but if you actually want to do that correctly, the metaprogramming gets awful. And we were never actually relying on it to work with any non-pointer type. (Except, apparently, by accident. ;))
Mantra: "If you're not testing it, it doesn't work." So since we never (intentionally) used these types with non-pointer Its, it just makes sense to static_assert against that usage in the future. (Or, by accident, on other platforms in the present!)

In D116613 I suggested that we ought to permit forward_iterator<stride_counter<int*>>, to cut down on the absolutely abominable metaprogramming involved with our current stride_counting_iterator<forward_iterator<int*>>. If we did, then that would be a reason to remove this assertion... but we still might want to keep some kind of assertion, because I would bet money that e.g. forward_iterator<std::vector<bool>::iterator> would explode.

[ldionne]

LGTM except for Arthur's comments, which I agree with (but IMO removing the static_assert in contiguous_iterator is fine).

I checked everything and I originally thought the libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp changes were weakening the tests for libc++, but it turns out they don't.

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

54–55

Here and in the functions below too. We generally don't use a single template parameter named O.

[CaseyCarter]

Moar review comments

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

22–23

I've also just realized that the ASSERT_SAME_TYPE which intends to test the deduction guide is doing nothing since we don't use CTAD on this line. Cleanup time.

Wrong test - the deduction guide test is just below. ASSERT_SAME_TYPE here is copy-pasta.

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

23–26

This is ridiculous. Fixing and refactoring.

libcxx/test/support/test_iterators.h

359 ↗

(On Diff #400193)

I'll revert this change. Oddly, I'm finding no test fallout now - I assume the problems have either been corrected elsewhere since I first found this, or are fixed in later commits on my branch.

[CaseyCarter]

Resolve merge conflicts.

[• Quuxplusone]

LGTM; none of my remaining nits are blocking.

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

55–73

FWIW, I'm predictably un-thrilled by the overloading of test<It, V, C> and test<It, V, D, R, P, C>; I would rather they were named differently, like testOrdinary and testUnusual, or test and test5, or something; but I have no really good naming suggestion, and this is still an improvement over the status quo, so no action required unless you feel like it.

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

24

Consider s/test_deduction/test_ctad/g for clarity.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

42

Both on lines 29,32 and 42,45, consider spelling the right-hand side of the == as just fmt + 1.
That is, both &fmt[1] and std::to_address(view.begin()) + 1 are verbose synonyms for fmt + 1.

@CaseyCarter, for my own curiosity, would MSVC be happy with

assert(context.begin() == view.begin() + 1);

or is that considered problematic because of comparing iterators into two different string_views (even though they view the same underlying range)? ...Hmm, looks like we're doing exactly that on line 33 of format.parse.ctx/end.pass.cpp. So maybe it's OK to do it here too?

[CaseyCarter]

More refactoring!

[CaseyCarter]

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

55–73

I see now that test<I, V, C>, testConst<I, V, C>, and testIOterator are equivalent to calling test with different template arguments. I'll rename the first to testMutable, and refactor all of them to actually call test to eliminate duplication.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

42

@CaseyCarter, for my own curiosity, would MSVC be happy with

assert(context.begin() == view.begin() + 1);

or is that considered problematic because of comparing iterators into two different string_views (even though they view the same underlying range)? ...Hmm, looks like we're doing exactly that on line 33 of format.parse.ctx/end.pass.cpp. So maybe it's OK to do it here too?

For basic_string_view we interpret "same underlying sequence" to mean "both iterators were obtained from basic_string_views with the same first and last character", so that would be a problem. (And yes, it's a problem in end. I have more patches to submit, I've been trying to keep a relatively constant five outstanding reviews.)

[• Quuxplusone]

One more whitespace/grammar nit in a comment. Ship it!

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

90–92

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

 
 #include "test_iterators.h"
 #include "iterator_traits_cpp17_iterators.h"
 
 template <class Traits>
 constexpr bool has_iterator_concept_v = requires {
   typename Traits::iterator_concept;
 };
 
-template <class Iter, class Category>
-constexpr bool testIOIterator() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, void>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, void>);
-  static_assert(std::same_as<typename Traits::pointer, void>);
-  static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
-}
-
-template <class Iter, class ValueType, class Category>
-constexpr bool testConstWithoutConcept() {
+template <class Iter, class Category, class ValueType, class DiffType, class RefType, class PtrType>
+constexpr bool test() {
   using Traits = std::iterator_traits<Iter>;
   static_assert(std::same_as<typename Traits::iterator_category, Category>);
   static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, const ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, const ValueType*>);
+  static_assert(std::same_as<typename Traits::difference_type, DiffType>);
+  static_assert(std::same_as<typename Traits::reference, RefType>);
+  static_assert(std::same_as<typename Traits::pointer, PtrType>);
+  if constexpr (std::is_pointer_v<Iter>) {
+    static_assert(std::same_as<typename Traits::iterator_concept, std::contiguous_iterator_tag>);
+  } else {
     static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
-}
-
-template <class Iter, class ValueType, class Category, class IterConcept>
-constexpr bool testConstWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, const ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, const ValueType*>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
-  return true;
   }
 
-template <class Iter, class ValueType, class Category>
-constexpr bool testWithoutConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, ValueType*>);
-  static_assert(!has_iterator_concept_v<Traits>);
-
   return true;
 }
 
-template <class Iter, class ValueType, class Category, class IterConcept>
-constexpr bool testWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
-  static_assert(std::same_as<typename Traits::reference, ValueType&>);
-  static_assert(std::same_as<typename Traits::pointer, ValueType*>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
-  return true;
+template <class Iter, class Category>
+constexpr bool testIOIterator() {
+  return test<Iter, Category, void, std::ptrdiff_t, void, void>();
 }
 
-template <class Iter, class ValueType, class DiffType, class RefType, class PtrType, class Category>
-constexpr bool testWithoutConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, DiffType>);
-  static_assert(std::same_as<typename Traits::reference, RefType>);
-  static_assert(std::same_as<typename Traits::pointer, PtrType>);
-  static_assert(!has_iterator_concept_v<Traits>);
-
-  return true;
+template <class Iter, class Category, class ValueType>
+constexpr bool testConst() {
+  return test<Iter, Category, ValueType, std::ptrdiff_t, const ValueType&, const ValueType*>();
 }
 
-template <class Iter, class ValueType, class DiffType, class RefType, class PtrType, class Category, class IterConcept>
-constexpr bool testWithConcept() {
-  using Traits = std::iterator_traits<Iter>;
-  static_assert(std::same_as<typename Traits::iterator_category, Category>);
-  static_assert(std::same_as<typename Traits::value_type, ValueType>);
-  static_assert(std::same_as<typename Traits::difference_type, DiffType>);
-  static_assert(std::same_as<typename Traits::reference, RefType>);
-  static_assert(std::same_as<typename Traits::pointer, PtrType>);
-  static_assert(std::same_as<typename Traits::iterator_concept, IterConcept>);
-
-  return true;
+template <class Iter, class Category, class ValueType>
+constexpr bool testMutable() {
+  return test<Iter, Category, ValueType, std::ptrdiff_t, ValueType&, ValueType*>();
 }
 
 // Standard types.
 
-// These tests depend on implementation details of libc++,
-// e.g. that std::array::iterator is a raw pointer type but std::string::iterator is not.
-// The Standard does not specify whether iterator_traits<It>::iterator_concept exists for any particular non-pointer type.
+// The Standard does not specify whether iterator_traits<It>::iterator_concept
+// exists for any particular non-pointer type, we assume it is present
+// only for pointers.
 //
-static_assert(testWithConcept<std::array<int, 10>::iterator, int, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testConstWithConcept<std::array<int, 10>::const_iterator, int, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testWithoutConcept<std::string::iterator, char, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::string::const_iterator, char, std::random_access_iterator_tag>());
-static_assert(testConstWithConcept<std::string_view::iterator, char, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testConstWithConcept<std::string_view::const_iterator, char, std::random_access_iterator_tag, std::contiguous_iterator_tag>());
-static_assert(testWithoutConcept<std::vector<int>::iterator, int, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::vector<int>::const_iterator, int, std::random_access_iterator_tag>());
-
-static_assert(testWithoutConcept<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
-static_assert(testConstWithoutConcept<std::deque<int>::const_iterator, int, std::random_access_iterator_tag>());
-static_assert(testWithoutConcept<std::forward_list<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::forward_list<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::list<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::list<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-
-static_assert(testWithoutConcept<std::map<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::map<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testWithoutConcept<std::multimap<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multimap<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
-
-static_assert(testConstWithoutConcept<std::set<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::set<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multiset<int>::iterator, int, std::bidirectional_iterator_tag>());
-static_assert(testConstWithoutConcept<std::multiset<int>::const_iterator, int, std::bidirectional_iterator_tag>());
-
-static_assert(testWithoutConcept<std::unordered_map<int, int>::iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_map<int, int>::const_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_map<int, int>::local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_map<int, int>::const_local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_multimap<int, int>::iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multimap<int, int>::const_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testWithoutConcept<std::unordered_multimap<int, int>::local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multimap<int, int>::const_local_iterator, std::pair<const int, int>, std::forward_iterator_tag>());
-
-static_assert(testConstWithoutConcept<std::unordered_set<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_set<int>::const_local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::const_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::local_iterator, int, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::unordered_multiset<int>::const_local_iterator, int, std::forward_iterator_tag>());
+static_assert(testMutable<std::array<int, 10>::iterator, std::random_access_iterator_tag, int>());
+static_assert(testConst<std::array<int, 10>::const_iterator, std::random_access_iterator_tag, int>());
+static_assert(testMutable<std::string::iterator, std::random_access_iterator_tag, char>());
+static_assert(testConst<std::string::const_iterator, std::random_access_iterator_tag, char>());
+static_assert(testConst<std::string_view::iterator, std::random_access_iterator_tag, char>());
+static_assert(testConst<std::string_view::const_iterator, std::random_access_iterator_tag, char>());
+static_assert(testMutable<std::vector<int>::iterator, std::random_access_iterator_tag, int>());
+static_assert(testConst<std::vector<int>::const_iterator, std::random_access_iterator_tag, int>());
+
+static_assert(testMutable<std::deque<int>::iterator, std::random_access_iterator_tag, int>());
+static_assert(testConst<std::deque<int>::const_iterator, std::random_access_iterator_tag, int>());
+static_assert(testMutable<std::forward_list<int>::iterator, std::forward_iterator_tag, int>());
+static_assert(testConst<std::forward_list<int>::const_iterator, std::forward_iterator_tag, int>());
+static_assert(testMutable<std::list<int>::iterator, std::bidirectional_iterator_tag, int>());
+static_assert(testConst<std::list<int>::const_iterator, std::bidirectional_iterator_tag, int>());
+
+static_assert(testMutable<std::map<int, int>::iterator, std::bidirectional_iterator_tag, std::pair<const int, int>>());
+static_assert(testConst<std::map<int, int>::const_iterator, std::bidirectional_iterator_tag, std::pair<const int, int>>());
+static_assert(testMutable<std::multimap<int, int>::iterator, std::bidirectional_iterator_tag, std::pair<const int, int>>());
+static_assert(testConst<std::multimap<int, int>::const_iterator, std::bidirectional_iterator_tag, std::pair<const int, int>>());
+
+static_assert(testConst<std::set<int>::iterator, std::bidirectional_iterator_tag, int>());
+static_assert(testConst<std::set<int>::const_iterator, std::bidirectional_iterator_tag, int>());
+static_assert(testConst<std::multiset<int>::iterator, std::bidirectional_iterator_tag, int>());
+static_assert(testConst<std::multiset<int>::const_iterator, std::bidirectional_iterator_tag, int>());
+
+#ifdef _MSVC_STL_VERSION
+using unordered_iterator_category = std::bidirectional_iterator_tag;
+#else // ^^^ MSVC STL / other vvv
+using unordered_iterator_category = std::forward_iterator_tag;
+#endif // _MSVC_STL_VERSION
+
+static_assert(testMutable<std::unordered_map<int, int>::iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testConst<std::unordered_map<int, int>::const_iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testMutable<std::unordered_map<int, int>::local_iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testConst<std::unordered_map<int, int>::const_local_iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testMutable<std::unordered_multimap<int, int>::iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testMutable<std::unordered_multimap<int, int>::local_iterator, unordered_iterator_category, std::pair<const int, int>>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_local_iterator, unordered_iterator_category, std::pair<const int, int>>());
+
+static_assert(testConst<std::unordered_set<int>::iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_set<int>::const_iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_set<int>::local_iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_set<int>::const_local_iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_multiset<int>::iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_multiset<int>::const_iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_multiset<int>::local_iterator, unordered_iterator_category, int>());
+static_assert(testConst<std::unordered_multiset<int>::const_local_iterator, unordered_iterator_category, int>());
 
-static_assert(testWithoutConcept<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
+static_assert(testMutable<std::reverse_iterator<int*>, std::random_access_iterator_tag, int>());
 static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>());
-static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
+static_assert(testConst<std::istream_iterator<int, char>, std::input_iterator_tag, int>());
 
 #if !defined(TEST_HAS_NO_LOCALIZATION)
-static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
-static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
+// libc++-specific since pointer type is unspecified:
+LIBCPP_STATIC_ASSERT(test<std::istreambuf_iterator<char>, std::input_iterator_tag, char, long long, char, char*>());
+static_assert(test<std::move_iterator<int*>, std::random_access_iterator_tag, int, std::ptrdiff_t, int&&, int*>());
 static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
-static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
-static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
+static_assert(testConst<std::cregex_iterator, std::forward_iterator_tag, std::cmatch>());
+static_assert(testConst<std::cregex_token_iterator, std::forward_iterator_tag, std::csub_match>());
 #endif // !TEST_HAS_NO_LOCALIZATION
 
 #ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
-static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
-                                 const std::filesystem::directory_entry&, const std::filesystem::directory_entry*,
-                                 std::input_iterator_tag>());
-static_assert(testWithoutConcept<std::filesystem::recursive_directory_iterator, std::filesystem::directory_entry,
-                                 std::ptrdiff_t, const std::filesystem::directory_entry&,
-                                 const std::filesystem::directory_entry*, std::input_iterator_tag>());
+static_assert(test<std::filesystem::directory_iterator, std::input_iterator_tag, std::filesystem::directory_entry,
+                   std::ptrdiff_t, const std::filesystem::directory_entry&, const std::filesystem::directory_entry*>());
+static_assert(test<std::filesystem::recursive_directory_iterator, std::input_iterator_tag,
+                   std::filesystem::directory_entry, std::ptrdiff_t, const std::filesystem::directory_entry&,
+                   const std::filesystem::directory_entry*>());
 #endif
 
 // Local test iterators.
 
 struct AllMembers {
   struct iterator_category {};
   struct value_type {};
   struct difference_type {};

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp

public:
   constexpr void operator++(int) noexcept { ++base_; }
 
   constexpr bool operator==(iterator_wrapper const& other) const noexcept { return base_ == other.base_; }
 
 private:
   I base_ = I{};
 };
 
-template <typename I>
-constexpr void unqualified_lookup_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename It, typename Out>
+constexpr void unqualified_lookup_move(It first_, It last_, Out result_first_, Out result_last_) {
   auto first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(first_)};
   auto last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(last_)};
   auto result_first = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_first_)};
   auto result_last = ::check_unqualified_lookup::unqualified_lookup_wrapper{std::move(result_last_)};
 
   static_assert(!noexcept(std::ranges::iter_move(first)), "unqualified-lookup case not being chosen");
 
   for (; first != last && result_first != result_last; (void)++first, ++result_first) {
     *result_first = std::ranges::iter_move(first);
   }
 }
 
-template <typename I>
-constexpr void lvalue_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename It, typename Out>
+constexpr void lvalue_move(It first_, It last_, Out result_first_, Out result_last_) {
   auto first = iterator_wrapper{std::move(first_)};
   auto last = ::iterator_wrapper{std::move(last_)};
   auto result_first = iterator_wrapper{std::move(result_first_)};
   auto result_last = iterator_wrapper{std::move(result_last_)};
 
   static_assert(!noexcept(std::ranges::iter_move(first)), "`operator*() const&` is not noexcept, and there's no hidden "
                                                           "friend iter_move.");
 
   for (; first != last && result_first != result_last; (void)++first, ++result_first) {
     *result_first = std::ranges::iter_move(first);
   }
 }
 
-template <typename I>
-constexpr void rvalue_move(I first_, I last_, I result_first_, I result_last_) {
+template <typename It, typename Out>
+constexpr void rvalue_move(It first_, It last_, Out result_first_, Out result_last_) {
   auto first = iterator_wrapper{std::move(first_)};
   auto last = iterator_wrapper{std::move(last_)};
   auto result_first = iterator_wrapper{std::move(result_first_)};
   auto result_last = iterator_wrapper{std::move(result_last_)};
 
   static_assert(noexcept(std::ranges::iter_move(std::move(first))),
                 "`operator*() &&` is noexcept, and there's no hidden friend iter_move.");
 

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

 //  constexpr basic_string_view(It begin, End end)
 
 #include <string_view>
 #include <cassert>
 #include <iterator>
 
 #include "make_string.h"
 #include "test_iterators.h"
 
-template<class CharT, class Sentinel>
-constexpr void test() {
-  auto val = MAKE_STRING_VIEW(CharT, "test");
-  auto sv = std::basic_string_view<CharT>(val.begin(), Sentinel(val.end()));
-  ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
-  assert(sv.size() == val.size());
+template<class It, class Sentinel, class CharT>
+constexpr void test_construction(std::basic_string_view<CharT> val) {
+  auto sv = std::basic_string_view<CharT>(It(val.data()), Sentinel(It(val.data() + val.size())));
   assert(sv.data() == val.data());
+  assert(sv.size() == val.size());
+}
+
+template<class CharT>
+constexpr void test_with_char() {
+  const auto val = MAKE_STRING_VIEW(CharT, "test");
+  test_construction<CharT*, CharT*>(val);
+  test_construction<CharT*, const CharT*>(val);
+  test_construction<const CharT*, CharT*>(val);
+  test_construction<const CharT*, sized_sentinel<const CharT*>>(val);
+  test_construction<contiguous_iterator<const CharT*>, contiguous_iterator<const CharT*>>(val);
+  test_construction<contiguous_iterator<const CharT*>, sized_sentinel<contiguous_iterator<const CharT*>>>(val);
 }
 
 constexpr bool test() {
-  test<char, char*>();
+  test_with_char<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t, wchar_t*>();
+  test_with_char<wchar_t>();
 #endif
-  test<char8_t, char8_t*>();
-  test<char16_t, char16_t*>();
-  test<char32_t, char32_t*>();
-  test<char, const char*>();
-  test<char, sized_sentinel<const char*>>();
+  test_with_char<char8_t>();
+  test_with_char<char16_t>();
+  test_with_char<char32_t>();
+
   return true;
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template<class CharT>
 struct ThrowingSentinel {
   friend bool operator==(const CharT*, ThrowingSentinel) noexcept { return true; }
   friend std::iter_difference_t<const CharT*> operator-(const CharT*, ThrowingSentinel) noexcept { return {}; }
   friend std::iter_difference_t<const CharT*> operator-(ThrowingSentinel, const CharT*) { throw 42; }
 };
 
 template <class CharT>
 void test_throwing() {
   auto val = MAKE_STRING_VIEW(CharT, "test");
   try {
-    (void)std::basic_string_view<CharT>(val.begin(), ThrowingSentinel<CharT>());
+    (void)std::basic_string_view<CharT>(val.data(), ThrowingSentinel<CharT>());
     assert(false);
   } catch (int i) {
     assert(i == 42);
   }
 }
 
 void test_throwing() {
   test_throwing<char>();
int main(int, char**) {
   static_assert(test());
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   test_throwing();
 #endif
 
   return 0;
 }
-

libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp

 
 #include <string_view>
 #include <cassert>
 
 #include "make_string.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 
-template<class CharT, class Sentinel>
-constexpr void test() {
-  auto val = MAKE_STRING_VIEW(CharT, "test");
-  auto sv = std::basic_string_view(val.begin(), Sentinel(val.end()));
+template<class It, class Sentinel, class CharT>
+constexpr void test_ctad(std::basic_string_view<CharT> val) {
+  auto sv = std::basic_string_view(It(val.data()), Sentinel(It(val.data() + val.size())));
   ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
-  assert(sv.size() == val.size());
   assert(sv.data() == val.data());
+  assert(sv.size() == val.size());
+}
+
+template<class CharT>
+constexpr void test_with_char() {
+  const auto val = MAKE_STRING_VIEW(CharT, "test");
+  test_ctad<CharT*, CharT*>(val);
+  test_ctad<CharT*, const CharT*>(val);
+  test_ctad<const CharT*, CharT*>(val);
+  test_ctad<const CharT*, sized_sentinel<const CharT*>>(val);
+  test_ctad<contiguous_iterator<const CharT*>, contiguous_iterator<const CharT*>>(val);
+  test_ctad<contiguous_iterator<const CharT*>, sized_sentinel<contiguous_iterator<const CharT*>>>(val);
 }
 
 constexpr void test() {
-  test<char, char*>();
+  test_with_char<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  test<wchar_t, wchar_t*>();
+  test_with_char<wchar_t>();
 #endif
-  test<char8_t, char8_t*>();
-  test<char16_t, char16_t*>();
-  test<char32_t, char32_t*>();
-  test<char, const char*>();
-  test<char, sized_sentinel<const char*>>();
+  test_with_char<char8_t>();
+  test_with_char<char16_t>();
+  test_with_char<char32_t>();
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }
-

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == &fmt[1]);
+    assert(std::to_address(context.begin()) == fmt + 1);
 
     context.advance_to(context.begin() + 1);
-    assert(context.begin() == &fmt[2]);
+    assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
 
     context.advance_to(context.begin() + 1);
-    assert(std::to_address(context.begin()) == std::to_address(view.begin()) + 1);
+    assert(std::to_address(context.begin()) == fmt + 1);
 
     context.advance_to(context.begin() + 1);
-    assert(std::to_address(context.begin()) == std::to_address(view.begin()) + 2);
+    assert(std::to_address(context.begin()) == fmt + 2);
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 #include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.begin() == &fmt[0]);
+    assert(std::to_address(context.begin()) == &fmt[0]);
     ASSERT_NOEXCEPT(context.begin());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     ASSERT_NOEXCEPT(context.begin());
   }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

constexpr void test(const CharT* fmt) {
 
   ASSERT_NOEXCEPT(
       std::basic_format_parse_context{std::basic_string_view<CharT>{}});
   ASSERT_NOEXCEPT(
       std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
 
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.begin() == &fmt[0]);
-    assert(context.end() == &fmt[3]);
+    assert(std::to_address(context.begin()) == &fmt[0]);
+    assert(std::to_address(context.end()) == &fmt[3]);
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     assert(context.end() == view.end());
   }
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 #include <string_view>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test(const CharT* fmt) {
   {
     std::basic_format_parse_context<CharT> context(fmt);
-    assert(context.end() == &fmt[3]);
+    assert(std::to_address(context.end()) == &fmt[3]);
     ASSERT_NOEXCEPT(context.end());
   }
   {
     std::basic_string_view view{fmt};
     std::basic_format_parse_context context(view);
     assert(context.end() == view.end());
     ASSERT_NOEXCEPT(context.end());
   }