diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -439,6 +439,7 @@
   __iterator/wrap_iter.h
   __locale
   __mbstate_t.h
+  __mdspan/extents.h
   __memory/addressof.h
   __memory/align.h
   __memory/aligned_alloc.h
@@ -854,6 +855,7 @@
   locale.h
   map
   math.h
+  mdspan
   memory
   memory_resource
   mutex
diff --git a/libcxx/include/__mdspan/extents.h b/libcxx/include/__mdspan/extents.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__mdspan/extents.h
@@ -0,0 +1,476 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXTENTS
+#define _LIBCPP_EXTENTS
+
+#include <array>
+#include <cinttypes>
+#include <limits>
+#include <span>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20
+
+namespace detail {
+
+// ------------------------------------------------------------------
+// ------------ static_array ----------------------------------------
+// ------------------------------------------------------------------
+// array like class which provides an array of static values with get
+
+// Implementation of Static Array with recursive implementation of get.
+template <size_t R, class T, T... Extents>
+struct static_array_impl;
+
+template <size_t R, class T, T FirstExt, T... Extents>
+struct static_array_impl<R, T, FirstExt, Extents...> {
+  constexpr static T get(size_t r) noexcept {
+    if (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::get(r);
+  }
+  template <size_t r>
+  constexpr static T get() {
+    if constexpr (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::template get<r>();
+  }
+};
+
+// End the recursion
+template <size_t R, class T, T FirstExt>
+struct static_array_impl<R, T, FirstExt> {
+  constexpr static T get(size_t) noexcept { return FirstExt; }
+  template <size_t>
+  constexpr static T get() {
+    return FirstExt;
+  }
+};
+
+// Don't start recursion if size 0
+template <class T>
+struct static_array_impl<0, T> {
+  constexpr static T get(size_t) noexcept { return T(); }
+  template <size_t>
+  constexpr static T get() {
+    return T();
+  }
+};
+
+// Static array, provides get<r>(), get(r) and operator[r]
+template <class T, T... Values>
+struct static_array : public static_array_impl<0, T, Values...> {
+public:
+  using value_type = T;
+
+  constexpr static size_t size() { return sizeof...(Values); }
+};
+
+// ------------------------------------------------------------------
+// ------------ index_sequence_scan ---------------------------------
+// ------------------------------------------------------------------
+
+// index_sequence_scan takes compile time values and provides get(r)
+//  which return the sum of the first r-1 values.
+
+// Recursive implementation for get
+template <size_t R, size_t... Values>
+struct index_sequence_scan_impl;
+
+template <size_t R, size_t FirstVal, size_t... Values>
+struct index_sequence_scan_impl<R, FirstVal, Values...> {
+  constexpr static size_t get(size_t r) {
+    if (r > R)
+      return FirstVal + index_sequence_scan_impl<R + 1, Values...>::get(r);
+    else
+      return 0;
+  }
+};
+
+template <size_t R, size_t FirstVal>
+struct index_sequence_scan_impl<R, FirstVal> {
+#  if defined(__NVCC__) || defined(__NVCOMPILER)
+  // NVCC warns about pointless comparison with 0 for R==0 and r being const
+  // evaluatable and also 0.
+  constexpr static size_t get(size_t r) { return static_cast<int64_t>(R) > static_cast<int64_t>(r) ? FirstVal : 0; }
+#  else
+  constexpr static size_t get(size_t r) { return R > r ? FirstVal : 0; }
+#  endif
+};
+template <>
+struct index_sequence_scan_impl<0> {
+  constexpr static size_t get(size_t) { return 0; }
+};
+
+// ------------------------------------------------------------------
+// ------------ possibly_empty_array  -------------------------------
+// ------------------------------------------------------------------
+
+// array like class which provides get function and operator [], and
+// has a specialization for the size 0 case.
+// This is needed to make the maybe_static_array be truly empty, for
+// all static values.
+
+template <class T, size_t N>
+struct possibly_empty_array {
+  T vals[N];
+  constexpr T& operator[](size_t r) { return vals[r]; }
+  constexpr const T& operator[](size_t r) const { return vals[r]; }
+};
+
+template <class T>
+struct possibly_empty_array<T, 0> {
+  constexpr T operator[](size_t) { return T(); }
+  constexpr const T operator[](size_t) const { return T(); }
+};
+
+// ------------------------------------------------------------------
+// ------------ maybe_static_array ----------------------------------
+// ------------------------------------------------------------------
+
+// array like class which has a mix of static and runtime values but
+// only stores the runtime values.
+// The type of the static and the runtime values can be different.
+// The position of a dynamic value is indicated through a tag value.
+template <class TDynamic, class TStatic, TStatic dyn_tag, TStatic... Values>
+struct maybe_static_array {
+  static_assert(is_convertible<TStatic, TDynamic>::value,
+                "maybe_static_array: TStatic must be convertible to TDynamic");
+  static_assert(is_convertible<TDynamic, TStatic>::value,
+                "maybe_static_array: TDynamic must be convertible to TStatic");
+
+private:
+  // Static values member
+  using static_vals_t                    = static_array<TStatic, Values...>;
+  constexpr static size_t m_size         = sizeof...(Values);
+  constexpr static size_t m_size_dynamic = ((Values == dyn_tag) + ... + 0);
+
+  // Dynamic values member
+  [[no_unique_address]] possibly_empty_array<TDynamic, m_size_dynamic> m_dyn_vals;
+
+  // static mapping of indices to the position in the dynamic values array
+  using dyn_map_t = index_sequence_scan_impl<0, static_cast<size_t>(Values == dyn_tag)...>;
+
+public:
+  // two types for static and dynamic values
+  using value_type        = TDynamic;
+  using static_value_type = TStatic;
+  // tag value indicating dynamic value
+  constexpr static static_value_type tag_value = dyn_tag;
+
+  constexpr maybe_static_array() = default;
+
+  // constructor for all static values
+  // TODO: add precondition check?
+  template <class... Vals>
+    requires((m_size_dynamic == 0) && (sizeof...(Vals) > 0))
+  constexpr maybe_static_array(Vals...) : m_dyn_vals{} {}
+
+  // constructors from dynamic values only
+  template <class... DynVals>
+    requires(sizeof...(DynVals) == m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(DynVals... vals) : m_dyn_vals{static_cast<TDynamic>(vals)...} {}
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N > 0)
+  constexpr maybe_static_array(const std::array<T, N>& vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
+  }
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N == 0)
+  constexpr maybe_static_array(const std::array<T, N>&) : m_dyn_vals{} {}
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N > 0)
+  constexpr maybe_static_array(const std::span<T, N>& vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
+  }
+
+  template <class T, size_t N>
+    requires(N == m_size_dynamic && N == 0)
+  constexpr maybe_static_array(const std::span<T, N>&) : m_dyn_vals{} {}
+
+  // constructors from all values
+  template <class... DynVals>
+    requires(sizeof...(DynVals) != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(DynVals... vals) {
+    static_assert((sizeof...(DynVals) == m_size), "Invalid number of values.");
+    TDynamic values[m_size]{static_cast<TDynamic>(vals)...};
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = values[r];
+      }
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(values[r] == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  template <class T, size_t N>
+    requires(N != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(const std::array<T, N>& vals) {
+    static_assert((N == m_size), "Invalid number of values.");
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
+#  endif
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+// Precondition check
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  template <class T, size_t N>
+    requires(N != m_size_dynamic && m_size_dynamic > 0)
+  constexpr maybe_static_array(const std::span<T, N>& vals) {
+    static_assert((N == m_size) || (m_size == dynamic_extent));
+#  ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
+#  endif
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+#  ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) == static_cast<TDynamic>(static_val));
+      }
+#  endif
+    }
+  }
+
+  // access functions
+  constexpr static TStatic static_value(size_t r) noexcept { return static_vals_t::get(r); }
+
+  constexpr TDynamic value(size_t r) const {
+    TStatic static_val = static_vals_t::get(r);
+    return static_val == dyn_tag ? m_dyn_vals[dyn_map_t::get(r)] : static_cast<TDynamic>(static_val);
+  }
+  constexpr TDynamic operator[](size_t r) const { return value(r); }
+
+  // observers
+  constexpr static size_t size() { return m_size; }
+  constexpr static size_t size_dynamic() { return m_size_dynamic; }
+};
+
+} // namespace detail
+
+// ------------------------------------------------------------------
+// ------------ extents ---------------------------------------------
+// ------------------------------------------------------------------
+
+// Class to describe the extents of a multi dimensional array.
+// Used by mdspan, mdarray and layout mappings.
+// See ISO C++ standard [mdspan.extents]
+
+template <class IndexType, size_t... Extents>
+class extents {
+public:
+  // typedefs for integral types used
+  using index_type = IndexType;
+  using size_type  = make_unsigned_t<index_type>;
+  using rank_type  = size_t;
+
+  static_assert(std::is_integral<index_type>::value && !std::is_same<index_type, bool>::value,
+                "extents::index_type must be a signed or unsigned integer type");
+
+private:
+  constexpr static rank_type m_rank         = sizeof...(Extents);
+  constexpr static rank_type m_rank_dynamic = ((Extents == dynamic_extent) + ... + 0);
+
+  // internal storage type using maybe_static_array
+  using vals_t = detail::maybe_static_array<IndexType, size_t, dynamic_extent, Extents...>;
+  [[no_unique_address]] vals_t m_vals;
+
+public:
+  // [mdspan.extents.obs], observers of multidimensional index space
+  constexpr static rank_type rank() noexcept { return m_rank; }
+  constexpr static rank_type rank_dynamic() noexcept { return m_rank_dynamic; }
+
+  constexpr index_type extent(rank_type r) const noexcept { return m_vals.value(r); }
+  constexpr static size_t static_extent(rank_type r) noexcept { return vals_t::static_value(r); }
+
+  // [mdspan.extents.cons], constructors
+  constexpr extents() noexcept = default;
+
+  // Construction from just dynamic or all values.
+  // Precondition check is deferred to maybe_static_array constructor
+  template <class... OtherIndexTypes>
+    requires((is_convertible_v<OtherIndexTypes, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...) &&
+             (sizeof...(OtherIndexTypes) == m_rank || sizeof...(OtherIndexTypes) == m_rank_dynamic))
+  constexpr explicit extents(OtherIndexTypes... dynvals) noexcept : m_vals(static_cast<index_type>(dynvals)...) {}
+
+  template <class OtherIndexType, size_t N>
+    requires(is_convertible_v<OtherIndexType, index_type>&& is_nothrow_constructible_v<index_type, OtherIndexType> &&
+             (N == m_rank || N == m_rank_dynamic))
+  explicit(N != m_rank_dynamic) constexpr extents(const array<OtherIndexType, N>& exts) noexcept
+      : m_vals(std::move(exts)) {}
+
+  template <class OtherIndexType, size_t N>
+    requires(is_convertible_v<OtherIndexType, index_type>&& is_nothrow_constructible_v<index_type, OtherIndexType> &&
+             (N == m_rank || N == m_rank_dynamic))
+  explicit(N != m_rank_dynamic) constexpr extents(const span<OtherIndexType, N>& exts) noexcept
+      : m_vals(std::move(exts)) {}
+
+private:
+  // Function to construct extents storage from other extents.
+  // With C++ 17 the first two variants could be collapsed using if constexpr
+  // in which case you don't need all the requires clauses.
+  // in C++ 14 mode that doesn't work due to infinite recursion
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R < m_rank) && (static_extent(R) == dynamic_extent))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents& exts,
+      DynamicValues... dynamic_values)
+  noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount + 1>(),
+        std::integral_constant<size_t, R + 1>(),
+        exts,
+        dynamic_values...,
+        exts.extent(R));
+  }
+
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R < m_rank) && (static_extent(R) != dynamic_extent))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents& exts,
+      DynamicValues... dynamic_values)
+  noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount>(), std::integral_constant<size_t, R + 1>(), exts, dynamic_values...);
+  }
+
+  template <size_t DynCount, size_t R, class OtherExtents, class... DynamicValues>
+    requires((R == m_rank) && (DynCount == m_rank_dynamic))
+  vals_t __construct_vals_from_extents(
+      std::integral_constant<size_t, DynCount>,
+      std::integral_constant<size_t, R>,
+      const OtherExtents&,
+      DynamicValues... dynamic_values)
+  noexcept { return vals_t{static_cast<index_type>(dynamic_values)...}; }
+
+public:
+  // Converting constructor from other extents specializations
+  template <class OtherIndexType, size_t... OtherExtents>
+    requires((sizeof...(OtherExtents) == sizeof...(Extents)) &&
+             ((OtherExtents == dynamic_extent || Extents == dynamic_extent || OtherExtents == Extents) && ...))
+  explicit(
+      (((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || ...) ||
+      (std::numeric_limits<index_type>::max() <
+       std::numeric_limits<OtherIndexType>::max())) constexpr extents(const extents<OtherIndexType, OtherExtents...>&
+                                                                          other) noexcept
+      : m_vals(__construct_vals_from_extents(
+            std::integral_constant<size_t, 0>(), std::integral_constant<size_t, 0>(), other)) {}
+
+  // Comparison operator
+  template <class OtherIndexType, size_t... OtherExtents>
+  friend constexpr bool operator==(const extents& lhs, const extents<OtherIndexType, OtherExtents...>& rhs) noexcept {
+    bool value = true;
+    if constexpr (rank() != sizeof...(OtherExtents)) {
+      value = false;
+    } else {
+      for (size_type r = 0; r < m_rank; r++)
+        value &= static_cast<index_type>(rhs.extent(r)) == lhs.extent(r);
+    }
+    return value;
+  }
+
+  template <class OtherIndexType, size_t... OtherExtents>
+  friend constexpr bool operator!=(extents const& lhs, extents<OtherIndexType, OtherExtents...> const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+};
+
+// Recursive helper classes to implement dextents alias for extents
+namespace detail {
+
+template <class IndexType, size_t Rank, class Extents = extents<IndexType>>
+struct __make_dextents;
+
+template <class IndexType, size_t Rank, size_t... ExtentsPack>
+struct __make_dextents< IndexType, Rank, extents<IndexType, ExtentsPack...>> {
+  using type = typename __make_dextents< IndexType, Rank - 1, extents<IndexType, dynamic_extent, ExtentsPack...>>::type;
+};
+
+template <class IndexType, size_t... ExtentsPack>
+struct __make_dextents< IndexType, 0, extents<IndexType, ExtentsPack...>> {
+  using type = extents<IndexType, ExtentsPack...>;
+};
+
+} // end namespace detail
+
+// [mdspan.extents.dextents], alias template
+template <class IndexType, size_t Rank>
+using dextents = typename detail::__make_dextents<IndexType, Rank>::type;
+
+// Deduction guide for extents
+template <class... IndexTypes>
+extents(IndexTypes...) -> extents<size_t, size_t((IndexTypes(), dynamic_extent))...>;
+
+// Helper type traits for identifying a class as extents.
+namespace detail {
+
+template <class T>
+struct __is_extents : ::std::false_type {};
+
+template <class IndexType, size_t... ExtentsPack>
+struct __is_extents<extents<IndexType, ExtentsPack...>> : ::std::true_type {};
+
+template <class T>
+inline constexpr bool __is_extents_v = __is_extents<T>::value;
+
+} // namespace detail
+
+#endif // _LIBCPP_STD_VER > 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_EXTENTS
diff --git a/libcxx/include/mdspan b/libcxx/include/mdspan
new file mode 100644
--- /dev/null
+++ b/libcxx/include/mdspan
@@ -0,0 +1,29 @@
+// -*-C++ - *-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_MDSPAN
+#define _LIBCPP_MDSPAN
+
+#include <__config>
+#include <__mdspan/extents.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_MDSPAN
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -1119,6 +1119,16 @@
     export initializer_list
     export *
   }
+  module mdspan {
+    header "mdspan"
+    export array
+    export span
+    export *
+
+    module __mdspan {
+      module extents                         { private header "__mdspan/extents.h" }
+    }
+  }
   module memory {
     header "memory"
     export *
diff --git a/libcxx/test/std/containers/views/mdspan/extents/ConvertibleToIntegral.h b/libcxx/test/std/containers/views/mdspan/extents/ConvertibleToIntegral.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/ConvertibleToIntegral.h
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CONVERTIBLE_TO_INTEGRAL_H
+#define CONVERTIBLE_TO_INTEGRAL_H
+
+struct IntType {
+  int val;
+  constexpr IntType() = default;
+  constexpr IntType(int v) noexcept : val(v){};
+
+  constexpr bool operator==(const IntType& rhs) const { return val == rhs.val; }
+  constexpr operator int() const noexcept { return val; }
+  constexpr operator unsigned char() const noexcept { return val; }
+};
+
+#endif
diff --git a/libcxx/test/std/containers/views/mdspan/extents/comparison.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/comparison.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/comparison.pass.cpp
@@ -0,0 +1,68 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class To, class From>
+void test_comparison(bool equal, To dest, From src) {
+  assert((dest == src) == equal);
+  assert((dest != src) != equal);
+}
+
+template <class T1, class T2>
+void test_comparison_different_rank() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_comparison(false, std::extents<T1>(), std::extents<T2, D>(1));
+  test_comparison(false, std::extents<T1>(), std::extents<T2, 1>());
+
+  test_comparison(false, std::extents<T1, D>(1), std::extents<T2>());
+  test_comparison(false, std::extents<T1, 1>(), std::extents<T2>());
+
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, D, D>(5, 5));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 5, D>(5));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 5, 1>());
+
+  test_comparison(false, std::extents<T1, D, D>(5, 5), std::extents<T2, D>(5));
+  test_comparison(false, std::extents<T1, 5, D>(5), std::extents<T2, D>(5));
+  test_comparison(false, std::extents<T1, 5, 5>(), std::extents<T2, 5>());
+}
+
+template <class T1, class T2>
+void test_comparison_same_rank() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_comparison(true, std::extents<T1>(), std::extents<T2>());
+
+  test_comparison(true, std::extents<T1, D>(5), std::extents<T2, D>(5));
+  test_comparison(true, std::extents<T1, 5>(), std::extents<T2, D>(5));
+  test_comparison(true, std::extents<T1, D>(5), std::extents<T2, 5>());
+  test_comparison(true, std::extents<T1, 5>(), std::extents< T2, 5>());
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, D>(7));
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, D>(7));
+  test_comparison(false, std::extents<T1, D>(5), std::extents<T2, 7>());
+  test_comparison(false, std::extents<T1, 5>(), std::extents<T2, 7>());
+
+  test_comparison(true, std::extents<T1, D, D, D, D, D>(5, 6, 7, 8, 9), std::extents<T2, D, D, D, D, D>(5, 6, 7, 8, 9));
+  test_comparison(true, std::extents<T1, D, 6, D, 8, D>(5, 7, 9), std::extents<T2, 5, D, D, 8, 9>(6, 7));
+  test_comparison(true, std::extents<T1, 5, 6, 7, 8, 9>(5, 6, 7, 8, 9), std::extents<T2, 5, 6, 7, 8, 9>());
+  test_comparison(
+      false, std::extents<T1, D, D, D, D, D>(5, 6, 7, 8, 9), std::extents<T2, D, D, D, D, D>(5, 6, 3, 8, 9));
+  test_comparison(false, std::extents<T1, D, 6, D, 8, D>(5, 7, 9), std::extents<T2, 5, D, D, 3, 9>(6, 7));
+  test_comparison(false, std::extents<T1, 5, 6, 7, 8, 9>(5, 6, 7, 8, 9), std::extents<T2, 5, 6, 7, 3, 9>());
+}
+
+template <class T1, class T2>
+void test_comparison() {
+  test_comparison_same_rank<T1, T2>();
+  test_comparison_different_rank<T1, T2>();
+}
+
+int main() {
+  test_comparison<int, int>();
+  test_comparison<int, size_t>();
+  test_comparison<size_t, int>();
+  test_comparison<size_t, long>();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp b/libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/cons.fail.cpp
@@ -0,0 +1,77 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+template <class E>
+void implicit_construction(E) {}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  // clang-format off
+  // test less than rank_dynammic args
+  {
+    std::array a1{3};
+    std::span<int, 1> s1(a1.data(), 1);
+    std::extents<T, 1, D, 3, D> e1(2); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a1); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s1); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+  // test more than rank_dynammic but less than rank args
+  {
+    std::array a3{3, 4, 5};
+    std::span<int, 3> s3(a3.data(), 3);
+    std::extents<T, 1, D, 3, D> e1(3, 4, 5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a3); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s3); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+  // test more than rank args
+  {
+    std::array a5{3, 4, 5, 6, 7};
+    std::span<int, 5> s5(a5.data(), 5);
+    std::extents<T, 1, D, 3, D> e1(3, 4, 5, 6, 7); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e2(a5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    std::extents<T, 1, D, 3, D> e3(s5); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, 1, D, 3, D>'}}
+    (void)e1;
+    (void)e2;
+    (void)e3;
+  }
+
+  // test implicit construction fails from span and array if all extents are given
+  {
+    std::array a5{3, 4, 5, 6, 7};
+    std::span<int, 5> s5(a5.data(), 5);
+    // check that explicit construction works, i.e. no error
+    std::extents<int, D, D, 5, D, D> e1(a5);
+    std::extents<int, D, D, 5, D, D> e2(s5);
+    (void)e1;
+    (void)e2;
+    implicit_construction<std::extents<int, D, D, 5, D, D>>(a5); // expected-error {{no matching function for call to 'implicit_construction'}}
+    implicit_construction<std::extents<int, D, D, 5, D, D>>(s5); // expected-error {{no matching function for call to 'implicit_construction'}}
+  }
+  // test construction fails from types not convertible to index_type but convertible to other integer types
+  {
+     std::array a{IntType(3)};
+     std::span<IntType, 1> s{a};
+     std::extents<unsigned long, D> e1(IntType(3)); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     std::extents<unsigned long, D> e2(a); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     std::extents<unsigned long, D> e3(s); // expected-error {{no matching constructor for initialization of 'std::extents<unsigned long, D>'}}
+     (void)e1;
+     (void)e2;
+     (void)e3;
+  }
+  // clang-format on
+}
+
+int main() { test<unsigned long>(); }
diff --git a/libcxx/test/std/containers/views/mdspan/extents/cons.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/cons.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/cons.pass.cpp
@@ -0,0 +1,102 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+// std::extents can be constructed from just indices, a std::array, or a std::span
+// In each of those cases one can either provide all extents, or just the dynamic ones
+// If constructed from std::span, the span needs to have a static extent
+// Furthermore, the indices/array/span can have integer types other than index_type
+
+template <class E, class AllExtents>
+void test_runtime_observers(E ext, AllExtents expected) {
+  for (typename E::rank_type r = 0; r < ext.rank(); r++) {
+    ASSERT_SAME_TYPE(decltype(ext.extent(0)), typename E::index_type);
+    assert(ext.extent(r) == static_cast<typename E::index_type>(expected[r]));
+  }
+}
+
+template <class E, class AllExtents>
+void test_implicit_construction_call(E e, AllExtents all_ext) {
+  test_runtime_observers(e, all_ext);
+}
+
+template <class E, class AllExtents, class Extents>
+void test_implicit_construction(AllExtents all_ext, Extents ext) {
+  test_implicit_construction_call<E>(ext, all_ext);
+  test_implicit_construction_call<E>(
+      std::span<typename Extents::value_type, E::rank_dynamic()>(ext.data(), ext.size()), all_ext);
+}
+
+template <class E, class AllExtents, class Extents, size_t... Indices>
+void test_construction(AllExtents all_ext, Extents ext, std::index_sequence<Indices...>) {
+  // construction from indices
+  test_runtime_observers(E(ext[Indices]...), all_ext);
+  // construction from array
+  test_runtime_observers(E(ext), all_ext);
+  // construction from span
+  test_runtime_observers(
+      E(std::span<typename Extents::value_type, sizeof...(Indices)>(ext.data(), sizeof...(Indices))), all_ext);
+}
+
+template <class E, class AllExtents>
+void test_construction(AllExtents all_ext) {
+  // test construction from all extents
+  test_construction<E>(all_ext, all_ext, std::make_index_sequence<E::rank()>());
+
+  // test construction from just dynamic extents
+  // create an array of just the extents corresponding to dynamic values
+  std::array<typename AllExtents::value_type, E::rank_dynamic()> dyn_ext;
+  size_t dynamic_idx = 0;
+  for (size_t r = 0; r < E::rank(); r++) {
+    if (E::static_extent(r) == std::dynamic_extent) {
+      dyn_ext[dynamic_idx] = all_ext[r];
+      dynamic_idx++;
+    }
+  }
+  test_construction<E>(all_ext, dyn_ext, std::make_index_sequence<E::rank_dynamic()>());
+  test_implicit_construction<E>(all_ext, dyn_ext);
+}
+
+template <class T, class TArg>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  test_construction<std::extents<T>>(std::array<TArg, 0>{});
+
+  test_construction<std::extents<T, 3>>(std::array<TArg, 1>{3});
+  test_construction<std::extents<T, D>>(std::array<TArg, 1>{3});
+
+  test_construction<std::extents<T, 3, 7>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, 3, D>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, D, 7>>(std::array<TArg, 2>{3, 7});
+  test_construction<std::extents<T, D, D>>(std::array<TArg, 2>{3, 7});
+
+  test_construction<std::extents<T, 3, 7, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, 7, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, D, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, 7, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, D, D>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, 3, D, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, D, 9>>(std::array<TArg, 3>{3, 7, 9});
+  test_construction<std::extents<T, D, 7, 9>>(std::array<TArg, 3>{3, 7, 9});
+
+  test_construction<std::extents<T, 1, 2, 3, 4, 5, 6, 7, 8, 9>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+  test_construction<std::extents<T, D, 2, 3, D, 5, D, 7, D, 9>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+  test_construction<std::extents<T, D, D, D, D, D, D, D, D, D>>(std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
+}
+
+int main() {
+  test<int, int>();
+  test<int, size_t>();
+  test<unsigned, int>();
+  test<char, size_t>();
+  test<long long, unsigned>();
+  test<size_t, int>();
+  test<size_t, size_t>();
+  test<int, IntType>();
+  test<unsigned char, IntType>();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/constexpr_usage.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/constexpr_usage.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/constexpr_usage.pass.cpp
@@ -0,0 +1,124 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "ConvertibleToIntegral.h"
+#include "test_macros.h"
+
+// std::extents can be constructed from just indices, a std::array, or a std::span
+// In each of those cases one can either provide all extents, or just the dynamic ones
+// If constructed from std::span, the span needs to have a static extent
+// Furthermore, the indices/array/span can have integer types other than index_type
+
+// All of this should work in constant expressions
+
+// This tests the actual observers and returns the sum of extents + rank
+template <class E, class AllExtents>
+constexpr size_t test_runtime_observers(E ext, AllExtents expected) {
+  size_t result = 0;
+  for (typename E::rank_type r = 0; r < ext.rank(); r++) {
+    result += ext.extent(r) == static_cast<typename E::index_type>(expected[r]);
+    result += ext.extent(r);
+  }
+  return result;
+}
+
+// Make sure constexpr usage of extents works in implicit construction
+template <class E, class AllExtents>
+constexpr size_t test_implicit_construction_call(E e, AllExtents all_ext) {
+  return test_runtime_observers(e, all_ext);
+}
+
+template <class E, class AllExtents, class Extents>
+constexpr size_t test_implicit_construction(AllExtents all_ext, Extents ext) {
+  return test_implicit_construction_call<E>(ext, all_ext) +
+         test_implicit_construction_call<E>(
+             std::span<typename Extents::value_type, E::rank_dynamic()>(ext.data(), ext.size()), all_ext);
+}
+
+template <class E, class AllExtents, class Extents, size_t... Indices>
+constexpr size_t test_construction(AllExtents all_ext, Extents ext, std::index_sequence<Indices...>) {
+  size_t result = 0;
+  // construction from indicies
+  result += test_runtime_observers(E(ext[Indices]...), all_ext);
+  // construction from array
+  result += test_runtime_observers(E(ext), all_ext);
+  // construction from span
+  result += test_runtime_observers(
+      E(std::span<typename Extents::value_type, sizeof...(Indices)>(ext.data(), sizeof...(Indices))), all_ext);
+  return result;
+}
+
+template <class E, class AllExtents>
+constexpr size_t test_construction(AllExtents all_ext) {
+  size_t result = 0;
+  // test construction from all extents
+  result += test_construction<E>(all_ext, all_ext, std::make_index_sequence<E::rank()>());
+
+  // test construction from just dynamic extents
+  // create an array of just the extents corresponding to dynamic values
+  std::array<typename AllExtents::value_type, E::rank_dynamic()> dyn_ext{0};
+  size_t dynamic_idx = 0;
+  for (size_t r = 0; r < E::rank(); r++) {
+    if (E::static_extent(r) == std::dynamic_extent) {
+      dyn_ext[dynamic_idx] = all_ext[r];
+      dynamic_idx++;
+    }
+  }
+  result += test_construction<E>(all_ext, dyn_ext, std::make_index_sequence<E::rank_dynamic()>());
+  result += test_implicit_construction<E>(all_ext, dyn_ext);
+  return result;
+}
+
+template <size_t result, size_t expected>
+struct const_expr {
+  // num_tests is how many different construction scenarios each
+  // construction tests expands to in the end.
+  // expected is the value each individual test return
+  constexpr static size_t num_tests = 8;
+  constexpr static bool value       = result == num_tests * expected;
+};
+
+template <class T, class TArg>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+
+  static_assert(const_expr<test_construction<std::extents<T>>(std::array<TArg, 0>{}), 0>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3>>(std::array<TArg, 1>{3}), 3 + 1>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, D>>(std::array<TArg, 1>{3}), 3 + 1>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D>>(std::array<TArg, 2>{3, 7}), 10 + 2>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, 7, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, D>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, 3, D, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 7, 9>>(std::array<TArg, 3>{3, 7, 9}), 19 + 3>::value);
+
+  static_assert(const_expr<test_construction<std::extents<T, 1, 2, 3, 4, 5, 6, 7, 8, 9>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, 2, 3, D, 5, D, 7, D, 9>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+  static_assert(const_expr<test_construction<std::extents<T, D, D, D, D, D, D, D, D, D>>(
+                               std::array<TArg, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+                           45 + 9>::value);
+}
+
+int main() {
+  test<int, int>();
+  test<int, size_t>();
+  test<char, size_t>();
+  test<int, IntType>();
+  test<unsigned char, IntType>();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/conversion.fail.cpp b/libcxx/test/std/containers/views/mdspan/extents/conversion.fail.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/conversion.fail.cpp
@@ -0,0 +1,81 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::extents can be converted into each other as long as there aren't any
+// mismatched static extents.
+// Convertibility requires that no runtime dimension is assigned to a static dimension,
+// and that the destinations index_type has a larger or equal max value than the
+// sources index_type
+
+// clang-format off
+void test_no_implicit_conversion() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int, D> from;
+    std::extents<int, 5> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<int, D, 7> from;
+    std::extents<int, 5, 7> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<size_t, D> from;
+    std::extents<int, D> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+  {
+    std::extents<size_t, 5> from;
+    std::extents<int, 5> to;
+    to = from; // expected-error {{no viable overloaded '='}}
+  }
+}
+
+void test_rank_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int> from;
+    std::extents<int, D> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, D, D> from;
+    std::extents<int> to0(from); // expected-error {{no matching constructor for initialization of 'std::extents<int>'}}
+    std::extents<int, D> to1(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D>'}}
+    std::extents<int, D, D, D> to3(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D, D, D>'}}
+    (void) to0;
+    (void) to1;
+    (void) to3;
+  }
+}
+
+void test_static_extent_mismatch() {
+  constexpr size_t D = std::dynamic_extent;
+  {
+    std::extents<int, 3> from;
+    std::extents<int, 2> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, 2>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, 3, D> from;
+    std::extents<int, 2, D> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, 2, D>'}}
+    (void) to;
+  }
+  {
+    std::extents<int, D, 2> from;
+    std::extents<int, D, 3> to(from); // expected-error {{no matching constructor for initialization of 'std::extents<int, D, 3>'}}
+    (void) to;
+  }
+}
+// clang-format on
+
+int main() {
+  test_rank_mismatch();
+  test_static_extent_mismatch();
+  test_no_implicit_conversion();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/conversion.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/conversion.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/conversion.pass.cpp
@@ -0,0 +1,57 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+// std::extents can be converted into each other as long as there aren't any
+// mismatched static extents.
+// Convertibility requires that no runtime dimension is assigned to a static dimension,
+// and that the destinations index_type has a larger or equal max value than the
+// sources index_type
+
+template <class To, class From>
+void test_implicit_conversion(To dest, From src) {
+  assert(dest == src);
+}
+
+template <bool implicit, class To, class From>
+void test_conversion(From src) {
+  To dest(src);
+  assert(dest == src);
+  if constexpr (implicit) {
+    dest = src;
+    assert(dest == src);
+    test_implicit_conversion<To, From>(src, src);
+  }
+}
+
+template <class T1, class T2>
+void test_conversion() {
+  constexpr size_t D             = std::dynamic_extent;
+  constexpr bool idx_convertible = std::numeric_limits<T1>::max() >= std::numeric_limits<T2>::max();
+
+  // clang-format off
+  test_conversion<idx_convertible && true,  std::extents<T1>>(std::extents<T2>());
+  test_conversion<idx_convertible && true,  std::extents<T1, D>>(std::extents<T2, D>(5));
+  test_conversion<idx_convertible && false, std::extents<T1, 5>>(std::extents<T2, D>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5>>(std::extents<T2, 5>());
+  test_conversion<idx_convertible && false, std::extents<T1, 5, D>>(std::extents<T2, D, D>(5, 5));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D>>(std::extents<T2, D, D>(5, 5));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D>>(std::extents<T2, D, 7>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5, 7>>(std::extents<T2, 5, 7>());
+  test_conversion<idx_convertible && false, std::extents<T1, 5, D, 8, D, D>>(std::extents<T2, D, D, 8, 9, 1>(5, 7));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D, D, D, D>>(
+                                            std::extents<T2, D, D, D, D, D>(5, 7, 8, 9, 1));
+  test_conversion<idx_convertible && true,  std::extents<T1, D, D, 8, 9, D>>(std::extents<T2, D, 7, 8, 9, 1>(5));
+  test_conversion<idx_convertible && true,  std::extents<T1, 5, 7, 8, 9, 1>>(std::extents<T2, 5, 7, 8, 9, 1>());
+  // clang-format on
+}
+
+int main() {
+  test_conversion<int, int>();
+  test_conversion<int, size_t>();
+  test_conversion<size_t, int>();
+  test_conversion<size_t, long>();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/obs_static.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/obs_static.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/obs_static.pass.cpp
@@ -0,0 +1,60 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class E, size_t rank, size_t rank_dynamic, size_t... StaticExts, size_t... Indices>
+void test_static_observers(std::index_sequence<StaticExts...>, std::index_sequence<Indices...>) {
+  ASSERT_NOEXCEPT(E::rank());
+  static_assert(E::rank() == rank);
+  ASSERT_NOEXCEPT(E::rank_dynamic());
+  static_assert(E::rank_dynamic() == rank_dynamic);
+
+  // Let's only test this if the call isn't a precondition violation
+  if constexpr (rank > 0) {
+    ASSERT_NOEXCEPT(E::static_extent(0));
+    ASSERT_SAME_TYPE(decltype(E::static_extent(0)), size_t);
+    static_assert(((E::static_extent(Indices) == StaticExts) && ...));
+  }
+}
+
+template <class E, size_t rank, size_t rank_dynamic, size_t... StaticExts>
+void test_static_observers() {
+  test_static_observers<E, rank, rank_dynamic>(
+      std::index_sequence<StaticExts...>(), std::make_index_sequence<sizeof...(StaticExts)>());
+}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+  constexpr size_t S = 5;
+
+  test_static_observers<std::extents<T>, 0, 0>();
+
+  test_static_observers<std::extents<T, S>, 1, 0, S>();
+  test_static_observers<std::extents<T, D>, 1, 1, D>();
+
+  test_static_observers<std::extents<T, S, S>, 2, 0, S, S>();
+  test_static_observers<std::extents<T, S, D>, 2, 1, S, D>();
+  test_static_observers<std::extents<T, D, S>, 2, 1, D, S>();
+  test_static_observers<std::extents<T, D, D>, 2, 2, D, D>();
+
+  test_static_observers<std::extents<T, S, S, S>, 3, 0, S, S, S>();
+  test_static_observers<std::extents<T, S, S, D>, 3, 1, S, S, D>();
+  test_static_observers<std::extents<T, S, D, S>, 3, 1, S, D, S>();
+  test_static_observers<std::extents<T, D, S, S>, 3, 1, D, S, S>();
+  test_static_observers<std::extents<T, S, D, D>, 3, 2, S, D, D>();
+  test_static_observers<std::extents<T, D, S, D>, 3, 2, D, S, D>();
+  test_static_observers<std::extents<T, D, D, S>, 3, 2, D, D, S>();
+  test_static_observers<std::extents<T, D, D, D>, 3, 3, D, D, D>();
+}
+
+int main() {
+  test<int>();
+  test<unsigned>();
+  test<char>();
+  test<long long>();
+  test<size_t>();
+}
diff --git a/libcxx/test/std/containers/views/mdspan/extents/types.pass.cpp b/libcxx/test/std/containers/views/mdspan/extents/types.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/containers/views/mdspan/extents/types.pass.cpp
@@ -0,0 +1,55 @@
+#include <mdspan>
+#include <type_traits>
+#include <concepts>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class E, class IndexType, size_t... Extents>
+void testExtents() {
+  ASSERT_SAME_TYPE(typename E::index_type, IndexType);
+  ASSERT_SAME_TYPE(typename E::size_type, std::make_unsigned_t<IndexType>);
+  ASSERT_SAME_TYPE(typename E::rank_type, size_t);
+
+  static_assert(sizeof...(Extents) == E::rank());
+  static_assert((static_cast<size_t>(Extents == std::dynamic_extent) + ...) == E::rank_dynamic());
+
+  static_assert(std::regular<E>);
+  static_assert(std::is_trivially_copyable_v<E>);
+}
+
+template <class IndexType, size_t... Extents>
+void testExtents() {
+  testExtents<std::extents<IndexType, Extents...>, IndexType, Extents...>();
+}
+
+template <class T>
+void test() {
+  constexpr size_t D = std::dynamic_extent;
+  testExtents<T, D>();
+  testExtents<T, 3>();
+  testExtents<T, 3, 3>();
+  testExtents<T, 3, D>();
+  testExtents<T, D, 3>();
+  testExtents<T, D, D>();
+  testExtents<T, 3, 3, 3>();
+  testExtents<T, 3, 3, D>();
+  testExtents<T, 3, D, D>();
+  testExtents<T, D, 3, D>();
+  testExtents<T, D, D, D>();
+  testExtents<T, 3, D, 3>();
+  testExtents<T, D, 3, 3>();
+  testExtents<T, D, D, 3>();
+
+  testExtents<T, 9, 8, 7, 6, 5, 4, 3, 2, 1>();
+  testExtents<T, 9, D, 7, 6, D, D, 3, D, D>();
+  testExtents<T, D, D, D, D, D, D, D, D, D>();
+}
+
+int main() {
+  test<int>();
+  test<unsigned>();
+  test<char>();
+  test<long long>();
+  test<size_t>();
+}