[libc++] Erase-Like Algorithms in C++17 and below

[miyuki]

Summary

A recent change https://reviews.llvm.org/D58332 implemented P0646R1.
However, the change does not fix any defects in the C++ Standard and
thus should not be applied retroactively.

This patch changes the return type of the remove, remove_if and
unique member functions of the class templates list and forward_list
back to void in versions prior to c++2a.

As the P0646R1 paper suggests, modern compilers are smart enough to
optimize out the code related to counting the number of removed
elements, so only minimal changes are required in the implementation
of the functions mentioned above.

[miyuki]

Abandoned in favor of:
https://reviews.llvm.org/rG1ab3fe8a7a6537f882bbb2dac72c479d05eb8c49 and
https://reviews.llvm.org/rGf814dcbafbabd46a1babaeabec6acc3b70951bf4

libcxx/include/forward_list

static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
     typedef value_type&                                                reference;
     typedef const value_type&                                          const_reference;
     typedef typename allocator_traits<allocator_type>::pointer         pointer;
     typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
     typedef typename allocator_traits<allocator_type>::size_type       size_type;
     typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+#if _LIBCPP_STD_VER > 17
+    typedef size_type __remove_return_type;
+#else
+    typedef void __remove_return_type;
+#endif
 
     typedef typename base::iterator       iterator;
     typedef typename base::const_iterator const_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     forward_list()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
         {} // = default;
#endif
     void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
     _LIBCPP_INLINE_VISIBILITY
     void splice_after(const_iterator __p, forward_list&& __x,
                       const_iterator __f, const_iterator __l);
     void splice_after(const_iterator __p, forward_list& __x);
     void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
     void splice_after(const_iterator __p, forward_list& __x,
                       const_iterator __f, const_iterator __l);
-    size_type remove(const value_type& __v);
-    template <class _Predicate> size_type remove_if(_Predicate __pred);
+    __remove_return_type remove(const value_type& __v);
+    template <class _Predicate> __remove_return_type remove_if(_Predicate __pred);
     _LIBCPP_INLINE_VISIBILITY
-    size_type unique() {return unique(__equal_to<value_type>());}
-    template <class _BinaryPredicate> size_type unique(_BinaryPredicate __binary_pred);
+    __remove_return_type unique() {return unique(__equal_to<value_type>());}
+    template <class _BinaryPredicate> __remove_return_type unique(_BinaryPredicate __binary_pred);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
     template <class _Compare>
         _LIBCPP_INLINE_VISIBILITY
         void merge(forward_list&& __x, _Compare __comp)
         {merge(__x, _VSTD::move(__comp));}
 #endif  // _LIBCPP_CXX03_LANG

 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
                                         forward_list&& __x,
                                         const_iterator __f, const_iterator __l)
 {
     splice_after(__p, __x, __f, __l);
 }
 
 template <class _Tp, class _Alloc>
-typename forward_list<_Tp, _Alloc>::size_type
+typename forward_list<_Tp, _Alloc>::__remove_return_type
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
     const iterator __e = end();
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__i.__get_begin()->__next_->__value_ == __v)
         {
             ++__count_removed;
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
                 ++__count_removed;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
-    
+#if _LIBCPP_STD_VER > 17
     return __count_removed;
+#else
+    (void)__count_removed;
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _Predicate>
-typename forward_list<_Tp, _Alloc>::size_type
+typename forward_list<_Tp, _Alloc>::__remove_return_type
 forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
     const iterator __e = end();
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__pred(__i.__get_begin()->__next_->__value_))
         {
             ++__count_removed;
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
                 ++__count_removed;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
-    
+#if _LIBCPP_STD_VER > 17
     return __count_removed;
+#else
+    (void)__count_removed;
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPredicate>
-typename forward_list<_Tp, _Alloc>::size_type
+typename forward_list<_Tp, _Alloc>::__remove_return_type
 forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ++__count_removed;
         if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
         __i = __j;
     }
     
+#if _LIBCPP_STD_VER > 17
     return __count_removed;
+#else
+    (void)__count_removed;
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
 void
 forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
 {
     if (this != &__x)

libcxx/include/list

public:
     typedef typename base::pointer                   pointer;
     typedef typename base::const_pointer             const_pointer;
     typedef typename base::size_type                 size_type;
     typedef typename base::difference_type           difference_type;
     typedef typename base::iterator                  iterator;
     typedef typename base::const_iterator            const_iterator;
     typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
+#if _LIBCPP_STD_VER > 17
+    typedef size_type __remove_return_type;
+#else
+    typedef void __remove_return_type;
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     list()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
     {
 #if _LIBCPP_DEBUG_LEVEL >= 2
         __get_db()->__insert_c(this);
 #endif
void splice(const_iterator __p, list&& __c, const_iterator __i)
         {splice(__p, __c, __i);}
     _LIBCPP_INLINE_VISIBILITY
     void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
         {splice(__p, __c, __f, __l);}
 #endif
     void splice(const_iterator __p, list& __c, const_iterator __i);
     void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
 
-    size_type remove(const value_type& __x);
-    template <class _Pred> size_type remove_if(_Pred __pred);
+    __remove_return_type remove(const value_type& __x);
+    template <class _Pred> __remove_return_type remove_if(_Pred __pred);
     _LIBCPP_INLINE_VISIBILITY
-    size_type unique() { return unique(__equal_to<value_type>()); }
+    __remove_return_type unique() { return unique(__equal_to<value_type>()); }
     template <class _BinaryPred>
-        size_type unique(_BinaryPred __binary_pred);
+        __remove_return_type unique(_BinaryPred __binary_pred);
     _LIBCPP_INLINE_VISIBILITY
     void merge(list& __c);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void merge(list&& __c) {merge(__c);}
 
     template <class _Comp>
     _LIBCPP_INLINE_VISIBILITY
#if _LIBCPP_DEBUG_LEVEL >= 2
             }
             __db->unlock();
         }
 #endif
     }
 }
 
 template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::size_type
+typename list<_Tp, _Alloc>::__remove_return_type
 list<_Tp, _Alloc>::remove(const value_type& __x)
 {
     list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     for (const_iterator __i = begin(), __e = end(); __i != __e;)
     {
         if (*__i == __x)
         {
             const_iterator __j = _VSTD::next(__i);
             for (; __j != __e && *__j == __x; ++__j)
                 ;
             __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
             __i = __j;
             if (__i != __e)
                 ++__i;
         }
         else
             ++__i;
     }
-
+#if _LIBCPP_STD_VER > 17
     return __deleted_nodes.size();
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _Pred>
-typename list<_Tp, _Alloc>::size_type
+typename list<_Tp, _Alloc>::__remove_return_type
 list<_Tp, _Alloc>::remove_if(_Pred __pred)
 {
     list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         if (__pred(*__i))
         {
             iterator __j = _VSTD::next(__i);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
             __i = __j;
             if (__i != __e)
                 ++__i;
         }
         else
             ++__i;
     }
 
+#if _LIBCPP_STD_VER > 17
     return __deleted_nodes.size();
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPred>
-typename list<_Tp, _Alloc>::size_type
+typename list<_Tp, _Alloc>::__remove_return_type
 list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 {
     list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
         if (++__i != __j) {
             __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
             __i = __j;
             }
     }
-    
+#if _LIBCPP_STD_VER > 17
     return __deleted_nodes.size();
+#endif
 }
 
 template <class _Tp, class _Alloc>
 inline
 void
 list<_Tp, _Alloc>::merge(list& __c)
 {
     merge(__c, __less<value_type>());

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove.pass.cpp

struct S {
     S(const S &rhs) : i_(new int(*rhs.i_)) {}
     S& operator = (const S &rhs) { *i_ = *rhs.i_; return *this; }
     ~S () { delete i_; i_ = NULL; }
     bool operator == (const S &rhs) const { return *i_ == *rhs.i_; }
     int get () const { return *i_; }
     int *i_;
     };
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
 
 int main(int, char**)
 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 4);
+        ASSERT_CPP20_EQ(c1.remove(0), 4);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
-        assert(c1.remove(0) == 4);
+        ASSERT_CPP20_EQ(c1.remove(0), 4);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 0);
+        ASSERT_CPP20_EQ(c1.remove(0), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
-        assert(c1.remove(0) == 0);
+        ASSERT_CPP20_EQ(c1.remove(0), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 1);
+        ASSERT_CPP20_EQ(c1.remove(0), 1);
         assert(c1 == c2);
     }
     {  // LWG issue #526
     typedef int T;
     typedef std::forward_list<T> C;
     int t1[] = {1, 2, 1, 3, 5, 8, 11};
     int t2[] = {   2,    3, 5, 8, 11};
     C c1(std::begin(t1), std::end(t1));
     C c2(std::begin(t2), std::end(t2));
-    assert(c1.remove(c1.front()) == 2);
+    ASSERT_CPP20_EQ(c1.remove(c1.front()), 2);
     assert(c1 == c2);
     }
     {
     typedef S T;
     typedef std::forward_list<T> C;
     int t1[] = {1, 2, 1, 3, 5, 8, 11, 1};
     int t2[] = {   2,    3, 5, 8, 11   };
     C c;
     for(int *ip = std::end(t1); ip != std::begin(t1);)
         c.push_front(S(*--ip));
-    assert(c.remove(c.front()) == 3);
+    ASSERT_CPP20_EQ(c.remove(c.front()), 3);
     C::const_iterator it = c.begin();
     for(int *ip = std::begin(t2); ip != std::end(t2); ++ip, ++it) {
         assert ( it != c.end());
         assert ( *ip == it->get());
         }
     assert ( it == c.end ());
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 4);
+        ASSERT_CPP20_EQ(c1.remove(0), 4);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
-        assert(c1.remove(0) == 4);
+        ASSERT_CPP20_EQ(c1.remove(0), 4);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 0);
+        ASSERT_CPP20_EQ(c1.remove(0), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
-        assert(c1.remove(0) == 0);
+        ASSERT_CPP20_EQ(c1.remove(0), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.remove(0) == 1);
+        ASSERT_CPP20_EQ(c1.remove(0), 1);
         assert(c1 == c2);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.pass.cpp

 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "counting_predicates.hpp"
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
 
 bool g(int i)
 {
     return i < 3;
 }
 
 struct PredLWG529 {
     PredLWG529 (int i) : i_(i) {};
int main(int, char**)
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 4);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 4);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 4);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 4);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 0);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 0);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 0);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 0);
         assert(c1 == c2);
         assert(cp.count() == 0);
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 1);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 1);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 
     { // LWG issue #526
     int a1[] = {1, 2, 1, 3, 5, 8, 11};
     int a2[] = {   2,    3, 5, 8, 11};
     std::forward_list<PredLWG529> c(a1, a1 + 7);
#if TEST_STD_VER >= 11
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 4);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 4);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 4);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 4);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 0);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 0);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 0);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 0);
         assert(c1 == c2);
         assert(cp.count() == 0);
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
-        assert(c1.remove_if(std::ref(cp)) == 1);
+        ASSERT_CPP20_EQ(c1.remove_if(std::ref(cp)), 1);
         assert(c1 == c2);
         assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/unique.pass.cpp

 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
+
 int main(int, char**)
 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {0, 5, 0, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 3);
+        ASSERT_CPP20_EQ(c1.unique(), 3);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 0, 0, 0};
         const T t2[] = {0};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 3);
+        ASSERT_CPP20_EQ(c1.unique(), 3);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 2);
+        ASSERT_CPP20_EQ(c1.unique(), 2); 
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
-        assert(c1.unique() == 0);
+        ASSERT_CPP20_EQ(c1.unique(), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 2);
+        ASSERT_CPP20_EQ(c1.unique(), 2);
         assert(c1 == c2);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {0, 5, 0, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 3);
+        ASSERT_CPP20_EQ(c1.unique(), 3);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 0, 0, 0};
         const T t2[] = {0};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 3);
+        ASSERT_CPP20_EQ(c1.unique(), 3);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 2);
+        ASSERT_CPP20_EQ(c1.unique(), 2);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
-        assert(c1.unique() == 0);
+        ASSERT_CPP20_EQ(c1.unique(), 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
-        assert(c1.unique() == 2);
+        ASSERT_CPP20_EQ(c1.unique(), 2);
         assert(c1 == c2);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.ops/remove.pass.cpp

 // void remove(const value_type& value);
 
 #include <list>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
+
 struct S {
   S(int i) : i_(new int(i)) {}
   S(const S &rhs) : i_(new int(*rhs.i_)) {}
   S &operator=(const S &rhs) {
     *i_ = *rhs.i_;
     return *this;
   }
   ~S() {
     delete i_;
     i_ = NULL;
   }
   bool operator==(const S &rhs) const { return *i_ == *rhs.i_; }
   int get() const { return *i_; }
   int *i_;
 };
 
 int main(int, char**) {
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     std::list<int> c(a1, a1 + 4);
-    assert(c.remove(3) == 1);
+    ASSERT_CPP20_EQ(c.remove(3), 1);
     assert(c == std::list<int>(a2, a2 + 3));
   }
   { // LWG issue #526
     int a1[] = {1, 2, 1, 3, 5, 8, 11};
     int a2[] = {2, 3, 5, 8, 11};
     std::list<int> c(a1, a1 + 7);
     c.remove(c.front());
     assert(c == std::list<int>(a2, a2 + 5));
   }
   {
     int a1[] = {1, 2, 1, 3, 5, 8, 11, 1};
     int a2[] = {2, 3, 5, 8, 11};
     std::list<S> c;
     for (int *ip = a1; ip < a1 + 8; ++ip)
       c.push_back(S(*ip));
-    assert(c.remove(c.front()) == 3);
+    ASSERT_CPP20_EQ(c.remove(c.front()), 3);
     std::list<S>::const_iterator it = c.begin();
     for (int *ip = a2; ip < a2 + 5; ++ip, ++it) {
       assert(it != c.end());
       assert(*ip == it->get());
     }
     assert(it == c.end());
   }
   {
     typedef no_default_allocator<int> Alloc;
     typedef std::list<int, Alloc> List;
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     List c(a1, a1 + 4, Alloc::create());
-      assert(c.remove(3) == 1);
+    ASSERT_CPP20_EQ(c.remove(3), 1);
     assert(c == List(a2, a2 + 3, Alloc::create()));
   }
 #if TEST_STD_VER >= 11
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     std::list<int, min_allocator<int>> c(a1, a1 + 4);
-    assert(c.remove(3) == 1);
+    ASSERT_CPP20_EQ(c.remove(3), 1);
     assert((c == std::list<int, min_allocator<int>>(a2, a2 + 3)));
   }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp

 #include <list>
 #include <cassert>
 #include <functional>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "counting_predicates.hpp"
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
+
 bool even(int i)
 {
     return i % 2 == 0;
 }
 
 bool g(int i)
 {
     return i < 3;

 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
     std::list<int> c(a1, a1+4);
     Predicate cp(g);
-    assert(c.remove_if(std::ref(cp)) == 2);
+    ASSERT_CPP20_EQ(c.remove_if(std::ref(cp)), 2);
     assert(c == std::list<int>(a2, a2+2));
     assert(cp.count() == 4);
     }
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 3};
     std::list<int> c(a1, a1+4);
     Predicate cp(even);
-    assert(c.remove_if(std::ref(cp)) == 2);
+    ASSERT_CPP20_EQ(c.remove_if(std::ref(cp)), 2);
     assert(c == std::list<int>(a2, a2+2));
     assert(cp.count() == 4);
     }
     { // LWG issue #526
     int a1[] = {1, 2, 1, 3, 5, 8, 11};
     int a2[] = {2, 3, 5, 8, 11};
     std::list<PredLWG529> c(a1, a1 + 7);
     c.remove_if(std::ref(c.front()));
     assert(c.size() == 5);
     for (size_t i = 0; i < c.size(); ++i)
     {
         assert(c.front() == a2[i]);
         c.pop_front();
     }
     }
 
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
     std::list<int, min_allocator<int>> c(a1, a1+4);
     Predicate cp(g);
-    assert(c.remove_if(std::ref(cp)) == 2);
+    ASSERT_CPP20_EQ(c.remove_if(std::ref(cp)), 2);
     assert((c == std::list<int, min_allocator<int>>(a2, a2+2)));
     assert(cp.count() == 4);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.ops/unique.pass.cpp

 // void unique();
 
 #include <list>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
+#if TEST_STD_VER > 17
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        assert((expr) == num_del);
+#else
+  #define ASSERT_CPP20_EQ(expr, num_del) \
+        expr;
+#endif
+
 int main(int, char**)
 {
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     std::list<int> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
-    assert(c.unique() == 5);
+    ASSERT_CPP20_EQ(c.unique(), 5);
     assert(c == std::list<int>(a2, a2+4));
     }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
     int a2[] = {2, 1, 4, 3};
     std::list<int, min_allocator<int>> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
-    assert(c.unique() == 5);
+    ASSERT_CPP20_EQ(c.unique(), 5);
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
 
   return 0;
 }