On Wed, 16 Jul 2025, 14:48 Luc Grosheintz, <luc.groshei...@gmail.com> wrote:
> PR121061 shows that the test coverage for custom integer types is
> insufficient. Custom IndexTypes are passed to mdspan related objects in
> one of two ways:
>
> * as a template parameter pack,
> * or as an array/span.
>
> These two cases have different requirements on the (constness of) custom
> IndexTypes. Therefore, the tests are restructured as follows:
>
> * allow testing with different custom integers,
> * separate code that tests the two cases described above,
> * use int_like.h for all tests with custom integers.
>
I like this approach, thanks.
OK for trunk.
> The affected tests are for:
>
> * creating extents, layout_stride::mapping and mdspan from
> custom integers,
>
> * mapping::operator() and mdspan::operator[].
>
> PR libstdc++/121061
>
> libstdc++-v3/ChangeLog:
>
> * testsuite/23_containers/mdspan/extents/custom_integer.cc:
> Enable checking with different custom integers. Improve
> checking non-existence of overloads for incompatible custom
> integers.
> * testsuite/23_containers/mdspan/layouts/mapping.cc: ditto. Also
> improve reuse of int_like.h.
> * testsuite/23_containers/mdspan/layouts/stride.cc: ditto.
> * testsuite/23_containers/mdspan/mdspan.cc: ditto.
> * testsuite/23_containers/mdspan/extents/int_like.h: Rename (old
> name).
> * testsuite/23_containers/mdspan/int_like.h: Rename (new name).
> (ThrowingInt): Add.
> (NotIntLike): Add.
>
> Signed-off-by: Luc Grosheintz <luc.groshei...@gmail.com>
> ---
> .../mdspan/extents/custom_integer.cc | 98 +++++++-----
> .../23_containers/mdspan/extents/int_like.h | 30 ----
> .../testsuite/23_containers/mdspan/int_like.h | 49 ++++++
> .../23_containers/mdspan/layouts/mapping.cc | 110 +++++++-------
> .../23_containers/mdspan/layouts/stride.cc | 20 +--
> .../testsuite/23_containers/mdspan/mdspan.cc | 143 ++++++++++++------
> 6 files changed, 264 insertions(+), 186 deletions(-)
> delete mode 100644
> libstdc++-v3/testsuite/23_containers/mdspan/extents/int_like.h
> create mode 100644 libstdc++-v3/testsuite/23_containers/mdspan/int_like.h
>
> diff --git
> a/libstdc++-v3/testsuite/23_containers/mdspan/extents/custom_integer.cc
> b/libstdc++-v3/testsuite/23_containers/mdspan/extents/custom_integer.cc
> index 404755bd5ac..4f631815b10 100644
> --- a/libstdc++-v3/testsuite/23_containers/mdspan/extents/custom_integer.cc
> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/extents/custom_integer.cc
> @@ -2,7 +2,7 @@
> #include <mdspan>
>
> #include <testsuite_hooks.h>
> -#include "int_like.h"
> +#include "../int_like.h"
>
> // Test construction from a custom integer-like object, that has
> // no copy/move ctor or copy/move assignment operator.
> @@ -12,51 +12,81 @@ constexpr size_t dyn = std::dynamic_extent;
> static_assert(std::is_convertible_v<IntLike, int>);
> static_assert(std::is_nothrow_constructible_v<int, IntLike>);
>
> -void
> -test_shape(const auto& s2, const auto& s23)
> -{
> - std::extents<int, 2, 3> expected;
> +template<typename Extents, bool Valid>
> + void
> + test_shape(const auto& shape)
> + {
> + static_assert(std::is_constructible_v<Extents, decltype(shape)> ==
> Valid);
>
> - std::extents<int, 2, 3> e1(s23);
> - VERIFY(e1 == expected);
> + if constexpr (Valid)
> + {
> + std::extents<int, 2, 3> expected;
> + Extents actual(shape);
> + VERIFY(actual == expected);
> + }
> + }
>
> - std::extents<int, dyn, 3> e2(s2);
> - VERIFY(e2 == expected);
> +template<typename Int, bool Valid>
> + void
> + test_shape_all()
> + {
> + auto a2 = std::array<Int, 1>{Int(2)};
> + auto s2 = std::span<Int, 1>(a2);
>
> - std::extents<int, dyn, 3> e3(s23);
> - VERIFY(e3 == expected);
> + auto a23 = std::array<Int, 2>{Int(2), Int(3)};
> + auto s23 = std::span<Int, 2>(a23);
>
> - std::extents<int, dyn, dyn> e4(s23);
> - VERIFY(e4 == expected);
> -}
> + auto check = [](const auto& dyn_exts, const auto& full_exts)
> + {
> + test_shape<std::extents<int, 2, 3>, Valid>(full_exts);
> + test_shape<std::extents<int, dyn, 3>, Valid>(dyn_exts);
> + test_shape<std::extents<int, dyn, 3>, Valid>(full_exts);
> + test_shape<std::extents<int, dyn, dyn>, Valid>(full_exts);
> + };
>
> -void
> -test_pack()
> -{
> - std::extents<int, 2, 3> expected;
> + check(a2, a23);
> + check(s2, s23);
> + }
>
> - std::extents<int, dyn, 3> e1(IntLike(2));
> - VERIFY(e1 == expected);
> +// Needed because is_constructible requires that Ints are move
> constructible.
> +template<typename Extents, typename... Ints>
> + concept has_ctor = requires
> + {
> + { Extents(Ints(0)...) } -> std::same_as<Extents>;
> + };
>
> - std::extents<int, dyn, 3> e2(IntLike(2), IntLike(3));
> - VERIFY(e2 == expected);
> +template<typename Int, bool Valid>
> + void
> + test_pack_all()
> + {
> + static_assert(has_ctor<std::extents<int, dyn, 3>, Int> == Valid);
> + static_assert(has_ctor<std::extents<int, dyn, 3>, Int, Int> == Valid);
> + static_assert(has_ctor<std::extents<int, dyn, dyn>, Int, Int> ==
> Valid);
>
> - std::extents<int, dyn, dyn> e3(IntLike(2), IntLike(3));
> - VERIFY(e3 == expected);
> -}
> + if constexpr (Valid)
> + {
> + std::extents<int, 2, 3> expected;
> +
> + std::extents<int, dyn, 3> e1(Int(2));
> + VERIFY(e1 == expected);
> +
> + std::extents<int, dyn, 3> e2(Int(2), Int(3));
> + VERIFY(e2 == expected);
> +
> + std::extents<int, dyn, dyn> e3(Int(2), Int(3));
> + VERIFY(e3 == expected);
> + }
> + }
>
> int
> main()
> {
> - auto a2 = std::array<IntLike, 1>{IntLike(2)};
> - auto s2 = std::span<IntLike, 1>(a2);
> -
> - auto a23 = std::array<IntLike, 2>{IntLike(2), IntLike(3)};
> - auto s23 = std::span<IntLike, 2>(a23);
> -
> - test_shape(a2, a23);
> - test_shape(s2, s23);
> - test_pack();
> + test_shape_all<int, true>();
> + test_shape_all<IntLike, true>();
> + test_shape_all<ThrowingInt, false>();
>
> + test_pack_all<int, true>();
> + test_pack_all<IntLike, true>();
> + test_pack_all<ThrowingInt, false>();
> return 0;
> }
> diff --git
> a/libstdc++-v3/testsuite/23_containers/mdspan/extents/int_like.h
> b/libstdc++-v3/testsuite/23_containers/mdspan/extents/int_like.h
> deleted file mode 100644
> index f39f4cc9081..00000000000
> --- a/libstdc++-v3/testsuite/23_containers/mdspan/extents/int_like.h
> +++ /dev/null
> @@ -1,30 +0,0 @@
> -#ifndef TEST_MDSPAN_INT_LIKE_H
> -#define TEST_MDSPAN_INT_LIKE_H
> -
> -class IntLike
> -{
> -public:
> - explicit
> - IntLike(int i)
> - : _M_i(i)
> - { }
> -
> - IntLike() = delete;
> - IntLike(const IntLike&) = delete;
> - IntLike(IntLike&&) = delete;
> -
> - const IntLike&
> - operator=(const IntLike&) = delete;
> -
> - const IntLike&
> - operator=(IntLike&&) = delete;
> -
> - constexpr
> - operator int() const noexcept
> - { return _M_i; }
> -
> -private:
> - int _M_i;
> -};
> -
> -#endif // TEST_MDSPAN_INT_LIKE_H
> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/int_like.h
> b/libstdc++-v3/testsuite/23_containers/mdspan/int_like.h
> new file mode 100644
> index 00000000000..ed45375f986
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/int_like.h
> @@ -0,0 +1,49 @@
> +#ifndef TEST_MDSPAN_INT_LIKE_H
> +#define TEST_MDSPAN_INT_LIKE_H
> +
> +enum class CustomIndexKind
> +{
> + Const,
> + Throwing,
> +};
> +
> +template<CustomIndexKind Kind>
> + class CustomIndexType
> + {
> + public:
> + explicit
> + CustomIndexType(int i)
> + : _M_i(i)
> + { }
> +
> + CustomIndexType() = delete;
> + CustomIndexType(const CustomIndexType&) = delete;
> + CustomIndexType(CustomIndexType&&) = delete;
> +
> + const CustomIndexType&
> + operator=(const CustomIndexType&) = delete;
> +
> + const CustomIndexType&
> + operator=(CustomIndexType&&) = delete;
> +
> + constexpr
> + operator int() const noexcept
> + requires (Kind == CustomIndexKind::Const)
> + { return _M_i; }
> +
> + constexpr
> + operator int() const
> + requires (Kind == CustomIndexKind::Throwing)
> + { return _M_i; }
> +
> + private:
> + int _M_i;
> + };
> +
> +using IntLike = CustomIndexType<CustomIndexKind::Const>;
> +using ThrowingInt = CustomIndexType<CustomIndexKind::Throwing>;
> +
> +struct NotIntLike
> +{ };
> +
> +#endif // TEST_MDSPAN_INT_LIKE_H
> diff --git
> a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
> index 963c804a369..17f0c00acf2 100644
> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
> @@ -1,6 +1,7 @@
> // { dg-do run { target c++23 } }
> #include <mdspan>
>
> +#include "../int_like.h"
> #include <cstdint>
> #include <testsuite_hooks.h>
>
> @@ -59,14 +60,13 @@ template<typename Mapping, size_t N>
> return ret;
> }
>
> -template<typename Mapping, typename... Indices>
> +template<typename Int, typename Mapping, typename... Indices>
> constexpr void
> test_linear_index(const Mapping& m, Indices... i)
> {
> using index_type = typename Mapping::index_type;
> index_type expected = linear_index(m, std::array{index_type(i)...});
> - VERIFY(m(i...) == expected);
> - VERIFY(m(uint8_t(i)...) == expected);
> + VERIFY(m(Int(i)...) == expected);
> }
>
> template<typename Layout>
> @@ -77,26 +77,26 @@ template<typename Layout>
> VERIFY(m() == 0);
> }
>
> -template<typename Layout>
> +template<typename Layout, typename Int>
> constexpr void
> test_linear_index_1d()
> {
> typename Layout::mapping<std::extents<int, 5>> m;
> - test_linear_index(m, 0);
> - test_linear_index(m, 1);
> - test_linear_index(m, 4);
> + test_linear_index<Int>(m, 0);
> + test_linear_index<Int>(m, 1);
> + test_linear_index<Int>(m, 4);
> }
>
> -template<typename Layout>
> +template<typename Layout, typename Int>
> constexpr void
> test_linear_index_2d()
> {
> typename Layout::mapping<std::extents<int, 3, 256>> m;
> - test_linear_index(m, 0, 0);
> - test_linear_index(m, 1, 0);
> - test_linear_index(m, 0, 1);
> - test_linear_index(m, 1, 1);
> - test_linear_index(m, 2, 4);
> + test_linear_index<Int>(m, 0, 0);
> + test_linear_index<Int>(m, 1, 0);
> + test_linear_index<Int>(m, 0, 1);
> + test_linear_index<Int>(m, 1, 1);
> + test_linear_index<Int>(m, 2, 4);
> }
>
> template<typename Layout>
> @@ -141,44 +141,34 @@ template<>
> }
> };
>
> -template<typename Layout>
> +template<typename Layout, typename Int>
> constexpr void
> test_linear_index_3d()
> {
> auto m = MappingFactory<Layout>::create(std::extents(3, 5, 7));
> - test_linear_index(m, 0, 0, 0);
> - test_linear_index(m, 1, 0, 0);
> - test_linear_index(m, 0, 1, 0);
> - test_linear_index(m, 0, 0, 1);
> - test_linear_index(m, 1, 1, 0);
> - test_linear_index(m, 2, 4, 6);
> + test_linear_index<Int>(m, 0, 0, 0);
> + test_linear_index<Int>(m, 1, 0, 0);
> + test_linear_index<Int>(m, 0, 1, 0);
> + test_linear_index<Int>(m, 0, 0, 1);
> + test_linear_index<Int>(m, 1, 1, 0);
> + test_linear_index<Int>(m, 2, 4, 6);
> }
>
> -struct IntLikeA
> -{
> - operator int()
> - { return 0; }
> -};
> -
> -struct IntLikeB
> -{
> - operator int() noexcept
> - { return 0; }
> -};
> -
> -struct NotIntLike
> -{ };
> +template<typename Mapping, typename... Ints>
> + concept has_linear_index = requires (Mapping m)
> + {
> + { m(Ints(0)...) } -> std::same_as<typename Mapping::index_type>;
> + };
>
> template<typename Layout>
> constexpr void
> test_has_linear_index_0d()
> {
> using Mapping = typename Layout::mapping<std::extents<int>>;
> - static_assert(std::invocable<Mapping>);
> - static_assert(!std::invocable<Mapping, int>);
> - static_assert(!std::invocable<Mapping, IntLikeA>);
> - static_assert(!std::invocable<Mapping, IntLikeB>);
> - static_assert(!std::invocable<Mapping, NotIntLike>);
> + static_assert(has_linear_index<Mapping>);
> + static_assert(!has_linear_index<Mapping, int>);
> + static_assert(!has_linear_index<Mapping, IntLike>);
> + static_assert(!has_linear_index<Mapping, NotIntLike>);
> }
>
> template<typename Layout>
> @@ -186,12 +176,13 @@ template<typename Layout>
> test_has_linear_index_1d()
> {
> using Mapping = typename Layout::mapping<std::extents<int, 3>>;
> - static_assert(std::invocable<Mapping, int>);
> - static_assert(!std::invocable<Mapping>);
> - static_assert(!std::invocable<Mapping, IntLikeA>);
> - static_assert(std::invocable<Mapping, IntLikeB>);
> - static_assert(!std::invocable<Mapping, NotIntLike>);
> - static_assert(std::invocable<Mapping, double>);
> + static_assert(!has_linear_index<Mapping>);
> + static_assert(has_linear_index<Mapping, int>);
> + static_assert(has_linear_index<Mapping, double>);
> + static_assert(has_linear_index<Mapping, IntLike>);
> + static_assert(!has_linear_index<Mapping, ThrowingInt>);
> + static_assert(!has_linear_index<Mapping, NotIntLike>);
> + static_assert(!has_linear_index<Mapping, int, int>);
> }
>
> template<typename Layout>
> @@ -199,22 +190,23 @@ template<typename Layout>
> test_has_linear_index_2d()
> {
> using Mapping = typename Layout::mapping<std::extents<int, 3, 5>>;
> - static_assert(std::invocable<Mapping, int, int>);
> - static_assert(!std::invocable<Mapping, int>);
> - static_assert(!std::invocable<Mapping, IntLikeA, int>);
> - static_assert(std::invocable<Mapping, IntLikeB, int>);
> - static_assert(!std::invocable<Mapping, NotIntLike, int>);
> - static_assert(std::invocable<Mapping, double, double>);
> + static_assert(!has_linear_index<Mapping, int>);
> + static_assert(has_linear_index<Mapping, int, int>);
> + static_assert(has_linear_index<Mapping, double, double>);
> + static_assert(has_linear_index<Mapping, IntLike, int>);
> + static_assert(!has_linear_index<Mapping, ThrowingInt, int>);
> + static_assert(!has_linear_index<Mapping, NotIntLike, int>);
> + static_assert(!has_linear_index<Mapping, int, int, int>);
> }
>
> -template<typename Layout>
> +template<typename Layout, typename Int>
> constexpr bool
> test_linear_index_all()
> {
> test_linear_index_0d<Layout>();
> - test_linear_index_1d<Layout>();
> - test_linear_index_2d<Layout>();
> - test_linear_index_3d<Layout>();
> + test_linear_index_1d<Layout, Int>();
> + test_linear_index_2d<Layout, Int>();
> + test_linear_index_3d<Layout, Int>();
> test_has_linear_index_0d<Layout>();
> test_has_linear_index_1d<Layout>();
> test_has_linear_index_2d<Layout>();
> @@ -527,7 +519,13 @@ template<typename Layout>
> constexpr bool
> test_mapping_all()
> {
> - test_linear_index_all<Layout>();
> + test_linear_index_all<Layout, uint8_t>();
> + test_linear_index_all<Layout, int>();
> + if !consteval
> + {
> + test_linear_index_all<Layout, IntLike>();
> + }
> +
> test_required_span_size_all<Layout>();
> test_stride_all<Layout>();
>
> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
> index c8af5c61254..1267306fb5c 100644
> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/stride.cc
> @@ -1,6 +1,7 @@
> // { dg-do run { target c++23 } }
> #include <mdspan>
>
> +#include "../int_like.h"
> #include <testsuite_hooks.h>
>
> constexpr size_t dyn = std::dynamic_extent;
> @@ -42,21 +43,6 @@ test_ctor_default_stride_all()
> return true;
> }
>
> -struct IntLikeA
> -{
> - operator int()
> - { return 0; }
> -};
> -
> -struct IntLikeB
> -{
> - operator int() noexcept
> - { return 0; }
> -};
> -
> -struct NotIntLike
> -{ };
> -
> template<typename E, typename E_arg, typename T, size_t N, bool Expected>
> constexpr void
> test_stride_constructible()
> @@ -77,8 +63,8 @@ test_stride_constructible_all()
> using E2 = std::extents<int, dyn>;
>
> test_stride_constructible<E0, E0, int, 0, true>();
> - test_stride_constructible<E0, E0, IntLikeA, 0, false>();
> - test_stride_constructible<E0, E0, IntLikeB, 0, true>();
> + test_stride_constructible<E0, E0, IntLike, 0, true>();
> + test_stride_constructible<E0, E0, ThrowingInt, 0, false>();
> test_stride_constructible<E0, E0, NotIntLike, 0, false>();
> test_stride_constructible<E1, E1, int, 1, true>();
> test_stride_constructible<E2, E1, int, 1, true>();
> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
> b/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
> index a650fb19bdf..adabb0c6639 100644
> --- a/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/mdspan.cc
> @@ -2,7 +2,7 @@
> #include <mdspan>
>
> #include <testsuite_hooks.h>
> -#include "extents/int_like.h"
> +#include "int_like.h"
> #include "layout_like.h"
>
> constexpr auto dyn = std::dynamic_extent;
> @@ -317,32 +317,50 @@ test_from_accessor()
> return true;
> }
>
> -void
> -test_from_int_like()
> -{
> - constexpr size_t n = 3*5*7;
> - std::array<double, n> storage{};
> +template<typename MDSpan, typename Pointer, typename... Ints>
> + concept has_pack_ctor = requires
> + {
> + { MDSpan(Pointer{}, Ints(0)...) } -> std::same_as<MDSpan>;
> + };
>
> - auto verify = [&](auto md)
> - {
> - VERIFY(md.data_handle() == storage.data());
> - VERIFY(md.extent(0) == 3);
> - VERIFY(md.extent(1) == 5);
> - VERIFY(md.extent(2) == 7);
> +template<typename CustomInt, bool ValidForPacks, bool ValidForArrays>
> + constexpr bool
> + test_from_int_like()
> + {
> + constexpr size_t n = 3*5*7;
> + std::array<double, n> storage{};
>
> - VERIFY((md[IntLike(0), 0, IntLike(0)]) == 0.0);
> - auto zero = std::array{IntLike(0), IntLike(0), IntLike(0)};
> - auto zero_view = std::span<IntLike, 3>{zero};
> - VERIFY((md[zero]) == 0.0);
> - VERIFY((md[zero_view]) == 0.0);
> - };
> + auto verify = [&](auto md)
> + {
> + VERIFY(md.data_handle() == storage.data());
> + VERIFY(md.extent(0) == 3);
> + VERIFY(md.extent(1) == 5);
> + VERIFY(md.extent(2) == 7);
> + };
>
> - auto shape = std::array{IntLike(3), IntLike(5), IntLike(7)};
> - auto shape_view = std::span<IntLike, 3>{shape};
> - verify(std::mdspan(storage.data(), IntLike(3), 5, IntLike(7)));
> - verify(std::mdspan(storage.data(), shape));
> - verify(std::mdspan(storage.data(), shape_view));
> -}
> + static_assert(has_pack_ctor<std::mdspan<float, std::dextents<int, 3>>,
> + float*, CustomInt, int, CustomInt> == ValidForPacks);
> +
> + static_assert(std::is_constructible_v<
> + std::mdspan<float, std::dextents<int, 3>>, float*,
> + std::span<CustomInt, 3>> == ValidForArrays);
> +
> + static_assert(std::is_constructible_v<
> + std::mdspan<float, std::dextents<int, 3>>, float*,
> + std::array<CustomInt, 3>> == ValidForArrays);
> +
> + if constexpr (ValidForPacks)
> + verify(std::mdspan(storage.data(), CustomInt(3), 5, CustomInt(7)));
> +
> + if constexpr (ValidForArrays)
> + {
> + auto shape = std::array{CustomInt(3), CustomInt(5), CustomInt(7)};
> + auto shape_view = std::span<CustomInt, 3>{shape};
> + verify(std::mdspan(storage.data(), shape));
> + verify(std::mdspan(storage.data(), shape_view));
> + }
> + return true;
> + }
>
> template<typename T, bool NothrowConstructible = true,
> bool NothrowAssignable = true>
> @@ -491,32 +509,53 @@ test_empty_all()
> return true;
> }
>
> -constexpr bool
> -test_access()
> +template<typename MDSpan, typename... Args>
> +concept indexable = requires (MDSpan md, Args... args)
> {
> - using Extents = std::extents<int, 3, 5, 7>;
> - auto exts = Extents{};
> + { md[args...] } -> std::same_as<typename MDSpan::reference>;
> +};
>
> - auto mapping = std::layout_left::mapping(exts);
> - constexpr size_t n = mapping.required_span_size();
> - std::array<double, n> storage{};
> +template<typename Int, bool ValidForPacks, bool ValidForArrays>
> + constexpr bool
> + test_access()
> + {
> + using Extents = std::extents<int, 3, 5, 7>;
> + auto exts = Extents{};
>
> - auto md = std::mdspan(storage.data(), mapping);
> - static_assert(std::__mdspan::__mapping_alike<decltype(md)>);
> + auto mapping = std::layout_left::mapping(exts);
> + constexpr size_t n = mapping.required_span_size();
> + std::array<double, n> storage{};
>
> - for(int i = 0; i < exts.extent(0); ++i)
> - for(int j = 0; j < exts.extent(1); ++j)
> - for(int k = 0; k < exts.extent(2); ++k)
> - {
> - std::array<int, 3> ijk{i, j, k};
> - storage[mapping(i, j, k)] = 1.0;
> - VERIFY((md[i, j, k]) == 1.0);
> - VERIFY((md[ijk]) == 1.0);
> - VERIFY((md[std::span(ijk)]) == 1.0);
> - storage[mapping(i, j, k)] = 0.0;
> - }
> - return true;
> -}
> + auto md = std::mdspan(storage.data(), mapping);
> + using MDSpan = decltype(md);
> +
> + for(int i = 0; i < exts.extent(0); ++i)
> + for(int j = 0; j < exts.extent(1); ++j)
> + for(int k = 0; k < exts.extent(2); ++k)
> + {
> + storage[mapping(i, j, k)] = 1.0;
> + if constexpr (ValidForPacks)
> + VERIFY((md[Int(i), Int(j), Int(k)]) == 1.0);
> +
> + if constexpr (ValidForArrays)
> + {
> + std::array<Int, 3> ijk{Int(i), Int(j), Int(k)};
> + VERIFY((md[ijk]) == 1.0);
> + VERIFY((md[std::span(ijk)]) == 1.0);
> + }
> + storage[mapping(i, j, k)] = 0.0;
> + }
> +
> + if constexpr (!ValidForPacks)
> + static_assert(!indexable<MDSpan, Int, int, Int>);
> +
> + if constexpr (!ValidForArrays)
> + {
> + static_assert(!indexable<MDSpan, std::array<Int, 3>>);
> + static_assert(!indexable<MDSpan, std::span<Int, 3>>);
> + }
> + return true;
> + }
>
> constexpr bool
> test_swap()
> @@ -650,14 +689,20 @@ main()
> test_from_accessor();
> static_assert(test_from_accessor());
>
> - test_from_int_like();
> + test_from_int_like<int, true, true>();
> + static_assert(test_from_int_like<int, true, true>());
> + test_from_int_like<IntLike, true, true>();
> + test_from_int_like<ThrowingInt, false, false>();
> +
> test_from_opaque_accessor();
> test_from_base_class_accessor();
> test_from_mapping_like();
> static_assert(test_from_mapping_like());
>
> - test_access();
> - static_assert(test_access());
> + test_access<int, true, true>();
> + static_assert(test_access<int, true, true>());
> + test_access<IntLike, true, true>();
> + test_access<ThrowingInt, false, false>();
>
> test_swap();
> static_assert(test_swap());
> --
> 2.50.0
>
>
