[libcxx] [test] Avoid MSVC truncation warnings.

[STL_MSFT]

Summary

[libcxx] [test] Avoid MSVC truncation warnings.

MSVC emits "warning C4244: 'initializing': conversion from 'int'
to 'short', possible loss of data" when it sees pair<Whatever, short>
constructed from (whatever, 4), because int is being truncated to
short within pair's constructor. (The compiler doesn't take into
account the fact that 4 is a literal at the callsite; it generates
this warning when the constructor is instantiated, because it might
be called with a runtime-valued int that would actually truncate.)

Instead of static_cast<short>, we can simply change short to int
in these tests, without affecting the pair operations that they're
trying to test: move assignment, convert copy construction, and
convert move construction.

[STL_MSFT]

Ping?

[STL_MSFT]

Approved by Eric.

test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

struct CountAssign {
   CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
 };
 int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
 int main()
 {
     {
-        typedef std::pair<std::unique_ptr<int>, short> P;
+        typedef std::pair<std::unique_ptr<int>, int> P;
         P p1(std::unique_ptr<int>(new int(3)), 4);
         P p2;
         p2 = std::move(p1);
         assert(*p2.first == 3);
         assert(p2.second == 4);
     }
     {
         using P = std::pair<int&, int&&>;

test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp

struct ImplicitT {
   constexpr ImplicitT(int x) : value(x) {}
   constexpr ImplicitT(ImplicitT const& o) : value(o.value) {}
   int value;
 };
 
 int main()
 {
     {
-        typedef std::pair<int, short> P1;
+        typedef std::pair<int, int> P1;
         typedef std::pair<double, long> P2;
         const P1 p1(3, 4);
         const P2 p2 = p1;
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
     {
         // We allow derived types to use this constructor
int main()
 
         test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType>();
         test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType const&, true, false>();
         test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&, true, false>();
         test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&&, true, false>();
     }
 #if TEST_STD_VER > 11
     {
-        typedef std::pair<int, short> P1;
+        typedef std::pair<int, int> P1;
         typedef std::pair<double, long> P2;
         constexpr P1 p1(3, 4);
         constexpr P2 p2 = p1;
         static_assert(p2.first == 3, "");
         static_assert(p2.second == 4, "");
     }
     {
         using P1 = std::pair<int, int>;

test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp

 struct ImplicitT {
   constexpr ImplicitT(int x) : value(x) {}
   int value;
 };
 
 int main()
 {
     {
-        typedef std::pair<std::unique_ptr<Derived>, short> P1;
+        typedef std::pair<std::unique_ptr<Derived>, int> P1;
         typedef std::pair<std::unique_ptr<Base>, long> P2;
         P1 p1(std::unique_ptr<Derived>(), 4);
         P2 p2 = std::move(p1);
         assert(p2.first == nullptr);
         assert(p2.second == 4);
     }
     {
         // We allow derived types to use this constructor