Change LDAwaitFuture to not treat zero timeout as unlimited timeout

Treating a timeout of zero as unlimited caused a change in behavior when initializing the SDK. This update restores the behavior init had when zero was passed as the timeout argument from pre-2.8.0. Also improves handling of spurious wakeups, and includes test cases for LDAwaitFuture.

Author: gwhelanLD

launchdarkly-android-client-sdk/src/androidTest/java/com/launchdarkly/android/LDAwaitFutureTest.java

@@ -0,0 +1,122 @@
+package com.launchdarkly.android;
+
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+
+@RunWith(AndroidJUnit4.class)
+public class LDAwaitFutureTest {
+
+    @Rule
+    public TimberLoggingRule timberLoggingRule = new TimberLoggingRule();
+
+    @Test
+    public void defaultCancelledValueIsFalse() {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        assertFalse(future.isCancelled());
+    }
+
+    @Test
+    public void futureStartsIncomplete() {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        assertFalse(future.isDone());
+    }
+
+    @Test(timeout = 500L)
+    public void futureThrowsTimeoutWhenNotSet() throws ExecutionException, InterruptedException {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        try {
+            future.get(250, TimeUnit.MILLISECONDS);
+        } catch (TimeoutException ignored) {
+        }
+    }
+
+    @Test(timeout = 500L)
+    public void futureThrowsTimeoutExceptionWithZeroTimeout() throws ExecutionException,
+            InterruptedException {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        try {
+            future.get(0, TimeUnit.SECONDS);
+        } catch (TimeoutException ignored) {
+        }
+    }
+
+    @Test(timeout = 500L)
+    public void futureDoesNotTimeoutOnSuccessfulFuture() throws InterruptedException,
+            ExecutionException, TimeoutException {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        future.set(null);
+        future.get(0, TimeUnit.SECONDS);
+    }
+
+    @Test(timeout = 500L)
+    public void futureThrowsExecutionExceptionOnFailedFuture() throws InterruptedException,
+            TimeoutException {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        Throwable t = new Throwable();
+        future.setException(t);
+        try {
+            future.get(0, TimeUnit.SECONDS);
+        } catch (ExecutionException ex) {
+            assertSame(t, ex.getCause());
+        }
+    }
+
+    @Test(timeout = 500L)
+    public void futureGetsSuccessfulFuture() throws InterruptedException, ExecutionException {
+        LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        future.set(null);
+        future.get();
+    }
+
+    @Test(timeout = 500L)
+    public void futureWakesWaiterOnSuccess() throws Exception {
+        final LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                Thread.sleep(250);
+                future.set(null);
+                return null;
+            }
+        }.call();
+        future.get();
+    }
+
+    @Test(timeout = 500L)
+    public void futureWakesWaiterOnFailure() throws Exception {
+        final Throwable t = new Throwable();
+        final LDAwaitFuture<Void> future = new LDAwaitFuture<>();
+        new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                Thread.sleep(250);
+                future.setException(t);
+                return null;
+            }
+        }.call();
+        try {
+            future.get();
+        } catch (ExecutionException ex) {
+            assertSame(t, ex.getCause());
+        }
+    }
+
+    @Test(timeout = 500L)
+    public void futureReturnsSetValue() throws ExecutionException, InterruptedException {
+        Object testObject = new Object();
+        LDAwaitFuture<Object> future = new LDAwaitFuture<>();
+        future.set(testObject);
+        assertSame(testObject, future.get());
+    }
+}

launchdarkly-android-client-sdk/src/main/java/com/launchdarkly/android/LDAwaitFuture.java

@@ -15,7 +15,8 @@ class LDAwaitFuture<T> implements Future<T> {
     private volatile boolean completed = false;
     private final Object notifier = new Object();
 
-    LDAwaitFuture() {}
+    LDAwaitFuture() {
+    }
 
     synchronized void set(T result) {
         if (!completed) {
@@ -29,7 +30,7 @@ synchronized void set(T result) {
         }
     }
 
-    synchronized void setException(Throwable error) {
+    synchronized void setException(@NonNull Throwable error) {
         if (!completed) {
             this.error = error;
             synchronized (notifier) {
@@ -59,7 +60,7 @@ public boolean isDone() {
     @Override
     public T get() throws ExecutionException, InterruptedException {
         synchronized (notifier) {
-            if (!completed) {
+            while (!completed) {
                 notifier.wait();
             }
         }
@@ -70,11 +71,14 @@ public T get() throws ExecutionException, InterruptedException {
     }
 
     @Override
-    public T get(long timeout, @NonNull TimeUnit unit) throws ExecutionException, TimeoutException, InterruptedException {
+    public T get(long timeout, @NonNull TimeUnit unit) throws ExecutionException,
+            TimeoutException, InterruptedException {
+        long remaining = unit.toNanos(timeout);
+        long doneAt = remaining + System.nanoTime();
         synchronized (notifier) {
-            if (!completed) {
-                long millis = TimeUnit.MILLISECONDS.convert(timeout, unit);
-                notifier.wait(millis);
+            while (!completed & remaining > 0) {
+                TimeUnit.NANOSECONDS.timedWait(notifier, remaining);
+                remaining = doneAt - System.nanoTime();
             }
         }
         if (!completed) {