diff --git a/libcxx/test/support/test.support/test_proxy.pass.cpp b/libcxx/test/support/test.support/test_proxy.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/test.support/test_proxy.pass.cpp
@@ -0,0 +1,273 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include "test_proxy.h"
+#include "test_iterators.h"
+
+#include <cassert>
+
+struct MoveOnly {
+  int i;
+
+  constexpr MoveOnly(int i) : i{i} {}
+  constexpr MoveOnly(MoveOnly&&)            = default;
+  constexpr MoveOnly& operator=(MoveOnly&&) = default;
+
+  constexpr MoveOnly(const MoveOnly&)            = delete;
+  constexpr MoveOnly& operator=(const MoveOnly&) = delete;
+};
+
+constexpr void testProxy() {
+  // constructor value
+  {
+    Proxy<int> p{5};
+    assert(p.data == 5);
+  }
+
+  // constructor reference
+  {
+    int i = 5;
+    Proxy<int&> p{i};
+    assert(&p.data == &i);
+  }
+
+  // constructor conversion
+  {
+    int i = 5;
+    Proxy<int&> p1{i};
+    Proxy<int> p2 = p1;
+    assert(p2.data == 5);
+
+    Proxy<int&> p3{p2};
+    assert(&(p3.data) == &(p2.data));
+
+    MoveOnly m1{8};
+    Proxy<MoveOnly&&> p4 = std::move(m1);
+
+    Proxy<MoveOnly> p5 = std::move(p4);
+    assert(p5.data.i == 8);
+  }
+
+  // assignment
+  {
+    Proxy<int> p1{5};
+    Proxy<int> p2{6};
+    p1 = p2;
+    assert(p1.data == 6);
+
+    MoveOnly m1{8};
+    Proxy<MoveOnly&&> p3 = std::move(m1);
+    Proxy<MoveOnly> p4{MoveOnly{9}};
+    p4 = std::move(p3);
+    assert(p4.data.i == 8);
+  }
+
+  // const assignment
+  {
+    int i = 5;
+    int j = 6;
+    const Proxy<int&> p1{i};
+    const Proxy<int&> p2{j};
+    p1 = p2;
+    assert(i == 6);
+
+    MoveOnly m1{8};
+    MoveOnly m2{9};
+    Proxy<MoveOnly&&> p3       = std::move(m1);
+    const Proxy<MoveOnly&&> p4 = std::move(m2);
+    p4                         = std::move(p3);
+    assert(p4.data.i == 8);
+  }
+}
+
+static_assert(std::input_iterator<ProxyIterator<cpp20_input_iterator<int*>>>);
+static_assert(!std::forward_iterator<ProxyIterator<cpp20_input_iterator<int*>>>);
+
+static_assert(std::forward_iterator<ProxyIterator<forward_iterator<int*>>>);
+static_assert(!std::bidirectional_iterator<ProxyIterator<forward_iterator<int*>>>);
+
+static_assert(std::bidirectional_iterator<ProxyIterator<bidirectional_iterator<int*>>>);
+static_assert(!std::random_access_iterator<ProxyIterator<bidirectional_iterator<int*>>>);
+
+static_assert(std::random_access_iterator<ProxyIterator<random_access_iterator<int*>>>);
+static_assert(!std::contiguous_iterator<ProxyIterator<random_access_iterator<int*>>>);
+
+static_assert(std::random_access_iterator<ProxyIterator<contiguous_iterator<int*>>>);
+static_assert(!std::contiguous_iterator<ProxyIterator<contiguous_iterator<int*>>>);
+
+template <class Iter>
+constexpr void testInputIteratorOperation() {
+  int data[] = {1, 2};
+  ProxyIterator<Iter> iter{Iter{data}};
+  sentinel_wrapper<ProxyIterator<Iter>> sent{ProxyIterator<Iter>{Iter{data + 2}}};
+
+  std::same_as<Proxy<int&>> decltype(auto) result = *iter;
+  assert(result.data == 1);
+  std::same_as<ProxyIterator<Iter>&> decltype(auto) iter2 = ++iter;
+  assert(&iter2 == &iter);
+  assert((*iter).data == 2);
+  ++iter;
+  assert(iter == sent);
+}
+
+template <class Iter>
+constexpr void testForwardIteratorOperation() {
+  int data[] = {1, 2};
+  ProxyIterator<Iter> iter{Iter{data}};
+
+  std::same_as<ProxyIterator<Iter>> decltype(auto) it2 = iter++;
+  assert((*it2).data == 1);
+  assert((*iter).data == 2);
+}
+
+template <class Iter>
+constexpr void testBidirectionalIteratorOperation() {
+  int data[] = {1, 2};
+  ProxyIterator<Iter> iter{Iter{data}};
+  ++iter;
+  assert((*iter).data == 2);
+
+  std::same_as<ProxyIterator<Iter>&> decltype(auto) iter2 = --iter;
+  assert(&iter2 == &iter);
+  assert((*iter).data == 1);
+  ++iter;
+
+  std::same_as<ProxyIterator<Iter>> decltype(auto) iter3 = iter--;
+  assert((*iter).data == 1);
+  assert((*iter3).data == 2);
+}
+
+template <class Iter>
+constexpr void testRandomAccessIteratorOperation() {
+  int data[] = {1, 2, 3, 4, 5};
+  ProxyIterator<Iter> iter{Iter{data}};
+
+  std::same_as<ProxyIterator<Iter>&> decltype(auto) iter2 = iter += 2;
+  assert(&iter2 == &iter);
+  assert((*iter).data == 3);
+
+  std::same_as<ProxyIterator<Iter>&> decltype(auto) iter3 = iter -= 1;
+  assert(&iter3 == &iter);
+  assert((*iter).data == 2);
+
+  std::same_as<Proxy<int&>> decltype(auto) r = iter[2];
+  assert(r.data == 4);
+
+  std::same_as<ProxyIterator<Iter>> decltype(auto) iter4 = iter - 1;
+  assert((*iter4).data == 1);
+
+  std::same_as<ProxyIterator<Iter>> decltype(auto) iter5 = iter4 + 2;
+  assert((*iter5).data == 3);
+
+  std::same_as<ProxyIterator<Iter>> decltype(auto) iter6 = 3 + iter4;
+  assert((*iter6).data == 4);
+
+  std::same_as<std::iter_difference_t<Iter>> decltype(auto) n = iter6 - iter5;
+  assert(n == 1);
+
+  assert(iter4 < iter5);
+  assert(iter3 <= iter5);
+  assert(iter5 > iter4);
+  assert(iter6 >= iter4);
+}
+
+constexpr void testProxyIterator() {
+  // input iterator operations
+  {
+    testInputIteratorOperation<cpp20_input_iterator<int*>>();
+    testInputIteratorOperation<forward_iterator<int*>>();
+    testInputIteratorOperation<bidirectional_iterator<int*>>();
+    testInputIteratorOperation<random_access_iterator<int*>>();
+    testInputIteratorOperation<contiguous_iterator<int*>>();
+  }
+
+  // forward iterator operations
+  {
+    testForwardIteratorOperation<forward_iterator<int*>>();
+    testForwardIteratorOperation<bidirectional_iterator<int*>>();
+    testForwardIteratorOperation<random_access_iterator<int*>>();
+    testForwardIteratorOperation<contiguous_iterator<int*>>();
+  }
+
+  // bidirectional iterator operations
+  {
+    testBidirectionalIteratorOperation<bidirectional_iterator<int*>>();
+    testBidirectionalIteratorOperation<random_access_iterator<int*>>();
+    testBidirectionalIteratorOperation<contiguous_iterator<int*>>();
+  }
+
+  // random access iterator operations
+  {
+    testRandomAccessIteratorOperation<random_access_iterator<int*>>();
+    testRandomAccessIteratorOperation<contiguous_iterator<int*>>();
+  }
+}
+
+constexpr void testProxyRange() {
+  int data[] = {3, 4, 5};
+  ProxyRange r{data};
+  std::same_as<ProxyIterator<int*>> decltype(auto) it = std::ranges::begin(r);
+  assert((*it).data == 3);
+  it += 3;
+  assert(it == std::ranges::end(r));
+}
+
+template <class Iter>
+concept StdMoveWorks = requires(std::iter_value_t<Iter> val, Iter iter) { val = std::move(*iter); };
+
+static_assert(StdMoveWorks<MoveOnly*>);
+static_assert(!StdMoveWorks<ProxyIterator<MoveOnly*>>);
+
+// although this "works" but it actually creates a copy instead of move
+static_assert(StdMoveWorks<ProxyIterator<int*>>);
+
+using std::swap;
+
+template <class Iter>
+concept SwapWorks = requires(Iter iter1, Iter iter2) { swap(*iter1, *iter2); };
+
+static_assert(SwapWorks<int*>);
+static_assert(!SwapWorks<ProxyIterator<int*>>);
+
+constexpr bool test() {
+  testProxy();
+  testProxyIterator();
+  testProxyRange();
+
+  // iter_move
+  {
+    MoveOnly data[] = {5, 6, 7};
+    ProxyRange r{data};
+    auto it                               = r.begin();
+    std::iter_value_t<decltype(it)> moved = std::ranges::iter_move(it);
+    assert(moved.data.i == 5);
+  }
+
+  // iter_swap
+  {
+    MoveOnly data[] = {5, 6, 7};
+    ProxyRange r{data};
+    auto it1 = r.begin();
+    auto it2 = it1 + 2;
+    std::ranges::iter_swap(it1, it2);
+    assert(data[0].i == 7);
+    assert(data[2].i == 5);
+  }
+
+  return true;
+}
+
+int main(int, const char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
\ No newline at end of file
diff --git a/libcxx/test/support/test_proxy.h b/libcxx/test/support/test_proxy.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/test_proxy.h
@@ -0,0 +1,309 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 SUPPORT_TEST_PROXY_H
+#define SUPPORT_TEST_PROXY_H
+
+#include <concepts>
+#include <iterator>
+#include <ranges>
+#include <type_traits>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER > 17
+
+// Proxy
+// ======================================================================
+// Proxy that can wrap a value of a reference. It simulates C++23's tuple
+// but simplified to just hold one argument.
+// Note that unlike tuple this class doesn't have special handling of swap
+template <class T>
+struct Proxy;
+
+template <class T>
+inline constexpr bool IsProxy = false;
+
+template <class T>
+inline constexpr bool IsProxy<Proxy<T>> = true;
+
+template <class T>
+struct Proxy {
+  T data;
+
+  template <class P>
+    requires std::same_as<std::decay_t<P>,
+                          Proxy> friend constexpr auto
+    getData(P&& p) -> std::__copy_cvref_t<P&&, T> {
+    return static_cast<std::__copy_cvref_t<P&&, T>>(p.data);
+  }
+
+  template <class U>
+    requires std::constructible_from<T, U&&>
+  constexpr Proxy(U&& u) : data{std::forward<U>(u)} {}
+
+  // This constructor covers conversion from cvref of Proxy<U>, including non-const/const versions of copy/move constructor
+  template <class Other>
+    requires(IsProxy<std::decay_t<Other>> && std::constructible_from<T, decltype(getData(std::declval<Other>()))>)
+  constexpr Proxy(Other&& other) : data{getData(std::forward<Other>(other))} {}
+
+  template <class Other>
+    requires(IsProxy<std::decay_t<Other>> && std::assignable_from<T&, decltype(getData(std::declval<Other>()))>)
+  constexpr Proxy& operator=(Other&& other) {
+    data = getData(std::forward<Other>(other));
+    return *this;
+  }
+
+  // const assignment required by indirectly_writable
+  template <class Other>
+    requires(IsProxy<std::decay_t<Other>> && std::assignable_from<const T&, decltype(getData(std::declval<Other>()))>)
+  constexpr const Proxy& operator=(Other&& other) const {
+    data = getData(std::forward<Other>(other));
+    return *this;
+  }
+
+  // no specialised swap function that takes const Proxy& and no specialised const member swap
+  // Calling swap(Proxy<T>{}, Proxy<T>{}) would fail (pass prvalues)
+};
+
+// This is to make ProxyIterator model `std::indirectly_readable`
+template <class T, class U, template <class> class TQual, template <class> class UQual>
+  requires requires { typename std::common_reference_t<TQual<T>, UQual<U>>; }
+struct std::basic_common_reference<Proxy<T>, Proxy<U>, TQual, UQual> {
+  using type = Proxy<std::common_reference_t<TQual<T>, UQual<U>>>;
+};
+
+template <class T, class U>
+  requires requires { typename std::common_type_t<T, U>; }
+struct std::common_type<Proxy<T>, Proxy<U>> {
+  using type = Proxy<std::common_type_t<T, U>>;
+};
+
+// ProxyIterator
+// ======================================================================
+// It wraps `Base` iterator and when deference it returns a Proxy<ref>
+// It simulates C++23's zip_view::iterator but simplified to just wrap
+// one base iterator.
+// Note it forwards value_type, iter_move, iter_swap. e.g If the base
+// iterator is int*,
+// operator*    -> Proxy<int&>
+// iter_value_t -> Proxy<int>
+// iter_move    -> Proxy<int&&>
+template <class Base>
+struct ProxyIteratorBase {};
+
+template <class Base>
+  requires std::derived_from<
+      typename std::iterator_traits<Base>::iterator_category,
+      std::input_iterator_tag> struct ProxyIteratorBase<Base> {
+  using iterator_category = std::input_iterator_tag;
+};
+
+template <std::input_iterator Base>
+consteval auto get_iterator_concept() {
+  if constexpr (std::random_access_iterator<Base>) {
+    return std::random_access_iterator_tag{};
+  } else if constexpr (std::bidirectional_iterator<Base>) {
+    return std::bidirectional_iterator_tag{};
+  } else if constexpr (std::forward_iterator<Base>) {
+    return std::forward_iterator_tag{};
+  } else {
+    return std::input_iterator_tag{};
+  }
+}
+
+template <std::input_iterator Base>
+struct ProxyIterator : ProxyIteratorBase<Base> {
+  Base base_;
+
+  using iterator_concept = decltype(get_iterator_concept<Base>());
+  using value_type       = Proxy<std::iter_value_t<Base>>;
+  using difference_type  = std::iter_difference_t<Base>;
+
+  ProxyIterator()
+    requires std::default_initializable<Base>
+  = default;
+
+  constexpr ProxyIterator(Base base) : base_{std::move(base)} {}
+
+  friend constexpr decltype(auto) base(const ProxyIterator& p) { return base(p.base_); }
+
+  // Specialization of iter_move
+  // If operator* returns Proxy<Foo&>, iter_move will return Proxy<Foo&&>
+  // Note std::move(*it) returns Proxy<Foo&>&&, which is not what we want as
+  // it will likely result in a copy rather than a move
+  friend constexpr Proxy<std::iter_rvalue_reference_t<Base>> iter_move(const ProxyIterator& p) noexcept {
+    return {std::ranges::iter_move(p.base_)};
+  }
+
+  // Specialization of iter_swap
+  // Note std::swap(*x, *y) would fail to compile as operator* returns prvalues
+  // and std::swap takes non-const lvalue references
+  friend constexpr void iter_swap(const ProxyIterator& x, const ProxyIterator& y) noexcept {
+    std::ranges::iter_swap(x.base_, y.base_);
+  }
+
+  // to satisfy input_iterator
+  constexpr Proxy<std::iter_reference_t<Base>> operator*() const { return {*base_}; }
+
+  constexpr ProxyIterator& operator++() {
+    ++base_;
+    return *this;
+  }
+
+  constexpr void operator++(int) { ++*this; }
+
+  friend constexpr bool operator==(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::equality_comparable<Base>
+  {
+    return x.base_ == y.base_;
+  }
+
+  // to satisfy forward_iterator
+  constexpr ProxyIterator operator++(int)
+    requires std::forward_iterator<Base>
+  {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  // to satisfy bidirectional_iterator
+  constexpr ProxyIterator& operator--()
+    requires std::bidirectional_iterator<Base>
+  {
+    --base_;
+    return *this;
+  }
+
+  constexpr ProxyIterator operator--(int)
+    requires std::bidirectional_iterator<Base>
+  {
+    auto tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+  constexpr ProxyIterator& operator+=(difference_type n)
+    requires std::random_access_iterator<Base>
+  {
+    base_ += n;
+    return *this;
+  }
+
+  constexpr ProxyIterator& operator-=(difference_type n)
+    requires std::random_access_iterator<Base>
+  {
+    base_ -= n;
+    return *this;
+  }
+
+  constexpr Proxy<std::iter_reference_t<Base>> operator[](difference_type n) const
+    requires std::random_access_iterator<Base>
+  {
+    return {base_[n]};
+  }
+
+  friend constexpr bool operator<(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::random_access_iterator<Base>
+  {
+    return x.base_ < y.base_;
+  }
+
+  friend constexpr bool operator>(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::random_access_iterator<Base>
+  {
+    return x.base_ > y.base_;
+  }
+
+  friend constexpr bool operator<=(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::random_access_iterator<Base>
+  {
+    return x.base_ <= y.base_;
+  }
+
+  friend constexpr bool operator>=(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::random_access_iterator<Base>
+  {
+    return x.base_ >= y.base_;
+  }
+
+  friend constexpr auto operator<=>(const ProxyIterator& x, const ProxyIterator& y)
+    requires(std::random_access_iterator<Base> && std::three_way_comparable<Base>)
+  {
+    return x.base_ <=> y.base_;
+  }
+
+  friend constexpr ProxyIterator operator+(const ProxyIterator& x, difference_type n)
+    requires std::random_access_iterator<Base>
+  {
+    return ProxyIterator{x.base_ + n};
+  }
+
+  friend constexpr ProxyIterator operator+(difference_type n, const ProxyIterator& x)
+    requires std::random_access_iterator<Base>
+  {
+    return ProxyIterator{n + x.base_};
+  }
+
+  friend constexpr ProxyIterator operator-(const ProxyIterator& x, difference_type n)
+    requires std::random_access_iterator<Base>
+  {
+    return ProxyIterator{x.base_ - n};
+  }
+
+  friend constexpr difference_type operator-(const ProxyIterator& x, const ProxyIterator& y)
+    requires std::random_access_iterator<Base>
+  {
+    return x.base_ - y.base_;
+  }
+};
+
+template <class BaseSent>
+struct ProxySentinel {
+  BaseSent base_;
+
+  ProxySentinel() = default;
+  constexpr ProxySentinel(BaseSent base) : base_{std::move(base)} {}
+
+  template <class Base>
+    requires std::equality_comparable_with<Base, BaseSent>
+  friend constexpr bool operator==(const ProxyIterator<Base>& p, const ProxySentinel& sent) {
+    return p.base_ == sent.base_;
+  }
+};
+
+template <std::ranges::input_range Base>
+  requires std::ranges::view<Base>
+struct ProxyRange {
+  Base base_;
+
+  constexpr auto begin() { return ProxyIterator{std::ranges::begin(base_)}; }
+
+  constexpr auto end() { return ProxySentinel{std::ranges::end(base_)}; }
+
+  constexpr auto begin() const
+    requires std::ranges::input_range<const Base>
+  {
+    return ProxyIterator{std::ranges::begin(base_)};
+  }
+
+  constexpr auto end() const
+    requires std::ranges::input_range<const Base>
+  {
+    return ProxySentinel{std::ranges::end(base_)};
+  }
+};
+
+template <std::ranges::input_range R>
+  requires std::ranges::viewable_range<R&&>
+ProxyRange(R&&) -> ProxyRange<std::views::all_t<R&&>>;
+
+#endif // TEST_STD_VER > 17
+
+#endif // SUPPORT_TEST_PROXY_H