[libc++][test] Miscellaneous MSVC cleanups

[CaseyCarter]

Summary

• Silence unused-local-typedef warnings: map.cons/assign_initializer_list.pass.cpp (and the set.cons variant) uses a local typedef only within LIBCPP_ASSERTs, so clang diagnoses it as unused when testing non-libc++.

• Add missing include: c.math/abs.pass.cpp uses std::numeric_limits but failed to #include <limits>.

• Don't test non-type: A "recent" change to meta.trans.other/underlying_type.pass.cpp unconditionally tests the type F which is conditionally defined.

• Use hash<long long> instead of hash<short> with int in unordered_meow deduction guide tests to avoid truncation warnings.

• Convert 3.14 explicitly in midpoint.float.pass since MSVC incorrectly diagnoses float meow = 3.14; as truncating.

[• Quuxplusone]

test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

70 ↗

(On Diff #223974)

Alternatively, if you wanted to change the instances of hash<short> to hash<>, that would be fine with me. (Just as long as it's something distinguishable from the default of hash<int>.)

[CaseyCarter]

test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

70 ↗

(On Diff #223974)

I do like the idea of avoiding rather than suppressing the warning. I'll change these tests to use hash<long long> instead of hash<short>, which avoids truncating conversions and preserves the "neither int nor long" property which provides some assurance the deduction guides aren't getting the type from the key type or mapped type.

[CaseyCarter]

Avoid rather than suppress truncation warnings in unordered_meow deduction guide tests.

[• Quuxplusone]

test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

70 ↗

(On Diff #223974)

Awesome. The CTAD tests LGTM! No opinion on the rest.

(It occurs to me that CTAD makes std::hash() mean std::hash<void>(), so maybe I should have avoided hash<void> and equal_to<void> in these tests to begin with.)

[ldionne]

You have commit access, right? If so, go ahead. Otherwise, LMK and I can commit this for you.

[CaseyCarter]

In D68681#1702194, @ldionne wrote:

You have commit access, right? If so, go ahead. Otherwise, LMK and I can commit this for you.

Yes, I apparently still have commit access ;) Thanks!

libcxx/test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp

void test_basic() {
     assert(*next(m.begin()) == V(2, 1));
     assert(*next(m.begin(), 2) == V(3, 1));
     }
 }
 
 
 void duplicate_keys_test() {
   typedef std::map<int, int, std::less<int>, test_allocator<std::pair<const int, int> > > Map;
-  typedef test_alloc_base AllocBase;
   {
-    LIBCPP_ASSERT(AllocBase::alloc_count == 0);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
     Map s = {{1, 0}, {2, 0}, {3, 0}};
-    LIBCPP_ASSERT(AllocBase::alloc_count == 3);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 3);
     s = {{4, 0}, {4, 0}, {4, 0}, {4, 0}};
-    LIBCPP_ASSERT(AllocBase::alloc_count == 1);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 1);
     assert(s.size() == 1);
     assert(s.begin()->first == 4);
   }
-  LIBCPP_ASSERT(AllocBase::alloc_count == 0);
+  LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
 }
 
 int main(int, char**)
 {
-    test_basic();
-    duplicate_keys_test();
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp

void basic_test() {
     assert(*++i == V(4));
     assert(*++i == V(5));
     assert(*++i == V(6));
   }
 }
 
 void duplicate_keys_test() {
   typedef std::set<int, std::less<int>, test_allocator<int> > Set;
-  typedef test_alloc_base AllocBase;
   {
-    LIBCPP_ASSERT(AllocBase::alloc_count == 0);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
     Set s = {1, 2, 3};
-    LIBCPP_ASSERT(AllocBase::alloc_count == 3);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 3);
     s = {4, 4, 4, 4, 4};
-    LIBCPP_ASSERT(AllocBase::alloc_count == 1);
+    LIBCPP_ASSERT(test_alloc_base::alloc_count == 1);
     assert(s.size() == 1);
     assert(*s.begin() == 4);
   }
-  LIBCPP_ASSERT(AllocBase::alloc_count == 0);
+  LIBCPP_ASSERT(test_alloc_base::alloc_count == 0);
 }
 
 int main(int, char**) {
   basic_test();
   duplicate_keys_test();
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp

int main(int, char**)
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
     std::unordered_map m(std::begin(arr), std::end(arr), 42);
     ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
-    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>());
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>>);
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>());
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
-    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>());
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>);
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
-    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 41));
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), std::equal_to<>(), test_allocator<PC>(0, 41));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 41);
     }
 
     {
     std::unordered_map<int, long> source;
     std::unordered_map m(source);
     ASSERT_SAME_TYPE(decltype(m), decltype(source));
     assert(m.size() == 0);
     }
 
     {
     std::unordered_map<int, long> source;
     std::unordered_map m{source};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(m), decltype(source));
     assert(m.size() == 0);
     }
 
     {
-    std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source;
+    std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>> source;
     test_allocator<PC> a(0, 42);
     std::unordered_map m(source, a);
     ASSERT_SAME_TYPE(decltype(m), decltype(source));
     assert(m.get_allocator().get_id() == 42);
     assert(m.size() == 0);
     }
 
     {
-    std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source;
+    std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>> source;
     test_allocator<PC> a(0, 43);
     std::unordered_map m{source, a};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(m), decltype(source));
     assert(m.get_allocator().get_id() == 43);
     assert(m.size() == 0);
     }
 
     {
     std::unordered_map m { P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} };
     ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
     std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42);
     ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
-    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>());
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>>);
+    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>());
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
-    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>());
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>);
+    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), std::equal_to<>());
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     }
 
     {
-    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44));
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>);
+    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<PC>(0, 44));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 44);
     }
 
     {
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
     std::unordered_map m(std::begin(arr), std::end(arr), 42, test_allocator<PC>(0, 45));
     ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 45);
     }
 
     {
     const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} };
-    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<PC>(0, 46));
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<PC>(0, 46));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 46);
     }
 
     {
     std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, test_allocator<PC>(0, 47));
     ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<int>, std::equal_to<int>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 47);
     }
 
     {
-    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48));
-    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>);
+    std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), test_allocator<PC>(0, 48));
+    ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>, test_allocator<PC>>);
     assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m)));
     assert(m.get_allocator().get_id() == 48);
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp

int main(int, char**)
     std::unordered_multiset s(std::begin(arr), std::end(arr), 42);
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>());
+    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 40));
+    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 40));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 40);
     }
 
     {
-    std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_multiset s(source);
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     }
 
     {
-    std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_multiset s{source};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     }
 
     {
-    std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_multiset s(source, test_allocator<int>(0, 41));
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     assert(s.get_allocator().get_id() == 41);
     }
 
     {
-    std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_multiset s{source, test_allocator<int>(0, 42)};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     assert(s.get_allocator().get_id() == 42);
     }
 
     {
     std::unordered_multiset s{ 1, 2, 1, INT_MAX, 3 };
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42);
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>());
+    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>());
+    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<int>(0, 43));
+    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<int>(0, 43));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 43);
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
     std::unordered_multiset s(std::begin(arr), std::end(arr), 42, test_allocator<int>(0, 44));
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 44);
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 44));
+    std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 44));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 44);
     }
 
     {
     std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, test_allocator<int>(0, 43));
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 43);
     }
 
     {
-    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), test_allocator<int>(0, 42));
+    std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), test_allocator<int>(0, 42));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 42);
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp

int main(int, char**)
     std::unordered_set s(std::begin(arr), std::end(arr), 42);
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>());
+    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 40));
+    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 40));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 40);
     }
 
     {
-    std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_set s(source);
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     }
 
     {
-    std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_set s{source};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     }
 
     {
-    std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_set s(source, test_allocator<int>(0, 41));
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     assert(s.get_allocator().get_id() == 41);
     }
 
     {
-    std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source;
+    std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source;
     std::unordered_set s{source, test_allocator<int>(0, 42)};  // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s.size() == 0);
     assert(s.get_allocator().get_id() == 42);
     }
 
     {
     std::unordered_set s{ 1, 2, 1, INT_MAX, 3 };
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
     std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42);
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>());
+    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>());
+    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>());
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     }
 
     {
-    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<int>(0, 43));
+    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<int>(0, 43));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 43);
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
     std::unordered_set s(std::begin(arr), std::end(arr), 42, test_allocator<int>(0, 44));
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 44);
     }
 
     {
     const int arr[] = { 1, 2, 1, INT_MAX, 3 };
-    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 44));
+    std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 44));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 44);
     }
 
     {
     std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, test_allocator<int>(0, 43));
 
     ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 43);
     }
 
     {
-    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), test_allocator<int>(0, 42));
+    std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), test_allocator<int>(0, 42));
 
-    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>);
+    ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>);
     assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s)));
     assert(s.get_allocator().get_id() == 42);
     }
 
     return 0;
 }

libcxx/test/std/numerics/c.math/abs.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <assert.h>
 #include <cmath>
 #include <cstdint>
+#include <limits>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template<class T>
 struct correct_size_int
 {
     typedef typename std::conditional<sizeof(T) < sizeof(int), int, T>::type type;
int main(int, char**)
     test_abs<long double, long double>();
     test_abs<double, double>();
     test_abs<float, float>();
 
     test_big();
 
     return 0;
 }
-

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp

 template <typename T>
 void fp_test()
 {
     ASSERT_SAME_TYPE(T, decltype(std::midpoint(T(), T())));
     ASSERT_NOEXCEPT(             std::midpoint(T(), T()));
 
     constexpr T maxV = std::numeric_limits<T>::max();
     constexpr T minV = std::numeric_limits<T>::min();
-    
 //  Things that can be compared exactly
     static_assert((std::midpoint(T(0), T(0))   == T(0)),   "");
     static_assert((std::midpoint(T(2), T(4))   == T(3)),   "");
     static_assert((std::midpoint(T(4), T(2))   == T(3)),   "");
     static_assert((std::midpoint(T(3), T(4))   == T(3.5)), "");
     static_assert((std::midpoint(T(0), T(0.4)) == T(0.2)), "");
 
 //  Things that can't be compared exactly
     constexpr T pct = fp_error_pct<T>();
     assert((fptest_close_pct(std::midpoint(T( 1.3), T(11.4)), T( 6.35),    pct)));
     assert((fptest_close_pct(std::midpoint(T(11.33), T(31.45)), T(21.39),  pct)));
     assert((fptest_close_pct(std::midpoint(T(-1.3), T(11.4)), T( 5.05),    pct)));
     assert((fptest_close_pct(std::midpoint(T(11.4), T(-1.3)), T( 5.05),    pct)));
     assert((fptest_close_pct(std::midpoint(T(0.1),  T(0.4)),  T(0.25),     pct)));
 
     assert((fptest_close_pct(std::midpoint(T(11.2345), T(14.5432)), T(12.88885),  pct)));
-    
 //  From e to pi
     assert((fptest_close_pct(std::midpoint(T(2.71828182845904523536028747135266249775724709369995),
                                       T(3.14159265358979323846264338327950288419716939937510)),
                                       T(2.92993724102441923691146542731608269097720824653752),  pct)));
 
     assert((fptest_close_pct(std::midpoint(maxV, T(0)), maxV/2, pct)));
     assert((fptest_close_pct(std::midpoint(T(0), maxV), maxV/2, pct)));
     assert((fptest_close_pct(std::midpoint(minV, T(0)), minV/2, pct)));

 //  Big numbers of different signs
     assert((fptest_close_pct(std::midpoint(maxV*T( 0.75),  maxV*T(-0.5)), maxV*T( 0.125), pct)));
     assert((fptest_close_pct(std::midpoint(maxV*T(-0.75),  maxV*T( 0.5)), maxV*T(-0.125), pct)));
 
 //  Denormalized values
 //  TODO
 
 //  Check two values "close to each other"
-    T d1 = 3.14;
+    T d1 = T(3.14);
     T d0 = std::nextafter(d1, T(2));
     T d2 = std::nextafter(d1, T(5));
     assert(d0 < d1);  // sanity checking
     assert(d1 < d2);  // sanity checking
 
 #if defined(__PPC__) && __LONG_DOUBLE_128__ && !__LONG_DOUBLE_IEEE128__
 //  For 128 bit long double implemented as 2 doubles on PowerPC,
 //  nextafterl() of libm gives imprecise results which fails the

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp

 #endif
 
 template <typename T, typename Expected>
 void check()
 {
     ASSERT_SAME_TYPE(Expected, typename std::underlying_type<T>::type);
 #if TEST_STD_VER > 11
     ASSERT_SAME_TYPE(Expected, typename std::underlying_type_t<T>);
-#endif  
+#endif
 }
 
 enum E { V = INT_MIN };
 
 #ifdef TEST_UNSIGNED_UNDERLYING_TYPE
 enum F { W = UINT_MAX };
 #endif // TEST_UNSIGNED_UNDERLYING_TYPE
 
#if TEST_STD_VER >= 11
     check<I, long>();
     check<J, int>();
     check<K, short>();
 #endif
 
 //  SFINAE-able underlying_type
 #if TEST_STD_VER > 17
     static_assert( has_type_member<E>::value, "");
+#ifdef TEST_UNSIGNED_UNDERLYING_TYPE
     static_assert( has_type_member<F>::value, "");
+#endif // TEST_UNSIGNED_UNDERLYING_TYPE
     static_assert( has_type_member<G>::value, "");
 
     static_assert(!has_type_member<void>::value, "");
     static_assert(!has_type_member<int>::value, "");
     static_assert(!has_type_member<double>::value, "");
     static_assert(!has_type_member<int[]>::value, "");
     static_assert(!has_type_member<S>::value, "");
     static_assert(!has_type_member<void (S::*)(int)>::value, "");