private static void checkNulls(AssertionInfo info, Object actual, Object sequence) { checkIsNotNull(sequence); assertNotNull(info, actual); }
void assertHasSameSizeAs(AssertionInfo info, Object array, Iterable<?> other) { assertNotNull(info, array); hasSameSizeAsCheck(info, array, other, sizeOf(array)); }
void assertContainsOnlyNulls(AssertionInfo info, Failures failures, Object[] actual) { assertNotNull(info, actual); // empty => no null elements => failure if (actual.length == 0) throw failures.failure(info, shouldContainOnlyNulls(actual)); // look for any non null elements List<Object> nonNullElements = new ArrayList<>(); for (Object element : actual) { if (element != null) nonNullElements.add(element); } if (nonNullElements.size() > 0) throw failures.failure(info, shouldContainOnlyNulls(actual, nonNullElements)); }
void assertcontainsAll(AssertionInfo info, Failures failures, Object array, Iterable<?> iterable) { if (iterable == null) throw iterableToLookForIsNull(); assertNotNull(info, array); Object[] values = newArrayList(iterable).toArray(); Set<Object> notFound = new LinkedHashSet<>(); for (Object value : values) { if (!arrayContains(array, value)) notFound.add(value); } if (!notFound.isEmpty()) throw failures.failure(info, shouldContain(array, 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 assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) { checkIsNotNull(expectedTypes); assertNotNull(info, actual); List<Object> nonMatchingElements = newArrayList(); for (Object value : asList(actual)) { boolean matching = false; for (Class<?> expectedType : expectedTypes) { if (expectedType.isInstance(value)) matching = true; } if (!matching) nonMatchingElements.add(value); } if (!nonMatchingElements.isEmpty()) { throw failures.failure(info, shouldOnlyHaveElementsOfTypes(actual, expectedTypes, nonMatchingElements)); } }
void assertcontainsAll(AssertionInfo info, Failures failures, Object array, Iterable<?> iterable) { if (iterable == null) throw iterableToLookForIsNull(); assertNotNull(info, array); Object[] values = newArrayList(iterable).toArray(); Set<Object> notFound = new LinkedHashSet<>(); for (Object value : values) { if (!arrayContains(array, value)) notFound.add(value); } if (!notFound.isEmpty()) throw failures.failure(info, shouldContain(array, 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 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)); }
void assertContainsNull(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (!arrayContains(array, null)) throw failures.failure(info, shouldContainNull(array)); }
void assertDoesNotContainNull(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (arrayContains(array, null)) throw failures.failure(info, shouldNotContainNull(array)); }
void assertEmpty(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (!isArrayEmpty(array)) throw failures.failure(info, shouldBeEmpty(array)); }
void assertNotEmpty(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (isArrayEmpty(array)) throw failures.failure(info, shouldNotBeEmpty()); }
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)); }
void assertDoesNotHaveDuplicates(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); ArrayWrapperList wrapped = wrap(array); Iterable<?> duplicates = comparisonStrategy.duplicatesFrom(wrapped); if (!isNullOrEmpty(duplicates)) throw failures.failure(info, shouldNotHaveDuplicates(array, duplicates, comparisonStrategy)); }