From c62cf54e47d2037ae861e9cdaad1c0d7246e5644 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 17:05:53 +0200
Subject: [PATCH 01/13] `views::common`

---
 tests/std/tests/P0896R4_views_common/test.cpp | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tests/std/tests/P0896R4_views_common/test.cpp b/tests/std/tests/P0896R4_views_common/test.cpp
index 5f5ebf7c66d..307c15b28d4 100644
--- a/tests/std/tests/P0896R4_views_common/test.cpp
+++ b/tests/std/tests/P0896R4_views_common/test.cpp
@@ -63,6 +63,46 @@ void non_literal_parts(R& r, E& expected) {
             }
         }
     }
+
+#if _HAS_CXX23
+    using ranges::const_iterator_t;
+
+    const same_as<const_iterator_t<R>> auto cfirst = r.cbegin();
+    if (!is_empty) {
+        assert(*cfirst == *begin(expected));
+    }
+
+    if constexpr (copyable<V>) {
+        auto r2                                         = r;
+        const same_as<const_iterator_t<R>> auto cfirst2 = r2.cbegin();
+        if (!is_empty) {
+            assert(*cfirst2 == *cfirst);
+        }
+    }
+
+    if constexpr (CanCBegin<const R&>) {
+        const same_as<const_iterator_t<const R>> auto cfirst3 = as_const(r).cbegin();
+        if (!is_empty) {
+            assert(*cfirst3 == *cfirst);
+        }
+    }
+
+    const same_as<const_iterator_t<R>> auto clast = r.cend();
+    if constexpr (bidirectional_iterator<R>) {
+        if (!is_empty) {
+            assert(*prev(clast) == *prev(end(expected)));
+        }
+    }
+
+    if constexpr (CanCEnd<const R&>) {
+        const same_as<const_iterator_t<R>> auto clast2 = as_const(r).cend();
+        if constexpr (bidirectional_range<const R>) {
+            if (!is_empty) {
+                assert(*prev(clast2) == *prev(end(expected)));
+            }
+        }
+    }
+#endif //_HAS_CXX23
 }
 
 template <class Rng, class Expected>

From dc8b646ca68972a72b7abce0b2ae7e7458d8c0b1 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 17:16:47 +0200
Subject: [PATCH 02/13] `views::filter`

---
 tests/std/tests/P0896R4_views_filter/test.cpp | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/tests/std/tests/P0896R4_views_filter/test.cpp b/tests/std/tests/P0896R4_views_filter/test.cpp
index d1520701573..787c247c425 100644
--- a/tests/std/tests/P0896R4_views_filter/test.cpp
+++ b/tests/std/tests/P0896R4_views_filter/test.cpp
@@ -201,6 +201,54 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
         STATIC_ASSERT(!CanEnd<const F>);
     }
 
+#if _HAS_CXX23
+    using ranges::const_iterator_t, ranges::const_sentinel_t;
+
+    // Validate view_interface::cbegin
+    STATIC_ASSERT(CanMemberCBegin<F>);
+    if (forward_range<V>) { // intentionally not if constexpr
+        // Ditto "let's make some extra calls because memoization"
+        const same_as<const_iterator_t<F>> auto ci = r.cbegin();
+        if (!is_empty) {
+            assert(*ci == *begin(expected));
+        }
+        assert(*r.cbegin() == *begin(expected));
+        assert(*r.cbegin() == *begin(expected));
+
+        if constexpr (copy_constructible<V>) {
+            auto r2                                     = r;
+            const same_as<const_iterator_t<F>> auto ci2 = r2.cbegin();
+            assert(*r2.cbegin() == *ci2);
+            assert(*r2.cbegin() == *ci2);
+            if (!is_empty) {
+                assert(*ci2 == *ci);
+            }
+        }
+
+        STATIC_ASSERT(!CanMemberCBegin<const F>);
+    }
+
+    // Validate view_interface::cend
+    STATIC_ASSERT(CanMemberCEnd<F>);
+    if (!is_empty) {
+        if constexpr (common_range<V>) {
+            same_as<const_iterator_t<F>> auto ci = r.cend();
+            if constexpr (bidirectional_range<V>) {
+                assert(*prev(ci) == *prev(end(expected)));
+            }
+        } else {
+            [[maybe_unused]] same_as<const_sentinel_t<F>> auto cs = r.cend();
+        }
+
+        if constexpr (bidirectional_range<V> && common_range<V> && copy_constructible<V>) {
+            auto r2 = r;
+            assert(*prev(r2.cend()) == *prev(end(expected)));
+        }
+
+        STATIC_ASSERT(!CanMemberCEnd<const F>);
+    }
+#endif // _HAS_CXX23
+
     // Validate view_interface::data
     STATIC_ASSERT(!CanData<F>);
     STATIC_ASSERT(!CanData<const F>);

From d46a4917211f06054b1d162820f1bd846bc7960c Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 17:32:22 +0200
Subject: [PATCH 03/13] `views::join`

---
 tests/std/tests/P0896R4_views_join/test.cpp | 71 +++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/tests/std/tests/P0896R4_views_join/test.cpp b/tests/std/tests/P0896R4_views_join/test.cpp
index 96d87e350f9..d8c99c98f1c 100644
--- a/tests/std/tests/P0896R4_views_join/test.cpp
+++ b/tests/std/tests/P0896R4_views_join/test.cpp
@@ -215,6 +215,77 @@ constexpr bool test_one(Outer&& rng, Expected&& expected) {
             }
         }
 
+#if _HAS_CXX23
+        using ranges::const_iterator_t, ranges::const_sentinel_t;
+
+        // Validate view_interface::cbegin
+        static_assert(CanMemberCBegin<R>);
+        static_assert(CanMemberCBegin<const R>
+                      == (forward_range<const V> && is_reference_v<range_reference_t<const V>>
+                          && input_range<range_reference_t<const V>>) );
+        if (forward_range<R>) { // intentionally not if constexpr
+            const same_as<const_iterator_t<R>> auto ci = r.cbegin();
+            if (!is_empty) {
+                assert(*ci == *begin(expected));
+            }
+
+            if constexpr (copyable<V>) {
+                auto r2                                     = r;
+                const same_as<const_iterator_t<R>> auto ci2 = r2.cbegin();
+                if (!is_empty) {
+                    assert(*ci2 == *ci);
+                }
+            }
+
+            static_assert(CanMemberCBegin<const R> == CanCBegin<const R&>);
+            if constexpr (CanMemberCBegin<const R>) {
+                const same_as<const_iterator_t<const R>> auto ci2 = as_const(r).cbegin();
+                if (!is_empty) {
+                    assert(*ci2 == *ci);
+                }
+
+                if constexpr (copyable<V>) {
+                    const auto r2                                     = r;
+                    const same_as<const_iterator_t<const R>> auto ci3 = r2.cbegin();
+                    if (!is_empty) {
+                        assert(*ci3 == *ci);
+                    }
+                }
+            }
+        }
+
+        // Validate view_interface::cend
+        static_assert(CanMemberCEnd<R>);
+        static_assert(CanMemberCEnd<const R>
+                      == (forward_range<const V> && is_reference_v<range_reference_t<const V>>
+                          && input_range<range_reference_t<const V>>) );
+        const same_as<const_sentinel_t<R>> auto cs = r.end();
+        if (!is_empty) {
+            if constexpr (bidirectional_range<R> && common_range<R>) {
+                assert(*prev(cs) == *prev(end(expected)));
+
+                if constexpr (copyable<V>) {
+                    auto r2 = r;
+                    assert(*prev(r2.cend()) == *prev(end(expected)));
+                }
+            }
+
+            static_assert(CanMemberCEnd<const R> == CanCEnd<const R&>);
+            if constexpr (CanMemberCEnd<const R>) {
+                const same_as<const_sentinel_t<const R>> auto cs2 = as_const(r).cend();
+                if constexpr (bidirectional_range<R> && common_range<R>) {
+                    assert(*prev(cs2) == *prev(end(expected)));
+
+                    if constexpr (copyable<V>) {
+                        const auto r2                               = r;
+                        const same_as<const_sentinel_t<R>> auto cs3 = r2.cend();
+                        assert(*prev(cs3) == *prev(end(expected)));
+                    }
+                }
+            }
+        }
+#endif // _HAS_CXX23
+
         // Validate view_interface::data
         static_assert(!CanData<R>);
         static_assert(!CanData<const R>);

From 48ca6938c14c7f8fe5c929c290e0f60675237200 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 18:51:50 +0200
Subject: [PATCH 04/13] `ranges::ref_view`

---
 .../tests/P0896R4_ranges_ref_view/test.cpp    | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/std/tests/P0896R4_ranges_ref_view/test.cpp b/tests/std/tests/P0896R4_ranges_ref_view/test.cpp
index 8eaa06f81f7..3cc6b2b5e40 100644
--- a/tests/std/tests/P0896R4_ranges_ref_view/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_ref_view/test.cpp
@@ -86,6 +86,26 @@ struct instantiator {
             STATIC_ASSERT(noexcept(as_const(test_view).end()) == noexcept(wrapped_input.end()));
         }
 
+#if _HAS_CXX23
+        if constexpr (ranges::input_range<R>) { // const iterators (from view_interface)
+            R wrapped_input{input};
+            ref_view<R> test_view{wrapped_input};
+            const same_as<ranges::const_iterator_t<R>> auto cfirst = as_const(test_view).cbegin();
+            if constexpr (_Is_specialization_v<remove_const_t<decltype(cfirst)>, basic_const_iterator>) {
+                assert(cfirst.base().peek() == begin(input));
+            } else {
+                assert(cfirst.peek() == begin(input));
+            }
+
+            const same_as<ranges::const_sentinel_t<R>> auto clast = as_const(test_view).cend();
+            if constexpr (_Is_specialization_v<remove_const_t<decltype(clast)>, basic_const_iterator>) {
+                assert(clast.base().peek() == end(input));
+            } else {
+                assert(clast.peek() == end(input));
+            }
+        }
+#endif // _HAS_CXX23
+
         { // state
             STATIC_ASSERT(can_size<ref_view<R>> == ranges::sized_range<R>);
             if constexpr (ranges::sized_range<R>) {

From e7ec7a6929e3a35a7254ff17380f3eac5f1126e2 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 18:59:36 +0200
Subject: [PATCH 05/13] `ranges::subrange`

---
 .../tests/P0896R4_ranges_subrange/test.compile.pass.cpp  | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp b/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
index d35611879fe..e3b810556a9 100644
--- a/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
+++ b/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
@@ -1036,6 +1036,15 @@ namespace test_subrange {
         STATIC_ASSERT(HasMemberEmpty<Subrange const>);
         STATIC_ASSERT(!copyable<I> || range<Subrange const&>);
 
+#if _HAS_CXX23 // Validate cbegin/cend
+        if constexpr (ranges::input_range<Subrange>) {
+            STATIC_ASSERT(CanMemberCBegin<Subrange>);
+            STATIC_ASSERT(CanMemberCBegin<const Subrange> == ranges::input_range<const Subrange&>);
+            STATIC_ASSERT(CanMemberCEnd<Subrange>);
+            STATIC_ASSERT(CanMemberCEnd<const Subrange> == ranges::input_range<const Subrange&>);
+        }
+#endif // _HAS_CXX23
+
         // Validate size
         STATIC_ASSERT(sized == HasMemberSize<Subrange>);
 

From e2f7d4e25cfa02a86de460d79d560bf5e2208d9c Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 19:11:57 +0200
Subject: [PATCH 06/13] `views::reverse`

---
 .../std/tests/P0896R4_views_reverse/test.cpp  | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/tests/std/tests/P0896R4_views_reverse/test.cpp b/tests/std/tests/P0896R4_views_reverse/test.cpp
index ba624f3d4d0..cff2dc65f1d 100644
--- a/tests/std/tests/P0896R4_views_reverse/test.cpp
+++ b/tests/std/tests/P0896R4_views_reverse/test.cpp
@@ -230,6 +230,63 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
         }
     }
 
+#if _HAS_CXX23
+    // Validate view_interface::cbegin
+    static_assert(CanMemberCBegin<R>);
+    {
+        const same_as<const_iterator<reverse_iterator<iterator_t<V>>>> auto ci = r.cbegin();
+        if (!is_empty) {
+            assert(*ci == *begin(expected));
+        }
+
+        if constexpr (copyable<V>) {
+            auto r2                                                                 = r;
+            const same_as<const_iterator<reverse_iterator<iterator_t<V>>>> auto ci2 = r2.cbegin();
+            assert(r2.cbegin() == ci2);
+            assert(r2.cbegin() == ci2);
+            if (!is_empty) {
+                assert(*ci2 == *ci);
+            }
+        }
+
+        static_assert(CanMemberCBegin<const R> == common_range<Rng>);
+        if constexpr (common_range<Rng>) {
+            const same_as<const_iterator<reverse_iterator<iterator_t<const V>>>> auto ci3 = as_const(r).cbegin();
+            assert(as_const(r).cbegin() == ci3);
+            assert(as_const(r).cbegin() == ci3);
+            if (!is_empty) {
+                assert(*ci3 == *ci);
+            }
+
+            if constexpr (copyable<V>) {
+                const auto r2                                                                 = r;
+                const same_as<const_iterator<reverse_iterator<iterator_t<const V>>>> auto ci4 = r2.cbegin();
+                assert(r2.cbegin() == ci4);
+                assert(r2.cbegin() == ci4);
+                if (!is_empty) {
+                    assert(*ci4 == *ci);
+                }
+            }
+        }
+    }
+
+    // Validate view_interface::cend
+    static_assert(CanMemberCEnd<R>);
+    if (!is_empty) {
+        assert(*prev(r.cend()) == *prev(end(expected)));
+
+        if constexpr (copyable<V>) {
+            auto r2 = r;
+            assert(*prev(r2.cend()) == *prev(end(expected)));
+        }
+
+        static_assert(CanMemberCEnd<const R> == common_range<Rng>);
+        if constexpr (common_range<Rng>) {
+            assert(*prev(as_const(r).cend()) == *prev(end(expected)));
+        }
+    }
+#endif //_HAS_CXX23
+
     // Validate view_interface::data
     static_assert(!CanData<R>);
     static_assert(!CanData<const R>);

From 5f651e977ed1f5048faf439ed8fb2952448cf541 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 19:23:38 +0200
Subject: [PATCH 07/13] `views::transform`

---
 .../tests/P0896R4_views_transform/test.cpp    | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/tests/std/tests/P0896R4_views_transform/test.cpp b/tests/std/tests/P0896R4_views_transform/test.cpp
index 927049c307f..340c07dd3f1 100644
--- a/tests/std/tests/P0896R4_views_transform/test.cpp
+++ b/tests/std/tests/P0896R4_views_transform/test.cpp
@@ -250,6 +250,54 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
         }
     }
 
+#if _HAS_CXX23
+    using ranges::const_iterator_t, ranges::const_sentinel_t;
+
+    // Validate view_interface::cbegin
+    STATIC_ASSERT(CanMemberCBegin<R>);
+    STATIC_ASSERT(CanMemberCBegin<const R&> == (range<const V> && const_invocable));
+    if (forward_range<V>) { // intentionally not if constexpr
+        const same_as<const_iterator_t<R>> auto ci = r.cbegin();
+        if (!is_empty) {
+            assert(*ci == *begin(expected));
+        }
+
+        if constexpr (copy_constructible<V>) {
+            auto r2                                     = r;
+            const same_as<const_iterator_t<R>> auto ci2 = r2.cbegin();
+            if (!is_empty) {
+                assert(*ci2 == *ci);
+            }
+        }
+
+        if constexpr (CanMemberCBegin<const R&>) {
+            const same_as<const_iterator_t<const R>> auto ci3 = as_const(r).cbegin();
+            if (!is_empty) {
+                assert(*ci3 == *ci);
+            }
+        }
+    }
+
+    // Validate view_interface::cend
+    STATIC_ASSERT(CanMemberCEnd<R>);
+    STATIC_ASSERT(CanMemberCEnd<const R&> == (range<const V> && const_invocable));
+    if (!is_empty) {
+        same_as<const_sentinel_t<R>> auto cs = r.cend();
+        STATIC_ASSERT(is_same_v<const_sentinel_t<R>, const_iterator_t<R>> == common_range<V>);
+        if constexpr (bidirectional_range<R> && common_range<R>) {
+            assert(*prev(cs) == *prev(end(expected)));
+        }
+
+        if constexpr (CanMemberCEnd<const R&>) {
+            same_as<const_sentinel_t<const R>> auto cs2 = as_const(r).cend();
+            STATIC_ASSERT(is_same_v<const_sentinel_t<const R>, const_iterator_t<const R>> == common_range<const V>);
+            if constexpr (bidirectional_range<const R> && common_range<const R>) {
+                assert(*prev(cs2) == *prev(end(expected)));
+            }
+        }
+    }
+#endif // _HAS_CXX23
+
     // Validate view_interface::data
     STATIC_ASSERT(!CanData<TV>);
     STATIC_ASSERT(!CanData<const TV>);

From 717bdbdce0672c880f41b465893cd2a345c787d6 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:50:02 +0200
Subject: [PATCH 08/13] Add missing spaces

Comments:
* https://github.com/microsoft/STL/pull/3612#discussion_r1154896936
* https://github.com/microsoft/STL/pull/3612#discussion_r1154920955
---
 tests/std/tests/P0896R4_views_common/test.cpp  | 2 +-
 tests/std/tests/P0896R4_views_reverse/test.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P0896R4_views_common/test.cpp b/tests/std/tests/P0896R4_views_common/test.cpp
index 307c15b28d4..63226da4992 100644
--- a/tests/std/tests/P0896R4_views_common/test.cpp
+++ b/tests/std/tests/P0896R4_views_common/test.cpp
@@ -102,7 +102,7 @@ void non_literal_parts(R& r, E& expected) {
             }
         }
     }
-#endif //_HAS_CXX23
+#endif // _HAS_CXX23
 }
 
 template <class Rng, class Expected>
diff --git a/tests/std/tests/P0896R4_views_reverse/test.cpp b/tests/std/tests/P0896R4_views_reverse/test.cpp
index cff2dc65f1d..663c70e6ee1 100644
--- a/tests/std/tests/P0896R4_views_reverse/test.cpp
+++ b/tests/std/tests/P0896R4_views_reverse/test.cpp
@@ -285,7 +285,7 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
             assert(*prev(as_const(r).cend()) == *prev(end(expected)));
         }
     }
-#endif //_HAS_CXX23
+#endif // _HAS_CXX23
 
     // Validate view_interface::data
     static_assert(!CanData<R>);

From 89dec1ca84b858ec3b7fa83bbb519330a9d3f189 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:50:59 +0200
Subject: [PATCH 09/13] Fix incorrect condition: `bidirectional_iterator<R>` ->
 `bidirectional_range<R>`

Comment: https://github.com/microsoft/STL/pull/3612#discussion_r1154898358
---
 tests/std/tests/P0896R4_views_common/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P0896R4_views_common/test.cpp b/tests/std/tests/P0896R4_views_common/test.cpp
index 63226da4992..74d6c875ca9 100644
--- a/tests/std/tests/P0896R4_views_common/test.cpp
+++ b/tests/std/tests/P0896R4_views_common/test.cpp
@@ -88,7 +88,7 @@ void non_literal_parts(R& r, E& expected) {
     }
 
     const same_as<const_iterator_t<R>> auto clast = r.cend();
-    if constexpr (bidirectional_iterator<R>) {
+    if constexpr (bidirectional_range<R>) {
         if (!is_empty) {
             assert(*prev(clast) == *prev(end(expected)));
         }

From 32be8db6871a29bfbdfcc0633f96c444f3030bee Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:52:49 +0200
Subject: [PATCH 10/13] Add missing `const`

Comment: https://github.com/microsoft/STL/pull/3612#discussion_r1154916153
---
 tests/std/tests/P0896R4_views_common/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P0896R4_views_common/test.cpp b/tests/std/tests/P0896R4_views_common/test.cpp
index 74d6c875ca9..e3ea2748a91 100644
--- a/tests/std/tests/P0896R4_views_common/test.cpp
+++ b/tests/std/tests/P0896R4_views_common/test.cpp
@@ -95,7 +95,7 @@ void non_literal_parts(R& r, E& expected) {
     }
 
     if constexpr (CanCEnd<const R&>) {
-        const same_as<const_iterator_t<R>> auto clast2 = as_const(r).cend();
+        const same_as<const_iterator_t<const R>> auto clast2 = as_const(r).cend();
         if constexpr (bidirectional_range<const R>) {
             if (!is_empty) {
                 assert(*prev(clast2) == *prev(end(expected)));

From 9530f2f2974a1265ba01fd1bfcaa482a70127f93 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:53:44 +0200
Subject: [PATCH 11/13] Again, add missing `const`

Comment: https://github.com/microsoft/STL/pull/3612#discussion_r1154920788
---
 tests/std/tests/P0896R4_views_join/test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P0896R4_views_join/test.cpp b/tests/std/tests/P0896R4_views_join/test.cpp
index d8c99c98f1c..c5280696def 100644
--- a/tests/std/tests/P0896R4_views_join/test.cpp
+++ b/tests/std/tests/P0896R4_views_join/test.cpp
@@ -277,8 +277,8 @@ constexpr bool test_one(Outer&& rng, Expected&& expected) {
                     assert(*prev(cs2) == *prev(end(expected)));
 
                     if constexpr (copyable<V>) {
-                        const auto r2                               = r;
-                        const same_as<const_sentinel_t<R>> auto cs3 = r2.cend();
+                        const auto r2                                     = r;
+                        const same_as<const_sentinel_t<const R>> auto cs3 = r2.cend();
                         assert(*prev(cs3) == *prev(end(expected)));
                     }
                 }

From d99ba097ad48b6a1d1f5275d90f50597e7f73705 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:54:52 +0200
Subject: [PATCH 12/13] Improve conditions (`views::reverse`)

Comment: https://github.com/microsoft/STL/pull/3612#discussion_r1154923809
---
 tests/std/tests/P0896R4_views_reverse/test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P0896R4_views_reverse/test.cpp b/tests/std/tests/P0896R4_views_reverse/test.cpp
index 663c70e6ee1..9e239582476 100644
--- a/tests/std/tests/P0896R4_views_reverse/test.cpp
+++ b/tests/std/tests/P0896R4_views_reverse/test.cpp
@@ -250,7 +250,7 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
         }
 
         static_assert(CanMemberCBegin<const R> == common_range<Rng>);
-        if constexpr (common_range<Rng>) {
+        if constexpr (CanMemberCBegin<const R>) {
             const same_as<const_iterator<reverse_iterator<iterator_t<const V>>>> auto ci3 = as_const(r).cbegin();
             assert(as_const(r).cbegin() == ci3);
             assert(as_const(r).cbegin() == ci3);
@@ -281,7 +281,7 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
         }
 
         static_assert(CanMemberCEnd<const R> == common_range<Rng>);
-        if constexpr (common_range<Rng>) {
+        if constexpr (CanMemberCEnd<const R>) {
             assert(*prev(as_const(r).cend()) == *prev(end(expected)));
         }
     }

From 69b21c70a5439ae63743d92bec3418b5207c93de Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Fri, 31 Mar 2023 23:58:12 +0200
Subject: [PATCH 13/13] Add extra "Ditto" comment

Comment: https://github.com/microsoft/STL/pull/3612#discussion_r1154922796
---
 tests/std/tests/P0896R4_views_reverse/test.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/std/tests/P0896R4_views_reverse/test.cpp b/tests/std/tests/P0896R4_views_reverse/test.cpp
index 9e239582476..60ae11572b2 100644
--- a/tests/std/tests/P0896R4_views_reverse/test.cpp
+++ b/tests/std/tests/P0896R4_views_reverse/test.cpp
@@ -234,6 +234,7 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
     // Validate view_interface::cbegin
     static_assert(CanMemberCBegin<R>);
     {
+        // Ditto "let's make some extra calls because reverse_view sometimes caches begin"
         const same_as<const_iterator<reverse_iterator<iterator_t<V>>>> auto ci = r.cbegin();
         if (!is_empty) {
             assert(*ci == *begin(expected));