[libcxx] [test] D27021: Fix MSVC warning C4389 "signed/unsigned mismatch", part 8/12.

Add static_cast<std::size_t> when comparing distance() to size(). These replacements were performed programmatically with regex_replace(): const vector<pair<regex, string>> reg_fmt = { { regex(R"(assert$(\w+)\.size\($ == std::distance$(\w+, \w+)$\))"), "assert($1.size() == static_cast<std::size_t>(std::distance($2)))" }, { regex(R"(assert$distance\((\w+\.begin\($, \w+\.end)\) == (\w+)\.size\))"), "assert(static_cast<std::size_t>(distance($1)) == $2.size())" }, { regex(R"(assert$std::distance\((\w+\.\w*begin\($, \w+\.\w*end)\) == (\w+)\.size\))"), "assert(static_cast<std::size_t>(std::distance($1)) == $2.size())" }, }; Also, include <cstddef> when it wasn't already being included. llvm-svn: 288745
author: Stephan T. Lavavej <stl@exchange.microsoft.com> 2016-12-06 01:12:34 +0000
committer: Stephan T. Lavavej <stl@exchange.microsoft.com> 2016-12-06 01:12:34 +0000
commit: fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6 (patch)
tree: 67ea304c455aa91bacfbd7b4be06824ff157ce3c
parent: ad55ee58691b58f3ac36e688fc90808d5cf71e7f (diff)
download: bcm5719-llvm-fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6.tar.gz
bcm5719-llvm-fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6.zip
117 files changed, 1046 insertions, 943 deletions
diff --git a/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp b/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
index 6f79e44454d..27fe3511c47 100644
--- a/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.access/iterator.pass.cpp
@@ -65,8 +65,8 @@ int main()
             V(8, 2)
         };
         std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::map<int, double>::iterator i;
         i = m.begin();
         std::map<int, double>::const_iterator k = i;
@@ -109,10 +109,10 @@ int main()
             V(8, 2)
         };
         const std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::map<int, double>::const_iterator i;
         i = m.begin();
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
@@ -152,8 +152,8 @@ int main()
             V(8, 2)
         };
         std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::map<int, double, std::less<int>, min_allocator<V>>::iterator i;
         i = m.begin();
         std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
@@ -196,10 +196,10 @@ int main()
             V(8, 2)
         };
         const std::map<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
         i = m.begin();
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
diff --git a/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp b/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
index 5f38e926a85..d79dae9e77d 100644
--- a/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/iterator.pass.cpp
@@ -28,6 +28,7 @@
 
 #include <map>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -64,8 +65,8 @@ int main()
             V(8, 2)
         };
         std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::multimap<int, double>::iterator i;
         i = m.begin();
         std::multimap<int, double>::const_iterator k = i;
@@ -109,10 +110,10 @@ int main()
             V(8, 2)
         };
         const std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::multimap<int, double>::const_iterator i;
         i = m.begin();
         for (int j = 1; j <= 8; ++j)
@@ -153,8 +154,8 @@ int main()
             V(8, 2)
         };
         std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::multimap<int, double, std::less<int>, min_allocator<V>>::iterator i;
         i = m.begin();
         std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator k = i;
@@ -198,10 +199,10 @@ int main()
             V(8, 2)
         };
         const std::multimap<int, double, std::less<int>, min_allocator<V>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::multimap<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
         i = m.begin();
         for (int j = 1; j <= 8; ++j)
diff --git a/libcxx/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
index 7b82cea5fbe..590c66801f9 100644
--- a/libcxx/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/insert_initializer_list.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -27,7 +28,7 @@ int main()
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(distance(m.begin(), m.end()) == m.size());
+    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
@@ -46,7 +47,7 @@ int main()
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(distance(m.begin(), m.end()) == m.size());
+    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
diff --git a/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp b/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
index b727345f153..ec17689f29b 100644
--- a/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/iterator.pass.cpp
@@ -28,6 +28,7 @@
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -64,8 +65,8 @@ int main()
             8
         };
         std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::multiset<int>::iterator i;
         i = m.begin();
         std::multiset<int>::const_iterator k = i;
@@ -104,10 +105,10 @@ int main()
             8
         };
         const std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::multiset<int>::const_iterator i;
         i = m.begin();
         for (int j = 1; j <= 8; ++j)
@@ -145,8 +146,8 @@ int main()
             8
         };
         std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::multiset<int, std::less<int>, min_allocator<int>>::iterator i;
         i = m.begin();
         std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
@@ -185,10 +186,10 @@ int main()
             8
         };
         const std::multiset<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::multiset<int, std::less<int>, min_allocator<int>>::const_iterator i;
         i = m.begin();
         for (int j = 1; j <= 8; ++j)
diff --git a/libcxx/test/std/containers/associative/set/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/associative/set/insert_initializer_list.pass.cpp
index 60a6e754e17..490d75905ad 100644
--- a/libcxx/test/std/containers/associative/set/insert_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/insert_initializer_list.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -27,7 +28,7 @@ int main()
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(distance(m.begin(), m.end()) == m.size());
+    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
@@ -45,7 +46,7 @@ int main()
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(distance(m.begin(), m.end()) == m.size());
+    assert(static_cast<std::size_t>(distance(m.begin(), m.end())) == m.size());
     C::const_iterator i = m.cbegin();
     assert(*i == V(1));
     assert(*++i == V(2));
diff --git a/libcxx/test/std/containers/associative/set/iterator.pass.cpp b/libcxx/test/std/containers/associative/set/iterator.pass.cpp
index 4535dce6877..be0a1578d2c 100644
--- a/libcxx/test/std/containers/associative/set/iterator.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/iterator.pass.cpp
@@ -65,8 +65,8 @@ int main()
             8
         };
         std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::set<int>::iterator i;
         i = m.begin();
         std::set<int>::const_iterator k = i;
@@ -104,10 +104,10 @@ int main()
             8
         };
         const std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::set<int>::const_iterator i;
         i = m.begin();
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
@@ -144,8 +144,8 @@ int main()
             8
         };
         std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
         std::set<int, std::less<int>, min_allocator<int>>::iterator i;
         i = m.begin();
         std::set<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
@@ -183,10 +183,10 @@ int main()
             8
         };
         const std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        assert(std::distance(m.begin(), m.end()) == m.size());
-        assert(std::distance(m.cbegin(), m.cend()) == m.size());
-        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        assert(std::distance(m.crbegin(), m.crend()) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
+        assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
         std::set<int, std::less<int>, min_allocator<int>>::const_iterator i;
         i = m.begin();
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
diff --git a/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
index 5c7e855d8b2..93dc7ac9003 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size.pass.cpp
@@ -50,7 +50,7 @@ test(C& c1, int size)
     typename C::size_type c1_osize = c1.size();
     c1.resize(size);
     assert(c1.size() == size);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(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);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
index 48187fdfbaf..50aa2cd9127 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.capacity/resize_size_value.pass.cpp
@@ -50,7 +50,7 @@ test(C& c1, int size, int x)
     typename C::size_type c1_osize = c1.size();
     c1.resize(size, x);
     assert(c1.size() == size);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(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);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
index 6507f58e119..f06067786cf 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -46,7 +47,7 @@ void
 test(C& c1, const C& c2)
 {
     c1.assign(c2.begin(), c2.end());
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
 }
 
@@ -66,7 +67,7 @@ testI(C& c1, const C& c2)
     typedef typename C::const_iterator CI;
     typedef input_iterator<CI> ICI;
     c1.assign(ICI(c2.begin()), ICI(c2.end()));
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
 }
 
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
index e00e0442d22..73636ecb03f 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_size_value.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -47,7 +48,7 @@ test(C& c1, int size, int v)
     typedef typename C::const_iterator CI;
     c1.assign(size, v);
     assert(c1.size() == size);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     for (CI i = c1.begin(); i != c1.end(); ++i)
         assert(*i == v);
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
index 4b9f8856b6c..87445c5b2b6 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_allocator.h"
 #include "test_iterators.h"
@@ -27,8 +28,8 @@ test(InputIterator f, InputIterator l)
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
-    assert(d.size() == std::distance(f, l));
-    assert(distance(d.begin(), d.end()) == d.size());
+    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());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
@@ -41,8 +42,8 @@ test(InputIterator f, InputIterator l)
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
-    assert(d.size() == std::distance(f, l));
-    assert(distance(d.begin(), d.end()) == d.size());
+    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());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
index c8f7759a19d..54227ebc12d 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "test_allocator.h"
@@ -28,8 +29,8 @@ test(InputIterator f, InputIterator l, const Allocator& a)
     typedef typename C::const_iterator const_iterator;
     C d(f, l, a);
     assert(d.get_allocator() == a);
-    assert(d.size() == std::distance(f, l));
-    assert(distance(d.begin(), d.end()) == d.size());
+    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());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i, ++f)
         assert(*i == *f);
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
index 94f758472f8..239c71d993d 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/size.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
@@ -31,7 +32,7 @@ test2(unsigned n)
     C d(n, Allocator());
     assert(DefaultOnly::count == n);
     assert(d.size() == n);
-    assert(distance(d.begin(), d.end()) == d.size());
+    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
@@ -52,7 +53,7 @@ test1(unsigned n)
     C d(n);
     assert(DefaultOnly::count == n);
     assert(d.size() == n);
-    assert(distance(d.begin(), d.end()) == d.size());
+    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == T());
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
index e46a7318ccb..2c8eee7cbe5 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
@@ -25,7 +26,7 @@ test(unsigned n, const T& x)
     typedef typename C::const_iterator const_iterator;
     C d(n, x);
     assert(d.size() == n);
-    assert(distance(d.begin(), d.end()) == d.size());
+    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
index ed8a7e13baa..6706411c253 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/size_value_alloc.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -25,7 +26,7 @@ test(unsigned n, const T& x, const Allocator& a)
     C d(n, x, a);
     assert(d.get_allocator() == a);
     assert(d.size() == n);
-    assert(distance(d.begin(), d.end()) == d.size());
+    assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
     for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
         assert(*i == x);
 }
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
index 713f2159e59..33a0b6df364 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
@@ -51,7 +52,7 @@ test(int P, C& c1)
     CI i = c1.emplace(c1.begin() + P, Emplaceable(1, 2.5));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     assert(*i == Emplaceable(1, 2.5));
 }
 
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
index 9bc5fabb9b4..def032c2705 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter.pass.cpp
@@ -51,7 +51,7 @@ test(int P, C& c1)
     I i = c1.erase(c1.cbegin() + P);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize - 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
index 3290a401371..338c66d81f9 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/erase_iter_iter.pass.cpp
@@ -53,7 +53,7 @@ test(int P, C& c1, int size)
     I i = c1.erase(c1.cbegin() + P, c1.cbegin() + (P + size));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize - size);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
index bd5e98c22f9..f843ff3a5da 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -58,7 +58,7 @@ test(int P, const C& c0, const C& c2)
     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(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
@@ -75,7 +75,7 @@ test(int P, const C& c0, const C& c2)
     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(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
@@ -92,7 +92,7 @@ test(int P, const C& c0, const C& c2)
     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(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
@@ -173,7 +173,7 @@ testI(int P, C& c1, const C& c2)
     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(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
index 0b0c7f66848..4ce8bbdd57d 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_rvalue.pass.cpp
@@ -52,7 +52,7 @@ test(int P, C& c1, int x)
     CI i = c1.insert(c1.begin() + P, MoveOnly(x));
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == MoveOnly(j));
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
index d91f8e33db5..779b9464e07 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_size_value.pass.cpp
@@ -51,7 +51,7 @@ test(int P, C& c1, int size, int x)
     CI i = c1.insert(c1.begin() + P, size, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + size);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
@@ -121,7 +121,7 @@ self_reference_test()
             CI jt = c.cbegin() + j;
             c.insert(it, 5, *jt);
             assert(c.size() == 25);
-            assert(distance(c.begin(), c.end()) == c.size());
+            assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
             it = c.cbegin();
             for (int k = 0; k < i; ++k, ++it)
                 assert(*it == k);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
index 232486778b7..e0c2d0129ef 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_value.pass.cpp
@@ -49,7 +49,7 @@ test(int P, C& c1, int x)
     CI i = c1.insert(c1.begin() + P, x);
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
@@ -103,7 +103,7 @@ self_reference_test()
             CI jt = c.cbegin() + j;
             c.insert(it, *jt);
             assert(c.size() == 21);
-            assert(distance(c.begin(), c.end()) == c.size());
+            assert(static_cast<std::size_t>(distance(c.begin(), c.end())) == c.size());
             it = c.cbegin();
             for (int k = 0; k < i; ++k, ++it)
                 assert(*it == k);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
index 6efbbd4083b..2336b81d4fc 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_back.pass.cpp
@@ -47,7 +47,7 @@ test(C& c1)
     std::size_t c1_osize = c1.size();
     c1.pop_back();
     assert(c1.size() == c1_osize - 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(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);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
index 0dff181baca..3de5586ab92 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/pop_front.pass.cpp
@@ -47,7 +47,7 @@ test(C& c1)
     std::size_t c1_osize = c1.size();
     c1.pop_front();
     assert(c1.size() == c1_osize - 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(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);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
index 82b4940a146..ef9839721a2 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front.pass.cpp
@@ -47,7 +47,7 @@ test(C& c1, int x)
     std::size_t c1_osize = c1.size();
     c1.push_front(x);
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == x);
     ++i;
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
index 33bb2824856..8e734a63934 100644
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.pass.cpp
@@ -50,7 +50,7 @@ test(C& c1, int x)
     std::size_t c1_osize = c1.size();
     c1.push_front(MoveOnly(x));
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     I i = c1.begin();
     assert(*i == MoveOnly(x));
     ++i;
diff --git a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
index 3d11239702c..bad80c279d4 100644
--- a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -25,7 +26,7 @@ test(Iterator first, Iterator last)
 {
     C c(first, last);
     LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == std::distance(first, last));
+    assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
diff --git a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
index 196694d7399..dd4a5c757cb 100644
--- a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -15,6 +15,7 @@
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -26,7 +27,7 @@ test(Iterator first, Iterator last, const typename C::allocator_type& a)
 {
     C c(first, last, a);
     LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == std::distance(first, last));
+    assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
 }
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index 6b823e6a95c..ec4944d1ad1 100644
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -13,6 +13,7 @@
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -26,7 +27,7 @@ test(Iterator first, Iterator last)
 {
     C c(first, last);
     LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == std::distance(first, last));
+    assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
index 08d383d2ba4..b4482ddb272 100644
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -14,6 +14,7 @@
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -27,7 +28,7 @@ test(Iterator first, Iterator last, const A& a)
 {
     C c(first, last, a);
     LIBCPP_ASSERT(c.__invariants());
-    assert(c.size() == std::distance(first, last));
+    assert(c.size() == static_cast<std::size_t>(std::distance(first, last)));
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
     for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first)
         assert(*i == *first);
diff --git a/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp b/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
index 2554e93f056..f99adb52b3f 100644
--- a/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/iterators.pass.cpp
@@ -23,6 +23,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -44,8 +45,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -63,8 +64,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #if TEST_STD_VER >= 11
@@ -84,8 +85,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -104,8 +105,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
index 1b9eb3569eb..5c5827f1532 100644
--- a/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/swap_member.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "../../test_compare.h"
 #include "../../test_hash.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -222,8 +223,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -231,8 +232,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -270,8 +271,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -279,8 +280,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -308,8 +309,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -321,8 +322,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -369,8 +370,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -382,8 +383,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -402,8 +403,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -411,8 +412,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -450,8 +451,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -459,8 +460,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -488,8 +489,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -501,8 +502,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -549,8 +550,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -562,8 +563,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
index 0ef5b26f3c8..b793f093435 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -68,8 +69,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -131,8 +132,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -177,8 +178,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
index e4da30bb4ef..4d92b3d4c2c 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -54,8 +55,8 @@ int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -87,8 +88,8 @@ int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
index 217f5f52358..e86d35b0ac8 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -69,8 +70,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -114,8 +115,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
@@ -160,8 +161,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
@@ -207,8 +208,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c0.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
index d951e1d2f03..0b1d460ef74 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -63,8 +64,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -103,8 +104,8 @@ int main()
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -142,8 +143,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
index 6dd848a56d8..cf83074ae17 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -63,8 +64,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(5)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -103,8 +104,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -142,8 +143,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
index 6249fb0f6b5..bebab0375d8 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -55,8 +56,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -87,8 +88,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -119,8 +120,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == a);
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -152,8 +153,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == a);
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
index 7673f79fb95..9055e3dcd16 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -58,8 +59,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -92,8 +93,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
index 68212915e02..db0010b3401 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -94,8 +95,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
index 126ba242810..c76ce3968ad 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -61,8 +62,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -97,8 +98,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
index e8d3562254c..6cb57d4ff21 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -62,8 +63,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -99,8 +100,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -135,8 +136,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
index c4cd5216115..808d8946a7e 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -50,8 +51,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -91,8 +92,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -117,8 +118,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -158,8 +159,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
index 58c9b5198ee..681c0e95b93 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -64,8 +65,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -105,8 +106,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -147,8 +148,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -188,8 +189,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
index 7c38ed61923..3dbcf4d1582 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -20,6 +20,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -93,8 +94,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -126,8 +127,8 @@ int main()
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -161,8 +162,8 @@ int main()
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == a);
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
index c2214921347..426b5dac18b 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -62,8 +63,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -98,8 +99,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
index 91ff7180a60..ea058bdff1f 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -64,8 +65,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -101,8 +102,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
index 0698d4c562a..1fdde2b1215 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -65,8 +66,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -103,8 +104,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
index 890ed2e8bca..f95efbe5f53 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -23,6 +23,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -67,8 +68,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -106,8 +107,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -144,8 +145,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
index 085ee43c955..f65b5366f1d 100644
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -222,8 +223,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -231,8 +232,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -270,8 +271,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -279,8 +280,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -308,8 +309,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -321,8 +322,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -369,8 +370,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -382,8 +383,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -402,8 +403,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -411,8 +412,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -450,8 +451,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -459,8 +460,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -488,8 +489,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -501,8 +502,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -549,8 +550,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -562,8 +563,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
index 14af93fec73..22aa3a0c051 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/iterators.pass.cpp
@@ -23,6 +23,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -44,8 +45,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
         i = c.begin();
         i->second = "ONE";
@@ -66,8 +67,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #if TEST_STD_VER >= 11
@@ -87,8 +88,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
         i = c.begin();
         i->second = "ONE";
@@ -110,8 +111,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index ede4738378d..3d3832a2fe3 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -62,8 +63,8 @@ void test(const C& c)
     i = eq.first;
     assert(i->first == 4);
     assert(i->second == "four");
-    assert(std::distance(c.begin(), c.end()) == c.size());
-    assert(std::distance(c.cbegin(), c.cend()) == c.size());
+    assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+    assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
 }
 
diff --git a/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
index 50571cf544d..6020f058e3a 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
@@ -44,8 +45,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -53,8 +54,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -92,8 +93,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -101,8 +102,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -130,8 +131,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -145,8 +146,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -193,8 +194,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -208,8 +209,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -229,8 +230,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -238,8 +239,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -277,8 +278,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -286,8 +287,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -315,8 +316,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -330,8 +331,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -378,8 +379,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -393,8 +394,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -414,8 +415,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -423,8 +424,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -462,8 +463,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -471,8 +472,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -500,8 +501,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -515,8 +516,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -563,8 +564,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -578,8 +579,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
index 6efe93437f7..62e756cda3b 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -82,8 +83,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -159,8 +160,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -219,8 +220,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
index 0d3b4453dd4..6d27dec98ea 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -79,8 +80,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -136,8 +137,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
index a89c9dbb4b3..b9b8723452f 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -89,8 +90,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -154,8 +155,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -219,8 +220,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -285,8 +286,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
index a5777be918e..5e314db06b8 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -77,8 +78,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -131,8 +132,8 @@ int main()
         assert(c.get_allocator() ==
                (other_allocator<std::pair<const int, std::string> >(-2)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -184,8 +185,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
index bb577ea15cf..cb221abd415 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -77,8 +78,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(5)));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -131,8 +132,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -184,8 +185,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
index 486d9dfabea..445fd2d82bb 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -74,8 +75,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -128,8 +129,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -183,8 +184,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == HF());
@@ -239,8 +240,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == hf);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
index 69fd0a35d6f..92a43b482bd 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -77,8 +78,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -133,8 +134,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
index 4dc7c91794d..d7afafcaec9 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -78,8 +79,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -135,8 +136,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
index 77f91bb9f56..9842a4bbdaf 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -80,8 +81,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -138,8 +139,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
index 79e64705fa0..244c3f5c657 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -81,8 +82,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -140,8 +141,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -199,8 +200,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
index ccd4237cda3..cc4e32e83cb 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.get_allocator() ==
                (test_allocator<std::pair<const int, std::string> >(10)));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -119,8 +120,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -159,8 +160,8 @@ int main()
         assert(c.get_allocator() ==
                (min_allocator<std::pair<const int, std::string> >()));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -219,8 +220,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
index b43ec080639..878ef598f8c 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -86,8 +87,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -150,8 +151,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -215,8 +216,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -279,8 +280,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
index 943b3a833bd..11465edae3e 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -20,6 +20,7 @@
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -78,8 +79,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -134,8 +135,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -191,8 +192,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == HF());
@@ -249,8 +250,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == hf);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
index 6385a9e457b..bc16de5a2ab 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -81,8 +82,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
@@ -139,8 +140,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
index 185bd5390d0..9ecfc5b7926 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -83,8 +84,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -142,8 +143,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
index 31153112118..7c4c535783d 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -84,8 +85,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -144,8 +145,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
index 7e2814fd5a8..909c1c3080e 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -23,6 +23,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -86,8 +87,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -147,8 +148,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
@@ -208,8 +209,8 @@ int main()
         i = eq.first;
         assert(i->first == 4);
         assert(i->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
index 9da1e71cba0..57e6b98c747 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -73,8 +74,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #if TEST_STD_VER >= 11
     {
@@ -119,8 +120,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #endif
 #if TEST_STD_VER >= 14
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
index f061d858e3f..0da6f8a564b 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -81,8 +82,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(2) == 2);
         assert(c.size() == 4);
@@ -104,8 +105,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(2) == 0);
         assert(c.size() == 4);
@@ -127,8 +128,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(4) == 1);
         assert(c.size() == 3);
@@ -145,8 +146,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(4) == 0);
         assert(c.size() == 3);
@@ -163,8 +164,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(1) == 2);
         assert(c.size() == 1);
@@ -173,8 +174,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(1) == 0);
         assert(c.size() == 1);
@@ -183,22 +184,22 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(3) == 1);
         assert(c.size() == 0);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 0);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 0);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #if TEST_STD_VER >= 11
     {
@@ -244,8 +245,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(2) == 2);
         assert(c.size() == 4);
@@ -267,8 +268,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(2) == 0);
         assert(c.size() == 4);
@@ -290,8 +291,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(4) == 1);
         assert(c.size() == 3);
@@ -308,8 +309,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(4) == 0);
         assert(c.size() == 3);
@@ -326,8 +327,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(1) == 2);
         assert(c.size() == 1);
@@ -336,8 +337,8 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(1) == 0);
         assert(c.size() == 1);
@@ -346,22 +347,22 @@ int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(3) == 1);
         assert(c.size() == 0);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 0);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         assert(c.erase(3) == 0);
         assert(c.size() == 0);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 0);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
     {
     typedef std::unordered_multimap<int, int> C;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
index 110cc4542b4..f239af4af31 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
@@ -68,8 +69,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         k = c.erase(i, j);
         assert(c.size() == 4);
@@ -91,8 +92,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         k = c.erase(c.cbegin(), c.cend());
         assert(c.size() == 0);
@@ -145,8 +146,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         k = c.erase(i, j);
         assert(c.size() == 4);
@@ -168,8 +169,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
 
         k = c.erase(c.cbegin(), c.cend());
         assert(c.size() == 0);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
index 851b36e51ca..e0b1c694186 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "min_allocator.h"
@@ -67,8 +68,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #if TEST_STD_VER >= 11
     {
@@ -114,8 +115,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
index 967ad369da3..483f2205055 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -19,6 +19,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "min_allocator.h"
@@ -67,8 +68,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #if TEST_STD_VER >= 11
     {
@@ -114,8 +115,8 @@ int main()
         k = eq.first;
         assert(k->first == 4);
         assert(k->second == "four");
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
     }
 #endif
 }
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
index 00f13b47616..4bdd9b076e3 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -43,8 +44,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -52,8 +53,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -91,8 +92,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -100,8 +101,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -129,8 +130,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -144,8 +145,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -192,8 +193,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -207,8 +208,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -228,8 +229,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -237,8 +238,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -276,8 +277,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -285,8 +286,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -314,8 +315,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -329,8 +330,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -377,8 +378,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -392,8 +393,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -413,8 +414,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -422,8 +423,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -461,8 +462,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -470,8 +471,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -499,8 +500,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -514,8 +515,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -562,8 +563,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -577,8 +578,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
index 70d0c5adfb3..d87099cdaf8 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/iterators.pass.cpp
@@ -22,6 +22,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -43,8 +44,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -62,8 +63,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #if TEST_STD_VER >= 11
@@ -83,8 +84,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -103,8 +104,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
index 40ef9035fa6..322e9dfd796 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -223,8 +224,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -232,8 +233,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -271,8 +272,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -280,8 +281,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -309,8 +310,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -322,8 +323,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -370,8 +371,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -383,8 +384,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -404,8 +405,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -413,8 +414,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -452,8 +453,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -461,8 +462,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -490,8 +491,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -503,8 +504,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -551,8 +552,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -564,8 +565,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
index b0a110f0bb5..b7557c43718 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -75,8 +76,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -147,8 +148,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -201,8 +202,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
index 2835cd444c3..3e42305309f 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -54,8 +55,8 @@ int main()
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -87,8 +88,8 @@ int main()
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
index 274c0397483..658bb93e2b1 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -76,8 +77,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -121,8 +122,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -166,8 +167,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -212,8 +213,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -257,8 +258,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
index b9d6785db5a..3ba35d7a548 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -69,8 +70,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -116,8 +117,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -162,8 +163,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
index 2b47200d25d..2c018e07734 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -69,8 +70,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(5));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -116,8 +117,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
index e51955cb4f7..ced52b5e6b4 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -53,8 +54,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -84,8 +85,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -118,8 +119,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -153,8 +154,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
index 7ffbae79768..845139f98d9 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -56,8 +57,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -89,8 +90,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
index 87dd0a8b572..4dc78bd261c 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -58,8 +59,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -92,8 +93,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
index 7f630d8eed9..f331208596b 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -94,8 +95,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
index eb50a4941f2..17f064f4628 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -60,8 +61,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -96,8 +97,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
index fc4ea964f40..71384f40283 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -57,8 +58,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -97,8 +98,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -133,8 +134,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -173,8 +174,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
index aad2d7d2e6e..bc804b42e22 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -71,8 +72,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -112,8 +113,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -154,8 +155,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -195,8 +196,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
index 9c6f2412680..a2ee746791d 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -19,6 +19,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -56,8 +57,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -89,8 +90,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -123,8 +124,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -158,8 +159,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
index 2ee8be120f1..f09f9c860bd 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -94,8 +95,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
index af1e15bd4ba..167216bf6be 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -61,8 +62,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -97,8 +98,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
index 20e048a98e1..8720f59a8fd 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -62,8 +63,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -99,8 +100,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
index f75f84e8496..3373dd0d4c5 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -64,8 +65,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -102,8 +103,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
index 7d0941ade31..dc22cae4f90 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -223,8 +224,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -232,8 +233,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -271,8 +272,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -280,8 +281,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -309,8 +310,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -322,8 +323,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -370,8 +371,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -383,8 +384,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -404,8 +405,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -413,8 +414,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -452,8 +453,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -461,8 +462,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -490,8 +491,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -503,8 +504,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -551,8 +552,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 6);
@@ -564,8 +565,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp b/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
index 1eddc9038b0..9c780e10980 100644
--- a/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/iterators.pass.cpp
@@ -22,6 +22,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -43,8 +44,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -62,8 +63,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #if TEST_STD_VER >= 11
@@ -83,8 +84,8 @@ int main()
         C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::iterator i;
     }
     {
@@ -103,8 +104,8 @@ int main()
         const C c(a, a + sizeof(a)/sizeof(a[0]));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         C::const_iterator i;
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp b/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
index e0f1699a9eb..4fb055e742c 100644
--- a/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/swap_member.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -223,8 +224,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -232,8 +233,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -271,8 +272,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -280,8 +281,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -309,8 +310,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -322,8 +323,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -370,8 +371,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -383,8 +384,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -404,8 +405,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -413,8 +414,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -452,8 +453,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -461,8 +462,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -490,8 +491,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -503,8 +504,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -551,8 +552,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -564,8 +565,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
index a1923d6b845..0859d8edc85 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -67,8 +68,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -130,8 +131,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -176,8 +177,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
index a99e74af594..2db01a21eaa 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -54,8 +55,8 @@ int main()
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -87,8 +88,8 @@ int main()
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
index b4d54cc378a..78a376335c3 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -68,8 +69,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(4));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -113,8 +114,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -158,8 +159,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -204,8 +205,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
index ba0d8e36398..06dcc552db0 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -61,8 +62,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -100,8 +101,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == other_allocator<int>(-2));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -138,8 +139,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
index 1e0344daa30..538e349602c 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -61,8 +62,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(5));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -100,8 +101,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
index 088e61600f3..eea61c7ab46 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -53,8 +54,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -84,8 +85,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -118,8 +119,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -153,8 +154,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
index a9a721d62fc..95baa3df285 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -56,8 +57,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -89,8 +90,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
index b0cded7ed28..108d67b66b2 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -58,8 +59,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -92,8 +93,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
index f21d526fe5e..5cb4d499a93 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -94,8 +95,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
index 54de7e6b281..7c1cbc8667d 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -60,8 +61,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -96,8 +97,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
index b716d60c2af..c5200bf7511 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -57,8 +58,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -97,8 +98,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -133,8 +134,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(c.load_factor() == 0);
         assert(c.max_load_factor() == 1);
 
@@ -173,8 +174,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
index 2342bbc130b..4d2830b3a80 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -62,8 +63,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(12));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -103,8 +104,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
@@ -145,8 +146,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
index e10d32c5e16..5bcc288aacb 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -19,6 +19,7 @@
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -56,8 +57,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -89,8 +90,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -123,8 +124,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -158,8 +159,8 @@ int main()
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
index 1db71e791a5..8900cafc485 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -59,8 +60,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -94,8 +95,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
index ecddff689ed..315ded7a0df 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -61,8 +62,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -97,8 +98,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
index b6f33ab8411..3f5c829f726 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -62,8 +63,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -99,8 +100,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
index 7cd465c4b36..f0d063d2cca 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
@@ -64,8 +65,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == test_allocator<int>(10));
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
@@ -102,8 +103,8 @@ int main()
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == min_allocator<int>());
         assert(!c.empty());
-        assert(std::distance(c.begin(), c.end()) == c.size());
-        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
+        assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
     }
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
index cb543b6446b..20d325dac1d 100644
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
@@ -17,6 +17,7 @@
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
@@ -42,8 +43,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -51,8 +52,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -90,8 +91,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -99,8 +100,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -128,8 +129,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -141,8 +142,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -189,8 +190,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(1));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -202,8 +203,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(2));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 
@@ -223,8 +224,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -232,8 +233,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -271,8 +272,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -280,8 +281,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -309,8 +310,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -322,8 +323,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -370,8 +371,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(2));
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -383,8 +384,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(1));
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #if TEST_STD_VER >= 11
@@ -404,8 +405,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -413,8 +414,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -452,8 +453,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         LIBCPP_ASSERT(c2.bucket_count() == 0);
@@ -461,8 +462,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -490,8 +491,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -503,8 +504,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
     {
@@ -551,8 +552,8 @@ int main()
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc());
-        assert(std::distance(c1.begin(), c1.end()) == c1.size());
-        assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size());
+        assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size());
         assert(c1.max_load_factor() == 2);
 
         assert(c2.bucket_count() >= 4);
@@ -564,8 +565,8 @@ int main()
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc());
-        assert(std::distance(c2.begin(), c2.end()) == c2.size());
-        assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
+        assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
         assert(c2.max_load_factor() == 1);
     }
 #endif
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
index cb0792ab23b..1b10224cd9e 100644
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -16,6 +16,7 @@
 #include <string>
 #include <iterator>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
@@ -32,7 +33,7 @@ test(It first, It last)
     typedef typename S::allocator_type A;
     S s2(first, last);
     LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == std::distance(first, last));
+    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
@@ -49,7 +50,7 @@ test(It first, It last, const A& a)
     typedef typename S::traits_type T;
     S s2(first, last, a);
     LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == std::distance(first, last));
+    assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
     for (It it = first; it != last; ++it, ++i)
         assert(s2[i] == *it);
author	Stephan T. Lavavej <stl@exchange.microsoft.com>	2016-12-06 01:12:34 +0000
committer	Stephan T. Lavavej <stl@exchange.microsoft.com>	2016-12-06 01:12:34 +0000
commit	fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6 (patch)
tree	67ea304c455aa91bacfbd7b4be06824ff157ce3c
parent	ad55ee58691b58f3ac36e688fc90808d5cf71e7f (diff)
download	bcm5719-llvm-fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6.tar.gz bcm5719-llvm-fbfb2ab63e94f1b0c248cd810ae3fb35889d99b6.zip