From 4a03ebee6bd2efe402536c0a2370070842f6074b Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Mon, 12 Jun 2023 17:08:15 +0200
Subject: [PATCH 01/13] Improve `std::mdspan` tests

---
 .../std/tests/P0009R18_mdspan_mdspan/test.cpp | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
index a0e16d63392..44580c94dd0 100644
--- a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
@@ -339,9 +339,12 @@ struct TrivialAccessor {
 static_assert(check_accessor_policy_requirements<TrivialAccessor<int>>());
 static_assert(is_trivial_v<TrivialAccessor<int>>);
 
-constexpr void check_modeled_concepts() {
-    using Mds = mdspan<long, extents<short, 4, 3, dynamic_extent>, TrackingLayout<layout_left>,
-        AccessorWithCustomOffsetPolicy<long>>;
+template <class Ext, class Layout, template <class> class AccessorTemplate>
+constexpr void check_modeled_concepts_and_member_types() {
+    using Accessor = AccessorTemplate<float>;
+    using Mds      = mdspan<float, Ext, Layout, Accessor>;
+
+    // Check modeled concepts
     static_assert(copyable<Mds>);
     static_assert(is_nothrow_move_constructible_v<Mds>);
     static_assert(is_nothrow_move_assignable_v<Mds>);
@@ -350,13 +353,8 @@ constexpr void check_modeled_concepts() {
         is_trivially_copyable_v<Mds>
         == (is_trivially_copyable_v<typename Mds::accessor_type> && is_trivially_copyable_v<typename Mds::mapping_type>
             && is_trivially_copyable_v<typename Mds::data_handle_type>) );
-}
 
-constexpr void check_member_types() {
-    using Ext      = extents<signed char, 2, 3, dynamic_extent, 7>;
-    using Layout   = layout_stride;
-    using Accessor = TrivialAccessor<float>;
-    using Mds      = mdspan<float, Ext, Layout, Accessor>;
+    // Check member types
     static_assert(same_as<typename Mds::extents_type, Ext>);
     static_assert(same_as<typename Mds::layout_type, Layout>);
     static_assert(same_as<typename Mds::accessor_type, Accessor>);
@@ -1319,8 +1317,10 @@ constexpr void check_deduction_guides() {
 }
 
 constexpr bool test() {
-    check_modeled_concepts();
-    check_member_types();
+    check_modeled_concepts_and_member_types<extents<signed char, 2, 3, 5>, layout_stride, TrivialAccessor>();
+    check_modeled_concepts_and_member_types<extents<unsigned short, 2, 4, dynamic_extent>, TrackingLayout<>,
+        AccessorWithTrackingDataHandle>();
+    check_modeled_concepts_and_member_types<dextents<unsigned long long, 3>, layout_left, TrackingAccessor>();
     check_observers();
     check_default_constructor();
     check_defaulted_copy_and_move_constructors();

From 4c3694cca7fac982db62b1fd30c6d48df7c950d9 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Mon, 12 Jun 2023 17:53:57 +0200
Subject: [PATCH 02/13] Improve `std::extents` tests

---
 tests/std/include/test_mdspan_support.hpp     |  26 +-
 .../tests/P0009R18_mdspan_extents/test.cpp    | 392 ++++++++++++++----
 2 files changed, 332 insertions(+), 86 deletions(-)

diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index 23b8902dc45..3163037be29 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -11,15 +11,35 @@
 #include <type_traits>
 #include <utility>
 
+enum class IsExplicit : bool { no, yes };
 enum class IsNothrow : bool { no, yes };
 
-template <std::integral Int, IsNothrow Nothrow = IsNothrow::yes>
+template <std::integral Int, IsNothrow Nothrow = IsNothrow::yes, IsExplicit Explicit = IsExplicit::no>
 struct ConvertibleToInt {
-    constexpr operator Int() const noexcept(std::to_underlying(Nothrow)) {
-        return Int{1};
+    Int val = 1;
+
+    constexpr explicit(std::to_underlying(Explicit)) operator Int() const noexcept(std::to_underlying(Nothrow)) {
+        return val;
     }
 };
 
+static_assert(std::is_aggregate_v<ConvertibleToInt<int>>);
+static_assert(std::is_convertible_v<ConvertibleToInt<int>, int>);
+static_assert(std::is_nothrow_convertible_v<ConvertibleToInt<int>, int>);
+static_assert(!std::is_nothrow_convertible_v<ConvertibleToInt<int, IsNothrow::no>, int>);
+static_assert(std::is_convertible_v<ConvertibleToInt<int, IsNothrow::no>, int>);
+static_assert(!std::is_convertible_v<ConvertibleToInt<int, IsNothrow::no, IsExplicit::yes>, int>);
+
+template <std::integral Int>
+struct NonConstConvertibleToInt {
+    constexpr operator Int() noexcept; // not defined
+};
+
+static_assert(std::is_convertible_v<NonConstConvertibleToInt<int>, int>);
+static_assert(!std::is_convertible_v<const NonConstConvertibleToInt<int>, int>);
+static_assert(std::is_nothrow_convertible_v<NonConstConvertibleToInt<int>, int>);
+static_assert(!std::is_nothrow_convertible_v<const NonConstConvertibleToInt<int>, int>);
+
 struct NonConvertibleToAnything {};
 
 namespace detail {
diff --git a/tests/std/tests/P0009R18_mdspan_extents/test.cpp b/tests/std/tests/P0009R18_mdspan_extents/test.cpp
index e7fa0109883..1ed2d2f5848 100644
--- a/tests/std/tests/P0009R18_mdspan_extents/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_extents/test.cpp
@@ -22,6 +22,13 @@ constexpr void check_members(index_sequence<Indices...>) {
     static_assert(regular<Ext>);
     static_assert(is_trivially_copyable_v<Ext>);
 
+    // Check implicit properties
+    static_assert(is_nothrow_copy_constructible_v<Ext>);
+    static_assert(is_nothrow_move_constructible_v<Ext>);
+    static_assert(is_nothrow_copy_assignable_v<Ext>);
+    static_assert(is_nothrow_move_assignable_v<Ext>);
+    static_assert(is_nothrow_swappable_v<Ext>);
+
     // Check member types
     static_assert(same_as<typename Ext::index_type, IndexType>);
     static_assert(same_as<typename Ext::size_type, make_unsigned_t<IndexType>>);
@@ -80,10 +87,42 @@ constexpr void check_members(index_sequence<Indices...>) {
     }
 }
 
+constexpr void check_defaulted_default_constructor() {
+    { // All extents are static
+        using Ext = extents<short, 3, 5, 7>;
+        static_assert(is_nothrow_default_constructible_v<Ext>);
+
+        Ext ext;
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 5);
+        assert(ext.extent(2) == 7);
+    }
+
+    { // Some extents are static, some dynamic
+        using Ext = extents<signed char, dynamic_extent, dynamic_extent, 4>;
+        static_assert(is_nothrow_default_constructible_v<Ext>);
+
+        Ext ext;
+        assert(ext.extent(0) == 0);
+        assert(ext.extent(1) == 0);
+        assert(ext.extent(2) == 4);
+    }
+
+    { // All extents are dynamic
+        using Ext = dextents<unsigned long, 3>;
+        static_assert(is_nothrow_default_constructible_v<Ext>);
+
+        Ext ext;
+        assert(ext.extent(0) == 0);
+        assert(ext.extent(1) == 0);
+        assert(ext.extent(2) == 0);
+    }
+}
+
 constexpr void check_construction_from_other_extents() {
     { // Check construction from too big or too small other extents
         using Ext = extents<int, 3, 3>;
-        static_assert(!is_constructible_v<Ext, int>);
+        static_assert(!is_constructible_v<Ext, extents<int, 3>>);
         static_assert(!is_constructible_v<Ext, extents<int, 3, 3, 3>>);
     }
 
@@ -95,17 +134,44 @@ constexpr void check_construction_from_other_extents() {
         static_assert(!is_constructible_v<extents<int, 3, 3>, extents<int, 3, 2>>);
     }
 
-    { // Check postconditions
-        extents<int, dynamic_extent, dynamic_extent> ext{4, 4};
-        extents<int, 4, 4> ext2{ext};
-        assert(ext == ext2);
-        assert(ext2.extent(0) == 4);
+    { // Check postconditions: static extents from static extents
+        extents<signed char, 3, 4> ext;
+        extents<short, 3, 4> ext2 = ext;
+        assert(ext2.extent(0) == 3);
         assert(ext2.extent(1) == 4);
+        assert(ext == ext2);
+    }
 
-        extents<long, 4, dynamic_extent> ext3{ext};
-        assert(ext == ext3);
-        assert(ext3.extent(0) == 4);
-        assert(ext3.extent(1) == 4);
+    { // Check postconditions: dynamic extents from static extents
+        extents<unsigned char, 2, 3> ext;
+        dextents<short, 2> ext2 = ext;
+        assert(ext2.extent(0) == 2);
+        assert(ext2.extent(1) == 3);
+        assert(ext == ext2);
+    }
+
+    { // Check postconditions: dynamic extents from dynamic extents
+        dextents<unsigned char, 2> ext{5, 10};
+        dextents<unsigned short, 2> ext2 = ext;
+        assert(ext2.extent(0) == 5);
+        assert(ext2.extent(1) == 10);
+        assert(ext == ext2);
+    }
+
+    { // Check postconditions: static extents from dynamic extents
+        dextents<signed char, 2> ext{9, 6};
+        extents<unsigned short, 9, 6> ext2{ext}; // NB: explicit constructor
+        assert(ext2.extent(0) == 9);
+        assert(ext2.extent(1) == 6);
+        assert(ext == ext2);
+    }
+
+    { // Check postconditions: wider index type to narrower index type
+        dextents<short, 2> ext{3, 5};
+        dextents<signed char, 2> ext2{ext}; // NB: explicit constructor
+        assert(ext2.extent(0) == 3);
+        assert(ext2.extent(1) == 5);
+        assert(ext == ext2);
     }
 
     { // Check implicit conversions
@@ -118,7 +184,7 @@ constexpr void check_construction_from_other_extents() {
 
 constexpr void check_construction_from_extents_pack() {
     { // Check construction from various types
-        using Ext = extents<int, 3, 3, dynamic_extent, dynamic_extent>;
+        using Ext = extents<signed char, 3, 3, dynamic_extent, dynamic_extent>;
         static_assert(is_nothrow_constructible_v<Ext, int, int>);
         static_assert(!is_constructible_v<Ext, int, int, int>);
         static_assert(is_nothrow_constructible_v<Ext, int, int, int, int>);
@@ -127,8 +193,10 @@ constexpr void check_construction_from_extents_pack() {
     { // Check construction from types (not) convertible to index_type
         using Ext = extents<long, 2, dynamic_extent>;
         static_assert(is_nothrow_constructible_v<Ext, ConvertibleToInt<int>>);
+        static_assert(!is_nothrow_constructible_v<Ext, ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>>);
         static_assert(!is_constructible_v<Ext, NonConvertibleToAnything>);
         static_assert(is_nothrow_constructible_v<Ext, int, ConvertibleToInt<int>>);
+        static_assert(!is_nothrow_constructible_v<Ext, int, ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>>);
         static_assert(!is_constructible_v<Ext, int, NonConvertibleToAnything>);
     }
 
@@ -138,15 +206,47 @@ constexpr void check_construction_from_extents_pack() {
         static_assert(!is_constructible_v<Ext, int, ConvertibleToInt<int, IsNothrow::no>>);
     }
 
-    { // Check postconditions
+    { // Check postconditions when 'sizeof...(pack) == rank()'
         using Ext = extents<int, dynamic_extent, dynamic_extent, 4>;
-        Ext ext1a{4, ConvertibleToInt<int>{}, 4};
-        Ext ext1b{4, 1, 4};
-        assert(ext1a == ext1b);
+        Ext ext{4, ConvertibleToInt<int>{.val = 4}, 4};
+        assert(ext.extent(0) == 4);
+        assert(ext.extent(1) == 4);
+        assert(ext.extent(2) == 4);
+        Ext ext2{4, 4, 4};
+        assert(ext == ext2);
+    }
 
-        Ext ext2a{4, ConvertibleToInt<int>{}};
-        Ext ext2b{4, 1};
-        assert(ext2a == ext2b);
+    { // Check postconditions when 'sizeof...(pack) == rank_dynamic()'
+        using Ext = extents<long long, dynamic_extent, dynamic_extent, 5>;
+        Ext ext{3, ConvertibleToInt<int>{.val = 3}};
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 3);
+        assert(ext.extent(2) == 5);
+        Ext ext2{3, 3};
+        assert(ext == ext2);
+    }
+
+    { // Check that elements from pack are passed through 'move'
+        using Ext = dextents<signed char, 3>;
+        struct FancyIndex {
+            constexpr operator integral auto() const& noexcept {
+                return 3;
+            }
+
+            constexpr operator integral auto() const&& noexcept {
+                return 3;
+            }
+
+            constexpr operator Ext::index_type() && noexcept {
+                return 4;
+            }
+        };
+
+        FancyIndex i;
+        Ext ext{FancyIndex{}, i, as_const(i)};
+        assert(ext.extent(0) == 4);
+        assert(ext.extent(1) == 4);
+        assert(ext.extent(2) == 4);
     }
 
     { // Check construction from integers with mismatched signs
@@ -167,48 +267,136 @@ constexpr void check_construction_from_extents_pack() {
 }
 
 constexpr void check_construction_from_array_and_span() {
-    { // Check construction from arrays/spans where [array/span].size() is equal to rank()
-        using Ext = extents<short, 1, dynamic_extent>;
-
-        array<int, 2> arr1 = {1, 5};
-        Ext ext1a{arr1};
-        span s1{arr1};
-        Ext ext1b{s1};
-        assert(ext1a == ext1b);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(arr1)>);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(s1)>);
-
-        array<ConvertibleToInt<int>, 2> arr2;
-        Ext ext2a{arr2};
-        span s2{arr2};
-        Ext ext2b{s2};
-        assert(ext2a == ext2b);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(arr2)>);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(s2)>);
+    { // Check construction from array/span where 'size()' is equal to 'rank()' and OtherIndexType models 'integral'
+        using Ext           = extents<short, 1, dynamic_extent>;
+        array<short, 2> arr = {1, 5};
+        Ext ext{arr};
+        assert(ext.extent(0) == 1);
+        assert(ext.extent(1) == 5);
+
+        Ext ext2{span{arr}};
+        assert(ext == ext2);
+
+        static_assert(is_nothrow_constructible_v<Ext, decltype(arr)>);
+        static_assert(is_nothrow_constructible_v<Ext, span<int, 2>>);
+    }
+
+    { // Check construction from array/span where 'size()' is equal to 'rank()' and OtherIndexType is class type
+        using Ext = extents<signed char, 3, dynamic_extent>;
+        array<ConvertibleToInt<int>, 2> arr{{{.val = 3}, {.val = 5}}};
+        Ext ext{arr};
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 5);
+
+        const span s{arr};
+        Ext ext2{s};
+        assert(ext == ext2);
+
+        static_assert(is_nothrow_constructible_v<Ext, decltype(arr)>);
+        static_assert(is_nothrow_constructible_v<Ext, decltype(s)>);
+    }
+
+    { // Check construction from array/span where 'size()' is equal to 'rank()' and OtherIndexType is "special"
+        using Ext = extents<unsigned int, dynamic_extent, 5>;
+        struct SpecialIndex {
+            constexpr operator integral auto() noexcept {
+                return 3;
+            }
 
+            constexpr operator integral auto() const noexcept {
+                return 5;
+            }
+        };
+
+        // Elements of 'arr' and 's' should be passed through 'as_const'
+        array<SpecialIndex, 2> arr;
+        Ext ext{arr};
+        assert(ext.extent(0) == 5);
+        assert(ext.extent(1) == 5);
+
+        span s{arr};
+        Ext ext2{s};
+        assert(ext == ext2);
+    }
+
+    { // Check invalid construction from array/span where 'size()' is equal to 'rank()'
+        using Ext = extents<long long, 3, dynamic_extent>;
+        static_assert(!is_constructible_v<Ext, array<ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>, 2>>);
+        static_assert(!is_constructible_v<Ext, array<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        static_assert(!is_constructible_v<Ext, array<NonConstConvertibleToInt<int>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<NonConstConvertibleToInt<int>, 2>>);
         static_assert(!is_constructible_v<Ext, array<NonConvertibleToAnything, 2>>);
         static_assert(!is_constructible_v<Ext, span<NonConvertibleToAnything, 2>>);
     }
 
-    { // Check construction from arrays/spans where [array/span].size() is equal to rank_dynamic()
-        using Ext = extents<unsigned char, 3, dynamic_extent, 3, dynamic_extent>;
+    { // Check construction from array/span where 'size()' is equal to 'rank_dynamic()' and OtherIndexType models
+      // 'integral'
+        using Ext         = extents<unsigned char, 3, dynamic_extent, 3, dynamic_extent>;
+        array<int, 2> arr = {4, 4};
+        Ext ext{arr};
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 4);
+        assert(ext.extent(2) == 3);
+        assert(ext.extent(3) == 4);
+
+        Ext ext2{span{arr}};
+        assert(ext == ext2);
+
+        static_assert(is_nothrow_constructible_v<Ext, decltype(arr)>);
+        static_assert(is_nothrow_constructible_v<Ext, span<int, 2>>);
+    }
 
-        array<int, 2> arr1 = {4, 4};
-        Ext ext1a{arr1};
-        span s1{arr1};
-        Ext ext1b{s1};
-        assert(ext1a == ext1b);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(arr1)>);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(s1)>);
+    { // Check construction from array/span where 'size()' is equal to 'rank_dynamic()' and OtherIndexType is class type
+        using Ext = extents<unsigned short, 3, dynamic_extent, 3, dynamic_extent>;
+        array<ConvertibleToInt<unsigned short>, 2> arr{{{.val = 2}, {.val = 2}}};
+        Ext ext{arr};
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 2);
+        assert(ext.extent(2) == 3);
+        assert(ext.extent(3) == 2);
 
-        array<ConvertibleToInt<int>, 2> arr2;
-        Ext ext2a{arr2};
-        span s2{arr2};
-        Ext ext2b{s2};
-        assert(ext2a == ext2b);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(arr2)>);
-        static_assert(is_nothrow_constructible_v<Ext, decltype(s2)>);
+        span s{arr};
+        Ext ext2{s};
+        assert(ext == ext2);
 
+        static_assert(is_nothrow_constructible_v<Ext, decltype(arr)>);
+        static_assert(is_nothrow_constructible_v<Ext, decltype(s)>);
+    }
+
+    { // Check construction from array/span where 'size()' is equal to 'rank_dynamic()' and OtherIndexType is "special"
+        using Ext = extents<unsigned int, dynamic_extent, dynamic_extent, 3>;
+        struct SpecialIndex {
+            constexpr operator integral auto() noexcept {
+                return 5;
+            }
+
+            constexpr operator integral auto() const noexcept {
+                return 3;
+            }
+        };
+
+        // Elements of 'arr' and 's' should be passed through 'as_const'
+        array<SpecialIndex, 2> arr;
+        Ext ext{arr};
+        assert(ext.extent(0) == 3);
+        assert(ext.extent(1) == 3);
+        assert(ext.extent(2) == 3);
+
+        span s{arr};
+        Ext ext2{s};
+        assert(ext == ext2);
+    }
+
+    { // Check invalid construction from array/span where 'size()' is equal to 'rank_dynamic()'
+        using Ext = extents<unsigned char, dynamic_extent, 5, dynamic_extent, 5>;
+        static_assert(!is_constructible_v<Ext, array<ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<ConvertibleToInt<int, IsNothrow::yes, IsExplicit::yes>, 2>>);
+        static_assert(!is_constructible_v<Ext, array<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        static_assert(!is_constructible_v<Ext, array<NonConstConvertibleToInt<int>, 2>>);
+        static_assert(!is_constructible_v<Ext, span<NonConstConvertibleToInt<int>, 2>>);
         static_assert(!is_constructible_v<Ext, array<NonConvertibleToAnything, 2>>);
         static_assert(!is_constructible_v<Ext, span<NonConvertibleToAnything, 2>>);
     }
@@ -228,15 +416,7 @@ constexpr void check_construction_from_array_and_span() {
 
         array arr = {4ll};
         (void) Ext{arr};
-
-        span s{arr};
-        (void) Ext{s};
-    }
-
-    { // Check construction from arrays/spans with elements that may throw during conversion to index_type
-        using Ext = extents<long, dynamic_extent, dynamic_extent>;
-        static_assert(!is_constructible_v<Ext, array<ConvertibleToInt<int, IsNothrow::no>, 2>>);
-        static_assert(!is_constructible_v<Ext, span<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        (void) Ext{span{arr}};
     }
 
     { // Check construction from arrays/spans with invalid size
@@ -262,27 +442,81 @@ constexpr void check_equality_operator() {
         extents<int, 3, 3> e1;
         extents<long, 2, 3> e2;
         extents<size_t, 3, 3> e3;
-        assert(e1 != e2);
+
+        same_as<bool> decltype(auto) cond = e1 != e2;
+        assert(cond);
         assert(e2 != e3);
         assert(e1 == e3);
+
+        static_assert(noexcept(e1 != e2));
+        static_assert(noexcept(e1 == e3));
     }
 
     { // Some extents are static, some dynamic
         extents<int, 3, dynamic_extent> e1{1};
         extents<long, dynamic_extent, 3> e2{2};
         extents<size_t, 2, dynamic_extent> e3{3};
-        assert(e1 != e2);
+
+        same_as<bool> decltype(auto) cond = e1 != e2;
+        assert(cond);
         assert(e2 == e3);
         assert(e1 != e2);
+
+        static_assert(noexcept(e1 != e2));
+        static_assert(noexcept(e2 == e3));
     }
 
     { // All extents are dynamic
         dextents<int, 2> e1{1, 2};
         dextents<long, 2> e2{1, 2};
         dextents<size_t, 2> e3{1, 3};
-        assert(e1 == e2);
+
+        same_as<bool> decltype(auto) cond = e1 == e2;
+        assert(cond);
         assert(e2 != e3);
         assert(e1 != e3);
+
+        static_assert(noexcept(e1 == e2));
+        static_assert(noexcept(e2 != e3));
+    }
+
+    { // Different ranks
+        static_assert(extents<int, 2, 3>{} != extents<short, 2>{});
+        static_assert(extents<int, 2, 2>{} != extents<long, 2, 3, 5>{});
+        static_assert(noexcept(extents<int, 2, 3>{} != extents<short, 2>{}));
+        static_assert(noexcept(extents<int, 2, 2>{} != extents<long, 2, 3, 5>{}));
+    }
+}
+
+template <class... Args>
+concept CanDeduceExtents = requires(Args&&... args) { extents{forward<Args>(args)...}; };
+
+template <class T, size_t ExpectedRank>
+constexpr bool all_extents_dynamic = false;
+
+template <class IndexType, size_t... Extents, size_t ExpectedRank>
+constexpr bool all_extents_dynamic<extents<IndexType, Extents...>, ExpectedRank> =
+    ((Extents == dynamic_extent) && ...) && (sizeof...(Extents) == ExpectedRank);
+
+constexpr void check_deduction_guide() {
+    { // Check 'CanDeduceExtents' concept
+        static_assert(CanDeduceExtents<signed char, short, int, long, long long>);
+        static_assert(CanDeduceExtents<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>);
+        static_assert(CanDeduceExtents<int, ConvertibleToInt<int>, int>);
+        static_assert(!CanDeduceExtents<int, ConvertibleToInt<int, IsNothrow::no>, int>);
+        static_assert(!CanDeduceExtents<int, NonConvertibleToAnything, int>);
+    }
+
+    { // Check correctness
+        extents ext{'1', 2, 3u, 4ll, ConvertibleToInt<size_t>{.val = 5}};
+        assert(ext.extent(0) == '1');
+        assert(ext.extent(1) == 2);
+        assert(ext.extent(2) == 3);
+        assert(ext.extent(3) == 4);
+        assert(ext.extent(4) == 5);
+
+        static_assert(all_extents_dynamic<decltype(ext), 5>);
+        static_assert(same_as<decltype(ext)::index_type, size_t>);
     }
 }
 
@@ -290,35 +524,27 @@ constexpr bool test() {
     check_members_with_various_extents([]<class IndexType, size_t... Extents>(const extents<IndexType, Extents...>&) {
         check_members<IndexType, Extents...>(make_index_sequence<sizeof...(Extents)>{});
     });
+    check_defaulted_default_constructor();
     check_construction_from_other_extents();
     check_construction_from_extents_pack();
     check_construction_from_array_and_span();
     check_equality_operator();
+    check_deduction_guide();
 
     return true;
 }
 
-template <class T, size_t ExpectedRank>
-constexpr bool all_extents_dynamic = false;
-
-template <class IndexType, size_t... Extents, size_t ExpectedRank>
-constexpr bool all_extents_dynamic<extents<IndexType, Extents...>, ExpectedRank> =
-    ((Extents == dynamic_extent) && ...) && (sizeof...(Extents) == ExpectedRank);
-
-template <class... Args>
-concept CanDeduceExtents = requires(Args&&... args) { extents{forward<Args>(args)...}; };
-
-// Check deduction guide
-using DG = decltype(extents{'1', 2, 3u, 4ll, ConvertibleToInt<size_t>{}});
-static_assert(all_extents_dynamic<DG, 5>);
-static_assert(same_as<DG::index_type, size_t>);
-static_assert(!CanDeduceExtents<int, long, short, NonConvertibleToAnything>);
-
 // Check dextents
 static_assert(all_extents_dynamic<dextents<signed char, 0>, 0>);
-static_assert(all_extents_dynamic<dextents<unsigned short, 2>, 2>);
-static_assert(all_extents_dynamic<dextents<int, 3>, 3>);
-static_assert(all_extents_dynamic<dextents<unsigned long, 5>, 5>);
+static_assert(all_extents_dynamic<dextents<short, 1>, 1>);
+static_assert(all_extents_dynamic<dextents<int, 2>, 2>);
+static_assert(all_extents_dynamic<dextents<long, 3>, 3>);
+static_assert(all_extents_dynamic<dextents<long long, 4>, 4>);
+static_assert(all_extents_dynamic<dextents<unsigned char, 5>, 5>);
+static_assert(all_extents_dynamic<dextents<unsigned short, 6>, 6>);
+static_assert(all_extents_dynamic<dextents<unsigned int, 7>, 7>);
+static_assert(all_extents_dynamic<dextents<unsigned long, 8>, 8>);
+static_assert(all_extents_dynamic<dextents<unsigned long long, 9>, 9>);
 
 int main() {
     static_assert(test());

From c34c10708e39f9ffe0d14cfc7deac640c5fa2013 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 12:19:11 +0200
Subject: [PATCH 03/13] Improve `std::layout_left` tests

---
 tests/std/include/test_mdspan_support.hpp     |  80 ++++++++++
 .../P0009R18_mdspan_layout_left/test.cpp      | 140 ++++++++++++++++--
 2 files changed, 208 insertions(+), 12 deletions(-)

diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index 3163037be29..ff55ef3fe19 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -4,12 +4,15 @@
 #pragma once
 
 #include <algorithm>
+#include <array>
 #include <concepts>
 #include <cstddef>
 #include <mdspan>
+#include <ranges>
 #include <span>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 enum class IsExplicit : bool { no, yes };
 enum class IsNothrow : bool { no, yes };
@@ -227,3 +230,80 @@ constexpr void check_members_with_various_extents(Fn&& fn) {
     details::check_members_with_various_extents_impl(std::forward<Fn>(fn), std::make_index_sequence<16>{});
 #endif // _PREFAST_
 }
+
+namespace details {
+    static constexpr bool permissive() {
+        return false;
+    }
+
+    template <class>
+    struct PermissiveTestBase {
+        static constexpr bool permissive() {
+            return true;
+        }
+    };
+
+    template <class T>
+    struct PermissiveTest : PermissiveTestBase<T> {
+        static constexpr bool test() {
+            return permissive();
+        }
+    };
+} // namespace details
+
+inline constexpr bool is_permissive = details::PermissiveTest<int>::test();
+
+template <class Mapping>
+struct MappingProperties {
+    typename Mapping::index_type req_span_size;
+    bool uniqueness;
+    bool exhaustiveness;
+    bool strideness;
+};
+
+template <class Mapping>
+    requires (!details::PermissiveTest<Mapping>::test())
+constexpr MappingProperties<Mapping> get_mapping_properties(const Mapping& mapping) {
+    constexpr typename Mapping::index_type zero = 0;
+
+    auto make_cartesian_prod = [&]<size_t... Indices>(std::index_sequence<Indices...>) {
+        return std::views::cartesian_product(std::views::iota(zero, mapping.extents().extent(Indices))...);
+    };
+
+    auto indices =
+        make_cartesian_prod(std::make_index_sequence<Mapping::extents_type::rank()>{})
+        | std::views::transform([&](auto tpl) { return std::apply([&](auto... i) { return mapping(i...); }, tpl); })
+        | std::ranges::to<std::vector>();
+    std::ranges::sort(indices);
+
+    MappingProperties<Mapping> props;
+
+    { // Find required span size (N4950 [mdspan.layout.reqmts]/12)
+        auto exts = std::views::iota(0u, Mapping::extents_type::rank())
+                  | std::views::transform([&](auto i) { return mapping.extents().extent(i); });
+        if (std::ranges::contains(exts, zero)) {
+            props.req_span_size = 0;
+        } else {
+            props.req_span_size = static_cast<Mapping::index_type>(1 + indices.back());
+        }
+    }
+
+    // Is mapping unique? (N4950 [mdspan.layout.reqmts]/14)
+    props.uniqueness = !std::ranges::contains(std::views::pairwise_transform(indices, std::minus{}), zero);
+
+    { // Is mapping exhaustive? (N4950 [mdspan.layout.reqmts]/16)
+        const auto diffs     = std::views::pairwise_transform(indices, [](auto x, auto y) { return y - x; });
+        props.exhaustiveness = std::ranges::find_if_not(diffs, [](auto x) { return x == 1; }) == diffs.end();
+    }
+
+    // Is mapping strided? FIXME (N4950 [mdspan.layout.reqmts]/18)
+    props.strideness = true;
+
+    return props;
+}
+
+template <class Mapping>
+    requires (details::PermissiveTest<Mapping>::test())
+constexpr MappingProperties<Mapping> get_mapping_properties(const Mapping&) {
+    return {}; // we cannot get properties in '/permissive' mode
+}
diff --git a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
index d585c455b10..e8711c62f05 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
@@ -34,17 +34,26 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     static_assert(same_as<typename Mapping::layout_type, layout_left>);
 
     { // Check default and copy constructor
-        Mapping m;
+        const Mapping m;
         Mapping cpy = m;
         assert(cpy == m);
         static_assert(is_nothrow_default_constructible_v<Mapping>);
         static_assert(is_nothrow_copy_constructible_v<Mapping>);
     }
 
+    { // Check copy assignment operator
+        const Mapping m;
+        Mapping cpy;
+        cpy = m;
+        assert(cpy == m);
+        static_assert(is_nothrow_copy_assignable_v<Ext>);
+    }
+
     { // Check construction from extents_type
         Mapping m{ext};
         assert(m.extents() == ext);
         static_assert(is_nothrow_constructible_v<Mapping, Ext>);
+        // Other tests are defined in 'check_construction_from_extents' function
     }
 
     using OtherIndexType = long long;
@@ -75,6 +84,9 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         // Other tests are defined in 'check_construction_from_other_right_mapping' function
     }
 
+#ifdef __clang__
+    if (!is_constant_evaluated()) // FIXME clang hits contexpr limit here
+#endif
     { // Check construction from layout_stride::mapping
         array<IndexType, Ext::rank()> strides{};
         if constexpr (Ext::rank() > 0) {
@@ -87,9 +99,9 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
             }
         }
 
-        using StrideMapping = layout_stride::mapping<Ext>;
-        StrideMapping stride_mapping{ext, strides};
-        [[maybe_unused]] Mapping m{stride_mapping};
+        layout_stride::mapping<Ext> m1{ext, span{strides}};
+        Mapping m2{m1};
+        assert(m1.extents() == m2.extents());
         // Other tests are defined in 'check_construction_from_other_stride_mapping' function
     }
 
@@ -101,9 +113,10 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 
     { // Check 'required_span_size' function
-        const IndexType expected_value = static_cast<IndexType>((ext.extent(Indices) * ... * 1));
-        assert(m.required_span_size() == expected_value);
+        same_as<IndexType> decltype(auto) rss = m.required_span_size();
+        assert(rss == static_cast<IndexType>((ext.extent(Indices) * ... * 1)));
         static_assert(noexcept(m.required_span_size()));
+        // Other tests are defined in 'check_mapping_properties'
     }
 
     { // Check operator()
@@ -124,6 +137,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         static_assert(Mapping::is_unique());
         static_assert(Mapping::is_exhaustive());
         static_assert(Mapping::is_strided());
+        // Other tests are defined in 'check_mapping_properties'
     }
 
     if constexpr (Ext::rank() > 0) { // Check 'stride' function
@@ -133,6 +147,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         assert(m.stride(0) == 1);
         static_assert(noexcept(m.stride(Ext::rank() - 1)));
         static_assert(noexcept(m.stride(0)));
+        // Other tests are defined in 'check_stride_function'
     } else {
         static_assert(!CheckStrideMemberFunction<Mapping>);
     }
@@ -144,6 +159,44 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 }
 
+constexpr void check_mapping_properties() {
+    auto check = [](const auto& mapping) {
+        const auto props = get_mapping_properties(mapping);
+        if constexpr (!is_permissive) {
+            assert(props.req_span_size == mapping.required_span_size());
+            assert(props.uniqueness);
+            assert(props.exhaustiveness);
+            assert(props.strideness);
+        }
+    };
+
+    using M1 = layout_left::mapping<extents<int, 2, 3, 5>>;
+    check(M1{});
+
+    using M2 = layout_left::mapping<extents<unsigned long, 8, dynamic_extent, 5>>;
+    check(M2{M2::extents_type{6}});
+
+    using M3 = layout_left::mapping<dextents<signed char, 4>>;
+    check(M3{M3::extents_type{3, 5, 4, 2}});
+}
+
+constexpr void check_construction_from_extents() {
+    using Ext = extents<int, 2, 4, 6>;
+    Ext ext;
+
+    { // Check construction from 'extents_type'
+        layout_left::mapping<Ext> mp(ext);
+        assert(mp.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(mp), Ext>);
+    }
+
+    { // Check construction from other extents
+        layout_left::mapping<extents<long, dynamic_extent, 4, dynamic_extent>> mp(ext);
+        assert(mp.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(mp), Ext>);
+    }
+}
+
 constexpr void check_construction_from_other_left_mapping() {
     { // Check invalid construction
         using Mapping = layout_left::mapping<extents<int, 3, 3>>;
@@ -161,14 +214,23 @@ constexpr void check_construction_from_other_left_mapping() {
         static_assert(NotImplicitlyConstructibleFrom<layout_left::mapping<extents<int, 3, 3>>,
             layout_left::mapping<extents<int, dynamic_extent, dynamic_extent>>>);
     }
+
+    { // Check effects
+        layout_left::mapping<extents<int, 5, 3, 5>> m1;
+        layout_left::mapping<dextents<short, 3>> m2{m1};
+        assert(m2.extents().extent(0) == 5);
+        assert(m2.extents().extent(1) == 3);
+        assert(m2.extents().extent(2) == 5);
+        assert(m1.extents() == m2.extents());
+    }
 }
 
 constexpr void check_construction_from_other_right_mapping() {
     { // Check construction from layout_right::mapping<E> with various values of E::rank()
-        static_assert(
-            is_constructible_v<layout_left::mapping<dextents<int, 0>>, layout_right::mapping<dextents<int, 0>>>);
-        static_assert(
-            is_constructible_v<layout_left::mapping<dextents<int, 1>>, layout_right::mapping<dextents<int, 1>>>);
+        static_assert(is_nothrow_constructible_v<layout_left::mapping<dextents<int, 0>>,
+            layout_right::mapping<dextents<int, 0>>>);
+        static_assert(is_nothrow_constructible_v<layout_left::mapping<dextents<int, 1>>,
+            layout_right::mapping<dextents<int, 1>>>);
         static_assert(
             !is_constructible_v<layout_left::mapping<dextents<int, 2>>, layout_right::mapping<dextents<int, 2>>>);
         static_assert(
@@ -189,6 +251,12 @@ constexpr void check_construction_from_other_right_mapping() {
         static_assert(NotImplicitlyConstructibleFrom<layout_left::mapping<extents<int, 3>>,
             layout_right::mapping<extents<int, dynamic_extent>>>);
     }
+
+    { // Check effects
+        layout_right::mapping<extents<int, 8>> m1;
+        layout_left::mapping<dextents<signed char, 1>> m2{m1};
+        assert(m2.extents().extent(0) == 8);
+    }
 }
 
 constexpr void check_construction_from_other_stride_mapping() {
@@ -211,8 +279,13 @@ constexpr void check_construction_from_other_stride_mapping() {
 
     { // Check correctness
         using Ext = extents<int, 4, 3, 2, 3, 4>;
-        layout_stride::mapping<Ext> stride_mapping{Ext{}, array{1, 4, 12, 24, 72}};
-        [[maybe_unused]] layout_left::mapping<Ext> m{stride_mapping};
+        layout_stride::mapping<Ext> m1{Ext{}, array{1, 4, 12, 24, 72}};
+        layout_left::mapping<Ext> m2{m1};
+        assert(m2.extents().extent(0) == 4);
+        assert(m2.extents().extent(1) == 3);
+        assert(m2.stride(2) == 12);
+        assert(m2.stride(3) == 24);
+        assert(m2.extents() == m1.extents());
     }
 
     { // Check implicit conversions
@@ -271,6 +344,35 @@ constexpr void check_call_operator() {
     }
 }
 
+constexpr void check_stride_function() {
+    layout_left::mapping<extents<unsigned short, 2, 3, 5, 7, 11>> prime_mapping;
+
+    { // Check return type
+        same_as<unsigned short> decltype(auto) s = prime_mapping.stride(0);
+        assert(s == 1);
+    }
+
+    { // Check that argument is 'rank_type'
+        struct ConvertibleToRankType {
+            constexpr operator integral auto() const {
+                return 0;
+            }
+
+            constexpr operator size_t() const { // NB: 'rank_type' is always 'size_t'
+                return 1;
+            }
+        };
+
+        assert(prime_mapping.stride(ConvertibleToRankType{}) == 2); // 1 * 2
+    }
+
+    { // Check other strides
+        assert(prime_mapping.stride(2) == 6);
+        assert(prime_mapping.stride(3) == 30);
+        assert(prime_mapping.stride(4) == 210);
+    }
+}
+
 constexpr void check_comparisons() {
     using StaticMapping  = layout_left::mapping<extents<int, 3>>;
     using DynamicMapping = layout_left::mapping<dextents<int, 1>>;
@@ -291,6 +393,14 @@ constexpr void check_comparisons() {
     }
 }
 
+constexpr void check_ctad() {
+    using Ext = extents<long, 3, 3>;
+    layout_left::mapping m{Ext{}};
+    static_assert(same_as<decltype(m), layout_left::mapping<Ext>>);
+    assert(m.extents().extent(0) == 3);
+    assert(m.stride(1) == 3);
+}
+
 constexpr void check_correctness() {
     { // empty extents
         const array<int, 0> values{};
@@ -385,11 +495,17 @@ constexpr bool test() {
         []<class IndexType, size_t... Extents>(const extents<IndexType, Extents...>& ext) {
             check_members(ext, make_index_sequence<sizeof...(Extents)>{});
         });
+    if (!is_constant_evaluated()) { // too heavy for compile time
+        check_mapping_properties();
+    }
+    check_construction_from_extents();
     check_construction_from_other_left_mapping();
     check_construction_from_other_right_mapping();
     check_construction_from_other_stride_mapping();
     check_call_operator();
+    check_stride_function();
     check_comparisons();
+    check_ctad();
     check_correctness();
 
     return true;

From 8b5e4b03b237a6c09a013c6441623fa49415bf95 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 13:10:38 +0200
Subject: [PATCH 04/13] Improve `std::layout_right` tests

---
 stl/inc/mdspan                                |   3 +-
 .../P0009R18_mdspan_layout_right/test.cpp     | 152 +++++++++++++++---
 2 files changed, 132 insertions(+), 23 deletions(-)

diff --git a/stl/inc/mdspan b/stl/inc/mdspan
index 2a0f9b289ab..bd7420639aa 100644
--- a/stl/inc/mdspan
+++ b/stl/inc/mdspan
@@ -549,7 +549,8 @@ public:
 
     template <class _OtherExtents>
         requires is_constructible_v<extents_type, _OtherExtents>
-    constexpr explicit(extents_type::rank() > 0) mapping(const layout_stride::template mapping<_OtherExtents>& _Other)
+    constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::template mapping<_OtherExtents>& _Other) noexcept
         : _Exts(_Other.extents()) {
         if constexpr (extents_type::rank() > 0) {
             const bool _Verify = [&]<size_t... _Indices>(index_sequence<_Indices...>) {
diff --git a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
index dd67099a7a1..d94f05a0784 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
@@ -34,24 +34,35 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     static_assert(same_as<typename Mapping::layout_type, layout_right>);
 
     { // Check default and copy constructor
-        Mapping m;
+        const Mapping m;
         Mapping cpy = m;
         assert(cpy == m);
         static_assert(is_nothrow_default_constructible_v<Mapping>);
         static_assert(is_nothrow_copy_constructible_v<Mapping>);
     }
 
+    { // Check copy assignment operator
+        const Mapping m;
+        Mapping cpy;
+        cpy = m;
+        assert(cpy == m);
+        static_assert(is_nothrow_copy_assignable_v<Ext>);
+    }
+
     { // Check construction from extents_type
         Mapping m{ext};
         assert(m.extents() == ext);
         static_assert(is_nothrow_constructible_v<Mapping, Ext>);
+        // Other tests are defined in 'check_construction_from_extents' function
     }
 
     using OtherIndexType = long long;
     using Ext2           = extents<OtherIndexType, Extents...>;
     using Mapping2       = layout_right::mapping<Ext2>;
 
-#ifndef __clang__ // FIXME, Clang suddenly cannot digest this
+#ifdef __clang__
+    if (!is_constant_evaluated()) // FIXME clang hits contexpr limit here
+#endif
     { // Check construction from other layout_right::mapping
         Mapping m1{ext};
         Mapping2 m2{m1};
@@ -59,7 +70,6 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         static_assert(is_nothrow_constructible_v<Mapping2, Mapping>);
         // Other tests are defined in 'check_construction_from_other_right_mapping' function
     }
-#endif // __clang__
 
     { // Check construction from layout_left::mapping
         using LeftMapping = layout_left::mapping<Ext>;
@@ -89,9 +99,9 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
             }
         }
 
-        using StrideMapping = layout_stride::mapping<Ext>;
-        StrideMapping stride_mapping{ext, strides};
-        [[maybe_unused]] Mapping m{stride_mapping};
+        layout_stride::mapping<Ext> m1{ext, strides};
+        Mapping m2{m1};
+        assert(m1.extents() == m2.extents());
         // Other tests are defined in 'check_construction_from_other_stride_mapping' function
     }
 
@@ -103,9 +113,10 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 
     { // Check 'required_span_size' function
-        const IndexType expected_value = static_cast<IndexType>((ext.extent(Indices) * ... * 1));
-        assert(m.required_span_size() == expected_value);
+        same_as<IndexType> decltype(auto) rss = m.required_span_size();
+        assert(rss == static_cast<IndexType>((ext.extent(Indices) * ... * 1)));
         static_assert(noexcept(m.required_span_size()));
+        // Other tests are defined in 'check_mapping_properties'
     }
 
     { // Check operator()
@@ -126,6 +137,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         static_assert(Mapping::is_unique());
         static_assert(Mapping::is_exhaustive());
         static_assert(Mapping::is_strided());
+        // Other tests are defined in 'check_mapping_properties'
     }
 
     if constexpr (Ext::rank() > 0) { // Check 'stride' function
@@ -134,6 +146,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         assert(m.stride(Ext::rank() - 1) == 1);
         static_assert(noexcept(m.stride(Ext::rank() - 1)));
         static_assert(noexcept(m.stride(0)));
+        // Other tests are defined in 'check_stride_function'
     } else {
         static_assert(!CheckStrideMemberFunction<Mapping>);
     }
@@ -145,6 +158,44 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 }
 
+constexpr void check_mapping_properties() {
+    auto check = [](const auto& mapping) {
+        const auto props = get_mapping_properties(mapping);
+        if constexpr (!is_permissive) {
+            assert(props.req_span_size == mapping.required_span_size());
+            assert(props.uniqueness);
+            assert(props.exhaustiveness);
+            assert(props.strideness);
+        }
+    };
+
+    using M1 = layout_right::mapping<extents<int, 7, 11, 13>>;
+    check(M1{});
+
+    using M2 = layout_right::mapping<extents<unsigned long, dynamic_extent, 4, dynamic_extent>>;
+    check(M2{M2::extents_type{2, 6}});
+
+    using M3 = layout_right::mapping<dextents<unsigned char, 4>>;
+    check(M3{M3::extents_type{4, 3, 5, 4}});
+}
+
+constexpr void check_construction_from_extents() {
+    using Ext = extents<int, 6, 4, 2>;
+    Ext ext;
+
+    { // Check construction from 'extents_type'
+        layout_right::mapping<Ext> mp(ext);
+        assert(mp.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(mp), Ext>);
+    }
+
+    { // Check construction from other extents
+        layout_right::mapping<extents<long, dynamic_extent, 4, dynamic_extent>> mp(ext);
+        assert(mp.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(mp), Ext>);
+    }
+}
+
 constexpr void check_construction_from_other_right_mapping() {
     { // Check invalid construction
         using Mapping = layout_right::mapping<extents<int, 3, 3>>;
@@ -166,10 +217,10 @@ constexpr void check_construction_from_other_right_mapping() {
 
 constexpr void check_construction_from_other_left_mapping() {
     { // Check construction from layout_left::mapping<E> with various values of E::rank()
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 0>>, layout_left::mapping<dextents<int, 0>>>);
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 1>>, layout_left::mapping<dextents<int, 1>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 0>>,
+            layout_left::mapping<dextents<int, 0>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 1>>,
+            layout_left::mapping<dextents<int, 1>>>);
         static_assert(
             !is_constructible_v<layout_right::mapping<dextents<int, 2>>, layout_left::mapping<dextents<int, 2>>>);
         static_assert(
@@ -188,18 +239,27 @@ constexpr void check_construction_from_other_left_mapping() {
         static_assert(NotImplicitlyConstructibleFrom<Mapping, layout_left::mapping<extents<long long, 4>>>);
         static_assert(NotImplicitlyConstructibleFrom<Mapping, layout_left::mapping<extents<int, dynamic_extent>>>);
     }
+
+    { // Check effects
+        layout_right::mapping<extents<unsigned int, 6, 2, 6>> m1;
+        layout_right::mapping<dextents<unsigned short, 3>> m2{m1};
+        assert(m2.extents().extent(0) == 6);
+        assert(m2.extents().extent(1) == 2);
+        assert(m2.extents().extent(2) == 6);
+        assert(m1.extents() == m2.extents());
+    }
 }
 
 constexpr void check_construction_from_other_stride_mapping() {
     { // Check construction from layout_stride::mapping<E> with various values of E::rank()
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 0>>, layout_stride::mapping<dextents<int, 0>>>);
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 1>>, layout_stride::mapping<dextents<int, 1>>>);
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 2>>, layout_stride::mapping<dextents<int, 2>>>);
-        static_assert(
-            is_constructible_v<layout_right::mapping<dextents<int, 3>>, layout_stride::mapping<dextents<int, 3>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 0>>,
+            layout_stride::mapping<dextents<int, 0>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 1>>,
+            layout_stride::mapping<dextents<int, 1>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 2>>,
+            layout_stride::mapping<dextents<int, 2>>>);
+        static_assert(is_nothrow_constructible_v<layout_right::mapping<dextents<int, 3>>,
+            layout_stride::mapping<dextents<int, 3>>>);
     }
 
     { // Check construction from layout_stride::mapping<E> when E is invalid
@@ -210,8 +270,13 @@ constexpr void check_construction_from_other_stride_mapping() {
 
     { // Check correctness
         using Ext = extents<int, 4, 3, 2, 3, 4>;
-        layout_stride::mapping<Ext> stride_mapping{Ext{}, array{72, 24, 12, 4, 1}};
-        [[maybe_unused]] layout_right::mapping<Ext> m{stride_mapping};
+        layout_stride::mapping<Ext> m1{Ext{}, array{72, 24, 12, 4, 1}};
+        layout_right::mapping<Ext> m2{m1};
+        assert(m2.extents().extent(0) == 4);
+        assert(m2.extents().extent(1) == 3);
+        assert(m2.stride(2) == 12);
+        assert(m2.stride(3) == 4);
+        assert(m2.extents() == m1.extents());
     }
 
     { // Check implicit conversions
@@ -272,6 +337,35 @@ constexpr void check_call_operator() {
     }
 }
 
+constexpr void check_stride_function() {
+    layout_right::mapping<extents<unsigned short, 2, 3, 5, 7, 11>> prime_mapping;
+
+    { // Check return type
+        same_as<unsigned short> decltype(auto) s = prime_mapping.stride(0);
+        assert(s == 1155); // 11 * 7 * 5 * 3
+    }
+
+    { // Check that argument is 'rank_type'
+        struct ConvertibleToRankType {
+            constexpr operator integral auto() const {
+                return 0;
+            }
+
+            constexpr operator size_t() const { // NB: 'rank_type' is always 'size_t'
+                return 1;
+            }
+        };
+
+        assert(prime_mapping.stride(ConvertibleToRankType{}) == 385); // 11 * 7 * 5
+    }
+
+    { // Check other strides
+        assert(prime_mapping.stride(2) == 77);
+        assert(prime_mapping.stride(3) == 11);
+        assert(prime_mapping.stride(4) == 1);
+    }
+}
+
 constexpr void check_comparisons() {
     using StaticMapping  = layout_right::mapping<extents<int, 4, 4>>;
     using DynamicMapping = layout_right::mapping<dextents<int, 2>>;
@@ -292,6 +386,14 @@ constexpr void check_comparisons() {
     }
 }
 
+constexpr void check_ctad() {
+    using Ext = extents<long, 5, 5>;
+    layout_right::mapping m{Ext{}};
+    static_assert(same_as<decltype(m), layout_right::mapping<Ext>>);
+    assert(m.extents().extent(0) == 5);
+    assert(m.stride(1) == 1);
+}
+
 constexpr void check_correctness() {
     { // empty extents
         const array<int, 0> vals{};
@@ -416,11 +518,17 @@ constexpr bool test() {
         []<class IndexType, size_t... Extents>(const extents<IndexType, Extents...>& ext) {
             check_members(ext, make_index_sequence<sizeof...(Extents)>{});
         });
+    if (!is_constant_evaluated()) { // too heavy for compile time
+        check_mapping_properties();
+    }
+    check_construction_from_extents();
     check_construction_from_other_right_mapping();
     check_construction_from_other_left_mapping();
     check_construction_from_other_stride_mapping();
     check_call_operator();
+    check_stride_function();
     check_comparisons();
+    check_ctad();
     check_correctness();
 
     return true;

From 265440556cd1e0f5b037515c7e2753beb3551252 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 13:11:04 +0200
Subject: [PATCH 05/13] Drive-by: include `"test_mdspan_support.hpp"` instead
 of `<test_mdspan_support.hpp>`

---
 tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp | 2 +-
 tests/std/tests/P0009R18_mdspan_mdspan/test.cpp           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
index 9036a910c75..f22101c0f7c 100644
--- a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
@@ -9,7 +9,7 @@
 #include <string>
 #include <type_traits>
 
-#include <test_mdspan_support.hpp>
+#include "test_mdspan_support.hpp"
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
index 44580c94dd0..b323b09621c 100644
--- a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
@@ -13,7 +13,7 @@
 #include <utility>
 #include <vector>
 
-#include <test_mdspan_support.hpp>
+#include "test_mdspan_support.hpp"
 
 using namespace std;
 

From 73e4fb08084281e1ef03ea8f529a0d5bb7a45dc5 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 14:13:29 +0200
Subject: [PATCH 06/13] Improve `std::layout_stride` tests

---
 .../P0009R18_mdspan_layout_stride/test.cpp    | 248 +++++++++++++-----
 1 file changed, 184 insertions(+), 64 deletions(-)

diff --git a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
index ec4ea0711a9..13ab33b6139 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
@@ -44,7 +44,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
     static_assert(same_as<typename Mapping::layout_type, layout_stride>);
 
     { // Check default and copy constructor
-        Mapping m;
+        const Mapping m;
         const Mapping cpy = m;
         const layout_right::mapping<Ext> right_mapping;
         assert(m == right_mapping);
@@ -53,12 +53,20 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
         static_assert(is_nothrow_copy_constructible_v<Mapping>);
     }
 
+    { // Check copy assignment operator
+        const Mapping m;
+        Mapping cpy;
+        cpy = m;
+        assert(cpy == m);
+        static_assert(is_nothrow_copy_assignable_v<Ext>);
+    }
+
     { // Check construction from extents_type and array
         Mapping m{ext, strs};
         assert(m.extents() == ext);
         assert(ranges::equal(m.strides(), strs, CmpEqual{}));
         static_assert(is_nothrow_constructible_v<Mapping, Ext, Strides>);
-        // Other tests are defined in 'check_construction_from_extents_and_array' function
+        // Other tests are defined in 'check_construction_from_extents_and_array_or_span' function
     }
 
     { // Check construction from extents_type and span
@@ -67,7 +75,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
         assert(m.extents() == ext);
         assert(ranges::equal(m.strides(), strs, CmpEqual{}));
         static_assert(is_nothrow_constructible_v<Mapping, Ext, Span>);
-        // Other tests are defined in 'check_construction_from_extents_and_array' function
+        // Other tests are defined in 'check_construction_from_extents_and_array_or_span' function
     }
 
     using OtherIndexType = long long;
@@ -94,6 +102,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
         same_as<Strides> decltype(auto) strs2 = m.strides();
         assert(ranges::equal(strs2, strs, CmpEqual{}));
         static_assert(noexcept(m.strides()));
+        // Other tests are defined in 'check_stride_function'
     }
 
     { // Check 'required_span_size' function
@@ -105,7 +114,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
             assert(m.required_span_size() == expected_value);
         }
         static_assert(noexcept(m.required_span_size()));
-        // Other tests are defined in 'check_required_span_size' function
+        // Other tests are defined in 'check_required_span_size' and 'check_mapping_properties' functions
     }
 
     // Call operator() is tested in 'check_call_operator' function
@@ -120,6 +129,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
         static_assert(Mapping::is_unique());
         static_assert(Mapping::is_strided());
         // Tests of 'is_exhaustive' are defined in 'check_is_exhaustive' function
+        // Other tests are defined in 'check_mapping_properties'
     }
 
     { // Check 'stride' function
@@ -164,35 +174,99 @@ constexpr void check_members(extents<IndexType, Extents...> ext, const array<int
     check_members_with_different_strides_index_type<unsigned long long>(ext, strides);
 }
 
-constexpr void check_construction_from_extents_and_array() {
-    // Check invalid construction
-    using Mapping = layout_stride::mapping<extents<int, 3, 3>>;
-    static_assert(!is_constructible_v<Mapping, extents<int, 2, 3>, array<int, 2>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<int, 3>>);
-    static_assert(!is_constructible_v<Mapping, dextents<int, 2>, array<int, 2>>);
-    static_assert(!is_constructible_v<Mapping, dextents<int, 2>, array<int, 3>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 2, 3>, span<int, 2>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<int, 3>>);
-    static_assert(!is_constructible_v<Mapping, dextents<int, 2>, span<int, 2>>);
-    static_assert(!is_constructible_v<Mapping, dextents<int, 2>, span<int, 3>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<NonConvertibleToAnything, 2>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<NonConvertibleToAnything, 2>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<ConvertibleToInt<int, IsNothrow::no>, 2>>);
-    static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+constexpr void check_mapping_properties() {
+    auto check = [](const auto& mapping, [[maybe_unused]] const bool expected_exhaustiveness) {
+        const auto props = get_mapping_properties(mapping);
+        if constexpr (!is_permissive) {
+            assert(props.req_span_size == mapping.required_span_size());
+            assert(props.uniqueness);
+            assert(props.exhaustiveness == expected_exhaustiveness);
+            assert(props.exhaustiveness == mapping.is_exhaustive());
+            assert(props.strideness);
+        }
+    };
+
+    { // Check exhaustive mappings
+        using M1 = layout_stride::mapping<extents<unsigned int, 4, 2, 3>>;
+        check(M1{M1::extents_type{}, array{6, 1, 2}}, true);
+
+        using M2 = layout_stride::mapping<extents<unsigned long long, dynamic_extent, dynamic_extent, 8>>;
+        check(M2{M2::extents_type{6, 7}, array{1, 48, 6}}, true);
+
+        using M3 = layout_stride::mapping<dextents<short, 4>>;
+        check(M3{M3::extents_type{3, 5, 2, 4}, array{20, 1, 60, 5}}, true);
+    }
+
+    { // Check non-exhaustive mappings
+        using M1 = layout_stride::mapping<extents<int, 2, 4, 3>>;
+        check(M1{M1::extents_type{}, array{9, 18, 1}}, false);
+
+        using M2 = layout_stride::mapping<extents<long long, 3, dynamic_extent, dynamic_extent>>;
+        check(M2{M2::extents_type{4, 3}, array{12, 36, 1}}, false);
+
+        using M3 = layout_stride::mapping<dextents<unsigned short, 3>>;
+        check(M3{M3::extents_type{4, 3, 2}, array{8, 32, 2}}, false);
+    }
+}
+
+constexpr void check_construction_from_extents_and_array_or_span() {
+    { // Check invalid construction
+        using Mapping = layout_stride::mapping<extents<int, 3, 3>>;
+        static_assert(!is_constructible_v<Mapping, extents<int, 2, 3>, array<int, 2>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 2, 3>, span<int, 2>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<int, 3>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<int, 3>>);
+        static_assert(!is_constructible_v<Mapping, dextents<int, 2>, array<int, 2>>);
+        static_assert(!is_constructible_v<Mapping, dextents<int, 2>, span<int, 2>>);
+        static_assert(!is_constructible_v<Mapping, dextents<int, 2>, array<int, 3>>);
+        static_assert(!is_constructible_v<Mapping, dextents<int, 2>, span<int, 3>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<NonConvertibleToAnything, 2>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<NonConvertibleToAnything, 2>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, array<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+        static_assert(!is_constructible_v<Mapping, extents<int, 3, 3>, span<ConvertibleToInt<int, IsNothrow::no>, 2>>);
+    }
+
+    using Ext = extents<int, 2, 4, 6>;
+    Ext ext;
+
+    { // Check construction from 'extents_type'
+        array strs{24, 1, 4};
+        layout_stride::mapping<Ext> m1(ext, strs);
+        assert(m1.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(m1), Ext, decltype(strs)>);
+
+        span s{strs};
+        layout_stride::mapping<Ext> m2(ext, s);
+        assert(m2.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(m2), Ext, decltype(s)>);
+    }
+
+    { // Check construction from other extents
+        using Ext2 = extents<long, dynamic_extent, 4, dynamic_extent>;
+
+        const array strs{1, 12, 2};
+        layout_stride::mapping<Ext2> m1(ext, strs);
+        assert(m1.extents() == ext);
+        static_assert(is_nothrow_constructible_v<decltype(m1), Ext, decltype(strs)>);
+
+        const span s{strs};
+        layout_stride::mapping<Ext2> m2(ext, s);
+        static_assert(is_nothrow_constructible_v<decltype(m2), Ext, decltype(s)>);
+    }
 }
 
 constexpr void check_construction_from_other_mappings() {
-    { // Check construction
+    { // Check valid construction
         using Mapping = layout_stride::mapping<extents<int, 4, 4>>;
-        static_assert(is_constructible_v<Mapping, layout_left::mapping<extents<int, 4, 4>>>);
-        static_assert(is_constructible_v<Mapping, layout_right::mapping<extents<int, 4, 4>>>);
-        static_assert(is_constructible_v<Mapping, layout_left::mapping<extents<long, 4, 4>>>);
-        static_assert(is_constructible_v<Mapping, layout_right::mapping<extents<long, 4, 4>>>);
-        static_assert(is_constructible_v<Mapping, layout_stride::mapping<extents<long, 4, 4>>>);
+        static_assert(is_nothrow_constructible_v<Mapping, layout_left::mapping<extents<int, 4, 4>>>);
+        static_assert(is_nothrow_constructible_v<Mapping, layout_right::mapping<extents<int, 4, 4>>>);
+        static_assert(is_nothrow_constructible_v<Mapping, layout_left::mapping<extents<long, 4, 4>>>);
+        static_assert(is_nothrow_constructible_v<Mapping, layout_right::mapping<extents<long, 4, 4>>>);
+        static_assert(is_nothrow_constructible_v<Mapping, layout_stride::mapping<extents<long, 4, 4>>>);
     }
 
     { // Check invalid construction
-        using Mapping = layout_stride::mapping<extents<int, 4, 4>>;
+        using Mapping = layout_stride::mapping<extents<unsigned int, 4, 4>>;
         static_assert(!is_constructible_v<Mapping, layout_left::mapping<extents<int, 4, 3>>>);
         static_assert(!is_constructible_v<Mapping, layout_right::mapping<extents<int, 3, 4>>>);
         static_assert(!is_constructible_v<Mapping, layout_left::mapping<extents<long, 4, 4, 4>>>);
@@ -328,6 +402,36 @@ constexpr void check_call_operator() {
     }
 }
 
+constexpr void check_stride_function() {
+    using Ext = extents<unsigned int, 2, 4, 6, 8, 10>;
+    layout_stride::mapping<Ext> even_mapping{Ext{}, array{80, 160, 640, 1, 8}};
+
+    { // Check return type
+        same_as<unsigned int> decltype(auto) s = even_mapping.stride(0);
+        assert(s == 80);
+    }
+
+    { // Check that argument is 'rank_type'
+        struct ConvertibleToRankType {
+            constexpr operator integral auto() const {
+                return 0;
+            }
+
+            constexpr operator size_t() const { // NB: 'rank_type' is always 'size_t'
+                return 1;
+            }
+        };
+
+        assert(even_mapping.stride(ConvertibleToRankType{}) == 160);
+    }
+
+    { // Check other strides
+        assert(even_mapping.stride(2) == 640);
+        assert(even_mapping.stride(3) == 1);
+        assert(even_mapping.stride(4) == 8);
+    }
+}
+
 constexpr void check_comparisons() {
     using E                    = extents<int, 2, 3>;
     using StaticStrideMapping  = layout_stride::mapping<E>;
@@ -351,7 +455,8 @@ constexpr void check_comparisons() {
     { // Check correctness: layout_stride::mapping with layout_stride::mapping
         StaticStrideMapping m1{E{}, array{3, 1}};
         DynamicStrideMapping m2{dextents<int, 2>{2, 3}, array{3, 1}};
-        assert(m1 == m2); // extents are equal, OFFSET(rhs) == 0, strides are equal
+        same_as<bool> decltype(auto) cond = m1 == m2;
+        assert(cond); // extents are equal, OFFSET(rhs) == 0, strides are equal
 
         DynamicStrideMapping m3{dextents<int, 2>{2, 3}, array{1, 2}};
         assert(m1 != m3); // extents are equal, OFFSET(rhs) == 0, strides are not equal
@@ -363,12 +468,16 @@ constexpr void check_comparisons() {
         assert(m3 != m4); // extents are not equal, OFFSET(rhs) == 0, strides are not equal
 
         // NB: OFFSET(layout_stride::mapping) is always equal to 0
+
+        static_assert(noexcept(m1 == m2));
+        static_assert(noexcept(m1 != m3));
     }
 
     { // Check correctness: layout_stride::mapping with layout_left::mapping
         LeftMapping m1;
         StaticStrideMapping m2{E{}, array{1, 2}};
-        assert(m1 == m2); // extents are equal, OFFSET(rhs) == 0, strides are equal
+        same_as<bool> decltype(auto) cond = m1 == m2;
+        assert(cond); // extents are equal, OFFSET(rhs) == 0, strides are equal
 
         DynamicStrideMapping m3{dextents<int, 2>{2, 3}, array{3, 1}};
         assert(m1 != m3); // extents are equal, OFFSET(rhs) == 0, strides are not equal
@@ -380,12 +489,16 @@ constexpr void check_comparisons() {
         assert(m3 != m4); // extents are not equal, OFFSET(rhs) == 0, strides are not equal
 
         // NB: OFFSET(layout_left::mapping) is always equal to 0
+
+        static_assert(noexcept(m1 == m2));
+        static_assert(noexcept(m1 != m3));
     }
 
     { // Check correctness: layout_stride::mapping with layout_right::mapping
         RightMapping m1;
         StaticStrideMapping m2{E{}, array{3, 1}};
-        assert(m1 == m2); // extents are equal, OFFSET(rhs) == 0, strides are equal
+        same_as<bool> decltype(auto) cond = m1 == m2;
+        assert(cond); // extents are equal, OFFSET(rhs) == 0, strides are equal
 
         DynamicStrideMapping m3{dextents<int, 2>{2, 3}, array{1, 2}};
         assert(m1 != m3); // extents are equal, OFFSET(rhs) == 0, strides are not equal
@@ -397,11 +510,47 @@ constexpr void check_comparisons() {
         assert(m3 != m4); // extents are not equal, OFFSET(rhs) == 0, strides are not equal
 
         // NB: OFFSET(layout_right::mapping) is always equal to 0
+
+        static_assert(noexcept(m1 == m2));
+        static_assert(noexcept(m1 != m3));
     }
 
     // TRANSITION, Check comparisons with custom layout mapping
 }
 
+constexpr void check_ctad() {
+    using E = extents<size_t, 2, 3>;
+    E e;
+
+    { // E::index_type and array::value_type are the same
+        array<size_t, 2> a{1, 2};
+        layout_stride::mapping m1{e, a};
+        static_assert(same_as<decltype(m1), layout_stride::mapping<E>>);
+        assert(m1.extents() == e);
+        assert(m1.strides() == a);
+
+        span s{a};
+        layout_stride::mapping m2{e, s};
+        static_assert(same_as<decltype(m2), layout_stride::mapping<E>>);
+        assert(m2.extents() == e);
+        assert(m2.strides() == a);
+    }
+
+    { // E::index_type and array::value_type are different
+        array<int, 2> a{1, 2};
+        layout_stride::mapping m1{e, a};
+        static_assert(same_as<decltype(m1), layout_stride::mapping<E>>);
+        assert(m1.extents() == e);
+        assert(ranges::equal(m1.strides(), a, CmpEqual{}));
+
+        span s{a};
+        layout_stride::mapping m2{e, s};
+        static_assert(same_as<decltype(m2), layout_stride::mapping<E>>);
+        assert(m2.extents() == e);
+        assert(ranges::equal(m2.strides(), a, CmpEqual{}));
+    }
+}
+
 constexpr void check_correctness() {
     { // empty extents
         const array<int, 0> vals{};
@@ -535,39 +684,6 @@ constexpr void check_correctness() {
     }
 }
 
-constexpr void check_ctad() {
-    using E = extents<size_t, 2, 3>;
-    E e;
-
-    { // E::index_type and array::value_type are the same
-        array<size_t, 2> a{1, 2};
-        layout_stride::mapping m1{e, a};
-        static_assert(same_as<decltype(m1), layout_stride::mapping<E>>);
-        assert(m1.extents() == e);
-        assert(m1.strides() == a);
-
-        span s{a};
-        layout_stride::mapping m2{e, s};
-        static_assert(same_as<decltype(m2), layout_stride::mapping<E>>);
-        assert(m2.extents() == e);
-        assert(m2.strides() == a);
-    }
-
-    { // E::index_type and array::value_type are different
-        array<int, 2> a{1, 2};
-        layout_stride::mapping m1{e, a};
-        static_assert(same_as<decltype(m1), layout_stride::mapping<E>>);
-        assert(m1.extents() == e);
-        assert(ranges::equal(m1.strides(), a, CmpEqual{}));
-
-        span s{a};
-        layout_stride::mapping m2{e, s};
-        static_assert(same_as<decltype(m2), layout_stride::mapping<E>>);
-        assert(m2.extents() == e);
-        assert(ranges::equal(m2.strides(), a, CmpEqual{}));
-    }
-}
-
 constexpr bool test() {
     // Check signed integers
     check_members(extents<signed char, 5>{5}, array{1});
@@ -583,14 +699,18 @@ constexpr bool test() {
     check_members(extents<unsigned long, 4>{}, array{1});
     check_members(extents<unsigned long long, 3, 2, dynamic_extent>{3}, array{1, 3, 6});
 
-    check_construction_from_extents_and_array();
+    if (!is_constant_evaluated()) { // too heavy for compile time
+        check_mapping_properties();
+    }
+    check_construction_from_extents_and_array_or_span();
     check_construction_from_other_mappings();
     check_required_span_size();
     check_is_exhaustive();
     check_call_operator();
+    check_stride_function();
     check_comparisons();
-    check_correctness();
     check_ctad();
+    check_correctness();
 
     return true;
 }

From 22270e79b824ae406f0b62e9309110c879b61ddf Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 14:13:55 +0200
Subject: [PATCH 07/13] Remove old tests

---
 tests/std/test.lst                       |    1 -
 tests/std/tests/P0009R18_mdspan/env.lst  |    4 -
 tests/std/tests/P0009R18_mdspan/test.cpp | 1094 ----------------------
 3 files changed, 1099 deletions(-)
 delete mode 100644 tests/std/tests/P0009R18_mdspan/env.lst
 delete mode 100644 tests/std/tests/P0009R18_mdspan/test.cpp

diff --git a/tests/std/test.lst b/tests/std/test.lst
index 018e7f0a004..af17e49329e 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -233,7 +233,6 @@ tests\LWG3422_seed_seq_ctors
 tests\LWG3480_directory_iterator_range
 tests\LWG3545_pointer_traits_sfinae
 tests\LWG3610_iota_view_size_and_integer_class
-tests\P0009R18_mdspan
 tests\P0009R18_mdspan_default_accessor
 tests\P0009R18_mdspan_extents
 tests\P0009R18_mdspan_extents_death
diff --git a/tests/std/tests/P0009R18_mdspan/env.lst b/tests/std/tests/P0009R18_mdspan/env.lst
deleted file mode 100644
index 18e2d7c71ec..00000000000
--- a/tests/std/tests/P0009R18_mdspan/env.lst
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P0009R18_mdspan/test.cpp b/tests/std/tests/P0009R18_mdspan/test.cpp
deleted file mode 100644
index 28ea7b5acae..00000000000
--- a/tests/std/tests/P0009R18_mdspan/test.cpp
+++ /dev/null
@@ -1,1094 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <algorithm>
-#include <cassert>
-#include <concepts>
-#include <mdspan>
-#include <type_traits>
-#include <vector>
-
-using namespace std;
-
-// A type that's regular and trivially copyable, and also maximally nothrow.
-template <class T>
-using is_regular_trivial_nothrow = std::conjunction<std::bool_constant<std::regular<T>>, is_trivially_copyable<T>,
-    is_nothrow_default_constructible<T>, is_nothrow_copy_constructible<T>, is_nothrow_move_constructible<T>,
-    is_nothrow_copy_assignable<T>, is_nothrow_move_assignable<T>, is_nothrow_swappable<T>>;
-
-template <class T>
-inline constexpr bool is_regular_trivial_nothrow_v = is_regular_trivial_nothrow<T>::value;
-
-struct Constructible {
-    // noexcept constructible for size_t, but not convertible
-    explicit operator size_t() noexcept;
-};
-
-struct Convertible {
-    // convertible, but not noexcept constructible
-    operator size_t();
-};
-
-struct ConstructibleAndConvertible {
-    // convertible and noexcept constructible
-    constexpr operator size_t() noexcept {
-        return size_t{2};
-    }
-};
-
-struct ConstructibleAndConvertibleConst {
-    // convertible and noexcept constructible
-    constexpr operator size_t() const noexcept {
-        return size_t{2};
-    }
-};
-
-
-void extent_tests_traits() {
-    static_assert(is_regular_trivial_nothrow_v<extents<size_t>>);
-    static_assert(is_regular_trivial_nothrow_v<extents<size_t, 2, 3>>);
-    static_assert(is_regular_trivial_nothrow_v<extents<size_t, dynamic_extent, 3>>);
-    static_assert(is_regular_trivial_nothrow_v<extents<size_t, 2, dynamic_extent>>);
-    static_assert(is_regular_trivial_nothrow_v<extents<size_t, dynamic_extent, dynamic_extent>>);
-
-    static_assert(is_same_v<dextents<size_t, 1>, extents<size_t, dynamic_extent>>);
-    static_assert(is_same_v<dextents<size_t, 2>, extents<size_t, dynamic_extent, dynamic_extent>>);
-    static_assert(is_same_v<dextents<short, 1>, extents<short, dynamic_extent>>);
-    static_assert(is_same_v<dextents<short, 2>, extents<short, dynamic_extent, dynamic_extent>>);
-
-    constexpr extents e(2, 3);
-    static_assert(is_same_v<remove_cvref_t<decltype(e)>, dextents<size_t, 2>>);
-    static_assert(e.static_extent(0) == dynamic_extent);
-    static_assert(e.static_extent(1) == dynamic_extent);
-    static_assert(e.extent(0) == 2);
-    static_assert(e.extent(1) == 3);
-
-    constexpr dextents<int, 1> ex0(1);
-    (void) ex0;
-    static_assert(!is_constructible_v<dextents<int, 1>, int*>);
-
-    extents<signed char>();
-    extents<unsigned char>();
-    extents<short>();
-    extents<unsigned short>();
-    extents<int>();
-    extents<unsigned int>();
-    extents<long>();
-    extents<unsigned long>();
-    extents<long long>();
-    extents<unsigned long long>();
-}
-
-void extent_tests_rank() {
-    static_assert(extents<size_t>::rank() == 0);
-    static_assert(extents<size_t>::rank_dynamic() == 0);
-
-    static_assert(extents<size_t, 2>::rank() == 1);
-    static_assert(extents<size_t, 2>::rank_dynamic() == 0);
-
-    static_assert(extents<size_t, dynamic_extent>::rank() == 1);
-    static_assert(extents<size_t, dynamic_extent>::rank_dynamic() == 1);
-
-    static_assert(extents<size_t, 2, 3>::rank() == 2);
-    static_assert(extents<size_t, 2, 3>::rank_dynamic() == 0);
-
-    static_assert(extents<size_t, 2, dynamic_extent>::rank() == 2);
-    static_assert(extents<size_t, 2, dynamic_extent>::rank_dynamic() == 1);
-
-    static_assert(extents<size_t, dynamic_extent, 3>::rank() == 2);
-    static_assert(extents<size_t, dynamic_extent, 3>::rank_dynamic() == 1);
-
-    static_assert(extents<size_t, dynamic_extent, dynamic_extent>::rank() == 2);
-    static_assert(extents<size_t, dynamic_extent, dynamic_extent>::rank_dynamic() == 2);
-}
-
-void extent_tests_static_extent() {
-    static_assert(extents<size_t, 2, 3>::static_extent(0) == 2);
-    static_assert(extents<size_t, 2, 3>::static_extent(1) == 3);
-
-    static_assert(extents<size_t, 2, dynamic_extent>::static_extent(0) == 2);
-    static_assert(extents<size_t, 2, dynamic_extent>::static_extent(1) == dynamic_extent);
-
-    static_assert(extents<size_t, dynamic_extent, 3>::static_extent(0) == dynamic_extent);
-    static_assert(extents<size_t, dynamic_extent, 3>::static_extent(1) == 3);
-
-    static_assert(extents<size_t, dynamic_extent, dynamic_extent>::static_extent(0) == dynamic_extent);
-    static_assert(extents<size_t, dynamic_extent, dynamic_extent>::static_extent(1) == dynamic_extent);
-}
-
-void extent_tests_extent() {
-    constexpr extents<size_t, 2, 3> e_23;
-    static_assert(e_23.extent(0) == 2);
-    static_assert(e_23.extent(1) == 3);
-
-    constexpr extents<size_t, 2, dynamic_extent> e_2d{3};
-    static_assert(e_2d.extent(0) == 2);
-    static_assert(e_2d.extent(1) == 3);
-
-    constexpr extents<size_t, dynamic_extent, dynamic_extent> e_dd{2, 3};
-    static_assert(e_dd.extent(0) == 2);
-    static_assert(e_dd.extent(1) == 3);
-
-    constexpr extents<size_t, 2, dynamic_extent, dynamic_extent> e_2dd{3, 5};
-    static_assert(e_2dd.extent(0) == 2);
-    static_assert(e_2dd.extent(1) == 3);
-    static_assert(e_2dd.extent(2) == 5);
-}
-
-void extent_tests_ctor_other_sizes() {
-    static_assert(!is_constructible_v<extents<size_t, 2>, Constructible>);
-    static_assert(!is_constructible_v<extents<size_t, 2>, Convertible>);
-    static_assert(is_constructible_v<extents<size_t, 2>, ConstructibleAndConvertible>);
-    [[maybe_unused]] constexpr extents<size_t, 2> ex0{ConstructibleAndConvertible{}};
-    static_assert(is_constructible_v<extents<size_t, 2>, ConstructibleAndConvertibleConst>);
-    [[maybe_unused]] constexpr extents<size_t, 2> ex1{ConstructibleAndConvertibleConst{}};
-
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, int>);
-    [[maybe_unused]] constexpr extents<int, dynamic_extent, 2, 2> ex2(1);
-    static_assert(!is_constructible_v<extents<int, dynamic_extent, 2, 2>, int, int>);
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, int, int, int>);
-    [[maybe_unused]] extents<int, dynamic_extent, 2, 3> ex3(1, 2, 3);
-
-    extents<size_t, 2, 3> e0;
-    assert(e0.extent(0) == 2);
-    assert(e0.extent(1) == 3);
-
-    extents<size_t, 2, dynamic_extent> e1(5);
-    assert(e1.extent(0) == 2);
-    assert(e1.extent(1) == 5);
-
-    extents<size_t, dynamic_extent, 3> e2(5);
-    assert(e2.extent(0) == 5);
-    assert(e2.extent(1) == 3);
-
-    extents<size_t, dynamic_extent, dynamic_extent> e3(5, 7);
-    assert(e3.extent(0) == 5);
-    assert(e3.extent(1) == 7);
-}
-
-void extent_tests_copy_ctor_other() {
-    // Rank and value of static extents must match.
-    static_assert(!is_constructible_v<extents<size_t, 2>, extents<size_t, 2, 3>>);
-    static_assert(!is_constructible_v<extents<size_t, 2, 3>, extents<size_t, 2>>);
-    static_assert(!is_constructible_v<extents<size_t, 2, 3>, extents<size_t, 3, 2>>);
-
-    // Static extents are constructible, but not convertible, from dynamic extents.
-    static_assert(is_constructible_v<extents<size_t, 2, 3>, extents<size_t, 2, dynamic_extent>>);
-    constexpr extents<size_t, 2, 3> ex0{extents<size_t, 2, dynamic_extent>{3}};
-    (void) ex0;
-    static_assert(!is_convertible_v<extents<size_t, 2, dynamic_extent>, extents<size_t, 2, 3>>);
-
-    // Dynamic extents are constructible and convertible from static extents.
-    static_assert(is_constructible_v<extents<size_t, 2, dynamic_extent>, extents<size_t, 2, 3>>);
-    extents<size_t, 2, dynamic_extent>{extents<size_t, 2, 3>{}};
-    static_assert(is_convertible_v<extents<size_t, 2, 3>, extents<size_t, 2, dynamic_extent>>);
-
-    // Can implicitly convert from narrower to wider size_type, but not vice-versa.
-    static_assert(is_convertible_v<extents<uint32_t, dynamic_extent>, extents<uint64_t, dynamic_extent>>);
-    static_assert(!is_convertible_v<extents<uint64_t, dynamic_extent>, extents<uint32_t, dynamic_extent>>);
-
-    extents<size_t, 2, dynamic_extent> e_dyn(3);
-    extents<size_t, 2, 3> e(e_dyn);
-    (void) e;
-
-    using E = extents<size_t, 2, 3>;
-
-    extents<size_t, 2, 3> e0{extents<size_t, 2, 3>{}};
-    E e1(extents<size_t, dynamic_extent, 3>(2u));
-    extents<size_t, 2, 3> e2{extents<size_t, 2, dynamic_extent>{3u}};
-    extents<size_t, 2, 3> e3{extents<size_t, dynamic_extent, dynamic_extent>{2u, 3u}};
-
-    (void) e0;
-    (void) e1;
-    (void) e2;
-    (void) e3;
-}
-
-template <class T, class IndexType, size_t N, class = void>
-struct is_array_cons_avail : std::false_type {};
-
-template <class T, class IndexType, size_t N>
-struct is_array_cons_avail<T, IndexType, N,
-    std::enable_if_t<std::is_same<decltype(T{std::declval<std::array<IndexType, N>>()}), T>::value>> : std::true_type {
-};
-
-template <class T, class IndexType, size_t N>
-constexpr bool is_array_cons_avail_v = is_array_cons_avail<T, IndexType, N>::value;
-
-void extent_tests_ctor_array() {
-    static_assert(!is_constructible_v<extents<size_t, 2>, array<Constructible, 1>>);
-    static_assert(!is_constructible_v<extents<size_t, 2>, array<Convertible, 1>>);
-    static_assert(!is_constructible_v<extents<size_t, 2>, array<ConstructibleAndConvertible, 1>>);
-    static_assert(is_constructible_v<extents<size_t, 2>, array<ConstructibleAndConvertibleConst, 1>>);
-    constexpr extents<size_t, 2> ex0{array<ConstructibleAndConvertibleConst, 1>{}};
-    (void) ex0;
-
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, array<int, 1>>);
-    constexpr extents<int, dynamic_extent, 2, 2> ex1{array<int, 1>{}};
-    static_assert(!is_constructible_v<extents<int, dynamic_extent, 2, 2>, array<int, 2>>);
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, array<int, 3>>);
-    constexpr extents<int, dynamic_extent, 2, 2> ex2{array<int, 3>{1, 2, 2}};
-    (void) ex1;
-    (void) ex2;
-
-    static_assert(is_constructible_v<extents<int, 10>, array<int, 0>>);
-    constexpr extents<int, 10> ex3{array<int, 0>{}};
-    static_assert(is_constructible_v<extents<int, 10>, array<int, 1>>);
-    constexpr extents<int, 10> ex4{array<int, 1>{10}};
-    static_assert(!is_constructible_v<extents<int, 10>, array<int, 2>>);
-    (void) ex3;
-    (void) ex4;
-
-    extents<size_t, 2, 3> e0;
-    assert(e0.extent(0) == 2u);
-    assert(e0.extent(1) == 3u);
-
-    // native extent::size_type
-    extents<size_t, 2, dynamic_extent> e1(to_array<size_t>({5}));
-    assert(e1.extent(0) == 2u);
-    assert(e1.extent(1) == 5u);
-
-    extents<size_t, dynamic_extent, 3> e2(to_array<size_t>({5}));
-    assert(e2.extent(0) == 5u);
-    assert(e2.extent(1) == 3u);
-
-    extents<size_t, dynamic_extent, dynamic_extent> e3(to_array<size_t>({5, 7}));
-    assert(e3.extent(0) == 5u);
-    assert(e3.extent(1) == 7u);
-
-    // convertible size type
-    extents<size_t, 2, dynamic_extent> e4(to_array<int>({5}));
-    assert(e4.extent(0) == 2u);
-    assert(e4.extent(1) == 5u);
-
-    extents<size_t, dynamic_extent, 3> e5(to_array<int>({5}));
-    assert(e5.extent(0) == 5u);
-    assert(e5.extent(1) == 3u);
-
-    extents<size_t, dynamic_extent, dynamic_extent> e6(to_array<int>({5, 7}));
-    assert(e6.extent(0) == 5u);
-    assert(e6.extent(1) == 7u);
-}
-
-void extent_tests_ctor_span() {
-    static_assert(!is_constructible_v<extents<size_t, 2>, span<Constructible, 1>>);
-    static_assert(!is_constructible_v<extents<size_t, 2>, span<Convertible, 1>>);
-    static_assert(!is_constructible_v<extents<size_t, 2>, span<ConstructibleAndConvertible, 1>>);
-    static_assert(is_constructible_v<extents<size_t, 2>, span<ConstructibleAndConvertibleConst, 1>>);
-    ConstructibleAndConvertibleConst arr0[1] = {{}};
-    constexpr extents<size_t, 2> ex0{span<ConstructibleAndConvertibleConst, 1>{arr0}};
-    (void) ex0;
-
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, span<int, 1>>);
-    constexpr int arr1[1] = {1};
-    constexpr extents<int, dynamic_extent, 2, 2> ex1{span<const int, 1>{arr1}};
-    static_assert(!is_constructible_v<extents<int, dynamic_extent, 2, 2>, span<int, 2>>);
-    static_assert(is_constructible_v<extents<int, dynamic_extent, 2, 2>, span<int, 3>>);
-    constexpr int arr2[3] = {3, 2, 2};
-    constexpr extents<int, dynamic_extent, 2, 2> ex2{span<const int, 3>{arr2}};
-    (void) ex1;
-    (void) ex2;
-
-
-    extents<size_t, 2, 3> e0;
-    assert(e0.extent(0) == 2u);
-    assert(e0.extent(1) == 3u);
-
-    // native extent::size_type
-    constexpr int one_int[] = {5};
-    constexpr int two_int[] = {5, 7};
-    extents<size_t, 2, dynamic_extent> e1(span{one_int});
-    assert(e1.extent(0) == 2);
-    assert(e1.extent(1) == 5);
-
-    extents<size_t, dynamic_extent, 3> e2(span{one_int});
-    assert(e2.extent(0) == 5);
-    assert(e2.extent(1) == 3);
-
-    extents<size_t, dynamic_extent, dynamic_extent> e3(span{two_int});
-    assert(e3.extent(0) == 5);
-    assert(e3.extent(1) == 7);
-
-    // convertible size type
-    constexpr size_t one_sizet[] = {5};
-    constexpr size_t two_sizet[] = {5, 7};
-    extents<size_t, 2, dynamic_extent> e4(span{one_sizet});
-    assert(e4.extent(0) == 2);
-    assert(e4.extent(1) == 5);
-
-    extents<size_t, dynamic_extent, 3> e5(span{one_sizet});
-    assert(e5.extent(0) == 5);
-    assert(e5.extent(1) == 3);
-
-    extents<size_t, dynamic_extent, dynamic_extent> e6(span{two_sizet});
-    assert(e6.extent(0) == 5);
-    assert(e6.extent(1) == 7);
-}
-
-void extent_tests_equality() {
-    static_assert(extents<size_t, 2, 3>{} == extents<size_t, 2, 3>{});
-    static_assert(extents<size_t, 2, 3>{} != extents<size_t, 3, 2>{});
-    static_assert(extents<size_t, 2>{} != extents<size_t, 2, 3>{});
-
-    extents<size_t, 2, 3> e_23;
-    extents<size_t, 2, dynamic_extent> e_2d{3};
-    extents<size_t, dynamic_extent, 3> e_d3{2};
-    extents<size_t, dynamic_extent, dynamic_extent> e_dd{2, 3};
-
-    assert(e_23 == e_2d);
-    assert(e_23 == e_d3);
-    assert(e_23 == e_dd);
-    assert(e_2d == e_d3);
-}
-
-template <class Mapping, enable_if_t<Mapping::extents_type::rank() == 2, int> = 0>
-void TestMapping(const Mapping& map) {
-    using IndexT = typename Mapping::index_type;
-    using RankT  = typename Mapping::rank_type;
-    static_assert(is_same_v<IndexT, decltype(declval<Mapping>()(IndexT{0}, IndexT{0}))>);
-    static_assert(is_same_v<IndexT, decltype(declval<Mapping>().stride(RankT{0}))>);
-
-    array<IndexT, Mapping::extents_type::rank()> s;
-    const auto& e      = map.extents();
-    size_t num_entries = 1;
-    for (size_t i = 0; i < Mapping::extents_type::rank(); ++i) {
-        num_entries *= e.extent(i);
-        s[i] = map.stride(i);
-    }
-
-    vector<IndexT> indices;
-    indices.reserve(num_entries);
-
-    for (IndexT i = 0; i < e.extent(0); ++i) {
-        for (IndexT j = 0; j < e.extent(1); ++j) {
-            const auto idx = i * s[0] + j * s[1];
-            assert(map(i, j) == idx);
-            indices.push_back(idx);
-        }
-    }
-
-    bool is_unique  = true;
-    bool is_exhaust = true;
-    sort(indices.begin(), indices.end());
-    for (size_t i = 1; i < indices.size(); ++i) {
-        const auto diff = indices[i] - indices[i - 1];
-        if (diff == 0) {
-            is_unique = false;
-        } else if (diff != 1) {
-            is_exhaust = false;
-        }
-    }
-
-    assert(map.is_unique() == is_unique);
-    assert(map.is_exhaustive() == is_exhaust);
-    assert(map.required_span_size() == indices.back() + 1);
-}
-
-template <class Mapping, enable_if_t<Mapping::extents_type::rank() == 3, int> = 0>
-void TestMapping(const Mapping& map) {
-    using IndexT = typename Mapping::index_type;
-    using RankT  = typename Mapping::rank_type;
-    static_assert(is_same_v<IndexT, decltype(declval<Mapping>()(IndexT{0}, IndexT{0}, IndexT{0}))>);
-    static_assert(is_same_v<IndexT, decltype(declval<Mapping>().stride(RankT{0}))>);
-
-    array<IndexT, Mapping::extents_type::rank()> s;
-    const auto& e      = map.extents();
-    size_t num_entries = 1;
-    for (size_t i = 0; i < Mapping::extents_type::rank(); ++i) {
-        num_entries *= e.extent(i);
-        s[i] = map.stride(i);
-    }
-
-    vector<IndexT> indices;
-    indices.reserve(num_entries);
-
-    for (IndexT i = 0; i < e.extent(0); ++i) {
-        for (IndexT j = 0; j < e.extent(1); ++j) {
-            for (IndexT k = 0; k < e.extent(2); ++k) {
-                const auto idx = i * s[0] + j * s[1] + k * s[2];
-                assert(map(i, j, k) == idx);
-                indices.push_back(idx);
-            }
-        }
-    }
-
-    bool is_unique  = true;
-    bool is_exhaust = true;
-    sort(indices.begin(), indices.end());
-    for (size_t i = 1; i < indices.size(); ++i) {
-        const auto diff = indices[i] - indices[i - 1];
-        if (diff == 0) {
-            is_unique = false;
-        } else if (diff != 1) {
-            is_exhaust = false;
-        }
-    }
-
-    assert(map.is_unique() == is_unique);
-    assert(map.is_exhaustive() == is_exhaust);
-    assert(map.required_span_size() == indices.back() + 1);
-}
-
-void layout_left_tests_traits() {
-    static_assert(is_regular_trivial_nothrow_v<layout_left::mapping<extents<size_t, 2, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_left::mapping<extents<size_t, dynamic_extent, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_left::mapping<extents<size_t, 2, dynamic_extent>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_left::mapping<extents<size_t, dynamic_extent, dynamic_extent>>>);
-
-    using E = extents<int, 2, 3>;
-    static_assert(is_same_v<layout_left::mapping<E>::extents_type, E>);
-    static_assert(is_same_v<layout_left::mapping<E>::index_type, E::index_type>);
-    static_assert(is_same_v<layout_left::mapping<E>::size_type, E::size_type>);
-    static_assert(is_same_v<layout_left::mapping<E>::rank_type, E::rank_type>);
-    static_assert(is_same_v<layout_left::mapping<E>::layout_type, layout_left>);
-}
-
-void layout_right_tests_traits() {
-    static_assert(is_regular_trivial_nothrow_v<layout_right::mapping<extents<size_t, 2, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_right::mapping<extents<size_t, dynamic_extent, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_right::mapping<extents<size_t, 2, dynamic_extent>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_right::mapping<extents<size_t, dynamic_extent, dynamic_extent>>>);
-
-    using E = extents<int, 2, 3>;
-    static_assert(is_same_v<layout_right::mapping<E>::extents_type, E>);
-    static_assert(is_same_v<layout_right::mapping<E>::index_type, E::index_type>);
-    static_assert(is_same_v<layout_right::mapping<E>::size_type, E::size_type>);
-    static_assert(is_same_v<layout_right::mapping<E>::rank_type, E::rank_type>);
-    static_assert(is_same_v<layout_right::mapping<E>::layout_type, layout_right>);
-}
-
-void layout_stride_tests_traits() {
-    static_assert(is_regular_trivial_nothrow_v<layout_stride::mapping<extents<size_t, 2, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_stride::mapping<extents<size_t, dynamic_extent, 3>>>);
-    static_assert(is_regular_trivial_nothrow_v<layout_stride::mapping<extents<size_t, 2, dynamic_extent>>>);
-    static_assert(
-        is_regular_trivial_nothrow_v<layout_stride::mapping<extents<size_t, dynamic_extent, dynamic_extent>>>);
-
-    using E = extents<int, 2, 3>;
-    static_assert(is_same_v<layout_stride::mapping<E>::extents_type, E>);
-    static_assert(is_same_v<layout_stride::mapping<E>::index_type, E::index_type>);
-    static_assert(is_same_v<layout_stride::mapping<E>::size_type, E::size_type>);
-    static_assert(is_same_v<layout_stride::mapping<E>::rank_type, E::rank_type>);
-    static_assert(is_same_v<layout_stride::mapping<E>::layout_type, layout_stride>);
-}
-
-void layout_left_tests_properties() {
-    constexpr layout_left::mapping<extents<size_t, 2, 3>> map{};
-    static_assert(map.is_unique() == true);
-    static_assert(map.is_exhaustive() == true);
-    static_assert(map.is_strided() == true);
-
-    static_assert(decltype(map)::is_always_unique() == true);
-    static_assert(decltype(map)::is_always_exhaustive() == true);
-    static_assert(decltype(map)::is_always_strided() == true);
-}
-
-void layout_right_tests_properties() {
-    constexpr layout_right::mapping<extents<size_t, 2, 3>> map{};
-    static_assert(map.is_unique() == true);
-    static_assert(map.is_exhaustive() == true);
-    static_assert(map.is_strided() == true);
-
-    static_assert(decltype(map)::is_always_unique() == true);
-    static_assert(decltype(map)::is_always_exhaustive() == true);
-    static_assert(decltype(map)::is_always_strided() == true);
-}
-
-void layout_stride_tests_properties() {
-    constexpr layout_stride::mapping<extents<size_t, 2, 3>> map{};
-    static_assert(map.is_unique() == true);
-    static_assert(map.is_strided() == true);
-
-    static_assert(decltype(map)::is_always_unique() == true);
-    static_assert(decltype(map)::is_always_exhaustive() == false);
-    static_assert(decltype(map)::is_always_strided() == true);
-}
-
-void layout_left_tests_extents_ctor() {
-    constexpr extents<size_t, 2, 3> e1;
-    constexpr extents<size_t, 5, dynamic_extent> e2{7};
-    constexpr extents<size_t, dynamic_extent, 13> e3{11};
-    constexpr extents<size_t, dynamic_extent, dynamic_extent> e4{17, 19};
-
-    constexpr layout_left::mapping m1{e1};
-    static_assert(m1.extents() == e1);
-
-    constexpr layout_left::mapping m2{e2};
-    static_assert(m2.extents() == e2);
-
-    constexpr layout_left::mapping m3{e3};
-    static_assert(m3.extents() == e3);
-
-    constexpr layout_left::mapping m4{e4};
-    static_assert(m4.extents() == e4);
-}
-
-void layout_right_tests_extents_ctor() {
-    constexpr extents<size_t, 2, 3> e1;
-    constexpr extents<size_t, 5, dynamic_extent> e2{7};
-    constexpr extents<size_t, dynamic_extent, 13> e3{11};
-    constexpr extents<size_t, dynamic_extent, dynamic_extent> e4{17, 19};
-
-    constexpr layout_right::mapping m1{e1};
-    static_assert(m1.extents() == e1);
-
-    constexpr layout_right::mapping m2{e2};
-    static_assert(m2.extents() == e2);
-
-    constexpr layout_right::mapping m3{e3};
-    static_assert(m3.extents() == e3);
-
-    constexpr layout_right::mapping m4{e4};
-    static_assert(m4.extents() == e4);
-}
-
-void layout_stride_tests_extents_ctor() {
-    constexpr extents<size_t, 2, 3> e1;
-    constexpr array<size_t, 2> s1{1, 2};
-
-    constexpr layout_stride::mapping m1{e1, s1};
-    static_assert(m1.extents() == e1);
-    static_assert(m1.strides() == s1);
-
-    constexpr extents<size_t, 5, dynamic_extent> e2{7};
-    constexpr array<size_t, 2> s2{7, 1};
-
-    constexpr layout_stride::mapping m2{e2, s2};
-    static_assert(m2.extents() == e2);
-    static_assert(m2.strides() == s2);
-}
-
-template <class Extents>
-void copy_ctor_helper_left(const Extents& e) {
-    const layout_left::mapping m1{e};
-    const layout_left::mapping m2{m1};
-    assert(m1 == m2);
-}
-
-template <class Extents>
-void copy_ctor_helper_right(const Extents& e) {
-    const layout_right::mapping m1{e};
-    const layout_right::mapping m2{m1};
-    assert(m1 == m2);
-}
-
-void layout_left_tests_copy_ctor() {
-    copy_ctor_helper_left(extents<size_t, 2, 3>{});
-    copy_ctor_helper_left(extents<size_t, 5, dynamic_extent>{7});
-    copy_ctor_helper_left(extents<size_t, dynamic_extent, 13>{11});
-    copy_ctor_helper_left(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_right_tests_copy_ctor() {
-    copy_ctor_helper_right(extents<size_t, 2, 3>{});
-    copy_ctor_helper_right(extents<size_t, 5, dynamic_extent>{7});
-    copy_ctor_helper_right(extents<size_t, dynamic_extent, 13>{11});
-    copy_ctor_helper_right(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_left_tests_copy_other_extent() {
-    using E1 = extents<size_t, 2, 3>;
-    using E2 = extents<size_t, 2, dynamic_extent>;
-    constexpr E1 e1;
-    constexpr E2 e2{3};
-    constexpr layout_left::mapping<E1> m1(static_cast<E1>(e2));
-    constexpr layout_left::mapping<E2> m2(e1);
-
-    static_assert(m1.extents() == e1);
-    static_assert(m2.extents() == e1);
-    static_assert(m1.extents() == e2);
-    static_assert(m2.extents() == e2);
-}
-
-void layout_right_tests_copy_ctor_other() {
-    using E1 = extents<size_t, 2, 3>;
-    using E2 = extents<size_t, 2, dynamic_extent>;
-    constexpr E1 e1;
-    constexpr E2 e2{3};
-    constexpr layout_right::mapping<E1> m1(static_cast<E1>(e2));
-    constexpr layout_right::mapping<E2> m2(e1);
-
-    static_assert(m1.extents() == e1);
-    static_assert(m2.extents() == e1);
-    static_assert(m1.extents() == e2);
-    static_assert(m2.extents() == e2);
-}
-
-template <class Extents>
-void assign_helper_left(const Extents& e) {
-    const layout_left::mapping m1{e};
-    layout_left::mapping<Extents> m2;
-    m2 = m1;
-    assert(m1 == m2);
-}
-
-template <class Extents>
-void assign_helper_right(const Extents& e) {
-    const layout_right::mapping m1{e};
-    layout_right::mapping<Extents> m2;
-    m2 = m1;
-    assert(m1 == m2);
-}
-
-void layout_left_tests_assign() {
-    assign_helper_left(extents<size_t, 2, 3>{});
-    assign_helper_left(extents<size_t, 5, dynamic_extent>{7});
-    assign_helper_left(extents<size_t, dynamic_extent, 13>{11});
-    assign_helper_left(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_right_tests_assign() {
-    assign_helper_right(extents<size_t, 2, 3>{});
-    assign_helper_right(extents<size_t, 5, dynamic_extent>{7});
-    assign_helper_right(extents<size_t, dynamic_extent, 13>{11});
-    assign_helper_right(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_left_tests_ctor_other_layout() {
-    using E = extents<size_t, 1>;
-
-    // from layout_left
-    using OE1 = extents<size_t, 1>;
-    static_assert(is_nothrow_constructible_v<layout_left::mapping<E>, layout_right::mapping<OE1>>);
-    static_assert(is_nothrow_convertible_v<layout_right::mapping<OE1>, layout_left::mapping<E>>);
-
-    using OE2 = extents<size_t, dynamic_extent>; // not convertible
-    static_assert(is_nothrow_constructible_v<layout_left::mapping<E>, layout_right::mapping<OE2>>);
-    static_assert(!is_convertible_v<layout_right::mapping<OE2>, layout_left::mapping<E>>);
-
-    using OE3 = extents<size_t, 1, 2>; // not constructible, rank > 1
-    static_assert(!is_constructible_v<layout_left::mapping<E>, layout_right::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_right::mapping<OE3>, layout_left::mapping<E>>);
-
-    static_assert(!is_constructible_v<layout_left::mapping<OE3>, layout_right::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_right::mapping<OE3>, layout_left::mapping<OE3>>);
-
-    // from layout_stride
-    static_assert(is_constructible_v<layout_left::mapping<extents<size_t>>, layout_stride::mapping<extents<size_t>>>);
-    static_assert(is_convertible_v<layout_stride::mapping<extents<size_t>>, layout_left::mapping<extents<size_t>>>);
-
-    static_assert(is_constructible_v<layout_left::mapping<E>, layout_stride::mapping<OE1>>);
-    static_assert(!is_convertible_v<layout_stride::mapping<OE1>, layout_left::mapping<E>>);
-
-    static_assert(!is_constructible_v<layout_left::mapping<E>, layout_stride::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_stride::mapping<OE3>, layout_left::mapping<E>>);
-}
-
-void layout_right_tests_ctor_other_layout() {
-    using E = extents<size_t, 1>;
-
-    // from layout_left
-    using OE1 = extents<size_t, 1>;
-    static_assert(is_nothrow_constructible_v<layout_right::mapping<E>, layout_left::mapping<OE1>>);
-    static_assert(is_nothrow_convertible_v<layout_left::mapping<OE1>, layout_right::mapping<E>>);
-
-    using OE2 = extents<size_t, dynamic_extent>; // not convertible
-    static_assert(is_nothrow_constructible_v<layout_right::mapping<E>, layout_left::mapping<OE2>>);
-    static_assert(!is_convertible_v<layout_left::mapping<OE2>, layout_right::mapping<E>>);
-
-    using OE3 = extents<size_t, 1, 2>; // not constructible, rank > 1
-    static_assert(!is_constructible_v<layout_right::mapping<E>, layout_left::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_left::mapping<OE3>, layout_right::mapping<E>>);
-
-    static_assert(!is_constructible_v<layout_right::mapping<OE3>, layout_left::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_left::mapping<OE3>, layout_right::mapping<OE3>>);
-
-    // from layout_stride
-    static_assert(is_constructible_v<layout_right::mapping<extents<size_t>>, layout_stride::mapping<extents<size_t>>>);
-    static_assert(is_convertible_v<layout_stride::mapping<extents<size_t>>, layout_right::mapping<extents<size_t>>>);
-
-    static_assert(is_constructible_v<layout_right::mapping<E>, layout_stride::mapping<OE1>>);
-    static_assert(!is_convertible_v<layout_stride::mapping<OE1>, layout_right::mapping<E>>);
-
-    static_assert(!is_constructible_v<layout_right::mapping<E>, layout_stride::mapping<OE3>>);
-    static_assert(!is_convertible_v<layout_stride::mapping<OE3>, layout_right::mapping<E>>);
-}
-
-void layout_left_tests_strides() {
-    using E = extents<size_t, 2, 3, 5, 7>;
-    layout_left::mapping<E> map;
-    static_assert(map.stride(0) == 1);
-    static_assert(map.stride(1) == 2);
-    static_assert(map.stride(2) == 2 * 3);
-    static_assert(map.stride(3) == 2 * 3 * 5);
-}
-
-void layout_right_tests_strides() {
-    using E = extents<size_t, 2, 3, 5, 7>;
-    layout_right::mapping<E> map;
-    static_assert(map.stride(0) == 7 * 5 * 3);
-    static_assert(map.stride(1) == 7 * 5);
-    static_assert(map.stride(2) == 7);
-    static_assert(map.stride(3) == 1);
-}
-
-void layout_stride_tests_strides() {
-    using E = extents<size_t, 3, 5>;
-    constexpr array<size_t, 2> s{1, 3};
-    constexpr layout_stride::mapping<E> map{E{}, s};
-    static_assert(map.stride(0) == s[0]);
-    static_assert(map.stride(1) == s[1]);
-    static_assert(map.strides() == s);
-}
-
-void layout_left_tests_indexing() {
-    static_assert(layout_left::mapping<extents<size_t>>{}() == 0);
-    TestMapping(layout_left::mapping<extents<size_t, 2, 3>>{});
-    TestMapping(layout_left::mapping<extents<int, 2, 3>>{});
-}
-
-void layout_right_tests_indexing() {
-    static_assert(layout_right::mapping<extents<size_t>>{}() == 0);
-    TestMapping(layout_right::mapping<extents<size_t, 2, 3>>{});
-    TestMapping(layout_right::mapping<extents<int, 2, 3>>{});
-}
-
-template <class Extents>
-void copy_ctor_helper_stride(const Extents& e) {
-    const layout_stride::mapping<Extents> m1{layout_right::mapping<Extents>{e}};
-    const layout_stride::mapping<Extents> m2{m1};
-    assert(m1 == m2);
-}
-
-void layout_stride_tests_copy_ctor() {
-    copy_ctor_helper_stride(extents<size_t, 2, 3>{});
-    copy_ctor_helper_stride(extents<size_t, 5, dynamic_extent>{7});
-    copy_ctor_helper_stride(extents<size_t, dynamic_extent, 13>{11});
-    copy_ctor_helper_stride(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_stride_tests_ctor_other_extents() {
-    constexpr extents<size_t, 2, 3> e1;
-    constexpr extents<size_t, 2, dynamic_extent> e2{3};
-    constexpr array<size_t, 2> s{3, 1};
-
-    constexpr layout_stride::mapping<remove_const_t<decltype(e1)>> m1(e1, s);
-    constexpr layout_stride::mapping<remove_const_t<decltype(e2)>> m2(m1);
-
-    static_assert(m2.extents() == e1);
-    static_assert(m2.strides() == s);
-}
-
-template <class LayoutMapping>
-void other_mapping_helper() {
-    constexpr LayoutMapping other;
-    constexpr layout_stride::mapping<typename LayoutMapping::extents_type> map{other};
-    static_assert(map.extents() == other.extents());
-    for (size_t i = 0; i < LayoutMapping::extents_type::rank(); ++i) {
-        assert(map.stride(i) == other.stride(i));
-    }
-}
-void layout_stride_tests_ctor_other_mapping() {
-    using E = extents<size_t, 2, 3>;
-    other_mapping_helper<layout_left::mapping<E>>();
-    other_mapping_helper<layout_right::mapping<E>>();
-}
-
-template <class Extents>
-void assign_helper_stride(const Extents& e) {
-    const layout_stride::mapping<Extents> m1{layout_right::mapping<Extents>{e}};
-    layout_stride::mapping<Extents> m2;
-    m2 = m1;
-    assert(m1 == m2);
-}
-
-void layout_stride_tests_assign() {
-    assign_helper_stride(extents<size_t, 2, 3>{});
-    assign_helper_stride(extents<size_t, 5, dynamic_extent>{7});
-    assign_helper_stride(extents<size_t, dynamic_extent, 13>{11});
-    assign_helper_stride(extents<size_t, dynamic_extent, dynamic_extent>{17, 19});
-}
-
-void layout_stride_tests_indexing_static() {
-    using E = extents<size_t, 2, 3>;
-    TestMapping(layout_stride::mapping<E>{E{}, array<size_t, 2>{1, 2}});
-    TestMapping(layout_stride::mapping<E>{E{}, array<size_t, 2>{3, 1}});
-
-    // non-exhaustive mappings
-    TestMapping(layout_stride::mapping<E>{E{}, array<size_t, 2>{1, 3}});
-    TestMapping(layout_stride::mapping<E>{E{}, array<size_t, 2>{4, 1}});
-    TestMapping(layout_stride::mapping<E>{E{}, array<size_t, 2>{2, 3}});
-
-    // exhaustive mappings with singleton dimensions
-    using E1 = extents<int, 2, 1, 3>;
-    TestMapping(layout_stride::mapping<E1>{E1{}, array<int, 3>{3, 1, 1}});
-    TestMapping(layout_stride::mapping<E1>{E1{}, array<int, 3>{3, 7, 1}});
-
-    using E2 = extents<int, 2, 3, 1>;
-    TestMapping(layout_stride::mapping<E2>{E2{}, array<int, 3>{3, 1, 1}});
-    TestMapping(layout_stride::mapping<E2>{E2{}, array<int, 3>{3, 1, 11}});
-
-    using E3 = extents<int, 3, 2, 1>;
-    TestMapping(layout_stride::mapping<E3>{E3{}, array<int, 3>{1, 3, 1}});
-    TestMapping(layout_stride::mapping<E3>{E3{}, array<int, 3>{1, 3, 13}});
-}
-
-
-void layout_stride_tests_equality() {
-    using E = extents<size_t, 2, 3>;
-    constexpr layout_stride::mapping<E> map1(layout_right::mapping<E>{});
-    constexpr layout_stride::mapping<E> map2(layout_right::mapping<E>{});
-    static_assert(map1 == map2);
-
-    constexpr layout_stride::mapping<E> map3{layout_left::mapping<E>{}};
-    static_assert(map1 != map3);
-
-    using ED = extents<size_t, dynamic_extent, dynamic_extent>;
-    constexpr layout_stride::mapping<ED> map4{ED{2, 3}, map1.strides()};
-    static_assert(map1 == map4);
-}
-
-void accessor_tests_general() {
-    default_accessor<double> a;
-    double arr[4] = {};
-    static_assert(a.offset(arr, 3) == &arr[3]);
-
-    a.access(arr, 2) = 42;
-    assert(arr[2] == 42);
-
-    static_assert(is_constructible_v<default_accessor<const double>, default_accessor<double>>);
-    static_assert(!is_constructible_v<default_accessor<double>, default_accessor<const double>>);
-}
-
-namespace Pathological {
-
-    struct Empty {};
-
-    struct Extents {
-        using index_type = int;
-        using size_type  = std::make_unsigned_t<index_type>;
-        using rank_type  = size_t;
-
-        explicit Extents(Empty) {}
-
-        template <size_t N>
-        explicit Extents(const array<Empty, N>&) {}
-
-        static constexpr size_t rank() {
-            return 0;
-        }
-
-        static constexpr size_t rank_dynamic() {
-            return 0;
-        }
-    };
-
-    struct Layout {
-        template <class E>
-        struct mapping {
-            using extents_type = E;
-            using layout_type  = Layout;
-            mapping(Extents) {}
-        };
-    };
-
-    struct Accessor {
-        using element_type     = int;
-        using data_handle_type = int*;
-        using reference        = int&;
-        Accessor(int) {}
-    };
-} // namespace Pathological
-
-void mdspan_tests_traits() {
-    using M = mdspan<const int, extents<size_t, 2, 3>>;
-    static_assert(is_trivially_copyable_v<M> /*&& is_default_constructible_v<M>*/
-                  && is_copy_constructible_v<M> && is_move_constructible_v<M> && is_copy_assignable_v<M>
-                  && is_move_assignable_v<M>);
-
-    static_assert(is_same_v<M::extents_type, extents<size_t, 2, 3>>);
-    static_assert(is_same_v<M::layout_type, layout_right>);
-    static_assert(is_same_v<M::accessor_type, default_accessor<const int>>);
-    static_assert(is_same_v<M::mapping_type, layout_right::mapping<extents<size_t, 2, 3>>>);
-    static_assert(is_same_v<M::element_type, const int>);
-    static_assert(is_same_v<M::value_type, int>);
-    static_assert(is_same_v<M::size_type, size_t>);
-    static_assert(is_same_v<M::data_handle_type, const int*>);
-    static_assert(is_same_v<M::reference, const int&>);
-}
-
-void mdspan_tests_ctor_sizes() {
-    static constexpr int arr[6] = {};
-    constexpr mdspan<const int, extents<size_t, dynamic_extent, 3>> mds1(arr, 2);
-    static_assert(mds1.data_handle() == arr);
-    static_assert((mds1.extents() == extents<size_t, 2, 3>{}));
-    static_assert(mds1.is_exhaustive());
-
-    static_assert(!is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, Pathological::Layout>, int*,
-                  int>); // Pathological::Layout not constructible from extents<size_t, dynamic_extent>
-
-    static_assert(
-        !is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, layout_right, Pathological::Accessor>, int*,
-            int>); // Pathological::Accessor not default constructible
-}
-
-void mdspan_tests_ctor_array() {
-    static constexpr int arr[6] = {};
-    constexpr mdspan<const int, extents<size_t, dynamic_extent, 3>> mds1(arr, array{2});
-    static_assert(mds1.data_handle() == arr);
-    static_assert(mds1.extents() == extents<size_t, 2, 3>{});
-
-    static_assert(!is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, Pathological::Layout>, int*,
-                  array<int, 1>>); // Pathological::Layout not constructible from extents<size_t, dynamic_extent>
-
-    static_assert(
-        !is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, layout_right, Pathological::Accessor>, int*,
-            array<int, 1>>); // Pathological::Accessor not default constructible
-}
-
-void mdspan_tests_ctor_extents() {
-    static constexpr int arr[6] = {};
-    constexpr mdspan<const int, extents<size_t, dynamic_extent, 3>> mds1(arr, extents<size_t, dynamic_extent, 3>{2});
-    static_assert(mds1.data_handle() == arr);
-    static_assert(mds1.extents() == extents<size_t, 2, 3>{});
-
-    static_assert(!is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, Pathological::Layout>, int*,
-                  extents<size_t, dynamic_extent>>); // Pathological::Layout not constructible from extents<size_t,
-                                                     // dynamic_extent>
-
-    static_assert(
-        !is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, layout_right, Pathological::Accessor>, int*,
-            extents<size_t, dynamic_extent>>); // Pathological::Accessor not default constructible
-}
-
-void mdspan_tests_ctor_mapping() {
-    static constexpr int arr[6] = {};
-    using E                     = extents<size_t, dynamic_extent, 3>;
-    constexpr layout_left::mapping<extents<size_t, 2, 3>> map(extents<size_t, 2, 3>{});
-
-    constexpr mdspan<const int, E, layout_left> mds1(arr, map);
-    static_assert(mds1.data_handle() == arr);
-    static_assert(mds1.extents() == extents<size_t, 2, 3>{});
-    static_assert(mds1.mapping() == map);
-
-    static_assert(
-        !is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, layout_right, Pathological::Accessor>, int*,
-            extents<size_t, dynamic_extent>>); // Pathological::Accessor not default constructible
-}
-
-template <class Type>
-struct stateful_accessor {
-    using element_type     = Type;
-    using data_handle_type = Type*;
-    using reference        = Type&;
-
-    constexpr stateful_accessor(int i_) : i(i_){};
-    int i = 0;
-};
-
-void mdspan_tests_ctor_accessor() {
-    static constexpr int arr[6] = {};
-    using E                     = extents<size_t, dynamic_extent, 3>;
-    constexpr layout_left::mapping<extents<size_t, 2, 3>> map(extents<size_t, 2, 3>{});
-    constexpr stateful_accessor<const int> acc(1);
-
-    constexpr mdspan<const int, E, layout_left, stateful_accessor<const int>> mds1(arr, map, acc);
-    static_assert(mds1.data_handle() == arr);
-    static_assert(mds1.extents() == extents<size_t, 2, 3>{});
-    static_assert(mds1.mapping() == map);
-    static_assert(mds1.accessor().i == 1);
-
-    static_assert(
-        !is_constructible_v<mdspan<int, extents<size_t, dynamic_extent>, layout_right, Pathological::Accessor>, int*,
-            extents<size_t, dynamic_extent>>); // Pathological::Accessor not default constructible
-}
-
-void mdspan_tests_assign() {
-    using E2   = extents<size_t, 2>;
-    int arr[6] = {};
-    mdspan<int, extents<size_t, dynamic_extent>> mds1(arr, 2);
-    mdspan<int, extents<size_t, dynamic_extent>> mds2(nullptr, 3);
-    mds2 = mds1;
-    assert(mds2.data_handle() == arr);
-    assert(mds2.extents() == E2{});
-    assert(mds2.mapping() == mds1.mapping());
-}
-
-void mdspan_tests_observers() {
-    using E                    = extents<size_t, dynamic_extent, 3>;
-    static constexpr int arr[] = {0, 1, 2, 3, 4, 5, 6, 7};
-    constexpr mdspan<const int, E, layout_stride> mds{arr, layout_stride::mapping<E>{E{2}, array<size_t, 2>{1, 3}}};
-
-    static_assert(mds.rank() == 2);
-    static_assert(mds.rank_dynamic() == 1);
-
-    static_assert(mds.static_extent(0) == dynamic_extent);
-    static_assert(mds.static_extent(1) == 3);
-    static_assert(mds.extent(0) == 2);
-    static_assert(mds.extent(1) == 3);
-    static_assert(mds.size() == 6);
-
-    static_assert(mds.stride(0) == 1);
-    static_assert(mds.stride(1) == 3);
-
-    static_assert(mds.is_always_unique());
-    static_assert(!mds.is_always_exhaustive());
-    static_assert(mds.is_always_strided());
-
-    static_assert(mds.is_unique());
-    static_assert(!mds.is_exhaustive());
-    static_assert(mds.is_strided());
-
-#ifdef __cpp_multidimensional_subscript // TRANSITION, P2128R6
-    static_assert(mds[1, 0] == 1);
-    static_assert(mds[1, 2] == 7);
-#endif // __cpp_multidimensional_subscript
-
-    static_assert(mds[array{0, 1}] == 3);
-    static_assert(mds[array{1, 1}] == 4);
-}
-
-int main() {
-    extent_tests_rank();
-    extent_tests_static_extent();
-    extent_tests_extent();
-    extent_tests_ctor_other_sizes();
-    extent_tests_copy_ctor_other();
-    extent_tests_ctor_array();
-    extent_tests_ctor_span();
-    extent_tests_equality();
-
-    layout_left_tests_traits();
-    layout_left_tests_properties();
-    layout_left_tests_extents_ctor();
-    layout_left_tests_copy_ctor();
-    layout_left_tests_copy_other_extent();
-    layout_left_tests_assign();
-    layout_left_tests_ctor_other_layout();
-    layout_left_tests_strides();
-    layout_left_tests_indexing();
-
-    layout_right_tests_traits();
-    layout_right_tests_properties();
-    layout_right_tests_extents_ctor();
-    layout_right_tests_copy_ctor();
-    layout_right_tests_copy_ctor_other();
-    layout_right_tests_assign();
-    layout_right_tests_ctor_other_layout();
-    layout_right_tests_strides();
-    layout_right_tests_indexing();
-
-    layout_stride_tests_traits();
-    layout_stride_tests_properties();
-    layout_stride_tests_extents_ctor();
-    layout_stride_tests_strides();
-    layout_stride_tests_copy_ctor();
-    layout_stride_tests_ctor_other_extents();
-    layout_stride_tests_ctor_other_mapping();
-    layout_stride_tests_assign();
-    layout_stride_tests_indexing_static();
-    layout_stride_tests_equality();
-
-    accessor_tests_general();
-
-    mdspan_tests_traits();
-    mdspan_tests_ctor_sizes();
-    mdspan_tests_ctor_array();
-    mdspan_tests_ctor_extents();
-    mdspan_tests_ctor_mapping();
-    mdspan_tests_ctor_accessor();
-    mdspan_tests_assign();
-    mdspan_tests_observers();
-
-    return 0;
-}

From 1f6f10cd8c9e1e85f0e35741ea40d063d81312cd Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 14:46:56 +0200
Subject: [PATCH 08/13] Change layouts' `check_mapping_properties` tests a
 little bit

---
 .../P0009R18_mdspan_layout_left/test.cpp      | 24 +++++------
 .../P0009R18_mdspan_layout_right/test.cpp     | 24 +++++------
 .../P0009R18_mdspan_layout_stride/test.cpp    | 42 +++++++++----------
 3 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
index e8711c62f05..146ca784d38 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
@@ -159,25 +159,25 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 }
 
-constexpr void check_mapping_properties() {
-    auto check = [](const auto& mapping) {
-        const auto props = get_mapping_properties(mapping);
-        if constexpr (!is_permissive) {
+void check_mapping_properties() {
+    if constexpr (!is_permissive) {
+        auto check = []([[maybe_unused]] const auto& mapping) {
+            const auto props = get_mapping_properties(mapping);
             assert(props.req_span_size == mapping.required_span_size());
             assert(props.uniqueness);
             assert(props.exhaustiveness);
             assert(props.strideness);
-        }
-    };
+        };
 
-    using M1 = layout_left::mapping<extents<int, 2, 3, 5>>;
-    check(M1{});
+        using M1 = layout_left::mapping<extents<int, 2, 3, 5>>;
+        check(M1{});
 
-    using M2 = layout_left::mapping<extents<unsigned long, 8, dynamic_extent, 5>>;
-    check(M2{M2::extents_type{6}});
+        using M2 = layout_left::mapping<extents<unsigned long, 8, dynamic_extent, 5>>;
+        check(M2{M2::extents_type{6}});
 
-    using M3 = layout_left::mapping<dextents<signed char, 4>>;
-    check(M3{M3::extents_type{3, 5, 4, 2}});
+        using M3 = layout_left::mapping<dextents<signed char, 4>>;
+        check(M3{M3::extents_type{3, 5, 4, 2}});
+    }
 }
 
 constexpr void check_construction_from_extents() {
diff --git a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
index d94f05a0784..b0dd098f7fc 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
@@ -158,25 +158,25 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 }
 
-constexpr void check_mapping_properties() {
-    auto check = [](const auto& mapping) {
-        const auto props = get_mapping_properties(mapping);
-        if constexpr (!is_permissive) {
+void check_mapping_properties() {
+    if constexpr (!is_permissive) {
+        auto check = []([[maybe_unused]] const auto& mapping) {
+            const auto props = get_mapping_properties(mapping);
             assert(props.req_span_size == mapping.required_span_size());
             assert(props.uniqueness);
             assert(props.exhaustiveness);
             assert(props.strideness);
-        }
-    };
+        };
 
-    using M1 = layout_right::mapping<extents<int, 7, 11, 13>>;
-    check(M1{});
+        using M1 = layout_right::mapping<extents<int, 7, 11, 13>>;
+        check(M1{});
 
-    using M2 = layout_right::mapping<extents<unsigned long, dynamic_extent, 4, dynamic_extent>>;
-    check(M2{M2::extents_type{2, 6}});
+        using M2 = layout_right::mapping<extents<unsigned long, dynamic_extent, 4, dynamic_extent>>;
+        check(M2{M2::extents_type{2, 6}});
 
-    using M3 = layout_right::mapping<dextents<unsigned char, 4>>;
-    check(M3{M3::extents_type{4, 3, 5, 4}});
+        using M3 = layout_right::mapping<dextents<unsigned char, 4>>;
+        check(M3{M3::extents_type{4, 3, 5, 4}});
+    }
 }
 
 constexpr void check_construction_from_extents() {
diff --git a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
index 13ab33b6139..ee6fec0b4e5 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
@@ -174,38 +174,38 @@ constexpr void check_members(extents<IndexType, Extents...> ext, const array<int
     check_members_with_different_strides_index_type<unsigned long long>(ext, strides);
 }
 
-constexpr void check_mapping_properties() {
-    auto check = [](const auto& mapping, [[maybe_unused]] const bool expected_exhaustiveness) {
-        const auto props = get_mapping_properties(mapping);
-        if constexpr (!is_permissive) {
+void check_mapping_properties() {
+    if constexpr (!is_permissive) {
+        auto check = [](const auto& mapping, const bool expected_exhaustiveness) {
+            const auto props = get_mapping_properties(mapping);
             assert(props.req_span_size == mapping.required_span_size());
             assert(props.uniqueness);
             assert(props.exhaustiveness == expected_exhaustiveness);
             assert(props.exhaustiveness == mapping.is_exhaustive());
             assert(props.strideness);
-        }
-    };
+        };
 
-    { // Check exhaustive mappings
-        using M1 = layout_stride::mapping<extents<unsigned int, 4, 2, 3>>;
-        check(M1{M1::extents_type{}, array{6, 1, 2}}, true);
+        { // Check exhaustive mappings
+            using M1 = layout_stride::mapping<extents<unsigned int, 4, 2, 3>>;
+            check(M1{M1::extents_type{}, array{6, 1, 2}}, true);
 
-        using M2 = layout_stride::mapping<extents<unsigned long long, dynamic_extent, dynamic_extent, 8>>;
-        check(M2{M2::extents_type{6, 7}, array{1, 48, 6}}, true);
+            using M2 = layout_stride::mapping<extents<unsigned long long, dynamic_extent, dynamic_extent, 8>>;
+            check(M2{M2::extents_type{6, 7}, array{1, 48, 6}}, true);
 
-        using M3 = layout_stride::mapping<dextents<short, 4>>;
-        check(M3{M3::extents_type{3, 5, 2, 4}, array{20, 1, 60, 5}}, true);
-    }
+            using M3 = layout_stride::mapping<dextents<short, 4>>;
+            check(M3{M3::extents_type{3, 5, 2, 4}, array{20, 1, 60, 5}}, true);
+        }
 
-    { // Check non-exhaustive mappings
-        using M1 = layout_stride::mapping<extents<int, 2, 4, 3>>;
-        check(M1{M1::extents_type{}, array{9, 18, 1}}, false);
+        { // Check non-exhaustive mappings
+            using M1 = layout_stride::mapping<extents<int, 2, 4, 3>>;
+            check(M1{M1::extents_type{}, array{9, 18, 1}}, false);
 
-        using M2 = layout_stride::mapping<extents<long long, 3, dynamic_extent, dynamic_extent>>;
-        check(M2{M2::extents_type{4, 3}, array{12, 36, 1}}, false);
+            using M2 = layout_stride::mapping<extents<long long, 3, dynamic_extent, dynamic_extent>>;
+            check(M2{M2::extents_type{4, 3}, array{12, 36, 1}}, false);
 
-        using M3 = layout_stride::mapping<dextents<unsigned short, 3>>;
-        check(M3{M3::extents_type{4, 3, 2}, array{8, 32, 2}}, false);
+            using M3 = layout_stride::mapping<dextents<unsigned short, 3>>;
+            check(M3{M3::extents_type{4, 3, 2}, array{8, 32, 2}}, false);
+        }
     }
 }
 

From 96e1b3b6d955eab97c04a07acd614a114c8305c5 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 18:16:55 +0200
Subject: [PATCH 09/13] Implement `is_strided` check in
 `get_mapping_properties`

---
 tests/std/include/test_mdspan_support.hpp | 61 ++++++++++++++++-------
 1 file changed, 43 insertions(+), 18 deletions(-)

diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index ff55ef3fe19..1690ada64c3 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -8,6 +8,7 @@
 #include <concepts>
 #include <cstddef>
 #include <mdspan>
+#include <optional>
 #include <ranges>
 #include <span>
 #include <type_traits>
@@ -263,41 +264,65 @@ struct MappingProperties {
 
 template <class Mapping>
     requires (!details::PermissiveTest<Mapping>::test())
-constexpr MappingProperties<Mapping> get_mapping_properties(const Mapping& mapping) {
-    constexpr typename Mapping::index_type zero = 0;
+MappingProperties<Mapping> get_mapping_properties(const Mapping& mapping) {
+    using IndexType          = typename Mapping::index_type;
+    constexpr IndexType zero = 0;
+    constexpr auto rank      = Mapping::extents_type::rank();
+    constexpr std::make_index_sequence<rank> rank_indices;
 
-    auto make_cartesian_prod = [&]<size_t... Indices>(std::index_sequence<Indices...>) {
-        return std::views::cartesian_product(std::views::iota(zero, mapping.extents().extent(Indices))...);
-    };
+    auto get_extent       = [&](size_t i) { return mapping.extents().extent(i); };
+    auto multidim_indices = [&]<size_t... Indices>(std::index_sequence<Indices...>) {
+        return std::views::cartesian_product(std::views::iota(zero, get_extent(Indices))...);
+    }(rank_indices);
 
-    auto indices =
-        make_cartesian_prod(std::make_index_sequence<Mapping::extents_type::rank()>{})
-        | std::views::transform([&](auto tpl) { return std::apply([&](auto... i) { return mapping(i...); }, tpl); })
-        | std::ranges::to<std::vector>();
-    std::ranges::sort(indices);
+    auto map_index      = [&](const auto& tpl) { return std::apply([&](auto... i) { return mapping(i...); }, tpl); };
+    auto mapped_indices = multidim_indices | std::views::transform(map_index) | std::ranges::to<std::vector>();
+    std::ranges::sort(mapped_indices);
 
-    MappingProperties<Mapping> props;
+    MappingProperties<Mapping> props{};
 
     { // Find required span size (N4950 [mdspan.layout.reqmts]/12)
-        auto exts = std::views::iota(0u, Mapping::extents_type::rank())
-                  | std::views::transform([&](auto i) { return mapping.extents().extent(i); });
+        auto exts = std::views::iota(0u, rank) | std::views::transform([&](auto i) { return get_extent(i); });
         if (std::ranges::contains(exts, zero)) {
             props.req_span_size = 0;
         } else {
-            props.req_span_size = static_cast<Mapping::index_type>(1 + indices.back());
+            props.req_span_size = static_cast<IndexType>(1 + mapped_indices.back());
         }
     }
 
     // Is mapping unique? (N4950 [mdspan.layout.reqmts]/14)
-    props.uniqueness = !std::ranges::contains(std::views::pairwise_transform(indices, std::minus{}), zero);
+    props.uniqueness = !std::ranges::contains(std::views::pairwise_transform(mapped_indices, std::minus{}), zero);
 
     { // Is mapping exhaustive? (N4950 [mdspan.layout.reqmts]/16)
-        const auto diffs     = std::views::pairwise_transform(indices, [](auto x, auto y) { return y - x; });
+        const auto diffs     = std::views::pairwise_transform(mapped_indices, [](auto x, auto y) { return y - x; });
         props.exhaustiveness = std::ranges::find_if_not(diffs, [](auto x) { return x == 1; }) == diffs.end();
     }
 
-    // Is mapping strided? FIXME (N4950 [mdspan.layout.reqmts]/18)
-    props.strideness = true;
+    { // Is mapping strided? (N4950 [mdspan.layout.reqmts]/18)
+        props.strideness = true; // assumption
+        for (auto r : std::views::iota(0u, rank)) {
+            std::optional<IndexType> sr;
+            for (auto i : multidim_indices) {
+                const auto i_plus_dr = [&]<size_t... Indices>(std::index_sequence<Indices...>) {
+                    return std::array{static_cast<IndexType>(std::get<Indices>(i) + (Indices == r ? 1 : 0))...};
+                }(rank_indices);
+
+                if (i_plus_dr[r] < get_extent(r)) {
+                    const auto diff = static_cast<IndexType>(map_index(i_plus_dr) - map_index(i));
+                    if (!sr.has_value()) {
+                        sr = diff;
+                    } else if (*sr != diff) {
+                        props.strideness = false;
+                        break;
+                    }
+                }
+            }
+
+            if (!props.strideness) {
+                break;
+            }
+        }
+    }
 
     return props;
 }

From a8150283d2a2d407ebbf4632b725c7c4b0f0f38e Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 19:34:27 +0200
Subject: [PATCH 10/13] Poke CI


From 0e8ab84515fe7e857e913de0d931cdd54057a533 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Tue, 13 Jun 2023 21:27:14 +0200
Subject: [PATCH 11/13] Revert "Drive-by: include `"test_mdspan_support.hpp"`
 instead of `<test_mdspan_support.hpp>`"

And use `<test_mdspan_support.hpp>` instead of `"test_mdspan_support.hpp"`

This reverts commit 265440556cd1e0f5b037515c7e2753beb3551252.
---
 tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp | 2 +-
 tests/std/tests/P0009R18_mdspan_extents/test.cpp          | 2 +-
 tests/std/tests/P0009R18_mdspan_layout_left/test.cpp      | 2 +-
 tests/std/tests/P0009R18_mdspan_layout_right/test.cpp     | 2 +-
 tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp    | 2 +-
 tests/std/tests/P0009R18_mdspan_mdspan/test.cpp           | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
index f22101c0f7c..9036a910c75 100644
--- a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
@@ -9,7 +9,7 @@
 #include <string>
 #include <type_traits>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_extents/test.cpp b/tests/std/tests/P0009R18_mdspan_extents/test.cpp
index 1ed2d2f5848..3ff5424078e 100644
--- a/tests/std/tests/P0009R18_mdspan_extents/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_extents/test.cpp
@@ -10,7 +10,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
index 146ca784d38..ab353018523 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
@@ -9,7 +9,7 @@
 #include <span>
 #include <type_traits>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
index b0dd098f7fc..e733fd63286 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
@@ -9,7 +9,7 @@
 #include <span>
 #include <type_traits>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
index ee6fec0b4e5..385b25dd44d 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
@@ -10,7 +10,7 @@
 #include <span>
 #include <type_traits>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 
diff --git a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
index b323b09621c..44580c94dd0 100644
--- a/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_mdspan/test.cpp
@@ -13,7 +13,7 @@
 #include <utility>
 #include <vector>
 
-#include "test_mdspan_support.hpp"
+#include <test_mdspan_support.hpp>
 
 using namespace std;
 

From b8cb9a6df3e24ab338591b94030eb9f09aea12f5 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Wed, 14 Jun 2023 14:35:55 +0200
Subject: [PATCH 12/13] `<test_mdspan_support.hpp>`: remove `exts` variable
 from `get_mapping_properties`

---
 tests/std/include/test_mdspan_support.hpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index 1690ada64c3..6763f021fc5 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -281,13 +281,11 @@ MappingProperties<Mapping> get_mapping_properties(const Mapping& mapping) {
 
     MappingProperties<Mapping> props{};
 
-    { // Find required span size (N4950 [mdspan.layout.reqmts]/12)
-        auto exts = std::views::iota(0u, rank) | std::views::transform([&](auto i) { return get_extent(i); });
-        if (std::ranges::contains(exts, zero)) {
-            props.req_span_size = 0;
-        } else {
-            props.req_span_size = static_cast<IndexType>(1 + mapped_indices.back());
-        }
+    // Find required span size (N4950 [mdspan.layout.reqmts]/12)
+    if (std::ranges::contains(std::views::iota(0u, rank) | std::views::transform(get_extent), zero)) {
+        props.req_span_size = 0;
+    } else {
+        props.req_span_size = static_cast<IndexType>(1 + mapped_indices.back());
     }
 
     // Is mapping unique? (N4950 [mdspan.layout.reqmts]/14)

From cfbc99ddd0948e96fcbcc3c58ea2e05bf0eeedfb Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 16 Jun 2023 14:39:23 -0700
Subject: [PATCH 13/13] Code review feedback.

---
 tests/std/include/test_mdspan_support.hpp              | 2 ++
 tests/std/tests/P0009R18_mdspan_layout_left/test.cpp   | 4 ++--
 tests/std/tests/P0009R18_mdspan_layout_right/test.cpp  | 4 ++--
 tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp | 2 +-
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index 6763f021fc5..b653d74268e 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -7,10 +7,12 @@
 #include <array>
 #include <concepts>
 #include <cstddef>
+#include <functional>
 #include <mdspan>
 #include <optional>
 #include <ranges>
 #include <span>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
diff --git a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
index ab353018523..9946cf40f8e 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_left/test.cpp
@@ -46,7 +46,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         Mapping cpy;
         cpy = m;
         assert(cpy == m);
-        static_assert(is_nothrow_copy_assignable_v<Ext>);
+        static_assert(is_nothrow_copy_assignable_v<Mapping>);
     }
 
     { // Check construction from extents_type
@@ -85,7 +85,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     }
 
 #ifdef __clang__
-    if (!is_constant_evaluated()) // FIXME clang hits contexpr limit here
+    if (!is_constant_evaluated()) // FIXME clang hits constexpr limit here
 #endif
     { // Check construction from layout_stride::mapping
         array<IndexType, Ext::rank()> strides{};
diff --git a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
index e733fd63286..a5e58742cbe 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_right/test.cpp
@@ -46,7 +46,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
         Mapping cpy;
         cpy = m;
         assert(cpy == m);
-        static_assert(is_nothrow_copy_assignable_v<Ext>);
+        static_assert(is_nothrow_copy_assignable_v<Mapping>);
     }
 
     { // Check construction from extents_type
@@ -61,7 +61,7 @@ constexpr void check_members(const extents<IndexType, Extents...>& ext, index_se
     using Mapping2       = layout_right::mapping<Ext2>;
 
 #ifdef __clang__
-    if (!is_constant_evaluated()) // FIXME clang hits contexpr limit here
+    if (!is_constant_evaluated()) // FIXME clang hits constexpr limit here
 #endif
     { // Check construction from other layout_right::mapping
         Mapping m1{ext};
diff --git a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
index 385b25dd44d..4c39707b548 100644
--- a/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_layout_stride/test.cpp
@@ -58,7 +58,7 @@ constexpr void do_check_members(const extents<IndexType, Extents...>& ext,
         Mapping cpy;
         cpy = m;
         assert(cpy == m);
-        static_assert(is_nothrow_copy_assignable_v<Ext>);
+        static_assert(is_nothrow_copy_assignable_v<Mapping>);
     }
 
     { // Check construction from extents_type and array