@VisibleForTesting ShouldBeEqual(Object actual, Object expected, ComparisonStrategy comparisonStrategy, Representation representation) { this.actual = actual; this.expected = expected; this.comparisonStrategy = comparisonStrategy; this.representation = representation; }
public class ShouldEndWithPath extends BasicErrorMessageFactory { @VisibleForTesting public static final String PATH_SHOULD_END_WITH = "%nExpected path:%n <%s>%nto end with:%n <%s>%nbut it did not."; public static ErrorMessageFactory shouldEndWith(final Path actual, final Path other) { return new ShouldEndWithPath(actual, other); } private ShouldEndWithPath(final Path actual, final Path other) { super(PATH_SHOULD_END_WITH, actual, other); } }
@VisibleForTesting PropertyOrFieldSupport(PropertySupport propertySupport, FieldSupport fieldSupport) { this.propertySupport = propertySupport; this.fieldSupport = fieldSupport; }
public class ShouldStartWithPath extends BasicErrorMessageFactory { @VisibleForTesting public static final String PATH_SHOULD_START_WITH = "%nExpected path:%n <%s>%nto start with:%n <%s>%nbut it did not."; public static ErrorMessageFactory shouldStartWith(final Path actual, final Path other) { return new ShouldStartWithPath(actual, other); } private ShouldStartWithPath(final Path actual, final Path other) { super(PATH_SHOULD_START_WITH, actual, other); } }
@VisibleForTesting Properties(String propertyName, Class<T> propertyType) { this.propertyName = propertyName; this.propertyType = propertyType; }
@VisibleForTesting public ComparisonStrategy getComparisonStrategy() { return comparisonStrategy; } }
@VisibleForTesting BigDecimals() { super(); }
@VisibleForTesting public ComparisonStrategy getComparisonStrategy() { return comparisonStrategy; }
@VisibleForTesting public Comparator<?> getComparator() { if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { return ((ComparatorBasedComparisonStrategy) comparisonStrategy) .getComparator(); } return null; }
@VisibleForTesting public Comparator<?> getComparator() { return comparisonStrategy instanceof ComparatorBasedComparisonStrategy ? ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator() : null; }
@VisibleForTesting public Comparator<?> getComparator() { if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { return ((ComparatorBasedComparisonStrategy) comparisonStrategy) .getComparator(); } return null; }
@VisibleForTesting public Comparator<?> getComparator() { if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator(); } return null; }
@VisibleForTesting public Comparator<?> getComparator() { if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator(); } return null; }
/** * Build a {@link Comparables} using a {@link StandardComparisonStrategy}. */ @VisibleForTesting public Comparables() { this(StandardComparisonStrategy.instance()); }
@VisibleForTesting public Comparator<?> getComparator() { if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator(); } return null; }
@VisibleForTesting public BinaryDiffResult diff(Path actual, byte[] expected) throws IOException { try (InputStream expectedStream = new ByteArrayInputStream(expected); InputStream actualStream = Files.newInputStream(actual)) { return diff(actualStream, expectedStream); } }
@VisibleForTesting public Comparator<?> getComparator() { if (!(comparisonStrategy instanceof ComparatorBasedComparisonStrategy)) return null; return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator(); }
@VisibleForTesting ByteArrays() { this(StandardComparisonStrategy.instance()); }
@VisibleForTesting public BinaryDiffResult diff(InputStream actualStream, InputStream expectedStream) throws IOException { int index = 0; while (true) { int actual = actualStream.read(); int expected = expectedStream.read(); if (actual == -1 && expected == -1) return BinaryDiffResult.noDiff(); // reached end of both streams if (actual != expected) return new BinaryDiffResult(index, expected, actual); index += 1; } } }
@VisibleForTesting public void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; Set<Object> notFound = new LinkedHashSet<>(); int valueCount = sizeOf(values); for (int i = 0; i < valueCount; i++) { Object value = Array.get(values, i); if (!arrayContains(actual, value)) notFound.add(value); } if (!notFound.isEmpty()) throw failures.failure(info, shouldContain(actual, values, notFound, comparisonStrategy)); }