diff --git a/libcxx/include/__iterator/common_iterator.h b/libcxx/include/__iterator/common_iterator.h
--- a/libcxx/include/__iterator/common_iterator.h
+++ b/libcxx/include/__iterator/common_iterator.h
@@ -28,6 +28,7 @@
 
 #if !defined(_LIBCPP_HAS_NO_RANGES)
 
+// REVIEW-NOTE: This is *not* part of the transform_view patch and will be added by a *separate* PR.
 template<class _I1, class _I2>
 concept indirectly_swappable =
     indirectly_readable<_I1> &&
@@ -38,63 +39,191 @@
         ranges::iter_swap(i2, i1);
         ranges::iter_swap(i2, i2);
     };
+// END-REVIEW-NOTE.
+
+struct default_sentinel_t {};
 
 template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
   requires (!same_as<_Iter, _Sent> && copyable<_Iter>)
 class common_iterator {
-  union {
-    _Iter __iter;
-    _Sent __sent;
+  union _Hold {
+    _Iter __iter; // __index == 0;
+    _Sent __sent; // __index == 1;
+
+    _Hold() = default;
+    constexpr _Hold(_Iter __iter) : __iter(_VSTD::move(__iter)) {}
+    constexpr _Hold(_Sent __sent) : __sent(_VSTD::move(__sent)) {}
+  } __u;
+  bool __index;
+
+  class __proxy {
+    friend common_iterator;
+
+    iter_value_t<_Iter> __value;
+    constexpr __proxy(iter_reference_t<_Iter>&& __x)
+      : __value(__x) {}
+
+  public:
+    constexpr const iter_value_t<_Iter>* operator->() const {
+      return _VSTD::addressof(__value);
+    }
+  };
+
+  class __postfix_proxy {
+    friend common_iterator;
+
+    iter_value_t<_Iter> __value;
+    constexpr __postfix_proxy(iter_reference_t<_Iter>&& __x)
+      : __value(__x) {}
+
+  public:
+    constexpr const iter_value_t<_Iter>& operator*() const {
+      return __value;
+    }
   };
 
 public:
   common_iterator() = default;
 
-  constexpr common_iterator(_Iter __i);
-  constexpr common_iterator(_Sent __s);
+  constexpr common_iterator(_Iter __i) : __u(_VSTD::move(__i)), __index(false) {}
+  constexpr common_iterator(_Sent __s) : __u(_VSTD::move(__s)), __index(true ) {}
 
   template<class _I2, class _S2>
     requires convertible_to<const _I2, _Iter> && convertible_to<const _S2&, _Sent>
-  common_iterator(const common_iterator<_I2, _S2>& __other);
+  constexpr common_iterator(const common_iterator<_I2, _S2>& __other)
+    : __u(__other.__u), __index(__other.__index) {}
 
   template<class _I2, class _S2>
     requires convertible_to<const _I2, _Iter> && convertible_to<const _S2&, _Sent> &&
              assignable_from<const _I2, _Iter> && assignable_from<const _S2&, _Sent>
-  common_iterator& operator=(const common_iterator<_I2, _S2>& __other);
+  constexpr common_iterator& operator=(const common_iterator<_I2, _S2>& __other) {
+    __u = __other.__u;
+    __index = __other.__index;
+  }
+
+  constexpr decltype(auto) operator*() { return *__u.__iter; }
+  constexpr decltype(auto) operator*() const
+    requires __dereferenceable<const _Iter>
+  { return *__u.__iter; }
 
-  decltype(auto) operator*();
-  decltype(auto) operator*() const
-    requires __dereferenceable<const _Iter>;
-  decltype(auto) operator->() const
+  constexpr decltype(auto) operator->() const
     requires indirectly_readable<const _Iter> &&
     (requires(const _Iter& __i) { __i.operator->(); } ||
      is_reference_v<iter_reference_t<_Iter>> ||
-     constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>);
-
-  common_iterator& operator++();
-  decltype(auto) operator++(int);
+     constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>) {
+    if constexpr (is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); })    {
+      return __u.__iter;
+    } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
+      auto&& __tmp = *__u.__iter;
+      return _VSTD::addressof(__tmp);
+    } else {
+      return __proxy(*__u.__iter);
+    }
+  }
+
+  constexpr common_iterator& operator++() { ++__u.__iter; return *this; }
+  constexpr decltype(auto) operator++(int) {
+    if constexpr (forward_iterator<_Iter>) {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    } else if constexpr (requires (_Iter& __i) { { *__i++ } -> __referenceable; } ||
+                         !constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>) {
+      return __u.__iter++;
+    } else {
+      __postfix_proxy __p(*this);
+      ++*this;
+      return __p;
+    }
+  }
 
   template<class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2>
-  friend bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index == __y.__index)
+      return true;
+
+    if (__x.__index == 0)
+      return __x.__u.__iter == __y.__u.__sent;
+
+    return __x.__u.__sent == __y.__u.__iter;
+  }
 
   template<class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2> && equality_comparable_with<_Iter, _I2>
-  friend bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index && __y.__index)
+      return true;
+
+    if (__x.__index == 0 && __y.__index == 0)
+      return __x.__u.__iter == __y.__u.__iter;
+
+    if (__x.__index == 0)
+      return __x.__u.__iter == __y.__u.__sent;
+
+    return __x.__u.__sent == __y.__u.__iter;
+  }
 
   template<sized_sentinel_for<_Iter> _I2, sized_sentinel_for<_Iter> _S2>
     requires sized_sentinel_for<_Sent, _I2>
-  friend iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y);
+  friend constexpr iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    if (__x.__index && __y.__index)
+      return 0;
 
-  friend iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
+    if (__x.__index == 0 && __y.__index == 0)
+      return __x.__u.__iter - __y.__u.__iter;
+
+    if (__x.__index == 0)
+      return __x.__u.__iter - __y.__u.__sent;
+
+    return __x.__u.__sent - __y.__u.__iter;
+  }
+
+  friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
     noexcept(noexcept(ranges::iter_move(declval<const _Iter&>())))
-      requires input_iterator<_Iter>;
+      requires input_iterator<_Iter>
+  { return ranges::iter_move(__i.__u.__iter); }
 
   template<indirectly_swappable<_Iter> _I2, class _S2>
-    friend void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
-      noexcept(noexcept(ranges::iter_swap(declval<const _Iter&>(), declval<const _I2&>())));
+  friend constexpr void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
+      noexcept(noexcept(ranges::iter_swap(declval<const _Iter&>(), declval<const _I2&>())))
+  { return ranges::iter_swap(__x.__u.__iter, __y.__u.__iter); }
 };
 
+template<class _Iter, class _Sent>
+struct incrementable_traits<common_iterator<_Iter, _Sent>> {
+  using difference_type = iter_difference_t<_Iter>;
+};
+
+template<class _Iter>
+concept __denotes_forward_iter =
+  requires {
+    typename iterator_traits<_Iter>::iterator_category;
+  } &&
+  derived_from<typename iterator_traits<_Iter>::iterator_category, forward_iterator_tag>;
+
+template<class _Iter, class _Sent>
+concept __common_iter_has_ptr_op = requires(const common_iterator<_Iter, _Sent> __a) {
+  __a.operator->();
+};
+
+template<class _Iter, class _Sent>
+struct iterator_traits<common_iterator<_Iter, _Sent>> {
+  using iterator_concept = conditional_t<forward_iterator<_Iter>,
+                                         forward_iterator_tag,
+                                         input_iterator_tag>;
+  using iterator_category = conditional_t<__denotes_forward_iter<_Iter>,
+                                          forward_iterator_tag,
+                                          input_iterator_tag>;
+  using pointer = conditional_t<__common_iter_has_ptr_op<_Iter, _Sent>,
+                                decltype(declval<const common_iterator<_Iter, _Sent>>().operator->()),
+                                void>;
+  using value_type = iter_value_t<_Iter>;
+  using difference_type = iter_difference_t<_Iter>;
+  using reference = iter_reference_t<_Iter>;
+};
+
+
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/test/std/iterators/predef.iterators/iterators.common/common_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/iterators.common/common_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/iterators.common/common_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/iterators.common/common_iterator.pass.cpp
@@ -18,8 +18,409 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_iterators.h"
+
+template <class It>
+class simple_iterator
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    simple_iterator() = default;
+    explicit constexpr simple_iterator(It it) : it_(it) {}
+
+    constexpr reference operator*() const {return *it_;}
+
+    constexpr simple_iterator& operator++() {++it_; return *this;}
+    constexpr simple_iterator operator++(int)
+        {simple_iterator tmp(*this); ++(*this); return tmp;}
+};
+
+template <class It>
+class value_iterator
+{
+    It it_;
+
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    constexpr It base() const {return it_;}
+
+    value_iterator() = default;
+    explicit constexpr value_iterator(It it) : it_(it) {}
+
+    constexpr value_type operator*() const {return *it_;}
+
+    constexpr value_iterator& operator++() {++it_; return *this;}
+    constexpr value_iterator operator++(int)
+        {value_iterator tmp(*this); ++(*this); return tmp;}
+};
+
+
+template<class T>
+struct sentienl_type {
+  T base;
+
+  template<class U>
+  friend constexpr bool operator==(const sentienl_type& lhs, const U& rhs) { return lhs.base == rhs.base(); }
+  template<class U>
+  friend constexpr bool operator==(const U& lhs, const sentienl_type& rhs) { return lhs.base() == rhs.base; }
+};
+
+template<class T>
+struct sized_sentienl_type {
+  T base;
+
+  template<class U>
+  friend constexpr bool operator==(const sized_sentienl_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  template<class U>
+  friend constexpr bool operator==(const U& lhs, const sized_sentienl_type& rhs) { return lhs.base() - rhs.base; }
+  template<class U>
+  friend constexpr auto operator- (const sized_sentienl_type& lhs, const U& rhs) { return lhs.base - rhs.base(); }
+  template<class U>
+  friend constexpr auto operator- (const U& lhs, const sized_sentienl_type& rhs) { return lhs.base() - rhs.base; }
+};
+
+template<class I, class S>
+concept ValidCommonIterator = requires {
+  typename std::common_iterator<I, S>;
+};
+
+constexpr void testIteratorTraits() {
+  {
+    using Iter = simple_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, int*>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = value_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    // Note: IterTraits::pointer == __proxy.
+    static_assert(!std::same_as<IterTraits::pointer, int*>);
+    static_assert(std::same_as<IterTraits::reference, int>);
+  }
+  {
+    using Iter = cpp17_input_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::input_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>); // TODO: is this right?
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = forward_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+  {
+    using Iter = random_access_iterator<int*>;
+    using CommonIter = std::common_iterator<Iter, sentienl_type<int*>>;
+    using IterTraits = std::iterator_traits<CommonIter>;
+
+    static_assert(std::same_as<IterTraits::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<IterTraits::value_type, int>);
+    static_assert(std::same_as<IterTraits::difference_type, std::ptrdiff_t>);
+    static_assert(std::same_as<IterTraits::pointer, Iter>);
+    static_assert(std::same_as<IterTraits::reference, int&>);
+  }
+}
+
+constexpr void testCtor() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  static_assert(std::is_default_constructible_v<std::common_iterator<int*, sentienl_type<int*>>>);
+
+  // Not copyable:
+  static_assert(!ValidCommonIterator<cpp20_input_iterator<int*>, sentienl_type<int*>>);
+  // Same iter and sent:
+  static_assert(!ValidCommonIterator<cpp17_input_iterator<int*>, cpp17_input_iterator<int*>>);
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+  }
+}
+
+constexpr void testMembers() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = simple_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = simple_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = value_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = value_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(*commonIter1.operator->().operator->() == 1);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(*commonIter2.operator->().operator->() == 1);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = cpp17_input_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = forward_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    const auto iter2 = random_access_iterator<int*>(buffer);
+    const auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    const auto commonSent2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(sentienl_type<int*>{buffer + 8});
+
+    assert(*iter1 == 1);
+    assert(*commonIter1 == 1);
+    assert(commonIter1 != commonSent1);
+    assert(commonIter1.operator->().base() == buffer);
+
+    assert(*iter2 == 1);
+    assert(*commonIter2 == 1);
+    assert(commonIter2 != commonSent2);
+    assert(commonIter2.operator->().base() == buffer);
+
+    assert(*(commonIter1++) == 1);
+    assert(*commonIter1 == 2);
+    assert(*(++commonIter1) == 3);
+    assert(*commonIter1 == 3);
+
+    for (auto i = 3; commonIter1 != commonSent1; ++i) {
+      assert(*(commonIter1++) == i);
+    }
+    assert(commonIter1 == commonSent1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sized_sentienl_type<int*>>(iter1);
+    auto commonSent1 = std::common_iterator<decltype(iter1), sized_sentienl_type<int*>>(sized_sentienl_type<int*>{buffer + 8});
+    assert(commonIter1 - commonSent1 == -8);
+    assert(commonSent1 - commonIter1 == 8);
+    assert(commonIter1 - commonIter1 == 0);
+    assert(commonSent1 - commonSent1 == 0);
+  }
+}
+
+constexpr void testCust() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    auto commonIter2 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    for (auto i = 0; i < 4; ++i) ++commonIter2;
+    assert(*commonIter2 == 5);
+    std::ranges::iter_swap(commonIter1, commonIter2);
+    assert(*commonIter1 == 5);
+    assert(*commonIter2 == 1);
+    std::ranges::iter_swap(commonIter2, commonIter1);
+  }
+  {
+    auto iter1 = cpp17_input_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = forward_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+  {
+    auto iter1 = random_access_iterator<int*>(buffer);
+    auto commonIter1 = std::common_iterator<decltype(iter1), sentienl_type<int*>>(iter1);
+    assert(std::ranges::iter_move(commonIter1) == 1);
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(commonIter1)), int&&);
+  }
+}
 
 constexpr bool test() {
+  testIteratorTraits();
+  testCtor();
+  testMembers();
+  testCust();
 
   return true;
 }