[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 6/7.

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 6/7.

test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
(Affects 64-bit architectures.) Include <cstddef> so we can take/return std::ptrdiff_t
(instead of int) in random_shuffle()'s RNG. (C++14 D.12 [depr.alg.random.shuffle]/2 says that
difference_type is used, and we're shuffling a plain array.)

test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
(Affects 64-bit architectures.) Include <iterator> because we're already using iterator_traits.
Then, store the result of subtracting two RanIts as difference_type instead of long
(which truncates on LLP64 architectures like MSVC x64).

test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.pass.cpp
test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.pass.cpp
(Affects 64-bit architectures.) Include <cstddef> so we can store the result of
subtracting two pointers as std::ptrdiff_t (instead of int).

test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp
(Affects 32-bit architectures.) Sometimes, size_t is too small. That's the case here,
where tellg() returns pos_type (N4606 27.7.2.3 [istream.unformatted]/39). Implementations can
have 64-bit pos_type (to handle large files) even when they have 32-bit size_t.

[EricWF]

LGTM.

test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp

 // template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
 //   requires ShuffleIterator<Iter>
 //         && Convertible<Rand::result_type, Iter::difference_type>
 //   void
 //   random_shuffle(Iter first, Iter last, Rand&& rand);
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
 
 #include "test_macros.h"
 
 struct gen
 {
-    int operator()(int n)
+    std::ptrdiff_t operator()(std::ptrdiff_t n)
     {
         return n-1;
     }
 };
 
 int main()
 {
     int ia[] = {1, 2, 3, 4};
     int ia1[] = {4, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     gen r;
     std::random_shuffle(ia, ia+sa, r);
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
     assert(std::is_permutation(ia, ia+sa, ia1));
 }

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

 
 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter>
 //         && LessThanComparable<Iter::value_type>
 //   void
 //   sort(Iter first, Iter last);
 
 #include <algorithm>
+#include <iterator>
 #include <cassert>
 
 template <class RI>
 void
 test_sort_helper(RI f, RI l)
 {
     typedef typename std::iterator_traits<RI>::value_type value_type;
+    typedef typename std::iterator_traits<RI>::difference_type difference_type;
+
     if (f != l)
     {
-        long len = l - f;
+        difference_type len = l - f;
         value_type* save(new value_type[len]);
         do
         {
             std::copy(f, l, save);
             std::sort(save, save+len);
             assert(std::is_sorted(save, save+len));
         } while (std::next_permutation(f, l));
         delete [] save;

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

 
 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter>
 //         && LessThanComparable<Iter::value_type>
 //   void
 //   stable_sort(Iter first, Iter last);
 
 #include <algorithm>
+#include <iterator>
 #include <cassert>
 
 template <class RI>
 void
 test_sort_helper(RI f, RI l)
 {
     typedef typename std::iterator_traits<RI>::value_type value_type;
+    typedef typename std::iterator_traits<RI>::difference_type difference_type;
+
     if (f != l)
     {
-        long len = l - f;
+        difference_type len = l - f;
         value_type* save(new value_type[len]);
         do
         {
             std::copy(f, l, save);
             std::stable_sort(save, save+len);
             assert(std::is_sorted(save, save+len));
         } while (std::next_permutation(f, l));
         delete [] save;

test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_flist.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>
 
 // void splice_after(const_iterator p, forward_list&& x);
 
 #include <forward_list>
 #include <cassert>
 #include <iterator>
+#include <cstddef>
 
 #include "min_allocator.h"
 
 typedef int T;
 const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7};
 const T t2[] = {10, 11, 12, 13, 14, 15};
-const int size_t1 = std::end(t1) - std::begin(t1);
-const int size_t2 = std::end(t2) - std::begin(t2);
+const std::ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
+const std::ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
 
 template <class C>
 void
 testd(const C& c, int p, int l)
 {
     typename C::const_iterator i = c.begin();
     int n1 = 0;
     for (; n1 < p; ++n1, ++i)

test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_one.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>
 
 // void splice_after(const_iterator p, forward_list&& x, const_iterator i);
 
 #include <forward_list>
 #include <cassert>
 #include <iterator>
+#include <cstddef>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 typedef int T;
 const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7};
 const T t2[] = {10, 11, 12};
-const int size_t1 = std::end(t1) - std::begin(t1);
-const int size_t2 = std::end(t2) - std::begin(t2);
+const std::ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
+const std::ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
 
 template <class C>
 void
 testd(const C& c, int p, int f)
 {
     typename C::const_iterator i = c.begin();
     int n1 = 0;
     for (; n1 < p; ++n1, ++i)

test/std/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp

int main()
     int bad=-1;
     std::ostringstream os;
     os << "aaaabbbb" << static_cast<char>(bad)
        << "ccccdddd" << std::endl;
     std::string s=os.str();
 
     std::istringstream is(s);
     const unsigned int ignoreLen=10;
-    size_t a=is.tellg();
+    std::istringstream::pos_type a=is.tellg();
     is.ignore(ignoreLen);
-    size_t b=is.tellg();
+    std::istringstream::pos_type b=is.tellg();
     assert((b-a)==ignoreLen);
 }