[libcxx] [test] Fix MSVC warnings C4127 and C6326 about constants.

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC warnings C4127 and C6326 about constants.

MSVC has compiler warnings C4127 "conditional expression is constant" (enabled
by /W4) and C6326 "Potential comparison of a constant with another constant"
(enabled by /analyze). They're potentially useful, although they're slightly
annoying to library devs who know what they're doing. In the latest version of
the compiler, C4127 is suppressed when the compiler sees simple tests like
"if (name_of_thing)", so extracting comparison expressions into named
constants is a workaround. At the same time, using std::integral_constant
avoids C6326, which doesn't look at template arguments.

test/std/containers/sequences/vector.bool/emplace.pass.cpp
Replace 1 == 1 with true, which is the same as far as the library is concerned.

[EricWF]

The changes sure look funny but I have no issue with them.

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

int main()
         assert(c.front() == false);
 
         i = c.emplace(c.cend(), true);
         assert(i == c.end()-1);
         assert(c.size() == 2);
         assert(c.front() == false);
         assert(c.back() == true);
 
-        i = c.emplace(c.cbegin()+1, 1 == 1);
+        i = c.emplace(c.cbegin()+1, true);
         assert(i == c.begin()+1);
         assert(c.size() == 3);
         assert(c.front() == false);
         assert(c[1] == true);
         assert(c.back() == true);
     }
     {
         typedef std::vector<bool, min_allocator<bool>> C;
         C c;
 
         C::iterator i = c.emplace(c.cbegin());
         assert(i == c.begin());
         assert(c.size() == 1);
         assert(c.front() == false);
 
         i = c.emplace(c.cend(), true);
         assert(i == c.end()-1);
         assert(c.size() == 2);
         assert(c.front() == false);
         assert(c.back() == true);
 
-        i = c.emplace(c.cbegin()+1, 1 == 1);
+        i = c.emplace(c.cbegin()+1, true);
         assert(i == c.begin()+1);
         assert(c.size() == 3);
         assert(c.size() == 3);
         assert(c.front() == false);
         assert(c[1] == true);
         assert(c.back() == true);
     }
 }

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

 // operator<<(uint32_t val);
 // operator<<( int64_t val);
 // operator<<(uint64_t val);
 
 //  Testing to make sure that the max length values are correctly inserted
 
 #include <sstream>
 #include <ios>
+#include <type_traits>
 #include <cctype>
 #include <cstdint>
 #include <cassert>
 
 template <typename T>
 void test_octal(const char *expected)
 {
     std::stringstream ss;
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 = std::integral_constant<bool, sizeof(long) == sizeof(int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(int64_t)>::value; // avoid compiler warnings
+
+    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 = std::integral_constant<bool, sizeof(T) <= sizeof(std::size_t)>::value; // avoid compiler warnings
+        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 = std::integral_constant<bool, sizeof(T) <= sizeof(std::size_t)>::value; // avoid compiler warnings
+        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

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // test bool all() const;
 
 #include <bitset>
+#include <type_traits>
 #include <cassert>
 
 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 = std::integral_constant<bool, (N > 1)>::value; // avoid compiler warnings
+    if (greater_than_1)
     {
         v[N/2] = false;
         assert(v.all() == false);
     }
 }
 
 int main()
 {

test/std/utilities/template.bitset/bitset.members/any.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.
 //
 //===----------------------------------------------------------------------===//
 
 // test bool any() const;
 
 #include <bitset>
+#include <type_traits>
 #include <cassert>
 
 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 = std::integral_constant<bool, (N > 1)>::value; // avoid compiler warnings
+    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

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // test bitset<N>::reference operator[](size_t pos);
 
 #include <bitset>
+#include <type_traits>
 #include <cstdlib>
 #include <cassert>
 
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
 #endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     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 = std::integral_constant<bool, (N > 0)>::value; // avoid compiler warnings
+    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

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // test constexpr bool operator[](size_t pos) const;
 
 #include <bitset>
+#include <type_traits>
 #include <cstdlib>
 #include <cassert>
 
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
 #endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     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 = std::integral_constant<bool, (N > 0)>::value; // avoid compiler warnings
+    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

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // test bool none() const;
 
 #include <bitset>
+#include <type_traits>
 #include <cassert>
 
 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 = std::integral_constant<bool, (N > 1)>::value; // avoid compiler warnings
+    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

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // test:
 
 // bool operator==(const bitset<N>& rhs) const;
 // bool operator!=(const bitset<N>& rhs) const;
 
 #include <bitset>
+#include <type_traits>
 #include <cstdlib>
 #include <cassert>
 
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wtautological-compare"
 #endif
 
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     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_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 = std::integral_constant<bool, (N > 0)>::value; // avoid compiler warnings
+    if (greater_than_0)
     {
         v2[N/2].flip();
         assert(v1 != v2);
     }
 }
 
 int main()
 {

test/std/utilities/template.bitset/bitset.members/to_ullong.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.
 //
 //===----------------------------------------------------------------------===//
 
 // test unsigned long long to_ullong() const;
 
 #include <bitset>
 #include <algorithm>
+#include <type_traits>
 #include <climits>
 #include <cassert>
 
 template <std::size_t N>
 void test_to_ullong()
 {
     const std::size_t M = sizeof(unsigned long long) * CHAR_BIT < N ? sizeof(unsigned long long) * CHAR_BIT : N;
-    const std::size_t X = M == 0 ? sizeof(unsigned long long) * CHAR_BIT - 1 : sizeof(unsigned long long) * CHAR_BIT - M;
-    const unsigned long long max = M == 0 ? 0 : (unsigned long long)(-1) >> X;
+    const bool is_M_zero = std::integral_constant<bool, M == 0>::value; // avoid compiler warnings
+    const std::size_t X = is_M_zero ? sizeof(unsigned long long) * CHAR_BIT - 1 : sizeof(unsigned long long) * CHAR_BIT - M;
+    const unsigned long long max = is_M_zero ? 0 : (unsigned long long)(-1) >> X;
     unsigned long long tests[] = {0,
                            std::min<unsigned long long>(1, max),
                            std::min<unsigned long long>(2, max),
                            std::min<unsigned long long>(3, max),
                            std::min(max, max-3),
                            std::min(max, max-2),
                            std::min(max, max-1),
                            max};

test/std/utilities/template.bitset/bitset.members/to_ulong.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.
 //
 //===----------------------------------------------------------------------===//
 
 // test unsigned long to_ulong() const;
 
 #include <bitset>
 #include <algorithm>
+#include <type_traits>
 #include <limits>
 #include <climits>
 #include <cassert>
 
 template <std::size_t N>
 void test_to_ulong()
 {
     const std::size_t M = sizeof(unsigned long) * CHAR_BIT < N ? sizeof(unsigned long) * CHAR_BIT : N;
-    const std::size_t X = M == 0 ? sizeof(unsigned long) * CHAR_BIT - 1 : sizeof(unsigned long) * CHAR_BIT - M;
-    const std::size_t max = M == 0 ? 0 : std::size_t(std::numeric_limits<unsigned long>::max()) >> X;
+    const bool is_M_zero = std::integral_constant<bool, M == 0>::value; // avoid compiler warnings
+    const std::size_t X = is_M_zero ? sizeof(unsigned long) * CHAR_BIT - 1 : sizeof(unsigned long) * CHAR_BIT - M;
+    const std::size_t max = is_M_zero ? 0 : std::size_t(std::numeric_limits<unsigned long>::max()) >> X;
     std::size_t tests[] = {0,
                            std::min<std::size_t>(1, max),
                            std::min<std::size_t>(2, max),
                            std::min<std::size_t>(3, max),
                            std::min(max, max-3),
                            std::min(max, max-2),
                            std::min(max, max-1),
                            max};