Java Code Examples for org.hamcrest.StringDescription#toString()

@Override
public final Collection<String> apply(final Dict request) {
    final Collection<String> result;
    final String matching = this.func.apply(request);
    if (this.matcher.matches(matching)) {
        result = new CollectionOf<>();
    } else {
        final StringDescription description = new StringDescription();
        description
            .appendText("\nExpected: ")
            .appendDescriptionOf(this.matcher)
            .appendText("\n     but: ");
        this.matcher.describeMismatch(matching, description);
        result = new CollectionOf<>(description.toString());
    }
    return result;
}
 

@Override
public <T> boolean assertThat(String businessDescription, String systemDescription, T actual,
        Matcher<? super T> matcher)
{
    boolean isMatches = matcher.matches(actual);
    if (!isMatches)
    {
        String assertionDescription = getAssertionDescriptionString(actual, matcher);
        return recordAssertion(format(businessDescription, assertionDescription),
                format(systemDescription, assertionDescription), isMatches);
    }
    StringDescription description = new StringDescription();
    matcher.describeTo(description);
    String matchedString = description.toString();
    return recordAssertion(businessDescription + StringUtils.SPACE + matchedString,
            systemDescription + StringUtils.SPACE + matchedString, isMatches);
}
 

public String toString()
{
    final StringDescription description = new StringDescription();
    final String lineSeparator = System.getProperty("line.separator");

    description.appendText("Unable to match: ");
    matcher.describeTo(description);
    description.appendText(", against the following errors:");
    encodedExceptions.forEach(
        (encodedException) ->
        {
            description.appendText(lineSeparator).appendText("  ");
            description.appendText(encodedException);
        });
    description.appendText(lineSeparator);

    return description.toString();
}
 

protected <T> String getAssertionDescriptionString(T actual, Matcher<? super T> matcher)
{
    StringDescription stringDescription = new StringDescription();
    stringDescription.appendText(EXPECTED).appendDescriptionOf(matcher);

    StringDescription mismatchStringDescription = new StringDescription();
    matcher.describeMismatch(actual, mismatchStringDescription);

    String mismatchString = mismatchStringDescription.toString();
    if (!mismatchString.isEmpty())
    {
        stringDescription.appendText(ACTUAL).appendText(mismatchString);
    }
    return stringDescription.toString();
}
 

@Override
public <T> String getAssertionDescriptionString(T actual, Matcher<? super T> matcher)
{
    if (matcher instanceof ConfigurableJsonMatcher)
    {
        if (matcher.matches(actual))
        {
            return "Condition is true";
        }
        StringDescription mismatchStringDescription = new StringDescription();
        matcher.describeMismatch(actual, mismatchStringDescription);
        return mismatchStringDescription.toString();
    }
    return super.getAssertionDescriptionString(actual, matcher);
}
 

@Override
protected boolean matchesSafely(Matcher m, Description mismatchDescription) {
    StringDescription stringDescription = new StringDescription();
    m.describeTo(stringDescription);
    final String description = stringDescription.toString();

    if (!matcher.matches(description)) {
        mismatchDescription.appendText("description ");
        matcher.describeMismatch(description, mismatchDescription);
        return false;
    }
    return true;
}
 

public static <T> Function1<T, String> diagnoseMismatch(final DiagnosingMatcher matcher) {
    return t -> {
        StringDescription mismatchDescription = new StringDescription();
        matcher.describeMismatch(t, mismatchDescription);
        return mismatchDescription.toString();
    };
}
 

@Override
protected boolean matchesSafely(Matcher m, Description mismatchDescription) {
    StringDescription stringDescription = new StringDescription();
    m.describeTo(stringDescription);
    final String description = stringDescription.toString();

    if (!matcher.matches(description)) {
        mismatchDescription.appendText("description ");
        matcher.describeMismatch(description, mismatchDescription);
        return false;
    }
    return true;
}
 

private String missingExceptionMessage() {
    String expectation= StringDescription.toString(matcherBuilder.build());
    return format(missingExceptionMessage, expectation);
}
 

static String describe(Matcher m) {
  final StringDescription d = new StringDescription();
  m.describeTo(d);
  return d.toString();
}
 

static String mismatchDescription(Matcher m, Object item) {
  final StringDescription d = new StringDescription();
  m.describeMismatch(item, d);
  return d.toString();
}
 

protected static String describe(SelfDescribing m) {
    return StringDescription.toString(m);
}
 

protected static String describe(SelfDescribing m) {
    return StringDescription.toString(m);
}
 

@Override
public boolean matchesSafely(Cursor cursor) {
  int chosenColumn = columnIndex;
  if (chosenColumn < 0) {
    chosenColumn = findColumnIndex(columnNameMatcher, cursor);
    if (chosenColumn < 0) {
      StringDescription description = new StringDescription();
      columnNameMatcher.describeTo(description);
      if (chosenColumn == COLUMN_NOT_FOUND) {
        if (checkColumns) {
          throw new IllegalArgumentException(
              "Couldn't find column in "
                  + Arrays.asList(cursor.getColumnNames())
                  + " matching "
                  + description.toString());
        }
        // this cursor position doesn't have a column with this name, but other ones might
        // (e.g. in case of MergeCursor), so if columnChecks are off continue the search.
        return false;
      } else if (chosenColumn == MULTIPLE_COLUMNS_FOUND) {
        throw new IllegalArgumentException(
            "Multiple columns in "
                + Arrays.asList(cursor.getColumnNames())
                + " match "
                + description.toString());
      } else {
        throw new IllegalArgumentException(
            "Couldn't find column in " + Arrays.asList(cursor.getColumnNames()));
      }
    }
  }
  try {
    return applier.apply(cursor, chosenColumn, valueMatcher);
  } catch (CursorIndexOutOfBoundsException e) {
    if (checkColumns) {
      throw new IllegalArgumentException("Column index is invalid", e);
    }
    // this cursor position doesn't have a column with this index, but other ones might
    // (e.g. in case of MergeCursor), so if columnChecks are off continue the search.
    return false;
  }
}
 

private String missingExceptionMessage() {
    String expectation= StringDescription.toString(matcherBuilder.build());
    return format(missingExceptionMessage, expectation);
}
 

private String describeFailureOf(Probe probe) {
	StringDescription description = new StringDescription();
	probe.describeFailureTo(description);
	return description.toString();
}
 

private boolean verifyNoAbandoned(
    final ApiSurface checkedApiSurface,
    final Set<Matcher<Class<?>>> allowedClasses,
    final Description mismatchDescription) {

  // <helper_lambdas>

  final Function<Matcher<Class<?>>, String> toMessage =
      abandonedClassMacther -> {
        final StringDescription description = new StringDescription();
        description.appendText("No ");
        abandonedClassMacther.describeTo(description);
        return description.toString();
      };

  final Predicate<Matcher<Class<?>>> matchedByExposedClasses =
      classMatcher ->
          FluentIterable.from(checkedApiSurface.getExposedClasses())
              .anyMatch(classMatcher::matches);

  // </helper_lambdas>

  final ImmutableSet<Matcher<Class<?>>> matchedClassMatchers =
      FluentIterable.from(allowedClasses).filter(matchedByExposedClasses).toSet();

  final Sets.SetView<Matcher<Class<?>>> abandonedClassMatchers =
      Sets.difference(allowedClasses, matchedClassMatchers);

  final ImmutableList<String> messages =
      FluentIterable.from(abandonedClassMatchers)
          .transform(toMessage)
          .toSortedList(Ordering.natural());

  if (!messages.isEmpty()) {
    mismatchDescription.appendText(
        "The following white-listed scopes did not have matching classes on the API surface:"
            + "\n\t"
            + Joiner.on("\n\t").join(messages));
  }

  return messages.isEmpty();
}
 

static String describe(Matcher m) {
  final StringDescription d = new StringDescription();
  m.describeTo(d);
  return d.toString();
}
 

static String mismatchDescription(Matcher m, Object item) {
  final StringDescription d = new StringDescription();
  m.describeMismatch(item, d);
  return d.toString();
}