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

[STL_MSFT]

Summary

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

Add static_cast<int>. In these cases, the values are guaranteed to be small-ish,
and they're being compared to int elements.

[EricWF]

LGTM.

Feel free to address the inline comments or not.

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

55

Wouldn't it make more sense to change these loop indexes to be int instead of unsigned?

[STL_MSFT]

Changed loop indices to int as requested.

[STL_MSFT]

Thanks, r288747.

test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

test1()
     std::unique_ptr<int> ia[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i].reset(new int(i));
     std::unique_ptr<int> ib[N];
 
     OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
-        assert(*ib[i] == i);
+        assert(*ib[i] == static_cast<int>(i));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 int main()
 {
     test<input_iterator<const int*>, output_iterator<int*> >();
     test<input_iterator<const int*>, input_iterator<int*> >();

test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

test1()
     std::unique_ptr<int> ia[N];
     for (unsigned i = 0; i < N; ++i)
         ia[i].reset(new int(i));
     std::unique_ptr<int> ib[N];
 
     OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
     assert(base(r) == ib);
     for (unsigned i = 0; i < N; ++i)
-        assert(*ib[i] == i);
+        assert(*ib[i] == static_cast<int>(i));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 int main()
 {
     test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();

test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
     for_each_test f = std::for_each(input_iterator<int*>(ia),
                                     input_iterator<int*>(ia+s),
                                     for_each_test(0));
     assert(f.count == s);
     for (unsigned i = 0; i < s; ++i)
-        assert(ia[i] == i+1);
+        assert(ia[i] == static_cast<int>(i+1));
 }

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

test()
     for (unsigned i = 0; i < N; ++i)
         ia[i] = 2*i;
     for (unsigned i = 0; i < N; ++i)
         ib[i] = 2*i+1;
     OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
                            InIter2(ib), InIter2(ib+N), OutIter(ic));
     assert(base(r) == ic+2*N);
     assert(ic[0] == 0);
-    assert(ic[2*N-1] == 2*N-1);
+    assert(ic[2*N-1] == static_cast<int>(2*N-1));
     assert(std::is_sorted(ic, ic+2*N));
     delete [] ic;
     delete [] ib;
     delete [] ia;
     }
     {
     unsigned N = 100;
     int* ia = new int[N];
     int* ib = new int[N];
     int* ic = new int[2*N];
     for (unsigned i = 0; i < 2*N; ++i)
         ic[i] = i;
     std::random_shuffle(ic, ic+2*N);
     std::copy(ic, ic+N, ia);
     std::copy(ic+N, ic+2*N, ib);
     std::sort(ia, ia+N);
     std::sort(ib, ib+N);
     OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
                            InIter2(ib), InIter2(ib+N), OutIter(ic));
     assert(base(r) == ic+2*N);
     assert(ic[0] == 0);
-    assert(ic[2*N-1] == 2*N-1);
+    assert(ic[2*N-1] == static_cast<int>(2*N-1));
     assert(std::is_sorted(ic, ic+2*N));
     delete [] ic;
     delete [] ib;
     delete [] ia;
     }
 }
 
 int main()

test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

test()
     for (unsigned i = 0; i < N; ++i)
         ib[i] = 2*i+1;
     std::reverse(ia, ia+N);
     std::reverse(ib, ib+N);
     binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
     OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
                            InIter2(ib), InIter2(ib+N), OutIter(ic), pred);
     assert(base(r) == ic+2*N);
-    assert(ic[0] == 2*N-1);
+    assert(ic[0] == static_cast<int>(2*N-1));
     assert(ic[2*N-1] == 0);
     assert(std::is_sorted(ic, ic+2*N, std::greater<int>()));
     assert(pred.count() <= (N + N - 1));
     delete [] ic;
     delete [] ib;
     delete [] ia;
     }
     {
     unsigned N = 100;
     int* ia = new int[N];
     int* ib = new int[N];
     int* ic = new int[2*N];
     for (unsigned i = 0; i < 2*N; ++i)
         ic[i] = i;
     std::random_shuffle(ic, ic+2*N);
     std::copy(ic, ic+N, ia);
     std::copy(ic+N, ic+2*N, ib);
     std::sort(ia, ia+N, std::greater<int>());
     std::sort(ib, ib+N, std::greater<int>());
     binary_counting_predicate<std::greater<int>, int, int> pred((std::greater<int>()));
     OutIter r = std::merge(InIter1(ia), InIter1(ia+N),
                            InIter2(ib), InIter2(ib+N), OutIter(ic), pred);
     assert(base(r) == ic+2*N);
-    assert(ic[0] == 2*N-1);
+    assert(ic[0] == static_cast<int>(2*N-1));
     assert(ic[2*N-1] == 0);
     assert(std::is_sorted(ic, ic+2*N, std::greater<int>()));
     assert(pred.count() <= (N + N - 1));
     delete [] ic;
     delete [] ib;
     delete [] ia;
     }
 }

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

for (int i = 0; i < start; ++i)
         c.pop_front();
     return c;
 }
 
 int main()
 {
     {
         std::deque<int> c = make<std::deque<int> >(10);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
     {
         const std::deque<int> c = make<std::deque<int> >(10);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
 #if TEST_STD_VER >= 11
     {
         std::deque<int, min_allocator<int>> c = make<std::deque<int, min_allocator<int>> >(10);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
     {
         const std::deque<int, min_allocator<int>> c = make<std::deque<int, min_allocator<int>> >(10);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c[i] == i);
-        for (unsigned i = 0; i < 10; ++i)
+        for (int i = 0; i < 10; ++i)
             assert(c.at(i) == i);
         assert(c.front() == 0);
         assert(c.back() == 9);
     }
 #endif
 }