diff --git a/libcxx/docs/ReleaseNotes/22.rst b/libcxx/docs/ReleaseNotes/22.rst
index ec23ba9d1e3a1..b3186f7e486d7 100644
--- a/libcxx/docs/ReleaseNotes/22.rst
+++ b/libcxx/docs/ReleaseNotes/22.rst
@@ -39,7 +39,7 @@ Implemented Papers
 ------------------
 
 - P2321R2: ``zip`` (`Github <https://llvm.org/PR105169>`__) (The paper is partially implemented. ``zip_transform_view``
-  is implemented in this release)
+  and `adjacent_view` are implemented in this release)
 - P3044R2: sub-``string_view`` from ``string`` (`Github <https://llvm.org/PR148140>`__)
 - P3223R2: Making ``std::istream::ignore`` less surprising (`Github <https://llvm.org/PR148178>`__)
 - P3060R3: Add ``std::views::indices(n)`` (`Github <https://llvm.org/PR148175>`__)
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index ddace8bf8c728..9d725f49a18f1 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -696,6 +696,7 @@ set(files
   __random/uniform_real_distribution.h
   __random/weibull_distribution.h
   __ranges/access.h
+  __ranges/adjacent_view.h
   __ranges/all.h
   __ranges/as_rvalue_view.h
   __ranges/chunk_by_view.h
@@ -739,6 +740,7 @@ set(files
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_transform_view.h
+  __ranges/zip_utils.h
   __ranges/zip_view.h
   __split_buffer
   __std_mbstate_t.h
diff --git a/libcxx/include/__ranges/adjacent_view.h b/libcxx/include/__ranges/adjacent_view.h
new file mode 100644
index 0000000000000..873b58d3b4365
--- /dev/null
+++ b/libcxx/include/__ranges/adjacent_view.h
@@ -0,0 +1,408 @@
+// -*- 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___RANGES_ADJACENT_VIEW_H
+#define _LIBCPP___RANGES_ADJACENT_VIEW_H
+
+#include <__config>
+
+#include <__algorithm/min.h>
+#include <__compare/three_way_comparable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/equality_comparable.h>
+#include <__cstddef/size_t.h>
+#include <__functional/invoke.h>
+#include <__functional/operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iter_swap.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty_view.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__ranges/zip_utils.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/maybe_const.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
+#include <__utility/move.h>
+#include <array>
+#include <tuple>
+
+#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 >= 23
+
+namespace ranges {
+
+template <forward_range _View, size_t _Np>
+  requires view<_View> && (_Np > 0)
+class adjacent_view : public view_interface<adjacent_view<_View, _Np>> {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+
+  template <bool>
+  class __iterator;
+
+  template <bool>
+  class __sentinel;
+
+  struct __as_sentinel {};
+
+public:
+  _LIBCPP_HIDE_FROM_ABI adjacent_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit adjacent_view(_View __base) : __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
+    return __iterator<false>(ranges::begin(__base_), ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View> // todo: this seems under-constrained. lwg issue?
+  {
+    return __iterator<true>(ranges::begin(__base_), ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    if constexpr (common_range<_View>) {
+      return __iterator<false>(__as_sentinel{}, ranges::begin(__base_), ranges::end(__base_));
+    } else {
+      return __sentinel<false>(ranges::end(__base_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    if constexpr (common_range<const _View>) {
+      return __iterator<true>(__as_sentinel{}, ranges::begin(__base_), ranges::end(__base_));
+    } else {
+      return __sentinel<true>(ranges::end(__base_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    using _ST = decltype(ranges::size(__base_));
+    using _CT = common_type_t<_ST, size_t>;
+    auto __sz = static_cast<_CT>(ranges::size(__base_));
+    __sz -= std::min<_CT>(__sz, _Np - 1);
+    return static_cast<_ST>(__sz);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    using _ST = decltype(ranges::size(__base_));
+    using _CT = common_type_t<_ST, size_t>;
+    auto __sz = static_cast<_CT>(ranges::size(__base_));
+    __sz -= std::min<_CT>(__sz, _Np - 1);
+    return static_cast<_ST>(__sz);
+  }
+};
+
+template <forward_range _View, size_t _Np>
+  requires view<_View> && (_Np > 0)
+template <bool _Const>
+class adjacent_view<_View, _Np>::__iterator {
+  friend adjacent_view;
+  using _Base                              = __maybe_const<_Const, _View>;
+  array<iterator_t<_Base>, _Np> __current_ = array<iterator_t<_Base>, _Np>();
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last) {
+    __current_[0] = __first;
+    for (int __i = 1; __i < static_cast<int>(_Np); ++__i) {
+      __current_[__i] = ranges::next(__current_[__i - 1], 1, __last);
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) {
+    if constexpr (!bidirectional_range<_Base>) {
+      __current_.fill(__last);
+    } else {
+      __current_[_Np - 1] = __last;
+      for (int __i = static_cast<int>(_Np) - 2; __i >= 0; --__i) {
+        __current_[__i] = ranges::prev(__current_[__i + 1], 1, __first);
+      }
+    }
+  }
+
+  template <class _Iter, size_t... _Is>
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr __iterator(_Iter&& __i, index_sequence<_Is...>)
+      : __current_{std::move(__i.__current_[_Is])...} {}
+
+  static consteval auto __get_iterator_concept() {
+    if constexpr (random_access_range<_Base>)
+      return random_access_iterator_tag{};
+    else if constexpr (bidirectional_range<_Base>)
+      return bidirectional_iterator_tag{};
+    else
+      return forward_iterator_tag{};
+  }
+
+  template <class _Tp, size_t... _Is>
+  static auto __repeat_tuple_helper(index_sequence<_Is...>) -> tuple<decltype((_Is, std::declval<_Tp (*)()>()()))...>;
+
+public:
+  using iterator_category = input_iterator_tag;
+  using iterator_concept  = decltype(__get_iterator_concept());
+  using value_type        = decltype(__repeat_tuple_helper<range_value_t<_Base>>(make_index_sequence<_Np>{}));
+  using difference_type   = range_difference_t<_Base>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+      : __iterator(std::move(__i), make_index_sequence<_Np>{}) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const {
+    return ranges::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    for (auto& __i : __current_) {
+      ++__i;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    for (auto& __i : __current_) {
+      --__i;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
+    requires random_access_range<_Base>
+  {
+    for (auto& __i : __current_) {
+      __i += __x;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
+    requires random_access_range<_Base>
+  {
+    for (auto& __i : __current_) {
+      __i -= __x;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type n) const
+    requires random_access_range<_Base>
+  {
+    return ranges::__tuple_transform([&](auto& __i) -> decltype(auto) { return __i[n]; }, __current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_.back() == __y.__current_.back();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_.back() < __y.__current_.back();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __y < __x;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__y < __x);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__x < __y);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_.back() <=> __y.__current_.back();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    auto __r = __i;
+    __r += __n;
+    return __r;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
+    requires random_access_range<_Base>
+  {
+    return __i + __n;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    auto __r = __i;
+    __r -= __n;
+    return __r;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+  {
+    return __x.__current_.back() - __y.__current_.back();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
+      noexcept(ranges::iter_move(std::declval<const iterator_t<_Base>&>())) &&
+      is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>) {
+    return ranges::__tuple_transform(ranges::iter_move, __i.__current_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
+      noexcept(ranges::iter_swap(std::declval<iterator_t<_Base>>(), std::declval<iterator_t<_Base>>())))
+    requires indirectly_swappable<iterator_t<_Base>>
+  {
+    for (size_t __i = 0; __i < _Np; ++__i) {
+      ranges::iter_swap(__l.__current_[__i], __r.__current_[__i]);
+    }
+  }
+};
+
+template <forward_range _View, size_t _Np>
+  requires view<_View> && (_Np > 0)
+template <bool _Const>
+class adjacent_view<_View, _Np>::__sentinel {
+  friend adjacent_view;
+  using _Base              = __maybe_const<_Const, _View>;
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) { __end_ = std::move(__end); }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+      : __end_(std::move(__i.__end_)) {}
+
+  template <bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_.back() == __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_.back() - __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __sentinel& __y, const __iterator<_OtherConst>& __x) {
+    return __y.__end_ - __x.__current_.back();
+  }
+};
+
+template <class _View, size_t _Np>
+constexpr bool enable_borrowed_range<adjacent_view<_View, _Np>> = enable_borrowed_range<_View>;
+
+namespace views {
+namespace __adjacent {
+
+template <size_t _Np>
+struct __fn : __range_adaptor_closure<__fn<_Np>> {
+  template <class _Range>
+    requires(_Np == 0 && forward_range<_Range &&>)
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&&) noexcept {
+    return empty_view<tuple<>>{};
+  }
+
+  template <class _Ranges>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ranges&& __range) noexcept(
+      noexcept(adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range))))
+      -> decltype(adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range))) {
+    return adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range));
+  }
+};
+
+} // namespace __adjacent
+inline namespace __cpo {
+template <size_t _Np>
+inline constexpr auto adjacent = __adjacent::__fn<_Np>{};
+inline constexpr auto pairwise = adjacent<2>;
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_ADJACENT_VIEW_H
diff --git a/libcxx/include/__ranges/zip_utils.h b/libcxx/include/__ranges/zip_utils.h
new file mode 100644
index 0000000000000..d7b40d12048cf
--- /dev/null
+++ b/libcxx/include/__ranges/zip_utils.h
@@ -0,0 +1,49 @@
+
+// -*- 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___RANGES_ZIP_VIEW_H
+#define _LIBCPP___RANGES_ZIP_VIEW_H
+
+#include <__config>
+
+#include <__functional/invoke.h>
+#include <__utility/forward.h>
+#include <tuple>
+
+#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 >= 23
+
+namespace ranges {
+
+template <class _Fun, class _Tuple>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_transform(_Fun&& __f, _Tuple&& __tuple) {
+  return std::apply(
+      [&]<class... _Types>(_Types&&... __elements) {
+        return tuple<invoke_result_t<_Fun&, _Types>...>(std::invoke(__f, std::forward<_Types>(__elements))...);
+      },
+      std::forward<_Tuple>(__tuple));
+}
+
+} // namespace ranges
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_ZIP_VIEW_H
diff --git a/libcxx/include/__ranges/zip_view.h b/libcxx/include/__ranges/zip_view.h
index ce00c98710c4e..bd54f37028e45 100644
--- a/libcxx/include/__ranges/zip_view.h
+++ b/libcxx/include/__ranges/zip_view.h
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___RANGES_ZIP_VIEW_H
-#define _LIBCPP___RANGES_ZIP_VIEW_H
+#ifndef _LIBCPP___RANGES_ZIP_UTILS_H
+#define _LIBCPP___RANGES_ZIP_UTILS_H
 
 #include <__config>
 
@@ -31,6 +31,7 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__ranges/zip_utils.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/declval.h>
@@ -58,15 +59,6 @@ concept __zip_is_common =
     (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
     ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
 
-template <class _Fun, class _Tuple>
-_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_transform(_Fun&& __f, _Tuple&& __tuple) {
-  return std::apply(
-      [&]<class... _Types>(_Types&&... __elements) {
-        return tuple<invoke_result_t<_Fun&, _Types>...>(std::invoke(__f, std::forward<_Types>(__elements))...);
-      },
-      std::forward<_Tuple>(__tuple));
-}
-
 template <class _Fun, class _Tuple>
 _LIBCPP_HIDE_FROM_ABI constexpr void __tuple_for_each(_Fun&& __f, _Tuple&& __tuple) {
   std::apply(
@@ -504,4 +496,4 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP___RANGES_ZIP_VIEW_H
+#endif // _LIBCPP___RANGES_ZIP_UTILS_H
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index 894093b409e11..e2b60cf8607db 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -1850,6 +1850,7 @@ module std [system] {
 
   module ranges {
     module access                         { header "__ranges/access.h" }
+    module adjacent_view                  { header "__ranges/adjacent_view.h" }
     module all                            {
       header "__ranges/all.h"
       export std.ranges.ref_view
@@ -1947,6 +1948,9 @@ module std [system] {
       header "__ranges/zip_view.h"
       export std.utility.pair
     }
+    module zip_utils {
+      header "__ranges/zip_utils.h"
+    }
     module zip_transform_view {
       header "__ranges/zip_transform_view.h"
     }
diff --git a/libcxx/include/ranges b/libcxx/include/ranges
index cfaa66a0831b3..fe272579ca898 100644
--- a/libcxx/include/ranges
+++ b/libcxx/include/ranges
@@ -353,6 +353,20 @@ namespace std::ranges {
 
   namespace views { inline constexpr unspecified zip_transform = unspecified; }     // C++23
 
+  // [range.adjacent], adjacent view
+  template<forward_range V, size_t N>
+    requires view<V> && (N > 0)
+  class adjacent_view;
+
+  template<class V, size_t N>
+    constexpr bool enable_borrowed_range<adjacent_view<V, N>> =
+      enable_borrowed_range<V>;
+
+  namespace views {
+    template<size_t N>
+      constexpr unspecified adjacent = unspecified;
+    inline constexpr auto pairwise = adjacent<2>;
+  }
 
   // [range.as.rvalue]
   template <view V>
@@ -411,6 +425,7 @@ namespace std {
 
 #  if _LIBCPP_STD_VER >= 20
 #    include <__ranges/access.h>
+#    include <__ranges/adjacent_view.h>
 #    include <__ranges/all.h>
 #    include <__ranges/common_view.h>
 #    include <__ranges/concepts.h>
diff --git a/libcxx/modules/std/ranges.inc b/libcxx/modules/std/ranges.inc
index cc7daa3cd1aec..38222812fdc0b 100644
--- a/libcxx/modules/std/ranges.inc
+++ b/libcxx/modules/std/ranges.inc
@@ -299,9 +299,6 @@ export namespace std {
     namespace views {
       using std::ranges::views::zip_transform;
     }
-#endif // _LIBCPP_STD_VER >= 23
-
-#if 0
     using std::ranges::adjacent_view;
 
     namespace views {
@@ -309,6 +306,9 @@ export namespace std {
       using std::ranges::views::pairwise;
     } // namespace views
 
+#endif // _LIBCPP_STD_VER >= 23
+
+#if 0
     using std::ranges::adjacent_transform_view;
 
     namespace views {
diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp
index 7e2510f5b5d13..9996ea42ab26d 100644
--- a/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp
+++ b/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp
@@ -121,7 +121,7 @@ static_assert(test(std::views::values, pairs));
 
 #if TEST_STD_VER >= 23
 // static_assert(test(std::views::adjacent_transform<2>, [](int x, int y) { return x + y; }, a));
-// static_assert(test(std::views::adjacent<2>, a));
+static_assert(test(std::views::adjacent<2>, a));
 // static_assert(test(std::views::as_const, a));
 static_assert(test(std::views::as_rvalue, a));
 // static_assert(test(std::views::cartesian_product, a, a, a));
@@ -129,6 +129,7 @@ static_assert(test(std::views::chunk_by, a, [](int x, int y) { return x < y; }))
 // static_assert(test(std::views::chunk, a, 1));
 // static_assert(test(std::views::enumerate, a));
 static_assert(test(std::views::join_with, 1));
+static_assert(test(std::views::pairwise, a));
 // static_assert(test(std::views::stride, a, 1));
 static_assert(test(std::views::zip_transform, [](int x, int y) { return x + y; }, a, a));
 static_assert(test(std::views::zip, a, a));
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/adaptor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/adaptor.pass.cpp
new file mode 100644
index 0000000000000..ffd0f52765734
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/adaptor.pass.cpp
@@ -0,0 +1,242 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// Test std::views::adjacent<N>
+
+#include <concepts>
+#include <cstddef>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+
+#include "../range_adaptor_types.h"
+
+template <std::size_t N>
+constexpr void test_constraints() {
+  // needs to be a range
+  static_assert(std::is_invocable_v<decltype((std::views::adjacent<N>)), std::ranges::empty_view<int>>);
+  static_assert(!std::is_invocable_v<decltype((std::views::adjacent<N>)), int>);
+
+  // underlying needs to be forward_range
+  static_assert(!std::is_invocable_v<decltype((std::views::adjacent<N>)), InputCommonView>);
+  static_assert(std::is_invocable_v<decltype((std::views::adjacent<N>)), ForwardSizedView>);
+}
+
+constexpr void test_pairwise_constraints() {
+  // needs to be a range
+  static_assert(std::is_invocable_v<decltype((std::views::pairwise)), std::ranges::empty_view<int>>);
+  static_assert(!std::is_invocable_v<decltype((std::views::pairwise)), int>);
+
+  // underlying needs to be forward_range
+  static_assert(!std::is_invocable_v<decltype((std::views::pairwise)), InputCommonView>);
+  static_assert(std::is_invocable_v<decltype((std::views::pairwise)), ForwardSizedView>);
+}
+
+constexpr void test_all_constraints() {
+  test_pairwise_constraints();
+  test_constraints<0>();
+  test_constraints<1>();
+  test_constraints<2>();
+  test_constraints<3>();
+  test_constraints<5>();
+}
+
+constexpr void test_zero_case() {
+  // N == 0 is a special case that always results in an empty range
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  std::same_as<std::ranges::empty_view<std::tuple<>>> decltype(auto) v =
+      std::views::adjacent<0>(ContiguousCommonView{buffer});
+  assert(std::ranges::size(v) == 0);
+}
+
+struct MoveOnlyView : ForwardSizedView {
+  using ForwardSizedView::ForwardSizedView;
+
+  constexpr MoveOnlyView(MoveOnlyView&&)      = default;
+  constexpr MoveOnlyView(const MoveOnlyView&) = delete;
+
+  constexpr MoveOnlyView& operator=(MoveOnlyView&&)      = default;
+  constexpr MoveOnlyView& operator=(const MoveOnlyView&) = delete;
+};
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  const auto validateBegin = [&](auto&& view) {
+    auto it    = view.begin();
+    auto tuple = *it;
+
+    assert(std::get<0>(tuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(tuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(tuple) == buffer[2]);
+    if constexpr (N >= 4)
+      assert(std::get<3>(tuple) == buffer[3]);
+    if constexpr (N >= 5)
+      assert(std::get<4>(tuple) == buffer[4]);
+  };
+
+  // Test `views::adjacent<N>(r)`
+  {
+    using View                          = std::ranges::adjacent_view<ContiguousCommonView, N>;
+    std::same_as<View> decltype(auto) v = std::views::adjacent<N>(ContiguousCommonView{buffer});
+    assert(std::ranges::size(v) == (N <= 8 ? 9 - N : 0));
+    validateBegin(v);
+  }
+
+  // Test `views::adjacent<N>(move only view)`
+  {
+    using View                          = std::ranges::adjacent_view<MoveOnlyView, N>;
+    std::same_as<View> decltype(auto) v = std::views::adjacent<N>(MoveOnlyView{buffer});
+    assert(std::ranges::size(v) == (N <= 8 ? 9 - N : 0));
+    validateBegin(v);
+  }
+
+  // Test `r | views::adjacent<N>`
+  {
+    using View                          = std::ranges::adjacent_view<ContiguousCommonView, N>;
+    std::same_as<View> decltype(auto) v = ContiguousCommonView{buffer} | std::views::adjacent<N>;
+    assert(std::ranges::size(v) == (N <= 8 ? 9 - N : 0));
+    validateBegin(v);
+  }
+
+  // Test `move only view | views::adjacent<N>`
+  {
+    using View                          = std::ranges::adjacent_view<MoveOnlyView, N>;
+    std::same_as<View> decltype(auto) v = MoveOnlyView{buffer} | std::views::adjacent<N>;
+    assert(std::ranges::size(v) == (N <= 8 ? 9 - N : 0));
+    validateBegin(v);
+  }
+
+  // Test adjacent<N> | adjacent<N>
+  {
+    using View = std::ranges::adjacent_view<std::ranges::adjacent_view<ContiguousCommonView, N>, N>;
+
+    auto twice                          = std::views::adjacent<N> | std::views::adjacent<N>;
+    std::same_as<View> decltype(auto) v = ContiguousCommonView{buffer} | twice;
+    assert(std::ranges::size(v) == (N <= 5 ? 10 - 2 * N : 0));
+
+    if (std::ranges::size(v) == 0)
+      return;
+
+    auto it          = v.begin();
+    auto nestedTuple = *it;
+
+    auto innerFirstTuple = std::get<0>(nestedTuple);
+
+    assert(std::get<0>(innerFirstTuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(innerFirstTuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(innerFirstTuple) == buffer[2]);
+    if constexpr (N >= 4)
+      assert(std::get<3>(innerFirstTuple) == buffer[3]);
+    if constexpr (N >= 5)
+      assert(std::get<4>(innerFirstTuple) == buffer[4]);
+
+    if constexpr (N >= 2) {
+      auto innerSecondTuple = std::get<1>(nestedTuple);
+      assert(std::get<0>(innerSecondTuple) == buffer[1]);
+      if constexpr (N >= 3)
+        assert(std::get<1>(innerSecondTuple) == buffer[2]);
+      if constexpr (N >= 4)
+        assert(std::get<2>(innerSecondTuple) == buffer[3]);
+      if constexpr (N >= 5)
+        assert(std::get<3>(innerSecondTuple) == buffer[4]);
+    }
+  }
+}
+
+constexpr void test_pairwise() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // Test `views::pairwise(r)`
+    using View                          = std::ranges::adjacent_view<ContiguousCommonView, 2>;
+    std::same_as<View> decltype(auto) v = std::views::pairwise(ContiguousCommonView{buffer});
+    assert(std::ranges::size(v) == 7);
+    auto it    = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    assert(std::get<1>(tuple) == buffer[1]);
+  }
+
+  {
+    // Test `views::pairwise(move only view)`
+    using View                          = std::ranges::adjacent_view<MoveOnlyView, 2>;
+    std::same_as<View> decltype(auto) v = std::views::pairwise(MoveOnlyView{buffer});
+    assert(std::ranges::size(v) == 7);
+    auto it    = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    assert(std::get<1>(tuple) == buffer[1]);
+  }
+  {
+    // Test `r | views::pairwise`
+    using View                          = std::ranges::adjacent_view<ContiguousCommonView, 2>;
+    std::same_as<View> decltype(auto) v = ContiguousCommonView{buffer} | std::views::pairwise;
+    assert(std::ranges::size(v) == 7);
+    auto it    = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    assert(std::get<1>(tuple) == buffer[1]);
+  }
+  {
+    // Test `move only view | views::pairwise`
+    using View                          = std::ranges::adjacent_view<MoveOnlyView, 2>;
+    std::same_as<View> decltype(auto) v = MoveOnlyView{buffer} | std::views::pairwise;
+    assert(std::ranges::size(v) == 7);
+    auto it    = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    assert(std::get<1>(tuple) == buffer[1]);
+  }
+  {
+    // Test pairwise | pairwise
+    using View = std::ranges::adjacent_view<std::ranges::adjacent_view<ContiguousCommonView, 2>, 2>;
+
+    auto twice                          = std::views::pairwise | std::views::pairwise;
+    std::same_as<View> decltype(auto) v = ContiguousCommonView{buffer} | twice;
+    assert(std::ranges::size(v) == 6);
+
+    auto it          = v.begin();
+    auto nestedTuple = *it;
+
+    auto innerFirstTuple = std::get<0>(nestedTuple);
+
+    assert(std::get<0>(innerFirstTuple) == buffer[0]);
+    assert(std::get<1>(innerFirstTuple) == buffer[1]);
+
+    auto innerSecondTuple = std::get<1>(nestedTuple);
+    assert(std::get<0>(innerSecondTuple) == buffer[1]);
+    assert(std::get<1>(innerSecondTuple) == buffer[2]);
+  }
+}
+
+constexpr bool test() {
+  test_all_constraints();
+  test_zero_case();
+  test_pairwise();
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/base.pass.cpp
new file mode 100644
index 0000000000000..c09231d672288
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/base.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr View base() const& requires copy_constructible<View>;
+// constexpr View base() &&;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+struct Range : std::ranges::view_base {
+  template <std::size_t N>
+  constexpr explicit Range(int (&buffer)[N]) : begin_(&buffer[0]), end_(&buffer[0] + N) {}
+  constexpr Range(Range const& other) : begin_(other.begin_), end_(other.end_), wasCopyInitialized(true) {}
+  constexpr Range(Range&& other) : begin_(other.begin_), end_(other.end_), wasMoveInitialized(true) {}
+  Range& operator=(Range const&) = default;
+  Range& operator=(Range&&)      = default;
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+  int* begin_;
+  int* end_;
+  bool wasCopyInitialized = false;
+  bool wasMoveInitialized = false;
+};
+
+static_assert(std::ranges::view<Range>);
+static_assert(std::ranges::forward_range<Range>);
+
+struct NonCopyableRange : std::ranges::view_base {
+  explicit NonCopyableRange(int*, int*);
+  NonCopyableRange(NonCopyableRange const&)            = delete;
+  NonCopyableRange(NonCopyableRange&&)                 = default;
+  NonCopyableRange& operator=(NonCopyableRange const&) = default;
+  NonCopyableRange& operator=(NonCopyableRange&&)      = default;
+  int* begin() const;
+  int* end() const;
+};
+
+static_assert(!std::copy_constructible<NonCopyableRange>);
+
+template <typename T>
+concept CanCallBaseOn = requires(T t) { std::forward<T>(t).base(); };
+
+template <std::size_t N>
+constexpr void test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  // Check the const& overload
+  {
+    Range range(buff);
+    auto view = range | std::views::adjacent<N>;
+
+    std::same_as<Range> decltype(auto) result = view.base();
+    assert(result.wasCopyInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 9);
+  }
+
+  // Check the && overload
+  {
+    Range range(buff);
+    auto view                                 = range | std::views::adjacent<N>;
+    std::same_as<Range> decltype(auto) result = std::move(view).base();
+    assert(result.wasMoveInitialized);
+    assert(result.begin() == buff);
+    assert(result.end() == buff + 9);
+  }
+
+  // Ensure the const& overload is not considered when the base is not copy-constructible
+  {
+    static_assert(!CanCallBaseOn<std::ranges::adjacent_view<NonCopyableRange, N> const&>);
+    static_assert(!CanCallBaseOn<std::ranges::adjacent_view<NonCopyableRange, N>&>);
+    static_assert(!CanCallBaseOn<std::ranges::adjacent_view<NonCopyableRange, N> const&&>);
+    static_assert(CanCallBaseOn<std::ranges::adjacent_view<NonCopyableRange, N>&&>);
+    static_assert(CanCallBaseOn<std::ranges::adjacent_view<NonCopyableRange, N>>);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/begin.pass.cpp
new file mode 100644
index 0000000000000..c17138bd6a5a3
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/begin.pass.cpp
@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto begin() requires (!(simple-view<Views> && ...));
+// constexpr auto begin() const requires (range<const Views> && ...);
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "../range_adaptor_types.h"
+
+template <class T>
+concept HasConstBegin = requires(const T& ct) { ct.begin(); };
+
+template <class T>
+concept HasBegin = requires(T& t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin = HasConstBegin<T> && requires(T& t, const T& ct) {
+  requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>;
+};
+
+template <class T>
+concept HasOnlyNonConstBegin = HasBegin<T> && !HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !HasConstAndNonConstBegin<T>;
+
+struct NoConstBeginView : std::ranges::view_base {
+  int* begin();
+  int* end();
+};
+
+template <class Range, std::size_t N>
+constexpr void test_one() {
+  using View = std::ranges::adjacent_view<Range, N>;
+  {
+    int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+    View v(Range{buffer});
+
+    auto it    = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(tuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(tuple) == buffer[2]);
+
+    auto cit    = std::as_const(v).begin();
+    auto ctuple = *cit;
+    assert(std::get<0>(ctuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(ctuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(ctuple) == buffer[2]);
+    if constexpr (N >= 4)
+      assert(std::get<3>(ctuple) == buffer[3]);
+    if constexpr (N >= 5)
+      assert(std::get<4>(ctuple) == buffer[4]);
+  }
+
+  {
+    // empty range
+    std::array<int, 0> buffer = {};
+    View v(Range{buffer.data(), 0});
+    auto it  = v.begin();
+    auto cit = std::as_const(v).begin();
+    assert(it == v.end());
+    assert(cit == std::as_const(v).end());
+  }
+
+  if constexpr (N > 2) {
+    // N greater than range size
+    int buffer[2] = {1, 2};
+    View v(Range{buffer});
+    auto it  = v.begin();
+    auto cit = std::as_const(v).begin();
+    assert(it == v.end());
+    assert(cit == std::as_const(v).end());
+  }
+}
+
+template <std::size_t N>
+constexpr void test_simple() {
+  test_one<SimpleCommon, N>();
+
+  using View = std::ranges::adjacent_view<SimpleCommon, N>;
+  static_assert(std::is_same_v<std::ranges::iterator_t<View>, std::ranges::iterator_t<const View>>);
+}
+
+template <std::size_t N>
+constexpr void test_non_simple() {
+  test_one<NonSimpleCommon, N>();
+
+  using View = std::ranges::adjacent_view<NonSimpleCommon, N>;
+  static_assert(!std::is_same_v<std::ranges::iterator_t<View>, std::ranges::iterator_t<const View>>);
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test_simple<N>();
+  test_non_simple<N>();
+
+  // Test with view that doesn't support const begin()
+  using ViewWithNoConstBegin = std::ranges::adjacent_view<NoConstBeginView, N>;
+  static_assert(!HasOnlyConstBegin<ViewWithNoConstBegin>);
+  static_assert(HasOnlyNonConstBegin<ViewWithNoConstBegin>);
+  static_assert(!HasConstAndNonConstBegin<ViewWithNoConstBegin>);
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/borrowing.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/borrowing.compile.pass.cpp
new file mode 100644
index 0000000000000..75e70c2bb95dc
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/borrowing.compile.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class View, size_t N>
+// inline constexpr bool enable_borrowed_range<adjacent_view<View, N>> =
+//      enable_borrowed_range<View>;
+
+#include <ranges>
+
+struct Borrowed : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+template <>
+inline constexpr bool std::ranges::enable_borrowed_range<Borrowed> = true;
+
+static_assert(std::ranges::borrowed_range<Borrowed>);
+
+struct NonBorrowed : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::borrowed_range<NonBorrowed>);
+
+// test borrowed_range
+static_assert(std::ranges::borrowed_range<std::ranges::adjacent_view<Borrowed, 1>>);
+static_assert(std::ranges::borrowed_range<std::ranges::adjacent_view<Borrowed, 2>>);
+static_assert(std::ranges::borrowed_range<std::ranges::adjacent_view<Borrowed, 3>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::adjacent_view<NonBorrowed, 1>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::adjacent_view<NonBorrowed, 2>>);
+static_assert(!std::ranges::borrowed_range<std::ranges::adjacent_view<NonBorrowed, 3>>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.default.pass.cpp
new file mode 100644
index 0000000000000..c8a8a9c740281
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.default.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// adjacent_view() default_initializable<V> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+constexpr int buff[] = {1, 2, 3, 4, 5};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView() : begin_(buff), end_(buff + std::ranges::size(buff)) {}
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct NoDefaultCtrView : std::ranges::view_base {
+  NoDefaultCtrView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+static_assert(std::is_default_constructible_v<std::ranges::adjacent_view<DefaultConstructibleView, 1>>);
+static_assert(std::is_default_constructible_v<std::ranges::adjacent_view<DefaultConstructibleView, 2>>);
+static_assert(std::is_default_constructible_v<std::ranges::adjacent_view<DefaultConstructibleView, 3>>);
+static_assert(!std::is_default_constructible_v<std::ranges::adjacent_view<NoDefaultCtrView, 1>>);
+static_assert(!std::is_default_constructible_v<std::ranges::adjacent_view<NoDefaultCtrView, 2>>);
+static_assert(!std::is_default_constructible_v<std::ranges::adjacent_view<NoDefaultCtrView, 3>>);
+
+template <std::size_t N>
+constexpr void test() {
+  {
+    using View = std::ranges::adjacent_view<DefaultConstructibleView, N>;
+    View v     = View(); // the default constructor is not explicit
+    assert(v.size() == std::ranges::size(buff) - (N - 1));
+    auto tuple = *v.begin();
+    assert(std::get<0>(tuple) == buff[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(tuple) == buff[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(tuple) == buff[2]);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.views.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.views.pass.cpp
new file mode 100644
index 0000000000000..647ca147fdc09
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/ctor.views.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr explicit adjacent_view(View)
+
+#include <ranges>
+#include <tuple>
+
+#include "../range_adaptor_types.h"
+
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept implicitly_constructible_from = requires(Args&&... args) { conversion_test<T>({std::move(args)...}); };
+
+// test constructor is explicit
+static_assert(std::constructible_from<std::ranges::adjacent_view<SimpleCommon, 1>, SimpleCommon>);
+static_assert(!implicitly_constructible_from<std::ranges::adjacent_view<SimpleCommon, 1>, SimpleCommon>);
+
+static_assert(std::constructible_from<std::ranges::adjacent_view<SimpleCommon, 5>, SimpleCommon>);
+static_assert(!implicitly_constructible_from<std::ranges::adjacent_view<SimpleCommon, 5>, SimpleCommon>);
+
+struct MoveAwareView : std::ranges::view_base {
+  int moves                 = 0;
+  constexpr MoveAwareView() = default;
+  constexpr MoveAwareView(MoveAwareView&& other) : moves(other.moves + 1) { other.moves = 1; }
+  constexpr MoveAwareView& operator=(MoveAwareView&& other) {
+    moves       = other.moves + 1;
+    other.moves = 0;
+    return *this;
+  }
+  constexpr const int* begin() const { return &moves; }
+  constexpr const int* end() const { return &moves + 1; }
+};
+
+template <class View, std::size_t N>
+constexpr void constructorTest(auto&& buffer) {
+  std::ranges::adjacent_view<View, N> v{View{buffer}};
+  auto tuple = *v.begin();
+  assert(std::get<0>(tuple) == buffer[0]);
+  if constexpr (N >= 2)
+    assert(std::get<1>(tuple) == buffer[1]);
+  if constexpr (N >= 3)
+    assert(std::get<2>(tuple) == buffer[2]);
+};
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // arguments are moved once
+    MoveAwareView mv;
+    std::ranges::adjacent_view<MoveAwareView, N> v{std::move(mv)};
+    auto tuple = *v.begin();
+    assert(std::get<0>(tuple) == 2); // one move from the local variable to parameter, one move from parameter to member
+  }
+
+  // forward
+  {
+    constructorTest<ForwardSizedView, N>(buffer);
+  }
+
+  // bidi
+  {
+    constructorTest<BidiCommonView, N>(buffer);
+  }
+
+  // random_access
+  {
+    constructorTest<SizedRandomAccessView, N>(buffer);
+  }
+
+  // contiguous
+  {
+    constructorTest<ContiguousCommonView, N>(buffer);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/end.pass.cpp
new file mode 100644
index 0000000000000..3ce45f49920fe
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/end.pass.cpp
@@ -0,0 +1,143 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto end() requires(!simple-view<_View>)
+// constexpr auto end() const requires range<const _View>
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "../range_adaptor_types.h"
+
+template <class Underlying, std::size_t N>
+constexpr void test_one() {
+  {
+    int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+    std::ranges::adjacent_view<Underlying, N> v{Underlying{buffer}};
+
+    auto it     = v.begin();
+    auto cit    = std::as_const(v).begin();
+    auto endIt  = v.end();
+    auto cendIt = std::as_const(v).end();
+    assert(it != endIt);
+    assert(cit != cendIt);
+    assert(it + (8 - (N - 1)) == endIt);
+    assert(cit + (8 - (N - 1)) == cendIt);
+  }
+  {
+    // empty range
+    std::array<int, 0> buffer = {};
+    std::ranges::adjacent_view<Underlying, N> v{Underlying{buffer.data(), 0}};
+    auto it     = v.begin();
+    auto cit    = std::as_const(v).begin();
+    auto endIt  = v.end();
+    auto cendIt = std::as_const(v).end();
+    assert(it == endIt);
+    assert(cit == cendIt);
+  }
+  if constexpr (N > 2) {
+    // N greater than range size
+    int buffer[2] = {1, 2};
+    std::ranges::adjacent_view<Underlying, N> v{Underlying{buffer}};
+    auto it     = v.begin();
+    auto cit    = std::as_const(v).begin();
+    auto endIt  = v.end();
+    auto cendIt = std::as_const(v).end();
+    assert(it == endIt);
+    assert(cit == cendIt);
+  }
+}
+
+template <std::size_t N>
+constexpr void test_simple_common_types() {
+  using NonConstView = std::ranges::adjacent_view<SimpleCommon, N>;
+  using ConstView    = const NonConstView;
+
+  static_assert(std::ranges::common_range<NonConstView>);
+  static_assert(std::ranges::common_range<ConstView>);
+  static_assert(std::is_same_v<std::ranges::sentinel_t<NonConstView>, std::ranges::sentinel_t<ConstView>>);
+
+  test_one<SimpleCommon, N>();
+}
+
+template <std::size_t N>
+constexpr void test_simple_non_common_types() {
+  using NonConstView = std::ranges::adjacent_view<SimpleNonCommon, N>;
+  using ConstView    = const NonConstView;
+
+  static_assert(!std::ranges::common_range<NonConstView>);
+  static_assert(!std::ranges::common_range<ConstView>);
+  static_assert(std::is_same_v<std::ranges::sentinel_t<NonConstView>, std::ranges::sentinel_t<ConstView>>);
+
+  test_one<SimpleNonCommon, N>();
+}
+
+template <std::size_t N>
+constexpr void test_non_simple_common_types() {
+  using NonConstView = std::ranges::adjacent_view<NonSimpleCommon, N>;
+  using ConstView    = const NonConstView;
+
+  static_assert(std::ranges::common_range<NonConstView>);
+  static_assert(std::ranges::common_range<ConstView>);
+  static_assert(!std::is_same_v<std::ranges::sentinel_t<NonConstView>, std::ranges::sentinel_t<ConstView>>);
+
+  test_one<NonSimpleCommon, N>();
+}
+
+template <std::size_t N>
+constexpr void test_non_simple_non_common_types() {
+  using NonConstView = std::ranges::adjacent_view<NonSimpleNonCommon, N>;
+  using ConstView    = const NonConstView;
+
+  static_assert(!std::ranges::common_range<NonConstView>);
+  static_assert(!std::ranges::common_range<ConstView>);
+  static_assert(!std::is_same_v<std::ranges::sentinel_t<NonConstView>, std::ranges::sentinel_t<ConstView>>);
+
+  test_one<NonSimpleNonCommon, N>();
+}
+
+template <std::size_t N>
+constexpr void test_forward_only() {
+  using NonConstView = std::ranges::adjacent_view<NonSimpleForwardSizedNonCommon, N>;
+  using ConstView    = const NonConstView;
+
+  static_assert(!std::ranges::common_range<NonConstView>);
+  static_assert(!std::ranges::common_range<ConstView>);
+  static_assert(!std::is_same_v<std::ranges::sentinel_t<NonConstView>, std::ranges::sentinel_t<ConstView>>);
+
+  test_one<NonSimpleForwardSizedNonCommon, N>();
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test_simple_common_types<N>();
+  test_simple_non_common_types<N>();
+  test_non_simple_common_types<N>();
+  test_non_simple_non_common_types<N>();
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/general.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/general.pass.cpp
new file mode 100644
index 0000000000000..3c3716190a495
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/general.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// Some basic examples of how adjacent_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <cstddef>
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <vector>
+
+constexpr void test_adjacent_pairs() {
+  std::vector v = {1, 2, 3, 4};
+
+  std::pair<size_t, size_t> expected_index{0, 1};
+  for (auto [x, y] : v | std::views::adjacent<2>) {
+    assert(x == v[expected_index.first]);
+    assert(y == v[expected_index.second]);
+    assert(&x == &v[expected_index.first]);
+    assert(&y == &v[expected_index.second]);
+    ++expected_index.first;
+    ++expected_index.second;
+  }
+}
+
+constexpr void test_string_view() {
+  std::string_view sv = "123456789";
+  auto v              = sv | std::views::adjacent<3>;
+  auto [a, b, c]      = *v.begin();
+  assert(a == '1');
+  assert(b == '2');
+  assert(c == '3');
+}
+
+constexpr bool test() {
+  test_adjacent_pairs();
+  test_string_view();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/helpers.h b/libcxx/test/std/ranges/range.adaptors/range.adjacent/helpers.h
new file mode 100644
index 0000000000000..cef29689ea301
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/helpers.h
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ADJACENT_HELPERS_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ADJACENT_HELPERS_H
+
+#include <tuple>
+
+// intentionally not using meta programming for the expected tuple types
+
+template <std::size_t N, class T>
+struct ExpectedTupleType;
+
+template <class T>
+struct ExpectedTupleType<1, T> {
+  using type = std::tuple<T>;
+};
+template <class T>
+struct ExpectedTupleType<2, T> {
+  using type = std::tuple<T, T>;
+};
+template <class T>
+struct ExpectedTupleType<3, T> {
+  using type = std::tuple<T, T, T>;
+};
+template <class T>
+struct ExpectedTupleType<4, T> {
+  using type = std::tuple<T, T, T, T>;
+};
+template <class T>
+struct ExpectedTupleType<5, T> {
+  using type = std::tuple<T, T, T, T, T>;
+};
+
+template <std::size_t N, class T>
+using expectedTupleType = typename ExpectedTupleType<N, T>::type;
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ADJACENT_HELPERS_H
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/arithmetic.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/arithmetic.pass.cpp
new file mode 100644
index 0000000000000..671a5c3fec4d0
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/arithmetic.pass.cpp
@@ -0,0 +1,165 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator+=(difference_type x)
+//   requires random_access_range<Base>;
+// constexpr iterator& operator-=(difference_type x)
+//   requires random_access_range<Base>;
+// friend constexpr iterator operator+(const iterator& i, difference_type n)
+//   requires random_access_range<Base>;
+// friend constexpr iterator operator+(difference_type n, const iterator& i)
+//   requires random_access_range<Base>;
+// friend constexpr iterator operator-(const iterator& i, difference_type n)
+//   requires random_access_range<Base>;
+// friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+//   requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+
+#include <iterator>
+#include <ranges>
+
+#include <array>
+#include <concepts>
+#include <functional>
+
+#include "../../range_adaptor_types.h"
+
+template <class T, class U>
+concept canPlusEqual = requires(T& t, U& u) { t += u; };
+
+template <class T, class U>
+concept canMinusEqual = requires(T& t, U& u) { t -= u; };
+
+template <class R, std::size_t N>
+constexpr void test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  const auto validateRefFromIndex = [&](auto&& tuple, std::size_t idx) {
+    assert(&std::get<0>(tuple) == &buffer[idx]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(tuple) == &buffer[idx + 1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(tuple) == &buffer[idx + 2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(tuple) == &buffer[idx + 3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(tuple) == &buffer[idx + 4]);
+  };
+
+  R rng{buffer};
+  {
+    // operator+(x, n) and operator+=
+    std::ranges::adjacent_view<R, N> v(rng);
+    auto it1 = v.begin();
+
+    validateRefFromIndex(*it1, 0);
+
+    auto it2 = it1 + 3;
+    validateRefFromIndex(*it2, 3);
+
+    auto it3 = 3 + it1;
+    validateRefFromIndex(*it3, 3);
+
+    it1 += 3;
+    assert(it1 == it2);
+    validateRefFromIndex(*it1, 3);
+  }
+
+  {
+    // operator-(x, n) and operator-=
+    std::ranges::adjacent_view<R, N> v(rng);
+    auto it1 = v.end();
+
+    auto it2 = it1 - 3;
+    validateRefFromIndex(*it2, 7 - N);
+
+    it1 -= 3;
+    assert(it1 == it2);
+    validateRefFromIndex(*it1, 7 - N);
+  }
+
+  {
+    // operator-(x, y)
+    std::ranges::adjacent_view<R, N> v(rng);
+    assert((v.end() - v.begin()) == (10 - N));
+
+    auto it1 = v.begin() + 2;
+    auto it2 = v.end() - 1;
+    assert((it1 - it2) == static_cast<long>(N) - 7);
+  }
+
+  {
+    // empty range
+    std::ranges::adjacent_view<R, N> v(R{buffer, 0});
+    assert((v.end() - v.begin()) == 0);
+  }
+
+  {
+    // N > size of range
+    std::ranges::adjacent_view<R, 3> v(R{buffer, 2});
+    assert((v.end() - v.begin()) == 0);
+  }
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test<ContiguousCommonView, N>();
+  test<SimpleCommonRandomAccessSized, N>();
+
+  {
+    // Non random access but sized sentinel
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    using View   = std::ranges::adjacent_view<ForwardSizedView, N>;
+    using Iter   = std::ranges::iterator_t<View>;
+    using Diff   = std::iter_difference_t<Iter>;
+
+    static_assert(!std::invocable<std::plus<>, Iter, Diff>);
+    static_assert(!std::invocable<std::plus<>, Diff, Iter>);
+    static_assert(!canPlusEqual<Iter, Diff>);
+    static_assert(!std::invocable<std::minus<>, Iter, Diff>);
+    static_assert(!canMinusEqual<Iter, Diff>);
+    static_assert(std::invocable<std::minus<>, Iter, Iter>);
+
+    View v(ForwardSizedView{buffer});
+    auto it1 = v.begin();
+    auto it2 = v.end();
+    assert((it2 - it1) == (10 - N));
+  }
+
+  {
+    // Non random access and non-sized sentinel
+    using View = std::ranges::adjacent_view<SimpleNonCommonNonRandom, N>;
+    using Iter = std::ranges::iterator_t<View>;
+    using Diff = std::iter_difference_t<Iter>;
+
+    static_assert(!std::invocable<std::plus<>, Iter, Diff>);
+    static_assert(!std::invocable<std::plus<>, Diff, Iter>);
+    static_assert(!canPlusEqual<Iter, Diff>);
+    static_assert(!std::invocable<std::minus<>, Iter, Diff>);
+    static_assert(!canMinusEqual<Iter, Diff>);
+    static_assert(!std::invocable<std::minus<>, Iter, Iter>);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/compare.pass.cpp
new file mode 100644
index 0000000000000..8461d7fa4a53c
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/compare.pass.cpp
@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// friend constexpr bool operator==(const iterator& x, const iterator& y);
+// friend constexpr bool operator<(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator>(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator<=(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator>=(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+//   requires random_access_range<Base> &&
+//            three_way_comparable<iterator_t<Base>>;
+
+#include <ranges>
+#include <compare>
+
+#include "test_iterators.h"
+#include "test_range.h"
+
+#include "../../range_adaptor_types.h"
+
+constexpr void compareOperatorTest(auto&& iter1, auto&& iter2) {
+  assert(!(iter1 < iter1));
+  assert(iter1 < iter2);
+  assert(!(iter2 < iter1));
+  assert(iter1 <= iter1);
+  assert(iter1 <= iter2);
+  assert(!(iter2 <= iter1));
+  assert(!(iter1 > iter1));
+  assert(!(iter1 > iter2));
+  assert(iter2 > iter1);
+  assert(iter1 >= iter1);
+  assert(!(iter1 >= iter2));
+  assert(iter2 >= iter1);
+  assert(iter1 == iter1);
+  assert(!(iter1 == iter2));
+  assert(iter2 == iter2);
+  assert(!(iter1 != iter1));
+  assert(iter1 != iter2);
+  assert(!(iter2 != iter2));
+}
+
+constexpr void inequalityOperatorsDoNotExistTest(auto&& iter1, auto&& iter2) {
+  using Iter1 = decltype(iter1);
+  using Iter2 = decltype(iter2);
+  static_assert(!std::is_invocable_v<std::less<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::less_equal<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::greater<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::greater_equal<>, Iter1, Iter2>);
+}
+
+template <std::size_t N>
+constexpr void test() {
+  {
+    // Test a new-school iterator with operator<=>; the iterator should also have operator<=>.
+    using It       = three_way_contiguous_iterator<int*>;
+    using SubRange = std::ranges::subrange<It>;
+    static_assert(std::three_way_comparable<It>);
+    using R = std::ranges::adjacent_view<SubRange, N>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto r       = R{SubRange(It(buffer), It(buffer + 8))};
+    auto iter1   = r.begin();
+    auto iter2   = iter1 + 1;
+
+    compareOperatorTest(iter1, iter2);
+
+    assert((iter1 <=> iter2) == std::strong_ordering::less);
+    assert((iter1 <=> iter1) == std::strong_ordering::equal);
+    assert((iter2 <=> iter1) == std::strong_ordering::greater);
+  }
+
+  {
+    // Test an old-school iterator with no operator<=>; the adjacent iterator shouldn't have
+    // operator<=> either.
+    using It       = random_access_iterator<int*>;
+    using SubRange = std::ranges::subrange<It>;
+    static_assert(!std::three_way_comparable<It>);
+    using R = std::ranges::adjacent_view<SubRange, N>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto r       = R{SubRange(It(buffer), It(buffer + 8))};
+    auto iter1   = r.begin();
+    auto iter2   = iter1 + 1;
+
+    compareOperatorTest(iter1, iter2);
+  }
+
+  {
+    // non random_access_range
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+    std::ranges::adjacent_view<BidiCommonView, N> v(BidiCommonView{buffer});
+    using View = decltype(v);
+    static_assert(!std::ranges::random_access_range<View>);
+
+    auto it1 = v.begin();
+    auto it2 = v.end();
+    assert(it1 != it2);
+
+    // advance it1 to the end
+    std::ranges::advance(it1, 9 - N);
+    assert(it1 == it2);
+
+    inequalityOperatorsDoNotExistTest(it1, it2);
+  }
+
+  {
+    // empty range
+    auto v   = std::views::empty<int> | std::views::adjacent<N>;
+    auto it1 = v.begin();
+    auto it2 = v.end();
+    assert(it1 == it2);
+  }
+
+  {
+    // N > size of range
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto v       = std::ranges::adjacent_view<ContiguousCommonView, 10>(ContiguousCommonView{buffer});
+    auto it1     = v.begin();
+    auto it2     = v.end();
+    assert(it1 == it2);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.default.pass.cpp
new file mode 100644
index 0000000000000..5c1fb15b443e0
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.default.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// iterator() = default;
+
+#include <ranges>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+struct PODIter {
+  int i; // deliberately uninitialised
+
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type        = int;
+  using difference_type   = std::intptr_t;
+
+  constexpr int operator*() const { return i; }
+
+  constexpr PODIter& operator++() { return *this; }
+  constexpr PODIter operator++(int) { return *this; }
+
+  friend constexpr bool operator==(const PODIter&, const PODIter&) = default;
+};
+
+struct IterDefaultCtrView : std::ranges::view_base {
+  PODIter begin() const;
+  PODIter end() const;
+};
+
+struct IterNoDefaultCtrView : std::ranges::view_base {
+  cpp20_input_iterator<int*> begin() const;
+  sentinel_wrapper<cpp20_input_iterator<int*>> end() const;
+};
+
+template <class... Views>
+using adjacent_iter = std::ranges::iterator_t<std::ranges::adjacent_view<Views...>>;
+
+template <std::size_t N>
+constexpr void test() {
+  using View = std::ranges::adjacent_view<IterDefaultCtrView, N>;
+  using Iter = std::ranges::iterator_t<View>;
+  {
+    Iter iter;
+    auto tuple = *iter;
+    assert((std::get<0>(tuple) == 0));
+    if constexpr (N >= 2)
+      assert((std::get<1>(tuple) == 0));
+    if constexpr (N >= 3)
+      assert((std::get<2>(tuple) == 0));
+    if constexpr (N >= 4)
+      assert((std::get<3>(tuple) == 0));
+    if constexpr (N >= 5)
+      assert((std::get<4>(tuple) == 0));
+  }
+
+  {
+    Iter iter  = {};
+    auto tuple = *iter;
+    assert((std::get<0>(tuple) == 0));
+    if constexpr (N >= 2)
+      assert((std::get<1>(tuple) == 0));
+    if constexpr (N >= 3)
+      assert((std::get<2>(tuple) == 0));
+    if constexpr (N >= 4)
+      assert((std::get<3>(tuple) == 0));
+    if constexpr (N >= 5)
+      assert((std::get<4>(tuple) == 0));
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.other.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.other.pass.cpp
new file mode 100644
index 0000000000000..7d47ca7761ae1
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/ctor.other.pass.cpp
@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator(iterator<!Const> i)
+//      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+using ConstIterIncompatibleView =
+    BasicView<forward_iterator<int*>,
+              forward_iterator<int*>,
+              random_access_iterator<const int*>,
+              random_access_iterator<const int*>>;
+static_assert(!std::convertible_to<std::ranges::iterator_t<ConstIterIncompatibleView>,
+                                   std::ranges::iterator_t<const ConstIterIncompatibleView>>);
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::adjacent_view<NonSimpleCommon, N> v(NonSimpleCommon{buffer});
+    auto iter1                                       = v.begin();
+    std::ranges::iterator_t<const decltype(v)> iter2 = iter1;
+
+    static_assert(!std::is_same_v<decltype(iter1), decltype(iter2)>);
+    // We cannot create a non-const iterator from a const iterator.
+    static_assert(!std::constructible_from<decltype(iter1), decltype(iter2)>);
+
+    assert(iter1 == iter2);
+
+    auto tuple = *iter2;
+    assert(std::get<0>(tuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(tuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(tuple) == buffer[2]);
+    if constexpr (N >= 4)
+      assert(std::get<3>(tuple) == buffer[3]);
+    if constexpr (N >= 5)
+      assert(std::get<4>(tuple) == buffer[4]);
+  }
+
+  {
+    // underlying non-const to const not convertible
+    std::ranges::adjacent_view<ConstIterIncompatibleView, N> v(ConstIterIncompatibleView{buffer});
+    auto iter1 = v.begin();
+    auto iter2 = std::as_const(v).begin();
+
+    static_assert(!std::is_same_v<decltype(iter1), decltype(iter2)>);
+
+    static_assert(!std::constructible_from<decltype(iter1), decltype(iter2)>);
+    static_assert(!std::constructible_from<decltype(iter2), decltype(iter1)>);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/decrement.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/decrement.pass.cpp
new file mode 100644
index 0000000000000..155b3d40a7378
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/decrement.pass.cpp
@@ -0,0 +1,102 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator--() requires bidirectional_range<Base>;
+// constexpr iterator operator--(int) requires bidirectional_range<Base>;
+
+#include <array>
+#include <cassert>
+#include <iterator>
+#include <ranges>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+template <class Iter>
+concept canDecrement = requires(Iter it) { --it; } || requires(Iter it) { it--; };
+
+template <class R, std::size_t N>
+constexpr void test_one() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  const auto validateRefFromIndex = [&](auto&& tuple, std::size_t idx) {
+    assert(&std::get<0>(tuple) == &buffer[idx]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(tuple) == &buffer[idx + 1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(tuple) == &buffer[idx + 2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(tuple) == &buffer[idx + 3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(tuple) == &buffer[idx + 4]);
+  };
+
+  {
+    auto v = R(buffer) | std::views::adjacent<N>;
+
+    auto it    = v.begin();
+    using Iter = decltype(it);
+
+    std::ranges::advance(it, v.end());
+
+    --it;
+    validateRefFromIndex(*it, 9 - N);
+
+    static_assert(std::is_same_v<decltype(--it), Iter&>);
+    std::same_as<Iter&> decltype(auto) it_ref = --it;
+    assert(&it_ref == &it);
+
+    validateRefFromIndex(*it, 8 - N);
+
+    std::same_as<Iter> decltype(auto) tmp = it--;
+
+    validateRefFromIndex(*tmp, 8 - N);
+    validateRefFromIndex(*it, 7 - N);
+
+    // Decrement to the beginning
+    for (int i = 6 - N; i >= 0; --i) {
+      --it;
+      validateRefFromIndex(*it, i);
+    }
+    assert(it == v.begin());
+  }
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test_one<ContiguousNonCommonSized, N>();
+  test_one<SimpleCommonRandomAccessSized, N>();
+  test_one<BidiNonCommonView, N>();
+
+  // Non-bidirectional base range
+  {
+    using View = std::ranges::adjacent_view<ForwardSizedView, N>;
+    using Iter = std::ranges::iterator_t<View>;
+
+    static_assert(!canDecrement<Iter>);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/deref.pass.cpp
new file mode 100644
index 0000000000000..f1e516c11701b
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/deref.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto operator*() const;
+
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <ranges>
+#include <tuple>
+
+#include "../helpers.h"
+#include "../../range_adaptor_types.h"
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // simple case
+    auto v                                                      = buffer | std::views::adjacent<N>;
+    std::same_as<expectedTupleType<N, int&>> decltype(auto) res = *v.begin();
+
+    assert(&std::get<0>(res) == &buffer[0]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(res) == &buffer[1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(res) == &buffer[2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(res) == &buffer[3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(res) == &buffer[4]);
+  }
+
+  {
+    // operator* is const
+    auto v                                                      = buffer | std::views::adjacent<N>;
+    const auto it                                               = v.begin();
+    std::same_as<expectedTupleType<N, int&>> decltype(auto) res = *it;
+    assert(&std::get<0>(res) == &buffer[0]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(res) == &buffer[1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(res) == &buffer[2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(res) == &buffer[3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(res) == &buffer[4]);
+  }
+
+  {
+    // underlying range with prvalue range_reference_t
+    auto v                                                     = std::views::iota(0, 8) | std::views::adjacent<N>;
+    std::same_as<expectedTupleType<N, int>> decltype(auto) res = *v.begin();
+    assert(std::get<0>(res) == 0);
+    if constexpr (N >= 2)
+      assert(std::get<1>(res) == 1);
+    if constexpr (N >= 3)
+      assert(std::get<2>(res) == 2);
+    if constexpr (N >= 4)
+      assert(std::get<3>(res) == 3);
+    if constexpr (N >= 5)
+      assert(std::get<4>(res) == 4);
+  }
+
+  {
+    // const-correctness
+    const std::array bufferConst                                      = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto v                                                            = bufferConst | std::views::adjacent<N>;
+    std::same_as<expectedTupleType<N, const int&>> decltype(auto) res = *v.begin();
+    assert(&std::get<0>(res) == &bufferConst[0]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(res) == &bufferConst[1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(res) == &bufferConst[2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(res) == &bufferConst[3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(res) == &bufferConst[4]);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/increment.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/increment.pass.cpp
new file mode 100644
index 0000000000000..d1dab943d2785
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/increment.pass.cpp
@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator++();
+// constexpr iterator operator++(int);
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+template <class R, std::size_t N>
+constexpr void test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  const auto validateRefFromIndex = [&](auto&& tuple, std::size_t idx) {
+    assert(&std::get<0>(tuple) == &buffer[idx]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(tuple) == &buffer[idx + 1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(tuple) == &buffer[idx + 2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(tuple) == &buffer[idx + 3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(tuple) == &buffer[idx + 4]);
+  };
+
+  {
+    auto v     = R(buffer) | std::views::adjacent<N>;
+    auto it    = v.begin();
+    using Iter = decltype(it);
+
+    validateRefFromIndex(*it, 0);
+
+    std::same_as<Iter&> decltype(auto) it_ref = ++it;
+    assert(&it_ref == &it);
+
+    validateRefFromIndex(*it, 1);
+
+    static_assert(std::is_same_v<decltype(it++), Iter>);
+    auto original                          = it;
+    std::same_as<Iter> decltype(auto) copy = it++;
+    assert(original == copy);
+
+    validateRefFromIndex(*copy, 1);
+    validateRefFromIndex(*it, 2);
+
+    // Increment to the end
+    for (std::size_t i = 3; i != 9 - N; ++i) {
+      ++it;
+      validateRefFromIndex(*it, i);
+    }
+
+    ++it;
+    assert(it == v.end());
+  }
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test<ContiguousCommonView, N>();
+  test<SimpleCommonRandomAccessSized, N>();
+  test<BidiNonCommonView, N>();
+  test<ForwardSizedView, N>();
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_move.pass.cpp
new file mode 100644
index 0000000000000..0d228c79e48ea
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_move.pass.cpp
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+
+#include <array>
+#include <cassert>
+#include <iterator>
+#include <ranges>
+#include <tuple>
+
+#include "../helpers.h"
+#include "../../range_adaptor_types.h"
+
+struct ThrowingMove {
+  ThrowingMove() = default;
+  ThrowingMove(ThrowingMove&&) {}
+};
+
+class IterMoveMayThrowIter {
+  int* it_;
+
+public:
+  using value_type      = int;
+  using difference_type = typename std::iterator_traits<int*>::difference_type;
+
+  constexpr IterMoveMayThrowIter() = default;
+  explicit constexpr IterMoveMayThrowIter(int* it) : it_(it) {}
+
+  friend constexpr decltype(auto) iter_move(const IterMoveMayThrowIter& it) noexcept(false) {
+    return std::ranges::iter_move(it.it_);
+  }
+
+  friend constexpr bool operator==(const IterMoveMayThrowIter& x, const IterMoveMayThrowIter& y) {
+    return x.it_ == y.it_;
+  }
+
+  constexpr decltype(auto) operator*() const { return *it_; }
+  constexpr IterMoveMayThrowIter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr IterMoveMayThrowIter operator++(int) {
+    auto tmp(*this);
+    ++(*this);
+    return tmp;
+  }
+};
+
+class IterMoveMayThrowRange {
+  int* buffer_;
+  std::size_t size_;
+
+public:
+  constexpr IterMoveMayThrowRange(int* buffer, std::size_t size) : buffer_(buffer), size_(size) {}
+  constexpr IterMoveMayThrowIter begin() const { return IterMoveMayThrowIter{buffer_}; }
+  constexpr IterMoveMayThrowIter end() const { return IterMoveMayThrowIter{buffer_ + size_}; }
+};
+
+template <std::size_t N>
+constexpr void test() {
+  {
+    // underlying iter_move noexcept
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    auto v = buffer | std::views::adjacent<N>;
+
+    auto it = v.begin();
+    static_assert(noexcept(std::ranges::iter_move(it)));
+
+    std::same_as<expectedTupleType<N, int&&>> decltype(auto) res = std::ranges::iter_move(it);
+
+    assert(&std::get<0>(res) == &buffer[0]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(res) == &buffer[1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(res) == &buffer[2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(res) == &buffer[3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(res) == &buffer[4]);
+  }
+
+  {
+    // underlying iter_move may throw
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    auto v = IterMoveMayThrowRange{buffer, 9} | std::views::adjacent<N>;
+
+    auto it = v.begin();
+    static_assert(!noexcept(std::ranges::iter_move(it)));
+
+    std::same_as<expectedTupleType<N, int&&>> decltype(auto) res = std::ranges::iter_move(it);
+    assert(&std::get<0>(res) == &buffer[0]);
+    if constexpr (N >= 2)
+      assert(&std::get<1>(res) == &buffer[1]);
+    if constexpr (N >= 3)
+      assert(&std::get<2>(res) == &buffer[2]);
+    if constexpr (N >= 4)
+      assert(&std::get<3>(res) == &buffer[3]);
+    if constexpr (N >= 5)
+      assert(&std::get<4>(res) == &buffer[4]);
+  }
+
+  {
+    // !is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>
+    // underlying iter_move may throw
+    auto throwingMoveRange =
+        std::views::iota(0, 9) | std::views::transform([](auto) noexcept { return ThrowingMove{}; });
+    auto v  = throwingMoveRange | std::views::adjacent<N>;
+    auto it = v.begin();
+    static_assert(!noexcept(std::ranges::iter_move(it)));
+  }
+
+  {
+    // underlying iterators' iter_move are called through ranges::iter_move
+    auto rng = adltest::IterMoveSwapRange{};
+    auto v   = rng | std::views::adjacent<N>;
+    assert(rng.iter_move_called_times == 0);
+    auto it = v.begin();
+    {
+      [[maybe_unused]] auto&& i = std::ranges::iter_move(it);
+      assert(rng.iter_move_called_times == N);
+    }
+    {
+      [[maybe_unused]] auto&& i = std::ranges::iter_move(it);
+      assert(rng.iter_move_called_times == 2 * N);
+    }
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_swap.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_swap.pass.cpp
new file mode 100644
index 0000000000000..36be63dc6594b
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/iter_swap.pass.cpp
@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+//   requires indirectly_swappable<iterator_t<Base>>;
+
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <ranges>
+
+#include "../helpers.h"
+#include "../../range_adaptor_types.h"
+
+struct ThrowingMove {
+  ThrowingMove() = default;
+  ThrowingMove(ThrowingMove&&) {}
+  ThrowingMove& operator=(ThrowingMove&&) { return *this; }
+};
+
+template <std::size_t N>
+constexpr void test() {
+  {
+    // underlying iter_swap noexcept
+    int buffer[] = {
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+    };
+
+    auto v = buffer | std::views::adjacent<N>;
+
+    auto iter1 = v.begin();
+    auto iter2 = v.begin() + 10;
+    static_assert(noexcept(std::ranges::iter_swap(iter1, iter2)));
+
+    std::ranges::iter_swap(iter1, iter2);
+
+    assert(buffer[0] == 11);
+    assert(buffer[10] == 1);
+    if constexpr (N >= 2) {
+      assert(buffer[1] == 12);
+      assert(buffer[11] == 2);
+    }
+    if constexpr (N >= 3) {
+      assert(buffer[2] == 13);
+      assert(buffer[12] == 3);
+    }
+    if constexpr (N >= 4) {
+      assert(buffer[3] == 14);
+      assert(buffer[13] == 4);
+    }
+    if constexpr (N >= 5) {
+      assert(buffer[4] == 15);
+      assert(buffer[14] == 5);
+    }
+
+    auto tuple1 = *iter1;
+    auto tuple2 = *iter2;
+    assert(&std::get<0>(tuple1) == &buffer[0]);
+    assert(&std::get<0>(tuple2) == &buffer[10]);
+
+    if constexpr (N >= 2) {
+      assert(&std::get<1>(tuple1) == &buffer[1]);
+      assert(&std::get<1>(tuple2) == &buffer[11]);
+    }
+    if constexpr (N >= 3) {
+      assert(&std::get<2>(tuple1) == &buffer[2]);
+      assert(&std::get<2>(tuple2) == &buffer[12]);
+    }
+    if constexpr (N >= 4) {
+      assert(&std::get<3>(tuple1) == &buffer[3]);
+      assert(&std::get<3>(tuple2) == &buffer[13]);
+    }
+    if constexpr (N >= 5) {
+      assert(&std::get<4>(tuple1) == &buffer[4]);
+      assert(&std::get<4>(tuple2) == &buffer[14]);
+    }
+  }
+
+  {
+    // underlying iter_swap may throw
+    std::array<ThrowingMove, 10> iterSwapMayThrow{};
+    auto v     = iterSwapMayThrow | std::views::adjacent<N>;
+    auto iter1 = v.begin();
+    auto iter2 = ++v.begin();
+    static_assert(!noexcept(std::ranges::iter_swap(iter1, iter2)));
+  }
+
+  {
+    // underlying iterators' iter_swap are called through ranges::iter_swap
+    auto rng = adltest::IterMoveSwapRange{};
+    auto v   = rng | std::views::adjacent<N>;
+    assert(rng.iter_move_called_times == 0);
+    auto it1 = v.begin();
+    auto it2 = std::ranges::next(it1, 3);
+
+    std::ranges::iter_swap(it1, it2);
+    assert(rng.iter_swap_called_times == 2 * N);
+
+    std::ranges::iter_swap(it1, it2);
+    assert(rng.iter_swap_called_times == 4 * N);
+  }
+
+  {
+    // !indirectly_swappable<iterator_t<Base>>;
+
+    const int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    auto v             = buffer | std::views::adjacent<N>;
+    auto it1           = v.begin();
+    auto it2           = v.begin() + 1;
+    static_assert(!std::invocable<decltype(std::ranges::iter_swap), decltype(it1), decltype(it2)>);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/member_types.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/member_types.compile.pass.cpp
new file mode 100644
index 0000000000000..fc70fc4eed162
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/member_types.compile.pass.cpp
@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// Iterator traits and member typedefs in adjacent_view::iterator.
+
+#include <array>
+#include <iterator>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+#include "../../range_adaptor_types.h"
+
+template <class T>
+struct DiffTypeIter : random_access_iterator<int*> {
+  using value_type      = int;
+  using difference_type = T;
+
+  int operator*() const;
+  DiffTypeIter& operator++();
+  DiffTypeIter operator++(int);
+  friend constexpr bool operator==(DiffTypeIter, DiffTypeIter) = default;
+};
+
+template <class T>
+struct DiffTypeView : std::ranges::view_base {
+  DiffTypeIter<T> begin() const;
+  DiffTypeIter<T> end() const;
+};
+
+struct Foo {};
+
+struct ConstVeryDifferentRange {
+  int* begin();
+  int* end();
+
+  forward_iterator<double*> begin() const;
+  forward_iterator<double*> end() const;
+};
+
+template <std::size_t N>
+void test() {
+  int buffer[] = {1, 2, 3, 4};
+
+  const auto expectedTupleType = [] {
+    if constexpr (N == 1)
+      return std::tuple<int>{};
+    else if constexpr (N == 2)
+      return std::tuple<int, int>{};
+    else if constexpr (N == 3)
+      return std::tuple<int, int, int>{};
+    else if constexpr (N == 4)
+      return std::tuple<int, int, int, int>{};
+    else if constexpr (N == 5)
+      return std::tuple<int, int, int, int, int>{};
+  };
+
+  using expected_value_type = decltype(expectedTupleType());
+
+  {
+    // Base contiguous range
+    std::ranges::adjacent_view<std::views::all_t<decltype((buffer))>, N> v(buffer);
+    using Iter = decltype(v.begin());
+
+    static_assert(std::is_same_v<typename Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename Iter::value_type, expected_value_type>);
+  }
+
+  {
+    // Base random access
+    std::ranges::adjacent_view<SizedRandomAccessView, N> v(SizedRandomAccessView{buffer});
+    using Iter = decltype(v.begin());
+
+    static_assert(std::is_same_v<typename Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename Iter::value_type, expected_value_type>);
+  }
+
+  {
+    // Base bidirectional
+    std::ranges::adjacent_view<BidiCommonView, N> v(BidiCommonView{buffer});
+    using Iter = decltype(v.begin());
+
+    static_assert(std::is_same_v<typename Iter::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename Iter::value_type, expected_value_type>);
+  }
+
+  {
+    // Base forward
+    std::ranges::adjacent_view<ForwardSizedView, N> v(ForwardSizedView{buffer});
+    using Iter = decltype(v.begin());
+
+    static_assert(std::is_same_v<typename Iter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename Iter::value_type, expected_value_type>);
+  }
+
+  {
+    // difference_type
+    std::ranges::adjacent_view<DiffTypeView<std::intptr_t>, N> v{DiffTypeView<std::intptr_t>{}};
+    using Iter = decltype(v.begin());
+    static_assert(std::is_same_v<typename Iter::difference_type, std::intptr_t>);
+  }
+
+  {
+    // value_type
+    const std::array foos{Foo{}};
+    auto v     = std::views::adjacent<2>(foos);
+    using Iter = decltype(v.begin());
+    static_assert(std::is_same_v<typename Iter::value_type, std::tuple<Foo, Foo>>);
+  }
+
+  {
+    // const-iterator different from iterator
+    auto v          = ConstVeryDifferentRange{} | std::views::adjacent<2>;
+    using Iter      = decltype(v.begin());
+    using ConstIter = decltype(std::as_const(v).begin());
+
+    static_assert(std::is_same_v<typename Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename Iter::value_type, std::tuple<int, int>>);
+
+    static_assert(std::is_same_v<typename ConstIter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::is_same_v<typename ConstIter::iterator_category, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename ConstIter::difference_type, std::ptrdiff_t>);
+    static_assert(std::is_same_v<typename ConstIter::value_type, std::tuple<double, double>>);
+  }
+}
+
+void test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+}
\ No newline at end of file
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/singular.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/singular.pass.cpp
new file mode 100644
index 0000000000000..de912ca50bac7
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/singular.pass.cpp
@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+
+// If the invocation of any non-const member function of `iterator` exits via an
+// exception, the iterator acquires a singular value.
+
+#include <ranges>
+
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+struct ThrowOnDecrementIterator {
+  int* it_;
+
+  using value_type      = int;
+  using difference_type = std::intptr_t;
+
+  ThrowOnDecrementIterator() = default;
+  explicit ThrowOnDecrementIterator(int* it) : it_(it) {}
+
+  ThrowOnDecrementIterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  ThrowOnDecrementIterator operator++(int) {
+    auto tmp = *this;
+    ++it_;
+    return tmp;
+  }
+
+  ThrowOnDecrementIterator& operator--() { throw 5; }
+  ThrowOnDecrementIterator operator--(int) { throw 5; }
+
+  int& operator*() const { return *it_; }
+
+  friend bool operator==(ThrowOnDecrementIterator const&, ThrowOnDecrementIterator const&) = default;
+};
+
+struct ThrowOnIncrementView : IntBufferView {
+  ThrowOnDecrementIterator begin() const { return ThrowOnDecrementIterator{buffer_}; }
+  ThrowOnDecrementIterator end() const { return ThrowOnDecrementIterator{buffer_ + size_}; }
+};
+
+template <std::size_t N>
+void test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8};
+  {
+    // adjacent_view iterator should be able to be destroyed after member function throws
+    auto v  = ThrowOnIncrementView{buffer} | std::views::adjacent<N>;
+    auto it = v.begin();
+    ++it;
+    try {
+      --it;
+      assert(false); // should not be reached as the above expression should throw.
+    } catch (int e) {
+      assert(e == 5);
+    }
+  }
+
+  {
+    // adjacent_view iterator should be able to be assigned after member function throws
+    auto v  = ThrowOnIncrementView{buffer} | std::views::adjacent<N>;
+    auto it = v.begin();
+    ++it;
+    try {
+      --it;
+      assert(false); // should not be reached as the above expression should throw.
+    } catch (int e) {
+      assert(e == 5);
+    }
+    it         = v.begin();
+    auto tuple = *it;
+    assert(std::get<0>(tuple) == buffer[0]);
+    if constexpr (N >= 2)
+      assert(std::get<1>(tuple) == buffer[1]);
+    if constexpr (N >= 3)
+      assert(std::get<2>(tuple) == buffer[2]);
+    if constexpr (N >= 4)
+      assert(std::get<3>(tuple) == buffer[3]);
+    if constexpr (N >= 5)
+      assert(std::get<4>(tuple) == buffer[4]);
+  }
+}
+
+void test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+}
+
+int main(int, char**) {
+  test();
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/subscript.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/subscript.pass.cpp
new file mode 100644
index 0000000000000..389fbe9dc98d4
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/iterator/subscript.pass.cpp
@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto operator[](difference_type n) const requires
+//        all_random_access<Const, Views...>
+
+#include <ranges>
+#include <cassert>
+
+#include "../../range_adaptor_types.h"
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // random_access_range
+    std::ranges::adjacent_view<SizedRandomAccessView, N> v(SizedRandomAccessView{buffer});
+    auto it = v.begin();
+    assert(it[0] == *it);
+    assert(it[2] == *(it + 2));
+
+    static_assert(std::is_same_v<decltype(it[0]), decltype(*it)>);
+  }
+
+  {
+    // contiguous_range
+    std::ranges::adjacent_view<ContiguousCommonView, N> v(ContiguousCommonView{buffer});
+    auto it = v.begin();
+    assert(it[0] == *it);
+    assert(it[2] == *(it + 2));
+
+    static_assert(std::is_same_v<decltype(it[0]), decltype(*it)>);
+  }
+
+  {
+    // non random_access_range
+    std::ranges::adjacent_view<BidiCommonView, N> v(BidiCommonView{buffer});
+    auto iter               = v.begin();
+    const auto canSubscript = [](auto&& it) { return requires { it[0]; }; };
+    static_assert(!canSubscript(iter));
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/range.concept.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/range.concept.compile.pass.cpp
new file mode 100644
index 0000000000000..674182592a281
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/range.concept.compile.pass.cpp
@@ -0,0 +1,135 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// test if adjacent_view models input_range, forward_range, bidirectional_range,
+//                            random_access_range, contiguous_range, common_range
+//                            sized_range
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+#include "../range_adaptor_types.h"
+
+template <std::size_t N>
+constexpr bool testConcept() {
+  int buffer[3] = {1, 2, 3};
+  {
+    std::ranges::adjacent_view<ContiguousCommonView, N> v(ContiguousCommonView{buffer});
+    using View = decltype(v);
+    static_assert(std::ranges::random_access_range<View>);
+    static_assert(!std::ranges::contiguous_range<View>);
+    static_assert(std::ranges::common_range<View>);
+    static_assert(std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<ContiguousNonCommonView, N> v{ContiguousNonCommonView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::random_access_range<View>);
+    static_assert(!std::ranges::contiguous_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<ContiguousNonCommonSized, N> v{ContiguousNonCommonSized{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::random_access_range<View>);
+    static_assert(!std::ranges::contiguous_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<SizedRandomAccessView, N> v{SizedRandomAccessView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::random_access_range<View>);
+    static_assert(!std::ranges::contiguous_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<NonSizedRandomAccessView, N> v{NonSizedRandomAccessView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::random_access_range<View>);
+    static_assert(!std::ranges::contiguous_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<BidiCommonView, N> v{BidiCommonView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::bidirectional_range<View>);
+    static_assert(!std::ranges::random_access_range<View>);
+    static_assert(std::ranges::common_range<View>);
+    static_assert(!std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<BidiNonCommonView, N> v{BidiNonCommonView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::forward_range<View>);
+    static_assert(std::ranges::bidirectional_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<ForwardSizedView, N> v{ForwardSizedView{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::forward_range<View>);
+    static_assert(!std::ranges::bidirectional_range<View>);
+    static_assert(std::ranges::common_range<View>);
+    static_assert(std::ranges::sized_range<View>);
+  }
+
+  {
+    std::ranges::adjacent_view<ForwardSizedNonCommon, N> v{ForwardSizedNonCommon{buffer}};
+    using View = decltype(v);
+    static_assert(std::ranges::forward_range<View>);
+    static_assert(!std::ranges::bidirectional_range<View>);
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(std::ranges::sized_range<View>);
+  }
+
+  return true;
+}
+
+static_assert(testConcept<1>());
+static_assert(testConcept<2>());
+static_assert(testConcept<3>());
+static_assert(testConcept<5>());
+
+using OutputIter = cpp17_output_iterator<int*>;
+static_assert(std::output_iterator<OutputIter, int>);
+
+struct OutputView : std::ranges::view_base {
+  OutputIter begin() const;
+  sentinel_wrapper<OutputIter> end() const;
+};
+static_assert(std::ranges::output_range<OutputView, int>);
+static_assert(!std::ranges::input_range<OutputView>);
+
+template <class T, std::size_t N>
+concept adjacent_viewable = requires { typename std::ranges::adjacent_view<T, N>; };
+
+static_assert(adjacent_viewable<SimpleCommon, 2>);
+
+// output_range is not supported
+static_assert(!adjacent_viewable<OutputView, 2>);
+
+// input only range is not supported
+static_assert(!adjacent_viewable<InputCommonView, 1>);
+static_assert(!adjacent_viewable<InputNonCommonView, 2>);
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.default.pass.cpp
new file mode 100644
index 0000000000000..00a6cee577741
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.default.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// sentinel() = default;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+struct PODSentinel {
+  bool b; // deliberately uninitialised
+
+  friend constexpr bool operator==(int*, const PODSentinel& s) { return s.b; }
+};
+
+struct Range : std::ranges::view_base {
+  int* begin() const;
+  PODSentinel end();
+};
+
+template <std::size_t N>
+constexpr void test() {
+  {
+    using R        = std::ranges::adjacent_view<Range, N>;
+    using Sentinel = std::ranges::sentinel_t<R>;
+    static_assert(!std::is_same_v<Sentinel, std::ranges::iterator_t<R>>);
+
+    std::ranges::iterator_t<R> it;
+
+    Sentinel s1;
+    assert(it != s1); // PODSentinel.b is initialised to false
+
+    Sentinel s2 = {};
+    assert(it != s2); // PODSentinel.b is initialised to false
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.other.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.other.pass.cpp
new file mode 100644
index 0000000000000..7a3ebbd94ca9d
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/ctor.other.pass.cpp
@@ -0,0 +1,116 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr sentinel(sentinel<!Const> s);
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;;
+
+#include <cassert>
+#include <ranges>
+
+#include "../../range_adaptor_types.h"
+
+template <class T>
+struct convertible_sentinel_wrapper {
+  explicit convertible_sentinel_wrapper() = default;
+  constexpr convertible_sentinel_wrapper(const T& it) : it_(it) {}
+
+  template <class U>
+    requires std::convertible_to<const U&, T>
+  constexpr convertible_sentinel_wrapper(const convertible_sentinel_wrapper<U>& other) : it_(other.it_) {}
+
+  constexpr friend bool operator==(convertible_sentinel_wrapper const& self, const T& other) {
+    return self.it_ == other;
+  }
+  T it_;
+};
+
+struct SentinelConvertibleView : IntBufferView {
+  using IntBufferView::IntBufferView;
+
+  constexpr int* begin() { return buffer_; }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr convertible_sentinel_wrapper<int*> end() { return convertible_sentinel_wrapper<int*>(buffer_ + size_); }
+  constexpr convertible_sentinel_wrapper<const int*> end() const {
+    return convertible_sentinel_wrapper<const int*>(buffer_ + size_);
+  }
+};
+
+static_assert(!std::ranges::common_range<SentinelConvertibleView>);
+static_assert(std::convertible_to<std::ranges::sentinel_t<SentinelConvertibleView>,
+                                  std::ranges::sentinel_t<SentinelConvertibleView const>>);
+static_assert(!simple_view<SentinelConvertibleView>);
+
+struct SentinelNonConvertibleView : IntBufferView {
+  using IntBufferView::IntBufferView;
+
+  constexpr int* begin() { return buffer_; }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr sentinel_wrapper<int*> end() { return sentinel_wrapper<int*>(buffer_ + size_); }
+  constexpr sentinel_wrapper<const int*> end() const { return sentinel_wrapper<const int*>(buffer_ + size_); }
+};
+
+static_assert(!std::ranges::common_range<SentinelNonConvertibleView>);
+static_assert(!std::convertible_to<std::ranges::sentinel_t<SentinelNonConvertibleView>,
+                                   std::ranges::sentinel_t<SentinelNonConvertibleView const>>);
+static_assert(!simple_view<SentinelNonConvertibleView>);
+
+template <std::size_t N>
+constexpr void test() {
+  using View = std::ranges::adjacent_view<SentinelConvertibleView, N>;
+  static_assert(!std::ranges::common_range<View>);
+
+  using Sent      = std::ranges::sentinel_t<View>;
+  using ConstSent = std::ranges::sentinel_t<const View>;
+  static_assert(!std::is_same_v<Sent, ConstSent>);
+
+  {
+    // implicitly convertible
+    static_assert(std::convertible_to<Sent, ConstSent>);
+  }
+  {
+    // !Const
+    static_assert(!std::convertible_to<ConstSent, Sent>);
+  }
+  {
+    // !convertible_to<iterator_t<V>, iterator_t<Base>>
+    using V2 = std::ranges::adjacent_view<SentinelNonConvertibleView, N>;
+    static_assert(!std::convertible_to<std::ranges::sentinel_t<V2>, std::ranges::sentinel_t<const V2>>);
+  }
+
+  {
+    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+    View v{SentinelConvertibleView{buffer}};
+    Sent sent1      = v.end();
+    ConstSent sent2 = sent1;
+
+    assert(v.begin() != sent2);
+    assert(std::as_const(v).begin() != sent2);
+    assert(v.begin() + (10 - N) == sent2);
+    assert(std::as_const(v).begin() + (10 - N) == sent2);
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/eq.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/eq.pass.cpp
new file mode 100644
index 0000000000000..a79107c69fb4b
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/eq.pass.cpp
@@ -0,0 +1,195 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<bool OtherConst>
+//   requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+
+#include <cassert>
+#include <compare>
+#include <ranges>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+using Iterator      = random_access_iterator<int*>;
+using ConstIterator = contiguous_iterator<const int*>;
+
+template <bool Const>
+struct ComparableSentinel {
+  using Iter = std::conditional_t<Const, ConstIterator, Iterator>;
+  Iter iter_;
+
+  explicit ComparableSentinel() = default;
+  constexpr explicit ComparableSentinel(const Iter& it) : iter_(it) {}
+
+  constexpr friend bool operator==(const Iterator& i, const ComparableSentinel& s) { return base(i) == base(s.iter_); }
+
+  constexpr friend bool operator==(const ConstIterator& i, const ComparableSentinel& s) {
+    return base(i) == base(s.iter_);
+  }
+};
+
+struct ComparableView : IntBufferView {
+  using IntBufferView::IntBufferView;
+
+  constexpr auto begin() { return Iterator(buffer_); }
+  constexpr auto begin() const { return ConstIterator(buffer_); }
+  constexpr auto end() { return ComparableSentinel<false>(Iterator(buffer_ + size_)); }
+  constexpr auto end() const { return ComparableSentinel<true>(ConstIterator(buffer_ + size_)); }
+};
+
+struct ConstIncompatibleView : IntBufferView {
+  using IntBufferView::IntBufferView;
+
+  constexpr random_access_iterator<int*> begin() { return random_access_iterator<int*>(buffer_); }
+  constexpr contiguous_iterator<const int*> begin() const { return contiguous_iterator<const int*>(buffer_); }
+  constexpr sentinel_wrapper<random_access_iterator<int*>> end() {
+    return sentinel_wrapper<random_access_iterator<int*>>(random_access_iterator<int*>(buffer_ + size_));
+  }
+  constexpr sentinel_wrapper<contiguous_iterator<const int*>> end() const {
+    return sentinel_wrapper<contiguous_iterator<const int*>>(contiguous_iterator<const int*>(buffer_ + size_));
+  }
+};
+
+template <std::size_t N>
+constexpr bool test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  {
+    // simple-view: const and non-const have the same iterator/sentinel type
+    using View = std::ranges::adjacent_view<SimpleNonCommon, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(simple_view<View>);
+
+    View v{SimpleNonCommon(buffer)};
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + 1 != v.end());
+    assert(v.begin() + 2 != v.end());
+    assert(v.begin() + 3 != v.end());
+    assert(v.begin() + (10 - N) == v.end());
+  }
+
+  {
+    // !simple-view: const and non-const have different iterator/sentinel types
+    using View = std::ranges::adjacent_view<NonSimpleNonCommon, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!simple_view<View>);
+
+    using Iter      = std::ranges::iterator_t<View>;
+    using ConstIter = std::ranges::iterator_t<const View>;
+    static_assert(!std::is_same_v<Iter, ConstIter>);
+    using Sentinel      = std::ranges::sentinel_t<View>;
+    using ConstSentinel = std::ranges::sentinel_t<const View>;
+    static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
+
+    static_assert(weakly_equality_comparable_with<Iter, Sentinel>);
+    static_assert(!weakly_equality_comparable_with<ConstIter, Sentinel>);
+    static_assert(weakly_equality_comparable_with<Iter, ConstSentinel>);
+    static_assert(weakly_equality_comparable_with<ConstIter, ConstSentinel>);
+
+    View v{NonSimpleNonCommon(buffer)};
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + (10 - N) == v.end());
+
+    assert(v.begin() != std::as_const(v).end());
+    assert(v.begin() + (10 - N) == std::as_const(v).end());
+    // the above works because
+    static_assert(std::convertible_to<Iter, ConstIter>);
+
+    assert(std::as_const(v).begin() != std::as_const(v).end());
+    assert(std::as_const(v).begin() + (10 - N) == std::as_const(v).end());
+  }
+
+  {
+    // underlying const/non-const sentinel can be compared with both const/non-const iterator
+    using View = std::ranges::adjacent_view<ComparableView, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!simple_view<View>);
+
+    using Iter      = std::ranges::iterator_t<View>;
+    using ConstIter = std::ranges::iterator_t<const View>;
+    static_assert(!std::is_same_v<Iter, ConstIter>);
+    using Sentinel      = std::ranges::sentinel_t<View>;
+    using ConstSentinel = std::ranges::sentinel_t<const View>;
+    static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
+
+    static_assert(weakly_equality_comparable_with<Iter, Sentinel>);
+    static_assert(weakly_equality_comparable_with<ConstIter, Sentinel>);
+    static_assert(weakly_equality_comparable_with<Iter, ConstSentinel>);
+    static_assert(weakly_equality_comparable_with<ConstIter, ConstSentinel>);
+
+    View v{ComparableView(buffer)};
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + (10 - N) == v.end());
+
+    static_assert(!std::convertible_to<Iter, ConstIter>);
+
+    assert(v.begin() != std::as_const(v).end());
+    assert(v.begin() + (10 - N) == std::as_const(v).end());
+
+    assert(std::as_const(v).begin() != v.end());
+    assert(std::as_const(v).begin() + (10 - N) == v.end());
+
+    assert(std::as_const(v).begin() != std::as_const(v).end());
+    assert(std::as_const(v).begin() + (10 - N) == std::as_const(v).end());
+  }
+
+  {
+    // underlying const/non-const sentinel cannot be compared with non-const/const iterator
+
+    using View = std::ranges::adjacent_view<ConstIncompatibleView, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!simple_view<View>);
+
+    using Iter      = std::ranges::iterator_t<View>;
+    using ConstIter = std::ranges::iterator_t<const View>;
+    static_assert(!std::is_same_v<Iter, ConstIter>);
+    using Sentinel      = std::ranges::sentinel_t<View>;
+    using ConstSentinel = std::ranges::sentinel_t<const View>;
+    static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
+
+    static_assert(weakly_equality_comparable_with<Iter, Sentinel>);
+    static_assert(!weakly_equality_comparable_with<ConstIter, Sentinel>);
+    static_assert(!weakly_equality_comparable_with<Iter, ConstSentinel>);
+    static_assert(weakly_equality_comparable_with<ConstIter, ConstSentinel>);
+
+    View v{ConstIncompatibleView{buffer}};
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + (10 - N) == v.end());
+
+    assert(std::as_const(v).begin() != std::as_const(v).end());
+    assert(std::as_const(v).begin() + (10 - N) == std::as_const(v).end());
+  }
+
+  return true;
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/minus.pass.cpp
new file mode 100644
index 0000000000000..9f3fada6013cb
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/sentinel/minus.pass.cpp
@@ -0,0 +1,185 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const iterator<OtherConst>& x, const sentinel& y);
+
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const sentinel& y, const iterator<OtherConst>& x);
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+#include <tuple>
+
+#include "../../range_adaptor_types.h"
+
+// clang-format off
+template <class T, class U>
+concept HasMinus = std::invocable<std::minus<>,const T&, const U&>;
+
+template <class T>
+concept SentinelHasMinus = HasMinus<std::ranges::sentinel_t<T>, std::ranges::iterator_t<T>>;
+// clang-format on
+
+template <std::size_t N>
+constexpr void test() {
+  int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+  {
+    // simple-view
+    using View = std::ranges::adjacent_view<ForwardSizedNonCommon, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(simple_view<View>);
+
+    View v{ForwardSizedNonCommon(buffer)};
+
+    auto it = v.begin();
+    auto st = v.end();
+    assert(st - it == (10 - N));
+    assert(st - std::ranges::next(it, 1) == (9 - N));
+
+    assert(it - st == (static_cast<int>(N) - 10));
+    assert(std::ranges::next(it, 1) - st == (static_cast<int>(N) - 9));
+    static_assert(SentinelHasMinus<View>);
+  }
+
+  {
+    // empty range
+    using View = std::ranges::adjacent_view<ForwardSizedNonCommon, N>;
+    View v{ForwardSizedNonCommon(buffer, 0)};
+
+    auto it = v.begin();
+    auto st = v.end();
+    assert(st - it == 0);
+    assert(it - st == 0);
+  }
+
+  {
+    // N > size of underlying range
+    using View = std::ranges::adjacent_view<ForwardSizedNonCommon, 5>;
+    View v{ForwardSizedNonCommon(buffer, 3)};
+
+    auto it = v.begin();
+    auto st = v.end();
+    assert(st - it == 0);
+    assert(it - st == 0);
+  }
+
+  {
+    // underlying sentinel does not model sized_sentinel_for
+    using View = std::ranges::adjacent_view<decltype(std::views::iota(0)), N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!SentinelHasMinus<View>);
+  }
+
+  {
+    // const incompatible:
+    // underlying const sentinels cannot subtract underlying iterators
+    // underlying sentinels cannot subtract underlying const iterators
+    using View = std::ranges::adjacent_view<NonSimpleForwardSizedNonCommon, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!simple_view<View>);
+
+    using Iter      = std::ranges::iterator_t<View>;
+    using ConstIter = std::ranges::iterator_t<const View>;
+    static_assert(!std::is_same_v<Iter, ConstIter>);
+    using Sentinel      = std::ranges::sentinel_t<View>;
+    using ConstSentinel = std::ranges::sentinel_t<const View>;
+    static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
+
+    static_assert(HasMinus<Iter, Sentinel>);
+    static_assert(HasMinus<Sentinel, Iter>);
+    static_assert(HasMinus<ConstIter, ConstSentinel>);
+    static_assert(HasMinus<ConstSentinel, ConstIter>);
+
+    View v{NonSimpleForwardSizedNonCommon{buffer}};
+
+    auto it       = v.begin();
+    auto const_it = std::as_const(v).begin();
+    auto st       = v.end();
+    auto const_st = std::as_const(v).end();
+
+    int n = N;
+
+    assert(it - st == (n - 10));
+    assert(st - it == (10 - n));
+    assert(const_it - const_st == (n - 10));
+    assert(const_st - const_it == (10 - n));
+
+    static_assert(!HasMinus<Iter, ConstSentinel>);
+    static_assert(!HasMinus<ConstSentinel, Iter>);
+    static_assert(!HasMinus<ConstIter, Sentinel>);
+    static_assert(!HasMinus<Sentinel, ConstIter>);
+  }
+
+  {
+    // const compatible allow non-const to const conversion
+    using View = std::ranges::adjacent_view<ConstCompatibleForwardSized, N>;
+    static_assert(!std::ranges::common_range<View>);
+    static_assert(!simple_view<View>);
+
+    using Iter      = std::ranges::iterator_t<View>;
+    using ConstIter = std::ranges::iterator_t<const View>;
+    static_assert(!std::is_same_v<Iter, ConstIter>);
+    using Sentinel      = std::ranges::sentinel_t<View>;
+    using ConstSentinel = std::ranges::sentinel_t<const View>;
+    static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
+
+    static_assert(HasMinus<Iter, Sentinel>);
+    static_assert(HasMinus<Sentinel, Iter>);
+    static_assert(HasMinus<ConstIter, ConstSentinel>);
+    static_assert(HasMinus<ConstSentinel, ConstIter>);
+    static_assert(HasMinus<Iter, ConstSentinel>);
+    static_assert(HasMinus<ConstSentinel, Iter>);
+    static_assert(HasMinus<ConstIter, Sentinel>);
+    static_assert(HasMinus<Sentinel, ConstIter>);
+
+    View v{ConstCompatibleForwardSized{buffer}};
+
+    auto it       = v.begin();
+    auto const_it = std::as_const(v).begin();
+    auto st       = v.end();
+    auto const_st = std::as_const(v).end();
+
+    int n = N;
+
+    assert(it - st == (n - 10));
+    assert(st - it == (10 - n));
+    assert(const_it - const_st == (n - 10));
+    assert(const_st - const_it == (10 - n));
+    assert(it - const_st == (n - 10));
+    assert(const_st - it == (10 - n));
+    assert(const_it - st == (n - 10));
+    assert(st - const_it == (10 - n));
+  }
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<4>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.adjacent/size.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.adjacent/size.pass.cpp
new file mode 100644
index 0000000000000..be88d27b54654
--- /dev/null
+++ b/libcxx/test/std/ranges/range.adaptors/range.adjacent/size.pass.cpp
@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr auto size() requires sized_range<View>
+// constexpr auto size() const requires sized_range<const View>
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../range_adaptor_types.h"
+
+int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+struct View : std::ranges::view_base {
+  std::size_t size_ = 0;
+  constexpr View(std::size_t s) : size_(s) {}
+  constexpr auto begin() const { return buffer; }
+  constexpr auto end() const { return buffer + size_; }
+};
+
+struct SizedNonConst : std::ranges::view_base {
+  using iterator    = forward_iterator<int*>;
+  std::size_t size_ = 0;
+  constexpr SizedNonConst(std::size_t s) : size_(s) {}
+  constexpr auto begin() const { return iterator{buffer}; }
+  constexpr auto end() const { return iterator{buffer + size_}; }
+  constexpr std::size_t size() { return size_; }
+};
+
+struct StrangeSizeView : std::ranges::view_base {
+  constexpr auto begin() const { return buffer; }
+  constexpr auto end() const { return buffer + 8; }
+
+  constexpr auto size() { return 5; }
+  constexpr auto size() const { return 6; }
+};
+
+// Test with different values of N for a sized view
+template <std::size_t N>
+constexpr void test_sized_view() {
+  std::ranges::adjacent_view<View, N> v(View(8));
+  static_assert(std::ranges::sized_range<decltype(v)>);
+  static_assert(std::ranges::sized_range<const decltype(v)>);
+
+  auto expected_size = 8 - (N - 1);
+  assert(v.size() == expected_size);
+  assert(std::as_const(v).size() == expected_size);
+}
+
+// Test with different values of N for a non-const sized view
+template <std::size_t N>
+constexpr void test_nonconst_sized() {
+  std::ranges::adjacent_view<SizedNonConst, N> v(SizedNonConst(5));
+  static_assert(std::ranges::sized_range<decltype(v)>);
+  static_assert(!std::ranges::sized_range<const decltype(v)>);
+
+  auto expected_size = 5 - (N - 1);
+  assert(v.size() == expected_size);
+}
+
+// Test with different values of N for a view with different const/non-const sizes
+template <std::size_t N>
+constexpr void test_strange_size() {
+  std::ranges::adjacent_view<StrangeSizeView, N> v(StrangeSizeView{});
+  static_assert(std::ranges::sized_range<decltype(v)>);
+  static_assert(std::ranges::sized_range<const decltype(v)>);
+
+  assert(v.size() == 5 - (N - 1));
+  assert(std::as_const(v).size() == 6 - (N - 1));
+}
+
+template <std::size_t N>
+constexpr void test_empty_range() {
+  std::ranges::adjacent_view<View, N> v(View(0));
+  static_assert(std::ranges::sized_range<decltype(v)>);
+  static_assert(std::ranges::sized_range<const decltype(v)>);
+
+  assert(v.size() == 0);
+  assert(std::as_const(v).size() == 0);
+}
+
+template <std::size_t N>
+constexpr void test_N_greater_than_size() {
+  if constexpr (N > 2) {
+    std::ranges::adjacent_view<View, N> v(View(2));
+    static_assert(std::ranges::sized_range<decltype(v)>);
+    static_assert(std::ranges::sized_range<const decltype(v)>);
+    assert(v.size() == 0);
+    assert(std::as_const(v).size() == 0);
+  }
+}
+
+template <std::size_t N>
+constexpr void test() {
+  test_sized_view<N>();
+  test_nonconst_sized<N>();
+  test_strange_size<N>();
+  test_empty_range<N>();
+  test_N_greater_than_size<N>();
+}
+
+constexpr bool test() {
+  test<1>();
+  test<2>();
+  test<3>();
+  test<5>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/ranges/range.adaptors/range.join/adaptor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.join/adaptor.pass.cpp
index 68fdfb5b8475d..10c092cf36f2c 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.join/adaptor.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.join/adaptor.pass.cpp
@@ -18,14 +18,14 @@
 #include "test_range.h"
 #include "types.h"
 
-struct MoveOnlyOuter : SimpleForwardCommonOuter<ForwardCommonInner> {
+struct MoveOnlyView : SimpleForwardCommonOuter<ForwardCommonInner> {
   using SimpleForwardCommonOuter<ForwardCommonInner>::SimpleForwardCommonOuter;
 
-  constexpr MoveOnlyOuter(MoveOnlyOuter&&) = default;
-  constexpr MoveOnlyOuter(const MoveOnlyOuter&) = delete;
+  constexpr MoveOnlyView(MoveOnlyView&&) = default;
+  constexpr MoveOnlyView(const MoveOnlyView&) = delete;
 
-  constexpr MoveOnlyOuter& operator=(MoveOnlyOuter&&) = default;
-  constexpr MoveOnlyOuter& operator=(const MoveOnlyOuter&) = delete;
+  constexpr MoveOnlyView& operator=(MoveOnlyView&&) = default;
+  constexpr MoveOnlyView& operator=(const MoveOnlyView&) = delete;
 };
 
 struct Foo {
@@ -51,13 +51,13 @@ constexpr bool test() {
   {
     // Test `views::join(move-only-view)`
     ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
-    using Result = std::ranges::join_view<MoveOnlyOuter>;
-    std::same_as<Result> decltype(auto) v = std::views::join(MoveOnlyOuter{inners});
+    using Result = std::ranges::join_view<MoveOnlyView>;
+    std::same_as<Result> decltype(auto) v = std::views::join(MoveOnlyView{inners});
     assert(std::ranges::next(v.begin(), 9) == v.end());
     assert(&(*v.begin()) == buffer1);
 
-    static_assert(std::invocable<decltype(std::views::join), MoveOnlyOuter>);
-    static_assert(!std::invocable<decltype(std::views::join), MoveOnlyOuter&>);
+    static_assert(std::invocable<decltype(std::views::join), MoveOnlyView>);
+    static_assert(!std::invocable<decltype(std::views::join), MoveOnlyView&>);
   }
 
   {
@@ -86,13 +86,13 @@ constexpr bool test() {
   {
     // Test `move-only-view | views::join`
     ForwardCommonInner inners[3] = {buffer1, buffer2, buffer3};
-    using Result = std::ranges::join_view<MoveOnlyOuter>;
-    std::same_as<Result> decltype(auto) v = MoveOnlyOuter{inners} | std::views::join;
+    using Result = std::ranges::join_view<MoveOnlyView>;
+    std::same_as<Result> decltype(auto) v = MoveOnlyView{inners} | std::views::join;
     assert(std::ranges::next(v.begin(), 9) == v.end());
     assert(&(*v.begin()) == buffer1);
 
-    static_assert(CanBePiped<MoveOnlyOuter, decltype((std::views::join))>);
-    static_assert(!CanBePiped<MoveOnlyOuter&, decltype((std::views::join))>);
+    static_assert(CanBePiped<MoveOnlyView, decltype((std::views::join))>);
+    static_assert(!CanBePiped<MoveOnlyView&, decltype((std::views::join))>);
   }
 
   {
diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip.transform/sentinel/minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip.transform/sentinel/minus.pass.cpp
index fc29a00014f67..48a0a6d206db5 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.zip.transform/sentinel/minus.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip.transform/sentinel/minus.pass.cpp
@@ -20,83 +20,7 @@
 #include <tuple>
 
 #include "../types.h"
-
-template <class Base = int*>
-struct convertible_forward_sized_iterator {
-  Base it_ = nullptr;
-
-  using iterator_category = std::forward_iterator_tag;
-  using value_type        = int;
-  using difference_type   = std::intptr_t;
-
-  convertible_forward_sized_iterator() = default;
-  constexpr convertible_forward_sized_iterator(Base it) : it_(it) {}
-
-  template <std::convertible_to<Base> U>
-  constexpr convertible_forward_sized_iterator(const convertible_forward_sized_iterator<U>& it) : it_(it.it_) {}
-
-  constexpr decltype(*Base{}) operator*() const { return *it_; }
-
-  constexpr convertible_forward_sized_iterator& operator++() {
-    ++it_;
-    return *this;
-  }
-  constexpr convertible_forward_sized_iterator operator++(int) { return forward_sized_iterator(it_++); }
-
-  friend constexpr bool
-  operator==(const convertible_forward_sized_iterator&, const convertible_forward_sized_iterator&) = default;
-
-  friend constexpr difference_type
-  operator-(const convertible_forward_sized_iterator& x, const convertible_forward_sized_iterator& y) {
-    return x.it_ - y.it_;
-  }
-};
-static_assert(std::forward_iterator<convertible_forward_sized_iterator<>>);
-
-template <class Base>
-struct convertible_sized_sentinel {
-  Base base_;
-  explicit convertible_sized_sentinel() = default;
-  constexpr convertible_sized_sentinel(const Base& it) : base_(it) {}
-
-  template <std::convertible_to<Base> U>
-  constexpr convertible_sized_sentinel(const convertible_sized_sentinel<U>& other) : base_(other.base_) {}
-
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr bool operator==(const convertible_sized_sentinel& s, const U& base) {
-    return s.base_ == base;
-  }
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr auto operator-(const convertible_sized_sentinel& s, const U& i) {
-    return s.base_ - i;
-  }
-
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr auto operator-(const U& i, const convertible_sized_sentinel& s) {
-    return i - s.base_;
-  }
-};
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<>>,
-                                      convertible_forward_sized_iterator<>>);
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<const int*>>,
-                                      convertible_forward_sized_iterator<int*>>);
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<int*>>,
-                                      convertible_forward_sized_iterator<const int*>>);
-
-struct ConstCompatibleForwardSized : IntBufferView {
-  using IntBufferView::IntBufferView;
-
-  using iterator       = convertible_forward_sized_iterator<int*>;
-  using const_iterator = convertible_forward_sized_iterator<const int*>;
-
-  constexpr iterator begin() { return {buffer_}; }
-  constexpr const_iterator begin() const { return {buffer_}; }
-  constexpr convertible_sized_sentinel<iterator> end() { return iterator{buffer_ + size_}; }
-  constexpr convertible_sized_sentinel<const_iterator> end() const { return const_iterator{buffer_ + size_}; }
-};
+#include "../../range_adaptor_types.h"
 
 template <class T, class U>
 concept HasMinus = std::invocable<std::minus<>, const T&, const U&>;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
index bcfa3407e6cb1..61f8935af3c4a 100644
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
@@ -28,83 +28,6 @@
 
 #include "../../range_adaptor_types.h"
 
-template <class Base = int*>
-struct convertible_forward_sized_iterator {
-  Base it_ = nullptr;
-
-  using iterator_category = std::forward_iterator_tag;
-  using value_type = int;
-  using difference_type = std::intptr_t;
-
-  convertible_forward_sized_iterator() = default;
-  constexpr convertible_forward_sized_iterator(Base it) : it_(it) {}
-
-  template <std::convertible_to<Base> U>
-  constexpr convertible_forward_sized_iterator(const convertible_forward_sized_iterator<U>& it) : it_(it.it_) {}
-
-  constexpr decltype(*Base{}) operator*() const { return *it_; }
-
-  constexpr convertible_forward_sized_iterator& operator++() {
-    ++it_;
-    return *this;
-  }
-  constexpr convertible_forward_sized_iterator operator++(int) { return forward_sized_iterator(it_++); }
-
-  friend constexpr bool operator==(const convertible_forward_sized_iterator&,
-                                   const convertible_forward_sized_iterator&) = default;
-
-  friend constexpr difference_type operator-(const convertible_forward_sized_iterator& x,
-                                             const convertible_forward_sized_iterator& y) {
-    return x.it_ - y.it_;
-  }
-};
-static_assert(std::forward_iterator<convertible_forward_sized_iterator<>>);
-
-template <class Base>
-struct convertible_sized_sentinel {
-  Base base_;
-  explicit convertible_sized_sentinel() = default;
-  constexpr convertible_sized_sentinel(const Base& it) : base_(it) {}
-
-  template <std::convertible_to<Base> U>
-  constexpr convertible_sized_sentinel(const convertible_sized_sentinel<U>& other) : base_(other.base_) {}
-
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr bool operator==(const convertible_sized_sentinel& s, const U& base) {
-    return s.base_ == base;
-  }
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr auto operator-(const convertible_sized_sentinel& s, const U& i) {
-    return s.base_ - i;
-  }
-
-  template <class U>
-    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
-  friend constexpr auto operator-(const U& i, const convertible_sized_sentinel& s) {
-    return i - s.base_;
-  }
-};
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<>>,
-                                      convertible_forward_sized_iterator<>>);
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<const int*>>,
-                                      convertible_forward_sized_iterator<int*>>);
-static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<int*>>,
-                                      convertible_forward_sized_iterator<const int*>>);
-
-struct ConstCompatibleForwardSized : IntBufferView {
-  using IntBufferView::IntBufferView;
-
-  using iterator = convertible_forward_sized_iterator<int*>;
-  using const_iterator = convertible_forward_sized_iterator<const int*>;
-
-  constexpr iterator begin() { return {buffer_}; }
-  constexpr const_iterator begin() const { return {buffer_}; }
-  constexpr convertible_sized_sentinel<iterator> end() { return iterator{buffer_ + size_}; }
-  constexpr convertible_sized_sentinel<const_iterator> end() const { return const_iterator{buffer_ + size_}; }
-};
-
 // clang-format off
 template <class T, class U>
 concept HasMinus = std::invocable<std::minus<>,const T&, const U&>;
@@ -161,10 +84,10 @@ constexpr bool test() {
     static_assert(!std::ranges::common_range<decltype(v)>);
     static_assert(!simple_view<decltype(v)>);
 
-    using Iter = std::ranges::iterator_t<decltype(v)>;
+    using Iter      = std::ranges::iterator_t<decltype(v)>;
     using ConstIter = std::ranges::iterator_t<const decltype(v)>;
     static_assert(!std::is_same_v<Iter, ConstIter>);
-    using Sentinel = std::ranges::sentinel_t<decltype(v)>;
+    using Sentinel      = std::ranges::sentinel_t<decltype(v)>;
     using ConstSentinel = std::ranges::sentinel_t<const decltype(v)>;
     static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
 
@@ -172,9 +95,9 @@ constexpr bool test() {
     static_assert(HasMinus<Sentinel, Iter>);
     static_assert(HasMinus<ConstIter, ConstSentinel>);
     static_assert(HasMinus<ConstSentinel, ConstIter>);
-    auto it = v.begin();
+    auto it       = v.begin();
     auto const_it = std::as_const(v).begin();
-    auto st = v.end();
+    auto st       = v.end();
     auto const_st = std::as_const(v).end();
     assert(it - st == -5);
     assert(st - it == 5);
@@ -193,10 +116,10 @@ constexpr bool test() {
     static_assert(!std::ranges::common_range<decltype(v)>);
     static_assert(!simple_view<decltype(v)>);
 
-    using Iter = std::ranges::iterator_t<decltype(v)>;
+    using Iter      = std::ranges::iterator_t<decltype(v)>;
     using ConstIter = std::ranges::iterator_t<const decltype(v)>;
     static_assert(!std::is_same_v<Iter, ConstIter>);
-    using Sentinel = std::ranges::sentinel_t<decltype(v)>;
+    using Sentinel      = std::ranges::sentinel_t<decltype(v)>;
     using ConstSentinel = std::ranges::sentinel_t<const decltype(v)>;
     static_assert(!std::is_same_v<Sentinel, ConstSentinel>);
 
@@ -209,9 +132,9 @@ constexpr bool test() {
     static_assert(HasMinus<ConstIter, Sentinel>);
     static_assert(HasMinus<Sentinel, ConstIter>);
 
-    auto it = v.begin();
+    auto it       = v.begin();
     auto const_it = std::as_const(v).begin();
-    auto st = v.end();
+    auto st       = v.end();
     auto const_st = std::as_const(v).end();
 
     assert(it - st == -5);
diff --git a/libcxx/test/std/ranges/range.adaptors/range_adaptor_types.h b/libcxx/test/std/ranges/range.adaptors/range_adaptor_types.h
index 288a78ac722e6..da5b94d75f466 100644
--- a/libcxx/test/std/ranges/range.adaptors/range_adaptor_types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range_adaptor_types.h
@@ -429,13 +429,18 @@ static_assert(!simple_view<NonSimpleSizedBidiNonCommonView>);
 
 namespace adltest {
 struct iter_move_swap_iterator {
-  std::reference_wrapper<int> iter_move_called_times;
-  std::reference_wrapper<int> iter_swap_called_times;
-  int i = 0;
+  int* iter_move_called_times = nullptr;
+  int* iter_swap_called_times = nullptr;
+  int i                       = 0;
 
-  using iterator_category = std::input_iterator_tag;
-  using value_type        = int;
-  using difference_type   = std::intptr_t;
+  constexpr iter_move_swap_iterator() = default;
+  constexpr iter_move_swap_iterator(int& iter_move_called_times_ref, int& iter_swap_called_times_ref)
+      : iter_move_called_times(&iter_move_called_times_ref),
+        iter_swap_called_times(&iter_swap_called_times_ref),
+        i(0) {}
+
+  using value_type      = int;
+  using difference_type = std::intptr_t;
 
   constexpr int operator*() const { return i; }
 
@@ -443,17 +448,24 @@ struct iter_move_swap_iterator {
     ++i;
     return *this;
   }
-  constexpr void operator++(int) { ++i; }
+  constexpr iter_move_swap_iterator operator++(int) {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
 
   friend constexpr bool operator==(const iter_move_swap_iterator& x, std::default_sentinel_t) { return x.i == 5; }
+  friend constexpr bool operator==(const iter_move_swap_iterator& x, const iter_move_swap_iterator& y) {
+    return x.i == y.i;
+  }
 
   friend constexpr int iter_move(iter_move_swap_iterator const& it) {
-    ++it.iter_move_called_times;
+    ++*it.iter_move_called_times;
     return it.i;
   }
   friend constexpr void iter_swap(iter_move_swap_iterator const& x, iter_move_swap_iterator const& y) {
-    ++x.iter_swap_called_times;
-    ++y.iter_swap_called_times;
+    ++*x.iter_swap_called_times;
+    ++*y.iter_swap_called_times;
   }
 };
 
@@ -465,4 +477,81 @@ struct IterMoveSwapRange {
 };
 } // namespace adltest
 
+template <class Base = int*>
+struct convertible_forward_sized_iterator {
+  Base it_ = nullptr;
+
+  using iterator_category = std::forward_iterator_tag;
+  using value_type        = int;
+  using difference_type   = std::intptr_t;
+
+  convertible_forward_sized_iterator() = default;
+  constexpr convertible_forward_sized_iterator(Base it) : it_(it) {}
+
+  template <std::convertible_to<Base> U>
+  constexpr convertible_forward_sized_iterator(const convertible_forward_sized_iterator<U>& it) : it_(it.it_) {}
+
+  constexpr decltype(*Base{}) operator*() const { return *it_; }
+
+  constexpr convertible_forward_sized_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr convertible_forward_sized_iterator operator++(int) { return forward_sized_iterator(it_++); }
+
+  friend constexpr bool
+  operator==(const convertible_forward_sized_iterator&, const convertible_forward_sized_iterator&) = default;
+
+  friend constexpr difference_type
+  operator-(const convertible_forward_sized_iterator& x, const convertible_forward_sized_iterator& y) {
+    return x.it_ - y.it_;
+  }
+};
+static_assert(std::forward_iterator<convertible_forward_sized_iterator<>>);
+
+template <class Base>
+struct convertible_sized_sentinel {
+  Base base_;
+  explicit convertible_sized_sentinel() = default;
+  constexpr convertible_sized_sentinel(const Base& it) : base_(it) {}
+
+  template <std::convertible_to<Base> U>
+  constexpr convertible_sized_sentinel(const convertible_sized_sentinel<U>& other) : base_(other.base_) {}
+
+  template <class U>
+    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
+  friend constexpr bool operator==(const convertible_sized_sentinel& s, const U& base) {
+    return s.base_ == base;
+  }
+  template <class U>
+    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
+  friend constexpr auto operator-(const convertible_sized_sentinel& s, const U& i) {
+    return s.base_ - i;
+  }
+
+  template <class U>
+    requires(std::convertible_to<Base, U> || std::convertible_to<U, Base>)
+  friend constexpr auto operator-(const U& i, const convertible_sized_sentinel& s) {
+    return i - s.base_;
+  }
+};
+static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<>>,
+                                      convertible_forward_sized_iterator<>>);
+static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<const int*>>,
+                                      convertible_forward_sized_iterator<int*>>);
+static_assert(std::sized_sentinel_for<convertible_sized_sentinel<convertible_forward_sized_iterator<int*>>,
+                                      convertible_forward_sized_iterator<const int*>>);
+
+struct ConstCompatibleForwardSized : IntBufferView {
+  using IntBufferView::IntBufferView;
+
+  using iterator       = convertible_forward_sized_iterator<int*>;
+  using const_iterator = convertible_forward_sized_iterator<const int*>;
+
+  constexpr iterator begin() { return {buffer_}; }
+  constexpr const_iterator begin() const { return {buffer_}; }
+  constexpr convertible_sized_sentinel<iterator> end() { return iterator{buffer_ + size_}; }
+  constexpr convertible_sized_sentinel<const_iterator> end() const { return const_iterator{buffer_ + size_}; }
+};
+
 #endif //  TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ADAPTOR_TYPES_H
diff --git a/libcxx/test/std/ranges/ranges_robust_against_no_unique_address.pass.cpp b/libcxx/test/std/ranges/ranges_robust_against_no_unique_address.pass.cpp
index 505ed2e77ae3b..43235e23a6a98 100644
--- a/libcxx/test/std/ranges/ranges_robust_against_no_unique_address.pass.cpp
+++ b/libcxx/test/std/ranges/ranges_robust_against_no_unique_address.pass.cpp
@@ -56,6 +56,7 @@ constexpr bool test() {
   testOne<std::ranges::single_view<Pred>>();
 
 #if TEST_STD_VER >= 23
+  testOne<std::ranges::adjacent_view<View, 5>>();
   testOne<std::ranges::chunk_by_view<View, Pred>>();
   testOne<std::ranges::repeat_view<Pred>>();
   testOne<std::ranges::zip_transform_view<Pred, View>>();