[libcxx] [test] Replace non-Standard "atomic_flag f(false);" with Standard "atomic_flag f;"

[EricWF]

Summary

Replace non-Standard "atomic_flag f(false);" with Standard "atomic_flag f;" in clear tests.
Although the value of 'f' is unspecified it shouldn't matter because these tests always call f.test_and_set() without checking the result, so the initial state shouldn't matter.

The test init03.pass.cpp is explicitly testing this non-Standard extension; It has been moved into the test/libcxx directory.

[EricWF]

This is a small problem. We actually provide <atomic> in C++03 minus ATOMIC_FLAG_INIT since it requires C++11.
I'll come up with a way to fix these tests so they keep working in C++03.

[STL_MSFT]

Since you control the definition of ATOMIC_FLAG_INIT, can you make it something like __secret_tag_type() in C++03? That would allow you to continue to provide the atomic_flag(bool) extension in C++03.

[EricWF]

I actually want this form of initialization to break in C++03, From the original review:

After putting this question up on cfe-dev I have decided that it would be best to allow the use of <atomic> in C++03. Although static initialization is a concern the syntax required to get it is C++11 only. Meaning that C++11 constant static initialization cannot silently break in C++03, it will always cause a syntax error. Furthermore ATOMIC_VAR_INIT and ATOMIC_FLAG_INIT remain defined in C++03 even though they cannot be used because C++03 usages will cause better error messages.

I think I'll just hack up these tests, or make them require C++11 or greater and add C++03 specific tests elsewhere.

[STL_MSFT]

Makes sense. MSVC will never have C++03 or C++11 modes (only 14/17/future) so anything you do in C++03 mode is fine by me.

[EricWF]

Stealing this review from STL.

[EricWF]

@STL_MSFT Does this work for you? I simply removed the initializer and call the default constructor instead. This leaves 'f' in an unspecified state but that shouldn't matter because we always call 'f.test_and_set()' before testing the clear operation.

[STL_MSFT]

I think this will work for me. Thanks!

libcxx/trunk/include/atomic

typedef struct atomic_flag
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
     atomic_flag() _NOEXCEPT = default;
 #else
     atomic_flag() _NOEXCEPT : __a_() {}
 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
     _LIBCPP_INLINE_VISIBILITY
-    atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {}
+    atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
 
 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;
 #else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 private:
     atomic_flag(const atomic_flag&);

libcxx/trunk/test/libcxx/atomics/atomics.flag/init_bool.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.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <atomic>
+
+// struct atomic_flag
+
+// TESTING EXTENSION atomic_flag(bool)
+
+#include <atomic>
+#include <cassert>
+
+int main()
+{
+    {
+        std::atomic_flag f(false);
+        assert(f.test_and_set() == 0);
+    }
+    {
+        std::atomic_flag f(true);
+        assert(f.test_and_set() == 1);
+    }
+}

libcxx/trunk/test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp

 // void atomic_flag_clear(atomic_flag*);
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
 }

libcxx/trunk/test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

 // void atomic_flag_clear_explicit(atomic_flag*, memory_order);
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }

libcxx/trunk/test/std/atomics/atomics.flag/clear.pass.cpp

 // void clear(memory_order = memory_order_seq_cst) volatile;
 
 #include <atomic>
 #include <cassert>
 
 int main()
 {
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f;
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }

libcxx/trunk/test/std/atomics/atomics.flag/init03.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.
-//
-//===----------------------------------------------------------------------===//
-//
-// UNSUPPORTED: libcpp-has-no-threads
-
-// <atomic>
-
-// struct atomic_flag
-
-// TESTING EXTENSION atomic_flag(bool)
-
-#include <atomic>
-#include <cassert>
-
-int main()
-{
-    std::atomic_flag f(false);
-    assert(f.test_and_set() == 0);
-}