/** * Equivalent to {@code map("map", f)}. * @see #map(String, Function2) */ default <R> Task<R> map(final Function2<T1, T2, R> f) { return map("map: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2())); }
@Test public void testNone() { Task<String> task = Task.par(Task.value("0"), Task.value("1")) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestSimpleBatchingStrategy.testNone", task); assertEquals(result, "01"); }
@Test public void testSingle() { Task<String> task = Task.par(Task.value("0"), _strategy.batchable(1)) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestSimpleBatchingStrategy.testSingle", task); assertEquals(result, "01"); }
@Test public void testNone() { Task<String> task = Task.par(Task.value("0"), Task.value("1")) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestTaskSimpleBatchingStrategy.testNone", task); assertEquals(result, "01"); }
@Test public void testTwo() { Task<String> task = Task.par(_strategy.batchable(0), _strategy.batchable(1)) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestSimpleBatchingStrategy.testTwo", task); assertEquals(result, "01"); }
@Test public void testSingle() { Task<String> task = Task.par(Task.value("0"), _strategy.batchable(1)) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestTaskSimpleBatchingStrategy.testSingle", task); assertEquals(result, "01"); }
@Test public void testTwo() { Task<String> task = Task.par(_strategy.batchable(0), _strategy.batchable(1)) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestTaskSimpleBatchingStrategy.testTwo", task); assertEquals(result, "01"); }
@Test public void testShareableWithPar() { final AtomicInteger counter = new AtomicInteger(); Task<String> task = Task.callable("increaser", () -> { counter.incrementAndGet(); return "hello"; } ); Task<String> test = Task.par(task.shareable().map(x -> x + "1"), task.shareable().map(x -> x + "2")).map((a, b) -> a + b); runAndWait("TestTaskReuse.testShareableWithPar", test); assertEquals(counter.get(), 1); assertEquals(test.get(), "hello1hello2"); }
@Test public void testClassifyFailure() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key / key); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1).recover(e -> "failed")) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestTaskBatchingStrategy.testClassifyFailure", task); assertEquals(result, "failed1"); assertEquals(strategy.getExecutedBatches().size(), 0); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testClassifyFailure() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<>((key, promise) -> promise.done(String.valueOf(key)), key -> key / key); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0).recover(e -> "failed"), strategy.batchable(1).recover(e -> "failed")) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestBatchingSupport.testClassifyFailure", task); assertEquals(result, "failed1"); assertEquals(strategy.getExecutedBatches().size(), 0); assertEquals(strategy.getExecutedSingletons().size(), 1); }
@Test public void testPar2() { Task<Integer> task = Task.par(Task.value(1), Task.value(2)).map((a, b) -> a + b); runAndWait("TestTaskFactoryMethods.testPar2", task); assertEquals((int)task.get(), 1 + 2); assertEquals(countTasks(task.getTrace()), 2 + 1 + 2); }
@Test public void testPar2Dsc() { Task<Integer> task = Task.par(Task.value(1), Task.value(2)).map("test", (a, b) -> a + b); runAndWait("TestTaskFactoryMethods.testPar2Dsc", task); assertEquals((int)task.get(), 1 + 2); assertEquals(countTasks(task.getTrace()), 2 + 1 + 2); }
@Test public void testLongRunningBatchTaskFailure() { Task<String> batchTask = _strategy.batchable(1); Task<String> failingTask = delayedFailure(new UnsupportedOperationException("not supported!"), 5, TimeUnit.MILLISECONDS); Task<String> finalTask = Task.par(batchTask, failingTask).map("concat", (s, t) -> s + t).recover("recover", throwable -> "hello"); runAndWaitForPlanToComplete("TestTaskSimpleBatchingStrategyBlocking.testLongRunningBatchTaskFailure", finalTask, 5, TimeUnit.SECONDS); verifyBatchFinished(finalTask); }
@Test public void testShareable() { Task<String> task = Task.par(_strategy.batchable(0).shareable(), _strategy.batchable(1).shareable()) .map("concat", (s0, s1) -> s0 + s1); String result = runAndWait("TestSimpleBatchingStrategy.testShareable", task); assertEquals(result, "01"); }
@Test public void testMapFork() { Task<Integer> base = Task.value("value", 1); Task<Integer> task = Task.par(base.map("m1", x -> x), base.map("m2", x -> x)) .map("sum", (x, y) -> x + y); runAndWait("FusionTaskTraceTest.testMapFork", task); }
@Test public void testLongRunningBatchTaskSuccess() { Task<String> batchTask = _strategy.batchable(1); Task<String> successTask = delayedValue("hello", 1, TimeUnit.MILLISECONDS); Task<String> finalTask = Task.par(batchTask, successTask).map("concat", (s, t) -> s + t); runAndWaitForPlanToComplete("TestTaskSimpleBatchingStrategyBlocking.testLongRunningBatchTaskSuccess", finalTask, 5, TimeUnit.SECONDS); verifyBatchFinished(finalTask); }
@Test public void testAsyncFork() { Task<Integer> base = Task.async("value", () -> { SettablePromise<Integer> p = Promises.settable(); p.done(1); return p; }); Task<Integer> task = Task.par(base.map("m1", x -> x), base.map("m2", x -> x)) .map("sum", (x, y) -> x + y); runAndWait("FusionTaskTraceTest.testAsyncFork", task); }
@Test public void testGetRequestsWithError() { Task<String> task = Task.par(toMessage(greetingGet(1L)), toMessage(greetingGet(-1L)).recover(e -> "failed")) .map("combine", (x, y) -> x + y); runAndWait(getTestClassName() + ".testGetRequestsWithError", task); assertEquals(task.get(), "Good morning!failed"); if (expectBatching()) { assertTrue(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } else { assertFalse(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } }
@Test public void testGetRequestsWithErrorOverrides() { Task<String> task = Task.par(toMessage(greetingGet(1L, overrides())), toMessage(greetingGet(-1L, overrides())).recover(e -> "failed")) .map("combine", (x, y) -> x + y); runAndWait(getTestClassName() + ".testGetRequestsWithErrorOverrides", task); assertEquals(task.get(), "Good morning!failed"); if (expectBatchingOverrides()) { assertTrue(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } else { assertFalse(hasTask("greetings batch_get(reqs: 2, ids: 2)", task.getTrace())); } }
private Task<int[]> mergeSort(final int[] toSort, final Range range) { if (range.size() == 0) { return Task.value("leaf", new int[0]); } else if (range.size() == 1) { return Task.value("leaf", new int[] { toSort[range.start()] }); } else { // Neither base case applied, so recursively split this problem into // smaller problems and then merge the results. return Task.value("ranges", Tuples.tuple(range.firstHalf(), range.secondHalf())) .flatMap("split", ranges -> Task.par(mergeSort(toSort, ranges._1()), mergeSort(toSort, ranges._2())) .map("merge", parts -> merge(ranges._1(), parts._1(), ranges._2(), parts._2()))); } }