You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2015/07/01 15:49:51 UTC

[3/3] incubator-tinkerpop git commit: More ResultQueue tests.

More ResultQueue tests.


Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/d648c597
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/d648c597
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/d648c597

Branch: refs/heads/master
Commit: d648c597514a0880f93f0017d90ee5dcaf619555
Parents: 7a84803
Author: Stephen Mallette <sp...@genoprime.com>
Authored: Wed Jul 1 09:49:34 2015 -0400
Committer: Stephen Mallette <sp...@genoprime.com>
Committed: Wed Jul 1 09:49:34 2015 -0400

----------------------------------------------------------------------
 .../tinkerpop/gremlin/driver/ResultQueue.java   | 24 +++---
 .../gremlin/driver/ResultQueueTest.java         | 77 ++++++++++++++++++++
 2 files changed, 88 insertions(+), 13 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/d648c597/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/ResultQueue.java
----------------------------------------------------------------------
diff --git a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/ResultQueue.java b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/ResultQueue.java
index 6d67405..6108d8e 100644
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/ResultQueue.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/ResultQueue.java
@@ -63,29 +63,23 @@ final class ResultQueue {
 
         final Pair<CompletableFuture<List<Result>>, Integer> nextWaiting = waiting.peek();
         if (nextWaiting != null && (resultLinkedBlockingQueue.size() >= nextWaiting.getValue1() || readComplete.isDone())) {
-            final List<Result> results = new ArrayList<>(nextWaiting.getValue1());
-            resultLinkedBlockingQueue.drainTo(results, nextWaiting.getValue1());
-            nextWaiting.getValue0().complete(results);
+            internalDrain(nextWaiting.getValue1(), nextWaiting.getValue0(), resultLinkedBlockingQueue);
             waiting.remove(nextWaiting);
         }
     }
 
     public CompletableFuture<List<Result>> await(final int items) {
         final CompletableFuture<List<Result>> result = new CompletableFuture<>();
-        if (size() > items || readComplete.isDone()) {
+        if (size() >= items || readComplete.isDone()) {
             // items are present so just drain to requested size if possible then complete it
-            final List<Result> results = new ArrayList<>(items);
-            resultLinkedBlockingQueue.drainTo(results, items);
-            result.complete(results);
+            internalDrain(items, result, resultLinkedBlockingQueue);
         } else {
             // not enough items in the result queue so save this for callback later when the results actually arrive.
             // only necessary to "wait" if we're not in the act of flushing already, in which case, no more waiting
             // for additional results should be allowed.
             if (flushed.get()) {
                 // just drain since we've flushed already
-                final List<Result> results = new ArrayList<>(items);
-                resultLinkedBlockingQueue.drainTo(results, items);
-                result.complete(results);
+                internalDrain(items, result, resultLinkedBlockingQueue);
             } else {
                 waiting.add(Pair.with(result, items));
             }
@@ -125,11 +119,15 @@ final class ResultQueue {
     private void flushWaiting() {
         while (waiting.peek() != null) {
             final Pair<CompletableFuture<List<Result>>, Integer> nextWaiting = waiting.poll();
-            final List<Result> results = new ArrayList<>(nextWaiting.getValue1());
-            resultLinkedBlockingQueue.drainTo(results, nextWaiting.getValue1());
-            nextWaiting.getValue0().complete(results);
+            internalDrain(nextWaiting.getValue1(), nextWaiting.getValue0(), resultLinkedBlockingQueue);
         }
 
         flushed.set(true);
     }
+
+    private static void internalDrain(int items, CompletableFuture<List<Result>> result, LinkedBlockingQueue<Result> resultLinkedBlockingQueue) {
+        final List<Result> results = new ArrayList<>(items);
+        resultLinkedBlockingQueue.drainTo(results, items);
+        result.complete(results);
+    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/d648c597/gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/ResultQueueTest.java
----------------------------------------------------------------------
diff --git a/gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/ResultQueueTest.java b/gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/ResultQueueTest.java
index 5e44864..ceb04ca 100644
--- a/gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/ResultQueueTest.java
+++ b/gremlin-driver/src/test/java/org/apache/tinkerpop/gremlin/driver/ResultQueueTest.java
@@ -24,10 +24,12 @@ import org.junit.Test;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -233,6 +235,81 @@ public class ResultQueueTest {
         assertThat(resultQueue.isEmpty(), is(true));
     }
 
+    @Test
+    public void shouldAwaitToExpectedValueAndDrainOnAwait() throws Exception {
+        resultQueue.add(new Result("test1"));
+        resultQueue.add(new Result("test2"));
+        resultQueue.add(new Result("test3"));
+
+        final CompletableFuture<List<Result>> future = resultQueue.await(3);
+        assertThat(future.isDone(), is(true));
+
+        final List<Result> results = future.get();
+        assertEquals("test1", results.get(0).getString());
+        assertEquals("test2", results.get(1).getString());
+        assertEquals("test3", results.get(2).getString());
+        assertEquals(3, results.size());
+
+        assertThat(resultQueue.isEmpty(), is(true));
+    }
+
+    @Test
+    public void shouldAwaitToReadCompletedAndDrainOnAwait() throws Exception {
+        resultQueue.add(new Result("test1"));
+        resultQueue.add(new Result("test2"));
+        resultQueue.add(new Result("test3"));
+
+        resultQueue.markComplete();
+
+        // you might want 30 but there are only three
+        final CompletableFuture<List<Result>> future = resultQueue.await(30);
+        assertThat(future.isDone(), is(true));
+
+        final List<Result> results = future.get();
+        assertEquals("test1", results.get(0).getString());
+        assertEquals("test2", results.get(1).getString());
+        assertEquals("test3", results.get(2).getString());
+        assertEquals(3, results.size());
+
+        assertThat(resultQueue.isEmpty(), is(true));
+    }
+
+    @Test
+    public void shouldDrainAsItemsArrive() throws Exception {
+        final Thread t = addToQueue(1000, 1, true);
+        try {
+            final AtomicInteger count1 = new AtomicInteger(0);
+            final AtomicInteger count2 = new AtomicInteger(0);
+            final AtomicInteger count3 = new AtomicInteger(0);
+            final CountDownLatch latch = new CountDownLatch(3);
+
+            resultQueue.await(500).thenAcceptAsync(r -> {
+                count1.set(r.size());
+                latch.countDown();
+            });
+
+            resultQueue.await(150).thenAcceptAsync(r -> {
+                count2.set(r.size());
+                latch.countDown();
+            });
+
+            resultQueue.await(350).thenAcceptAsync(r -> {
+                count3.set(r.size());
+                latch.countDown();
+            });
+
+            assertThat(latch.await(3000, TimeUnit.MILLISECONDS), is(true));
+
+            assertEquals(500, count1.get());
+            assertEquals(150, count2.get());
+            assertEquals(350, count3.get());
+
+            assertThat(resultQueue.isEmpty(), is(true));
+        } finally {
+            t.interrupt();
+        }
+    }
+
     private Thread addToQueue(final int numberOfItemsToAdd, final long pauseBetweenItemsInMillis,
                               final boolean start) throws Exception {
         final Thread t = new Thread(() -> {