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

[STL_MSFT]

Summary

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

Change unsigned to int in parameters.

[STL_MSFT]

Thanks, r287823.

test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp

 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   make_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N);
     assert(std::is_heap(ia, ia+N));
     delete [] ia;

test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp

 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   pop_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N);
     for (int i = N; i > 0; --i)
     {

test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp

 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N, std::greater<int>());
     for (int i = N; i > 0; --i)
     {

test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp

 //   requires ShuffleIterator<Iter>
 //         && LessThanComparable<Iter::value_type>
 //   void
 //   push_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     for (int i = 0; i <= N; ++i)
     {
         std::push_heap(ia, ia+i);

test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp

 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     for (int i = 0; i <= N; ++i)
     {
         std::push_heap(ia, ia+i, std::greater<int>());

test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp

 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter> && LessThanComparable<Iter::value_type>
 //   void
 //   sort_heap(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N);
     std::sort_heap(ia, ia+N);
     assert(std::is_sorted(ia, ia+N));

test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp

 {
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N, std::greater<int>());
     std::sort_heap(ia, ia+N, std::greater<int>());
     assert(std::is_sorted(ia, ia+N, std::greater<int>()));

test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp

if (first != last)
             assert(!(*i < *j));
     }
     else
         assert(i == last);
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp

if (first != last)
             assert(!std::greater<int>()(*i, *j));
     }
     else
         assert(i == last);
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp

if (first != last)
             assert(!(*j < *i));
     }
     else
         assert(i == last);
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp

if (first != last)
             assert(!std::greater<int>()(*j, *i));
     }
     else
         assert(i == last);
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp

test(Iter first, Iter last)
     {
         assert(p.first == last);
         assert(p.second == last);
     }
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp

test(Iter first, Iter last)
     {
         assert(p.first == last);
         assert(p.second == last);
     }
 }
 
 template <class Iter>
 void
-test(unsigned N)
+test(int N)
 {
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = i;
     std::random_shuffle(a, a+N);
     test(Iter(a), Iter(a+N));
     delete [] a;
 }

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

 //         && LessThanComparable<Iter::value_type>
 //   void
 //   nth_element(Iter first, Iter nth, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
 void
-test_one(unsigned N, unsigned M)
+test_one(int N, int M)
 {
     assert(N != 0);
     assert(M < N);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::nth_element(array, array+M, array+N);
     assert(array[M] == M);
     std::nth_element(array, array+N, array+N); // begin, end, end
     delete [] array;
 }
 
 void
-test(unsigned N)
+test(int N)
 {
     test_one(N, 0);
     test_one(N, 1);
     test_one(N, 2);
     test_one(N, 3);
     test_one(N, N/2-1);
     test_one(N, N/2);
     test_one(N, N/2+1);

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

struct indirect_less
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 void
-test_one(unsigned N, unsigned M)
+test_one(int N, int M)
 {
     assert(N != 0);
     assert(M < N);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::nth_element(array, array+M, array+N, std::greater<int>());
     assert(array[M] == N-M-1);
     std::nth_element(array, array+N, array+N, std::greater<int>()); // begin, end, end
     delete [] array;
 }
 
 void
-test(unsigned N)
+test(int N)
 {
     test_one(N, 0);
     test_one(N, 1);
     test_one(N, 2);
     test_one(N, 3);
     test_one(N, N/2-1);
     test_one(N, N/2);
     test_one(N, N/2+1);

test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp

 
 #include <algorithm>
 #include <cassert>
 
 #include "test_iterators.h"
 
 template <class Iter>
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     int* input = new int[N];
     int* output = new int[M];
     for (int i = 0; i < N; ++i)
         input[i] = i;
     std::random_shuffle(input, input+N);
     int* r = std::partial_sort_copy(Iter(input), Iter(input+N), output, output+M);
     int* e = output + std::min(N, M);
     assert(r == e);
     int i = 0;
     for (int* x = output; x < e; ++x, ++i)
         assert(*x == i);
     delete [] output;
     delete [] input;
 }
 
 template <class Iter>
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts<Iter>(N, 0);
     test_larger_sorts<Iter>(N, 1);
     test_larger_sorts<Iter>(N, 2);
     test_larger_sorts<Iter>(N, 3);
     test_larger_sorts<Iter>(N, N/2-1);
     test_larger_sorts<Iter>(N, N/2);
     test_larger_sorts<Iter>(N, N/2+1);

test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp

 #include <algorithm>
 #include <functional>
 #include <cassert>
 
 #include "test_iterators.h"
 
 template <class Iter>
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     int* input = new int[N];
     int* output = new int[M];
     for (int i = 0; i < N; ++i)
         input[i] = i;
     std::random_shuffle(input, input+N);
     int* r = std::partial_sort_copy(Iter(input), Iter(input+N), output, output+M,
                                     std::greater<int>());
     int* e = output + std::min(N, M);
     assert(r == e);
     int i = 0;
     for (int* x = output; x < e; ++x, ++i)
         assert(*x == N-i-1);
     delete [] output;
     delete [] input;
 }
 
 template <class Iter>
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts<Iter>(N, 0);
     test_larger_sorts<Iter>(N, 1);
     test_larger_sorts<Iter>(N, 2);
     test_larger_sorts<Iter>(N, 3);
     test_larger_sorts<Iter>(N, N/2-1);
     test_larger_sorts<Iter>(N, N/2);
     test_larger_sorts<Iter>(N, N/2+1);

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

 //         && LessThanComparable<Iter::value_type>
 //   void
 //   partial_sort(Iter first, Iter middle, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     assert(N != 0);
     assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N);
     for (int i = 0; i < M; ++i)
     {
         assert(i < N); // quiet analysis warnings
         assert(array[i] == i);
     }
     delete [] array;
 }
 
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts(N, 0);
     test_larger_sorts(N, 1);
     test_larger_sorts(N, 2);
     test_larger_sorts(N, 3);
     test_larger_sorts(N, N/2-1);
     test_larger_sorts(N, N/2);
     test_larger_sorts(N, N/2+1);

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

struct indirect_less
     template <class P>
     bool operator()(const P& x, const P& y)
         {return *x < *y;}
 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     assert(N != 0);
     assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N, std::greater<int>());
     for (int i = 0; i < M; ++i)
     {
         assert(i < N); // quiet analysis warnings
         assert(array[i] == N-i-1);
     }
     delete [] array;
 }
 
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts(N, 0);
     test_larger_sorts(N, 1);
     test_larger_sorts(N, 2);
     test_larger_sorts(N, 3);
     test_larger_sorts(N, N/2-1);
     test_larger_sorts(N, N/2);
     test_larger_sorts(N, N/2+1);

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

test_sort_()
     int ia[sa];
     for (int i = 0; i < sa; ++i)
     {
         test_sort_driver(ia, ia+sa, i);
     }
 }
 
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     assert(N != 0);
     assert(M != 0);
     // create array length N filled with M different numbers
     int* array = new int[N];
     int x = 0;
     for (int i = 0; i < N; ++i)
     {
test_larger_sorts(int N, int M)
     std::reverse(array, array+N);
     std::swap_ranges(array, array+N/2, array+N/2);
     std::sort(array, array+N);
     assert(std::is_sorted(array, array+N));
     delete [] array;
 }
 
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts(N, 1);
     test_larger_sorts(N, 2);
     test_larger_sorts(N, 3);
     test_larger_sorts(N, N/2-1);
     test_larger_sorts(N, N/2);
     test_larger_sorts(N, N/2+1);
     test_larger_sorts(N, N-2);

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

test_sort_()
     int ia[sa];
     for (int i = 0; i < sa; ++i)
     {
         test_sort_driver(ia, ia+sa, i);
     }
 }
 
 void
-test_larger_sorts(unsigned N, unsigned M)
+test_larger_sorts(int N, int M)
 {
     assert(N != 0);
     assert(M != 0);
     // create array length N filled with M different numbers
     int* array = new int[N];
     int x = 0;
     for (int i = 0; i < N; ++i)
     {
test_larger_sorts(int N, int M)
     std::reverse(array, array+N);
     std::swap_ranges(array, array+N/2, array+N/2);
     std::stable_sort(array, array+N);
     assert(std::is_sorted(array, array+N));
     delete [] array;
 }
 
 void
-test_larger_sorts(unsigned N)
+test_larger_sorts(int N)
 {
     test_larger_sorts(N, 1);
     test_larger_sorts(N, 2);
     test_larger_sorts(N, 3);
     test_larger_sorts(N, N/2-1);
     test_larger_sorts(N, N/2);
     test_larger_sorts(N, N/2+1);
     test_larger_sorts(N, N-2);