private static boolean isArrayEmpty(Object array) { return sizeOf(array) == 0; }
/** * Return true if actualArray contains exactly the given sequence at given starting index, false otherwise. * * * @param actualStartIndex the index to start looking for sequence in actualArray * @param actualArray the actual array to search sequence in * @param sequence the sequence to look for * @return true if actualArray contains exactly the given sequence at given starting index, false otherwise. */ private boolean containsSequenceAtGivenIndex(int actualStartIndex, Object actualArray, Object sequence) { int sequenceSize = sizeOf(sequence); for (int i = 0; i < sequenceSize; i++) { if (areEqual(Array.get(sequence, i), Array.get(actualArray, i + actualStartIndex))) continue; return false; } return true; }
void assertStartsWith(AssertionInfo info, Failures failures, Object actual, Object sequence) { if (commonChecks(info, actual, sequence)) return; int sequenceSize = sizeOf(sequence); int arraySize = sizeOf(actual); if (arraySize < sequenceSize) throw arrayDoesNotStartWithSequence(info, failures, actual, sequence); for (int i = 0; i < sequenceSize; i++) { if (!areEqual(Array.get(sequence, i), Array.get(actual, i))) throw arrayDoesNotStartWithSequence(info, failures, actual, sequence); } }
void assertEndsWith(AssertionInfo info, Failures failures, Object actual, Object sequence) { checkNulls(info, actual, sequence); int sequenceSize = sizeOf(sequence); int arraySize = sizeOf(actual); if (arraySize < sequenceSize) throw arrayDoesNotEndWithSequence(info, failures, actual, sequence); for (int i = 0; i < sequenceSize; i++) { int sequenceIndex = sequenceSize - (i + 1); int arrayIndex = arraySize - (i + 1); if (!areEqual(Array.get(sequence, sequenceIndex), Array.get(actual, arrayIndex))) throw arrayDoesNotEndWithSequence(info, failures, actual, sequence); } }
void assertDoesNotContainSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) { if (commonChecks(info, actual, sequence)) return; // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence); for (int actualIndex = 0; actualIndex <= lastIndexWhereSequenceCanBeFound; actualIndex++) { if (containsSequenceAtGivenIndex(actualIndex, actual, sequence)) { throw failures.failure(info, shouldNotContainSequence(actual, sequence, actualIndex, comparisonStrategy)); } } }
void assertContainsSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) { if (commonChecks(info, actual, sequence)) return; // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence); for (int actualIndex = 0; actualIndex <= lastIndexWhereSequenceCanBeFound; actualIndex++) { if (containsSequenceAtGivenIndex(actualIndex, actual, sequence)) return; } throw failures.failure(info, shouldContainSequence(actual, sequence, comparisonStrategy)); }
void assertHasSameSizeAs(AssertionInfo info, Object array, Iterable<?> other) { assertNotNull(info, array); hasSameSizeAsCheck(info, array, other, sizeOf(array)); }
void assertStartsWith(AssertionInfo info, Failures failures, Object actual, Object sequence) { if (commonChecks(info, actual, sequence)) return; int sequenceSize = sizeOf(sequence); int arraySize = sizeOf(actual); if (arraySize < sequenceSize) throw arrayDoesNotStartWithSequence(info, failures, actual, sequence); for (int i = 0; i < sequenceSize; i++) { if (!areEqual(Array.get(sequence, i), Array.get(actual, i))) throw arrayDoesNotStartWithSequence(info, failures, actual, sequence); } }
@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)); }
void assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object values) { checkIsNotNullAndNotEmpty(values); assertNotNull(info, array); Set<Object> found = new LinkedHashSet<>(); int valuesSize = sizeOf(values); for (int i = 0; i < valuesSize; i++) { Object value = Array.get(values, i); if (arrayContains(array, value)) found.add(value); } if (!found.isEmpty()) throw failures.failure(info, shouldNotContain(array, values, found, comparisonStrategy)); }
void assertHasSizeGreaterThanOrEqualTo(AssertionInfo info, Object array, int boundary) { assertNotNull(info, array); int sizeOfActual = sizeOf(array); checkSizeGreaterThanOrEqualTo(array, boundary, sizeOfActual, info); }
void assertHasSizeLessThan(AssertionInfo info, Object array, int boundary) { assertNotNull(info, array); int sizeOfActual = sizeOf(array); checkSizeLessThan(array, boundary, sizeOfActual, info); }
void assertContainsSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) { if (commonChecks(info, actual, sequence)) return; // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence); for (int actualIndex = 0; actualIndex <= lastIndexWhereSequenceCanBeFound; actualIndex++) { if (containsSequenceAtGivenIndex(actualIndex, actual, sequence)) return; } throw failures.failure(info, shouldContainSequence(actual, sequence, comparisonStrategy)); }
void assertHasSize(AssertionInfo info, Failures failures, Object array, int expectedSize) { assertNotNull(info, array); int sizeOfActual = sizeOf(array); if (sizeOfActual != expectedSize) throw failures.failure(info, shouldHaveSize(array, sizeOfActual, expectedSize)); }
public void assertIsSubsetOf(AssertionInfo info, Failures failures, Object actual, Iterable<?> values) { assertNotNull(info, actual); checkIterableIsNotNull(info, values); List<Object> extra = newArrayList(); int sizeOfActual = sizeOf(actual); for (int i = 0; i < sizeOfActual; i++) { Object actualElement = Array.get(actual, i); if (!iterableContains(values, actualElement)) { extra.add(actualElement); } } if (extra.size() > 0) { throw failures.failure(info, shouldBeSubsetOf(actual, values, extra, comparisonStrategy)); } }
void assertContains(AssertionInfo info, Failures failures, Object array, Object value, Index index) { assertNotNull(info, array); assertNotEmpty(info, failures, array); checkIndexValueIsValid(index, sizeOf(array) - 1); Object actualElement = Array.get(array, index.value); if (!areEqual(actualElement, value)) throw failures.failure(info, shouldContainAtIndex(array, value, index, Array.get(array, index.value), comparisonStrategy)); }
void assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object value, Index index) { assertNotNull(info, array); checkIndexValueIsValid(index, Integer.MAX_VALUE); if (index.value >= sizeOf(array)) return; if (areEqual(Array.get(array, index.value), value)) throw failures.failure(info, shouldNotContainAtIndex(array, value, index, comparisonStrategy)); }
@SuppressWarnings("unchecked") private <E> List<E> filterElements(AssertionInfo info, Failures failures, Conditions conditions, Object array, Condition<E> condition, boolean negateCondition) throws AssertionError { assertNotNull(info, array); conditions.assertIsNotNull(condition); try { List<E> filteredElements = new LinkedList<>(); int arraySize = sizeOf(array); for (int i = 0; i < arraySize; i++) { E element = (E) Array.get(array, i); if (negateCondition ? !condition.matches(element) : condition.matches(element)) filteredElements.add(element); } return filteredElements; } catch (ClassCastException e) { throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(array, condition)); } }
public void assertHasSameSizeAs(AssertionInfo info, Object array, Object other) { assertNotNull(info, array); assertIsArray(info, array); assertIsArray(info, other); hasSameSizeAsCheck(info, array, other, sizeOf(array)); }
void assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object value, Index index) { assertNotNull(info, array); checkIndexValueIsValid(index, Integer.MAX_VALUE); if (index.value >= sizeOf(array)) return; if (areEqual(Array.get(array, index.value), value)) throw failures.failure(info, shouldNotContainAtIndex(array, value, index, comparisonStrategy)); }