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

[STL_MSFT]

Summary

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

Add static_cast<std::size_t> when comparing int to std::size_t.

Also, include <cstddef> when it wasn't already being included.

[STL_MSFT]

Thanks, r287822.

test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp

 //         && CopyConstructible<Compare>
 //   void
 //   nth_element(Iter first, Iter nth, Iter last, Compare comp);
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
int main()
     test(500);
     test(997);
     test(1000);
     test(1009);
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::vector<std::unique_ptr<int> > v(1000);
-    for (int i = 0; i < v.size(); ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i].reset(new int(i));
     std::nth_element(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
     assert(*v[v.size()/2] == v.size()/2);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp

 //         && CopyConstructible<Compare>
 //   void
 //   partial_sort(Iter first, Iter middle, Iter last, Compare comp);
 
 #include <algorithm>
 #include <vector>
 #include <functional>
 #include <cassert>
+#include <cstddef>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
int main()
     test_larger_sorts(997);
     test_larger_sorts(1000);
     test_larger_sorts(1009);
     }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::vector<std::unique_ptr<int> > v(1000);
-    for (int i = 0; i < v.size(); ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i].reset(new int(i));
     std::partial_sort(v.begin(), v.begin() + v.size()/2, v.end(), indirect_less());
-    for (int i = 0; i < v.size()/2; ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size()/2; ++i)
         assert(*v[i] == i);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp

 //         && CopyConstructible<Compare>
 //   void
 //   sort(Iter first, Iter last, Compare comp);
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 int main()
 {
     {
     std::vector<int> v(1000);
-    for (int i = 0; i < v.size(); ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i] = i;
     std::sort(v.begin(), v.end(), std::greater<int>());
     std::reverse(v.begin(), v.end());
     assert(std::is_sorted(v.begin(), v.end()));
     }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::vector<std::unique_ptr<int> > v(1000);
-    for (int i = 0; i < v.size(); ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i].reset(new int(i));
     std::sort(v.begin(), v.end(), indirect_less());
     assert(std::is_sorted(v.begin(), v.end(), indirect_less()));
     assert(*v[0] == 0);
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp

 //         && CopyConstructible<Compare>
 //   void
 //   stable_sort(Iter first, Iter last, Compare comp);
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
 
 struct indirect_less
 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}

 
 int main()
 {
     test();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
     std::vector<std::unique_ptr<int> > v(1000);
-    for (int i = 0; i < v.size(); ++i)
+    for (int i = 0; static_cast<std::size_t>(i) < v.size(); ++i)
         v[i].reset(new int(i));
     std::stable_sort(v.begin(), v.end(), indirect_less());
     assert(std::is_sorted(v.begin(), v.end(), indirect_less()));
     assert(*v[0] == 0);
     assert(*v[1] == 1);
     assert(*v[2] == 2);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/associative/map/map.access/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()
         };
         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());
         std::map<int, double>::iterator i;
         i = m.begin();
         std::map<int, double>::const_iterator k = i;
         assert(i == k);
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
         {
             assert(i->first == j);
             assert(i->second == 1);
             i->second = 2.5;
             assert(i->second == 2.5);
         }
     }
     {
int main()
         };
         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());
         std::map<int, double>::const_iterator i;
         i = m.begin();
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        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
     {
         typedef std::pair<const int, double> V;
#if TEST_STD_VER >= 11
         };
         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());
         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; j <= m.size(); ++j, ++i)
+        for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
         {
             assert(i->first == j);
             assert(i->second == 1);
             i->second = 2.5;
             assert(i->second == 2.5);
         }
     }
     {
#if TEST_STD_VER >= 11
         };
         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());
         std::map<int, double, std::less<int>, min_allocator<V>>::const_iterator i;
         i = m.begin();
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
         {
             assert(i->first == j);
             assert(i->second == 1);
         }
     }
 #endif
 #if TEST_STD_VER > 11
     { // N3644 testing

test/std/containers/associative/set/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()
         };
         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());
         std::set<int>::iterator i;
         i = m.begin();
         std::set<int>::const_iterator k = i;
         assert(i == k);
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
int main()
         };
         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());
         std::set<int>::const_iterator i;
         i = m.begin();
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        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;
         V ar[] =
         {
             1,
#if TEST_STD_VER >= 11
         };
         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());
         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; j <= m.size(); ++j, ++i)
+        for (int j = 1; static_cast<std::size_t>(j) <= m.size(); ++j, ++i)
             assert(*i == j);
     }
     {
         typedef int V;
         V ar[] =
         {
             1,
             1,
#if TEST_STD_VER >= 11
         };
         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());
         std::set<int, std::less<int>, min_allocator<int>>::const_iterator i;
         i = m.begin();
-        for (int j = 1; j <= m.size(); ++j, ++i)
+        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
         typedef std::set<int> C;
         C::iterator ii1{}, ii2{};
         C::iterator ii4 = ii1;

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

 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());
     CI i = c1.begin();
-    for (int j = 0; j < std::min(c1_osize, c1.size()); ++j, ++i)
+    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>
 void
 testN(int start, int N, int M)

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

 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());
     CI i = c1.begin();
-    for (int j = 0; j < std::min(c1_osize, c1.size()); ++j, ++i)
+    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>
 void
 testN(int start, int N, int M)

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

 // <deque>
 
 // iterator erase(const_iterator p)
 
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
make(int size, int start = 0 )
     return c;
 }
 
 template <class C>
 void
 test(int P, C& c1)
 {
     typedef typename C::iterator I;
-    assert(P < c1.size());
+    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());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
         assert(*i == j);
-    for (++j; j < c1_osize; ++j, ++i)
+    for (++j; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     int pstep = std::max(N / std::max(std::min(N, 10), 1), 1);

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

 // <deque>
 
 // iterator erase(const_iterator f, const_iterator l)
 
 #include <deque>
 #include <algorithm>
 #include <iterator>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
make(int size, int start = 0 )
     return c;
 }
 
 template <class C>
 void
 test(int P, C& c1, int size)
 {
     typedef typename C::iterator I;
-    assert(P + size <= c1.size());
+    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());
     i = c1.begin();
     int j = 0;
     for (; j < P; ++j, ++i)
         assert(*i == j);
-    for (j += size; j < c1_osize; ++j, ++i)
+    for (j += size; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     int pstep = std::max(N / std::max(std::min(N, 10), 1), 1);

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

 
 // <deque>
 
 // template <class InputIterator>
 //   iterator insert (const_iterator p, InputIterator f, InputIterator l);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
test(int P, const C& c0, const C& c2)
     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());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
-    for (int j = 0; j < c2.size(); ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
-    for (int j = P; j < c1_osize; ++j, ++i)
+    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());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
-    for (int j = 0; j < c2.size(); ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
-    for (int j = P; j < c1_osize; ++j, ++i)
+    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());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
-    for (int j = 0; j < c2.size(); ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
-    for (int j = P; j < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
     }
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {
testI(int P, C& c1, const C& c2)
     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());
     i = c1.begin();
     for (int j = 0; j < P; ++j, ++i)
         assert(*i == j);
-    for (int j = 0; j < c2.size(); ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c2.size(); ++j, ++i)
         assert(*i == j);
-    for (int j = P; j < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testNI(int start, int N, int M)
 {
     for (int i = 0; i <= 3; ++i)

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

 // <deque>
 
 // iterator insert (const_iterator p, value_type&& v);
 
 // UNSUPPORTED: c++98, c++03
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 
 template <class C>
 C
 make(int size, int start = 0 )
test(int P, C& c1, int x)
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(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; j < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     for (int i = 0; i <= 3; ++i)

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

 // REQUIRES: long_tests
 
 // <deque>
 
 // iterator insert (const_iterator p, size_type n, const value_type& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
test(int P, C& c1, int size, int x)
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + size);
     assert(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; j < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N, int M)
 {
     for (int i = 0; i <= 3; ++i)

test/std/containers/sequences/deque/deque.modifiers/insert_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>
 
 // iterator insert (const_iterator p, const value_type& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
test(int P, C& c1, int x)
     assert(i == c1.begin() + P);
     assert(c1.size() == c1_osize + 1);
     assert(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; j < c1_osize; ++j, ++i)
+    for (int j = P; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     for (int i = 0; i <= 3; ++i)

test/std/containers/sequences/deque/deque.modifiers/pop_back.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 pop_back()
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);

 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());
     I i = c1.begin();
-    for (int j = 0; j < c1.size(); ++j, ++i)
+    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)
 {
     if (N != 0)

test/std/containers/sequences/deque/deque.modifiers/pop_front.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 pop_front()
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);

 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());
     I i = c1.begin();
-    for (int j = 1; j < c1.size(); ++j, ++i)
+    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)
 {
     if (N != 0)

test/std/containers/sequences/deque/deque.modifiers/push_front.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 push_front(const value_type& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class C>
 C
 make(int size, int start = 0 )
 {
     const int b = 4096 / sizeof(int);
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());
     I i = c1.begin();
     assert(*i == x);
     ++i;
-    for (int j = 0; j < c1_osize; ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == j);
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     C c1 = make<C>(N, start);

test/std/containers/sequences/deque/deque.modifiers/push_front_rvalue.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 push_front(value_type&& v);
 
 #include <deque>
 #include <cassert>
+#include <cstddef>
 
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class C>
 C
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());
     I i = c1.begin();
     assert(*i == MoveOnly(x));
     ++i;
-    for (int j = 0; j < c1_osize; ++j, ++i)
+    for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
         assert(*i == MoveOnly(j));
 }
 
 template <class C>
 void
 testN(int start, int N)
 {
     C c1 = make<C>(N, start);

test/std/containers/sequences/vector/vector.modifiers/push_back.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>
 
 // void push_back(const value_type& x);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
     {
         // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
         // Use 17 for implementations that dynamically allocate a container proxy
         // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
         std::vector<int, limited_allocator<int, 17> > c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(2);
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(3);
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == j);
     }
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.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>
 
 // void push_back(value_type&& x);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "MoveOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<MoveOnly> c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
     {
         // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
         // Use 17 for implementations that dynamically allocate a container proxy
         // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
         std::vector<MoveOnly, limited_allocator<MoveOnly, 17> > c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly>> c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(2));
         assert(c.size() == 3);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(3));
         assert(c.size() == 4);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
-        for (int j = 0; j < c.size(); ++j)
+        for (int j = 0; static_cast<std::size_t>(j) < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }