[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 3/4.

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 3/4.

test/std/containers/sequences/vector.bool/copy.pass.cpp
test/std/containers/sequences/vector.bool/copy_alloc.pass.cpp
test/std/containers/sequences/vector/vector.cons/copy.pass.cpp
test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp
Change "unsigned s = x.size();" to "typename C::size_type s = x.size();"
because that's what it returns.

test/std/strings/basic.string/string.cons/pointer_alloc.pass.cpp
Include <cstddef>, then change "unsigned n = T::length(s);"
to "std::size_t n = T::length(s);" because that's what char_traits returns.

test/std/strings/basic.string/string.cons/substr.pass.cpp
Change unsigned to typename S::size_type because that's what str.size() returns.

test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
This was needlessly truncating std::size_t to unsigned.
It's being used to compare and initialize std::size_t.

[EricWF]

LGTM

[STL_MSFT]

Thanks, r288753.

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

 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x)
 {
-    unsigned s = x.size();
+    typename C::size_type s = x.size();
     C c(x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
 
 int main()
 {

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

 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class C>
 void
 test(const C& x, const typename C::allocator_type& a)
 {
-    unsigned s = x.size();
+    typename C::size_type s = x.size();
     C c(x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
 }
 
 int main()
 {

test/std/containers/sequences/vector/vector.cons/copy.pass.cpp

 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
 void
 test(const C& x)
 {
-    unsigned s = x.size();
+    typename C::size_type s = x.size();
     C c(x);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
 int main()

test/std/containers/sequences/vector/vector.cons/copy_alloc.pass.cpp

 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 template <class C>
 void
 test(const C& x, const typename C::allocator_type& a)
 {
-    unsigned s = x.size();
+    typename C::size_type s = x.size();
     C c(x, a);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == s);
     assert(c == x);
     LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
 }
 
 int main()

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

 // <string>
 
 // basic_string(const charT* s, 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(const charT* s)
 {
     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;
-    unsigned n = T::length(s);
+    std::size_t n = T::length(s);
     S s2(s);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class charT, class A>
 void
 test(const charT* s, const A& a)
 {
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     typedef typename S::traits_type T;
-    unsigned n = T::length(s);
+    std::size_t n = T::length(s);
     S s2(s, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == n);
     assert(T::compare(s2.data(), s, n) == 0);
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 

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

 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos);
         LIBCPP_ASSERT(s2.__invariants());
-        unsigned rlen = str.size() - pos;
+        typename S::size_type rlen = str.size() - pos;
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {

 test(S str, unsigned pos, unsigned n)
 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
     if (pos <= str.size())
     {
         S s2(str, pos, n);
         LIBCPP_ASSERT(s2.__invariants());
-        unsigned rlen = std::min<unsigned>(str.size() - pos, n);
+        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == A());
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {

 {
     typedef typename S::traits_type T;
     typedef typename S::allocator_type A;
 
     if (pos <= str.size())
     {
         S s2(str, pos, n, a);
         LIBCPP_ASSERT(s2.__invariants());
-        unsigned rlen = std::min<unsigned>(str.size() - pos, n);
+        typename S::size_type rlen = std::min<typename S::size_type>(str.size() - pos, n);
         assert(s2.size() == rlen);
         assert(T::compare(s2.data(), str.data() + pos, rlen) == 0);
         assert(s2.get_allocator() == a);
         assert(s2.capacity() >= s2.size());
     }
 #ifndef TEST_HAS_NO_EXCEPTIONS
     else
     {

test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp

 #include "test_macros.h"
 
 template <std::size_t N>
 void test_val_ctor()
 {
     {
         TEST_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
         assert(v.size() == N);
-        unsigned M = std::min<std::size_t>(N, 64);
+        std::size_t M = std::min<std::size_t>(N, 64);
         for (std::size_t i = 0; i < M; ++i)
             assert(v[i] == ((i & 1) != 0));
         for (std::size_t i = M; i < N; ++i)
             assert(v[i] == false);
     }
 #if TEST_STD_VER >= 11
     {
         constexpr std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);