Task<Map<Long, Try<String>>> batchGet(Collection<Long> keys) { return Task.callable("batchGet", () -> keys.stream().collect(Collectors.toMap(Function.identity(), key -> Success.of(Long.toString(key))))); } }
/** * Equivalent to {@code callable("callable", callable)}. * @see #callable(String, Callable) */ public static <T> Task<T> callable(final Callable<? extends T> callable) { return callable("callable: " + _taskDescriptor.getDescription(callable.getClass().getName()), callable); }
@Override public Task<Map<K, Try<T>>> taskForBatch(final G group, final Set<K> keys) { return Task.callable("taskForBatch", () -> { if (keys.size() == 1) { _singletons.add(keys); } else { _batches.add(keys); } return keys.stream().collect(Collectors.toMap(Function.identity(), _completer)); }); }
@Override public Task<Map<Integer, Try<String>>> taskForBatch(Set<Integer> keys) { return Task.callable("taskForBatch", () -> { return keys.stream().collect(Collectors.toMap(Function.identity(), key -> Success.of(Integer.toString(key)))); }); } }
@Test public void testExecuteMultipleTimes() { final AtomicInteger counter = new AtomicInteger(); Task<String> task = Task.callable(() -> { counter.incrementAndGet(); return "hello"; } ); runAndWait("TestTaskReuse.testExecuteMultipleTimes-1", task); runAndWait("TestTaskReuse.testExecuteMultipleTimes-2", task); runAndWait("TestTaskReuse.testExecuteMultipleTimes-3", task); assertEquals(counter.get(), 1); }
@Test public void testCallable() { Task<UUID> task = Task.callable(UUID::randomUUID); runAndWait("TestTaskFactoryMethods.testCallable", task); assertNotNull(task.get()); assertEquals(countTasks(task.getTrace()), 1); }
@Test public void testFlattenFailure() { Task<Task<String>> nested = Task.callable(() -> getFailureTask()); Task<String> flat = Task.flatten(nested); try { runAndWait("AbstractTaskTest.testFlattenFailure", flat); fail("should have failed"); } catch (Exception ex) { assertTrue(flat.isFailed()); } assertEquals(flat.getError().getMessage(), TASK_ERROR_MESSAGE); }
public void testFlatMap(int expectedNumberOfTasks) { Task<String> task = getSuccessTask().flatMap(str -> Task.callable("strlenstr", () -> String.valueOf(str.length()))); runAndWait("AbstractTaskTest.testFlatMap", task); assertEquals(task.get(), String.valueOf(TASK_VALUE.length())); assertEquals(countTasks(task.getTrace()), expectedNumberOfTasks); }
@Test public void testFlatten() { Task<Task<String>> nested = Task.callable(() -> getSuccessTask()); Task<String> flat = Task.flatten(nested); runAndWait("AbstractTaskTest.testFlatten", flat); assertEquals(flat.get(), TASK_VALUE); }
@Test public void testRunWithSyncError() throws InterruptedException { final Exception exception = new Exception(); final Task<String> task = Task.callable("task", () -> { throw exception; } ); runTask(task); assertTrue(task.await(5, TimeUnit.SECONDS)); assertFailed(task, exception); }
@Test public void testAsyncWithContext() { final Task<String> t = Task.callable(() -> "done"); Task<String> task = Task.async(ctx -> { ctx.run(t); return t; }); String value = runAndWait("TestTaskFactoryMethods.testAsyncWithContext", task); assertEquals(value, "done"); assertEquals(countTasks(task.getTrace()), 2); }
@Test public void testRun() throws InterruptedException { final String result = "result"; final Task<String> task = Task.callable("task", () -> result); runTask(task); assertTrue(task.await(5, TimeUnit.SECONDS)); assertDone(task, result); }
public void testRecoverWithSuccess(int expectedNumberOfTasks) { Task<String> success = getSuccessTask().recoverWith(e -> Task.callable("recover failure", () -> { throw new RuntimeException("recover failed!"); } )); runAndWait("AbstractTaskTest.testRecoverWithSuccess", success); assertEquals(success.get(), TASK_VALUE); assertEquals(countTasks(success.getTrace()), expectedNumberOfTasks); }
@Test public void testHappyPath() throws InterruptedException { final Task<Try<String>> task = Task.callable("test", () -> "hello").toTry(); runAndWait("TestWithTry.testHappyPath", task); assertFalse(task.get().isFailed()); assertEquals("hello", task.get().get()); }
public void testRecoverWithCancelled(int expectedNumberOfTasks) { Task<String> cancelled = getCancelledTask().recoverWith(e -> Task.callable("recover success", () -> "recovered")); try { runAndWait("AbstractTaskTest.testRecoverWithCancelled", cancelled); fail("should have failed"); } catch (Exception ex) { assertTrue(cancelled.isFailed()); assertTrue(Exceptions.isCancellation(cancelled.getError())); } assertEquals(countTasks(cancelled.getTrace()), expectedNumberOfTasks); }
public void testRecoverWithRecoverd(int expectedNumberOfTasks) { Task<String> recovered = getFailureTask().recoverWith(e -> Task.callable("recover success", () -> "recovered")); runAndWait("AbstractTaskTest.testRecoverWithRecoverd", recovered); assertEquals(recovered.get(), "recovered"); assertEquals(countTasks(recovered.getTrace()), expectedNumberOfTasks); }
@Test public void testFlatMapTaskType() { Task<String> task = Task.value("Welcome"); Task<String> flatMap = task.flatMap("+earth", s -> Task.callable(() -> s + " on earth!")); runAndWait("flatMapTaskType", flatMap); assertEquals(flatMap.getShallowTrace().getTaskType(), TaskType.FLATTEN.getName()); }
public void testAndThenTask(int expectedNumberOfTasks) { Task<Integer> task = getSuccessTask().andThen(Task.callable("life", () -> 42)); runAndWait("AbstractTaskTest.testAndThenTask", task); assertEquals((int) task.get(), 42); assertEquals(countTasks(task.getTrace()), expectedNumberOfTasks); }
@Test public void testCancelAfterDone() throws InterruptedException { final String result = "result"; final Task<String> task = Task.callable("task", () -> result); runTask(task); assertTrue(task.await(5, TimeUnit.SECONDS)); assertDone(task, result); assertFalse(task.cancel(new Exception())); assertDone(task, result); }
@Test public void testSetPriorityAfterRun() throws InterruptedException { final String result = "result"; final Task<String> task = Task.callable("task", () -> result); runTask(task); assertTrue(task.await(5, TimeUnit.SECONDS)); assertFalse(task.setPriority(5)); assertEquals(0, task.getPriority()); assertDone(task, result); }