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

[STL_MSFT]

Summary

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

Add static_cast<std::size_t> to more comparisons. (Performed manually, unlike part 8/12.)

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

[EricWF]

LGTM.

I may have considered doing the cast to ptrdiff_t for the other operand instead of the size_t cast, but IDK which is better.

[STL_MSFT]

Thanks, r288746.

test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

 // SampleIterator sample(PopulationIterator first, PopulationIterator last,
 //                       SampleIterator out, Distance n,
 //                       UniformRandomNumberGenerator &&g);
 
 #include <algorithm>
 #include <random>
 #include <type_traits>
 #include <cassert>
+#include <cstddef>
 
 #include "test_iterators.h"
 #include "test_macros.h"
 
 struct ReservoirSampleExpectations {
   enum { os = 4 };
   static int oa1[os];
   static int oa2[os];
void test() {
   ((void)oa1); // Prevent unused warning
   const int *oa2 = Expectations::oa2;
   ((void)oa2); // Prevent unused warning
   std::minstd_rand g;
   SampleIterator end;
   end = std::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, g);
-  assert(end.base() - oa == std::min(os, is));
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
   // sample() is deterministic but non-reproducible;
   // its results can vary between implementations.
   LIBCPP_ASSERT(std::equal(oa, oa + os, oa1));
   end = std::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, std::move(g));
-  assert(end.base() - oa == std::min(os, is));
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
   LIBCPP_ASSERT(std::equal(oa, oa + os, oa2));
 }
 
 template <template<class...> class PopulationIteratorType, class PopulationItem,
           template<class...> class SampleIteratorType, class SampleItem>
 void test_empty_population() {
   typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
   typedef SampleIteratorType<SampleItem *> SampleIterator;
void test_small_population() {
   const unsigned os = 8;
   SampleItem oa[os];
   const SampleItem oa1[] = {1, 2, 3, 4, 5};
   std::minstd_rand g;
   SampleIterator end;
   end = std::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, g);
-  assert(end.base() - oa == std::min(os, is));
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
   typedef typename std::iterator_traits<PopulationIterator>::iterator_category PopulationCategory;
   if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) {
     assert(std::equal(oa, end.base(), oa1));
   } else {
     assert(std::is_permutation(oa, end.base(), oa1));
   }
 }
 

test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_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.
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
 // template <class InputIterator>
 //   priority_queue(InputIterator first, InputIterator last);
 
 #include <queue>
 #include <cassert>
+#include <cstddef>
 
 int main()
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
     std::priority_queue<int> q(a, an);
-    assert(q.size() == an - a);
+    assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 8);
 }

test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_iter_iter_comp.pass.cpp

 // <queue>
 
 // template <class InputIterator>
 //   priority_queue(InputIterator first, InputIterator last, const Compare& comp);
 
 #include <queue>
 #include <cassert>
 #include <functional>
+#include <cstddef>
 
 int main()
 {
     int a[] = {3, 5, 2, 0, 6, 8, 1};
     int* an = a + sizeof(a)/sizeof(a[0]);
     std::priority_queue<int, std::vector<int>, std::greater<int> >
         q(a, an, std::greater<int>());
-    assert(q.size() == an - a);
+    assert(q.size() == static_cast<std::size_t>(an - a));
     assert(q.top() == 0);
 }

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(c1.size() == static_cast<std::size_t>(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);
 }
 

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(c1.size() == static_cast<std::size_t>(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);
 }
 

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

 }
 
 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(c1.size() == static_cast<std::size_t>(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/forwardlist/forwardlist.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // explicit forward_list(size_type n);
 // explicit forward_list(size_type n, const Alloc& a);
 
 #include <forward_list>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void check_allocator(unsigned n, Allocator const &alloc = Allocator())
 {
 #if TEST_STD_VER > 11
     typedef std::forward_list<T, Allocator> C;
     C d(n, alloc);
     assert(d.get_allocator() == alloc);
-    assert(std::distance(d.begin(), d.end()) == n);
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == n);
 #endif
 }
 
 int main()
 {
     {
         typedef DefaultOnly T;
         typedef std::forward_list<T> C;

test/std/containers/sequences/forwardlist/forwardlist.ops/remove_if.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 
 // template <class Predicate> void remove_if(Predicate pred);
 
 #include <forward_list>
 #include <iterator>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 #include "counting_predicates.hpp"
 
 
 bool g(int i)
 {
     return i < 3;
 }
 
 int main()
 {
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         C c1;
         C c2;
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
         assert(cp.count() == 0);
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 #if TEST_STD_VER >= 11
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 5, 5, 0, 0, 0, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {0, 0, 0, 0};
         C c1(std::begin(t1), std::end(t1));
         C c2;
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c1;
         C c2;
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
         assert(cp.count() == 0);
     }
     {
         typedef int T;
         typedef unary_counting_predicate<bool(*)(T), T> Predicate;
         typedef std::forward_list<T, min_allocator<T>> C;
         const T t1[] = {5, 5, 5, 0};
         const T t2[] = {5, 5, 5};
         C c1(std::begin(t1), std::end(t1));
         C c2(std::begin(t2), std::end(t2));
         Predicate cp(g);
         c1.remove_if(std::ref(cp));
         assert(c1 == c2);
-        assert(cp.count() == std::distance(std::begin(t1), std::end(t1)));
+        assert(cp.count() == static_cast<std::size_t>(std::distance(std::begin(t1), std::end(t1))));
     }
 #endif
 }

test/std/containers/sequences/list/list.cons/size_type.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // explicit list(size_type n);
 
 #include <list>
 #include <cassert>
+#include <cstddef>
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
 void
 test3(unsigned n, Allocator const &alloc = Allocator())
 {
 #if TEST_STD_VER > 11
     typedef std::list<T, Allocator> C;
     typedef typename C::const_iterator const_iterator;
     {
     C d(n, alloc);
     assert(d.size() == n);
-    assert(std::distance(d.begin(), d.end()) == n);
+    assert(static_cast<std::size_t>(std::distance(d.begin(), d.end())) == n);
     assert(d.get_allocator() == alloc);
     }
 #endif
 }
 
 
 int main()
 {

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

 
 // std::find with vector<bool>::iterator
 
 // http://llvm.org/bugs/show_bug.cgi?id=16816
 
 #include <vector>
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 
 int main()
 {
     {
         for (unsigned i = 1; i < 256; ++i)
         {
             std::vector<bool> b(i,true);
             std::vector<bool>::iterator j = std::find(b.begin()+1, b.end(), false);
-            assert(j-b.begin() == i);
+            assert(static_cast<std::size_t>(j-b.begin()) == i);
             assert(b.end() == j);
         }
     }
     {
         for (unsigned i = 1; i < 256; ++i)
         {
             std::vector<bool> b(i,false);
             std::vector<bool>::iterator j = std::find(b.begin()+1, b.end(), true);
-            assert(j-b.begin() == i);
+            assert(static_cast<std::size_t>(j-b.begin()) == i);
             assert(b.end() == j);
         }
     }
 }

test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp

 // template<class E> class initializer_list;
 
 // const E* begin() const;
 // const E* end() const;
 // size_t size() const;
 
 #include <initializer_list>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 struct A
 {
     A(std::initializer_list<int> il)
     {
         const int* b = il.begin();
         const int* e = il.end();
         assert(il.size() == 3);
-        assert(e - b == il.size());
+        assert(static_cast<std::size_t>(e - b) == il.size());
         assert(*b++ == 3);
         assert(*b++ == 2);
         assert(*b++ == 1);
     }
 };
 
 #if TEST_STD_VER > 11
 struct B
 {
     constexpr B(std::initializer_list<int> il)
     {
         const int* b = il.begin();
         const int* e = il.end();
         assert(il.size() == 3);
-        assert(e - b == il.size());
+        assert(static_cast<std::size_t>(e - b) == il.size());
         assert(*b++ == 3);
         assert(*b++ == 2);
         assert(*b++ == 1);
     }
 };
 
 #endif  // TEST_STD_VER > 11
 

test/std/language.support/support.initlist/support.initlist.range/begin_end.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <initializer_list>
 
 // template<class E> const E* begin(initializer_list<E> il);
 
 #include <initializer_list>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 struct A
 {
     A(std::initializer_list<int> il)
     {
         const int* b = begin(il);
         const int* e = end(il);
         assert(il.size() == 3);
-        assert(e - b == il.size());
+        assert(static_cast<std::size_t>(e - b) == il.size());
         assert(*b++ == 3);
         assert(*b++ == 2);
         assert(*b++ == 1);
     }
 };
 
 #if TEST_STD_VER > 11
 struct B
 {
     constexpr B(std::initializer_list<int> il)
     {
         const int* b = begin(il);
         const int* e = end(il);
         assert(il.size() == 3);
-        assert(e - b == il.size());
+        assert(static_cast<std::size_t>(e - b) == il.size());
         assert(*b++ == 3);
         assert(*b++ == 2);
         assert(*b++ == 1);
     }
 };
 
 #endif  // TEST_STD_VER > 11
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_in.pass.cpp

 // result in(stateT& state,
 //           const externT* from, const externT* from_end, const externT*& from_next,
 //           internT* to, internT* to_end, internT*& to_next) const;
 
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
 int main()
 {
     std::locale l = std::locale::classic();
     const std::basic_string<F::extern_type> from("some text");
     const std::basic_string<F::intern_type> expected(from.begin(), from.end());
     std::basic_string<F::intern_type> to(from.size(), F::intern_type());
     const F& f = std::use_facet<F>(l);
     std::mbstate_t mbs = {};
     const F::extern_type* from_next = 0;
     F::intern_type* to_next = 0;
     F::result r = f.in(mbs, from.data(), from.data() + from.size(), from_next,
                             &to[0], &to[0] + to.size(), to_next);
     assert(r == F::ok);
-    assert(from_next - from.data() == from.size());
-    assert(to_next - to.data() == expected.size());
-    assert(to_next - to.data() == expected.size());
+    assert(static_cast<std::size_t>(from_next - from.data()) == from.size());
+    assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
+    assert(static_cast<std::size_t>(to_next - to.data()) == expected.size());
     assert(to == expected);
 }

test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/wchar_t_out.pass.cpp

 // result out(stateT& state,
 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
+#include <cstddef>
 
 typedef std::codecvt<wchar_t, char, std::mbstate_t> F;
 
 int main()
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     {
         const std::basic_string<F::intern_type> from(L"some text");
         std::vector<char> to(from.size()+1);
         std::mbstate_t mbs = {};
         const F::intern_type* from_next = 0;
         char* to_next = 0;
         F::result r = f.out(mbs, from.data(), from.data() + from.size(), from_next,
                                  to.data(), to.data() + to.size(), to_next);
         assert(r == F::ok);
-        assert(from_next - from.data() == from.size());
-        assert(to_next - to.data() == from.size());
+        assert(static_cast<std::size_t>(from_next - from.data()) == from.size());
+        assert(static_cast<std::size_t>(to_next - to.data()) == from.size());
         assert(to.data() == std::string("some text"));
     }
     {
         std::basic_string<F::intern_type> from(L"some text");
         from[4] = '\0';
         std::vector<char> to(from.size()+1);
         std::mbstate_t mbs = {};
         const F::intern_type* from_next = 0;
         char* to_next = 0;
         F::result r = f.out(mbs, from.data(), from.data() + from.size(), from_next,
                                  to.data(), to.data() + to.size(), to_next);
         assert(r == F::ok);
-        assert(from_next - from.data() == from.size());
-        assert(to_next - to.data() == from.size());
+        assert(static_cast<std::size_t>(from_next - from.data()) == from.size());
+        assert(static_cast<std::size_t>(to_next - to.data()) == from.size());
         assert(memcmp(to.data(), "some\0text", from.size()) == 0);
     }
     {
         std::basic_string<F::intern_type> from(L"some text");
         std::vector<char> to(from.size()-1);
         std::mbstate_t mbs = {};
         const F::intern_type* from_next = 0;
         char* to_next = 0;
         F::result r = f.out(mbs, from.data(), from.data() + from.size(), from_next,
                                  to.data(), to.data() + to.size()-1, to_next);
         assert(r == F::partial);
-        assert(from_next - from.data() == to.size()-1);
-        assert(to_next - to.data() == to.size()-1);
+        assert(static_cast<std::size_t>(from_next - from.data()) == to.size()-1);
+        assert(static_cast<std::size_t>(to_next - to.data()) == to.size()-1);
         assert(to.data() == std::string("some te"));
     }
 }

test/std/numerics/numarray/valarray.range/end_const.pass.cpp

 // template<class T> class valarray;
 
 // template <class T>
 //   unspecified1
 //   end(const valarray<T>& v);
 
 #include <valarray>
 #include <cassert>
+#include <cstddef>
 
 int main()
 {
     {
         typedef int T;
         T a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         const std::valarray<T> v(a, N);
         assert(v[v.size()-1] == 5);
-        assert(end(v) - begin(v) == v.size());
+        assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
 }

test/std/numerics/numarray/valarray.range/end_non_const.pass.cpp

 // template<class T> class valarray;
 
 // template <class T>
 //   unspecified1
 //   end(valarray<T>& v);
 
 #include <valarray>
 #include <cassert>
+#include <cstddef>
 
 int main()
 {
     {
         typedef int T;
         T a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
         *(end(v) - 1) = 10;
         assert(v[v.size()-1] == 10);
-        assert(end(v) - begin(v) == v.size());
+        assert(static_cast<std::size_t>(end(v) - begin(v)) == v.size());
     }
 }

test/std/re/re.results/re.results.acc/begin_end.pass.cpp

 
 // class match_results<BidirectionalIterator, Allocator>
 
 // const_iterator begin() const;
 // const_iterator end() const;
 
 #include <regex>
 #include <cassert>
+#include <cstddef>
 #include "test_macros.h"
 
 void
 test()
 {
     std::match_results<const char*> m;
     const char s[] = "abcdefghijk";
     assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
     std::match_results<const char*>::const_iterator i = m.begin();
     std::match_results<const char*>::const_iterator e = m.end();
 
-    assert(e - i == m.size());
+    assert(static_cast<std::size_t>(e - i) == m.size());
     for (int j = 0; i != e; ++i, ++j)
         assert(*i == m[j]);
 }
 
 int main()
 {
     test();
 }

test/std/re/re.results/re.results.acc/cbegin_cend.pass.cpp

 
 // class match_results<BidirectionalIterator, Allocator>
 
 // const_iterator cbegin() const;
 // const_iterator cend() const;
 
 #include <regex>
 #include <cassert>
+#include <cstddef>
 #include "test_macros.h"
 
 void
 test()
 {
     std::match_results<const char*> m;
     const char s[] = "abcdefghijk";
     assert(std::regex_search(s, m, std::regex("cd((e)fg)hi")));
 
     std::match_results<const char*>::const_iterator i = m.cbegin();
     std::match_results<const char*>::const_iterator e = m.cend();
 
-    assert(e - i == m.size());
+    assert(static_cast<std::size_t>(e - i) == m.size());
     for (int j = 0; i != e; ++i, ++j)
         assert(*i == m[j]);
 }
 
 int main()
 {
     test();
 }

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

 // <string>
 
 // basic_string(size_type n, charT c, const Allocator& a = Allocator());
 
 #include <string>
 #include <stdexcept>
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class charT>
 void
 test(unsigned n, charT c)

 test(Tp n, Tp c)
 {
     typedef char 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(n, c);
     LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
+    assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class Tp, class A>
 void
 test(Tp n, Tp c, const A& a)
 {
     typedef char charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
     S s2(n, c, a);
     LIBCPP_ASSERT(s2.__invariants());
-    assert(s2.size() == n);
+    assert(s2.size() == static_cast<std::size_t>(n));
     for (int i = 0; i < n; ++i)
         assert(s2[i] == c);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 int main()
 {

test/std/strings/basic.string/string.iterators/end.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 //       iterator end();
 // const_iterator end() const;
 
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::iterator e = s.end();
     typename S::const_iterator ce = cs.end();
     if (s.empty())
     {
         assert(e == s.begin());
         assert(ce == cs.begin());
     }
-    assert(e - s.begin() == s.size());
-    assert(ce - cs.begin() == cs.size());
+    assert(static_cast<std::size_t>(e - s.begin()) == s.size());
+    assert(static_cast<std::size_t>(ce - cs.begin()) == cs.size());
 }
 
 int main()
 {
     {
     typedef std::string S;
     test(S());
     test(S("123"));

test/std/strings/basic.string/string.iterators/rend.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 //       reverse_iterator rend();
 // const_reverse_iterator rend() const;
 
 #include <string>
 #include <cassert>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
     typename S::reverse_iterator e = s.rend();
     typename S::const_reverse_iterator ce = cs.rend();
     if (s.empty())
     {
         assert(e == s.rbegin());
         assert(ce == cs.rbegin());
     }
-    assert(e - s.rbegin() == s.size());
-    assert(ce - cs.rbegin() == cs.size());
+    assert(static_cast<std::size_t>(e - s.rbegin()) == s.size());
+    assert(static_cast<std::size_t>(ce - cs.rbegin()) == cs.size());
 }
 
 int main()
 {
     {
     typedef std::string S;
     test(S());
     test(S("123"));

test/std/strings/string.view/string.view.iterators/end.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const_iterator end() const;
 
 #include <string_view>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
test(S s)
     }
     else
     {
         assert(  e !=  s.begin());
         assert(ce1 != cs.begin());
         assert(ce2 !=  s.begin());
     }
 
-    assert(  e -  s.begin() == s.size());
-    assert(ce1 - cs.begin() == cs.size());
-    assert(ce2 - s.cbegin() == s.size());
+    assert(static_cast<std::size_t>(  e -  s.begin()) == s.size());
+    assert(static_cast<std::size_t>(ce1 - cs.begin()) == cs.size());
+    assert(static_cast<std::size_t>(ce2 - s.cbegin()) == s.size());
 
     assert(  e == ce1);
     assert(  e == ce2);
     assert(ce1 == ce2);
 }
 
 
 int main()

test/std/strings/string.view/string.view.iterators/rend.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <string_view>
 
 // constexpr const_iterator rend() const;
 
 #include <string_view>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 template <class S>
 void
 test(S s)
 {
     const S& cs = s;
test(S s)
     }
     else
     {
         assert(  e !=  s.rbegin());
         assert(ce1 != cs.rbegin());
         assert(ce2 !=  s.rbegin());
     }
 
-    assert(  e -  s.rbegin() == s.size());
-    assert(ce1 - cs.rbegin() == cs.size());
-    assert(ce2 - s.crbegin() == s.size());
+    assert(static_cast<std::size_t>(  e -  s.rbegin()) == s.size());
+    assert(static_cast<std::size_t>(ce1 - cs.rbegin()) == cs.size());
+    assert(static_cast<std::size_t>(ce2 - s.crbegin()) == s.size());
 
     assert(  e == ce1);
     assert(  e == ce2);
     assert(ce1 == ce2);
 }
 
 
 int main()