remove SimpleWaiter class and use CountDownLatch in tests

Author: davidmoten

src/main/java/com/microsoft/graph/concurrency/SimpleWaiter.java

@@ -2,13 +2,15 @@
 
 import static org.junit.Assert.*;
 
-import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import com.microsoft.graph.core.ClientException;
 import com.microsoft.graph.logger.MockLogger;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
@@ -46,7 +48,7 @@ public void run() {
             }
         });
 
-        callback._completionWaiter.waitForSignal();
+        callback.waitForCompletion();;
         assertTrue(callback._successCalled.get());
         assertEquals(expectedResult, callback._successResult.get());
         assertEquals(1,mLogger.getLogMessages().size());
@@ -61,7 +63,7 @@ public void testPerformOnForegroundWithResult() {
 
         defaultExecutors.performOnForeground(expectedResult,callback);
 
-        callback._completionWaiter.waitForSignal();
+        callback.waitForCompletion();
         assertTrue(callback._successCalled.get());
         assertFalse(callback._failureCalled.get());
         assertEquals(expectedResult, callback._successResult.get());
@@ -78,7 +80,7 @@ public void testPerformOnForegroundWithProgress() throws Exception {
 
         defaultExecutors.performOnForeground(expectedCurrentValue, expectedMaxValue, callback);
 
-        callback._completionWaiter.waitForSignal();
+        callback.waitForCompletion();;
         assertFalse(callback._successCalled.get());
         assertFalse(callback._failureCalled.get());
         assertTrue(callback._progressCalled.get());
@@ -97,7 +99,7 @@ public void testPerformOnForegroundWithClientException() {
         defaultExecutors.performOnForeground(new ClientException(expectedExceptionMessage,null),
                 callback);
 
-        callback._completionWaiter.waitForSignal();
+        callback.waitForCompletion();
         assertFalse(callback._successCalled.get());
         assertTrue(callback._failureCalled.get());
         assertEquals(expectedExceptionMessage, callback._exceptionResult.get().getMessage());
@@ -106,7 +108,7 @@ public void testPerformOnForegroundWithClientException() {
     }
 
 	private class ExecutorTestCallback<T> implements IProgressCallback<T> {
-        SimpleWaiter _completionWaiter = new SimpleWaiter();
+        CountDownLatch latch = new CountDownLatch(1);
 
         AtomicBoolean _successCalled = new AtomicBoolean(false);
         AtomicReference<T> _successResult = new AtomicReference<>();
@@ -122,22 +124,31 @@ private class ExecutorTestCallback<T> implements IProgressCallback<T> {
         public void success(final T result) {
             _successCalled.set(true);
             _successResult.set(result);
-            _completionWaiter.signal();
+            latch.countDown();
         }
 
         @Override
         public void failure(final ClientException ex) {
             _failureCalled.set(true);
             _exceptionResult.set(ex);
-            _completionWaiter.signal();
+            latch.countDown();
         }
 
         @Override
         public void progress(final long current, final long max) {
             _progressCalled.set(true);
             _progressResultCurrent.set(current);
             _progressResultMax.set(max);
-            _completionWaiter.signal();
+            latch.countDown();
+        }
+        
+        void waitForCompletion() {
+            try {
+                // use a big enough wait to handle a big gc
+                Assert.assertTrue(latch.await(20, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
         }
     }
 }

src/test/java/com/microsoft/graph/concurrency/DefaultExecutorsTests.java

@@ -1,28 +1,30 @@
 package com.microsoft.graph.concurrency;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import org.junit.*;
+import org.junit.Test;
 
 public class SynchronousExecutorTests {
 
-	@Ignore
 	@Test
 	public void testExecute() throws Exception {
         final AtomicBoolean success = new AtomicBoolean(false);
-        final SimpleWaiter simpleWaiter = new SimpleWaiter();
+        final CountDownLatch latch = new CountDownLatch(1);
         SynchronousExecutor synchronousExecutor = new SynchronousExecutor();
         synchronousExecutor.execute(new Runnable() {
             @Override
             public void run() {
                 success.set(true);
-                simpleWaiter.signal();
+                latch.countDown();
             }
         });
-        simpleWaiter.waitForSignal();
-        Thread.sleep(2000);
+        // use a big enough wait to handle a big gc
+        assertTrue(latch.await(20, TimeUnit.SECONDS));
         assertTrue(success.get());
         assertEquals(0, synchronousExecutor.getActiveCount());
     }