[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!

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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
 }

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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }

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 = ATOMIC_FLAG_INIT;
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f(false);
+        std::atomic_flag f = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f(false);
+        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         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 = ATOMIC_FLAG_INIT;
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
 }