[libc++] Implement `std::condition_variable_any::wait[_for/until]` overloads that take `stop_token`

[huixie90]

Summary

• This is section 32.6.4 of P0660R10
• https://eel.is/c++draft/thread.condvarany.intwait

[huixie90]

CI

[Mordante]

In general looks good. I have some minor comments. I think it would be good to keep track how often predicates are called and whether that matches the (minimal) expectation. For example when a stop_requested() == true the predicate is called exactly one time.

libcxx/include/condition_variable

106

Can you align the // since C++20 ?

318

327

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

96

This is our typical code style.

135

I wonder here and at other places whether 2 ms is long enough.
Are we sure this is changed after the wait_for is really in it's loop? Or can the flag be set before entering the loop.

Would it make sense to validate how often the predicate is executed? When it's less than 2 the loop was executed 0 times.

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

43

Please include <concepts>.

[ldionne]

Commandeering per discussion w/ Hui.

libcxx/include/condition_variable

95

Let's mark this as experimental.

[huixie90]

address feedback rebase

[huixie90]

CI

[huixie90]

libcxx/include/condition_variable

318

this is a member function call . not std::wait_until

327

this is a member function call, not std::wait_until

[huixie90]

rebase

[huixie90]

FTM

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

guard stop_token headers with no thread macro

[huixie90]

ci

[ldionne]

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

135

If the thread creation is really slow, this test could be vacuous (it would test the same as the test that does request_stop() before we wait_for). Would it make sense to instead do something like:

auto thread = support::make_test_thread([&]() {
    // wait until we're ready
    some_atomic.wait(...);
    ss.request_stop();

    while (!done) {
        cv.notify_all();
        std::this_thread::sleep_for(2ms);
      }
});

std::same_as<bool> auto r = cv.wait_for(lock, ss.get_token(), 1h, [&]() {
  some_atomic.notify_all(); // here signal that we're ready for the other thread to request a stop
  return false;
});
assert(!r);
done = true;
thread.join();

Does this make sense at all? That way the pred will be the one to trigger the fact that we request_stop() on the other thread. Would that be more robust?

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

80

Whatever we do for the other test we should do here too.

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

130

And here.

[huixie90]

address feedback

[ldionne]

LGTM with minor nitpick. You can ignore the CI failures since they are unrelated and have been fixed since then. Thanks!

libcxx/docs/Status/Cxx20.rst

51 ↗

(On Diff #557207)

libcxx/include/condition_variable

public:
     template <class Lock, class Clock, class Duration, class Predicate>
         bool
         wait_until(Lock& lock,
                    const chrono::time_point<Clock, Duration>& abs_time,
                    Predicate pred);
 
     template <class Lock, class Rep, class Period>
         cv_status
         wait_for(Lock& lock,
                  const chrono::duration<Rep, Period>& rel_time);
 
     template <class Lock, class Rep, class Period, class Predicate>
         bool
         wait_for(Lock& lock,
                  const chrono::duration<Rep, Period>& rel_time,
                  Predicate pred);
+
+    // [thread.condvarany.intwait], interruptible waits
+    template <class Lock, class Predicate>
+      bool wait(Lock& lock, stop_token stoken, Predicate pred);         // since C++20
+
+    template <class Lock, class Clock, class Duration, class Predicate>
+      bool wait_until(Lock& lock, stop_token stoken,
+                      const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);   // since C++20
+
+    template <class Lock, class Rep, class Period, class Predicate>
+      bool wait_for(Lock& lock, stop_token stoken,
+                    const chrono::duration<Rep, Period>& rel_time, Predicate pred);  // since C++20
 };
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
 #include <__memory/unique_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
+#include <__stop_token/stop_token.h>
 #include <__utility/move.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_HAS_NO_THREADS
template <class _Lock, class _Rep, class _Period>
                  const chrono::duration<_Rep, _Period>& __d);
 
     template <class _Lock, class _Rep, class _Period, class _Predicate>
         bool
         _LIBCPP_INLINE_VISIBILITY
         wait_for(_Lock& __lock,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
+
+#if _LIBCPP_STD_VER >= 20
+
+    template <class _Lock, class _Predicate>
+    _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
+
+    template <class _Lock, class _Clock, class _Duration, class _Predicate>
+    _LIBCPP_HIDE_FROM_ABI bool wait_until(_Lock& __lock, stop_token __stoken,
+                const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
+
+    template <class _Lock, class _Rep, class _Period, class _Predicate>
+    _LIBCPP_HIDE_FROM_ABI bool wait_for(_Lock& __lock, stop_token __stoken,
+                const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
+
+#endif // _LIBCPP_STD_VER >= 20
 };
 
 inline
 condition_variable_any::condition_variable_any()
     : __mut_(make_shared<mutex>()) {}
 
 inline
 void

 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d,
                                  _Predicate __pred)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Lock, class _Predicate>
+bool condition_variable_any::wait(_Lock& __lock, stop_token __stoken, _Predicate __pred) {
+    while (!__stoken.stop_requested()) {
+        if (__pred())
+            return true;
+        wait(__lock);
+    }
+    return __pred();
+}
+
+template <class _Lock, class _Clock, class _Duration, class _Predicate>
+bool condition_variable_any::wait_until(
+    _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred) {
+    while (!__stoken.stop_requested()) {
+        if (__pred())
+            return true;
+        if (wait_until(__lock, __abs_time) == cv_status::timeout)
+            return __pred();
+    }
+    return __pred();
+}
+
+template <class _Lock, class _Rep, class _Period, class _Predicate>
+bool condition_variable_any::wait_for(
+    _Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) {
+    return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred));
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
 _LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// template<class Lock, class Rep, class Period, class Predicate>
+//   bool wait_for(Lock& lock, stop_token stoken,
+//                 const chrono::duration<Rep, Period>& rel_time, Predicate pred);
+
+#include <cassert>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  using namespace std::chrono_literals;
+
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 4: The returned value indicates whether the predicate evaluated to true
+    // regardless of whether the timeout was triggered or a stop request was made.]
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait_for(lock, ss.get_token(), 1h, []() { return false; });
+    assert(!r2);
+
+    std::same_as<bool> auto r3 = cv.wait_for(lock, ss.get_token(), -1h, []() { return true; });
+    assert(r3);
+
+    std::same_as<bool> auto r4 = cv.wait_for(lock, ss.get_token(), 1h, []() { return true; });
+    assert(r4);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request, pred was true
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return true; });
+    assert(r1);
+
+    std::same_as<bool> auto r2 = cv.wait_for(lock, ss.get_token(), 1h, []() { return true; });
+    assert(r2);
+  }
+
+  // no stop request, pred was false, abs_time was in the past
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), -1h, []() { return false; });
+    assert(!r1);
+  }
+
+  // no stop request, pred was false until timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    auto oldTime = std::chrono::steady_clock::now();
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), 2ms, [&]() { return false; });
+
+    assert((std::chrono::steady_clock::now() - oldTime) >= 2ms);
+    assert(!r1);
+  }
+
+  // no stop request, pred was false, changed to true before timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(2ms);
+      Lock lock{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r1 = cv.wait_for(lock, ss.get_token(), 1h, [&]() { return flag; });
+    assert(flag);
+    assert(r1);
+
+    thread.join();
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool done = false;
+    auto thread           = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(2ms);
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(2ms);
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait_for(lock, ss.get_token(), 1h, [&]() { return false; });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait_for(lock, ss.get_token(), 1h, []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}

libcxx/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

 
 // RUN: %{build}
 // RUN: %{run} 1
 // RUN: %{run} 2
 // RUN: %{run} 3
 // RUN: %{run} 4
 // RUN: %{run} 5
 // RUN: %{run} 6
+// RUN: %{run} 7
+// RUN: %{run} 8
+// RUN: %{run} 9
 
 // -----------------------------------------------------------------------------
 // Overview
 //   Check that std::terminate is called if wait(...) fails to meet its post
 //   conditions. This can happen when reacquiring the mutex throws
 //   an exception.
 //
 //  The following methods are tested within this file
 //   1.  void wait(Lock& lock);
 //   2.  void wait(Lock& lock, Pred);
 //   3.  void wait_for(Lock& lock, Duration);
 //   4.  void wait_for(Lock& lock, Duration, Pred);
 //   5.  void wait_until(Lock& lock, TimePoint);
 //   6.  void wait_until(Lock& lock, TimePoint, Pred);
+//   7.  bool wait(Lock& lock, stop_token stoken, Predicate pred);
+//   8.  bool wait_for(Lock& lock, stop_token stoken, Duration, Predicate pred);
+//   9.  bool wait_until(Lock& lock, stop_token stoken, TimePoint, Predicate pred);
 //
 // Plan
 //   1 Create a mutex type, 'ThrowingMutex', that throws when the lock is acquired
 //     for the *second* time.
 //
 //   2 Replace the terminate handler with one that exits with a '0' exit code.
 //
 //   3 Create a 'condition_variable_any' object 'cv' and a 'ThrowingMutex'

 
 #include <atomic>
 #include <cassert>
 #include <chrono>
 #include <condition_variable>
 #include <cstdlib>
 #include <exception>
 #include <string>
+#include <stop_token>
 #include <thread>
 
 #include "make_test_thread.h"
+#include "test_macros.h"
 
 void my_terminate() {
   std::_Exit(0); // Use _Exit to prevent cleanup from taking place.
 }
 
 // The predicate used in the cv.wait calls.
 bool pred = false;
 bool pred_function() {

 }
 
 typedef std::chrono::system_clock Clock;
 typedef std::chrono::milliseconds MS;
 
 int main(int argc, char **argv) {
   assert(argc == 2);
   int id = std::stoi(argv[1]);
-  assert(id >= 1 && id <= 6);
+  assert(id >= 1 && id <= 9);
   std::set_terminate(my_terminate); // set terminate after std::stoi because it can throw.
   MS wait(250);
   try {
     mut.lock();
     assert(pred == false);
     support::make_test_thread(signal_me).detach();
     switch (id) {
       case 1: cv.wait(mut); break;
       case 2: cv.wait(mut, pred_function); break;
       case 3: cv.wait_for(mut, wait); break;
       case 4: cv.wait_for(mut, wait, pred_function); break;
       case 5: cv.wait_until(mut, Clock::now() + wait); break;
       case 6: cv.wait_until(mut, Clock::now() + wait, pred_function); break;
+#if TEST_STD_VER >=20
+      case 7: cv.wait(mut, std::stop_source{}.get_token(), pred_function); break;
+      case 8: cv.wait_for(mut, std::stop_source{}.get_token(), wait, pred_function); break;
+      case 9: cv.wait_until(mut, std::stop_source{}.get_token(), Clock::now() + wait, pred_function); break;
+#else
+      case 7:
+      case 8:
+      case 9: 
+        return 0;
+#endif //TEST_STD_VER >=20
       default: assert(false);
     }
   } catch (...) {}
   assert(false);
 
   return 0;
 }

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// template<class Lock, class Predicate>
+//   bool wait(Lock& lock, stop_token stoken, Predicate pred);
+
+#include <cassert>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 1: The returned value indicates whether the predicate evaluated to true regardless of whether there was a stop request.]
+    std::same_as<bool> auto r1 = cv.wait(lock, ss.get_token(), []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait(lock, ss.get_token(), []() { return true; });
+    assert(r2);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    std::same_as<bool> auto r1 = cv.wait(lock, ss.get_token(), []() { return true; });
+    assert(r1);
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      Lock lock2{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r2 = cv.wait(lock, ss.get_token(), [&]() { return flag; });
+    assert(flag);
+    assert(r2);
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool done = false;
+    auto thread           = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait(lock, ss.get_token(), [&]() { return false; });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait(lock, ss.get_token(), []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// template<class Lock, class Clock, class Duration, class Predicate>
+//   bool wait_until(Lock& lock, stop_token stoken,
+//                   const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
+
+#include <cassert>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class Mutex, class Lock>
+void test() {
+  const auto past   = std::chrono::steady_clock::now() - std::chrono::hours(1);
+  const auto future = std::chrono::steady_clock::now() + std::chrono::hours(1);
+
+  // stop_requested before hand
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+    ss.request_stop();
+
+    // [Note 4: The returned value indicates whether the predicate evaluated to true
+    // regardless of whether the timeout was triggered or a stop request was made.]
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return false; });
+    assert(!r1);
+
+    std::same_as<bool> auto r2 = cv.wait_until(lock, ss.get_token(), future, []() { return false; });
+    assert(!r2);
+
+    std::same_as<bool> auto r3 = cv.wait_until(lock, ss.get_token(), past, []() { return true; });
+    assert(r3);
+
+    std::same_as<bool> auto r4 = cv.wait_until(lock, ss.get_token(), future, []() { return true; });
+    assert(r4);
+
+    // Postconditions: lock is locked by the calling thread.
+    assert(lock.owns_lock());
+  }
+
+  // no stop request, pred was true
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return true; });
+    assert(r1);
+
+    std::same_as<bool> auto r2 = cv.wait_until(lock, ss.get_token(), future, []() { return true; });
+    assert(r2);
+  }
+
+  // no stop request, pred was false, abs_time was in the past
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), past, []() { return false; });
+    assert(!r1);
+  }
+
+  // no stop request, pred was false until timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    auto oldTime = std::chrono::steady_clock::now();
+
+    std::same_as<bool> auto r1 =
+        cv.wait_until(lock, ss.get_token(), oldTime + std::chrono::milliseconds(2), [&]() { return false; });
+
+    assert((std::chrono::steady_clock::now() - oldTime) >= std::chrono::milliseconds(2));
+    assert(!r1);
+  }
+
+  // no stop request, pred was false, changed to true before timeout
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    bool flag   = false;
+    auto thread = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      Lock lock{mutex};
+      flag = true;
+      cv.notify_all();
+    });
+
+    std::same_as<bool> auto r1 = cv.wait_until(lock, ss.get_token(), future, [&]() { return flag; });
+    assert(flag);
+    assert(r1);
+
+    thread.join();
+  }
+
+  // stop request comes while waiting
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    std::atomic_bool done = false;
+    auto thread           = support::make_test_thread([&]() {
+      std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      ss.request_stop();
+
+      while (!done) {
+        cv.notify_all();
+        std::this_thread::sleep_for(std::chrono::milliseconds(2));
+      }
+    });
+
+    std::same_as<bool> auto r = cv.wait_until(lock, ss.get_token(), future, [&]() { return false; });
+    assert(!r);
+    done = true;
+    thread.join();
+
+    assert(lock.owns_lock());
+  }
+
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  // Throws: Any exception thrown by pred.
+  {
+    std::stop_source ss;
+    std::condition_variable_any cv;
+    Mutex mutex;
+    Lock lock{mutex};
+
+    try {
+      cv.wait_until(lock, ss.get_token(), future, []() -> bool { throw 5; });
+      assert(false);
+    } catch (int i) {
+      assert(i == 5);
+    }
+  }
+#endif //!defined(TEST_HAS_NO_EXCEPTIONS)
+}
+
+int main(int, char**) {
+  test<std::mutex, std::unique_lock<std::mutex>>();
+  test<std::shared_mutex, std::shared_lock<std::shared_mutex>>();
+
+  return 0;
+}