[libc++] [test] Qualify `distance` as `std::distance` in a lot of tests. NFCI.

[• Quuxplusone]

Summary

We shouldn't be calling distance via ADL -- and neither should anybody in the wild be calling it via ADL, so it's not like we need to test this ADL ability of distance in particular.

This and D119677 + D119687 came out of my running the tests with a modified version of D119670 to look for all the places we call std:: functions unqualified. I claim that almost every time we do this, it's either accidental or unwise or both.

If this std::distance patch looks good to folks, then I've got similar patches lined up for

• std::next
• std::prev
• std::move
• std::getline
• std::atomic_flag_{clear,test}
• iomanip functions (std::hex, std::showpoint, et al) in std/localization/
• iomanip functions (std::hex, std::showpoint, et al) in std/input.output/iostream.format/
• using std::optional; using std::make_optional; in std/utilities/optional/
• using std::any; using std::any_cast; in std/utilities/any/ (this one is not purely mechanical, though)

where I propose to post at least the first 8 as one giant PR just to poke CI, and then land it as 8 individual commits if CI is green. @ldionne @Mordante any objections to that plan?

[ldionne]

This patch and the proposed plan SGTM, however if all the changes look basically like this (just adding std:: mechanically), I'd rather just have all the follow-ups in the same PR. It's going to be as easy to review and will create less review traffic.

[Mordante]

In D119685#3320577, @ldionne wrote:

This patch and the proposed plan SGTM, however if all the changes look basically like this (just adding std:: mechanically), I'd rather just have all the follow-ups in the same PR. It's going to be as easy to review and will create less review traffic.

+1 to what Louis said.

Thanks for the cleanup and LGTM.

libcxx/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp

m =
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                             };
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
                             {
                                 {20, 1},
                             };
     m =
                             {
                                 {1, 1},
                                 {1, 1.5},
                                 {1, 2},
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                             };
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 }
 
 
 void duplicate_keys_test() {

libcxx/test/std/containers/associative/map/map.cons/copy.pass.cpp

int main(int, char**)
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
#if TEST_STD_VER >= 11
         };
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = mo;
         assert(m.get_allocator() == A(-2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
#if TEST_STD_VER >= 11
         };
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m = mo;
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/copy_alloc.pass.cpp

int main(int, char**)
     };
     typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::map<int, double, C, A> m(mo, A(3));
     assert(m.get_allocator() == A(3));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
 
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     assert(mo.size() == 3);
-    assert(distance(mo.begin(), mo.end()) == 3);
+    assert(std::distance(mo.begin(), mo.end()) == 3);
     assert(*mo.begin() == V(1, 1));
     assert(*next(mo.begin()) == V(2, 1));
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
#if TEST_STD_VER >= 11
     };
     typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     std::map<int, double, C, A> m(mo, A());
     assert(m.get_allocator() == A());
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
 
     assert(mo.get_allocator() == A());
     assert(mo.key_comp() == C(5));
     assert(mo.size() == 3);
-    assert(distance(mo.begin(), mo.end()) == 3);
+    assert(std::distance(mo.begin(), mo.end()) == 3);
     assert(*mo.begin() == V(1, 1));
     assert(*next(mo.begin()) == V(2, 1));
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
     {
     typedef std::pair<const int, double> V;
     V ar[] =
     {
#if TEST_STD_VER >= 11
     };
     typedef test_less<int> C;
     typedef explicit_allocator<V> A;
     std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
     std::map<int, double, C, A> m(mo, A{});
     assert(m.get_allocator() == A());
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
 
     assert(mo.get_allocator() == A());
     assert(mo.key_comp() == C(5));
     assert(mo.size() == 3);
-    assert(distance(mo.begin(), mo.end()) == 3);
+    assert(std::distance(mo.begin(), mo.end()) == 3);
     assert(*mo.begin() == V(1, 1));
     assert(*next(mo.begin()) == V(2, 1));
     assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/copy_assign.pass.cpp

int main(int, char**)
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
     {
         typedef std::pair<const int, double> V;
         const V ar[] =
         {
int main(int, char**)
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::pair<const int, double> V;
         V ar[] =
#if TEST_STD_VER >= 11
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
         m = mo;
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
     {
         typedef std::pair<const int, double> V;
         V ar[] =
         {
#if TEST_STD_VER >= 11
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A());
         m = mo;
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
 
     assert(balanced_allocs());
     {
         typedef std::pair<const int, double> V;
assert(balanced_allocs());
         };
         typedef test_less<int> C;
         typedef counting_allocatorT<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(1));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(2));
         m = mo;
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
     assert(balanced_allocs());
     {
         typedef std::pair<const int, double> V;
         V ar[] =
assert(balanced_allocs());
         };
         typedef test_less<int> C;
         typedef counting_allocatorF<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(100));
         std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(200));
         m = mo;
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == V(1, 1));
         assert(*next(mo.begin()) == V(2, 1));
         assert(*next(mo.begin(), 2) == V(3, 1));
     }
     assert(balanced_allocs());
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/initializer_list.pass.cpp

std::map<int, double> m =
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                             };
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
                             {
                                 {1, 1},
                                 {1, 1.5},
                                 {1, 2},
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                             };
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare.pass.cpp

std::map<int, double, C> m({
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                                }, C(3));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     }
     {
     typedef std::pair<const int, double> V;
     typedef test_less<int> C;
     std::map<int, double, C, min_allocator<std::pair<const int, double>>> m({
                                 {1, 1},
                                 {1, 1.5},
                                 {1, 2},
                                 {2, 1},
                                 {2, 1.5},
                                 {2, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                                }, C(3));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/initializer_list_compare_alloc.pass.cpp

std::map<int, double, C, A> m({
                                    {2, 1},
                                    {2, 1.5},
                                    {2, 2},
                                    {3, 1},
                                    {3, 1.5},
                                    {3, 2}
                                   }, C(3), A(6));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == A(6));
     }
     {
     typedef std::pair<const int, double> V;
     typedef test_less<int> C;
     typedef min_allocator<std::pair<const int, double> > A;
     std::map<int, double, C, A> m({
                                    {1, 1},
                                    {1, 1.5},
                                    {1, 2},
                                    {2, 1},
                                    {2, 1.5},
                                    {2, 2},
                                    {3, 1},
                                    {3, 1.5},
                                    {3, 2}
                                   }, C(3), A());
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == A());
     }
     {
     typedef std::pair<const int, double> V;
     typedef min_allocator<V> A;
     typedef test_less<int> C;
     typedef std::map<int, double, C, A> M;
     A a;
     M m ({ {1, 1},
            {1, 1.5},
            {1, 2},
            {2, 1},
            {2, 1.5},
            {2, 2},
            {3, 1},
            {3, 1.5},
            {3, 2}
           }, a);
 
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.get_allocator() == a);
     }
     {
     typedef std::pair<const int, double> V;
     typedef explicit_allocator<V> A;
     typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m({
                                    {1, 1},
                                    {1, 1.5},
                                    {1, 2},
                                    {2, 1},
                                    {2, 1.5},
                                    {2, 2},
                                    {3, 1},
                                    {3, 1.5},
                                    {3, 2}
                                   }, C(3), a);
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.key_comp() == C(3));
     assert(m.get_allocator() == a);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/iter_iter.pass.cpp

V ar[] =
         V(2, 1.5),
         V(2, 2),
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
     {
         V(1, 1),
         V(1, 1.5),
         V(1, 2),
         V(2, 1),
         V(2, 1.5),
         V(2, 2),
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     std::map<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp.pass.cpp

V ar[] =
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     typedef test_less<int> C;
     std::map<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
     {
         V(1, 1),
         V(1, 1.5),
         V(1, 2),
         V(2, 1),
         V(2, 1.5),
         V(2, 2),
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     typedef test_less<int> C;
     std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/iter_iter_comp_alloc.pass.cpp

V ar[] =
         V(3, 2),
     };
     typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     assert(m.get_allocator() == A(7));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
V ar[] =
         V(3, 2),
     };
     typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     assert(m.get_allocator() == A());
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 #if TEST_STD_VER > 11
     {
     typedef std::pair<const int, double> V;
     V ar[] =
#if TEST_STD_VER > 11
     };
     {
     typedef min_allocator<V> A;
     typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
 
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.get_allocator() == a);
     }
     {
     typedef explicit_allocator<V> A;
     typedef test_less<int> C;
     A a;
     std::map<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a );
 
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     assert(m.get_allocator() == a);
     }
     }
 #endif
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.cons/move.pass.cpp

int main(int, char**)
     {
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(C(5), A(7));
         std::map<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
             V(2, 1.5),
             V(2, 2),
             V(3, 1),
             V(3, 1.5),
             V(3, 2),
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::map<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(C(5), A());
         std::map<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
             V(2, 1.5),
             V(2, 2),
             V(3, 1),
             V(3, 1.5),
             V(3, 2),
         };
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::map<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::map<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(2, 1));
         assert(*next(m.begin(), 2) == V(3, 1));
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/map/map.modifiers/insert_initializer_list.pass.cpp

std::map<int, double> m =
                                 {3, 2}
                             };
     m.insert({
                  {2, 1},
                  {2, 1.5},
                  {2, 2},
              });
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
     {
     typedef std::pair<const int, double> V;
     std::map<int, double, std::less<int>, min_allocator<V>> m =
                             {
                                 {1, 1},
                                 {1, 1.5},
                                 {1, 2},
                                 {3, 1},
                                 {3, 1.5},
                                 {3, 2}
                             };
     m.insert({
                  {2, 1},
                  {2, 1.5},
                  {2, 2},
              });
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/assign_initializer_list.pass.cpp

m =
                {2, 1},
                {2, 1.5},
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            };
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
m =
                {2, 1},
                {2, 1.5},
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            };
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list.pass.cpp

C m =
                {2, 1},
                {2, 1.5},
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            };
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
C m =
                {2, 1},
                {2, 1.5},
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            };
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare.pass.cpp

C m(
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            },
            Cmp(4)
         );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
C m(
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            },
            Cmp(4)
         );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     assert(m.key_comp() == Cmp(4));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/initializer_list_compare_alloc.pass.cpp

C m(
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            },
            Cmp(4), A(5)
         );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
C m(
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            },
            Cmp(4), A()
         );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
M m ({ {1, 1},
            {2, 1.5},
            {2, 2},
            {3, 1},
            {3, 1.5},
            {3, 2}
           }, a);
 
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     M::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
C m(
                {2, 2},
                {3, 1},
                {3, 1.5},
                {3, 2}
            },
            Cmp(4), A{}
         );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(1, 2));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(2, 2));
     assert(*++i == V(3, 1));
     assert(*++i == V(3, 1.5));
     assert(*++i == V(3, 2));
     assert(m.key_comp() == Cmp(4));
     assert(m.get_allocator() == A{});
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter.pass.cpp

V ar[] =
         V(2, 1.5),
         V(2, 2),
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
V ar[] =
         V(2, 1.5),
         V(2, 2),
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
V ar[] =
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     typedef min_allocator<std::pair<const int, double>> A;
     A a;
     std::multimap<int, double, std::less<int>, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     assert(m.get_allocator() == a);
     }
 #endif
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp.pass.cpp

V ar[] =
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     typedef test_less<int> C;
     std::multimap<int, double, C> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
V ar[] =
         V(3, 1),
         V(3, 1.5),
         V(3, 2),
     };
     typedef test_less<int> C;
     std::multimap<int, double, C, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/iter_iter_comp_alloc.pass.cpp

V ar[] =
         V(3, 2),
     };
     typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     assert(m.get_allocator() == A(7));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
V ar[] =
         V(3, 2),
     };
     typedef test_less<int> C;
     typedef min_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
     assert(m.get_allocator() == A());
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
V ar[] =
         V(3, 2),
     };
     typedef test_less<int> C;
     typedef explicit_allocator<V> A;
     std::multimap<int, double, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A{});
     assert(m.get_allocator() == A{});
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*m.begin() == V(1, 1));
     assert(*next(m.begin()) == V(1, 1.5));
     assert(*next(m.begin(), 2) == V(1, 2));
     assert(*next(m.begin(), 3) == V(2, 1));
     assert(*next(m.begin(), 4) == V(2, 1.5));
     assert(*next(m.begin(), 5) == V(2, 2));
     assert(*next(m.begin(), 6) == V(3, 1));
     assert(*next(m.begin(), 7) == V(3, 1.5));
     assert(*next(m.begin(), 8) == V(3, 2));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.cons/move.pass.cpp

int main(int, char**)
     {
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(C(5), A(7));
         std::multimap<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
             V(2, 1.5),
             V(2, 2),
             V(3, 1),
             V(3, 1.5),
             V(3, 2),
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multimap<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(1, 1.5));
         assert(*next(m.begin(), 2) == V(1, 2));
         assert(*next(m.begin(), 3) == V(2, 1));
         assert(*next(m.begin(), 4) == V(2, 1.5));
         assert(*next(m.begin(), 5) == V(2, 2));
         assert(*next(m.begin(), 6) == V(3, 1));
         assert(*next(m.begin(), 7) == V(3, 1.5));
         assert(*next(m.begin(), 8) == V(3, 2));
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(C(5), A());
         std::multimap<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         V ar[] =
         {
             V(1, 1),
             V(1, 1.5),
             V(1, 2),
             V(2, 1),
             V(2, 1.5),
             V(2, 2),
             V(3, 1),
             V(3, 1.5),
             V(3, 2),
         };
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multimap<int, double, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multimap<int, double, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*m.begin() == V(1, 1));
         assert(*next(m.begin()) == V(1, 1.5));
         assert(*next(m.begin(), 2) == V(1, 2));
         assert(*next(m.begin(), 3) == V(2, 1));
         assert(*next(m.begin(), 4) == V(2, 1.5));
         assert(*next(m.begin(), 5) == V(2, 2));
         assert(*next(m.begin(), 6) == V(3, 1));
         assert(*next(m.begin(), 7) == V(3, 1.5));
         assert(*next(m.begin(), 8) == V(3, 2));
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_initializer_list.pass.cpp

int main(int, char**)
     m.insert(
                {
                    {1, 1.5},
                    {2, 1.5},
                    {3, 1.5},
                }
             );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 2));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 2));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(3, 1));
int main(int, char**)
     m.insert(
                {
                    {1, 1.5},
                    {2, 1.5},
                    {3, 1.5},
                }
             );
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1, 1));
     assert(*++i == V(1, 2));
     assert(*++i == V(1, 1.5));
     assert(*++i == V(2, 1));
     assert(*++i == V(2, 2));
     assert(*++i == V(2, 1.5));
     assert(*++i == V(3, 1));
     assert(*++i == V(3, 2));
     assert(*++i == V(3, 1.5));
     }
 
   return 0;
 }

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

 int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
+    assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
+    assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/assign_initializer_list.pass.cpp

 int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {10, 8};
     m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/copy.pass.cpp

int main(int, char**)
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 9);
-        assert(distance(mo.begin(), mo.end()) == 9);
+        assert(std::distance(mo.begin(), mo.end()) == 9);
         assert(*next(mo.begin(), 0) == 1);
         assert(*next(mo.begin(), 1) == 1);
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
#if TEST_STD_VER >= 11
         };
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = mo;
         assert(m.get_allocator() == A(-2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 9);
-        assert(distance(mo.begin(), mo.end()) == 9);
+        assert(std::distance(mo.begin(), mo.end()) == 9);
         assert(*next(mo.begin(), 0) == 1);
         assert(*next(mo.begin(), 1) == 1);
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/copy_alloc.pass.cpp

int main(int, char**)
     };
     typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::multiset<int, C, A> m(mo, A(3));
     assert(m.get_allocator() == A(3));
     assert(m.key_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
 
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     assert(mo.size() == 9);
-    assert(distance(mo.begin(), mo.end()) == 9);
+    assert(std::distance(mo.begin(), mo.end()) == 9);
     assert(*next(mo.begin(), 0) == 1);
     assert(*next(mo.begin(), 1) == 1);
     assert(*next(mo.begin(), 2) == 1);
     assert(*next(mo.begin(), 3) == 2);
     assert(*next(mo.begin(), 4) == 2);
     assert(*next(mo.begin(), 5) == 2);
     assert(*next(mo.begin(), 6) == 3);
     assert(*next(mo.begin(), 7) == 3);
     assert(*next(mo.begin(), 8) == 3);
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/copy_assign.pass.cpp

int main(int, char**)
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 9);
-        assert(distance(mo.begin(), mo.end()) == 9);
+        assert(std::distance(mo.begin(), mo.end()) == 9);
         assert(*next(mo.begin(), 0) == 1);
         assert(*next(mo.begin(), 1) == 1);
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
int main(int, char**)
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::multiset<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 9);
-        assert(distance(mo.begin(), mo.end()) == 9);
+        assert(std::distance(mo.begin(), mo.end()) == 9);
         assert(*next(mo.begin(), 0) == 1);
         assert(*next(mo.begin(), 1) == 1);
         assert(*next(mo.begin(), 2) == 1);
         assert(*next(mo.begin(), 3) == 2);
         assert(*next(mo.begin(), 4) == 2);
         assert(*next(mo.begin(), 5) == 2);
         assert(*next(mo.begin(), 6) == 3);
         assert(*next(mo.begin(), 7) == 3);
         assert(*next(mo.begin(), 8) == 3);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list.pass.cpp

 
 int main(int, char**)
 {
     {
     typedef std::multiset<int> C;
     typedef C::value_type V;
     C m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     min_allocator<int> a;
     C m ({1, 2, 3, 4, 5, 6}, a);
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.get_allocator() == a);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare.pass.cpp

 
 int main(int, char**)
 {
     typedef test_less<int> Cmp;
     typedef std::multiset<int, Cmp> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10));
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/initializer_list_compare_alloc.pass.cpp

 int main(int, char**)
 {
     typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::multiset<int, Cmp, A> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4));
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
     assert(m.get_allocator() == A(4));
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp

V ar[] =
         2,
         3,
         3,
         3
     };
     std::multiset<V> m(cpp17_input_iterator<const int*>(ar),
                   cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
V ar[] =
         2,
         3,
         3,
         3
     };
     std::multiset<V, std::less<V>, min_allocator<V>> m(cpp17_input_iterator<const int*>(ar),
                   cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp

int main(int, char**)
     typedef test_less<V> C;
     typedef test_allocator<V> A;
     std::multiset<V, C, A> m(cpp17_input_iterator<const V*>(ar),
                         cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
                         C(5), A(7));
     assert(m.value_comp() == C(5));
     assert(m.get_allocator() == A(7));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
V ar[] =
         3
     };
     typedef test_allocator<V> A;
     typedef test_less<int> C;
     A a;
     std::multiset<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
 
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
     assert(m.get_allocator() == a);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp

V ar[] =
         3,
         3
     };
     typedef test_less<V> C;
     std::multiset<V, C> m(cpp17_input_iterator<const V*>(ar),
                      cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
     assert(m.size() == 9);
-    assert(distance(m.begin(), m.end()) == 9);
+    assert(std::distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
     assert(*next(m.begin(), 1) == 1);
     assert(*next(m.begin(), 2) == 1);
     assert(*next(m.begin(), 3) == 2);
     assert(*next(m.begin(), 4) == 2);
     assert(*next(m.begin(), 5) == 2);
     assert(*next(m.begin(), 6) == 3);
     assert(*next(m.begin(), 7) == 3);
     assert(*next(m.begin(), 8) == 3);
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.cons/move.pass.cpp

int main(int, char**)
         typedef int V;
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(C(5), A(7));
         std::multiset<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
             2,
             2,
             3,
             3,
             3
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::multiset<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
             2,
             2,
             3,
             3,
             3
         };
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::multiset<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::multiset<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 9);
-        assert(distance(m.begin(), m.end()) == 9);
+        assert(std::distance(m.begin(), m.end()) == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
         assert(*next(m.begin(), 2) == 1);
         assert(*next(m.begin(), 3) == 2);
         assert(*next(m.begin(), 4) == 2);
         assert(*next(m.begin(), 5) == 2);
         assert(*next(m.begin(), 6) == 3);
         assert(*next(m.begin(), 7) == 3);
         assert(*next(m.begin(), 8) == 3);
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
 
   return 0;
 }

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

 int main(int, char**)
 {
     {
     typedef std::set<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
+    assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
+    assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp

 
 void basic_test() {
   {
     typedef std::set<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
   }
   {
     typedef std::set<int, std::less<int>, min_allocator<int> > C;
     typedef C::value_type V;
     C m = {10, 8};
     m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
   }

libcxx/test/std/containers/associative/set/set.cons/copy.pass.cpp

int main(int, char**)
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int V;
         V ar[] =
#if TEST_STD_VER >= 11
         };
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = mo;
         assert(m.get_allocator() == A(-2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A(7));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/copy_alloc.pass.cpp

int main(int, char**)
     };
     typedef test_less<int> C;
     typedef test_allocator<V> A;
     std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
     std::set<int, C, A> m(mo, A(3));
     assert(m.get_allocator() == A(3));
     assert(m.key_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
 
     assert(mo.get_allocator() == A(7));
     assert(mo.key_comp() == C(5));
     assert(mo.size() == 3);
-    assert(distance(mo.begin(), mo.end()) == 3);
+    assert(std::distance(mo.begin(), mo.end()) == 3);
     assert(*mo.begin() == 1);
     assert(*next(mo.begin()) == 2);
     assert(*next(mo.begin(), 2) == 3);
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/copy_assign.pass.cpp

int main(int, char**)
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
     {
         typedef int V;
         const V ar[] =
         {
int main(int, char**)
         typedef test_less<int> C;
         typedef other_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(2));
         std::set<int, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0])/2, C(3), A(7));
         m = mo;
         assert(m.get_allocator() == A(2));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A(2));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 3);
-        assert(distance(mo.begin(), mo.end()) == 3);
+        assert(std::distance(mo.begin(), mo.end()) == 3);
         assert(*mo.begin() == 1);
         assert(*next(mo.begin()) == 2);
         assert(*next(mo.begin(), 2) == 3);
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/initializer_list.pass.cpp

 
 int main(int, char**)
 {
     {
     typedef std::set<int> C;
     typedef C::value_type V;
     C m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {1, 2, 3, 4, 5, 6};
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare.pass.cpp

 
 int main(int, char**)
 {
     typedef test_less<int> Cmp;
     typedef std::set<int, Cmp> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10));
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/initializer_list_compare_alloc.pass.cpp

 {
     {
     typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::set<int, Cmp, A> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, Cmp(10), A(4));
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.key_comp() == Cmp(10));
     assert(m.get_allocator() == A(4));
     }
     {
     typedef test_less<int> Cmp;
     typedef test_allocator<int> A;
     typedef std::set<int, Cmp, A> C;
     typedef C::value_type V;
     C m({1, 2, 3, 4, 5, 6}, A(4));
     assert(m.size() == 6);
-    assert(distance(m.begin(), m.end()) == 6);
+    assert(std::distance(m.begin(), m.end()) == 6);
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(m.get_allocator() == A(4));
     }
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp

V ar[] =
         2,
         3,
         3,
         3
     };
     std::set<V> m(cpp17_input_iterator<const int*>(ar),
                   cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
 #if TEST_STD_VER >= 11
     {
     typedef int V;
     V ar[] =
     {
         1,
         1,
         1,
         2,
         2,
         2,
         3,
         3,
         3
     };
     std::set<V, std::less<int>, min_allocator<int>> m(cpp17_input_iterator<const int*>(ar),
                   cpp17_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp

int main(int, char**)
     typedef test_less<V> C;
     typedef test_allocator<V> A;
     std::set<V, C, A> m(cpp17_input_iterator<const V*>(ar),
                         cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
                         C(5), A(7));
     assert(m.value_comp() == C(5));
     assert(m.get_allocator() == A(7));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     }
 #if TEST_STD_VER > 11
     {
     typedef int V;
     V ar[] =
V ar[] =
         3
     };
     typedef test_allocator<V> A;
     typedef test_less<int> C;
     A a(7);
     std::set<V, C, A> m(ar, ar+sizeof(ar)/sizeof(ar[0]), a);
 
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
     assert(m.get_allocator() == a);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp

V ar[] =
         3,
         3
     };
     typedef test_less<V> C;
     std::set<V, C> m(cpp17_input_iterator<const V*>(ar),
                      cpp17_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
     assert(m.size() == 3);
-    assert(distance(m.begin(), m.end()) == 3);
+    assert(std::distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
     assert(*next(m.begin()) == 2);
     assert(*next(m.begin(), 2) == 3);
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/move.pass.cpp

int main(int, char**)
         typedef int V;
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(C(5), A(7));
         std::set<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 0);
-        assert(distance(m.begin(), m.end()) == 0);
+        assert(std::distance(m.begin(), m.end()) == 0);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
             2,
             2,
             3,
             3,
             3
         };
         typedef test_less<int> C;
         typedef test_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A(7));
         std::set<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A(7));
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A(test_alloc_base::moved_value));
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
             1,
             2,
             2,
             2,
             3,
             3,
             3
         };
         typedef test_less<int> C;
         typedef min_allocator<V> A;
         std::set<int, C, A> mo(ar, ar+sizeof(ar)/sizeof(ar[0]), C(5), A());
         std::set<int, C, A> m = std::move(mo);
         assert(m.get_allocator() == A());
         assert(m.key_comp() == C(5));
         assert(m.size() == 3);
-        assert(distance(m.begin(), m.end()) == 3);
+        assert(std::distance(m.begin(), m.end()) == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
         assert(*next(m.begin(), 2) == 3);
 
         assert(mo.get_allocator() == A());
         assert(mo.key_comp() == C(5));
         assert(mo.size() == 0);
-        assert(distance(mo.begin(), mo.end()) == 0);
+        assert(std::distance(mo.begin(), mo.end()) == 0);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp

 template <class C>
 void
 test(C& c1, int size)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size);
     assert(c1.size() == static_cast<std::size_t>(size));
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     CI i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
         assert(*i == j);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == 0);
 }
 
 template <class C>

libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp

 template <class C>
 void
 test(C& c1, int size, int x)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size, x);
     assert(c1.size() == static_cast<std::size_t>(size));
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     CI i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < std::min(c1_osize, c1.size()); ++j, ++i)
         assert(*i == j);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == x);
 }
 
 template <class C>

libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp

make(int size, int start = 0 )
     return c;
 }
 
 template <class C>
 void
 test(C& c1, const C& c2)
 {
     c1.assign(c2.begin(), c2.end());
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {
     C c1 = make<C>(N, start);
     C c2 = make<C>(M);
     test(c1, c2);
 }
 
 template <class C>
 void
 testI(C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> ICI;
     c1.assign(ICI(c2.begin()), ICI(c2.end()));
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
 }
 
 template <class C>
 void
 testNI(int start, int N, int M)
 {
     C c1 = make<C>(N, start);

libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp

 
 template <class C>
 void
 test(C& c1, int size, int v)
 {
     typedef typename C::const_iterator CI;
     c1.assign(size, v);
     assert(c1.size() == static_cast<std::size_t>(size));
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     for (CI i = c1.begin(); i != c1.end(); ++i)
         assert(*i == v);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp

 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::allocator<T> Allocator;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 template <class Allocator, class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp

 test(InputIterator f, InputIterator l, const Allocator& a)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l, a);
     assert(d.get_allocator() == a);
     assert(d.size() == static_cast<std::size_t>(std::distance(f, l)));
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
 
 void basic_test()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);

libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp

 #if TEST_STD_VER > 11
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n, Allocator());
     assert(static_cast<unsigned>(DefaultOnly::count) == n);
     assert(d.size() == n);
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
     }
     assert(DefaultOnly::count == 0);
 #else
     ((void)n);
 #endif
 }
 
 template <class T, class Allocator>
 void
 test1(unsigned n)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n);
     assert(static_cast<unsigned>(DefaultOnly::count) == n);
     assert(d.size() == n);
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
 #if TEST_STD_VER >= 11
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
 #endif
     }
     assert(DefaultOnly::count == 0);
 }
 

libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp

 template <class T, class Allocator>
 void
 test(unsigned n, const T& x)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x);
     assert(d.size() == n);
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
     test<int, std::allocator<int> >(0, 5);
     test<int, std::allocator<int> >(1, 10);

libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp

 void
 test(unsigned n, const T& x, const Allocator& a)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x, a);
     assert(d.get_allocator() == a);
     assert(d.size() == n);
-    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
     {
     std::allocator<int> a;

libcxx/test/std/containers/sequences/deque/deque.modifiers/clear.pass.cpp

 int main(int, char**)
 {
     {
         typedef NotConstructible T;
         typedef std::deque<T> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::deque<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef NotConstructible T;
         typedef std::deque<T, min_allocator<T>> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::deque<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp

 void
 test(int P, C& c1)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.emplace(c1.begin() + P, Emplaceable(1, 2.5));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     assert(*i == Emplaceable(1, 2.5));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     for (int i = 0; i <= 3; ++i)

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp

test(C& c1)
     std::size_t c1_osize = c1.size();
 #if TEST_STD_VER > 14
     typedef typename C::reference Ref;
     Ref ref = c1.emplace_back(Emplaceable(1, 2.5));
 #else
               c1.emplace_back(Emplaceable(1, 2.5));
 #endif
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end())
+    assert(std::distance(c1.begin(), c1.end())
                == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.end();
     assert(*--i == Emplaceable(1, 2.5));
 #if TEST_STD_VER > 14
     assert(&(*i) == &ref);
 #endif
 }
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp

test(C& c1)
     std::size_t c1_osize = c1.size();
 #if TEST_STD_VER > 14
     typedef typename C::reference Ref;
     Ref res_ref = c1.emplace_front(Emplaceable(1, 2.5));
 #else
                   c1.emplace_front(Emplaceable(1, 2.5));
 #endif
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end())
+    assert(std::distance(c1.begin(), c1.end())
                == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.begin();
     assert(*i == Emplaceable(1, 2.5));
 #if TEST_STD_VER > 14
     assert(&res_ref == &(*i));
 #endif
 }
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp

 test(int P, C& c1)
 {
     typedef typename C::iterator I;
     assert(static_cast<std::size_t>(P) < c1.size());
     std::size_t c1_osize = c1.size();
     I i = c1.erase(c1.cbegin() + P);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize - 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
         assert(*i == j);
     for (++j; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp

 test(int P, C& c1, int size)
 {
     typedef typename C::iterator I;
     assert(static_cast<std::size_t>(P + size) <= c1.size());
     std::size_t c1_osize = c1.size();
     I i = c1.erase(c1.cbegin() + P, c1.cbegin() + (P + size));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize - size);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
         assert(*i == j);
     for (j += size; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

test(int P, const C& c0, const C& c2)
     {
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
     }
     {
     typedef typename C::const_iterator CI;
     typedef forward_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
     }
     {
     typedef typename C::const_iterator CI;
     typedef bidirectional_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
     }

 testI(int P, C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
     typedef cpp17_input_iterator<CI> ICI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + c2.size());
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp

 void
 test(int P, C& c1, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, MoveOnly(x));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
     assert(*i == MoveOnly(x));
     ++i;
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp

 void
 test(int P, C& c1, int size, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, size, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + size);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     for (int j = 0; j < size; ++j, ++i)
         assert(*i == x);
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
self_reference_test()
     {
         for (int j = 0; j < 20; ++j)
         {
             C c = make<C>(20);
             CI it = c.cbegin() + i;
             CI jt = c.cbegin() + j;
             c.insert(it, 5, *jt);
             assert(c.size() == 25);
-            assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
+            assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
             it = c.cbegin();
             for (int k = 0; k < i; ++k, ++it)
                 assert(*it == k);
             for (int k = 0; k < 5; ++k, ++it)
                 assert(*it == j);
             for (int k = i; k < 20; ++k, ++it)
                 assert(*it == k);
         }

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp

 void
 test(int P, C& c1, int x)
 {
     typedef typename C::const_iterator CI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
     assert(*i == x);
     ++i;
     for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
self_reference_test()
     {
         for (int j = 0; j < 20; ++j)
         {
             C c = make<C>(20);
             CI it = c.cbegin() + i;
             CI jt = c.cbegin() + j;
             c.insert(it, *jt);
             assert(c.size() == 21);
-            assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
+            assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
             it = c.cbegin();
             for (int k = 0; k < i; ++k, ++it)
                 assert(*it == k);
             assert(*it == j);
             ++it;
             for (int k = i; k < 20; ++k, ++it)
                 assert(*it == k);
         }

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp

 template <class C>
 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_back();
     assert(c1.size() == c1_osize - 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     for (int j = 0; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)

libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp

 template <class C>
 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_front();
     assert(c1.size() == c1_osize - 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     for (int j = 1; static_cast<std::size_t>(j) < c1.size(); ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp

 template <class C>
 void
 test(C& c1, int x)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.push_front(x);
     assert(c1.size() == c1_osize + 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == x);
     ++i;
     for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>

libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp

 template <class C>
 void
 test(C& c1, int x)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.push_front(MoveOnly(x));
     assert(c1.size() == c1_osize + 1);
-    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
+    assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == MoveOnly(x));
     ++i;
     for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, (void) ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp

 int main(int, char**)
 {
     {
         typedef NotConstructible T;
         typedef std::forward_list<T> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef NotConstructible T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         ASSERT_NOEXCEPT(c.clear());
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         c.clear();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_after.pass.cpp

int main(int, char**)
     {
         typedef Emplaceable T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         C c;
         I i = c.emplace_after(c.cbefore_begin());
         assert(i == c.begin());
         assert(c.front() == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.emplace_after(c.cbegin(), 1, 2.5);
         assert(i == next(c.begin()));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin()) == Emplaceable(1, 2.5));
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.emplace_after(next(c.cbegin()), 2, 3.5);
         assert(i == next(c.begin(), 2));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin()) == Emplaceable(1, 2.5));
         assert(*next(c.begin(), 2) == Emplaceable(2, 3.5));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.emplace_after(c.cbegin(), 3, 4.5);
         assert(i == next(c.begin()));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin(), 1) == Emplaceable(3, 4.5));
         assert(*next(c.begin(), 2) == Emplaceable(1, 2.5));
         assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
     {
         typedef Emplaceable T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         C c;
         I i = c.emplace_after(c.cbefore_begin());
         assert(i == c.begin());
         assert(c.front() == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.emplace_after(c.cbegin(), 1, 2.5);
         assert(i == next(c.begin()));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin()) == Emplaceable(1, 2.5));
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.emplace_after(next(c.cbegin()), 2, 3.5);
         assert(i == next(c.begin(), 2));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin()) == Emplaceable(1, 2.5));
         assert(*next(c.begin(), 2) == Emplaceable(2, 3.5));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.emplace_after(c.cbegin(), 3, 4.5);
         assert(i == next(c.begin()));
         assert(c.front() == Emplaceable());
         assert(*next(c.begin(), 1) == Emplaceable(3, 4.5));
         assert(*next(c.begin(), 2) == Emplaceable(1, 2.5));
         assert(*next(c.begin(), 3) == Emplaceable(2, 3.5));
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/emplace_front.pass.cpp

int main(int, char**)
     {
         typedef Emplaceable T;
         typedef std::forward_list<T> C;
         C c;
 #if TEST_STD_VER > 14
         T& r1 = c.emplace_front();
         assert(c.front() == Emplaceable());
         assert(&r1 == &c.front());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         T& r2 = c.emplace_front(1, 2.5);
         assert(c.front() == Emplaceable(1, 2.5));
         assert(&r2 == &c.front());
 #else
         c.emplace_front();
         assert(c.front() == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.emplace_front(1, 2.5);
         assert(c.front() == Emplaceable(1, 2.5));
 #endif
         assert(*next(c.begin()) == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
     {
         typedef Emplaceable T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
 #if TEST_STD_VER > 14
         T& r1 = c.emplace_front();
         assert(c.front() == Emplaceable());
         assert(&r1 == &c.front());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         T& r2 = c.emplace_front(1, 2.5);
         assert(c.front() == Emplaceable(1, 2.5));
         assert(&r2 == &c.front());
 #else
         c.emplace_front();
         assert(c.front() == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.emplace_front(1, 2.5);
         assert(c.front() == Emplaceable(1, 2.5));
 #endif
         assert(*next(c.begin()) == Emplaceable());
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_many.pass.cpp

int main(int, char**)
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t), std::end(t));
 
         C::iterator i = c.erase_after(next(c.cbefore_begin(), 4), next(c.cbefore_begin(), 4));
         assert(i == next(c.cbefore_begin(), 4));
-        assert(distance(c.begin(), c.end()) == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 4);
         assert(*next(c.begin(), 5) == 5);
         assert(*next(c.begin(), 6) == 6);
         assert(*next(c.begin(), 7) == 7);
         assert(*next(c.begin(), 8) == 8);
         assert(*next(c.begin(), 9) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 2), next(c.cbefore_begin(), 5));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 8);
+        assert(std::distance(c.begin(), c.end()) == 8);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
         assert(*next(c.begin(), 5) == 7);
         assert(*next(c.begin(), 6) == 8);
         assert(*next(c.begin(), 7) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 2), next(c.cbefore_begin(), 3));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 8);
+        assert(std::distance(c.begin(), c.end()) == 8);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
         assert(*next(c.begin(), 5) == 7);
         assert(*next(c.begin(), 6) == 8);
         assert(*next(c.begin(), 7) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 5), next(c.cbefore_begin(), 9));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
 
         i = c.erase_after(next(c.cbefore_begin(), 0), next(c.cbefore_begin(), 2));
         assert(i == c.begin());
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 4);
         assert(*next(c.begin(), 2) == 5);
         assert(*next(c.begin(), 3) == 6);
 
         i = c.erase_after(next(c.cbefore_begin(), 0), next(c.cbefore_begin(), 5));
         assert(i == c.begin());
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t), std::end(t));
 
         C::iterator i = c.erase_after(next(c.cbefore_begin(), 4), next(c.cbefore_begin(), 4));
         assert(i == next(c.cbefore_begin(), 4));
-        assert(distance(c.begin(), c.end()) == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 4);
         assert(*next(c.begin(), 5) == 5);
         assert(*next(c.begin(), 6) == 6);
         assert(*next(c.begin(), 7) == 7);
         assert(*next(c.begin(), 8) == 8);
         assert(*next(c.begin(), 9) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 2), next(c.cbefore_begin(), 5));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 8);
+        assert(std::distance(c.begin(), c.end()) == 8);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
         assert(*next(c.begin(), 5) == 7);
         assert(*next(c.begin(), 6) == 8);
         assert(*next(c.begin(), 7) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 2), next(c.cbefore_begin(), 3));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 8);
+        assert(std::distance(c.begin(), c.end()) == 8);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
         assert(*next(c.begin(), 5) == 7);
         assert(*next(c.begin(), 6) == 8);
         assert(*next(c.begin(), 7) == 9);
 
         i = c.erase_after(next(c.cbefore_begin(), 5), next(c.cbefore_begin(), 9));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 5);
         assert(*next(c.begin(), 4) == 6);
 
         i = c.erase_after(next(c.cbefore_begin(), 0), next(c.cbefore_begin(), 2));
         assert(i == c.begin());
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 4);
         assert(*next(c.begin(), 2) == 5);
         assert(*next(c.begin(), 3) == 6);
 
         i = c.erase_after(next(c.cbefore_begin(), 0), next(c.cbefore_begin(), 5));
         assert(i == c.begin());
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/erase_after_one.pass.cpp

int main(int, char**)
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         C::iterator i = c.erase_after(next(c.cbefore_begin(), 4));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 0));
         assert(i == c.begin());
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 2);
         assert(*next(c.begin(), 2) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 1));
         assert(i == next(c.begin()));
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 1));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(*next(c.begin(), 0) == 1);
 
         i = c.erase_after(next(c.cbefore_begin(), 0));
         assert(i == c.begin());
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         C::iterator i = c.erase_after(next(c.cbefore_begin(), 4));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 0));
         assert(i == c.begin());
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 2);
         assert(*next(c.begin(), 2) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 1));
         assert(i == next(c.begin()));
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
         assert(*next(c.begin(), 0) == 1);
         assert(*next(c.begin(), 1) == 3);
 
         i = c.erase_after(next(c.cbefore_begin(), 1));
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(*next(c.begin(), 0) == 1);
 
         i = c.erase_after(next(c.cbefore_begin(), 0));
         assert(i == c.begin());
         assert(i == c.end());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_const.pass.cpp

int main(int, char**)
         typedef int T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0);
         assert(i == c.begin());
         assert(c.front() == 0);
         assert(c.front() == 0);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.insert_after(c.cbegin(), 1);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.insert_after(next(c.cbegin()), 2);
         assert(i == next(c.begin(), 2));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
         assert(*next(c.begin(), 2) == 2);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.insert_after(c.cbegin(), 3);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 1);
         assert(*next(c.begin(), 3) == 2);
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0);
         assert(i == c.begin());
         assert(c.front() == 0);
         assert(c.front() == 0);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.insert_after(c.cbegin(), 1);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.insert_after(next(c.cbegin()), 2);
         assert(i == next(c.begin(), 2));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
         assert(*next(c.begin(), 2) == 2);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.insert_after(c.cbegin(), 3);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 1);
         assert(*next(c.begin(), 3) == 2);
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_init.pass.cpp

 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), {});
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), {0, 1, 2});
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         i = c.insert_after(c.begin(), {3, 4});
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), {});
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), {0, 1, 2});
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         i = c.insert_after(c.begin(), {3, 4});
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp

int main(int, char**)
         typedef int T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         typedef cpp17_input_iterator<const T*> J;
         C c;
         const T t[] = {0, 1, 2, 3, 4};
         I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         i = c.insert_after(c.begin(), J(t+3), J(t+5));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         typedef cpp17_input_iterator<const T*> J;
         C c;
         const T t[] = {0, 1, 2, 3, 4};
         I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), J(t), J(t+3));
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         i = c.insert_after(c.begin(), J(t+3), J(t+5));
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 4);
         assert(*next(c.begin(), 3) == 1);
         assert(*next(c.begin(), 4) == 2);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_rv.pass.cpp

int main(int, char**)
         typedef MoveOnly T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0);
         assert(i == c.begin());
         assert(c.front() == 0);
         assert(c.front() == 0);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.insert_after(c.cbegin(), 1);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.insert_after(next(c.cbegin()), 2);
         assert(i == next(c.begin(), 2));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
         assert(*next(c.begin(), 2) == 2);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.insert_after(c.cbegin(), 3);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 1);
         assert(*next(c.begin(), 3) == 2);
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
     {
         typedef MoveOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0);
         assert(i == c.begin());
         assert(c.front() == 0);
         assert(c.front() == 0);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
 
         i = c.insert_after(c.cbegin(), 1);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
 
         i = c.insert_after(next(c.cbegin()), 2);
         assert(i == next(c.begin(), 2));
         assert(c.front() == 0);
         assert(*next(c.begin()) == 1);
         assert(*next(c.begin(), 2) == 2);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
 
         i = c.insert_after(c.cbegin(), 3);
         assert(i == next(c.begin()));
         assert(c.front() == 0);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 1);
         assert(*next(c.begin(), 3) == 2);
-        assert(distance(c.begin(), c.end()) == 4);
+        assert(std::distance(c.begin(), c.end()) == 4);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_size_value.pass.cpp

 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0, 0);
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), 3, 3);
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 3);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 3);
 
         i = c.insert_after(c.begin(), 2, 2);
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 3);
         assert(*next(c.begin(), 1) == 2);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 3);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
         C c;
         I i = c.insert_after(c.cbefore_begin(), 0, 0);
         assert(i == c.before_begin());
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
 
         i = c.insert_after(c.cbefore_begin(), 3, 3);
         assert(i == next(c.before_begin(), 3));
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 3);
         assert(*next(c.begin(), 1) == 3);
         assert(*next(c.begin(), 2) == 3);
 
         i = c.insert_after(c.begin(), 2, 2);
         assert(i == next(c.begin(), 2));
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         assert(*next(c.begin(), 0) == 3);
         assert(*next(c.begin(), 1) == 2);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 3);
         assert(*next(c.begin(), 4) == 3);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/pop_front.pass.cpp

int main(int, char**)
     {
         typedef int T;
         typedef std::forward_list<T> C;
         typedef std::forward_list<T> C;
         C c;
         c.push_front(1);
         c.push_front(3);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(c.front() == 1);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef MoveOnly T;
         typedef std::forward_list<T> C;
         C c;
         c.push_front(1);
         c.push_front(3);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(c.front() == 1);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.push_front(1);
         c.push_front(3);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(c.front() == 1);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef MoveOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.push_front(1);
         c.push_front(3);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         assert(c.front() == 1);
         c.pop_front();
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_const.pass.cpp

 int main(int, char**)
 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         C c;
         c.push_front(1);
         assert(c.front() == 1);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.push_front(3);
         assert(c.front() == 3);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.push_front(1);
         assert(c.front() == 1);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.push_front(3);
         assert(c.front() == 3);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/push_front_rv.pass.cpp

 int main(int, char**)
 {
     {
         typedef MoveOnly T;
         typedef std::forward_list<T> C;
         C c;
         c.push_front(1);
         assert(c.front() == 1);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.push_front(3);
         assert(c.front() == 3);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
     {
         typedef MoveOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.push_front(1);
         assert(c.front() == 1);
-        assert(distance(c.begin(), c.end()) == 1);
+        assert(std::distance(c.begin(), c.end()) == 1);
         c.push_front(3);
         assert(c.front() == 3);
         assert(*next(c.begin()) == 1);
-        assert(distance(c.begin(), c.end()) == 2);
+        assert(std::distance(c.begin(), c.end()) == 2);
     }
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size.pass.cpp

 
 int main(int, char**)
 {
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T> C;
         C c;
         c.resize(0);
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
         c.resize(10);
-        assert(distance(c.begin(), c.end()) == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
         c.resize(20);
-        assert(distance(c.begin(), c.end()) == 20);
+        assert(std::distance(c.begin(), c.end()) == 20);
         c.resize(5);
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         c.resize(0);
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         c.resize(3);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         c.resize(6);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 0);
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
 
         c.resize(6);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 0);
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
     }
 #if TEST_STD_VER >= 11
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.resize(0);
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
         c.resize(10);
-        assert(distance(c.begin(), c.end()) == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
         c.resize(20);
-        assert(distance(c.begin(), c.end()) == 20);
+        assert(std::distance(c.begin(), c.end()) == 20);
         c.resize(5);
-        assert(distance(c.begin(), c.end()) == 5);
+        assert(std::distance(c.begin(), c.end()) == 5);
         c.resize(0);
-        assert(distance(c.begin(), c.end()) == 0);
+        assert(std::distance(c.begin(), c.end()) == 0);
     }
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         c.resize(3);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         c.resize(6);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 0);
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
 
         c.resize(6);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 0);
         assert(*next(c.begin(), 4) == 0);
         assert(*next(c.begin(), 5) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/resize_size_value.pass.cpp

 {
     {
         typedef int T;
         typedef std::forward_list<T> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         c.resize(3, 10);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         c.resize(6, 10);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 10);
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
 
         c.resize(6, 12);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 10);
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t[] = {0, 1, 2, 3, 4};
         C c(std::begin(t), std::end(t));
 
         c.resize(3, 10);
-        assert(distance(c.begin(), c.end()) == 3);
+        assert(std::distance(c.begin(), c.end()) == 3);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
 
         c.resize(6, 10);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 10);
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
 
         c.resize(6, 12);
-        assert(distance(c.begin(), c.end()) == 6);
+        assert(std::distance(c.begin(), c.end()) == 6);
         assert(*next(c.begin(), 0) == 0);
         assert(*next(c.begin(), 1) == 1);
         assert(*next(c.begin(), 2) == 2);
         assert(*next(c.begin(), 3) == 10);
         assert(*next(c.begin(), 4) == 10);
         assert(*next(c.begin(), 5) == 10);
     }
     {

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

 
 template <class C>
 void test(int N)
 {
     C c;
     for (int i = 0; i < N; ++i)
         c.push_front(i);
     c.reverse();
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(*j == i);
 }
 
 int main(int, char**)
 {
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int> >(i);
 #if TEST_STD_VER >= 11
     for (int i = 0; i < 10; ++i)
         test<std::forward_list<int, min_allocator<int>> >(i);
 #endif
 
   return 0;
 }

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

void test(int N)
     typedef typename C::value_type T;
     typedef std::vector<T> V;
     V v;
     for (int i = 0; i < N; ++i)
         v.push_back(i);
     std::shuffle(v.begin(), v.end(), randomness);
     C c(v.begin(), v.end());
     c.sort();
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(*j == i);
 }
 
 struct Payload
 {
     int val;
void test_stable(int N)
     for (int i = 0; i < N; ++i)
         v.push_back(Payload(i/2));
     std::shuffle(v.begin(), v.end(), randomness);
     for (int i = 0; i < N; ++i)
         v[i].side = i;
 
     C c(v.begin(), v.end());
     c.sort();
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
 
 //  Are we sorted?
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(j->val == i/2);
 
 //  Are we stable?
     for (C::const_iterator it = c.begin(); it != c.end(); ++it)

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

void test_stable(int N)
     for (int i = 0; i < N; ++i)
         v.push_back(Payload(i/2));
     std::shuffle(v.begin(), v.end(), randomness);
     for (int i = 0; i < N; ++i)
         v[i].side = i;
 
     C c(v.begin(), v.end());
     c.sort(greater);
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
 
 //  Are we sorted?
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(j->val == (N-1-i)/2);
 
 //  Are we stable?
     for (C::const_iterator it = c.begin(); it != c.end(); ++it)
void test(int N)
     typedef typename C::value_type T;
     typedef std::vector<T> V;
     V v;
     for (int i = 0; i < N; ++i)
         v.push_back(i);
     std::shuffle(v.begin(), v.end(), randomness);
     C c(v.begin(), v.end());
     c.sort(std::greater<T>());
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(*j == N-1-i);
 }
 
 int main(int, char**)
 {
     for (int i = 0; i < 40; ++i)

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

testd(const C& c, int p, int l)
     typename C::const_iterator i = c.begin();
     int n1 = 0;
     for (; n1 < p; ++n1, ++i)
         assert(*i == t1[n1]);
     for (int n2 = 0; n2 < l; ++n2, ++i)
         assert(*i == t2[n2]);
     for (; n1 < size_t1; ++n1, ++i)
         assert(*i == t1[n1]);
-    assert(distance(c.begin(), c.end()) == size_t1 + l);
+    assert(std::distance(c.begin(), c.end()) == size_t1 + l);
 }
 
 int main(int, char**)
 {
     {
     // splicing different containers
     typedef std::forward_list<T> C;
     for (int l = 0; l <= size_t2; ++l)

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

testd(const C& c, int p, int f)
     typename C::const_iterator i = c.begin();
     int n1 = 0;
     for (; n1 < p; ++n1, ++i)
         assert(*i == t1[n1]);
     for (int n2 = f; n2 < f+1; ++n2, ++i)
         assert(*i == t2[n2]);
     for (; n1 < size_t1; ++n1, ++i)
         assert(*i == t1[n1]);
-    assert(distance(c.begin(), c.end()) == size_t1 + 1);
+    assert(std::distance(c.begin(), c.end()) == size_t1 + 1);
 }
 
 template <class C>
 void
 tests(const C& c, int p, int f)
 {
     typename C::const_iterator i = c.begin();
     int n = 0;
else // p > f+1
             assert(*i == t1[n]);
         for (n = f+1; n < p; ++n, ++i)
             assert(*i == t1[n]);
         for (n = f; n < f+1; ++n, ++i)
             assert(*i == t1[n]);
         for (n = p; n < size_t1; ++n, ++i)
             assert(*i == t1[n]);
     }
-    assert(distance(c.begin(), c.end()) == size_t1);
+    assert(std::distance(c.begin(), c.end()) == size_t1);
 }
 
 int main(int, char**)
 {
     {
     // splicing different containers
     typedef std::forward_list<T> C;
     for (int f = 0; f <= size_t2-1; ++f)

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

testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
     typename C::const_iterator i = c.begin();
     ptrdiff_t n1 = 0;
     for (; n1 < p; ++n1, ++i)
         assert(*i == t1[n1]);
     for (ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)
         assert(*i == t2[n2]);
     for (; n1 < size_t1; ++n1, ++i)
         assert(*i == t1[n1]);
-    assert(distance(c.begin(), c.end()) == size_t1 + (l > f+1 ? l-1-f : 0));
+    assert(std::distance(c.begin(), c.end()) == size_t1 + (l > f+1 ? l-1-f : 0));
 }
 
 template <class C>
 void
 tests(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
 {
     typename C::const_iterator i = c.begin();
     ptrdiff_t n = 0;
else // p > f
             assert(*i == t1[n]);
         for (n = l-1; n < p; ++n, ++i)
             assert(*i == t1[n]);
         for (n = f; n < l-1; ++n, ++i)
             assert(*i == t1[n]);
         for (n = p; n < size_t1; ++n, ++i)
             assert(*i == t1[n]);
     }
-    assert(distance(c.begin(), c.end()) == size_t1);
+    assert(std::distance(c.begin(), c.end()) == size_t1);
 }
 
 int main(int, char**)
 {
     {
     // splicing different containers
     typedef std::forward_list<T> C;
     for (ptrdiff_t f = 0; f <= size_t2+1; ++f)

libcxx/test/std/containers/sequences/forwardlist/forwardlist.spec/member_swap.pass.cpp

int main(int, char**)
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1, 1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(1, 2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1, 1));
         C c2(A(1, 2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1, 1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(1, 2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1, 1));
         C c2(A(1, 2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator().get_id() == 2);
     }
 
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1));
         C c2(A(2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1));
         C c2(A(2));
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A());
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A());
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A());
         C c2(A{});
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A{});
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A());
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A{});
         C c2(A{});
         c1.swap(c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.spec/non_member_swap.pass.cpp

int main(int, char**)
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1, 1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(1, 2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1, 1));
         C c2(A(1, 2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1, 1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(1, 2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator().get_id() == 2);
     }
     {
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1, 1));
         C c2(A(1, 2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator().get_id() == 1);
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator().get_id() == 2);
     }
 
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A(1));
         C c2(A(2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1));
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A(2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
     {
         typedef int T;
         typedef other_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A(1));
         C c2(A(2));
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A(2));
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A(1));
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A());
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A());
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         const T t1[] = {0, 1, 2, 3, 4, 5};
         C c1(std::begin(t1), std::end(t1), A());
         C c2(A{});
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 6);
+        assert(std::distance(c2.begin(), c2.end()) == 6);
         assert(*next(c2.begin(), 0) == 0);
         assert(*next(c2.begin(), 1) == 1);
         assert(*next(c2.begin(), 2) == 2);
         assert(*next(c2.begin(), 3) == 3);
         assert(*next(c2.begin(), 4) == 4);
         assert(*next(c2.begin(), 5) == 5);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A{});
         const T t2[] = {10, 11, 12};
         C c2(std::begin(t2), std::end(t2), A());
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 3);
+        assert(std::distance(c1.begin(), c1.end()) == 3);
         assert(*next(c1.begin(), 0) == 10);
         assert(*next(c1.begin(), 1) == 11);
         assert(*next(c1.begin(), 2) == 12);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A());
     }
     {
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
         C c1(A{});
         C c2(A{});
         swap(c1, c2);
 
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c1.get_allocator() == A());
 
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(c2.get_allocator() == A());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp

 {
     {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.begin();
     ++i;
     std::list<int>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::list<int, min_allocator<int>> l1(a1, a1+3);
     std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
     ++i;
     std::list<int, min_allocator<int>>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp

 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
         std::list<int> l1(a1, a1+3);
         std::list<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert(l1 == std::list<int>(a1+1, a1+3));
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert(l1 == std::list<int>(a1+2, a1+3));
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
 #if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert((l1 == std::list<int, min_allocator<int>>(a1+1, a1+3)));
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert((l1 == std::list<int, min_allocator<int>>(a1+2, a1+3)));
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp

 
 template <class List>
 void test() {
     int a1[] = {1, 2, 3};
     List l1;
     typename List::iterator i = l1.insert(l1.begin(), a1, a1+3);
     assert(i == l1.begin());
     assert(l1.size() == 3);
-    assert(distance(l1.begin(), l1.end()) == 3);
+    assert(std::distance(l1.begin(), l1.end()) == 3);
     i = l1.begin();
     assert(*i == 1);
     ++i;
     assert(*i == 2);
     ++i;
     assert(*i == 3);
     int a2[] = {4, 5, 6};
     i = l1.insert(i, a2, a2+3);
     assert(*i == 4);
     assert(l1.size() == 6);
-    assert(distance(l1.begin(), l1.end()) == 6);
+    assert(std::distance(l1.begin(), l1.end()) == 6);
     i = l1.begin();
     assert(*i == 1);
     ++i;
     assert(*i == 2);
     ++i;
     assert(*i == 4);
     ++i;
     assert(*i == 5);
try
         i = l1.insert(i, a2, a2+3);
         assert(false);
     }
     catch (...)
     {
     }
     assert(globalMemCounter.checkOutstandingNewEq(save_count));
     assert(l1.size() == 6);
-    assert(distance(l1.begin(), l1.end()) == 6);
+    assert(std::distance(l1.begin(), l1.end()) == 6);
     i = l1.begin();
     assert(*i == 1);
     ++i;
     assert(*i == 2);
     ++i;
     assert(*i == 4);
     ++i;
     assert(*i == 5);

libcxx/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp

 void test()
 {
     int a1[] = {1, 2, 3};
     int a2[] = {1, 4, 2, 3};
     List l1(a1, a1+3);
     typename List::iterator i = l1.insert(next(l1.cbegin()), 4);
     assert(i == next(l1.begin()));
     assert(l1.size() == 4);
-    assert(distance(l1.begin(), l1.end()) == 4);
+    assert(std::distance(l1.begin(), l1.end()) == 4);
     assert(l1 == List(a2, a2+4));
 
 #if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
     globalMemCounter.throw_after = 0;
     int save_count = globalMemCounter.outstanding_new;
     try
     {
         i = l1.insert(i, 5);

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

void test_stable(int N)
     for (int i = 0; i < N; ++i)
         v.push_back(Payload(i/2));
     std::shuffle(v.begin(), v.end(), randomness);
     for (int i = 0; i < N; ++i)
         v[i].side = i;
 
     C c(v.begin(), v.end());
     c.sort();
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
 
 //  Are we sorted?
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(j->val == i/2);
 
 //  Are we stable?
     for (C::const_iterator it = c.begin(); it != c.end(); ++it)

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

void test_stable(int N)
     for (int i = 0; i < N; ++i)
         v.push_back(Payload(i/2));
     std::shuffle(v.begin(), v.end(), randomness);
     for (int i = 0; i < N; ++i)
         v[i].side = i;
 
     C c(v.begin(), v.end());
     c.sort(greater);
-    assert(distance(c.begin(), c.end()) == N);
+    assert(std::distance(c.begin(), c.end()) == N);
 
 //  Are we sorted?
     typename C::const_iterator j = c.begin();
     for (int i = 0; i < N; ++i, ++j)
         assert(j->val == (N-1-i)/2);
 
 //  Are we stable?
     for (C::const_iterator it = c.begin(); it != c.end(); ++it)

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

 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
     {
         std::list<int> l1;
         std::list<int> l2;
         l1.splice(l1.end(), l2);
         assert(l1.size() == 0);
-        assert(distance(l1.begin(), l1.end()) == 0);
+        assert(std::distance(l1.begin(), l1.end()) == 0);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2;
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2;
         l1.splice(l1.end(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2;
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2;
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2;
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+1);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+1);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+2);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         std::list<int> l2(a2, a2+2);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(next(l1.begin(), 3), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
 #if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2;
         l1.splice(l1.end(), l2);
         assert(l1.size() == 0);
-        assert(distance(l1.begin(), l1.end()) == 0);
+        assert(std::distance(l1.begin(), l1.end()) == 0);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2;
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2;
         l1.splice(l1.end(), l2);
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2;
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2;
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2;
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 4);
-        assert(distance(l1.begin(), l1.end()) == 4);
+        assert(std::distance(l1.begin(), l1.end()) == 4);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.begin(), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(next(l1.begin()), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(next(l1.begin(), 2), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 4);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(next(l1.begin(), 3), l2);
         assert(l1.size() == 6);
-        assert(distance(l1.begin(), l1.end()) == 6);
+        assert(std::distance(l1.begin(), l1.end()) == 6);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);

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

 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 1);
-        assert(distance(l2.begin(), l2.end()) == 1);
+        assert(std::distance(l2.begin(), l2.end()) == 1);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         i = l2.begin();
         assert(*i == 5);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+2);
         l1.splice(l1.end(), l2, next(l2.begin()));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 1);
-        assert(distance(l2.begin(), l2.end()) == 1);
+        assert(std::distance(l2.begin(), l2.end()) == 1);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 5);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         i = l2.begin();
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin()));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 5);
         i = l2.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int> l1;
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 6);
         i = l2.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int> l1(a1, a1+1);
         l1.splice(l1.begin(), l1, l1.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+1);
         l1.splice(l1.begin(), l2, l2.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+1);
         std::list<int> l2(a2, a2+1);
         l1.splice(next(l1.begin()), l2, l2.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int> l1(a1, a1+2);
         l1.splice(l1.begin(), l1, l1.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         l1.splice(l1.begin(), l1, next(l1.begin()));
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+2);
         l1.splice(next(l1.begin()), l1, l1.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int> l1(a1, a1+2);
         l1.splice(next(l1.begin()), l1, next(l1.begin()));
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
 #if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 1);
-        assert(distance(l2.begin(), l2.end()) == 1);
+        assert(std::distance(l2.begin(), l2.end()) == 1);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         i = l2.begin();
         assert(*i == 5);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+2);
         l1.splice(l1.end(), l2, next(l2.begin()));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 1);
-        assert(distance(l2.begin(), l2.end()) == 1);
+        assert(std::distance(l2.begin(), l2.end()) == 1);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 5);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2, l2.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         i = l2.begin();
         assert(*i == 5);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin()));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 5);
         i = l2.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 6);
     }
     {
         std::list<int, min_allocator<int>> l1;
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         assert(l2.size() == 2);
-        assert(distance(l2.begin(), l2.end()) == 2);
+        assert(std::distance(l2.begin(), l2.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 6);
         i = l2.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 5);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         l1.splice(l1.begin(), l1, l1.begin());
         assert(l1.size() == 1);
-        assert(distance(l1.begin(), l1.end()) == 1);
+        assert(std::distance(l1.begin(), l1.end()) == 1);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(l1.begin(), l2, l2.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 4);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+1);
         std::list<int, min_allocator<int>> l2(a2, a2+1);
         l1.splice(next(l1.begin()), l2, l2.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         assert(l2.size() == 0);
-        assert(distance(l2.begin(), l2.end()) == 0);
+        assert(std::distance(l2.begin(), l2.end()) == 0);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         l1.splice(l1.begin(), l1, l1.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         l1.splice(l1.begin(), l1, next(l1.begin()));
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         l1.splice(next(l1.begin()), l1, l1.begin());
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+2);
         l1.splice(next(l1.begin()), l1, next(l1.begin()));
         assert(l1.size() == 2);
-        assert(distance(l1.begin(), l1.end()) == 2);
+        assert(std::distance(l1.begin(), l1.end()) == 2);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
     }
 #endif
 
   return 0;
 }

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

 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     int a2[] = {4, 5, 6};
     {
         std::list<int> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         assert(l2.size() == 1);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         assert(l2.size() == 1);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int> l1(a1, a1+3);
         std::list<int> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         assert(l2.size() == 1);
         i = l2.begin();
         assert(*i == 4);
     }
 #if TEST_STD_VER >= 11
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 3);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
         assert(l1.size() == 3);
-        assert(distance(l1.begin(), l1.end()) == 3);
+        assert(std::distance(l1.begin(), l1.end()) == 3);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 1);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         assert(l2.size() == 1);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 5);
         ++i;
         assert(*i == 6);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         assert(l2.size() == 1);
         i = l2.begin();
         assert(*i == 4);
     }
     {
         std::list<int, min_allocator<int>> l1(a1, a1+3);
         std::list<int, min_allocator<int>> l2(a2, a2+3);
         l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
         assert(l1.size() == 5);
-        assert(distance(l1.begin(), l1.end()) == 5);
+        assert(std::distance(l1.begin(), l1.end()) == 5);
         std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
         assert(*i == 1);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 5);

libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp

int main(int, char**)
     }
     {
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::list<int> c1;
         std::list<int> c2(a2, a2 + 7);
         swap(c1, c2);
         assert(c1 == std::list<int>(a2, a2 + 7));
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         std::list<int> c1(a1, a1 + 5);
         std::list<int> c2;
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2 == std::list<int>(a1, a1 + 5));
     }
     {
         std::list<int> c1;
         std::list<int> c2;
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef test_allocator<int> A;
         std::list<int, A> c1(a1, a1 + 5, A(1));
         std::list<int, A> c2(a2, a2 + 7, A(1));
         swap(c1, c2);
#if TEST_STD_VER >= 11
     }
     {
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::list<int, min_allocator<int>> c1;
         std::list<int, min_allocator<int>> c2(a2, a2 + 7);
         swap(c1, c2);
         assert((c1 == std::list<int, min_allocator<int>>(a2, a2 + 7)));
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         std::list<int, min_allocator<int>> c1(a1, a1 + 5);
         std::list<int, min_allocator<int>> c2;
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert((c2 == std::list<int, min_allocator<int>>(a1, a1 + 5)));
     }
     {
         std::list<int, min_allocator<int>> c1;
         std::list<int, min_allocator<int>> c2;
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef min_allocator<int> A;
         std::list<int, A> c1(a1, a1 + 5, A());
         std::list<int, A> c2(a2, a2 + 7, A());
         swap(c1, c2);

libcxx/test/std/containers/sequences/vector.bool/erase_iter.pass.cpp

 {
     bool a1[] = {1, 0, 1};
     {
     std::vector<bool> l1(a1, a1+3);
     std::vector<bool>::const_iterator i = l1.begin();
     ++i;
     std::vector<bool>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == true);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == true);
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == true);
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     }
 #if TEST_STD_VER >= 11
     {
     std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
     std::vector<bool, min_allocator<bool>>::const_iterator i = l1.begin();
     ++i;
     std::vector<bool, min_allocator<bool>>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == true);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == true);
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == true);
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/erase_iter_iter.pass.cpp

 
 int main(int, char**)
 {
     bool a1[] = {1, 0, 1};
     {
         std::vector<bool> l1(a1, a1+3);
         std::vector<bool>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
     }
     {
         std::vector<bool> l1(a1, a1+3);
         std::vector<bool>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert(l1 == std::vector<bool>(a1+1, a1+3));
     }
     {
         std::vector<bool> l1(a1, a1+3);
         std::vector<bool>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert(l1 == std::vector<bool>(a1+2, a1+3));
     }
     {
         std::vector<bool> l1(a1, a1+3);
         std::vector<bool>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
     }
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert((l1 == std::vector<bool, min_allocator<bool>>(a1+1, a1+3)));
     }
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert((l1 == std::vector<bool, min_allocator<bool>>(a1+2, a1+3)));
     }
     {
         std::vector<bool, min_allocator<bool>> l1(a1, a1+3);
         std::vector<bool, min_allocator<bool>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter.pass.cpp

int main(int, char**)
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int>::const_iterator i = l1.begin();
     assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
     }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>>::const_iterator i = l1.begin();
     assert(is_contiguous_container_asan_correct(l1));
     ++i;
     std::vector<int, min_allocator<int>>::iterator j = l1.erase(i);
     assert(l1.size() == 2);
-    assert(distance(l1.begin(), l1.end()) == 2);
+    assert(std::distance(l1.begin(), l1.end()) == 2);
     assert(*j == 3);
     assert(*l1.begin() == 1);
     assert(*next(l1.begin()) == 3);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(j);
     assert(j == l1.end());
     assert(l1.size() == 1);
-    assert(distance(l1.begin(), l1.end()) == 1);
+    assert(std::distance(l1.begin(), l1.end()) == 1);
     assert(*l1.begin() == 1);
     assert(is_contiguous_container_asan_correct(l1));
     j = l1.erase(l1.begin());
     assert(j == l1.end());
     assert(l1.size() == 0);
-    assert(distance(l1.begin(), l1.end()) == 0);
+    assert(std::distance(l1.begin(), l1.end()) == 0);
     assert(is_contiguous_container_asan_correct(l1));
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
 // Test for LWG2853:
 // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.
     {
     Throws arr[] = {1, 2, 3};

libcxx/test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter.pass.cpp

 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     {
         std::vector<int> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert(l1 == std::vector<int>(a1+1, a1+3));
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert(l1 == std::vector<int>(a1+2, a1+3));
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<std::vector<int> > outer(2, std::vector<int>(1));
         assert(is_contiguous_container_asan_correct(outer));
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
         outer.erase(outer.begin(), outer.begin());
         assert(outer.size() == 2);
         assert(outer[0].size() == 1);
         assert(outer[1].size() == 1);
         assert(is_contiguous_container_asan_correct(outer));
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
         assert(l1.size() == 3);
-        assert(distance(l1.cbegin(), l1.cend()) == 3);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 3);
         assert(i == l1.begin());
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
         assert(l1.size() == 2);
-        assert(distance(l1.cbegin(), l1.cend()) == 2);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 2);
         assert(i == l1.begin());
         assert((l1 == std::vector<int, min_allocator<int>>(a1+1, a1+3)));
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
         assert(l1.size() == 1);
-        assert(distance(l1.cbegin(), l1.cend()) == 1);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 1);
         assert(i == l1.begin());
         assert((l1 == std::vector<int, min_allocator<int>>(a1+2, a1+3)));
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<int, min_allocator<int>> l1(a1, a1+3);
         assert(is_contiguous_container_asan_correct(l1));
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
         assert(l1.size() == 0);
-        assert(distance(l1.cbegin(), l1.cend()) == 0);
+        assert(std::distance(l1.cbegin(), l1.cend()) == 0);
         assert(i == l1.begin());
         assert(is_contiguous_container_asan_correct(l1));
     }
     {
         std::vector<std::vector<int, min_allocator<int>>, min_allocator<std::vector<int, min_allocator<int>>>> outer(2, std::vector<int, min_allocator<int>>(1));
         assert(is_contiguous_container_asan_correct(outer));
         assert(is_contiguous_container_asan_correct(outer[0]));
         assert(is_contiguous_container_asan_correct(outer[1]));

libcxx/test/std/containers/sequences/vector/vector.special/swap.pass.cpp

int main(int, char**)
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1);
         std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1 == std::vector<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int> c2(a2, a2);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2 == std::vector<int>(a1, a1+sizeof(a1)/sizeof(a1[0])));
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1);
         std::vector<int> c2(a2, a2);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef test_allocator<int> A;
         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1, 1));
#if TEST_STD_VER >= 11
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1);
         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert((c1 == std::vector<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int, min_allocator<int>> c2(a2, a2);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert((c2 == std::vector<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1);
         std::vector<int, min_allocator<int>> c2(a2, a2);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
         swap(c1, c2);
         assert(c1.empty());
-        assert(distance(c1.begin(), c1.end()) == 0);
+        assert(std::distance(c1.begin(), c1.end()) == 0);
         assert(c2.empty());
-        assert(distance(c2.begin(), c2.end()) == 0);
+        assert(std::distance(c2.begin(), c2.end()) == 0);
         assert(is_contiguous_container_asan_correct(c1));
         assert(is_contiguous_container_asan_correct(c2));
     }
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         typedef min_allocator<int> A;
         std::vector<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());