diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
@@ -66,155 +66,133 @@
 }
 
 template <class Iter, class ValueType, class Category>
-constexpr bool testConstWithoutConcept() {
+constexpr bool testConst() {
   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(!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>);
+  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>
-constexpr bool testWithoutConcept() {
+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, 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>);
+  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 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 ValueType, class DiffType, class RefType, class PtrType, class Category, class IterConcept>
-constexpr bool testWithConcept() {
+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, 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>);
+  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;
 }
 
 // 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(testWithoutConcept<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
+static_assert(test<std::array<int, 10>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::array<int, 10>::const_iterator, int, std::random_access_iterator_tag>());
+static_assert(test<std::string::iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string::const_iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string_view::iterator, char, std::random_access_iterator_tag>());
+static_assert(testConst<std::string_view::const_iterator, char, std::random_access_iterator_tag>());
+static_assert(test<std::vector<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::vector<int>::const_iterator, int, std::random_access_iterator_tag>());
+
+static_assert(test<std::deque<int>::iterator, int, std::random_access_iterator_tag>());
+static_assert(testConst<std::deque<int>::const_iterator, int, std::random_access_iterator_tag>());
+static_assert(test<std::forward_list<int>::iterator, int, std::forward_iterator_tag>());
+static_assert(testConst<std::forward_list<int>::const_iterator, int, std::forward_iterator_tag>());
+static_assert(test<std::list<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::list<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+
+static_assert(test<std::map<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::map<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(test<std::multimap<int, int>::iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multimap<int, int>::const_iterator, std::pair<const int, int>, std::bidirectional_iterator_tag>());
+
+static_assert(testConst<std::set<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::set<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multiset<int>::iterator, int, std::bidirectional_iterator_tag>());
+static_assert(testConst<std::multiset<int>::const_iterator, int, std::bidirectional_iterator_tag>());
+
+#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(test<std::unordered_map<int, int>::iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_map<int, int>::const_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_map<int, int>::local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_map<int, int>::const_local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_multimap<int, int>::iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(test<std::unordered_multimap<int, int>::local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multimap<int, int>::const_local_iterator, std::pair<const int, int>, unordered_iterator_category>());
+
+static_assert(testConst<std::unordered_set<int>::iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::const_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_set<int>::const_local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::const_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::local_iterator, int, unordered_iterator_category>());
+static_assert(testConst<std::unordered_multiset<int>::const_local_iterator, int, unordered_iterator_category>());
+
+static_assert(test<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
 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>, int, std::input_iterator_tag>());
 
 #if !defined(_LIBCPP_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>, char, long long, char, char*, std::input_iterator_tag>());
+static_assert(test<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
 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::cmatch, std::forward_iterator_tag>());
+static_assert(testConst<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 #ifndef _LIBCPP_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::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::recursive_directory_iterator, std::filesystem::directory_entry,
+                   std::ptrdiff_t, const std::filesystem::directory_entry&,
+                   const std::filesystem::directory_entry*, std::input_iterator_tag>());
 #endif
 
 // Local test iterators.
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp
--- a/libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_move.pass.cpp
@@ -49,8 +49,8 @@
   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_)};
@@ -63,8 +63,8 @@
   }
 }
 
-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_)};
@@ -78,8 +78,8 @@
   }
 }
 
-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_)};
diff --git a/libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp b/libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp
--- a/libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp
+++ b/libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp
@@ -22,25 +22,33 @@
 #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;
 }
 
@@ -56,7 +64,7 @@
 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);
@@ -91,4 +99,3 @@
 
   return 0;
 }
-
diff --git a/libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp b/libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp
--- a/libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp
+++ b/libcxx/test/std/strings/string.view/string.view.deduct/iterator_sentinel.pass.cpp
@@ -20,25 +20,33 @@
 #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_deduction(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_deduction<CharT*, CharT*>(val);
+  test_deduction<CharT*, const CharT*>(val);
+  test_deduction<const CharT*, CharT*>(val);
+  test_deduction<const CharT*, sized_sentinel<const CharT*>>(val);
+  test_deduction<contiguous_iterator<const CharT*>, contiguous_iterator<const CharT*>>(val);
+  test_deduction<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**) {
@@ -46,4 +54,3 @@
 
   return 0;
 }
-
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp
@@ -26,10 +26,10 @@
     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());
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp
@@ -24,7 +24,7 @@
 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());
   }
   {
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp
@@ -47,8 +47,8 @@
 
   {
     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};
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp
@@ -24,7 +24,7 @@
 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());
   }
   {