[libcxx] [test] Make the condvar wait_for tests a bit more understandable. NFC.

[mstorsjo]

Summary

This was requested in the review of D99175; rename the "runs"
variable to clarify what it means wrt the test, and move updating of
it to the main function to clarify its behaviour wrt the two runs
further.

[curdeius]

LGTM.

[• Quuxplusone]

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

36

Is there a reason we can't do void f(bool expect_timeout)?

[mstorsjo]

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

36

I guess we could, although I'm not sure if that makes it significantly more readable...

[mstorsjo]

(Also, feel free to commandeer the patch.)

[• Quuxplusone]

Meh. 😛

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

 #include "test_macros.h"
 
 std::condition_variable cv;
 std::mutex mut;
 
 int test1 = 0;
 int test2 = 0;
 
-int runs = 0;
+bool expect_timeout = false;
 
 void f()
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds milliseconds;
     std::unique_lock<std::mutex> lk(mut);
     assert(test2 == 0);
     test1 = 1;
     cv.notify_one();
     Clock::time_point t0 = Clock::now();
     Clock::time_point wait_end = t0 + milliseconds(250);
     Clock::duration d;
     do {
         d = wait_end - Clock::now();
         if (d <= milliseconds(0)) break;
     } while (test2 == 0 && cv.wait_for(lk, d) == std::cv_status::no_timeout);
     Clock::time_point t1 = Clock::now();
-    if (runs == 0)
+    if (!expect_timeout)
     {
         assert(t1 - t0 < milliseconds(250));
         assert(test2 != 0);
     }
     else
     {
         assert(t1 - t0 - milliseconds(250) < milliseconds(50));
         assert(test2 == 0);
     }
-    ++runs;
 }
 
 int main(int, char**)
 {
     {
         std::unique_lock<std::mutex> lk(mut);
         std::thread t = support::make_test_thread(f);
         assert(test1 == 0);
         while (test1 == 0)
             cv.wait(lk);
         assert(test1 != 0);
         test2 = 1;
         lk.unlock();
         cv.notify_one();
         t.join();
     }
     test1 = 0;
     test2 = 0;
+    expect_timeout = true;
     {
         std::unique_lock<std::mutex> lk(mut);
         std::thread t = support::make_test_thread(f);
         assert(test1 == 0);
         while (test1 == 0)
             cv.wait(lk);
         assert(test1 != 0);
         lk.unlock();
         t.join();
     }
 
   return 0;
 }

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

 typedef std::timed_mutex L0;
 typedef std::unique_lock<L0> L1;
 
 L0 m0;
 
 int test1 = 0;
 int test2 = 0;
 
-int runs = 0;
+bool expect_timeout = false;
 
 void f()
 {
     typedef std::chrono::system_clock Clock;
     typedef std::chrono::milliseconds milliseconds;
     L1 lk(m0);
     assert(test2 == 0);
     test1 = 1;
     cv.notify_one();
     Clock::time_point t0 = Clock::now();
     Clock::time_point wait_end = t0 + milliseconds(250);
     Clock::duration d;
     do {
         d = wait_end - Clock::now();
         if (d <= milliseconds(0)) break;
     } while (test2 == 0 && cv.wait_for(lk, d) == std::cv_status::no_timeout);
     Clock::time_point t1 = Clock::now();
-    if (runs == 0)
+    if (!expect_timeout)
     {
         assert(t1 - t0 < milliseconds(250));
         assert(test2 != 0);
     }
     else
     {
         assert(t1 - t0 - milliseconds(250) < milliseconds(50));
         assert(test2 == 0);
     }
-    ++runs;
 }
 
 int main(int, char**)
 {
     {
         L1 lk(m0);
         std::thread t = support::make_test_thread(f);
         assert(test1 == 0);
         while (test1 == 0)
             cv.wait(lk);
         assert(test1 != 0);
         test2 = 1;
         lk.unlock();
         cv.notify_one();
         t.join();
     }
     test1 = 0;
     test2 = 0;
+    expect_timeout = true;
     {
         L1 lk(m0);
         std::thread t = support::make_test_thread(f);
         assert(test1 == 0);
         while (test1 == 0)
             cv.wait(lk);
         assert(test1 != 0);
         lk.unlock();
         t.join();
     }
 
   return 0;
 }