[libcxx] Tests cleanup: use UNSUPPORTED instead of TEST_STD_VER.

[amakc11]

Summary

Some older tests use, for example, the following template:

#if TEST_STD_VER > 11
<do something useful testing>
#else
int main() {}
#endif

It yields building and running an "empty" test if the condition on TEST_STD_VER evaluates to false. This patch replaces this template with appropriate UNSUPPORTED directive which prevents spending time on building and running such tests in unsupported environment.

[ldionne]

I prefer this approach because it allows us to see which tests are supported/unsupported under a given standard. The same holds for configurations like host system, deployment target on OSX & al. I like this change.

[ldionne]

Can you please rebase on top of the latest master? https://reviews.llvm.org/D57624 makes it not apply cleanly :-(

[amakc11]

Oops, seems like a "commit race" happened. :-)

[amakc11]

Patch is rebased as requested.

[ldionne]

Thanks for the patch! Committed as r353206.

test/std/input.output/iostream.format/quoted.manip/quoted.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 // <iomanip>
 
 // quoted
 
 #include <iomanip>
 #include <sstream>
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER > 11
-
 template <class CharT, class Traits>
 bool is_skipws ( const std::basic_istream<CharT, Traits>& is ) {
     return ( is.flags() & std::ios_base::skipws ) != 0;
     }
 
 template <class CharT, class Traits = std::char_traits<CharT>>
 void both_ways ( const CharT *p ) {
     std::basic_string<CharT, Traits> str(p);
//  missing end quote - must not hang
     assert ( unquote (  "abc" ) == "abc" ); // no delimiter
     assert ( unquote ( L"abc" ) == L"abc" ); // no delimiter
     assert ( unquote (  "abc def" ) ==  "abc" ); // no delimiter
     assert ( unquote ( L"abc def" ) == L"abc" ); // no delimiter
 
     assert ( unquote (  "" ) ==  "" ); // nothing there
     assert ( unquote ( L"" ) == L"" ); // nothing there
     test_padding ();
-    
     return 0;
 }
-
-#else
-int main(int, char**) {
-  return 0;
-}
-#endif

test/std/utilities/allocator.adaptor/allocator.adaptor.types/allocator_pointers.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 #include <scoped_allocator>
 #include <memory>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     typedef Alloc                        allocator_type;
 //     typedef typename allocator_type::value_type
 //                                          value_type;
int main(int, char**)
     test_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();
 
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<char>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<int>>> ();
     test_void_pointer<std::scoped_allocator_adaptor<std::allocator<Foo>>> ();
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif

test/std/utilities/memory/default.allocator/allocator_pointers.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 #include <memory>
 #include <cassert>
 
-#include "test_macros.h"
-
-#if TEST_STD_VER >= 11
 // #include <memory>
 //
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     typedef Alloc                        allocator_type;
 //     typedef typename allocator_type::value_type
 //                                          value_type;
int main(int, char**)
     test_pointer<std::allocator<Foo>> ();
 
     test_void_pointer<std::allocator<char>> ();
     test_void_pointer<std::allocator<int>> ();
     test_void_pointer<std::allocator<Foo>> ();
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif

test/std/utilities/meta/meta.unary/meta.unary.cat/nullptr.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // nullptr_t
 //  is_null_pointer
 
+// UNSUPPORTED: c++98, c++03, c++11
+
 #include <type_traits>
 #include <cstddef>        // for std::nullptr_t
-#include "test_macros.h"
 
-#if TEST_STD_VER > 11
 template <class T>
 void test_nullptr_imp()
 {
     static_assert(!std::is_void<T>::value, "");
     static_assert( std::is_null_pointer<T>::value, "");
     static_assert(!std::is_integral<T>::value, "");
     static_assert(!std::is_floating_point<T>::value, "");
     static_assert(!std::is_array<T>::value, "");

 int main(int, char**)
 {
     test_nullptr<std::nullptr_t>();
 
 //  LWG#2582
     static_assert(!std::is_null_pointer<incomplete_type>::value, "");
     return 0;
 }
-#else
-int main(int, char**) {
-  return 0;
-}
-#endif

test/std/utilities/tuple/tuple.tuple/TupleFunction.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
 //
 //===----------------------------------------------------------------------===//
 
-// This is for bugs 18853 and 19118
-
-#include "test_macros.h"
+// UNSUPPORTED: c++98, c++03
 
-#if TEST_STD_VER >= 11
+// This is for bugs 18853 and 19118
 
 #include <tuple>
 #include <functional>
 
 struct X
 {
     X() {}
 
     template <class T>
     X(T);
 
     void operator()() {}
 };
 
 int main(int, char**)
 {
     X x;
     std::function<void()> f(x);
 
   return 0;
 }
-#else
-int main(int, char**) { return 0; }
-#endif