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(() -> {