[libcxx] [test] Fix Container::insert(value_type const&) tests

[jloser]

Summary

[libcxx] [test] Fix Container::insert(value_type const&) tests

Several unit tests meaning to test the behavior of lvalue insertion incorrectly pass rvalues. Fixes bug PR # 27394

[EricWF]

Have you verified that we're not losing test coverage here? That is, are you sure we still have tests for the rvalue overloads in other test files?

libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp

41

Should be v3?

[jloser]

Use v3 rather than an rvalue of 3 in libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp

[EricWF]

LGTM. Thanks!

[EricWF]

Committed as r329541.

[jloser]

In D44411#1056374, @EricWF wrote:

Have you verified that we're not losing test coverage here? That is, are you sure we still have tests for the rvalue overloads in other test files?

Yep. These containers already have tests for inserts with rvalues. No loss in test coverage here.

libcxx/test/std/containers/associative/multiset/insert_cv.pass.cpp

 
 // iterator insert(const value_type& v);
 
 #include <set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::multiset<int> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(*r == 2);
+template<class Container>
+void do_insert_cv_test()
+    typedef Container M;
+    typedef typename M::iterator R;
+    typedef typename M::value_type VT;
+    const VT v1(2);
+    R r = m.insert(v1);
 
-        r = m.insert(M::value_type(1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(*r == 1);
+    const VT v2(1);
+    r = m.insert(v2);
 
-        r = m.insert(M::value_type(3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r == 3);
+    const VT v3(3);
+    r = m.insert(v3);
 
-        r = m.insert(M::value_type(3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(*r == 3);
-    }
+    r = m.insert(v3);
+
+int main()
+{
+    do_insert_cv_test<std::multiset<int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
-        typedef M::iterator R;
-        M m;
-        R r = m.insert(M::value_type(2));
-        assert(r == m.begin());
-        assert(m.size() == 1);
-        assert(*r == 2);
-
-        r = m.insert(M::value_type(1));
-        assert(r == m.begin());
-        assert(m.size() == 2);
-        assert(*r == 1);
-
-        r = m.insert(M::value_type(3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r == 3);
-
-        r = m.insert(M::value_type(3));
-        assert(r == prev(m.end()));
-        assert(m.size() == 4);
-        assert(*r == 3);
+        do_insert_cv_test<M>();
     }
 #endif
 }

libcxx/test/std/containers/associative/set/insert_cv.pass.cpp

 
 // pair<iterator, bool> insert(const value_type& v);
 
 #include <set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::set<int> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(*r.first == 2);
+template<class Container>
+void do_insert_cv_test()
+    typedef Container M;
+    typedef std::pair<typename M::iterator, bool> R;
+    typedef typename M::value_type VT;
+
+    const VT v1(2);
+    R r = m.insert(v1);
 
-        r = m.insert(M::value_type(1));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(*r.first == 1);
+    const VT v2(1);
+    r = m.insert(v2);
 
-        r = m.insert(M::value_type(3));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r.first == 3);
+    const VT v3(3);
+    r = m.insert(v3);
 
-        r = m.insert(M::value_type(3));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r.first == 3);
-    }
+    r = m.insert(v3);
+
+int main()
+{
+    do_insert_cv_test<std::set<int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::set<int, std::less<int>, min_allocator<int>> M;
-        typedef std::pair<M::iterator, bool> R;
-        M m;
-        R r = m.insert(M::value_type(2));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 1);
-        assert(*r.first == 2);
-
-        r = m.insert(M::value_type(1));
-        assert(r.second);
-        assert(r.first == m.begin());
-        assert(m.size() == 2);
-        assert(*r.first == 1);
-
-        r = m.insert(M::value_type(3));
-        assert(r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r.first == 3);
-
-        r = m.insert(M::value_type(3));
-        assert(!r.second);
-        assert(r.first == prev(m.end()));
-        assert(m.size() == 3);
-        assert(*r.first == 3);
+        do_insert_cv_test<M>();
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_const_lvalue.pass.cpp

void do_insert_cv_test()
 
     const VT v1(2.5, 2);
     R r = m.insert(v1);
     assert(r.second);
     assert(m.size() == 1);
     assert(r.first->first == 2.5);
     assert(r.first->second == 2);
 
-    r = m.insert(VT(2.5, 3)); // test rvalue insertion works in C++03
+    const VT v2(2.5, 3);
+    r = m.insert(v2);
     assert(!r.second);
     assert(m.size() == 1);
     assert(r.first->first == 2.5);
     assert(r.first->second == 2);
 
-    const VT v2(1.5, 1);
-    r = m.insert(v2);
+    const VT v3(1.5, 1);
+    r = m.insert(v3);
     assert(r.second);
     assert(m.size() == 2);
     assert(r.first->first == 1.5);
     assert(r.first->second == 1);
 
-    const VT v3(3.5, 3);
-    r = m.insert(v3);
+    const VT v4(3.5, 3);
+    r = m.insert(v4);
     assert(r.second);
     assert(m.size() == 3);
     assert(r.first->first == 3.5);
     assert(r.first->second == 3);
 
-    const VT v4(3.5, 4);
-    r = m.insert(v4);
+    const VT v5(3.5, 4);
+    r = m.insert(v5);
     assert(!r.second);
     assert(m.size() == 3);
     assert(r.first->first == 3.5);
     assert(r.first->second == 3);
 }
 
 int main()
 {

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <unordered_map>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_map<double, int> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
+template<class Container>
+void do_insert_hint_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    typename C::const_iterator e = c.end();
+    const VT v1(3.5, 3);
+    R r = c.insert(e, v1);
 
-        r = c.insert(c.end(), P(3.5, 4));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
+    const VT v2(3.5, 4);
+    r = c.insert(c.end(), v2);
 
-        r = c.insert(c.end(), P(4.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
+    const VT v3(4.5, 4);
+    r = c.insert(c.end(), v3);
 
-        r = c.insert(c.end(), P(5.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
-    }
+    const VT v4(5.5, 4);
+    r = c.insert(c.end(), v4);
+
+int main()
+{
+    do_insert_hint_const_lvalue_test<std::unordered_map<double, int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
-
-        r = c.insert(c.end(), P(3.5, 4));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
-
-        r = c.insert(c.end(), P(4.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
 
-        r = c.insert(c.end(), P(5.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
+        do_insert_hint_const_lvalue_test<C>();
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_map<double, int> C;
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C c2;
         C::const_iterator e = c2.end();
         P v(3.5, 3);
         R r = c.insert(e, v);
         assert(false);
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_const_lvalue.pass.cpp

 
 // iterator insert(const value_type& x);
 
 #include <unordered_map>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_multimap<double, int> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
+template<class Container>
+void do_insert_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    const VT v1(3.5, 3);
+    R r = c.insert(v1);
 
-        r = c.insert(P(3.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 3.5);
-        assert(r->second == 4);
+    const VT v2(3.5, 4);
+    r = c.insert(v2);
 
-        r = c.insert(P(4.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
+    const VT v3(4.5, 4);
+    r = c.insert(v3);
 
-        r = c.insert(P(5.5, 4));
-        assert(c.size() == 4);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
-    }
+    const VT v4(5.5, 4);
+    r = c.insert(v4);
+
+int main()
+{
+    do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
-
-        r = c.insert(P(3.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 3.5);
-        assert(r->second == 4);
-
-        r = c.insert(P(4.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
-
-        r = c.insert(P(5.5, 4));
-        assert(c.size() == 4);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
+        do_insert_const_lvalue_test<C>();
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <unordered_map>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_multimap<double, int> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
+template<class Container>
+void do_insert_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    typename C::const_iterator e = c.end();
+    const VT v1(3.5, 3);
+    R r = c.insert(e, v1);
 
-        r = c.insert(c.end(), P(3.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 3.5);
-        assert(r->second == 4);
+    const VT v2(3.5, 4);
+    r = c.insert(c.end(), v2);
 
-        r = c.insert(c.end(), P(4.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
+    const VT v3(4.5, 4);
+    r = c.insert(c.end(), v3);
 
-        r = c.insert(c.end(), P(5.5, 4));
-        assert(c.size() == 4);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
-    }
+    const VT v4(5.5, 4);
+    r = c.insert(c.end(), v4);
+
+int main()
+{
+    do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
-        assert(c.size() == 1);
-        assert(r->first == 3.5);
-        assert(r->second == 3);
-
-        r = c.insert(c.end(), P(3.5, 4));
-        assert(c.size() == 2);
-        assert(r->first == 3.5);
-        assert(r->second == 4);
-
-        r = c.insert(c.end(), P(4.5, 4));
-        assert(c.size() == 3);
-        assert(r->first == 4.5);
-        assert(r->second == 4);
-
-        r = c.insert(c.end(), P(5.5, 4));
-        assert(c.size() == 4);
-        assert(r->first == 5.5);
-        assert(r->second == 4);
+        do_insert_const_lvalue_test<C>();
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_multimap<double, int> C;
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C c2;
         C::const_iterator e = c2.end();
         P v(3.5, 3);
         R r = c.insert(e, v);
         assert(false);
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.multiset/insert_const_lvalue.pass.cpp

 
 // iterator insert(const value_type& x);
 
 #include <unordered_set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_multiset<double> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
+template<class Container>
+void do_insert_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    const VT v1(3.5);
+    R r = c.insert(v1);
 
-        r = c.insert(P(3.5));
-        assert(c.size() == 2);
-        assert(*r == 3.5);
+    r = c.insert(v1);
 
-        r = c.insert(P(4.5));
-        assert(c.size() == 3);
-        assert(*r == 4.5);
+    const VT v2(4.5);
+    r = c.insert(v2);
 
-        r = c.insert(P(5.5));
-        assert(c.size() == 4);
-        assert(*r == 5.5);
-    }
+    const VT v3(5.5);
+    r = c.insert(v3);
+
+int main()
+{
+    do_insert_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
-                                std::equal_to<double>, min_allocator<double>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
-
-        r = c.insert(P(3.5));
-        assert(c.size() == 2);
-        assert(*r == 3.5);
-
-        r = c.insert(P(4.5));
-        assert(c.size() == 3);
-        assert(*r == 4.5);
-
-        r = c.insert(P(5.5));
-        assert(c.size() == 4);
-        assert(*r == 5.5);
+        do_insert_const_lvalue_test<C>();
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <unordered_set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_multiset<double> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
+template<class Container>
+void do_insert_hint_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    typename C::const_iterator e = c.end();
+    const VT v1(3.5);
+    R r = c.insert(e, v1);
 
-        r = c.insert(c.end(), P(3.5));
-        assert(c.size() == 2);
-        assert(*r == 3.5);
+    r = c.insert(c.end(), v1);
 
-        r = c.insert(c.end(), P(4.5));
-        assert(c.size() == 3);
-        assert(*r == 4.5);
+    const VT v2(4.5);
+    r = c.insert(c.end(), v2);
 
-        r = c.insert(c.end(), P(5.5));
-        assert(c.size() == 4);
-        assert(*r == 5.5);
-    }
+    const VT v3(5.5);
+    r = c.insert(c.end(), v3);
+
+int main()
+{
+    do_insert_hint_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
-                                std::equal_to<double>, min_allocator<double>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
-
-        r = c.insert(c.end(), P(3.5));
-        assert(c.size() == 2);
-        assert(*r == 3.5);
-
-        r = c.insert(c.end(), P(4.5));
-        assert(c.size() == 3);
-        assert(*r == 4.5);
-
-        r = c.insert(c.end(), P(5.5));
-        assert(c.size() == 4);
-        assert(*r == 5.5);
+        do_insert_hint_const_lvalue_test<C>();
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_multiset<double> C;
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C c2;
         C::const_iterator e = c2.end();
         P v(3.5);
         R r = c.insert(e, v);
         assert(false);
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.set/insert_const_lvalue.pass.cpp

 
 // pair<iterator, bool> insert(const value_type& x);
 
 #include <unordered_set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_set<double> C;
-        typedef std::pair<C::iterator, bool> R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r.first == 3.5);
-        assert(r.second);
+template<class Container>
+void do_insert_const_lvalue_test()
+    typedef Container C;
+    typedef std::pair<typename C::iterator, bool> R;
+    typedef typename C::value_type VT;
+    const VT v1(3.5);
+    R r = c.insert(v1);
 
-        r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r.first == 3.5);
-        assert(!r.second);
+    r = c.insert(v1);
 
-        r = c.insert(P(4.5));
-        assert(c.size() == 2);
-        assert(*r.first == 4.5);
-        assert(r.second);
+    const VT v2(4.5);
+    r = c.insert(v2);
 
-        r = c.insert(P(5.5));
-        assert(c.size() == 3);
-        assert(*r.first == 5.5);
-        assert(r.second);
-    }
+    const VT v3(5.5);
+    r = c.insert(v3);
+
+int main()
+{
+    do_insert_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
-        typedef std::pair<C::iterator, bool> R;
-        typedef C::value_type P;
-        C c;
-        R r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r.first == 3.5);
-        assert(r.second);
-
-        r = c.insert(P(3.5));
-        assert(c.size() == 1);
-        assert(*r.first == 3.5);
-        assert(!r.second);
-
-        r = c.insert(P(4.5));
-        assert(c.size() == 2);
-        assert(*r.first == 4.5);
-        assert(r.second);
-
-        r = c.insert(P(5.5));
-        assert(c.size() == 3);
-        assert(*r.first == 5.5);
-        assert(r.second);
+        do_insert_const_lvalue_test<C>();
     }
 #endif
 }

libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp

 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <unordered_set>
 #include <cassert>
 
 #include "min_allocator.h"
 
-int main()
-{
-    {
-        typedef std::unordered_set<double> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
+template<class Container>
+void do_insert_hint_const_lvalue_test()
+    typedef Container C;
+    typedef typename C::iterator R;
+    typedef typename C::value_type VT;
+    typename C::const_iterator e = c.end();
+    const VT v1(3.5);
+    R r = c.insert(e, v1);
 
-        r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
+    r = c.insert(e, v1);
 
-        r = c.insert(e, P(4.5));
-        assert(c.size() == 2);
-        assert(*r == 4.5);
+    const VT v2(4.5);
+    r = c.insert(e, v2);
 
-        r = c.insert(e, P(5.5));
-        assert(c.size() == 3);
-        assert(*r == 5.5);
-    }
+    const VT v3(5.5);
+    r = c.insert(e, v3);
+
+int main()
+{
+    do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
-
-        r = c.insert(e, P(3.5));
-        assert(c.size() == 1);
-        assert(*r == 3.5);
-
-        r = c.insert(e, P(4.5));
-        assert(c.size() == 2);
-        assert(*r == 4.5);
-
-        r = c.insert(e, P(5.5));
-        assert(c.size() == 3);
-        assert(*r == 5.5);
+        do_insert_hint_const_lvalue_test<C>();
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_set<double> C;
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C c2;
         C::const_iterator e = c2.end();
         P v(3.5);
         R r = c.insert(e, v);
         assert(false);
     }
 #endif
 }