Erase-Like Algorithms Should Return size_type (P0646R1)

[zoecarver]

Summary

This patch changes the return type of "Erase-Like Algorithms" to size_type and updates tests accordingly.

For reference P0646R1.

[zoecarver]

Ping :)

[mclow.lists]

You're going to have to find a different approach here.
Traversing the list to see how the size has changed is not acceptable.

include/forward_list

1535

This is an expensive operation, it requires traversing the list.
And you're doing it twice - once at the beginning, and once at the end.

include/list

2158

Just call __deleted_notes.size() It has constant complexity.

[zoecarver]

include/forward_list

1535

I have updated them all to use unsigned integers. Should be much faster.

include/list

2158

Good call, thanks.

[zoecarver]

Improve performance by using simple counters.

[zoecarver]

test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

16 ↗

(On Diff #193722)

These showed up when I pulled from master. I am happy to get rid of them if needed.

[mclow.lists]

include/forward_list

1535

You're missing the point. It's not the signed/unsignedness that is expensive; it's the traversal. This algorithm goes from the start of the list to the end, looking for things to delete. On a 100,000 element list, (say) that takes time. But it has to do that, because otherwise how will it know which items to delete?

But with your change, it would have to traverse that list three times. That's wrong.

Instead you need to "get inside" the loop, and count the items that are being erased as they are being erased.

This is specific to forward_list, because all the other containers have constant-time implementations of size().

include/list

2166

size() is constant time.
distance(begin(), end()) is linear.

2198

Same here. Use size().

[mclow.lists]

Ok, so your update and my comments passed in flight. I'll try again :-)

include/list

2166

same as L2203. Just use size()

2198

You don't have to do this work for list, because it has a constant-time size() member.

Just call size() at the start, and again at the end, and return the difference.

[mclow.lists]

A meta-question:
Why does list<_Tp, _Alloc>::remove(const value_type& __x) gather all the deleted nodes into a separate list, while
list<_Tp, _Alloc>::remove_if(_Pred __pred) and list<_Tp, _Alloc>::unique() just delete them as they go?

they're all the same operation under the hood.
[ I know you didn't create this difference. ]

[mclow.lists]

In D58332#1455053, @mclow.lists wrote:

A meta-question:
Why does list<_Tp, _Alloc>::remove(const value_type& __x) gather all the deleted nodes into a separate list, while
list<_Tp, _Alloc>::remove_if(_Pred __pred) and list<_Tp, _Alloc>::unique() just delete them as they go?

they're all the same operation under the hood.
[ I know you didn't create this difference. ]

And the reason is:
The value_type &x passed into remove might refer to an item in the list itself, and if we destroy the elements as we go, we will destroy the value that we're comparing against. This is not the case for unique, but it could be the case for remove_if (imagine a list of predicates, and calling remove_if passing one of the predicates in the list). I'll fix this up later.
Reference: SVN commit 215210

[zoecarver]

In D58332#1455053, @mclow.lists wrote:

A meta-question:
Why does list<_Tp, _Alloc>::remove(const value_type& __x) gather all the deleted nodes into a separate list, while
list<_Tp, _Alloc>::remove_if(_Pred __pred) and list<_Tp, _Alloc>::unique() just delete them as they go?

they're all the same operation under the hood.
[ I know you didn't create this difference. ]

Actually very happy you asked about this, I meant to ask the same thing but forgot.

include/list

2166

Forgot size was a member... will do.

[zoecarver]

Use size() member in std::list.

[mclow.lists]

Committed a modified version as revision 364840 (since I changed the implementation of forward_list::remove_if, etc)

[miyuki]

Shouldn't the type change be guarded with a conditional compilation construct? I could write

std::list<int> l
assert(typeid(void) == typeid(l.unique()));

and expect this assertion to pass when compiling with, say, -std=c++98.

[mclow.lists]

In D58332#1571535, @miyuki wrote:

Shouldn't the type change be guarded with a conditional compilation construct? I could write

std::list<int> l
assert(typeid(void) == typeid(l.unique()));

and expect this assertion to pass when compiling with, say, -std=c++98.

Yes, it should. I'll fix it. Thanks!

[mclow.lists]

Fixed list in revision 365261

[mclow.lists]

Fixed forward_list in revision 365290

include/forward_list

#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void splice_after(const_iterator __p, forward_list&& __x,
                       const_iterator __f, const_iterator __l);
 #endif  // _LIBCPP_CXX03_LANG
     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);
-    void remove(const value_type& __v);
-    template <class _Predicate> void remove_if(_Predicate __pred);
+    size_type remove(const value_type& __v);
+    template <class _Predicate> size_type remove_if(_Predicate __pred);
     _LIBCPP_INLINE_VISIBILITY
-    void unique() {unique(__equal_to<value_type>());}
-    template <class _BinaryPredicate> void unique(_BinaryPredicate __binary_pred);
+    size_type unique() {return unique(__equal_to<value_type>());}
+    template <class _BinaryPredicate> size_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,
                                         const_iterator __f, const_iterator __l)
 {
     splice_after(__p, __x, __f, __l);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-void
+typename forward_list<_Tp, _Alloc>::size_type
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes; // collect the nodes we're removing
     iterator __e = end();
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__i.__get_begin()->__next_->__value_ == __v)
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
                 ;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
+    
+    return _VSTD::distance(__deleted_nodes.begin(), __deleted_nodes.end());
 }
 
 template <class _Tp, class _Alloc>
 template <class _Predicate>
-void
+typename forward_list<_Tp, _Alloc>::size_type
 forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
 {
     iterator __e = end();
+    auto __start_count = _VSTD::distance(begin(), end());
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__pred(__i.__get_begin()->__next_->__value_))
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             erase_after(__i, __j);
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
+    
+    return __start_count - _VSTD::distance(begin(), end());
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPredicate>
-void
+typename forward_list<_Tp, _Alloc>::size_type
 forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
+    auto __start_count = _VSTD::distance(begin(), end());
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
         if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
             erase_after(__i, __j);
         __i = __j;
     }
+    
+    return __start_count - _VSTD::distance(begin(), end());;
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
 void
 forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
 {
     if (this != &__x)

include/list

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);
 
-    void remove(const value_type& __x);
-    template <class _Pred> void remove_if(_Pred __pred);
+    size_type remove(const value_type& __x);
+    template <class _Pred> size_type remove_if(_Pred __pred);
     _LIBCPP_INLINE_VISIBILITY
-    void unique();
+    size_type unique();
     template <class _BinaryPred>
-        void unique(_BinaryPred __binary_pred);
+        size_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>
-void
+typename list<_Tp, _Alloc>::size_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;
     }
+    
+    return _VSTD::distance(__deleted_nodes.begin(), __deleted_nodes.end());
 }
 
 template <class _Tp, class _Alloc>
 template <class _Pred>
-void
+typename list<_Tp, _Alloc>::size_type
 list<_Tp, _Alloc>::remove_if(_Pred __pred)
 {
+    auto __start_count = _VSTD::distance(begin(), end());
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         if (__pred(*__i))
         {
             iterator __j = _VSTD::next(__i);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             __i = erase(__i, __j);
             if (__i != __e)
                 ++__i;
         }
         else
             ++__i;
     }
+    
+    return __start_count - _VSTD::distance(begin(), end());
 }
 
 template <class _Tp, class _Alloc>
 inline
-void
+typename list<_Tp, _Alloc>::size_type
 list<_Tp, _Alloc>::unique()
 {
-    unique(__equal_to<value_type>());
+    return unique(__equal_to<value_type>());
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPred>
-void
+typename list<_Tp, _Alloc>::size_type
 list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 {
+    auto __start_count = _VSTD::distance(begin(), end());
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
         iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
         if (++__i != __j)
             __i = erase(__i, __j);
     }
+    
+    return __start_count - _VSTD::distance(begin(), end());
 }
 
 template <class _Tp, class _Alloc>
 inline
 void
 list<_Tp, _Alloc>::merge(list& __c)
 {
     merge(__c, __less<value_type>());

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

 {
     {
         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));
-        c1.remove(0);
+        assert(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;
-        c1.remove(0);
+        assert(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));
-        c1.remove(0);
+        assert(c1.remove(0) == 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
-        c1.remove(0);
+        assert(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));
-        c1.remove(0);
+        assert(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));
-    c1.remove(c1.front());
+    assert(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));
-    c.remove(c.front());
+    assert(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));
-        c1.remove(0);
+        assert(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;
-        c1.remove(0);
+        assert(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));
-        c1.remove(0);
+        assert(c1.remove(0) == 0);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
-        c1.remove(0);
+        assert(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));
-        c1.remove(0);
+        assert(c1.remove(0) == 1);
         assert(c1 == c2);
     }
 #endif
 
   return 0;
 }

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

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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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))));
     }
 #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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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);
-        c1.remove_if(std::ref(cp));
+        assert(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;
 }

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

 {
     {
         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));
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(c1.unique() == 2);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(c1.unique() == 2);
         assert(c1 == c2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
-        c1.unique();
+        assert(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));
-        c1.unique();
+        assert(c1.unique() == 2);
         assert(c1 == c2);
     }
 #endif
 
   return 0;
 }

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

struct S {
   int *i_;
 };
 
 int main(int, char**) {
   {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {1, 2, 4};
     std::list<int> c(a1, a1 + 4);
-    c.remove(3);
+    assert(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));
-    c.remove(c.front());
+    assert(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());
-    c.remove(3);
+      assert(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);
-    c.remove(3);
+    assert(c.remove(3) == 1);
     assert((c == std::list<int, min_allocator<int>>(a2, a2 + 3)));
   }
 #endif
 
   return 0;
 }

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

 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3, 4};
     int a2[] = {3, 4};
     std::list<int> c(a1, a1+4);
     Predicate cp(g);
-    c.remove_if(std::ref(cp));
+    assert(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);
-    c.remove_if(std::ref(cp));
+    assert(c.remove_if(std::ref(cp)) == 2);
     assert(c == std::list<int>(a2, a2+2));
     assert(cp.count() == 4);
     }
 #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);
-    c.remove_if(std::ref(cp));
+    assert(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;
 }

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

 #include "min_allocator.h"
 
 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]));
-    c.unique();
+    assert(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]));
-    c.unique();
+    assert(c.unique() == 5);
     assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
     }
 #endif
 
   return 0;
 }