Refine search
private static void assertFutureFailsWithMockFailure(ListenableFuture<?> future) { assertTrue(future.isDone()); try { future.get(); fail(); } catch (Exception e) { assertContains(e.getMessage(), "Mock failure"); } }
private static void assertSinkCanWrite(LocalExchangeSink sink) { assertFalse(sink.isFinished()); assertTrue(sink.waitForWriting().isDone()); }
private static ListenableFuture<?> assertSinkWriteBlocked(LocalExchangeSink sink) { assertFalse(sink.isFinished()); ListenableFuture<?> writeFuture = sink.waitForWriting(); assertFalse(writeFuture.isDone()); return writeFuture; }
@Test(timeOut = 10_000) public void testOfferAfterFinish() throws Exception { AsyncQueue<String> queue = new AsyncQueue<>(4, executor); assertTrue(queue.offer("1").isDone()); assertTrue(queue.offer("2").isDone()); assertTrue(queue.offer("3").isDone()); assertFalse(queue.offer("4").isDone()); queue.finish(); assertTrue(queue.offer("5").isDone()); assertTrue(queue.offer("6").isDone()); assertTrue(queue.offer("7").isDone()); assertFalse(queue.isFinished()); assertEquals(queue.getBatchAsync(100).get(), ImmutableList.of("1", "2", "3", "4")); assertTrue(queue.isFinished()); }
@Test(expectedExceptions = IllegalStateException.class) public void addInputFailsOnBlockedOperator() { Operator operator = createTableWriterOperator(new BlockingPageSink()); operator.addInput(rowPagesBuilder(BIGINT).row(42).build().get(0)); assertFalse(operator.isBlocked().isDone()); assertFalse(operator.needsInput()); operator.addInput(rowPagesBuilder(BIGINT).row(42).build().get(0)); }
@Test public void testBadRequest() throws Exception { ScheduledRequestHandler handler = new ScheduledRequestHandler(queryScheduler, serverMetrics); String requestBadString = "foobar"; byte[] requestData = requestBadString.getBytes(); ByteBuf buffer = Unpooled.wrappedBuffer(requestData); ListenableFuture<byte[]> response = handler.processRequest(channelHandlerContext, buffer); // The handler method is expected to return immediately Assert.assertTrue(response.isDone()); byte[] responseBytes = response.get(); Assert.assertNull(responseBytes); }
@Test(timeOut = 10_000) public void testEmptyQueue() throws Exception { AsyncQueue<String> queue = new AsyncQueue<>(4, executor); assertTrue(queue.offer("1").isDone()); assertTrue(queue.offer("2").isDone()); assertTrue(queue.offer("3").isDone()); assertEquals(queue.getBatchAsync(2).get(), ImmutableList.of("1", "2")); assertEquals(queue.getBatchAsync(2).get(), ImmutableList.of("3")); ListenableFuture<?> batchFuture = queue.getBatchAsync(2); assertFalse(batchFuture.isDone()); assertTrue(queue.offer("4").isDone()); assertEquals(batchFuture.get(), ImmutableList.of("4")); batchFuture = queue.getBatchAsync(2); assertFalse(batchFuture.isDone()); queue.finish(); batchFuture.get(); assertTrue(queue.isFinished()); }
@Test public void testFailDoesNotFreeReader() { BroadcastOutputBuffer buffer = createBroadcastBuffer( createInitialEmptyOutputBuffers(BROADCAST) .withBuffer(FIRST, BROADCAST_PARTITION_ID) .withNoMoreBufferIds(), sizeOfPages(5)); assertFalse(buffer.isFinished()); // attempt to get a page ListenableFuture<BufferResult> future = buffer.get(FIRST, 0, sizeOfPages(10)); // verify we are waiting for a page assertFalse(future.isDone()); // add one page addPage(buffer, createPage(0)); // verify we got one page assertBufferResultEquals(TYPES, getFuture(future, NO_WAIT), bufferResult(0, createPage(0))); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); // fail the buffer buffer.fail(); // future should have not finished assertFalse(future.isDone()); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); }
@Test public void testMemoryFutureCancellation() { setUpCountStarFromOrdersWithJoin(); ListenableFuture future = userPool.reserve(fakeQueryId, "test", TEN_MEGABYTES.toBytes()); assertTrue(!future.isDone()); try { future.cancel(true); fail("cancel should fail"); } catch (UnsupportedOperationException e) { assertEquals(e.getMessage(), "cancellation is not supported"); } userPool.free(fakeQueryId, "test", TEN_MEGABYTES.toBytes()); assertTrue(future.isDone()); }
@AfterMethod public void tearDown(Method method) { assertTrue(Futures.allAsList(futures).isDone(), "Expression test futures are not complete"); log.info("FINISHED %s in %s verified %s expressions", method.getName(), Duration.nanosSince(start), futures.size()); }
private void assertDriversProgress(Predicate<OperatorContext> reason) { do { assertFalse(isOperatorBlocked(drivers, reason)); boolean progress = false; for (Driver driver : drivers) { ListenableFuture<?> blocked = driver.process(); progress = progress | blocked.isDone(); } // query should not block assertTrue(progress); } while (!drivers.stream().allMatch(Driver::isFinished)); }
private static ListenableFuture<?> enqueuePage(OutputBuffer buffer, Page page) { buffer.enqueue(ImmutableList.of(PAGES_SERDE.serialize(page))); ListenableFuture<?> future = buffer.isFull(); assertFalse(future.isDone()); return future; }
@Test(timeOut = 10_000) public void testFullQueue() throws Exception { AsyncQueue<String> queue = new AsyncQueue<>(4, executor); assertTrue(queue.offer("1").isDone()); assertTrue(queue.offer("2").isDone()); assertTrue(queue.offer("3").isDone()); assertFalse(queue.offer("4").isDone()); assertFalse(queue.offer("5").isDone()); ListenableFuture<?> offerFuture = queue.offer("6"); assertFalse(offerFuture.isDone()); assertEquals(queue.getBatchAsync(2).get(), ImmutableList.of("1", "2")); assertFalse(offerFuture.isDone()); assertEquals(queue.getBatchAsync(1).get(), ImmutableList.of("3")); offerFuture.get(); offerFuture = queue.offer("7"); assertFalse(offerFuture.isDone()); queue.finish(); offerFuture.get(); assertFalse(queue.isFinished()); assertEquals(queue.getBatchAsync(4).get(), ImmutableList.of("4", "5", "6", "7")); assertTrue(queue.isFinished()); }
@Test public void testFailDoesNotFreeReader() { PartitionedOutputBuffer buffer = createPartitionedBuffer( createInitialEmptyOutputBuffers(PARTITIONED) .withBuffer(FIRST, 0) .withNoMoreBufferIds(), sizeOfPages(5)); assertFalse(buffer.isFinished()); // attempt to get a page ListenableFuture<BufferResult> future = buffer.get(FIRST, 0, sizeOfPages(10)); // verify we are waiting for a page assertFalse(future.isDone()); // add one page addPage(buffer, createPage(0)); // verify we got one page assertBufferResultEquals(TYPES, getFuture(future, NO_WAIT), bufferResult(0, createPage(0))); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); // fail the buffer buffer.fail(); // future should have not finished assertFalse(future.isDone()); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); }
@Test public void testMultipleNodes() { FixedCountScheduler nodeScheduler = new FixedCountScheduler( (node, partition, totalPartitions) -> Optional.of(taskFactory.createTableScanTask( new TaskId("test", 1, 1), node, ImmutableList.of(), new PartitionedSplitCountTracker(delta -> {}))), generateRandomNodes(5)); ScheduleResult result = nodeScheduler.schedule(); assertTrue(result.isFinished()); assertTrue(result.getBlocked().isDone()); assertEquals(result.getNewTasks().size(), 5); assertEquals(result.getNewTasks().stream().map(RemoteTask::getNodeId).collect(toImmutableSet()).size(), 5); }
private static void assertEffectivelyFinished(ScheduleResult scheduleResult, StageScheduler scheduler) { if (scheduleResult.isFinished()) { assertTrue(scheduleResult.getBlocked().isDone()); return; } assertTrue(scheduleResult.getBlocked().isDone()); ScheduleResult nextScheduleResult = scheduler.schedule(); assertTrue(nextScheduleResult.isFinished()); assertTrue(nextScheduleResult.getBlocked().isDone()); assertEquals(nextScheduleResult.getNewTasks().size(), 0); assertEquals(nextScheduleResult.getSplitsScheduled(), 0); }
private static void assertSource(LocalExchangeSource source, int pageCount) { LocalExchangeBufferInfo bufferInfo = source.getBufferInfo(); assertEquals(bufferInfo.getBufferedPages(), pageCount); assertFalse(source.isFinished()); if (pageCount == 0) { assertFalse(source.waitForReading().isDone()); assertNull(source.removePage()); assertFalse(source.waitForReading().isDone()); assertFalse(source.isFinished()); assertEquals(bufferInfo.getBufferedBytes(), 0); } else { assertTrue(source.waitForReading().isDone()); assertTrue(bufferInfo.getBufferedBytes() > 0); } }
static ListenableFuture<?> enqueuePage(OutputBuffer buffer, Page page) { buffer.enqueue(ImmutableList.of(PAGES_SERDE.serialize(page))); ListenableFuture<?> future = buffer.isFull(); assertFalse(future.isDone()); return future; }
@Test public void testNoMorePagesFreesReader() { ArbitraryOutputBuffer buffer = createArbitraryBuffer(createInitialEmptyOutputBuffers(ARBITRARY), sizeOfPages(10)); buffer.setOutputBuffers(createInitialEmptyOutputBuffers(ARBITRARY).withBuffer(FIRST, 0)); assertFalse(buffer.isFinished()); ListenableFuture<BufferResult> future = buffer.get(FIRST, 0, sizeOfPages(10)); assertFalse(future.isDone()); buffer.setNoMorePages(); assertTrue(future.isDone()); assertTrue(buffer.get(FIRST, 0, sizeOfPages(10)).isDone()); }
@Test public void testFailDoesNotFreeReader() { ArbitraryOutputBuffer buffer = createArbitraryBuffer( createInitialEmptyOutputBuffers(ARBITRARY) .withBuffer(FIRST, BROADCAST_PARTITION_ID) .withNoMoreBufferIds(), sizeOfPages(5)); assertFalse(buffer.isFinished()); // attempt to get a page ListenableFuture<BufferResult> future = buffer.get(FIRST, 0, sizeOfPages(10)); // verify we are waiting for a page assertFalse(future.isDone()); // add one page addPage(buffer, createPage(0)); // verify we got one page assertBufferResultEquals(TYPES, getFuture(future, NO_WAIT), bufferResult(0, createPage(0))); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); // fail the buffer buffer.fail(); // future should have not finished assertFalse(future.isDone()); // attempt to get another page, and verify we are blocked future = buffer.get(FIRST, 1, sizeOfPages(10)); assertFalse(future.isDone()); }