diff --git a/libcxx/test/std/iterators/predef.iterators/iterators.common/ctor.pass.cpp b/libcxx/test/std/iterators/predef.iterators/iterators.common/ctor.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/iterators.common/ctor.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/iterators.common/ctor.pass.cpp
@@ -27,59 +27,60 @@
   typename std::common_iterator<I, S>;
 };
 
-template<class I, class I2>
-concept ConvCtorEnabled = requires(std::common_iterator<I2, sentinel_type<int*>> ci) {
-  std::common_iterator<I, sentinel_type<int*>>(ci);
-};
-
 void test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
-  static_assert( std::is_default_constructible_v<std::common_iterator<int*, sentinel_type<int*>>>);
-  static_assert(!std::is_default_constructible_v<std::common_iterator<non_default_constructible_iterator<int*>, sentinel_type<int*>>>);
+  static_assert( std::is_default_constructible_v<std::common_iterator<int*, sentinel_wrapper<int*>>>);
+  static_assert(!std::is_default_constructible_v<std::common_iterator<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>>);
 
   // Not copyable:
-  static_assert(!ValidCommonIterator<cpp20_input_iterator<int*>, sentinel_type<int*>>);
+  static_assert(!ValidCommonIterator<cpp20_input_iterator<int*>, sentinel_wrapper<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), sentinel_type<int*>>(iter1);
-    auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
-
-    assert(*iter1 == 1);
+    using It = cpp17_input_iterator<int*>;
+    using Sent = sentinel_wrapper<It>;
+    auto commonIter1 = std::common_iterator<It, Sent>(It(buffer));
+    auto commonSent1 = std::common_iterator<It, Sent>(Sent(It(buffer + 8)));
     assert(*commonIter1 == 1);
     assert(commonIter1 != commonSent1);
+    assert(std::next(commonIter1, 8) == commonSent1);
   }
   {
-    auto iter1 = forward_iterator<int*>(buffer);
-    auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
-    auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
-
-    assert(*iter1 == 1);
+    using It = forward_iterator<int*>;
+    using Sent = sentinel_wrapper<It>;
+    auto commonIter1 = std::common_iterator<It, Sent>(It(buffer));
+    auto commonSent1 = std::common_iterator<It, Sent>(Sent(It(buffer + 8)));
     assert(*commonIter1 == 1);
     assert(commonIter1 != commonSent1);
+    assert(std::next(commonIter1, 8) == commonSent1);
   }
   {
-    auto iter1 = random_access_iterator<int*>(buffer);
-    auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
-    auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
-
-    assert(*iter1 == 1);
+    using It = random_access_iterator<int*>;
+    using Sent = sentinel_wrapper<It>;
+    auto commonIter1 = std::common_iterator<It, Sent>(It(buffer));
+    auto commonSent1 = std::common_iterator<It, Sent>(Sent(It(buffer + 8)));
     assert(*commonIter1 == 1);
     assert(commonIter1 != commonSent1);
+    assert(std::next(commonIter1, 8) == commonSent1);
   }
-
-  // Conversion constructor:
   {
-    convertible_iterator<int*> conv{buffer};
-    auto commonIter1 = std::common_iterator<convertible_iterator<int*>, sentinel_type<int*>>(conv);
-    auto commonIter2 = std::common_iterator<forward_iterator<int*>, sentinel_type<int*>>(commonIter1);
-    assert(*commonIter2 == 1);
-
-    static_assert( ConvCtorEnabled<forward_iterator<int*>, convertible_iterator<int*>>);
-    static_assert(!ConvCtorEnabled<forward_iterator<int*>, random_access_iterator<int*>>);
+    // Test the converting constructor
+    struct Base {};
+    struct Derived : Base {};
+
+    using BaseIt = std::common_iterator<Base*, const Base*>;
+    using DerivedIt = std::common_iterator<Derived*, const Derived*>;
+    static_assert(std::is_convertible_v<DerivedIt, BaseIt>); // Derived* to Base*
+    static_assert(!std::is_constructible_v<DerivedIt, BaseIt>); // Base* to Derived*
+    Derived a[10];
+    auto it = DerivedIt(a); // the iterator type
+    auto jt = BaseIt(it);
+    assert(jt == BaseIt(a));
+    it = DerivedIt((const Derived*)a); // the sentinel type
+    jt = it;
+    assert(jt == BaseIt(a));
   }
 }
 
diff --git a/libcxx/test/std/iterators/predef.iterators/iterators.common/types.h b/libcxx/test/std/iterators/predef.iterators/iterators.common/types.h
--- a/libcxx/test/std/iterators/predef.iterators/iterators.common/types.h
+++ b/libcxx/test/std/iterators/predef.iterators/iterators.common/types.h
@@ -157,32 +157,6 @@
     }
 };
 
-template <class It>
-class convertible_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_;}
-
-    convertible_iterator() = default;
-    explicit constexpr convertible_iterator(It it) : it_(it) {}
-
-    constexpr reference operator*() const {return *it_;}
-
-    constexpr convertible_iterator& operator++() {++it_; return *this;}
-    constexpr convertible_iterator operator++(int)
-        {convertible_iterator tmp(*this); ++(*this); return tmp;}
-
-    operator forward_iterator<It>() const { return forward_iterator<It>(it_); }
-};
-
 template <class It>
 class non_const_deref_iterator
 {
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -116,38 +116,6 @@
     void operator,(T const &) = delete;
 };
 
-template <class It>
-class non_default_constructible_iterator
-{
-    It it_;
-
-    template <class U> friend class non_default_constructible_iterator;
-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;
-
-    non_default_constructible_iterator() = delete;
-
-    TEST_CONSTEXPR explicit non_default_constructible_iterator(It it) : it_(it) {}
-    template <class U>
-        TEST_CONSTEXPR non_default_constructible_iterator(const non_default_constructible_iterator<U>& u) : it_(u.it_) {}
-
-    TEST_CONSTEXPR reference operator*() const {return *it_;}
-    TEST_CONSTEXPR pointer operator->() const {return it_;}
-
-    TEST_CONSTEXPR_CXX14 non_default_constructible_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 non_default_constructible_iterator operator++(int) {return non_default_constructible_iterator(it_++);}
-
-    friend TEST_CONSTEXPR bool operator==(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y) {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR bool operator!=(const non_default_constructible_iterator& x, const non_default_constructible_iterator& y) {return x.it_ != y.it_;}
-
-    template <class T>
-    void operator,(T const &) = delete;
-};
-
 template <class It>
 class bidirectional_iterator
 {