[libc++] Void-cast runtime-unused variables.

[STL_MSFT]

Summary

[libc++] Void-cast runtime-unused variables.

Also, remove unused names in exception handlers, remove an unused array, move a conditionally-used array, and remove unused argc/argv.

Fixes MSVC "warning C4101: unreferenced local variable".

[STL_MSFT]

Are there any issues with these changes? I tried to follow the existing practice for void-casting, including the comment (although the comments varied).

[EricWF]

One inline change requested.

test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

24420

Isn't this unused as well on non-apple platforms?

24421

Move str inside the #ifdef __APPLE__ instead.

test/std/numerics/rand/rand.device/eval.pass.cpp

33

This looks OK, but I noticed that *technically* the spec only says the exception type is derived from std::exception.

However if we can keep testing this exception without bothering anybody I say we do.

[STL_MSFT]

This moves "str" as requested. It also adds void casts to another file, and removes an unused argc/argv pair.

[dblaikie]

I'm not sure why we'd want to compile the test suite with -Wunused-variable
(& even if we did, I imagine Clang's doesn't fire here because the
variables are used, just in non-evaluated contexts?)? Is there a benefit to
it being clean of unused-variable warnings? (in Clang's test case we just
aggressively disable warnings rather than making all the code warning
clean, for example)

[STL_MSFT]

What I'm doing is running libcxx's tests against MSVC's compiler and libraries. I could aggressively suppress warnings (and indeed I'm doing that for the noisiest, lowest-value warnings), but instead I'm building the tests with /W4 (our highest supported level). It is indeed somewhat annoying to make tests warning-free, although it does find real issues occasionally (e.g. the broken assert that I reported first). The real value is verifying that the headers are warning-free, which has the potential to catch issues in the product code. This is possibly a difference in philosophy between VC's STL and libc++, because I believe libc++ uses the "system header" behavior to avoid all warnings from system headers.

test/std/numerics/rand/rand.device/eval.pass.cpp

33

This one's problematic for MSVC for other reasons, but I have no issue with system_error here, so I haven't changed it.

[STL_MSFT]

[David Blaikie]

Unused-variable seems pretty low value.

Yeah, but it still has the potential to detect mistakes (e.g. typos, or code you intended to write but forgot about).

I figured I'd submit a patch, since there weren't actually that many occurrences, and they were all easy to silence in a targeted manner, following existing conventions.

*nod* just a question of whether the work is worth it - which is mostly totally up to you (& you've decided it's worth it for you)

For the time being, I've decided that fixing signed/unsigned mismatch and similar warnings is too much work, so I'm globally suppressing them. (There were hundreds.)

My main concern is that this bar will be hard to maintain/will likely rot over time, which reduces the value of establishing it
(especially when doing so involves adding code like the void casts in many places).

When my work is finished (currently 3132 tests are passing out of 4541), I expect that we'll start running libcxx's tests in our automation, which will detect regressions rapidly and reliably.

For this particular warning, the suppression mechanism is super simple and easy to maintain (if you don't mention a variable at runtime, have the void cast).

Do you need to run the test cases with warnings enabled to catch them in the STL with MSVC?

Yes. Gotta instantiate stuff.

There are two main scenarios in which you'd want to see warnings in the STL. The first is when the STL itself is doing something bad. The second is when user code causes the STL to do something bad. For example, giving less<int32_t> to an STL algorithm with an int64_t range. That'll truncate, but the truncation happens within the algorithm.

(We do have "include all headers" and "include each header alone" tests for other reasons.)

STL

[EricWF]

Our test harness has a switch to enable warnings. I would be happy to set up a bot in that configuration. It would probably be easier than setting up one that uses MSVC.
Currently that mode disables the unused variable warnings but if/when STL cleans all of those we can turn that warning on to prevent regressions.

Thanks again for cleaning these warnings up. I've been meaning to get to it *eventually*.

[STL_MSFT]

No problem! With these changes, my test runs are currently clean wrt "warning C4100: unreferenced formal parameter" and "warning C4101: unreferenced local variable", but note that (1) Clang may emit unused-variable warnings in somewhat different situations, and (2) I've still got 25% of the tests failing to compile, which may be hiding further warnings.

[EricWF]

r268284.

In D19625#418697, @STL_MSFT wrote:

No problem! With these changes, my test runs are currently clean wrt "warning C4100: unreferenced formal parameter" and "warning C4101: unreferenced local variable", but note that (1) Clang may emit unused-variable warnings in somewhat different situations, and (2) I've still got 25% of the tests failing to compile, which may be hiding further warnings.

I'm hoping Clang is pretty similar. I guess we will see. I'm going to hold off setting up a bot for a while still.

test/std/depr/depr.c.headers/setjmp_h.pass.cpp

 
 #ifndef setjmp
 #error setjmp not defined
 #endif
 
 int main()
 {
     jmp_buf jb;
+    ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(longjmp(jb, 0)), void>::value");
 }

test/std/depr/depr.c.headers/stdio_h.pass.cpp

 #pragma GCC diagnostic ignored "-Wformat-zero-length"
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" // for tmpnam
 #endif
 
 int main()
 {
     FILE* fp = 0;
     fpos_t fpos = {0};
-    size_t s = 0; ((void)s);
+    size_t s = 0;
     char* cp = 0;
     char arr[] = {'a', 'b'};
     va_list va;
+    ((void)fp); // Prevent unused warning
+    ((void)fpos); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)cp); // Prevent unused warning
+    ((void)arr); // Prevent unused warning
+    ((void)va); // Prevent unused warning
     static_assert((std::is_same<decltype(remove("")), int>::value), "");
     static_assert((std::is_same<decltype(rename("","")), int>::value), "");
     static_assert((std::is_same<decltype(tmpfile()), FILE*>::value), "");
     static_assert((std::is_same<decltype(tmpnam(cp)), char*>::value), "");
     static_assert((std::is_same<decltype(fclose(fp)), int>::value), "");
     static_assert((std::is_same<decltype(fflush(fp)), int>::value), "");
     static_assert((std::is_same<decltype(fopen("", "")), FILE*>::value), "");
     static_assert((std::is_same<decltype(freopen("", "", fp)), FILE*>::value), "");

test/std/input.output/file.streams/c.files/cstdio.pass.cpp

 
 int main()
 {
     std::FILE* fp = 0;
     std::fpos_t fpos = {0};
     std::size_t s = 0;
     char* cp = 0;
     std::va_list va;
+    ((void)fp); // Prevent unused warning
+    ((void)fpos); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)cp); // Prevent unused warning
+    ((void)va); // Prevent unused warning
     static_assert((std::is_same<decltype(std::fclose(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::fflush(fp)), int>::value), "");
     static_assert((std::is_same<decltype(std::setbuf(fp,cp)), void>::value), "");
     static_assert((std::is_same<decltype(std::vfprintf(fp,"",va)), int>::value), "");
     static_assert((std::is_same<decltype(std::fprintf(fp," ")), int>::value), "");
     static_assert((std::is_same<decltype(std::fscanf(fp,"")), int>::value), "");
     static_assert((std::is_same<decltype(std::snprintf(cp,0," ")), int>::value), "");
     static_assert((std::is_same<decltype(std::sprintf(cp," ")), int>::value), "");

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

void test_hex(const char *expected)
 
     std::string str = ss.str();
     for (size_t i = 0; i < str.size(); ++i )
         str[i] = std::toupper(str[i]);
 
     assert(str == expected);
 }
 
-int main(int argc, char* argv[])
+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/std/iterators/iterator.primitives/std.iterator.tags/bidirectional_iterator_tag.pass.cpp

 // struct bidirectional_iterator_tag : public forward_iterator_tag {};
 
 #include <iterator>
 #include <type_traits>
 
 int main()
 {
     std::bidirectional_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::forward_iterator_tag,
                                    std::bidirectional_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::bidirectional_iterator_tag>::value), "");
 }

test/std/iterators/iterator.primitives/std.iterator.tags/forward_iterator_tag.pass.cpp

 // struct forward_iterator_tag: public input_iterator_tag {};
 
 #include <iterator>
 #include <type_traits>
 
 int main()
 {
     std::forward_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::input_iterator_tag,
                                    std::forward_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::forward_iterator_tag>::value), "");
 }

test/std/iterators/iterator.primitives/std.iterator.tags/input_iterator_tag.pass.cpp

 // struct input_iterator_tag {};
 
 #include <iterator>
 #include <type_traits>
 
 int main()
 {
     std::input_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::input_iterator_tag>::value), "");
 }

test/std/iterators/iterator.primitives/std.iterator.tags/output_iterator_tag.pass.cpp

 // struct output_iterator_tag {};
 
 #include <iterator>
 #include <type_traits>
 
 int main()
 {
     std::output_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((!std::is_base_of<std::input_iterator_tag,
                                     std::output_iterator_tag>::value), "");
 }

test/std/iterators/iterator.primitives/std.iterator.tags/random_access_iterator_tag.pass.cpp

 // struct random_access_iterator_tag : public bidirectional_iterator_tag {};
 
 #include <iterator>
 #include <type_traits>
 
 int main()
 {
     std::random_access_iterator_tag tag;
+    ((void)tag); // Prevent unused warning
     static_assert((std::is_base_of<std::bidirectional_iterator_tag,
                                    std::random_access_iterator_tag>::value), "");
     static_assert((!std::is_base_of<std::output_iterator_tag,
                                     std::random_access_iterator_tag>::value), "");
 }

test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp

int main()
     }
 #if __cplusplus > 201103L
     {
         try
         {
             std::throw_with_nested(Final());
             assert(false);
         }
-        catch (const Final &f)
+        catch (const Final &)
         {
         }
     }
 #endif
 }

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

int main()
     {
         std::exception_ptr p2;
         try
         {
             assert(A::constructed == 0);
             throw A();
             assert(false);
         }
-        catch (A& a)
+        catch (A&)
         {
             std::exception_ptr p = std::current_exception();
             assert(A::constructed == 1);
             assert(p != nullptr);
             p2 = std::current_exception();
             assert(A::constructed == 1);
             assert(p == p2);
         }
         assert(A::constructed == 1);
     }
     assert(A::constructed == 0);
     {
         std::exception_ptr p2;
         try
         {
             assert(A::constructed == 0);
             throw A();
             assert(false);
         }
-        catch (A a)
+        catch (A)
         {
             std::exception_ptr p = std::current_exception();
             assert(A::constructed == 2);
             assert(p != nullptr);
             p2 = std::current_exception();
             assert(A::constructed == 2);
             assert(p == p2);
         }

test/std/language.support/support.runtime/csetjmp.pass.cpp

 
 #ifndef setjmp
 #error setjmp not defined
 #endif
 
 int main()
 {
     std::jmp_buf jb;
+    ((void)jb); // Prevent unused warning
     static_assert((std::is_same<decltype(std::longjmp(jb, 0)), void>::value),
                   "std::is_same<decltype(std::longjmp(jb, 0)), void>::value");
 }

test/std/language.support/support.runtime/ctime.pass.cpp

 
 #ifndef CLOCKS_PER_SEC
 #error CLOCKS_PER_SEC not defined
 #endif
 
 int main()
 {
     std::clock_t c = 0;
-    ((void)c);
     std::size_t s = 0;
     std::time_t t = 0;
     std::tm tm = {0};
+    ((void)c); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)t); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
     static_assert((std::is_same<decltype(std::clock()), std::clock_t>::value), "");
     static_assert((std::is_same<decltype(std::difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(std::mktime(&tm)), std::time_t>::value), "");
     static_assert((std::is_same<decltype(std::time(&t)), std::time_t>::value), "");
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::asctime(&tm)), char*>::value), "");
     static_assert((std::is_same<decltype(std::ctime(&t)), char*>::value), "");
     static_assert((std::is_same<decltype(std::gmtime(&t)), std::tm*>::value), "");
     static_assert((std::is_same<decltype(std::localtime(&t)), std::tm*>::value), "");
 #endif
     char* c1 = 0;
     const char* c2 = 0;
+    ((void)c1); // Prevent unused warning
+    ((void)c2); // Prevent unused warning
     static_assert((std::is_same<decltype(std::strftime(c1,s,c2,&tm)), std::size_t>::value), "");
 }

test/std/localization/c.locales/clocale.pass.cpp

 
 #ifndef NULL
 #error NULL not defined
 #endif
 
 int main()
 {
     std::lconv lc;
+    ((void)lc); // Prevent unused warning
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::setlocale(0, "")), char*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::localeconv()), std::lconv*>::value), "");
 }

test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp

             {
             }
         }
     }
 }
 
 void test12()
 {
-    char str[200];
     output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
 #ifdef __APPLE__
 // This test is failing on FreeBSD, possibly due to different representations
 // of the floating point numbers.  
     const my_facet f(1);
+    char str[200];
     {
         long double v = 1234567890.125;
         std::ios ios(0);
         hexfloat(ios);
         // %a
         {
             ios.precision(0);
             {
int main()
     test5();
     test6();
     test7();
     test8();
     test9();
     test10();
     test11();
     test12();
-    char str[200];
     output_iterator<char*> iter;
     std::locale lc = std::locale::classic();
     std::locale lg(lc, new my_numpunct);
     const my_facet f(1);
     {
         long double v = -INFINITY;
     }
     {

test/std/numerics/cfenv/cfenv.syn/cfenv.pass.cpp

 #ifndef FE_DFL_ENV
 #error FE_DFL_ENV not defined
 #endif
 
 int main()
 {
     std::fenv_t fenv;
     std::fexcept_t fex;
+    ((void)fenv); // Prevent unused warning
+    ((void)fex); // Prevent unused warning
     static_assert((std::is_same<decltype(std::feclearexcept(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fegetexceptflag(&fex, 0)), int>::value), "");
     static_assert((std::is_same<decltype(std::feraiseexcept(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fesetexceptflag(&fex, 0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fetestexcept(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fegetround()), int>::value), "");
     static_assert((std::is_same<decltype(std::fesetround(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fegetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::feholdexcept(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::fesetenv(&fenv)), int>::value), "");
     static_assert((std::is_same<decltype(std::feupdateenv(&fenv)), int>::value), "");
 }

test/std/numerics/rand/rand.device/eval.pass.cpp

int main()
     }
 
     try
     {
         std::random_device r("/dev/null");
         r();
         assert(false);
     }
-    catch (const std::system_error& e)
+    catch (const std::system_error&)
     {
     }
 }

test/std/re/re.alg/re.alg.search/grep.pass.cpp

extern "C" void LLVMFuzzerTestOneInput(const char *data)
     {
         try
         {
             std::regex::flag_type flag = std::regex_constants::grep;
             std::string s((const char *)data, size);
             std::regex re(s, flag);
             std::regex_match(s, re);
         } 
-        catch (std::regex_error &ex) {} 
+        catch (std::regex_error &) {} 
     } 
 }
 
 
 void fuzz_tests()  // patterns that the fuzzer has found
 {
 // Raw string literals are a C++11 feature.
 #if TEST_STD_VER >= 11

test/std/strings/c.strings/cwchar.pass.cpp

int main()
     std::size_t s = 0;
     std::tm *tm = 0;
     std::wint_t w = 0;
     ::FILE* fp = 0;
     std::va_list va;
 
     char* ns = 0;
     wchar_t* ws = 0;
+
+    ((void)mb); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
+    ((void)w); // Prevent unused warning
+    ((void)fp); // Prevent unused warning
+    ((void)va); // Prevent unused warning
+    ((void)ns); // Prevent unused warning
+    ((void)ws); // Prevent unused warning
+
     static_assert((std::is_same<decltype(std::fwprintf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::fwscanf(fp, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::swprintf(ws, s, L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::swscanf(L"", L"")), int>::value), "");
     static_assert((std::is_same<decltype(std::vfwprintf(fp, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vfwscanf(fp, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vswprintf(ws, s, L"", va)), int>::value), "");
     static_assert((std::is_same<decltype(std::vswscanf(L"", L"", va)), int>::value), "");

test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.pass.cpp

 //           | pointer_traits<pointer>::rebind<const void>
 //                                          const_void_pointer;
 
 template <typename Alloc>
 void test_pointer()
 {
      typename std::allocator_traits<Alloc>::pointer        vp;
      typename std::allocator_traits<Alloc>::const_pointer cvp;
-     
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <=  vp)>::value, "");
 
      static_assert(std::is_same<bool, decltype( vp == cvp)>::value, "");
void test_pointer()
      static_assert(std::is_same<bool, decltype(cvp <= cvp)>::value, "");
 }
 
 template <typename Alloc>
 void test_void_pointer()
 {
      typename std::allocator_traits<Alloc>::void_pointer        vp;
      typename std::allocator_traits<Alloc>::const_void_pointer cvp;
-     
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <=  vp)>::value, "");
 
      static_assert(std::is_same<bool, decltype( vp == cvp)>::value, "");

test/std/utilities/memory/default.allocator/allocator_pointers.pass.cpp

 //           | pointer_traits<pointer>::rebind<const void>
 //                                          const_void_pointer;
 
 template <typename Alloc>
 void test_pointer()
 {
      typename std::allocator_traits<Alloc>::pointer        vp;
      typename std::allocator_traits<Alloc>::const_pointer cvp;
-     
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <=  vp)>::value, "");
 
      static_assert(std::is_same<bool, decltype( vp == cvp)>::value, "");
void test_pointer()
      static_assert(std::is_same<bool, decltype(cvp <= cvp)>::value, "");
 }
 
 template <typename Alloc>
 void test_void_pointer()
 {
      typename std::allocator_traits<Alloc>::void_pointer        vp;
      typename std::allocator_traits<Alloc>::const_void_pointer cvp;
-     
+     ((void)vp); // Prevent unused warning
+     ((void)cvp); // Prevent unused warning
+
      static_assert(std::is_same<bool, decltype( vp ==  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp !=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp >=  vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <   vp)>::value, "");
      static_assert(std::is_same<bool, decltype( vp <=  vp)>::value, "");
 
      static_assert(std::is_same<bool, decltype( vp == cvp)>::value, "");

test/std/utilities/time/date.time/ctime.pass.cpp

 
 #ifndef CLOCKS_PER_SEC
 #error CLOCKS_PER_SEC not defined
 #endif
 
 int main()
 {
     std::clock_t c = 0;
-    ((void)c); // avoid unused warning
     std::size_t s = 0;
     std::time_t t = 0;
     std::tm tm = {0};
     char str[3];
+    ((void)c); // Prevent unused warning
+    ((void)s); // Prevent unused warning
+    ((void)t); // Prevent unused warning
+    ((void)tm); // Prevent unused warning
+    ((void)str); // Prevent unused warning
     static_assert((std::is_same<decltype(std::clock()), std::clock_t>::value), "");
     static_assert((std::is_same<decltype(std::difftime(t,t)), double>::value), "");
     static_assert((std::is_same<decltype(std::mktime(&tm)), std::time_t>::value), "");
     static_assert((std::is_same<decltype(std::time(&t)), std::time_t>::value), "");
 #ifndef _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
     static_assert((std::is_same<decltype(std::asctime(&tm)), char*>::value), "");
     static_assert((std::is_same<decltype(std::ctime(&t)), char*>::value), "");
     static_assert((std::is_same<decltype(std::gmtime(&t)), std::tm*>::value), "");
     static_assert((std::is_same<decltype(std::localtime(&t)), std::tm*>::value), "");
 #endif
     static_assert((std::is_same<decltype(std::strftime(str,s,"",&tm)), std::size_t>::value), "");
 }

test/std/utilities/utility/forward/forward.pass.cpp

 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 int main()
 {
     A a;
     const A ca = A();
 
+    ((void)a); // Prevent unused warning
+    ((void)ca); // Prevent unused warning
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     static_assert(sizeof(test(std::forward<A&>(a))) == 1, "");
     static_assert(sizeof(test(std::forward<A>(a))) == 4, "");
     static_assert(sizeof(test(std::forward<A>(source()))) == 4, "");
 
     static_assert(sizeof(test(std::forward<const A&>(a))) == 2, "");
 //    static_assert(sizeof(test(std::forward<const A&>(source()))) == 2, "");
     static_assert(sizeof(test(std::forward<const A>(a))) == 8, "");