void assertContainsExactlyInAnyOrder(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; List<Object> notExpected = asList(actual); List<Object> notFound = asList(values); for (Object value : asList(values)) { if (iterableContains(notExpected, value)) { iterablesRemoveFirst(notExpected, value); iterablesRemoveFirst(notFound, value); } } if (notExpected.isEmpty() && notFound.isEmpty()) return; throw failures.failure(info, shouldContainExactlyInAnyOrder(actual, values, notFound, notExpected, comparisonStrategy)); }
void assertContainsOnly(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; List<Object> notExpected = asList(actual); List<Object> notFound = asList(values); for (Object value : asList(values)) { if (iterableContains(notExpected, value)) { iterableRemoves(notExpected, value); iterableRemoves(notFound, value); } } if (!notExpected.isEmpty() || !notFound.isEmpty()) { throw failures.failure(info, shouldContainOnly(actual, values, notFound, notExpected, comparisonStrategy)); } }
void assertContainsOnlyOnce(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; Iterable<?> actualDuplicates = comparisonStrategy.duplicatesFrom(asList(actual)); Set<Object> notFound = new LinkedHashSet<>(); Set<Object> notOnlyOnce = new LinkedHashSet<>(); for (Object expectedElement : asList(values)) { if (!arrayContains(actual, expectedElement)) { notFound.add(expectedElement); } else if (iterableContains(actualDuplicates, expectedElement)) { notOnlyOnce.add(expectedElement); } } if (!notFound.isEmpty() || !notOnlyOnce.isEmpty()) throw failures.failure(info, shouldContainsOnlyOnce(actual, values, notFound, notOnlyOnce, comparisonStrategy)); // assertion succeeded }
static <T> void assertIsSortedAccordingToComparator(AssertionInfo info, Failures failures, Object array, Comparator<T> comparator) { assertNotNull(info, array); checkNotNull(comparator, "The given comparator should not be null"); try { List<T> arrayAsList = asList(array); // empty arrays are considered sorted even if comparator can't be applied to <T>. if (arrayAsList.size() == 0) return; if (arrayAsList.size() == 1) { // call compare to see if unique element is compatible with comparator. comparator.compare(arrayAsList.get(0), arrayAsList.get(0)); return; } for (int i = 0; i < arrayAsList.size() - 1; i++) { // array is sorted in comparator defined order iif element i is less or equal than element i+1 if (comparator.compare(arrayAsList.get(i), arrayAsList.get(i + 1)) > 0) throw failures.failure(info, shouldBeSortedAccordingToGivenComparator(i, array, comparator)); } } catch (ClassCastException e) { throw failures.failure(info, shouldHaveComparableElementsAccordingToGivenComparator(array, comparator)); } }
void assertContainsOnlyOnce(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; Iterable<?> actualDuplicates = comparisonStrategy.duplicatesFrom(asList(actual)); Set<Object> notFound = new LinkedHashSet<>(); Set<Object> notOnlyOnce = new LinkedHashSet<>(); for (Object expectedElement : asList(values)) { if (!arrayContains(actual, expectedElement)) { notFound.add(expectedElement); } else if (iterableContains(actualDuplicates, expectedElement)) { notOnlyOnce.add(expectedElement); } } if (!notFound.isEmpty() || !notOnlyOnce.isEmpty()) throw failures.failure(info, shouldContainsOnlyOnce(actual, values, notFound, notOnlyOnce, comparisonStrategy)); // assertion succeeded }
void assertContainsExactlyInAnyOrder(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; List<Object> notExpected = asList(actual); List<Object> notFound = asList(values); for (Object value : asList(values)) { if (iterableContains(notExpected, value)) { iterablesRemoveFirst(notExpected, value); iterablesRemoveFirst(notFound, value); } } if (notExpected.isEmpty() && notFound.isEmpty()) return; throw failures.failure(info, shouldContainExactlyInAnyOrder(actual, values, notFound, notExpected, comparisonStrategy)); }
void assertContainsOnly(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; List<Object> notExpected = asList(actual); List<Object> notFound = asList(values); for (Object value : asList(values)) { if (iterableContains(notExpected, value)) { iterableRemoves(notExpected, value); iterableRemoves(notFound, value); } } if (!notExpected.isEmpty() || !notFound.isEmpty()) { throw failures.failure(info, shouldContainOnly(actual, values, notFound, notExpected, comparisonStrategy)); } }
public void assertContainsAnyOf(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; assertIsArray(info, actual); assertIsArray(info, values); List<Object> valuesToSearchFor = asList(values); for (Object element : asList(actual)) { if (iterableContains(valuesToSearchFor, element)) return; } throw failures.failure(info, shouldContainAnyOf(actual, values, 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)); } }
public void assertContainsAnyOf(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; assertIsArray(info, actual); assertIsArray(info, values); List<Object> valuesToSearchFor = asList(values); for (Object element : asList(actual)) { if (iterableContains(valuesToSearchFor, element)) return; } throw failures.failure(info, shouldContainAnyOf(actual, values, comparisonStrategy)); }
static <T> void assertIsSortedAccordingToComparator(AssertionInfo info, Failures failures, Object array, Comparator<T> comparator) { assertNotNull(info, array); checkNotNull(comparator, "The given comparator should not be null"); try { List<T> arrayAsList = asList(array); // empty arrays are considered sorted even if comparator can't be applied to <T>. if (arrayAsList.size() == 0) return; if (arrayAsList.size() == 1) { // call compare to see if unique element is compatible with comparator. comparator.compare(arrayAsList.get(0), arrayAsList.get(0)); return; } for (int i = 0; i < arrayAsList.size() - 1; i++) { // array is sorted in comparator defined order iif element i is less or equal than element i+1 if (comparator.compare(arrayAsList.get(i), arrayAsList.get(i + 1)) > 0) throw failures.failure(info, shouldBeSortedAccordingToGivenComparator(i, array, comparator)); } } catch (ClassCastException e) { throw failures.failure(info, shouldHaveComparableElementsAccordingToGivenComparator(array, comparator)); } }
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 assertContainsExactly(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; assertIsArray(info, actual); assertIsArray(info, values); List<Object> actualAsList = asList(actual); IterableDiff diff = diff(actualAsList, asList(values), comparisonStrategy); if (!diff.differencesFound()) { // actual and values have the same elements but are they in the same order ? int arrayLength = sizeOf(actual); for (int i = 0; i < arrayLength; i++) { Object actualElement = Array.get(actual, i); Object expectedElement = Array.get(values, i); if (!areEqual(actualElement, expectedElement)) throw failures.failure(info, elementsDifferAtIndex(actualElement, expectedElement, i, comparisonStrategy)); } return; } throw failures.failure(info, shouldContainExactly(actual, asList(values), diff.missing, diff.unexpected, comparisonStrategy)); }
void assertContainsExactly(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; assertIsArray(info, actual); assertIsArray(info, values); List<Object> actualAsList = asList(actual); IterableDiff diff = diff(actualAsList, asList(values), comparisonStrategy); if (!diff.differencesFound()) { // actual and values have the same elements but are they in the same order ? int arrayLength = sizeOf(actual); for (int i = 0; i < arrayLength; i++) { Object actualElement = Array.get(actual, i); Object expectedElement = Array.get(values, i); if (!areEqual(actualElement, expectedElement)) throw failures.failure(info, elementsDifferAtIndex(actualElement, expectedElement, i, comparisonStrategy)); } return; } throw failures.failure(info, shouldContainExactly(actual, asList(values), diff.missing, diff.unexpected, comparisonStrategy)); }
void assertContainsOnlyOnce(AssertionInfo info, Failures failures, Object actual, Object values) { if (commonChecks(info, actual, values)) return; Iterable<?> actualDuplicates = comparisonStrategy.duplicatesFrom(asList(actual)); Set<Object> notFound = new LinkedHashSet<Object>(); Set<Object> notOnlyOnce = new LinkedHashSet<Object>(); for (Object expectedElement : asList(values)) { if (!arrayContains(actual, expectedElement)) { notFound.add(expectedElement); } else if (iterableContains(actualDuplicates, expectedElement)) { notOnlyOnce.add(expectedElement); } } if (!notFound.isEmpty() || !notOnlyOnce.isEmpty()) throw failures.failure(info, shouldContainsOnlyOnce(actual, values, notFound, notOnlyOnce, comparisonStrategy)); // assertion succeeded }
static <T> void assertIsSortedAccordingToComparator(AssertionInfo info, Failures failures, Object array, Comparator<T> comparator) { assertNotNull(info, array); if (comparator == null) throw new NullPointerException("The given comparator should not be null"); try { List<T> arrayAsList = asList(array); // empty arrays are considered sorted even if comparator can't be applied to <T>. if (arrayAsList.size() == 0) return; if (arrayAsList.size() == 1) { // call compare to see if unique element is compatible with comparator. comparator.compare(arrayAsList.get(0), arrayAsList.get(0)); return; } for (int i = 0; i < arrayAsList.size() - 1; i++) { // array is sorted in comparator defined order iif element i is less or equal than element i+1 if (comparator.compare(arrayAsList.get(i), arrayAsList.get(i + 1)) > 0) throw failures.failure(info, shouldBeSortedAccordingToGivenComparator(i, array, comparator)); } } catch (ClassCastException e) { throw failures.failure(info, shouldHaveComparableElementsAccordingToGivenComparator(array, comparator)); } }