Java Subject类代码示例

import com.google.common.truth.Subject; //导入依赖的package包/类
private Subject<DefaultSubject, Object> assertToolchainResolution(
    Label toolchainType,
    Iterable<ConstraintValueInfo> targetConstraints,
    Iterable<ConstraintValueInfo> execConstraints,
    ImmutableList<DeclaredToolchainInfo> toolchains)
    throws Exception {

  PlatformInfo execPlatform =
      PlatformInfo.builder()
          .setLabel(makeLabel("//platform:exec"))
          .addConstraints(execConstraints)
          .build();
  PlatformInfo targetPlatform =
      PlatformInfo.builder()
          .setLabel(makeLabel("//platform:target"))
          .addConstraints(targetConstraints)
          .build();

  DeclaredToolchainInfo resolvedToolchain =
      ToolchainResolutionFunction.resolveConstraints(
          toolchainType, execPlatform, targetPlatform, toolchains, null);
  return assertThat(resolvedToolchain);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
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);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
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);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <S extends Subject<S, E>, E> ListSubject<S, E> assertThat(
    List<E> list, Function<E, S> elementAssertThatFunction) {
  // The ListSubjectFactory always returns ListSubjects.
  // -> Casting is appropriate.
  return (ListSubject<S, E>)
      assertAbout(new ListSubjectFactory<>(elementAssertThatFunction)).that(list);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
/**
 * Allows for assertions on the value provided by this provider.
 *
 * <p>The value provided by a checked provider is the object returned by a call to {@link
 * CheckedProvider#get}
 *
 * @return a {@link Subject} for asserting against the return value of {@link CheckedProvider#get}
 */
public Subject<?, Object> providedValue() {
  P provider = actual();
  T got;
  try {
    got = provider.get();
  } catch (Exception e) {
    failWithRawMessageAndCause(
        String.format("checked provider <%s> threw an exception", provider), e);
    return ignoreCheck().that(new Object());
  }
  return check().withMessage("value provided by <%s>", provider).that(got);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
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);
    }
  };
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
private static Subject<DefaultSubject, Object> assertThat(Object subject) {
  return Truth.assertThat(subject);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
public static Subject<DefaultSubject, Object> assertThat(@Nullable Object target) {
    return assert_().that(target);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
/**
 * Use this for checking assertions about BooleanFormulas (given the corresponding solver) with
 * Truth: <code>assert_().about(booleanFormulasOf(context)).that(formula).is...()</code>.
 */
public static Subject.Factory<BooleanFormulaSubject, BooleanFormula> booleanFormulasOf(
    final SolverContext context) {
  return (metadata, formula) -> new BooleanFormulaSubject(metadata, formula, context);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
/**
 * Use this for checking assertions about ProverEnvironments with Truth: <code>
 * assert_().about(proverEnvironments()).that(stack).is...()</code>.
 */
public static Subject.Factory<ProverEnvironmentSubject, BasicProverEnvironment<?>>
    proverEnvironments() {
  return (metadata, formula) -> new ProverEnvironmentSubject(metadata, formula);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
public static <S extends Subject<S, ? super T>, T> OptionalSubject<S, T> assertThat(
    Optional<T> optional, Function<? super T, ? extends S> elementAssertThatFunction) {
  OptionalSubjectFactory<S, T> optionalSubjectFactory =
      new OptionalSubjectFactory<>(elementAssertThatFunction);
  return assertAbout(optionalSubjectFactory).that(optional);
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
public static Subject.Factory<TypeSubject, TypeI> types() {
  return TypeSubject::new;
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
public static <T, P extends CheckedProvider<T>>
    Subject.Factory<CheckedProviderSubject<T, P>, P> checkedProviders() {
  return new CheckedProviderSubjectFactory<>();
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
public static Subject.Factory<DeadlineSubject, Deadline> deadline() {
  return deadlineFactory;
}
 

import com.google.common.truth.Subject; //导入依赖的package包/类
/** Returns the subject factory for doing assertions on paths. */
public static Subject.Factory<PathSubject, Path> paths() {
  return new PathSubjectFactory();
}