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

[STL_MSFT]

Summary

[libcxx] [test] 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.

[EricWF]

LGTM.

[STL_MSFT]

Thanks, r288745.

test/std/containers/associative/map/map.access/iterator.pass.cpp

int main()
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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;
         assert(i == k);
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
         {
             assert(i->first == j);
             assert(i->second == 1);
int main()
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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)
         {
             assert(i->first == j);
             assert(i->second == 1);
         }
     }
#if TEST_STD_VER >= 11
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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;
         assert(i == k);
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
         {
             assert(i->first == j);
             assert(i->second == 1);
#if TEST_STD_VER >= 11
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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)
         {
             assert(i->first == j);
             assert(i->second == 1);
         }
     }

test/std/containers/associative/multimap/iterator.pass.cpp

 //
 // const_iterator         cbegin()  const;
 // const_iterator         cend()    const;
 // const_reverse_iterator crbegin() const;
 // const_reverse_iterator crend()   const;
 
 #include <map>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::pair<const int, double> V;
int main()
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
             for (double d = 1; d <= 2; d += .5, ++i)
             {
                 assert(i->first == j);
int main()
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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)
             for (double d = 1; d <= 2; d += .5, ++i)
             {
                 assert(i->first == j);
                 assert(i->second == d);
             }
#if TEST_STD_VER >= 11
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
             for (double d = 1; d <= 2; d += .5, ++i)
             {
                 assert(i->first == j);
#if TEST_STD_VER >= 11
             V(7, 1),
             V(7, 1.5),
             V(7, 2),
             V(8, 1),
             V(8, 1.5),
             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)
             for (double d = 1; d <= 2; d += .5, ++i)
             {
                 assert(i->first == j);
                 assert(i->second == d);
             }

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

 // <set>
 
 // class multiset
 
 // void insert(initializer_list<value_type> il);
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
     typedef std::multiset<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(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));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #if TEST_STD_VER >= 11
     {
     typedef std::multiset<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(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));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 #endif
 }

test/std/containers/associative/multiset/iterator.pass.cpp

 //
 // const_iterator         cbegin()  const;
 // const_iterator         cend()    const;
 // const_reverse_iterator crbegin() const;
 // const_reverse_iterator crend()   const;
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef int V;
int main()
             7,
             7,
             7,
             8,
             8,
             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;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
             for (int n = 0; n < 3; ++n, ++i)
                 assert(*i == j);
     }
int main()
             7,
             7,
             7,
             8,
             8,
             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)
             for (int k = 0; k < 3; ++k, ++i)
                 assert(*i == j);
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
             7,
             7,
             7,
             8,
             8,
             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;
         assert(i == k);
         for (int j = 1; j <= 8; ++j)
             for (int n = 0; n < 3; ++n, ++i)
                 assert(*i == j);
     }
#if TEST_STD_VER >= 11
             7,
             7,
             7,
             8,
             8,
             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)
             for (int k = 0; k < 3; ++k, ++i)
                 assert(*i == j);
     }
 #endif
 #if TEST_STD_VER > 11

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

 // <set>
 
 // class set
 
 // void insert(initializer_list<value_type> il);
 
 #include <set>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
     typedef std::set<int> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(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));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 #if TEST_STD_VER >= 11
     {
     typedef std::set<int, std::less<int>, min_allocator<int>> C;
     typedef C::value_type V;
     C m = {10, 8};
     m.insert({1, 2, 3, 4, 5, 6});
     assert(m.size() == 8);
-    assert(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));
     assert(*++i == V(3));
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
     assert(*++i == V(8));
     assert(*++i == V(10));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/associative/set/iterator.pass.cpp

int main()
             7,
             7,
             7,
             8,
             8,
             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;
         assert(i == k);
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
     {
int main()
             7,
             7,
             7,
             8,
             8,
             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)
             assert(*i == j);
     }
 #if TEST_STD_VER >= 11
     {
         typedef int V;
#if TEST_STD_VER >= 11
             7,
             7,
             7,
             8,
             8,
             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;
         assert(i == k);
         for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
     {
#if TEST_STD_VER >= 11
             7,
             7,
             7,
             8,
             8,
             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)
             assert(*i == j);
     }
 #endif
 #if TEST_STD_VER > 11
     { // N3644 testing

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

 template <class C>
 void
 test(C& c1, int size)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size);
     assert(c1.size() == 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);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == 0);
 }
 
 template <class C>

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

 template <class C>
 void
 test(C& c1, int size, int x)
 {
     typedef typename C::const_iterator CI;
     typename C::size_type c1_osize = c1.size();
     c1.resize(size, x);
     assert(c1.size() == 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);
     for (std::size_t j = c1_osize; j < c1.size(); ++j, ++i)
         assert(*i == x);
 }
 
 template <class C>

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator>
 //   void assign(InputIterator f, InputIterator l);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
make(int size, int start = 0 )
     return c;
 }
 
 template <class C>
 void
 test(C& c1, const C& c2)
 {
     c1.assign(c2.begin(), c2.end());
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {
     C c1 = make<C>(N, start);
     C c2 = make<C>(M);
     test(c1, c2);
 }
 
 template <class C>
 void
 testI(C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
     typedef 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);
 }
 
 template <class C>
 void
 testNI(int start, int N, int M)
 {
     C c1 = make<C>(N, start);

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // void assign(size_type n, const value_type& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )

 
 template <class C>
 void
 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);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator> deque(InputIterator f, InputIterator l);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::allocator<T> Allocator;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
-    assert(d.size() == 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);
 }
 
 template <class Allocator, class InputIterator>
 void
 test(InputIterator f, InputIterator l)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l);
-    assert(d.size() == 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);
 }
 
 int main()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // template <class InputIterator>
 //   deque(InputIterator f, InputIterator l, const allocator_type& a);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class InputIterator, class Allocator>
 void
 test(InputIterator f, InputIterator l, const Allocator& a)
 {
     typedef typename std::iterator_traits<InputIterator>::value_type T;
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(f, l, a);
     assert(d.get_allocator() == a);
-    assert(d.size() == 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);
 }
 
 int main()
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // explicit deque(size_type n);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test2(unsigned n)
 {
 #if TEST_STD_VER > 11
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n, Allocator());
     assert(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());
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
     assert(DefaultOnly::count == 0);
 #endif
 }
 
 template <class T, class Allocator>
 void
 test1(unsigned n)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     assert(DefaultOnly::count == 0);
     {
     C d(n);
     assert(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());
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     }
     assert(DefaultOnly::count == 0);
 }
 

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(size_type n, const value_type& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(unsigned n, const T& x)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x);
     assert(d.size() == n);
-    assert(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);
 }
 
 int main()
 {
     test<int, std::allocator<int> >(0, 5);
     test<int, std::allocator<int> >(1, 10);

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // deque(size_type n, const value_type& v, const allocator_type& a);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test(unsigned n, const T& x, const Allocator& a)
 {
     typedef std::deque<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     C d(n, x, a);
     assert(d.get_allocator() == a);
     assert(d.size() == n);
-    assert(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);
 }
 
 int main()
 {
     {
     std::allocator<int> a;

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

 // <deque>
 
 // template <class... Args> iterator emplace(const_iterator p, Args&&... args);
 
 // UNSUPPORTED: c++98, c++03
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
 
 template <class C>
 C
 make(int size, int start = 0 )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 template <class C>
 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_back();
     assert(c1.size() == c1_osize - 1);
-    assert(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);
 }
 
 template <class C>
 void
 testN(int start, int N)

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

 template <class C>
 void
 test(C& c1)
 {
     typedef typename C::iterator I;
     std::size_t c1_osize = c1.size();
     c1.pop_front();
     assert(c1.size() == c1_osize - 1);
-    assert(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);
 }
 
 template <class C>
 void
 testN(int start, int N)

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

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

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

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

test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // template <class InputIter> vector(InputIter first, InputIter last);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C, class Iterator>
 void
 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);
 }
 
 int main()
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);

test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp

 // <vector>
 // vector<bool>
 
 // template <class InputIter> vector(InputIter first, InputIter last,
 //                                   const allocator_type& a);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class C, class Iterator>
 void
 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);
 }
 
 int main()
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);

test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // template <class InputIter> vector(InputIter first, InputIter last);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C, class Iterator>
 void
 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);
 }
 
 int main()
 {
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};

test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // template <class InputIter> vector(InputIter first, InputIter last,
 //                                   const allocator_type& a);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C, class Iterator, class A>
 void
 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);
 }
 
 #if TEST_STD_VER >= 11
 
 template <class T>

test/std/containers/unord/unord.map/iterators.pass.cpp

 // const_iterator begin()  const {return __table_.begin();}
 // const_iterator end()    const {return __table_.end();}
 // const_iterator cbegin() const {return __table_.begin();}
 // const_iterator cend()   const {return __table_.end();}
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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;
     }
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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;
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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
 #if TEST_STD_VER > 11
     { // N3644 testing
         typedef std::unordered_map<int,double> C;
         C::iterator ii1{}, ii2{};
         C::iterator ii4 = ii1;

test/std/containers/unord/unord.map/swap_member.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // void swap(unordered_map& __u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(3));
         C c2(0, Hash(2), Compare(2), Alloc(3));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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
 }

test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp

 // class unordered_map
 
 // unordered_map& operator=(const unordered_map& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<const int, std::string> P;
         const P a[] =
         {
int main()
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/assign_init.pass.cpp

 // class unordered_map
 
 // unordered_map& operator=(initializer_list<value_type> il);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
                     P(2, "four"),
                 };
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
                     P(2, "four"),
                 };
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp

 // class unordered_map
 
 // unordered_map& operator=(unordered_map&& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_map<int, std::string,
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};

test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp

 
 // unordered_map(const unordered_map& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<std::pair<const int, std::string> >
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp

 
 // unordered_map(const unordered_map& u, const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/init.pass.cpp

 // class unordered_map
 
 // unordered_map(initializer_list<value_type> il);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
#if TEST_STD_VER > 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
     {
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
         typedef test_compare<std::equal_to<int>> Comp;
#if TEST_STD_VER > 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == test_hash<std::hash<int> >()));
         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);
     }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp

 
 // unordered_map(initializer_list<value_type> il, size_type n);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp

 
 // unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp

 // unordered_map(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp

 // unordered_map(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql, const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp

 
 // UNSUPPORTED: c++98, c++03
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<std::pair<const int, std::string> >
                                    > C;
         C c0(7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
             min_allocator<std::pair<const int, std::string> >()
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};

test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp

 
 // unordered_map(unordered_map&& u, const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::pair<int, std::string> P;
         typedef explicit_allocator<std::pair<const int, std::string>> A;
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

 
 // template <class InputIterator>
 //     unordered_map(InputIterator first, InputIterator last);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
#if TEST_STD_VER > 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == HF());
         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);
     }
     {
         typedef std::pair<int, std::string> P;
         typedef test_allocator<std::pair<const int, std::string>> A;
         typedef test_hash<std::hash<int>> HF;
         typedef test_compare<std::equal_to<int>> Comp;
#if TEST_STD_VER > 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         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);
     }
 #endif
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

 // template <class InputIterator>
 //     unordered_map(InputIterator first, InputIterator last, size_type n);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

 //     unordered_map(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

 //     unordered_map(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

 //                   const hasher& hf, const key_equal& eql,
 //                   const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_map<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
         assert(c.at(3) == "three");
         assert(c.at(4) == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // void swap(unordered_map& __u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(3));
         C c2(0, Hash(2), Compare(2), Alloc(3));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.at(40) == "forty");
         assert(c1.at(50) == "fifty");
         assert(c1.at(60) == "sixty");
         assert(c1.at(70) == "seventy");
         assert(c1.at(80) == "eighty");
         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);
         assert(c2.size() == 4);
         assert(c2.at(1) == "one");
         assert(c2.at(2) == "two");
         assert(c2.at(3) == "three");
         assert(c2.at(4) == "four");
         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
 }

test/std/containers/unord/unord.multimap/iterators.pass.cpp

 // const_iterator begin()  const {return __table_.begin();}
 // const_iterator end()    const {return __table_.end();}
 // const_iterator cbegin() const {return __table_.begin();}
 // const_iterator cend()   const {return __table_.end();}
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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";
         assert(i->second == "ONE");
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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";
         assert(i->second == "ONE");
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(1, "one"),
             P(2, "two"),
             P(3, "three"),
             P(4, "four"),
             P(1, "four"),
             P(2, "four"),
         };
         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
 #if TEST_STD_VER > 11
     { // N3644 testing
         typedef std::unordered_multimap<int,double> C;
         C::iterator ii1{}, ii2{};
         C::iterator ii4 = ii1;

test/std/containers/unord/unord.multimap/rehash.pass.cpp

 
 // void rehash(size_type n);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
   assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
void test(const C& c)
     i = eq.first;
     assert(i->first == 3);
     assert(i->second == "three");
     eq = c.equal_range(4);
     assert(std::distance(eq.first, eq.second) == 1);
     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);
 }
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;

test/std/containers/unord/unord.multimap/swap_member.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // void swap(unordered_multimap& __u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
 
 #include "min_allocator.h"
 
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp

 // class unordered_multimap
 
 // unordered_multimap& operator=(const unordered_multimap& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(i->second == "three");
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<const int, std::string> P;
         const P a[] =
         {
int main()
         assert(i->second == "three");
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(i->second == "three");
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_init.pass.cpp

 // class unordered_multimap
 
 // unordered_multimap& operator=(initializer_list<value_type> il);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp

 // class unordered_multimap
 
 // unordered_multimap& operator=(unordered_multimap&& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
     {
         typedef test_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
     {
         typedef other_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<std::pair<const int, std::string> > A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
         std::unordered_multimap<int, int>::iterator i = s1.begin();

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp

 
 // unordered_multimap(const unordered_multimap& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<std::pair<const int, std::string> >
#if TEST_STD_VER >= 11
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp

 
 // unordered_multimap(const unordered_multimap& u, const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(i->second == "three");
         ++i;
         assert(i->first == 4);
         assert(i->second == "four");
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init.pass.cpp

 // class unordered_multimap
 
 // unordered_multimap(initializer_list<value_type> il);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER > 11
     {
#if TEST_STD_VER > 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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());
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
     }
     {
#if TEST_STD_VER > 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
     }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp

 
 // unordered_multimap(initializer_list<value_type> il, size_type n);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp

 
 // unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp

 // unordered_multimap(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp

 // unordered_multimap(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql, const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp

 
 // unordered_multimap(unordered_multimap&& u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
 
         assert(c0.empty());
     }
#if TEST_STD_VER >= 11
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_multimap<int, std::string,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 
         assert(c0.empty());
     }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp

 
 #include <iostream>
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(12)));
 
         assert(c0.empty());
     }
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
 
         assert(c0.empty());
     }
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 
         assert(c0.empty());
     }
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});
 
         assert(c0.empty());
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

 
 // template <class InputIterator>
 //     unordered_multimap(InputIterator first, InputIterator last);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER > 11
     {
#if TEST_STD_VER > 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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());
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
     }
     {
#if TEST_STD_VER > 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         assert(c.get_allocator() == a);
         assert(!(c.get_allocator() == A()));
     }
 #endif
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

 // template <class InputIterator>
 //     unordered_multimap(InputIterator first, InputIterator last, size_type n);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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> >());
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

 //     unordered_multimap(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >());
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

 //     unordered_multimap(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

 //                   const hasher& hf, const key_equal& eql,
 //                   const allocator_type& a);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
int main()
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
     }
 #if TEST_STD_VER >= 11
     {
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
     }
     {
         typedef explicit_allocator<std::pair<const int, std::string>> A;
#if TEST_STD_VER >= 11
         i = eq.first;
         assert(i->first == 3);
         assert(i->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert(c.get_allocator() == A{});;
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_const_iter.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // iterator erase(const_iterator p)
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 struct TemplateConstructor
 {
     template<typename T>
     TemplateConstructor (const T&) {}
 };
int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
#if TEST_STD_VER >= 11
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
     {
     //  This is LWG #2059
         typedef TemplateConstructor T;
         typedef std::unordered_multimap<T, int, Hash> C;
         typedef C::iterator I;

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_key.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type erase(const key_type& k);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 #if TEST_STD_VER >= 11
 template <typename Unordered>
 bool only_deletions ( const Unordered &whole, const Unordered &part ) {
     typename Unordered::const_iterator w = whole.begin();
     typename Unordered::const_iterator p = part.begin();
int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
#if TEST_STD_VER >= 11
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         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;
     C m, m2;
     for ( int i = 0; i < 10; ++i ) {
         for (int j = 0; j < 2; ++j ) {
             m.insert (std::make_pair(i,j));
             m2.insert(std::make_pair(i,j));

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/erase_range.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // iterator erase(const_iterator first, const_iterator last)
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         assert(k == c.end());
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
#if TEST_STD_VER >= 11
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         eq = c.equal_range(1);
         assert(std::distance(eq.first, eq.second) == 2);
         k = eq.first;
         assert(k->first == 1);
         assert(k->second == "one");
         ++k;
         assert(k->first == 1);
         assert(k->second == "four");
         eq = c.equal_range(3);
         assert(std::distance(eq.first, eq.second) == 1);
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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);
         assert(k == c.end());
     }
 #endif
 }

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_init.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // void insert(initializer_list<value_type> il);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         C c;
         c.insert(
#if TEST_STD_VER >= 11
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
 }

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp

 // class unordered_multimap
 
 // template <class InputIterator>
 //     void insert(InputIterator first, InputIterator last);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multimap<int, std::string> C;
int main()
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
#if TEST_STD_VER >= 11
         k = eq.first;
         assert(k->first == 3);
         assert(k->second == "three");
         eq = c.equal_range(4);
         assert(std::distance(eq.first, eq.second) == 1);
         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
 }

test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // void swap(unordered_multimap& __u);
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
int main()
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<std::pair<const int, std::string> > Alloc;
         typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
         typedef std::pair<int, std::string> P;
#if TEST_STD_VER >= 11
         assert(c1.find(40)->second == "forty");
         assert(c1.find(50)->second == "fifty");
         assert(c1.find(60)->second == "sixty");
         assert(c1.find(70)->second == "seventy");
         assert(c1.find(80)->second == "eighty");
         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);
         assert(c2.size() == 6);
         assert(c2.find(1)->second == "one");
         assert(next(c2.find(1))->second == "four");
         assert(c2.find(2)->second == "two");
         assert(next(c2.find(2))->second == "four");
         assert(c2.find(3)->second == "three");
         assert(c2.find(4)->second == "four");
         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
 }

test/std/containers/unord/unord.multiset/iterators.pass.cpp

 // iterator       end();
 // const_iterator begin()  const;
 // const_iterator end()    const;
 // const_iterator cbegin() const;
 // const_iterator cend()   const;
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_multiset<int> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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;
     }
     {
         typedef std::unordered_multiset<int> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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;
     }
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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
 #if TEST_STD_VER > 11
     { // N3644 testing
         typedef std::unordered_multiset<int> C;
         C::iterator ii1{}, ii2{};
         C::iterator ii4 = ii1;

test/std/containers/unord/unord.multiset/swap_member.pass.cpp

 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // void swap(unordered_multiset& __u);
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // unordered_multiset& operator=(const unordered_multiset& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_multiset<int> C;
         typedef int P;
         P a[] =
         {
int main()
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_init.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // unordered_multiset& operator=(initializer_list<value_type> il);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
                     P(2)
                 };
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
                     P(2)
                 };
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // unordered_multiset& operator=(unordered_multiset&& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef other_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef test_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef min_allocator<int> A;
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         std::unordered_multiset<int> s1 = {1, 2, 3};
         std::unordered_multiset<int>::iterator i = s1.begin();

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp

 // class unordered_multiset
 
 // unordered_multiset(const unordered_multiset& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<int>
#if TEST_STD_VER >= 11
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp

 // class unordered_multiset
 
 // unordered_multiset(const unordered_multiset& u, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // unordered_multiset(initializer_list<value_type> il);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
#if TEST_STD_VER > 11
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
         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);
     }
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
#if TEST_STD_VER > 11
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         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);
     }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp

 // class unordered_multiset
 
 // unordered_multiset(initializer_list<value_type> il, size_type n);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp

 
 // unordered_multiset(initializer_list<value_type> il, size_type n,
 //               const hasher& hf);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp

 
 // unordered_multiset(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp

 
 // unordered_multiset(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp

 // class unordered_multiset
 
 // unordered_multiset(unordered_multiset&& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
#if TEST_STD_VER >= 11
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp

 // class unordered_multiset
 
 // unordered_multiset(unordered_multiset&& u, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         ++i;
         assert(*i == 3);
         ++i;
         assert(*i == 4);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef int P;
         typedef test_allocator<int> A;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #if TEST_STD_VER >= 11
     {
         typedef int P;
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef int P;
         typedef min_allocator<int> A;
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp

 // class unordered_multiset
 
 // template <class InputIterator>
 //     unordered_multiset(InputIterator first, InputIterator last);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
#if TEST_STD_VER > 11
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
         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);
     }
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
#if TEST_STD_VER > 11
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         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);
     }
 #endif
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp

 
 // template <class InputIterator>
 //     unordered_multiset(InputIterator first, InputIterator last, size_type n);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp

 // template <class InputIterator>
 //     unordered_multiset(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp

 // template <class InputIterator>
 //     unordered_multiset(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp

 //     unordered_multiset(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql,
 //                   const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp

 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // void swap(unordered_multiset& x, unordered_multiset& y);
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 6);
         assert(c2.count(1) == 2);
         assert(c2.count(2) == 2);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
 }

test/std/containers/unord/unord.set/iterators.pass.cpp

 // iterator       end()          {return __table_.end();}
 // const_iterator begin()  const {return __table_.begin();}
 // const_iterator end()    const {return __table_.end();}
 // const_iterator cbegin() const {return __table_.begin();}
 // const_iterator cend()   const {return __table_.end();}
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         typedef std::unordered_set<int> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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;
     }
     {
         typedef std::unordered_set<int> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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;
     }
     {
         typedef std::unordered_set<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef int P;
         P a[] =
         {
             P(1),
             P(2),
             P(3),
             P(4),
             P(1),
             P(2)
         };
         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
 #if TEST_STD_VER > 11
     { // N3644 testing
         typedef std::unordered_set<int> C;
         C::iterator ii1{}, ii2{};
         C::iterator ii4 = ii1;

test/std/containers/unord/unord.set/swap_member.pass.cpp

 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // void swap(unordered_set& u);
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         c1.swap(c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
 }

test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // unordered_set& operator=(const unordered_set& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_set<int> C;
         typedef int P;
         P a[] =
         {
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/assign_init.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // unordered_set& operator=(initializer_list<value_type> il);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
                     P(2)
                 };
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
                     P(2)
                 };
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // unordered_set& operator=(unordered_set&& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef test_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef other_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef min_allocator<int> A;
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         std::unordered_set<int> s1 = {1, 2, 3};
         std::unordered_set<int>::iterator i = s1.begin();

test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp

 // class unordered_set
 
 // unordered_set(const unordered_set& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
                                    min_allocator<int>
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp

 // class unordered_set
 
 // unordered_set(const unordered_set& u, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/init.pass.cpp

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // unordered_set(initializer_list<value_type> il);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
#if TEST_STD_VER > 11
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
         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);
     }
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
#if TEST_STD_VER > 11
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         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);
     }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp

 // class unordered_set
 
 // unordered_set(initializer_list<value_type> il, size_type n);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp

 
 // unordered_set(initializer_list<value_type> il, size_type n,
 //               const hasher& hf);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp

 
 // unordered_set(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp

 
 // unordered_set(initializer_list<value_type> il, size_type n,
 //               const hasher& hf, const key_equal& eql, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }

test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp

 // class unordered_set
 
 // unordered_set(unordered_set&& u);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
#if TEST_STD_VER >= 11
            );
         C c = std::move(c0);
         LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {

test/std/containers/unord/unord.set/unord.set.cnstr/move_alloc.pass.cpp

 // class unordered_set
 
 // unordered_set(unordered_set&& u, const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
 {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
     {
         typedef int P;
         typedef test_allocator<int> A;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #if TEST_STD_VER >= 11
     {
         typedef int P;
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
 
         assert(c0.empty());
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp

 // class unordered_set
 
 // template <class InputIterator>
 //     unordered_set(InputIterator first, InputIterator last);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER > 11
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
#if TEST_STD_VER > 11
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp());
         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);
     }
     {
         typedef int T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
#if TEST_STD_VER > 11
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp());
         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);
     }
 
 #endif
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp

 
 // template <class InputIterator>
 //     unordered_set(InputIterator first, InputIterator last, size_type n);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >());
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp

 // template <class InputIterator>
 //     unordered_set(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp

 // template <class InputIterator>
 //     unordered_set(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp

 //     unordered_set(InputIterator first, InputIterator last, size_type n,
 //                   const hasher& hf, const key_equal& eql,
 //                   const allocator_type& a);
 
 #include <unordered_set>
 #include <cassert>
 #include <cfloat>
 #include <cmath>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
int main()
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int,
                                    test_hash<std::hash<int> >,
                                    test_compare<std::equal_to<int> >,
#if TEST_STD_VER >= 11
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
         assert(c.count(3) == 1);
         assert(c.count(4) == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         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);
     }
 #endif
 }

test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp

 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // void swap(unordered_set& x, unordered_set& y);
 
 #include <unordered_set>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 int main()
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 0);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef test_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         assert(c1.hash_function() == Hash(2));
         assert(c1.key_eq() == Compare(2));
         assert(c1.get_allocator() == Alloc(3));
-        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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         assert(c2.hash_function() == Hash(1));
         assert(c2.key_eq() == Compare(1));
         assert(c2.get_allocator() == Alloc(3));
-        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);
     }
 
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc(1));
         C c2(0, Hash(2), Compare(2), Alloc(2));
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef other_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
int main()
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
         C c1(0, Hash(1), Compare(1), Alloc());
         C c2(0, Hash(2), Compare(2), Alloc());
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 0);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         c2.max_load_factor(2);
         swap(c1, c2);
 
         LIBCPP_ASSERT(c1.bucket_count() == 0);
         assert(c1.size() == 0);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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);
     }
     {
         typedef test_hash<std::hash<int> > Hash;
         typedef test_compare<std::equal_to<int> > Compare;
         typedef min_allocator<int> Alloc;
         typedef std::unordered_set<int, Hash, Compare, Alloc> C;
         typedef int P;
#if TEST_STD_VER >= 11
         assert(*c1.find(40) == 40);
         assert(*c1.find(50) == 50);
         assert(*c1.find(60) == 60);
         assert(*c1.find(70) == 70);
         assert(*c1.find(80) == 80);
         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);
         assert(c2.size() == 4);
         assert(c2.count(1) == 1);
         assert(c2.count(2) == 1);
         assert(c2.count(3) == 1);
         assert(c2.count(4) == 1);
         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
 }

test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

 
 // template<class InputIterator>
 //   basic_string(InputIterator begin, InputIterator end,
 //   const Allocator& a = Allocator());
 
 #include <string>
 #include <iterator>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../input_iterator.h"
 #include "min_allocator.h"
 
 template <class It>
 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::traits_type T;
     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);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     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);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 int main()