[libcxx] [test] Fix MSVC warning C4127 "conditional expression is constant".

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC warning C4127 "conditional expression is constant".

MSVC has a compiler warning (enabled at /W4) that's potentially useful,
although slightly annoying to library devs who know what they're doing.
In the latest version of the compiler, the warning is suppressed when the
compiler sees simple tests like "if (name_of_thing)", so extracting comparison
expressions into named constants is a workaround. This is useful for ensuring
that libraries are C4127-clean.

[STL_MSFT]

Actually, this pattern annoys "warning C6326: Potential comparison of a constant with another constant." from /analyze. I'll figure out a better fix, probably with integral_constant.

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp

int main()
 
     test_octal<uint16_t>(                "177777");
     test_octal< int16_t>(                "177777");
     test_octal<uint32_t>(           "37777777777");
     test_octal< int32_t>(           "37777777777");
     test_octal<uint64_t>("1777777777777777777777");
     test_octal< int64_t>("1777777777777777777777");
     test_octal<uint64_t>("1777777777777777777777");
-    if (sizeof(long) == sizeof(int64_t)) {
+
+    const bool long_is_64 = sizeof(long) == sizeof(int64_t);
+    const bool long_long_is_64 = sizeof(long long) == sizeof(int64_t);
+
+    if (long_is_64) {
         test_octal< unsigned long>("1777777777777777777777");
         test_octal<          long>("1777777777777777777777");
     }
-    if (sizeof(long long) == sizeof(int64_t)) {
+    if (long_long_is_64) {
         test_octal< unsigned long long>("1777777777777777777777");
         test_octal<          long long>("1777777777777777777777");
     }
 
     test_dec<uint16_t>(               "65535");
     test_dec< int16_t>(                  "-1");
     test_dec<uint32_t>(          "4294967295");
     test_dec< int32_t>(                  "-1");
     test_dec<uint64_t>("18446744073709551615");
     test_dec< int64_t>(                  "-1");
-    if (sizeof(long) == sizeof(int64_t)) {
+    if (long_is_64) {
         test_dec<unsigned long>("18446744073709551615");
         test_dec<         long>(                  "-1");
     }
-    if (sizeof(long long) == sizeof(int64_t)) {
+    if (long_long_is_64) {
         test_dec<unsigned long long>("18446744073709551615");
         test_dec<         long long>(                  "-1");
     }
 
     test_hex<uint16_t>(            "FFFF");
     test_hex< int16_t>(            "FFFF");
     test_hex<uint32_t>(        "FFFFFFFF");
     test_hex< int32_t>(        "FFFFFFFF");
     test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
     test_hex< int64_t>("FFFFFFFFFFFFFFFF");
-    if (sizeof(long) == sizeof(int64_t)) {
+    if (long_is_64) {
         test_hex<unsigned long>("FFFFFFFFFFFFFFFF");
         test_hex<         long>("FFFFFFFFFFFFFFFF");
     }
-    if (sizeof(long long) == sizeof(int64_t)) {
+    if (long_long_is_64) {
         test_hex<unsigned long long>("FFFFFFFFFFFFFFFF");
         test_hex<         long long>("FFFFFFFFFFFFFFFF");
     }
 }

test/std/utilities/function.objects/unord.hash/enum.pass.cpp

test()
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
     typedef typename std::underlying_type<T>::type under_type;
 
     H h1;
     std::hash<under_type> h2;
     for (int i = 0; i <= 5; ++i)
     {
         T t(static_cast<T> (i));
-        if (sizeof(T) <= sizeof(std::size_t))
+        const bool small = sizeof(T) <= sizeof(std::size_t);
+        if (small)
             assert(h1(t) == h2(static_cast<under_type>(i)));
     }
 }
 
 int main()
 {
     test<Cardinals>();
 
     test<Colors>();
     test<ShortColors>();
     test<LongColors>();
     test<EightBitColors>();
 
     test<Fruits>();
 }

test/std/utilities/function.objects/unord.hash/integral.pass.cpp

test()
     typedef std::hash<T> H;
     static_assert((std::is_same<typename H::argument_type, T>::value), "" );
     static_assert((std::is_same<typename H::result_type, std::size_t>::value), "" );
     H h;
 
     for (int i = 0; i <= 5; ++i)
     {
         T t(static_cast<T>(i));
-        if (sizeof(T) <= sizeof(std::size_t))
+        const bool small = sizeof(T) <= sizeof(std::size_t);
+        if (small)
         {
             const std::size_t result = h(t);
             LIBCPP_ASSERT(result == static_cast<size_t>(t));
             ((void)result); // Prevent unused warning
         }
     }
 }
 

test/std/utilities/template.bitset/bitset.members/all.pass.cpp

 template <std::size_t N>
 void test_all()
 {
     std::bitset<N> v;
     v.reset();
     assert(v.all() == (N == 0));
     v.set();
     assert(v.all() == true);
-    if (N > 1)
+    const bool greater_than_1 = N > 1;
+    if (greater_than_1)
     {
         v[N/2] = false;
         assert(v.all() == false);
     }
 }
 
 int main()
 {

test/std/utilities/template.bitset/bitset.members/any.pass.cpp

 template <std::size_t N>
 void test_any()
 {
     std::bitset<N> v;
     v.reset();
     assert(v.any() == false);
     v.set();
     assert(v.any() == (N != 0));
-    if (N > 1)
+    const bool greater_than_1 = N > 1;
+    if (greater_than_1)
     {
         v[N/2] = false;
         assert(v.any() == true);
         v.reset();
         v[N/2] = true;
         assert(v.any() == true);
     }
 }

test/std/utilities/template.bitset/bitset.members/index.pass.cpp

for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);
     return v;
 }
 
 template <std::size_t N>
 void test_index_const()
 {
     std::bitset<N> v1 = make_bitset<N>();
-    if (N > 0)
+    const bool greater_than_0 = N > 0;
+    if (greater_than_0)
     {
         assert(v1[N/2] == v1.test(N/2));
         typename std::bitset<N>::reference r = v1[N/2];
         assert(r == v1.test(N/2));
         typename std::bitset<N>::reference r2 = v1[N/2];
         r = r2;
         assert(r == v1.test(N/2));
         r = false;

test/std/utilities/template.bitset/bitset.members/index_const.pass.cpp

for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);
     return v;
 }
 
 template <std::size_t N>
 void test_index_const()
 {
     const std::bitset<N> v1 = make_bitset<N>();
-    if (N > 0)
+    const bool greater_than_0 = N > 0;
+    if (greater_than_0)
     {
         assert(v1[N/2] == v1.test(N/2));
     }
 }
 
 int main()
 {
     test_index_const<0>();

test/std/utilities/template.bitset/bitset.members/none.pass.cpp

 template <std::size_t N>
 void test_none()
 {
     std::bitset<N> v;
     v.reset();
     assert(v.none() == true);
     v.set();
     assert(v.none() == (N == 0));
-    if (N > 1)
+    const bool greater_than_1 = N > 1;
+    if (greater_than_1)
     {
         v[N/2] = false;
         assert(v.none() == false);
         v.reset();
         v[N/2] = true;
         assert(v.none() == false);
     }
 }

test/std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp

 }
 
 template <std::size_t N>
 void test_equality()
 {
     const std::bitset<N> v1 = make_bitset<N>();
     std::bitset<N> v2 = v1;
     assert(v1 == v2);
-    if (N > 0)
+    const bool greater_than_0 = N > 0;
+    if (greater_than_0)
     {
         v2[N/2].flip();
         assert(v1 != v2);
     }
 }
 
 int main()
 {