FutureTest.java

package io.trane.future;

import static java.util.stream.Collectors.toList;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;

import org.junit.After;
import org.junit.Test;

public class FutureTest {

  private <T> T get(Future<T> future) throws CheckedFutureException {
    return future.get(Duration.ofMillis(1));
  }

  private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  private final Exception ex = new TestException();

  @After
  public void shutdownScheduler() {
    scheduler.shutdown();
  }

  /*** true ***/

  @Test
  public void trueConst() throws CheckedFutureException {
    assertEquals(true, get(Future.TRUE));
  }

  /*** false ***/

  @Test
  public void falseConst() throws CheckedFutureException {
    assertEquals(false, get(Future.FALSE));
  }

  /*** never ***/

  @Test
  public void never() {
    assertTrue(Future.never() instanceof NoFuture);
  }

  /*** apply ***/

  @Test
  public void applyValue() throws CheckedFutureException {
    Integer value = 1;
    Future<Integer> future = Future.apply(() -> value);
    assertEquals(value, get(future));
  }

  @Test(expected = ArithmeticException.class)
  public void applyException() throws CheckedFutureException {
    Future<Integer> future = Future.apply(() -> 1 / 0);
    get(future);
  }

  /*** flatApply ***/

  @Test
  public void flatApplyValue() throws CheckedFutureException {
    Integer value = 1;
    Future<Integer> future = Future.flatApply(() -> Future.value(value));
    assertEquals(value, get(future));
  }

  @Test(expected = ArithmeticException.class)
  public void flatApplyException() throws CheckedFutureException {
    Future<Integer> future = Future.flatApply(() -> Future.value(1 / 0));
    get(future);
  }

  /*** value ***/

  @Test
  public void value() throws CheckedFutureException {
    Integer value = 1;
    Future<Integer> future = Future.value(value);
    assertEquals(value, get(future));
  }

  /*** exception ***/

  @Test(expected = TestException.class)
  public void exception() throws CheckedFutureException {

    Future<Integer> future = Future.exception(ex);
    get(future);
  }

  /*** flatten ***/

  @Test
  public void flatten() throws CheckedFutureException {
    Future<Future<Integer>> future = Future.value(Future.value(1));
    assertEquals(get(Future.flatten(future)), get(future.flatMap(f -> f)));
  }

  /*** tailrec ***/

  Future<Integer> tailrecLoop(Future<Integer> f) {
    return Tailrec.apply(() -> {
      return f.flatMap(i -> {
        if (i == 0)
          return Future.value(0);
        else
          return tailrecLoop(Future.value(i - 1));
      });
    });
  }

  @Test
  public void tailrec() throws CheckedFutureException {
    assertEquals(new Integer(0), get(tailrecLoop(Future.value(20000))));
  }

  Future<Integer> tailrecLoopDelayed(Future<Integer> f) {
    return Tailrec.apply(() -> {
      return f.flatMap(i -> {
        if (i == 0)
          return Future.value(0);
        else
          return tailrecLoopDelayed(Future.value(i - 1).delayed(Duration.ofNanos(1), scheduler));
      });
    });
  }

  @Test
  public void tailrecDelayed() throws CheckedFutureException {
    assertEquals(new Integer(0), tailrecLoopDelayed(Future.value(20000)).get(Duration.ofSeconds(10)));
  }

  Future<Integer> nonTailrecLoop(Future<Integer> f) {
    return f.flatMap(i -> {
      if (i == 0)
        return Future.value(0);
      else
        return nonTailrecLoop(Future.value(i - 1));
    });
  }

  @Test(expected = StackOverflowError.class)
  public void nonTailrec() throws CheckedFutureException {
    assertEquals(new Integer(0), get(nonTailrecLoop(Future.value(20000))));
  }

  Future<Integer> nonTailrecLoopDelayed(Future<Integer> f) {
    return f.flatMap(i -> {
      if (i == 0)
        return Future.value(0);
      else
        return nonTailrecLoop(Future.value(i - 1).delayed(Duration.ofNanos(1), scheduler));
    });
  }

  @Test(expected = StackOverflowError.class)
  public void nonTailrecDelayed() throws CheckedFutureException {
    assertEquals(new Integer(0), get(nonTailrecLoop(Future.value(20000))));
  }

  /*** emptyList ***/

  @Test
  public void emptyList() throws CheckedFutureException {
    Future<List<String>> future = Future.emptyList();
    assertTrue(get(future).isEmpty());
  }

  @Test(expected = UnsupportedOperationException.class)
  public void emptyListIsUnmodifiable() throws CheckedFutureException {
    Future<List<String>> future = Future.emptyList();
    get(future).add("s");
  }

  /*** emptyOptional ***/

  @Test
  public void emptyOptional() throws CheckedFutureException {
    Future<Optional<String>> future = Future.emptyOptional();
    assertFalse(get(future).isPresent());
  }

  /*** collect ***/

  @Test
  public void collectEmpty() {
    Future<List<String>> future = Future.collect(new ArrayList<>());
    assertEquals(Future.emptyList(), future);
  }

  @Test
  public void collectOne() throws CheckedFutureException {
    Future<List<Integer>> future = Future.collect(Arrays.asList(Future.value(1)));
    Integer[] expected = { 1 };
    assertArrayEquals(expected, get(future).toArray());
  }

  @Test
  public void collectTwo() throws CheckedFutureException {
    Future<List<Integer>> future = Future.collect(Arrays.asList(Future.value(1), Future.value(2)));
    Integer[] expected = { 1, 2 };
    assertArrayEquals(expected, get(future).toArray());
  }

  @Test
  public void collectSatisfiedFutures() throws CheckedFutureException {
    Future<List<Integer>> future = Future.collect(Arrays.asList(Future.value(1), Future.value(2), Future.value(3)));
    Integer[] expected = { 1, 2, 3 };
    assertArrayEquals(expected, get(future).toArray());
  }

  @Test(expected = TestException.class)
  public void collectSatisfiedFuturesException() throws CheckedFutureException {
    Future<List<Integer>> future = Future
        .collect(Arrays.asList(Future.value(1), Future.exception(ex), Future.value(3)));
    get(future);
  }

  @Test
  public void collectPromises() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Promise<Integer> p3 = Promise.apply();
    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, p3));
    p1.setValue(1);
    p2.setValue(2);
    p3.setValue(3);
    Integer[] expected = { 1, 2, 3 };
    Object[] result = get(future).toArray();
    assertArrayEquals(expected, result);
  }

  @Test(expected = TestException.class)
  public void collectPromisesException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Promise<Integer> p3 = Promise.apply();
    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, p3));
    p1.setValue(1);
    p2.setException(ex);
    p3.setValue(3);
    get(future);
  }

  @Test
  public void collectMixed() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setValue(2);
    Integer[] expected = { 1, 2, 3 };
    assertArrayEquals(expected, get(future).toArray());
  }

  @Test(expected = TestException.class)
  public void collectMixedException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setException(ex);
    Integer[] expected = { 1, 2, 3 };
    assertArrayEquals(expected, get(future).toArray());
  }

  @Test
  public void collectConcurrentResults() throws CheckedFutureException {
    ExecutorService ex = Executors.newFixedThreadPool(10);
    try {
      List<Promise<Integer>> promises = Stream.generate(() -> Promise.<Integer>apply()).limit(20000).collect(toList());
      AtomicBoolean start = new AtomicBoolean();
      Future<List<Integer>> future = Future.collect(promises);
      for (Promise<Integer> p : promises) {
        ex.submit(() -> {
          while (true) {
            if (start.get())
              break;
          }
          p.setValue(p.hashCode());
        });
      }
      start.set(true);
      List<Integer> expected = promises.stream().map(p -> p.hashCode()).collect(toList());
      List<Integer> result = future.get(Duration.ofSeconds(1));
      assertArrayEquals(expected.toArray(), result.toArray());
    } finally {
      ex.shutdown();
    }
  }

  @Test
  public void collectInterrupts() {
    AtomicReference<Throwable> p1Intr = new AtomicReference<>();
    AtomicReference<Throwable> p2Intr = new AtomicReference<>();
    AtomicReference<Throwable> p3Intr = new AtomicReference<>();
    Promise<Integer> p1 = Promise.apply(p1Intr::set);
    Promise<Integer> p2 = Promise.apply(p2Intr::set);
    Promise<Integer> p3 = Promise.apply(p3Intr::set);

    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, p3));

    future.raise(ex);

    assertEquals(ex, p1Intr.get());
    assertEquals(ex, p2Intr.get());
    assertEquals(ex, p3Intr.get());
  }

  @Test(expected = TimeoutException.class)
  public void collectTimeout() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<List<Integer>> future = Future.collect(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    future.get(Duration.ofMillis(10));
  }

  /*** join ***/

  @Test
  public void joinEmpty() {
    Future<Void> future = Future.join(new ArrayList<>());
    assertEquals(Future.VOID, future);
  }

  @Test
  public void joinOne() throws CheckedFutureException {
    Future<Integer> f = Future.value(1);
    assertEquals(f.voided(), Future.join(Arrays.asList(f)));
  }

  @Test
  public void joinSatisfiedFutures() throws CheckedFutureException {
    Future<Void> future = Future.join(Arrays.asList(Future.value(1), Future.value(2)));
    get(future);
  }

  @Test(expected = TestException.class)
  public void joinSatisfiedFuturesException() throws CheckedFutureException {
    Future<Void> future = Future.join(Arrays.asList(Future.value(1), Future.exception(ex)));
    get(future);
  }

  @Test
  public void joinPromises() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Void> future = Future.join(Arrays.asList(p1, p2));
    p1.setValue(1);
    p2.setValue(2);
    get(future);
  }

  @Test(expected = TestException.class)
  public void joinPromisesException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Void> future = Future.join(Arrays.asList(p1, p2));
    p1.setValue(1);
    p2.setException(ex);
    get(future);
  }

  @Test
  public void joinMixed() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Void> future = Future.join(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setValue(2);
    get(future);
  }

  @Test(expected = TestException.class)
  public void joinMixedException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Void> future = Future.join(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setException(ex);
    get(future);
  }

  @Test
  public void joinConcurrentResults() throws CheckedFutureException {
    List<Promise<Integer>> promises = Stream.generate(() -> Promise.<Integer>apply()).limit(20000).collect(toList());
    ExecutorService ex = Executors.newFixedThreadPool(10);
    try {
      Future<Void> future = Future.join(promises);
      for (Promise<Integer> p : promises) {
        ex.submit(() -> {
          p.setValue(p.hashCode());
        });
      }
      future.get(Duration.ofSeconds(1));
    } finally {
      ex.shutdown();
    }
  }

  @Test
  public void joinInterrupts() {
    AtomicReference<Throwable> p1Intr = new AtomicReference<>();
    AtomicReference<Throwable> p2Intr = new AtomicReference<>();
    Promise<Integer> p1 = Promise.apply(p1Intr::set);
    Promise<Integer> p2 = Promise.apply(p2Intr::set);

    Future<Void> future = Future.join(Arrays.asList(p1, p2));

    future.raise(ex);

    assertEquals(ex, p1Intr.get());
    assertEquals(ex, p2Intr.get());
  }

  @Test(expected = TimeoutException.class)
  public void joinTimeout() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Void> future = Future.join(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    future.get(Duration.ofMillis(10));
  }

  /*** selectIndex **/

  @Test(expected = IllegalArgumentException.class)
  public void selectIndexEmpty() throws CheckedFutureException {
    get(Future.selectIndex(new ArrayList<>()));
  }

  @Test
  public void selectIndexOne() throws CheckedFutureException {
    Future<Integer> f = Future.selectIndex(Arrays.asList(Future.value(1)));
    assertEquals(new Integer(0), get(f));
  }

  @Test
  public void selectIndexSatisfiedFutures() throws CheckedFutureException {
    Future<Integer> future = Future.selectIndex(Arrays.asList(Future.value(1), Future.value(2)));
    assertEquals(new Integer(0), get(future));
  }

  @Test
  public void selectIndexPromises() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2));
    p2.setValue(2);
    assertEquals(new Integer(1), get(future));
  }

  @Test
  public void selectIndexPromisesException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2));
    p1.setException(new Throwable());
    assertEquals(new Integer(0), get(future));
  }

  @Test
  public void selectIndexMixed() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setValue(2);
    assertEquals(new Integer(2), get(future));
  }

  @Test
  public void selectIndexMixedException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setException(new Throwable());
    assertEquals(new Integer(2), get(future));
  }

  @Test
  public void selectIndexInterrupts() {
    AtomicReference<Throwable> p1Intr = new AtomicReference<>();
    AtomicReference<Throwable> p2Intr = new AtomicReference<>();
    Promise<Integer> p1 = Promise.apply(p1Intr::set);
    Promise<Integer> p2 = Promise.apply(p2Intr::set);

    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2));

    future.raise(ex);

    assertEquals(ex, p1Intr.get());
    assertEquals(ex, p2Intr.get());
  }

  @Test(expected = TimeoutException.class)
  public void selectIndexTimeout() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.selectIndex(Arrays.asList(p1, p2));
    future.get(Duration.ofMillis(100));
  }

  /*** firstCompletedOf **/

  @Test(expected = IllegalArgumentException.class)
  public void firstCompletedOfEmpty() throws CheckedFutureException {
    get(Future.firstCompletedOf(new ArrayList<>()));
  }

  @Test
  public void firstCompletedOfOne() throws CheckedFutureException {
    Future<Integer> f = Future.firstCompletedOf(Arrays.asList(Future.value(1)));
    assertEquals(new Integer(1), get(f));
  }

  @Test
  public void firstCompletedOfSatisfiedFutures() throws CheckedFutureException {
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(Future.value(1), Future.value(2)));
    assertEquals(new Integer(1), get(future));
  }

  @Test
  public void firstCompletedOfPromises() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2));
    p2.setValue(2);
    assertEquals(new Integer(2), get(future));
  }

  @Test(expected = TestException.class)
  public void firstCompletedOfPromisesException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2));
    p1.setException(new TestException());
    get(future);
  }

  @Test
  public void firstCompletedOfMixed() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setValue(2);
    assertEquals(new Integer(3), get(future));
  }

  @Test
  public void firstCompletedOfMixedException() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2, Future.value(3)));
    p1.setValue(1);
    p2.setException(new Throwable());
    assertEquals(new Integer(3), get(future));
  }

  @Test
  public void firstCompletedOfInterrupts() {
    AtomicReference<Throwable> p1Intr = new AtomicReference<>();
    AtomicReference<Throwable> p2Intr = new AtomicReference<>();
    Promise<Integer> p1 = Promise.apply(p1Intr::set);
    Promise<Integer> p2 = Promise.apply(p2Intr::set);

    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2));

    future.raise(ex);

    assertEquals(ex, p1Intr.get());
    assertEquals(ex, p2Intr.get());
  }

  @Test(expected = TimeoutException.class)
  public void firstCompletedOfTimeout() throws CheckedFutureException {
    Promise<Integer> p1 = Promise.apply();
    Promise<Integer> p2 = Promise.apply();
    Future<Integer> future = Future.firstCompletedOf(Arrays.asList(p1, p2));
    future.get(Duration.ofMillis(10));
  }

  /*** whileDo ***/

  @Test
  public void whileDo() throws CheckedFutureException {
    int iterations = 200000;
    AtomicInteger count = new AtomicInteger(iterations);
    AtomicInteger callCount = new AtomicInteger(0);
    Future<Void> future = Future.whileDo(() -> count.decrementAndGet() >= 0,
        () -> Future.apply(() -> callCount.incrementAndGet()));
    get(future);
    assertEquals(-1, count.get());
    assertEquals(iterations, callCount.get());
  }

  /*** delay ***/

  @Test
  public void delay() throws CheckedFutureException {
    long delay = 10;
    long start = System.currentTimeMillis();
    Future.delay(Duration.ofMillis(delay), scheduler).get(Duration.ofMillis(200));
    assertTrue(System.currentTimeMillis() - start >= delay);
  }

  /*** within ***/

  @Test(expected = TimeoutException.class)
  public void withinDefaultExceptionFailure() throws CheckedFutureException {
    Future<Integer> f = (Promise.<Integer>apply()).within(Duration.ofMillis(1), scheduler);
    get(f);
  }

  @Test
  public void withinDefaultExceptionSuccess() throws CheckedFutureException {
    Promise<Integer> p = Promise.<Integer>apply();
    Future<Integer> f = p.within(Duration.ofMillis(10), scheduler);
    p.setValue(1);
    assertEquals(new Integer(1), get(f));
  }
}