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

[STL_MSFT]

Summary

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

Change "int j;" indices to "std::size_t j;".

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

[STL_MSFT]

Thanks, r287824.

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

 // <vector>
 // vector<bool>
 
 // template <class Iter>
 //   iterator insert(const_iterator position, Iter first, Iter last);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::vector<bool> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
                                         input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
int main()
         while(v.size() < v.capacity()) v.push_back(false);
         size_t sz = v.size();
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
                                         forward_iterator<const bool*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool> v(100);
         while(v.size() < v.capacity()) v.push_back(false);
         v.pop_back(); v.pop_back(); v.pop_back();
         size_t sz = v.size();
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
                                         forward_iterator<const bool*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
                                         input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
                                         forward_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 }

test/std/containers/sequences/vector.bool/insert_iter_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.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::vector<bool> v(100);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool> v(100);
         while(v.size() < v.capacity()) v.push_back(false);
         size_t sz = v.size();
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool> v(100);
         while(v.size() < v.capacity()) v.push_back(false);
         v.pop_back(); v.pop_back();
         size_t sz = v.size();
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 }

test/std/containers/sequences/vector.bool/insert_iter_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.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // iterator insert(const_iterator position, const value_type& x);
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
         std::vector<bool> v(100);
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool> v(100);
         while(v.size() < v.capacity()) v.push_back(false);
         size_t sz = v.size();
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<bool> v(100);
         while(v.size() < v.capacity()) v.push_back(false);
         v.pop_back(); v.pop_back();
         size_t sz = v.size();
         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<bool, min_allocator<bool>> v(100);
         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 //   iterator insert(const_iterator position, Iter first, Iter last);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
int main()
         while(v.size() < v.capacity()) v.push_back(0); // force reallocation
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int> v(100);
         v.reserve(128); // force no reallocation
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (int k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {

test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp

 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
int main()
     {
         std::vector<int> v(100);
         while(v.size() < v.capacity()) v.push_back(0); // force reallocation
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int> v(100);
         v.reserve(128); // force no reallocation
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == sz + 5);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (; j < 15; ++j)
             assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {

test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp

 // iterator insert(const_iterator position, const value_type& x);
 
 #if _LIBCPP_DEBUG >= 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 #endif
 
 #include <vector>
 #include <cassert>
+#include <cstddef>
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
         std::vector<int> v(100);
int main()
     {
         std::vector<int> v(100);
         while(v.size() < v.capacity()) v.push_back(0); // force reallocation
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int> v(100);
         while(v.size() < v.capacity()) v.push_back(0);
         v.pop_back(); v.pop_back(); // force no reallocation
         size_t sz = v.size();
         std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == sz + 1);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
-        int j;
+        std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int, limited_allocator<int, 300> > v(100);