uts: mock object.wait(timeout) calls as well

Author: ttypic

lib/src/main/java/io/ably/lib/http/HttpScheduler.java

@@ -291,7 +291,7 @@ public T get(long timeout, TimeUnit unit) throws InterruptedException, Execution
             long remaining = unit.toMillis(timeout), deadline = clock.currentTimeMillis() + remaining;
             synchronized(this) {
                 while(remaining > 0) {
-                    wait(remaining);
+                    clock.waitOn(this, remaining);
                     if(isDone) { break; }
                     remaining = deadline - clock.currentTimeMillis();
                 }

lib/src/main/java/io/ably/lib/transport/ConnectionManager.java

@@ -995,7 +995,7 @@ public void run() {
             boolean pending;
             synchronized(heartbeatWaiters) {
                 try {
-                    heartbeatWaiters.wait(HEARTBEAT_TIMEOUT);
+                    clock.waitOn(heartbeatWaiters, HEARTBEAT_TIMEOUT);
                 } catch (InterruptedException ie) {
                 }
                 pending = clear();
@@ -1506,7 +1506,7 @@ private void tryWait(long timeout) {
             if(timeout == 0) {
                 wait();
             } else {
-                wait(timeout);
+                clock.waitOn(this, timeout);
             }
         } catch (InterruptedException e) {}
     }

lib/src/main/java/io/ably/lib/util/Clock.java

@@ -1,6 +1,46 @@
 package io.ably.lib.util;
 
+/**
+ * Abstraction over time-related operations used throughout the SDK.
+ *
+ * <p>The default implementation, {@link SystemClock}, delegates to the real system clock and
+ * standard Java concurrency primitives. Tests and debug builds can supply an alternative
+ * implementation (e.g. a fake/controllable clock) via {@link io.ably.lib.debug.DebugOptions#clock}
+ * to drive time-dependent behaviour deterministically without sleeping.
+ */
 public interface Clock {
+
+    /**
+     * Returns the current wall-clock time in milliseconds since the Unix epoch
+     * (1 January 1970 00:00:00 UTC), analogous to {@link System#currentTimeMillis()}.
+     *
+     * @return current time in milliseconds
+     */
     long currentTimeMillis();
+
+    /**
+     * Creates a new {@link NamedTimer} backed by this clock.
+     *
+     * <p>The name is used for diagnostic and logging purposes (e.g. as the underlying
+     * {@link java.util.Timer} thread name).
+     *
+     * @param name a human-readable label for the timer; must not be {@code null}
+     * @return a new {@link NamedTimer} instance ready to schedule tasks
+     */
     NamedTimer newTimer(String name);
+
+    /**
+     * Causes the current thread to wait until either another thread calls
+     * {@link Object#notify()} / {@link Object#notifyAll()} on {@code target}, or the
+     * specified timeout elapses — analogous to {@link Object#wait(long)}.
+     *
+     * <p>The caller must hold the monitor of {@code target} before invoking this method,
+     * exactly as required by {@link Object#wait(long)}.
+     *
+     * @param target  the object whose monitor the current thread holds and will wait on;
+     *                must not be {@code null}
+     * @param timeout maximum time to wait in milliseconds; {@code 0} means wait indefinitely
+     * @throws InterruptedException if the current thread is interrupted while waiting
+     */
+    void waitOn(Object target, long timeout) throws InterruptedException;
 }

lib/src/main/java/io/ably/lib/util/SystemClock.java

@@ -31,6 +31,11 @@ public void cancel() {
         };
     }
 
+    @Override
+    public void waitOn(Object target, long timeout) throws InterruptedException {
+        target.wait(timeout);
+    }
+
     public static Clock clockFrom(ClientOptions opts) {
         if (opts instanceof DebugOptions) {
             Clock c = ((DebugOptions) opts).clock;

uts/src/test/kotlin/io/ably/lib/test/mock/DefaultPendingRequest.kt

@@ -4,9 +4,9 @@ import io.ably.lib.network.FailedConnectionException
 import io.ably.lib.network.HttpBody
 import io.ably.lib.network.HttpRequest
 import io.ably.lib.network.HttpResponse
+import kotlin.time.Duration
 import kotlinx.coroutines.CompletableDeferred
 import java.net.SocketTimeoutException
-import java.time.Duration
 
 internal class DefaultPendingRequest(
     private val request: HttpRequest,
@@ -34,7 +34,7 @@ internal class DefaultPendingRequest(
 
     override fun respondWithDelay(delay: Duration, status: Int, body: Any) {
         Thread {
-            Thread.sleep(delay.toMillis())
+            Thread.sleep(delay.inWholeMilliseconds)
             respondWith(status, body)
         }.apply { isDaemon = true }.start()
     }

uts/src/test/kotlin/io/ably/lib/test/mock/FakeClock.kt

@@ -15,6 +15,7 @@ import kotlin.time.Duration
 class FakeClock(initialTimeMs: Long = 0L) : Clock {
     @Volatile private var time = initialTimeMs
     private val timers = mutableMapOf<String, FakeNamedTimer>()
+    private val waiters = mutableListOf<Waiter>()
 
     override fun currentTimeMillis() = time
 
@@ -24,10 +25,29 @@ class FakeClock(initialTimeMs: Long = 0L) : Clock {
         return t
     }
 
+    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
+    override fun waitOn(target: Any, timeout: Long) {
+        synchronized(waiters) {
+            waiters.add(Waiter(target as Object, time + timeout))
+        }
+        (target as Object).wait()
+    }
+
     /** Advance virtual time by [ms] milliseconds, firing any timers that become due. */
     fun advance(ms: Long) {
         time += ms
         timers.values.forEach { it.fireDue(time) }
+        val due = synchronized(waiters) {
+            waiters.filter { it.fireAt <= time }.also {
+                waiters.removeIf { it.fireAt <= time }
+            }
+        }
+        // notifyAll() requires holding the target's monitor.
+        due.forEach { waiter ->
+            synchronized(waiter.target) {
+                waiter.target.notifyAll()
+            }
+        }
     }
 
     /** Advance virtual time by [time], firing any timers that become due. */
@@ -60,4 +80,7 @@ class FakeClock(initialTimeMs: Long = 0L) : Clock {
     }
 
     class Scheduled(val task: TimerTask, val fireAt: Long)
+
+    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
+    class Waiter(val target: Object, val fireAt: Long)
 }

uts/src/test/kotlin/io/ably/lib/test/mock/PendingRequest.kt

@@ -1,6 +1,7 @@
 package io.ably.lib.test.mock
 
-import java.time.Duration
+import kotlin.time.Duration
+
 
 /**
  * An in-flight HTTP request that the test must resolve.