com.google.common.truth.Subject Java Examples

@CheckReturnValue
Subject hasResultThat() {
  try {
    return assertThat(callable.call());
  } catch (Exception e) {
    throw new AssertionError("Unexpected exception", e);
  }
}
 

static Subject.Factory<ZipEntrySubject, ZipEntry> zipEntries(ZipFile zip) {
  return new Subject.Factory<ZipEntrySubject, ZipEntry>() {
    @Override
    public ZipEntrySubject createSubject(FailureMetadata metadata, ZipEntry actual) {
      return new ZipEntrySubject(metadata, zip, actual);
    }
  };
}
 

public static Subject<?, Object> assertCompleted(CompletionStage<?> stage)
    throws InterruptedException, ExecutionException {
  assertThat(stage.toCompletableFuture().isDone()).isTrue();
  Object result = stage.toCompletableFuture().get();
  assertThat(stage.toCompletableFuture().isCancelled()).isFalse();
  assertThat(stage.toCompletableFuture().isCompletedExceptionally()).isFalse();
  return assertThat(result);
}
 

public static Subject<?, Object> assertAfterCompleted(CompletionStage<?> stage)
    throws InterruptedException, ExecutionException {
  Object result = stage.toCompletableFuture().get();
  assertThat(stage.toCompletableFuture().isDone()).isTrue();
  assertThat(stage.toCompletableFuture().isCancelled()).isFalse();
  assertThat(stage.toCompletableFuture().isCompletedExceptionally()).isFalse();
  return assertThat(result);
}
 

static Subject.Factory<ClassNameSubject, String> classNames(Path basePath) {
  return new Subject.Factory<ClassNameSubject, String>() {
    @Override
    public ClassNameSubject createSubject(FailureMetadata metadata, String actual) {
      return new ClassNameSubject(metadata, basePath, actual);
    }
  };
}
 

/** Static method for getting the subject factory (for use with assertAbout()). */
public static Subject.Factory<ToolchainContextSubject, ToolchainContext> toolchainContexts() {
  return TOOLCHAIN_CONTEXT_SUBJECT_FACTORY;
}
 

public static Subject.Factory<IntentSubject, Intent> intents() {
  return IntentSubject::new;
}
 

public static Subject.Factory<LocationSubject, Location> locations() {
  return LocationSubject::new;
}
 

public Subject hasEntryThat(SkyKey key) {
  return check("get(%s)", key).that(actual.get(key));
}
 

public Subject hasVersionThat() {
  return check("getVersion()").that(actual.getVersion());
}
 

public Subject addReverseDepAndCheckIfDone(@Nullable SkyKey reverseDep)
    throws InterruptedException {
  return check("addReverseDepAndCheckIfDone()")
      .that(actual.addReverseDepAndCheckIfDone(reverseDep));
}
 

/** Static method for getting the subject factory (for use with assertAbout()). */
public static Subject.Factory<ToolchainCollectionSubject, ToolchainCollection<?>>
    toolchainCollections() {
  return TOOLCHAIN_COLLECTION_SUBJECT_FACTORY;
}
 

public Subject getValue(String name) throws EvalException {
  return check("getValue(%s)", name).that(actual.getValue(name));
}
 

public static Subject.Factory<NotificationSubject, Notification> notifications() {
  return NotificationSubject::new;
}
 

public static Subject.Factory<DeadlineSubject, Deadline> deadline() {
  return deadlineFactory;
}
 

/** Returns the subject factory for doing assertions on paths. */
public static Subject.Factory<PathSubject, Path> paths() {
  return new PathSubjectFactory();
}
 

/** Returns a {@link Subject.Factory} for {@link JavaFileObjectSubject}s. */
public static Subject.Factory<JavaFileObjectSubject, JavaFileObject> javaFileObjects() {
  return FACTORY;
}
 

/** Returns a {@link Subject.Factory} for a {@link Compilation}. */
public static Subject.Factory<CompilationSubject, Compilation> compilations() {
  return FACTORY;
}
 

public static Subject.Factory<NotificationActionSubject, Action> notificationActions() {
  return NotificationActionSubject::new;
}
 

public static Subject.Factory<PendingIntentSubject, PendingIntent> pendingIntents() {
  return PendingIntentSubject::new;
}
 

public static Subject.Factory<DeadlineSubject, Deadline> deadline() {
  return deadlineFactory;
}
 

public <T extends Parcelable, SubjectT extends Subject> SubjectT parcelableAsType(
    String key, Subject.Factory<SubjectT, T> subjectFactory) {
  return check("getParcelable(%s)", key).about(subjectFactory).that(actual.<T>getParcelable(key));
}
 

public static Subject.Factory<BundleSubject, Bundle> bundles() {
  return BundleSubject::new;
}
 

public static <T extends Parcelable> Subject.Factory<ParcelableSubject<T>, T> parcelables() {
  return ParcelableSubject<T>::new;
}
 

public static Subject.Factory<MotionEventSubject, MotionEvent> motionEvents() {
  return MotionEventSubject::new;
}
 

public static Subject.Factory<PointerPropertiesSubject, PointerProperties> pointerProperties() {
  return PointerPropertiesSubject::new;
}
 

public static Subject.Factory<PointerCoordsSubject, PointerCoords> pointerCoords() {
  return PointerCoordsSubject::new;
}
 

public static Subject.Factory<TextDiffSubject, ImmutableList<String>> textFactory() {
  return TEXT_DIFF_SUBJECT_TEXT_FACTORY;
}
 

/**
 * Asserts about the log site of the log record.
 */
public Subject logSite() {
  return check("getLogSite()").that(actual.getLogSite());
}
 

public static Subject.Factory<LogDataSubject, LogData> logData() {
  return LOG_DATA_SUBJECT_FACTORY;
}