diff --git a/kotlin-native/runtime/src/main/cpp/Clock.hpp b/kotlin-native/runtime/src/main/cpp/Clock.hpp
new file mode 100644
index 00000000000..2144d46b75c
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/Clock.hpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <condition_variable>
+#include <future>
+#include <mutex>
+#include <thread>
+
+#include "Saturating.hpp"
+
+namespace kotlin {
+
+namespace internal {
+
+template <typename NowF, typename StepDuration, typename Clock, typename Rep, typename Period, typename Ret, typename WaitForF>
+Ret waitUntilViaFor(
+        NowF&& nowF,
+        StepDuration step,
+        std::chrono::time_point<Clock, std::chrono::duration<saturating<Rep>, Period>> until,
+        Ret timeoutValue,
+        WaitForF&& waitForF) {
+    while (true) {
+        auto current = std::invoke(std::forward<NowF>(nowF));
+        if (current >= until) {
+            return timeoutValue;
+        }
+        auto left = until - current;
+        // Shield standard library from saturating types.
+        auto interval = left > step ? std::chrono::duration<Rep, Period>(step) : std::chrono::duration<Rep, Period>(left);
+        if (auto value = std::invoke(std::forward<WaitForF>(waitForF), interval); value != timeoutValue) {
+            return value;
+        }
+    }
+}
+
+template <typename NowF, typename StepDuration, typename Clock, typename Rep, typename Period, typename WaitForF>
+void waitUntilViaFor(
+        NowF&& nowF,
+        StepDuration step,
+        std::chrono::time_point<Clock, std::chrono::duration<saturating<Rep>, Period>> until,
+        WaitForF&& waitForF) {
+    while (true) {
+        auto current = std::invoke(std::forward<NowF>(nowF));
+        if (current >= until) {
+            return;
+        }
+        auto left = until - current;
+        // Shield standard library from saturating types.
+        auto interval = left > step ? std::chrono::duration<Rep, Period>(step) : std::chrono::duration<Rep, Period>(left);
+        std::invoke(std::forward<WaitForF>(waitForF), interval);
+    }
+}
+
+template <typename T, typename Lock>
+struct IsStdCV : public std::false_type {};
+
+template <>
+struct IsStdCV<std::condition_variable, std::unique_lock<std::mutex>> : public std::true_type {};
+
+template <typename Lock>
+struct IsStdCV<std::condition_variable_any, Lock> : public std::true_type {};
+
+template <typename T, typename Lock>
+inline constexpr bool isStdCV = IsStdCV<T, Lock>::value;
+
+template <typename T>
+struct IsStdFuture : public std::false_type {};
+
+template <typename T>
+struct IsStdFuture<std::future<T>> : public std::true_type {};
+
+template <typename T>
+struct IsStdFuture<std::shared_future<T>> : public std::true_type {};
+
+template <typename T>
+inline constexpr bool isStdFuture = IsStdFuture<T>::value;
+
+template <typename Clock>
+class ClockWaitImpl {
+public:
+    template <typename Rep, typename Period>
+    static void sleep_for(std::chrono::duration<Rep, Period> interval) {
+        // Not using this_thread::sleep_for, because it may mishandle "infinite" intervals. Use saturating arithmetics to address this.
+        return ClockWaitImpl<Clock>::sleep_until(Clock::now() + interval);
+    }
+
+    template <typename Rep, typename Period>
+    static void sleep_until(std::chrono::time_point<Clock, std::chrono::duration<Rep, Period>> until) {
+        if constexpr (is_saturating_v<Rep>) {
+            return Clock::sleepImpl(until);
+        } else {
+            return ClockWaitImpl<Clock>::sleep_until(std::chrono::time_point<Clock, std::chrono::duration<saturating<Rep>, Period>>(until));
+        }
+    }
+
+    template <typename CV, typename Lock, typename Rep, typename Period, typename F, typename = std::enable_if_t<isStdCV<CV, Lock>>>
+    static bool wait_for(CV& cv, Lock& lock, std::chrono::duration<Rep, Period> interval, F&& f) {
+        // Not using cv.wait_for, because it may mishandle "infinite" intervals. Use saturating arithmetics to address this.
+        return ClockWaitImpl<Clock>::wait_until(cv, lock, Clock::now() + interval, std::forward<F>(f));
+    }
+
+    template <typename CV, typename Lock, typename Rep, typename Period, typename F, typename = std::enable_if_t<isStdCV<CV, Lock>>>
+    static bool wait_until(CV& cv, Lock& lock, std::chrono::time_point<Clock, std::chrono::duration<Rep, Period>> until, F&& f) {
+        if constexpr (is_saturating_v<Rep>) {
+            [[maybe_unused]] auto pendingWait = Clock::addPendingWait(until);
+            // Implement in terms of repeated cv.wait_for of non-"infinite" intervals.
+            return internal::waitUntilViaFor(&Clock::now, Clock::wait_step, until, false, [&](auto interval) {
+                return cv.wait_for(lock, interval, std::forward<F>(f));
+            });
+        } else {
+            return ClockWaitImpl<Clock>::wait_until(
+                    cv, lock, std::chrono::time_point<Clock, std::chrono::duration<saturating<Rep>, Period>>(until), std::forward<F>(f));
+        }
+    }
+
+    template <typename Future, typename Rep, typename Period, typename = std::enable_if_t<isStdFuture<Future>>>
+    static std::future_status wait_for(const Future& future, std::chrono::duration<Rep, Period> interval) {
+        // Not using future.wait_for, because it may mishandle "infinite" intervals. Use saturating arithmetics to address this.
+        return ClockWaitImpl<Clock>::wait_until(future, Clock::now() + interval);
+    }
+
+    template <typename Future, typename Rep, typename Period, typename = std::enable_if_t<isStdFuture<Future>>>
+    static std::future_status wait_until(const Future& future, std::chrono::time_point<Clock, std::chrono::duration<Rep, Period>> until) {
+        if constexpr (is_saturating_v<Rep>) {
+            [[maybe_unused]] auto pendingWait = Clock::addPendingWait(until);
+            // Implement in terms of repeated future.wait_for of non-"infinite" intervals.
+            return internal::waitUntilViaFor(&Clock::now, Clock::wait_step, until, std::future_status::timeout, [&](auto interval) {
+                return future.wait_for(interval);
+            });
+        } else {
+            return ClockWaitImpl<Clock>::wait_until(
+                    future, std::chrono::time_point<Clock, std::chrono::duration<saturating<Rep>, Period>>(until));
+        }
+    }
+};
+
+} // namespace internal
+
+using nanoseconds = std::chrono::duration<saturating<std::chrono::nanoseconds::rep>, std::chrono::nanoseconds::period>;
+using microseconds = std::chrono::duration<saturating<std::chrono::microseconds::rep>, std::chrono::microseconds::period>;
+using milliseconds = std::chrono::duration<saturating<std::chrono::milliseconds::rep>, std::chrono::milliseconds::period>;
+using seconds = std::chrono::duration<saturating<std::chrono::seconds::rep>, std::chrono::seconds::period>;
+using minutes = std::chrono::duration<saturating<std::chrono::minutes::rep>, std::chrono::minutes::period>;
+using hours = std::chrono::duration<saturating<std::chrono::hours::rep>, std::chrono::hours::period>;
+
+class steady_clock : public internal::ClockWaitImpl<steady_clock> {
+public:
+    using rep = saturating<std::chrono::steady_clock::rep>;
+    using period = std::chrono::steady_clock::period;
+    using duration = std::chrono::duration<rep, period>;
+    using time_point = std::chrono::time_point<steady_clock>;
+
+    static constexpr bool is_steady = true;
+
+    static time_point now() noexcept {
+        auto time = std::chrono::steady_clock::now().time_since_epoch();
+        return time_point(time);
+    }
+
+private:
+    friend class internal::ClockWaitImpl<steady_clock>;
+
+    // Use non-saturating type here, because step may be fed into the standard library.
+    static inline constexpr auto wait_step = std::chrono::hours(24);
+
+    template <typename Rep, typename Period>
+    static void sleepImpl(std::chrono::time_point<steady_clock, std::chrono::duration<saturating<Rep>, Period>> until) {
+        // Implement in terms of repeated this_thread::sleep_for of non-"infinite" intervals.
+        return internal::waitUntilViaFor(&now, wait_step, until, [&](auto interval) { std::this_thread::sleep_for(interval); });
+    }
+
+    template <typename Rep, typename Period>
+    static int addPendingWait(std::chrono::time_point<steady_clock, std::chrono::duration<saturating<Rep>, Period>> until) {
+        // No need to register here.
+        return 0;
+    }
+};
+
+} // namespace kotlin
diff --git a/kotlin-native/runtime/src/main/cpp/ClockTest.cpp b/kotlin-native/runtime/src/main/cpp/ClockTest.cpp
new file mode 100644
index 00000000000..2630d2dc2b7
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/ClockTest.cpp
@@ -0,0 +1,1118 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#include "Clock.hpp"
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <shared_mutex>
+#include <tuple>
+#include <type_traits>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include "ClockTestSupport.hpp"
+#include "ScopedThread.hpp"
+#include "TestSupport.hpp"
+
+using namespace kotlin;
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_ImmediateOK) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    constexpr int okValue = 13;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(okValue));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, okValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_EventualOK) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    constexpr int okValue = 13;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(okValue));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, okValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_LastChanceOK) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    constexpr int okValue = 13;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step));
+        EXPECT_CALL(waitForF, Call(rest)).WillOnce(testing::Return(okValue));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, okValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_Timeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step));
+        EXPECT_CALL(waitForF, Call(rest)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step + rest));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, timeoutValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_ImmediateTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step + step));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, timeoutValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_ClockJumpTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        // Instead of incrementing by `step`, the clock jumped straight to `until`.
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(until));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, timeoutValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Int_NonconformantWaitTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    // waitFor non-conformingly waits less than specified.
+    constexpr auto actualStep = std::chrono::seconds(7);
+    constexpr auto rest = std::chrono::seconds(3);
+    constexpr auto until = TimePoint() + step + step + rest;
+    constexpr int timeoutValue = 42;
+    testing::StrictMock<testing::MockFunction<int(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep));
+        EXPECT_CALL(waitForF, Call(step)).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep));
+        // Waited 2 * 7 out of 2 * 10 + 3 seconds. 9 seconds left. Will wait only 6 seconds.
+        EXPECT_CALL(waitForF, Call(std::chrono::seconds(9))).WillOnce(testing::Return(timeoutValue));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep + std::chrono::seconds(6)));
+        EXPECT_CALL(waitForF, Call(std::chrono::seconds(3))).WillOnce(testing::Return(timeoutValue));
+        // Finally waited enough.
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep + std::chrono::seconds(9)));
+    }
+    auto result = internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, timeoutValue, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+    EXPECT_THAT(result, timeoutValue);
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Void_Timeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    testing::StrictMock<testing::MockFunction<void(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step));
+        EXPECT_CALL(waitForF, Call(step));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step));
+        EXPECT_CALL(waitForF, Call(rest));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step + rest));
+    }
+    internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Void_ImmediateTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    testing::StrictMock<testing::MockFunction<void(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + step + step + step));
+    }
+    internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Void_ClockJumpTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    constexpr auto rest = std::chrono::seconds(1);
+    constexpr auto until = TimePoint() + step + step + rest;
+    testing::StrictMock<testing::MockFunction<void(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step));
+        // Instead of incrementing by `step`, the clock jumped straight to `until`.
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(until));
+    }
+    internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+}
+
+TEST(ClockInternalTest, WaitUntilViaFor_Void_NonconformantWaitTimeout) {
+    using TimePoint = std::chrono::time_point<test_support::manual_clock>;
+    testing::StrictMock<testing::MockFunction<TimePoint()>> nowF;
+    constexpr auto step = std::chrono::seconds(10);
+    // waitFor non-conformingly waits less than specified.
+    constexpr auto actualStep = std::chrono::seconds(7);
+    constexpr auto rest = std::chrono::seconds(3);
+    constexpr auto until = TimePoint() + step + step + rest;
+    testing::StrictMock<testing::MockFunction<void(std::chrono::seconds)>> waitForF;
+
+    {
+        testing::InSequence s;
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint()));
+        EXPECT_CALL(waitForF, Call(step));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep));
+        EXPECT_CALL(waitForF, Call(step));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep));
+        // Waited 2 * 7 out of 2 * 10 + 3 seconds. 9 seconds left. Will wait only 6 seconds.
+        EXPECT_CALL(waitForF, Call(std::chrono::seconds(9)));
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep + std::chrono::seconds(6)));
+        EXPECT_CALL(waitForF, Call(std::chrono::seconds(3)));
+        // Finally waited enough.
+        EXPECT_CALL(nowF, Call()).WillOnce(testing::Return(TimePoint() + actualStep + actualStep + std::chrono::seconds(9)));
+    }
+    internal::waitUntilViaFor(nowF.AsStdFunction(), step, until, [&](auto interval) {
+        return waitForF.Call(std::chrono::duration_cast<std::chrono::seconds>(interval));
+    });
+}
+
+namespace {
+
+class ClockTestNames {
+public:
+    template <typename T>
+    static std::string GetName(int) {
+        if constexpr (std::is_same_v<T, kotlin::steady_clock>) {
+            return "steady_clock";
+        } else if constexpr (std::is_same_v<T, kotlin::test_support::manual_clock>) {
+            return "manual_clock";
+        } else {
+            return "unknown";
+        }
+    }
+};
+
+} // namespace
+
+template <typename T>
+class ClockTest : public testing::Test {
+public:
+    ClockTest() noexcept { test_support::manual_clock::reset(); }
+};
+
+using ClockTestTypes = testing::Types<kotlin::steady_clock, kotlin::test_support::manual_clock>;
+TYPED_TEST_SUITE(ClockTest, ClockTestTypes, ClockTestNames);
+
+TYPED_TEST(ClockTest, SleepFor) {
+    constexpr auto interval = milliseconds(1);
+    auto before = TypeParam::now();
+    TypeParam::sleep_for(interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(after - before, testing::Ge(interval));
+}
+
+TYPED_TEST(ClockTest, SleepUntil) {
+    auto until = TypeParam::now() + milliseconds(1);
+    TypeParam::sleep_until(until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(after, testing::Ge(until));
+}
+
+TYPED_TEST(ClockTest, CVWaitFor_OK) {
+    constexpr auto interval = hours(10);
+    std::condition_variable cv;
+    std::mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, interval, [&] { return ok; });
+    auto after = TypeParam::now();
+    EXPECT_TRUE(result);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, CVWaitFor_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::condition_variable cv;
+    std::mutex m;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    std::unique_lock guard(m);
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, interval, [] { return false; });
+    auto after = TypeParam::now();
+    EXPECT_FALSE(result);
+    EXPECT_THAT(after - before, testing::Ge(interval));
+}
+
+TYPED_TEST(ClockTest, CVWaitFor_InfiniteTimeout) {
+    std::condition_variable cv;
+    std::mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_for` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, microseconds::max(), [&] { return ok; });
+    EXPECT_TRUE(result);
+}
+
+TYPED_TEST(ClockTest, CVWaitUntil_OK) {
+    std::condition_variable cv;
+    std::mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    auto until = TypeParam::now() + hours(10);
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, until, [&] { return ok; });
+    auto after = TypeParam::now();
+    EXPECT_TRUE(result);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, CVWaitUntil_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::condition_variable cv;
+    std::mutex m;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    std::unique_lock guard(m);
+    auto until = TypeParam::now() + interval;
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, until, [] { return false; });
+    auto after = TypeParam::now();
+    EXPECT_FALSE(result);
+    EXPECT_THAT(after, testing::Ge(until));
+}
+
+TYPED_TEST(ClockTest, CVWaitUntil_InfiniteTimeout) {
+    std::condition_variable cv;
+    std::mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_until` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, TypeParam::time_point::max(), [&] { return ok; });
+    EXPECT_TRUE(result);
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitFor_OK) {
+    constexpr auto interval = hours(10);
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, interval, [&] { return ok; });
+    auto after = TypeParam::now();
+    EXPECT_TRUE(result);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitFor_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    std::unique_lock guard(m);
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, interval, [] { return false; });
+    auto after = TypeParam::now();
+    EXPECT_FALSE(result);
+    EXPECT_THAT(after - before, testing::Ge(interval));
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitFor_InfiniteTimeout) {
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_for` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    go = true;
+    auto result = TypeParam::wait_for(cv, guard, microseconds::max(), [&] { return ok; });
+    EXPECT_TRUE(result);
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitUntil_OK) {
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    auto until = TypeParam::now() + hours(10);
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, until, [&] { return ok; });
+    auto after = TypeParam::now();
+    EXPECT_TRUE(result);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitUntil_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    std::unique_lock guard(m);
+    auto until = TypeParam::now() + interval;
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, until, [] { return false; });
+    auto after = TypeParam::now();
+    EXPECT_FALSE(result);
+    EXPECT_THAT(after, testing::Ge(until));
+}
+
+TYPED_TEST(ClockTest, CVAnyWaitUntil_InfiniteTimeout) {
+    std::condition_variable_any cv;
+    std::shared_mutex m;
+    bool ok = false;
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_until` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        {
+            std::unique_lock guard(m);
+            ok = true;
+        }
+        cv.notify_all();
+    });
+    std::unique_lock guard(m);
+    go = true;
+    auto result = TypeParam::wait_until(cv, guard, TypeParam::time_point::max(), [&] { return ok; });
+    EXPECT_TRUE(result);
+}
+
+TYPED_TEST(ClockTest, FutureWaitFor_OK) {
+    constexpr auto interval = hours(10);
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        promise.set_value(42);
+    });
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::ready);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, FutureWaitFor_Deferred) {
+    constexpr auto interval = hours(10);
+    std::future<int> future = std::async(std::launch::deferred, [] { return 42; });
+    auto before = TypeParam::now();
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::deferred);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, FutureWaitFor_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::timeout);
+    EXPECT_THAT(after - before, testing::Ge(interval));
+}
+
+TYPED_TEST(ClockTest, FutureWaitFor_InfiniteTimeout) {
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_for` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        promise.set_value(42);
+    });
+    go = true;
+    auto result = TypeParam::wait_for(future, microseconds::max());
+    EXPECT_THAT(result, std::future_status::ready);
+}
+
+TYPED_TEST(ClockTest, FutureWaitUntil_OK) {
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        promise.set_value(42);
+    });
+    auto until = TypeParam::now() + hours(10);
+    go = true;
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::ready);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, FutureWaitUntil_Deferred) {
+    std::future<int> future = std::async(std::launch::deferred, [] { return 42; });
+    auto until = TypeParam::now() + hours(10);
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::deferred);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, FutureWaitUntil_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    auto until = TypeParam::now() + interval;
+    go = true;
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::timeout);
+    EXPECT_THAT(after, testing::Ge(until));
+}
+
+TYPED_TEST(ClockTest, FutureWaitUntil_InfiniteTimeout) {
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_until` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        promise.set_value(42);
+    });
+    go = true;
+    auto result = TypeParam::wait_until(future, TypeParam::time_point::max());
+    EXPECT_THAT(result, std::future_status::ready);
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitFor_OK) {
+    constexpr auto interval = hours(10);
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        promise.set_value(42);
+    });
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::ready);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitFor_Deferred) {
+    constexpr auto interval = hours(10);
+    std::shared_future<int> future = std::async(std::launch::deferred, [] { return 42; });
+    auto before = TypeParam::now();
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::deferred);
+    EXPECT_THAT(after - before, testing::Lt(interval));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitFor_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    auto before = TypeParam::now();
+    go = true;
+    auto result = TypeParam::wait_for(future, interval);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::timeout);
+    EXPECT_THAT(after - before, testing::Ge(interval));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitFor_InfiniteTimeout) {
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_for` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        promise.set_value(42);
+    });
+    go = true;
+    auto result = TypeParam::wait_for(future, microseconds::max());
+    EXPECT_THAT(result, std::future_status::ready);
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitUntil_OK) {
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        promise.set_value(42);
+    });
+    auto until = TypeParam::now() + hours(10);
+    go = true;
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::ready);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitUntil_Deferred) {
+    std::shared_future<int> future = std::async(std::launch::deferred, [] { return 42; });
+    auto until = TypeParam::now() + hours(10);
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::deferred);
+    EXPECT_THAT(after, testing::Lt(until));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitUntil_Timeout) {
+    constexpr auto interval = microseconds(10);
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        TypeParam::sleep_for(interval);
+    });
+    auto until = TypeParam::now() + interval;
+    go = true;
+    auto result = TypeParam::wait_until(future, until);
+    auto after = TypeParam::now();
+    EXPECT_THAT(result, std::future_status::timeout);
+    EXPECT_THAT(after, testing::Ge(until));
+}
+
+TYPED_TEST(ClockTest, SharedFutureWaitUntil_InfiniteTimeout) {
+    std::promise<int> promise;
+    std::shared_future<int> future = promise.get_future();
+    std::atomic<bool> go = false;
+    ScopedThread thread([&] {
+        while (!go.load()) {
+        }
+        // Wait to see if `TypeParam::wait_until` wakes up from timeout.
+        TypeParam::sleep_for(milliseconds(1));
+        promise.set_value(42);
+    });
+    go = true;
+    auto result = TypeParam::wait_until(future, TypeParam::time_point::max());
+    EXPECT_THAT(result, std::future_status::ready);
+}
+
+namespace {
+
+class ClockTypesTestNames {
+public:
+    template <typename T>
+    static std::string GetName(int) {
+        std::string result;
+        result += clockName<T>();
+        result += "_";
+        result += durationName<T>();
+        return result;
+    }
+
+private:
+    template <typename T>
+    static const char* clockName() {
+        using Clock = typename std::tuple_element<0, T>::type;
+        if constexpr (std::is_same_v<Clock, kotlin::steady_clock>) {
+            return "steady_clock";
+        } else if constexpr (std::is_same_v<Clock, kotlin::test_support::manual_clock>) {
+            return "manual_clock";
+        } else {
+            return "unknown";
+        }
+    }
+
+    template <typename T>
+    static const char* durationName() {
+        using Duration = typename std::tuple_element<1, T>::type;
+        if constexpr (std::is_same_v<Duration, std::chrono::nanoseconds>) {
+            return "ns";
+        } else if constexpr (std::is_same_v<Duration, std::chrono::microseconds>) {
+            return "us";
+        } else if constexpr (std::is_same_v<Duration, std::chrono::milliseconds>) {
+            return "ms";
+        } else if constexpr (std::is_same_v<Duration, std::chrono::seconds>) {
+            return "s";
+        } else if constexpr (std::is_same_v<Duration, std::chrono::minutes>) {
+            return "m";
+        } else if constexpr (std::is_same_v<Duration, std::chrono::hours>) {
+            return "h";
+        } else if constexpr (std::is_same_v<Duration, kotlin::nanoseconds>) {
+            return "sat_ns";
+        } else if constexpr (std::is_same_v<Duration, kotlin::microseconds>) {
+            return "sat_us";
+        } else if constexpr (std::is_same_v<Duration, kotlin::milliseconds>) {
+            return "sat_ms";
+        } else if constexpr (std::is_same_v<Duration, kotlin::seconds>) {
+            return "sat_s";
+        } else if constexpr (std::is_same_v<Duration, kotlin::minutes>) {
+            return "sat_m";
+        } else if constexpr (std::is_same_v<Duration, kotlin::hours>) {
+            return "sat_h";
+        } else {
+            return "unknown";
+        }
+    }
+};
+
+} // namespace
+
+template <typename T>
+class ClockTypesTest : public testing::Test {
+public:
+    using Clock = typename std::tuple_element<0, T>::type;
+    using Duration = typename std::tuple_element<1, T>::type;
+};
+
+using ClockTypesTestTypes = testing::Types<
+        std::tuple<kotlin::steady_clock, std::chrono::nanoseconds>,
+        std::tuple<kotlin::steady_clock, std::chrono::microseconds>,
+        std::tuple<kotlin::steady_clock, std::chrono::milliseconds>,
+        std::tuple<kotlin::steady_clock, std::chrono::seconds>,
+        std::tuple<kotlin::steady_clock, std::chrono::minutes>,
+        std::tuple<kotlin::steady_clock, std::chrono::hours>,
+        std::tuple<kotlin::steady_clock, kotlin::nanoseconds>,
+        std::tuple<kotlin::steady_clock, kotlin::microseconds>,
+        std::tuple<kotlin::steady_clock, kotlin::milliseconds>,
+        std::tuple<kotlin::steady_clock, kotlin::seconds>,
+        std::tuple<kotlin::steady_clock, kotlin::minutes>,
+        std::tuple<kotlin::steady_clock, kotlin::hours>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::nanoseconds>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::microseconds>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::milliseconds>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::seconds>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::minutes>,
+        std::tuple<kotlin::test_support::manual_clock, std::chrono::hours>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::nanoseconds>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::microseconds>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::milliseconds>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::seconds>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::minutes>,
+        std::tuple<kotlin::test_support::manual_clock, kotlin::hours>>;
+TYPED_TEST_SUITE(ClockTypesTest, ClockTypesTestTypes, ClockTypesTestNames);
+
+TYPED_TEST(ClockTypesTest, SleepFor) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<void, decltype(Clock::sleep_for(std::declval<Duration>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, SleepUntil) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<void, decltype(Clock::sleep_until(std::declval<std::chrono::time_point<Clock, Duration>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, CVWaitFor) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  bool,
+                  decltype(Clock::wait_for(
+                          std::declval<std::condition_variable&>(), std::declval<std::unique_lock<std::mutex>&>(), std::declval<Duration>(),
+                          std::declval<std::function<bool()>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, CVWaitUntil) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  bool,
+                  decltype(Clock::wait_until(
+                          std::declval<std::condition_variable&>(), std::declval<std::unique_lock<std::mutex>&>(),
+                          std::declval<std::chrono::time_point<Clock, Duration>>(), std::declval<std::function<bool()>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, CVAnyWaitFor) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  bool,
+                  decltype(Clock::wait_for(
+                          std::declval<std::condition_variable_any&>(), std::declval<std::unique_lock<std::shared_mutex>&>(),
+                          std::declval<Duration>(), std::declval<std::function<bool()>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, CVAnyWaitUntil) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  bool,
+                  decltype(Clock::wait_until(
+                          std::declval<std::condition_variable_any&>(), std::declval<std::unique_lock<std::shared_mutex>&>(),
+                          std::declval<std::chrono::time_point<Clock, Duration>>(), std::declval<std::function<bool()>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, FutureWaitFor) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  std::future_status, decltype(Clock::wait_for(std::declval<const std::future<int>&>(), std::declval<Duration>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, FutureWaitUntil) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  std::future_status,
+                  decltype(Clock::wait_until(
+                          std::declval<const std::future<int>&>(), std::declval<std::chrono::time_point<Clock, Duration>>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, SharedFutureWaitFor) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  std::future_status, decltype(Clock::wait_for(std::declval<const std::shared_future<int>&>(), std::declval<Duration>()))>);
+}
+
+TYPED_TEST(ClockTypesTest, SharedFutureWaitUntil) {
+    using Clock = typename ClockTypesTest<TypeParam>::Clock;
+    using Duration = typename ClockTypesTest<TypeParam>::Duration;
+    static_assert(std::is_same_v<
+                  std::future_status,
+                  decltype(Clock::wait_until(
+                          std::declval<const std::shared_future<int>&>(), std::declval<std::chrono::time_point<Clock, Duration>>()))>);
+}
+
+TEST(ManualClockTest, SleepUntil) {
+    test_support::manual_clock::reset();
+
+    auto before = test_support::manual_clock::now();
+    test_support::manual_clock::sleep_until(before + seconds(2));
+    EXPECT_THAT(test_support::manual_clock::now() - before, seconds(2));
+    // Sleep until current time.
+    test_support::manual_clock::sleep_until(before + seconds(2));
+    EXPECT_THAT(test_support::manual_clock::now() - before, seconds(2));
+    // Sleep until moment in the past.
+    test_support::manual_clock::sleep_until(before);
+    EXPECT_THAT(test_support::manual_clock::now() - before, seconds(2));
+}
+
+TEST(ManualClockTest, Pending) {
+    test_support::manual_clock::reset();
+
+    // Nothing pending at start.
+    EXPECT_THAT(test_support::manual_clock::pending(), std::nullopt);
+    std::promise<int> promise;
+    std::future<int> future = promise.get_future();
+    ScopedThread thread([&] { test_support::manual_clock::wait_for(future, seconds(1)); });
+    test_support::manual_clock::waitForPending(test_support::manual_clock::now() + seconds(1));
+
+    // Unblocks the thread.
+    test_support::manual_clock::sleep_for(seconds(1));
+    thread.join();
+
+    // Nothing pending anymore.
+    EXPECT_THAT(test_support::manual_clock::pending(), std::nullopt);
+}
+
+TEST(ManualClockTest, ConcurrentSleepUntil) {
+    test_support::manual_clock::reset();
+
+    constexpr auto threadCount = kDefaultThreadCount;
+    KStdVector<ScopedThread> threads;
+    std::atomic<bool> run = false;
+    std::atomic<int> ready = 0;
+    for (int i = 0; i < threadCount; ++i) {
+        threads.emplace_back([&, i] {
+            auto now = test_support::manual_clock::now();
+            ++ready;
+            while (!run.load()) {
+            }
+            test_support::manual_clock::sleep_until(now + seconds(i));
+        });
+    }
+    auto before = test_support::manual_clock::now();
+    while (ready.load() < threadCount) {
+    }
+    run = true;
+    threads.clear();
+    auto after = test_support::manual_clock::now();
+    EXPECT_THAT(after - before, seconds(threadCount - 1));
+}
+
+TEST(ManualClockTest, ConcurrentWaits) {
+    test_support::manual_clock::reset();
+
+    constexpr auto threadCount = kDefaultThreadCount;
+    KStdVector<ScopedThread> threads;
+    std::mutex mutex;
+    std::condition_variable cv;
+    std::condition_variable_any cvAny;
+    std::promise<int> promise1;
+    std::promise<int> promise2;
+    std::future<int> future = promise1.get_future();
+    std::shared_future<int> shared_future = promise2.get_future().share();
+    std::atomic<bool> run = false;
+    std::atomic<int> ready = 0;
+    for (int i = 0; i < threadCount; ++i) {
+        threads.emplace_back([&, i] {
+            auto now = test_support::manual_clock::now();
+            ++ready;
+            while (!run.load()) {
+            }
+            switch (i % 4) {
+                case 0: {
+                    std::unique_lock guard(mutex);
+                    test_support::manual_clock::wait_until(cv, guard, now + seconds(i / 3 + 1), [] { return false; });
+                }
+                case 1: {
+                    std::unique_lock guard(mutex);
+                    test_support::manual_clock::wait_until(cvAny, guard, now + seconds(i / 3 + 1), [] { return false; });
+                }
+                case 2: {
+                    test_support::manual_clock::wait_until(future, now + seconds(i / 3 + 1));
+                }
+                case 3: {
+                    test_support::manual_clock::wait_until(shared_future, now + seconds(i / 3 + 1));
+                }
+            }
+        });
+    }
+    auto before = test_support::manual_clock::now();
+    while (ready.load() < threadCount) {
+    }
+    run = true;
+
+    test_support::manual_clock::sleep_until(before + seconds(1));
+    // Now the first 3 threads will be unblocked.
+    threads[0].join();
+    threads[1].join();
+    threads[2].join();
+    // Make sure at least one other thread is waiting.
+    while (!test_support::manual_clock::pending()) {
+    }
+    auto pendingAfterSecond = *test_support::manual_clock::pending();
+    EXPECT_THAT(pendingAfterSecond, testing::Ge(before + seconds(2)));
+
+    // Unblock all the threads.
+    test_support::manual_clock::sleep_until(before + seconds((threadCount - 1) / 3 + 1));
+    threads.clear();
+    // All threads are gone, nothing can possibly be pending.
+    EXPECT_THAT(test_support::manual_clock::pending(), std::nullopt);
+}
diff --git a/kotlin-native/runtime/src/main/cpp/ClockTestSupport.cpp b/kotlin-native/runtime/src/main/cpp/ClockTestSupport.cpp
new file mode 100644
index 00000000000..21be99d25cb
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/ClockTestSupport.cpp
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#include "ClockTestSupport.hpp"
+
+using namespace kotlin;
+
+// static
+std::atomic<test_support::manual_clock::time_point> test_support::manual_clock::now_ = test_support::manual_clock::time_point::min();
+
+// static
+std::mutex test_support::manual_clock::pendingWaitsMutex_;
+
+// static
+KStdOrderedMultiset<test_support::manual_clock::time_point> test_support::manual_clock::pendingWaits_;
diff --git a/kotlin-native/runtime/src/main/cpp/ClockTestSupport.hpp b/kotlin-native/runtime/src/main/cpp/ClockTestSupport.hpp
new file mode 100644
index 00000000000..6d1ed88de45
--- /dev/null
+++ b/kotlin-native/runtime/src/main/cpp/ClockTestSupport.hpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "Clock.hpp"
+
+#include <optional>
+
+#include "gtest/gtest.h"
+
+#include "Types.h"
+#include "Utils.hpp"
+
+namespace kotlin::test_support {
+
+// Clock that is manually advanced (cannot go backwards). For testing purposes.
+// TODO: Should be reset at the start of each test.
+class manual_clock : public internal::ClockWaitImpl<manual_clock> {
+public:
+    using duration = nanoseconds;
+    using rep = duration::rep;
+    using period = duration::period;
+    using time_point = std::chrono::time_point<manual_clock>;
+
+    // Steady because it cannot go backwards.
+    static constexpr bool is_steady = true;
+
+    static time_point now() noexcept { return now_.load(); }
+
+    static std::optional<time_point> pending() noexcept {
+        std::unique_lock guard(pendingWaitsMutex_);
+        auto it = pendingWaits_.begin();
+        if (it == pendingWaits_.end()) {
+            return std::nullopt;
+        }
+        return *it;
+    }
+
+    template <typename Duration, typename Rep, typename Period>
+    static void waitForPending(
+            std::chrono::time_point<manual_clock, Duration> expectedPending, std::chrono::duration<Rep, Period> timeout) {
+        // Use real clock for timeout.
+        auto until = std::chrono::steady_clock::now() + timeout;
+        while (!pending() || *pending() != expectedPending) {
+            if (std::chrono::steady_clock::now() > until) {
+                EXPECT_THAT(pending(), std::make_optional(expectedPending));
+                return;
+            }
+        }
+    }
+
+    template <typename Duration>
+    static void waitForPending(std::chrono::time_point<manual_clock, Duration> expectedPending) {
+        waitForPending(expectedPending, std::chrono::minutes(5));
+    }
+
+    // Should be done before the timer is used (in the beginning of the test, for example).
+    static void reset(time_point start = time_point::min()) noexcept {
+        std::unique_lock guard(pendingWaitsMutex_);
+        RuntimeAssert(pendingWaits_.empty(), "To reset, there must not be any pending waits");
+        now_ = start;
+    }
+
+private:
+    friend class internal::ClockWaitImpl<manual_clock>;
+
+    // Use non-saturating type here, because step may be fed into the standard library.
+    static inline constexpr auto wait_step = std::chrono::microseconds(1);
+
+    template <typename Rep, typename Period>
+    static void sleepImpl(std::chrono::time_point<manual_clock, std::chrono::duration<saturating<Rep>, Period>> until) {
+        time_point before = now();
+        while (before < until) {
+            now_.compare_exchange_weak(before, until);
+        }
+    }
+
+    class PendingWaitRegistration : private Pinned {
+    public:
+        ~PendingWaitRegistration() noexcept {
+            std::unique_lock guard(pendingWaitsMutex_);
+            pendingWaits_.erase(it_);
+        }
+
+    private:
+        friend class manual_clock;
+
+        explicit PendingWaitRegistration(KStdOrderedMultiset<time_point>::iterator it) noexcept : it_(it) {}
+
+        KStdOrderedMultiset<time_point>::iterator it_;
+    };
+
+    template <typename Rep, typename Period>
+    static PendingWaitRegistration addPendingWait(
+            std::chrono::time_point<manual_clock, std::chrono::duration<saturating<Rep>, Period>> until) {
+        std::unique_lock guard(pendingWaitsMutex_);
+        auto it = pendingWaits_.insert(until);
+        return PendingWaitRegistration(it);
+    }
+
+    static std::atomic<time_point> now_;
+    static std::mutex pendingWaitsMutex_;
+    static KStdOrderedMultiset<time_point> pendingWaits_;
+};
+
+} // namespace kotlin::test_support