Fix C++11

Author: ldionne

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_for.pass.cpp

@@ -43,8 +43,8 @@ int main(int, char**) {
   // happen that we get awoken spuriously and fail to recognize it
   // (making this test useless), but the likelihood should be small.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
+    std::atomic<bool> ready           (false);
+    std::atomic<bool> likely_spurious (true);
     auto timeout                      = std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_for_pred.pass.cpp

@@ -43,9 +43,9 @@ int main(int, char**) {
   // the likelihood that we got awoken by a spurious wakeup by updating the
   // likely_spurious flag only immediately before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;
 
@@ -110,9 +110,9 @@ int main(int, char**) {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
-    auto timeout             = std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
+    auto timeout = std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_pred.pass.cpp

@@ -31,8 +31,8 @@ int main(int, char**) {
   // spurious wakeup by updating the likely_spurious flag only immediately
   // before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
     std::condition_variable cv;
     std::mutex mutex;
 
@@ -70,8 +70,8 @@ int main(int, char**) {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
     std::condition_variable cv;
     std::mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp

@@ -49,9 +49,9 @@ void test() {
   // happen that we get awoken spuriously and fail to recognize it
   // (making this test useless), but the likelihood should be small.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_until_pred.pass.cpp

@@ -49,9 +49,9 @@ void test() {
   // the likelihood that we got awoken by a spurious wakeup by updating the
   // likely_spurious flag only immediately before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;
 
@@ -112,9 +112,9 @@ void test() {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
-    auto timeout             = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable cv;
     std::mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.pass.cpp

@@ -49,9 +49,9 @@ void test() {
   // happen that we get awoken spuriously and fail to recognize it
   // (making this test useless), but the likelihood should be small.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_for_pred.pass.cpp

@@ -49,9 +49,9 @@ void test() {
   // the likelihood that we got awoken by a spurious wakeup by updating the
   // likely_spurious flag only immediately before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;
 
@@ -116,9 +116,9 @@ void test() {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
-    auto timeout             = std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
+    auto timeout = std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_pred.pass.cpp

@@ -39,8 +39,8 @@ void test() {
   // spurious wakeup by updating the likely_spurious flag only immediately
   // before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
     std::condition_variable_any cv;
     Mutex mutex;
 
@@ -78,8 +78,8 @@ void test() {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
     std::condition_variable_any cv;
     Mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until.pass.cpp

@@ -54,9 +54,9 @@ void test() {
   // happen that we get awoken spuriously and fail to recognize it
   // (making this test useless), but the likelihood should be small.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;
 

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_until_pred.pass.cpp

@@ -55,9 +55,9 @@ void test() {
   // the likelihood that we got awoken by a spurious wakeup by updating the
   // likely_spurious flag only immediately before we perform the notification.
   {
-    std::atomic<bool> ready           = false;
-    std::atomic<bool> likely_spurious = true;
-    auto timeout                      = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> likely_spurious(true);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;
 
@@ -118,9 +118,9 @@ void test() {
   // taken. In particular, we do need to eventually ensure we get out of the wait
   // by standard means, so we actually wake up the thread at the end.
   {
-    std::atomic<bool> ready  = false;
-    std::atomic<bool> awoken = false;
-    auto timeout             = Clock::now() + std::chrono::seconds(3600);
+    std::atomic<bool> ready(false);
+    std::atomic<bool> awoken(false);
+    auto timeout = Clock::now() + std::chrono::seconds(3600);
     std::condition_variable_any cv;
     Mutex mutex;