[libcxx] Mark atomic tests UNSUPPORTED for c++03 and c++98.

[EricWF]

Summary

clang doesn't provide the atomic intrinsics in C++03 and lower so even including atomic leads to a compile error. This header is strictly not supported in c++03.

[danalbert]

LGTM.

[danalbert]

Actually, on second thought, shouldn't these be XFAIL? Do we care about ensuring that you can't use <atomic> for < C++11?

[EricWF]

Are you saying that if we plan to support <atomic> in C++03 we should mark them as XFAIL? I don't think <atomic> will ever be supported below c++11, hence the use of <atomic> in c++03 is "unsupported".

Let me know if I didn't understand anything.

[danalbert]

I'm saying we might want to verify that these do in fact fail. UNSUPPORTED
causes the test to not be run, XFAIL tests to ensure failure, which is
possibly what we want here. OTOH, our test configuration isn't set up to do
conditional _compile time_ failures, so maybe we should just settle for
UNSUPPORTED.

[EricWF]

I'm saying we might want to verify that these do in fact fail. UNSUPPORTED
causes the test to not be run, XFAIL tests to ensure failure, which is
possibly what we want here.
OTOH, our test configuration isn't set up to do
conditional _compile time_ failures, so maybe we should just settle for UNSUPPORTED.

Your right. That's probably a good idea. <atomic> is unique in that it actually explicitly errors when it is included but won't work.
.fail.cpp tests are expected to fail at compile time. I think we should do is leave these tests as unsupported and add a cxx03.fail.cpp test
that ensures including <atomic> results in a compiler failures.

Here's my gripe. I like the separation between

1. XFAIL - tests that should be fixed.
2. UNSUPPORTED - tests I don't care about at all.

It makes it a lot easier to watch just the tests I care about. Adding one XFAIL test seems a touch cleaner, and will guarantee the same thing.

[EricWF]

Added two tests to ensure that <atomic> doesn't compile when one of the following is true:

1. __cplusplus < 201103L
2. _LIBCPP_HAS_NO_THREADS is defined.

The added tests are:

• /test/atomics/c++11-only.fail.cpp
• /test/atomics/libcpp-no-threads.fail.cpp

[EricWF]

It seems like it might be possible to get these tests working in C++03 mode under clang. Abandoning this so we can try and get them working instead.

[jroelofs]

test/atomics/libcpp-no-threads.fail.cpp

1

test/atomics/libcpp-no-threads.fail.cpp looks useful to me as a separate change, though we probably ought to think about how to support fail tests that are conditional on platform specifics (which is what this test really ought to be).

I think the way forward on that would be to add support for support for implicit "XFAIL: *" in *.fail.cpp tests when an XFAIL line isn't specified. Then the afformentioned test should have an "XFAIL: libcpp-has-no-threads".

Something to discus at the cross testing BOF, I suppose....

test/atomics/atomics.fences/atomic_signal_fence.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.fences/atomic_thread_fence.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/atomic_flag_clear.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/atomic_flag_test_and_set.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/atomic_flag_test_and_set_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/clear.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/copy_assign.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // struct atomic_flag

test/atomics/atomics.flag/copy_ctor.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // struct atomic_flag

test/atomics/atomics.flag/copy_volatile_assign.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // struct atomic_flag

test/atomics/atomics.flag/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.flag/test_and_set.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.lockfree/lockfree.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.order/kill_dependency.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.order/memory_order.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.generic/address.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... test case crashes clang.
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.generic/bool.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.generic/integral.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.generic/integral_typedefs.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.generic/trivially_copyable.fail.cpp

 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.generic/trivially_copyable.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 34
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 38
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 34
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 38
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... fails assertion line 31
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 32
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... test crashes clang
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class Integral>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... test crashes clang
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class Integral>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_and_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_or_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... test crashes clang
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class Integral>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... test crashes clang
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class Integral>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_xor_explicit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 34
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 34
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 31
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 31
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 //  ... assertion fails line 31
 
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // template <class T>

test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>
 

test/atomics/c++11-only.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+#if __cplusplus < 201103L
+#include <atomic>
+#else
+#error This test should not compile.
+#endif
+
+int main()
+{
+}

test/atomics/libcpp-no-threads.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#define _LIBCPP_HAS_NO_THREADS
+#endif
+
+#include <atomic>
+
+int main()
+{
+}

test/atomics/version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
 
 // <atomic>