package com.atlassian.vcache.internal.test;
   
   import org.hamcrest.Description;
   import org.hamcrest.Factory;
   import org.hamcrest.Matcher;
   import org.hamcrest.TypeSafeMatcher;
   
   import java.util.Optional;
   import java.util.concurrent.CompletableFuture;
  import java.util.concurrent.CompletionStage;
  
  import static java.util.Objects.requireNonNull;
  
  /**
   * Matcher for {@link CompletionStage}
   *
   * @param <T> the type of the result
   */
  public class CompletionStageSuccessful<T> extends TypeSafeMatcher<CompletionStage<T>> {
      private final Optional<Matcher<T>> valueMatcher;
  
      public CompletionStageSuccessful(Optional<Matcher<T>> valueMatcher) {
          this.valueMatcher = requireNonNull(valueMatcher);
      }
  
      @Override
      protected boolean matchesSafely(CompletionStage<T> stage) {
          try {
              final CompletableFuture<T> future = stage.toCompletableFuture();
              return !future.isCompletedExceptionally()
                      && (!valueMatcher.isPresent() || valueMatcher.get().matches(future.get()));
          } catch (Exception e) {
              return false;
          }
      }
  
      @Override
      public void describeTo(Description description) {
          if (valueMatcher.isPresent()) {
              description.appendText("successful result which ");
              description.appendDescriptionOf(valueMatcher.get());
          } else {
              description.appendText("successful result");
          }
      }
  
      @Override
      protected void describeMismatchSafely(CompletionStage<T> stage, Description mismatchDescription) {
          final CompletableFuture<T> future = stage.toCompletableFuture();
  
          if (future.isCompletedExceptionally()) {
              mismatchDescription.appendText("isCompletedExceptionally() is true");
          } else if (valueMatcher.isPresent()) {
              try {
                  mismatchDescription.appendText("result was " + future.get());
              } catch (Exception e) {
                  mismatchDescription.appendText("get() throws " + e);
              }
          }
      }
  
      @Factory
      public static <T> Matcher<CompletionStage<T>> successfulWith(Matcher<T> valueMatcher) {
          return new CompletionStageSuccessful<>(Optional.of(valueMatcher));
      }
  
      @Factory
      public static <T> Matcher<CompletionStage<T>> successful() {
          return new CompletionStageSuccessful<>(Optional.empty());
      }
  }