com.google.common.truth.StringSubject Java Examples

/**
 * Returns a {@link StringSubject} that makes assertions about the contents of the actual file as
 * a string.
 */
public StringSubject contentsAsString(Charset charset) {
  try {
    return check("contents()")
        .that(JavaFileObjects.asByteSource(actual).asCharSource(charset).read());
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

public StringSubject hasJsdocCommentThat() {
  Truth.assertThat(actual()).isNotNull();
  JSDocInfo info = actual().getJsDoc().getInfo();
  assertWithMessage("%s does not have jsdoc", actual()).that(info).isNotNull();
  return Truth.assertThat(info.getOriginalCommentString())
      .named("%s jsdoc comment", internalCustomName());
}
 

@Test
public void compile_withNestedAutoValueInSamePackage_shouldRegisterGeneratedSubclass() {
  Compilation result =
      javac()
          .withProcessors(new AutoValueProcessor(), new EncodableProcessor())
          .compile(
              JavaFileObjects.forSourceLines(
                  "Foo",
                  "import com.google.firebase.encoders.annotations.Encodable;",
                  "import com.google.auto.value.AutoValue;",
                  "@Encodable @AutoValue public abstract class Foo {",
                  "public abstract Bar getBar();",
                  "@AutoValue public abstract static class Bar {",
                  "public abstract Baz getBaz();",
                  "@AutoValue public abstract static class Baz {",
                  "public abstract String getField();",
                  "}",
                  "}",
                  "}"));

  StringSubject compiled =
      assertThat(result).generatedSourceFile("AutoFooEncoder").contentsAsUtf8String();

  compiled.contains("cfg.registerEncoder(AutoValue_Foo.class");
  compiled.contains("cfg.registerEncoder(AutoValue_Foo_Bar.class");
  compiled.contains("cfg.registerEncoder(AutoValue_Foo_Bar_Baz.class");
}
 

public Which<StringSubject> hasLogAtLevelWithMessage(Level level, String message) {
  List<String> messagesAtLevel = getMessagesAtLevel(level);
  check("atLevel(%s)", level)
      .that(messagesAtLevel)
      .comparingElementsUsing(CONTAINS_CORRESPONDENCE)
      .contains(message);
  for (String messageCandidate : messagesAtLevel) {
    if (messageCandidate.contains(message)) {
      return new Which<>(
          assertWithMessage(String.format("log message at %s matching '%s'", level, message))
              .that(messageCandidate));
    }
  }
  throw new AssertionError("Message check passed yet matching message not found");
}
 

@Override
public StringSubject verifyText() {
    return assertThat(text());
}
 

private static StringSubject assertMap(AndroidDataConverter<String> converter) {
  return assertThat(converter.map(TO_MAP));
}
 

public final StringSubject title() {
  return check("title").that(actual.title != null ? actual.title.toString() : null);
}
 

public final StringSubject tickerText() {
  return check("tickerText")
      .that(actual.tickerText != null ? actual.tickerText.toString() : null);
}
 

public StringSubject string(String key) {
  return check("getString(%s)", key).that(actual.getString(key));
}
 

StringSubject diagnosticStream() {
  String[] parseResult = parse();
  return assertThat(parseResult[1]);
}
 

StringSubject assertOnlyLog() {
  assertThat(logRecords).hasSize(1);
  LogRecord logRecord = logRecords.get(0);
  flush();
  return assertThat(logRecordToString(logRecord));
}
 

@Override
public StringSubject verifyTitle () {
    return assertThat (title ());
}
 

@Override
public StringSubject verifyAlertMessage(final AlertDecision decision) {
    final String actual = alert(decision);
    return assertThat(actual);
}
 

@Override
public StringSubject verifyAttribute(final String attribute) {
    return assertThat(attribute(attribute));
}
 

/**
 * @return string subject
 * @author Wasiq Bhamla
 * @since 08-Jun-2019
 */
StringSubject verifyTitle();
 

/**
 * @author Wasiq Bhamla
 * @since 06-Jun-2019
 * @param decision alert decision
 * @return string subject
 */
StringSubject verifyAlertMessage (AlertDecision decision);
 

/**
 * @author Wasiq Bhamla
 * @since 07-Jun-2019
 * @return subject
 */
StringSubject verifyText ();
 

/**
 * @author Wasiq Bhamla
 * @since 07-Jun-2019
 * @param attribute element attribute
 * @return subject
 */
StringSubject verifyAttribute (final String attribute);
 

/**
 * Returns a {@link StringSubject} that makes assertions about the contents of the actual file as
 * a UTF-8 string.
 */
public StringSubject contentsAsUtf8String() {
  return contentsAsString(UTF_8);
}