/** * {@inheritDoc} * <p> * Example with byte array: * <pre><code class='java'> // assertions will pass * assertThat(new byte[]{1, 2}).hasSameSizeAs(new byte[]{2, 3}); * assertThat(new byte[]{1, 2}).hasSameSizeAs(new Byte[]{2, 3}); * assertThat(new byte[]{1, 2}).hasSameSizeAs(new int[]{2, 3}); * assertThat(new byte[]{1, 2}).hasSameSizeAs(new String[]{"1", "2"}); * * // assertion will fail * assertThat(new byte[]{ 1, 2 }).hasSameSizeAs(new byte[]{ 1, 2, 3 });</code></pre> */ @Override public SELF hasSameSizeAs(Object other) { assertIsArray(info, other); new Arrays().assertHasSameSizeAs(info, actual, other); return myself; }
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 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 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 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 assertIsSorted(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { // instead of comparing array elements with their natural comparator, use the one set by client. Comparator<?> comparator = ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator(); assertIsSortedAccordingToComparator(info, failures, array, comparator); return; } // empty arrays are considered sorted even if component type is not sortable. if (sizeOf(array) == 0) return; assertThatArrayComponentTypeIsSortable(info, failures, array); try { // sorted assertion is only relevant if array elements are Comparable // => we should be able to build a Comparable array Comparable<Object>[] comparableArray = arrayOfComparableItems(array); // array with 0 or 1 element are considered sorted. if (comparableArray.length <= 1) return; for (int i = 0; i < comparableArray.length - 1; i++) { // array is sorted in ascending order iif element i is less or equal than element i+1 if (comparableArray[i].compareTo(comparableArray[i + 1]) > 0) throw failures.failure(info, shouldBeSorted(i, array)); } } catch (ClassCastException e) { // elements are either not Comparable or not mutually Comparable (e.g. array with String and Integer) throw failures.failure(info, shouldHaveMutuallyComparableElements(array)); } }
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 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 assertContainsSubsequence(AssertionInfo info, Failures failures, Object actual, Object subsequence) { if (commonChecks(info, actual, subsequence)) return; int sizeOfActual = sizeOf(actual); int sizeOfSubsequence = sizeOf(subsequence); // look for given subsequence, stop check when there is not enough elements remaining in actual to contain // subsequence int lastIndexWhereEndOfSubsequenceCanBeFound = sizeOfActual - sizeOfSubsequence; int actualIndex = 0; int subsequenceIndex = 0; while (actualIndex <= lastIndexWhereEndOfSubsequenceCanBeFound && subsequenceIndex < sizeOfSubsequence) { if (areEqual(Array.get(actual, actualIndex), Array.get(subsequence, subsequenceIndex))) { subsequenceIndex++; lastIndexWhereEndOfSubsequenceCanBeFound++; } actualIndex++; } if (subsequenceIndex < sizeOfSubsequence) throw failures.failure(info, shouldContainSubsequence(actual, subsequence, comparisonStrategy)); }
void assertContainsNull(AssertionInfo info, Failures failures, Object array) { assertNotNull(info, array); if (!arrayContains(array, null)) throw failures.failure(info, shouldContainNull(array)); }
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 assertEndsWith(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 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 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)); }
@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 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 ByteArrays(ComparisonStrategy comparisonStrategy) { setArrays(new Arrays(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)); } }
/** * 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; }
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)); } }