Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use checkNotNullIterables method of org.assertj.core.internal.Iterables class

Best Assertj code snippet using org.assertj.core.internal.Iterables.checkNotNullIterables

Source:Iterables.java

...355  public void assertContainsOnly(AssertionInfo info, Iterable<?> actual, Object[] expectedValues) {356    final List<?> actualAsList = newArrayList(actual);357    // don't use commonCheckThatIterableAssertionSucceeds to get a better error message when actual is not empty and358    // expectedValues is359    checkNotNullIterables(info, actualAsList, expectedValues);360    // if both actual and values are empty, then assertion passes.361    if (actualAsList.isEmpty() && expectedValues.length == 0) return;362    // after the for loop, unexpected = expectedValues - actual363    List<Object> unexpectedValues = newArrayList(actualAsList);364    // after the for loop, missing = actual - expectedValues365    List<Object> missingValues = newArrayList(expectedValues);366    for (Object expected : expectedValues) {367      if (iterableContains(actualAsList, expected)) {368        // since expected was found in actual:369        // -- it does not belong to the missing elements370        iterablesRemove(missingValues, expected);371        // -- it does not belong to the unexpected elements372        iterablesRemove(unexpectedValues, expected);373      }374    }375    if (!unexpectedValues.isEmpty() || !missingValues.isEmpty()) {376      throw failures.failure(info, shouldContainOnly(actualAsList, expectedValues,377                                                     missingValues, unexpectedValues,378                                                     comparisonStrategy));379    }380  }381  /**382   * Asserts that the given {@code Iterable} contains the given values and only once.383   *384   * @param info contains information about the assertion.385   * @param actual the given {@code Iterable}.386   * @param values the values that are expected to be in the given {@code Iterable}.387   * @throws NullPointerException if the array of values is {@code null}.388   * @throws IllegalArgumentException if the array of values is empty.389   * @throws AssertionError if the given {@code Iterable} is {@code null}.390   * @throws AssertionError if the given {@code Iterable} does not contain the given values or if the given391   *           {@code Iterable} contains values that are not in the given array.392   */393  public void assertContainsOnlyOnce(AssertionInfo info, Iterable<?> actual, Object[] values) {394    if (commonCheckThatIterableAssertionSucceeds(info, actual, values)) return;395    // check for elements in values that are missing in actual.396    Set<Object> notFound = new LinkedHashSet<>();397    Set<Object> notOnlyOnce = new LinkedHashSet<>();398    Iterable<?> actualDuplicates = comparisonStrategy.duplicatesFrom(actual);399    for (Object expectedOnlyOnce : values) {400      if (!iterableContains(actual, expectedOnlyOnce)) {401        notFound.add(expectedOnlyOnce);402      } else if (iterableContains(actualDuplicates, expectedOnlyOnce)) {403        notOnlyOnce.add(expectedOnlyOnce);404      }405    }406    if (!notFound.isEmpty() || !notOnlyOnce.isEmpty())407      throw failures.failure(info, shouldContainsOnlyOnce(actual, values, notFound, notOnlyOnce, comparisonStrategy));408    // assertion succeeded409  }410  /**411   * Asserts that the given {@code Iterable} contains only null elements and nothing else.412   *413   * @param info contains information about the assertion.414   * @param actual the given {@code Iterable}.415   * @throws AssertionError if the given {@code Iterable} is {@code null}.416   * @throws AssertionError if the given {@code Iterable} does not contain at least a null element or if the given417   *           {@code Iterable} contains values that are not null elements.418   */419  public void assertContainsOnlyNulls(AssertionInfo info, Iterable<?> actual) {420    assertNotNull(info, actual);421    // empty => no null elements => failure422    if (sizeOf(actual) == 0) throw failures.failure(info, shouldContainOnlyNulls(actual));423    // look for any non null elements424    List<Object> nonNullElements = stream(actual).filter(java.util.Objects::nonNull).collect(toList());425    if (nonNullElements.size() > 0) throw failures.failure(info, shouldContainOnlyNulls(actual, nonNullElements));426  }427  /**428   * Verifies that the given <code>{@link Iterable}</code> contains the given sequence of objects, without any other429   * objects between them.430   *431   * @param info contains information about the assertion.432   * @param actual the given {@code Iterable}.433   * @param sequence the sequence of objects to look for.434   * @throws AssertionError if the given {@code Iterable} is {@code null}.435   * @throws NullPointerException if the given sequence is {@code null}.436   * @throws IllegalArgumentException if the given sequence is empty.437   * @throws AssertionError if the given {@code Iterable} does not contain the given sequence of objects.438   */439  public void assertContainsSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence) {440    // perform the checks that would have been done in commonCheckThatIterableAssertionSucceeds but do them explicitly without441    // having to create a new iterator on actual - which would break if actual were only singly-traversable.442    checkNotNullIterables(info, actual, sequence);443    // store the elements from actual that have been visited (because we don't know we can look ahead - the 'actual'444    // might be singly-traversable) in a fixed-length LIFO having what is in effect a sliding window.445    // So we store each element and slide for each new element until a match is found or until the 'actual' is446    // exhausted. Of course if 'actual' really is infinite then this could take a while :-D447    final Iterator<?> actualIterator = actual.iterator();448    if (!actualIterator.hasNext() && sequence.length == 0) return;449    failIfEmptySinceActualIsNotEmpty(sequence);450    // we only store sequence.length entries from actual in the LIFO, no need for more.451    Lifo lifo = new Lifo(sequence.length);452    while (actualIterator.hasNext()) {453      lifo.add(actualIterator.next());454      if (lifo.matchesExactly(sequence)) return;455    }456    throw actualDoesNotContainSequence(info, actual, sequence);457  }458  private class Lifo {459    private int maxSize;460    private LinkedList<Object> stack;461    Lifo(int maxSize) {462      this.maxSize = maxSize;463      stack = new LinkedList<>();464    }465    void add(final Object element) {466      if (stack.size() == maxSize) stack.removeFirst();467      stack.addLast(element);468    }469    boolean matchesExactly(Object[] sequence) {470      if (stack.size() != sequence.length) return false;471      for (int i = 0; i < sequence.length; i++) {472        if (!areEqual(stack.get(i), sequence[i])) return false;473      }474      return true;475    }476  }477  /**478   * Verifies that the given <code>{@link Iterable}</code> does not contain the given sequence of objects in order.479   *480   * @param info contains information about the assertion.481   * @param actual the given {@code Iterable}.482   * @param sequence the sequence of objects to look for.483   * @throws AssertionError if the given {@code Iterable} is {@code null}.484   * @throws NullPointerException if the given sequence is {@code null}.485   * @throws IllegalArgumentException if the given sequence is empty.486   * @throws AssertionError if the given {@code Iterable} does contain the given sequence of objects.487   */488  public void assertDoesNotContainSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence) {489    requireNonNull(sequence, nullSequence());490    checkIsNotEmptySequence(sequence);491    assertNotNull(info, actual);492    // check for elements in values that are missing in actual.493    List<?> actualAsList = newArrayList(actual);494    for (int index = 0; index < actualAsList.size(); index++) {495      // look for given sequence in actual starting from current index (i)496      if (containsSequenceAtGivenIndex(actualAsList, sequence, index)) {497        throw actualDoesContainSequence(info, actual, sequence, index);498      }499    }500  }501  /**502   * Verifies that the given <code>{@link Iterable}</code> contains the given subsequence of objects (possibly with503   * other values between them).504   *505   * @param info contains information about the assertion.506   * @param actual the given {@code Iterable}.507   * @param subsequence the subsequence of objects to look for.508   * @throws AssertionError if the given {@code Iterable} is {@code null}.509   * @throws NullPointerException if the given sequence is {@code null}.510   * @throws IllegalArgumentException if the given subsequence is empty.511   * @throws AssertionError if the given {@code Iterable} does not contain the given subsequence of objects.512   */513  public void assertContainsSubsequence(AssertionInfo info, Iterable<?> actual, Object[] subsequence) {514    if (commonCheckThatIterableAssertionSucceeds(info, actual, subsequence)) return;515    if (sizeOf(actual) < subsequence.length) {516      throw failures.failure(info, actualDoesNotHaveEnoughElementsToContainSubsequence(actual, subsequence));517    }518    Iterator<?> actualIterator = actual.iterator();519    int subsequenceIndex = 0;520    while (actualIterator.hasNext() && subsequenceIndex < subsequence.length) {521      Object actualNext = actualIterator.next();522      Object subsequenceNext = subsequence[subsequenceIndex];523      if (areEqual(actualNext, subsequenceNext)) subsequenceIndex++;524    }525    if (subsequenceIndex < subsequence.length) throw actualDoesNotContainSubsequence(info, actual, subsequence, subsequenceIndex);526  }527  /**528   * Verifies that the given <code>{@link Iterable}</code> does not contain the given subsequence of objects (possibly529   * with other values between them).530   *531   * @param info contains information about the assertion.532   * @param actual the given {@code Iterable}.533   * @param subsequence the subsequence of objects to look for.534   * @throws AssertionError if the given {@code Iterable} is {@code null}.535   * @throws NullPointerException if the given sequence is {@code null}.536   * @throws IllegalArgumentException if the given subsequence is empty.537   * @throws AssertionError if the given {@code Iterable} contains the given subsequence of objects.538   */539  public void assertDoesNotContainSubsequence(AssertionInfo info, Iterable<?> actual, Object[] subsequence) {540    requireNonNull(subsequence, nullSubsequence());541    checkIsNotEmptySubsequence(subsequence);542    assertNotNull(info, actual);543    int subsequenceIndex = 0;544    int subsequenceStartIndex = 0;545    List<?> actualAsList = newArrayList(actual);546    for (int index = 0; index < actualAsList.size(); index++) {547      Object actualNext = actualAsList.get(index);548      Object subsequenceNext = subsequence[subsequenceIndex];549      if (areEqual(actualNext, subsequenceNext)) {550        if (subsequenceIndex == 0) subsequenceStartIndex = index;551        subsequenceIndex++;552      }553      if (subsequenceIndex == subsequence.length) {554        throw actualContainsSubsequence(info, actual, subsequence, subsequenceStartIndex);555      }556    }557  }558  /**559   * Verifies that the actual <code>Iterable</code> is a subset of values <code>Iterable</code>. <br>560   * Both actual and given iterable are treated as sets, therefore duplicates on either of them are ignored.561   *562   * @param info contains information about the assertion.563   * @param actual the actual {@code Iterable}.564   * @param values the {@code Iterable} that should contain all actual elements.565   * @throws AssertionError if the actual {@code Iterable} is {@code null}.566   * @throws NullPointerException if the given Iterable is {@code null}.567   * @throws AssertionError if the actual {@code Iterable} is not subset of set <code>{@link Iterable}</code>568   */569  public void assertIsSubsetOf(AssertionInfo info, Iterable<?> actual, Iterable<?> values) {570    assertNotNull(info, actual);571    checkIterableIsNotNull(values);572    List<Object> extra = stream(actual).filter(actualElement -> !iterableContains(values, actualElement))573                                       .collect(toList());574    if (extra.size() > 0) throw failures.failure(info, shouldBeSubsetOf(actual, values, extra, comparisonStrategy));575  }576  /**577   * Return true if actualAsList contains exactly the given sequence at given starting index, false otherwise.578   *579   * @param actualAsList the list to look sequence in580   * @param sequence the sequence to look for581   * @param startingIndex the index of actual list at which we start looking for sequence.582   * @return true if actualAsList contains exactly the given sequence at given starting index, false otherwise.583   */584  private boolean containsSequenceAtGivenIndex(List<?> actualAsList, Object[] sequence, int startingIndex) {585    // check that, starting from given index, actualAsList has enough remaining elements to contain sequence586    if (actualAsList.size() - startingIndex < sequence.length) return false;587    for (int i = 0; i < sequence.length; i++) {588      if (!areEqual(actualAsList.get(startingIndex + i), sequence[i])) return false;589    }590    return true;591  }592  private boolean areEqual(Object actual, Object other) {593    return comparisonStrategy.areEqual(actual, other);594  }595  private AssertionError actualDoesNotContainSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence) {596    return failures.failure(info, shouldContainSequence(actual, sequence, comparisonStrategy));597  }598  private AssertionError actualDoesContainSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence, int index) {599    return failures.failure(info, shouldNotContainSequence(actual, sequence, index, comparisonStrategy));600  }601  private AssertionError actualDoesNotContainSubsequence(AssertionInfo info, Iterable<?> actual, Object[] subsequence,602                                                         int subsequenceIndex) {603    return failures.failure(info, shouldContainSubsequence(actual, subsequence, subsequenceIndex, comparisonStrategy));604  }605  private AssertionError actualContainsSubsequence(AssertionInfo info, Iterable<?> actual, Object[] subsequence,606                                                   int index) {607    return failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy, index));608  }609  /**610   * Asserts that the given {@code Iterable} does not contain the given values.611   *612   * @param info contains information about the assertion.613   * @param actual the given {@code Iterable}.614   * @param values the values that are expected not to be in the given {@code Iterable}.615   * @throws NullPointerException if the array of values is {@code null}.616   * @throws IllegalArgumentException if the array of values is empty.617   * @throws AssertionError if the given {@code Iterable} is {@code null}.618   * @throws AssertionError if the given {@code Iterable} contains any of given values.619   */620  public void assertDoesNotContain(AssertionInfo info, Iterable<?> actual, Object[] values) {621    checkIsNotNullAndNotEmpty(values);622    assertNotNull(info, actual);623    Set<Object> found = new LinkedHashSet<>();624    for (Object o : values) {625      if (iterableContains(actual, o)) found.add(o);626    }627    if (!found.isEmpty()) throw failures.failure(info, shouldNotContain(actual, values, found, comparisonStrategy));628  }629  /**630   * Asserts that the given {@code Iterable} does not contain the given values.631   *632   * @param <T> the type of actual elements633   * @param info contains information about the assertion.634   * @param actual the given {@code Iterable}.635   * @param iterable the values that are expected not to be in the given {@code Iterable}.636   * @throws NullPointerException if the array of values is {@code null}.637   * @throws IllegalArgumentException if the array of values is empty.638   * @throws AssertionError if the given {@code Iterable} is {@code null}.639   * @throws AssertionError if the given {@code Iterable} contains any of given values.640   */641  public <T> void assertDoesNotContainAnyElementsOf(AssertionInfo info, Iterable<? extends T> actual,642                                                    Iterable<? extends T> iterable) {643    checkIsNotNullAndNotEmpty(iterable);644    List<T> values = newArrayList(iterable);645    assertDoesNotContain(info, actual, values.toArray());646  }647  /**648   * Asserts that the given {@code Iterable} does not have duplicate values.649   *650   * @param info contains information about the assertion.651   * @param actual the given {@code Iterable}.652   * @throws NullPointerException if the array of values is {@code null}.653   * @throws IllegalArgumentException if the array of values is empty.654   * @throws AssertionError if the given {@code Iterable} is {@code null}.655   * @throws AssertionError if the given {@code Iterable} contains duplicate values.656   */657  public void assertDoesNotHaveDuplicates(AssertionInfo info, Iterable<?> actual) {658    assertNotNull(info, actual);659    Iterable<?> duplicates = comparisonStrategy.duplicatesFrom(actual);660    if (!isNullOrEmpty(duplicates))661      throw failures.failure(info, shouldNotHaveDuplicates(actual, duplicates, comparisonStrategy));662  }663  /**664   * Verifies that the given {@code Iterable} starts with the given sequence of objects, without any other objects665   * between them. Similar to <code>{@link #assertContainsSequence(AssertionInfo, Iterable, Object[])}</code>, but it666   * also verifies that the first element in the sequence is also the first element of the given {@code Iterable}.667   *668   * @param info contains information about the assertion.669   * @param actual the given {@code Iterable}.670   * @param sequence the sequence of objects to look for.671   * @throws NullPointerException if the given argument is {@code null}.672   * @throws IllegalArgumentException if the given argument is an empty array.673   * @throws AssertionError if the given {@code Iterable} is {@code null}.674   * @throws AssertionError if the given {@code Iterable} does not start with the given sequence of objects.675   */676  public void assertStartsWith(AssertionInfo info, Iterable<?> actual, Object[] sequence) {677    if (commonCheckThatIterableAssertionSucceeds(info, actual, sequence)) return;678    int i = 0;679    for (Object actualCurrentElement : actual) {680      if (i >= sequence.length) break;681      if (areEqual(actualCurrentElement, sequence[i++])) continue;682      throw actualDoesNotStartWithSequence(info, actual, sequence);683    }684    if (sequence.length > i) {685      // sequence has more elements than actual686      throw actualDoesNotStartWithSequence(info, actual, sequence);687    }688  }689  private AssertionError actualDoesNotStartWithSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence) {690    return failures.failure(info, shouldStartWith(actual, sequence, comparisonStrategy));691  }692  /**693   * Verifies that the given {@code Iterable} ends with the given sequence of objects, without any other objects between694   * them. Similar to <code>{@link #assertContainsSequence(AssertionInfo, Iterable, Object[])}</code>, but it also695   * verifies that the last element in the sequence is also the last element of the given {@code Iterable}.696   *697   * @param info contains information about the assertion.698   * @param actual the given {@code Iterable}.699   * @param first the first element of the end sequence.700   * @param rest the optional next elements of the end sequence.701   * @throws NullPointerException if the given argument is {@code null}.702   * @throws IllegalArgumentException if the given argument is an empty array.703   * @throws AssertionError if the given {@code Iterable} is {@code null}.704   * @throws AssertionError if the given {@code Iterable} does not end with the given sequence of objects.705   */706  public void assertEndsWith(AssertionInfo info, Iterable<?> actual, Object first, Object[] rest) {707    Object[] sequence = prepend(first, rest);708    assertEndsWith(info, actual, sequence);709  }710  /**711   * Verifies that the given {@code Iterable} ends with the given sequence of objects, without any other objects between712   * them. Similar to <code>{@link #assertContainsSequence(AssertionInfo, Iterable, Object[])}</code>, but it also713   * verifies that the last element in the sequence is also the last element of the given {@code Iterable}.714   *715   * @param info contains information about the assertion.716   * @param actual the given {@code Iterable}.717   * @param sequence the sequence of objects to look for.718   * @throws NullPointerException if the given argument is {@code null}.719   * @throws IllegalArgumentException if the given argument is an empty array.720   * @throws AssertionError if the given {@code Iterable} is {@code null}.721   * @throws AssertionError if the given {@code Iterable} does not end with the given sequence of objects.722   */723  public void assertEndsWith(AssertionInfo info, Iterable<?> actual, Object[] sequence) {724    checkNotNullIterables(info, actual, sequence);725    int sizeOfActual = sizeOf(actual);726    if (sizeOfActual < sequence.length) throw actualDoesNotEndWithSequence(info, actual, sequence);727    int start = sizeOfActual - sequence.length;728    int sequenceIndex = 0, indexOfActual = 0;729    for (Object actualElement : actual) {730      if (indexOfActual++ < start) continue;731      if (areEqual(actualElement, sequence[sequenceIndex++])) continue;732      throw actualDoesNotEndWithSequence(info, actual, sequence);733    }734  }735  private boolean commonCheckThatIterableAssertionSucceeds(AssertionInfo info, Iterable<?> actual, Object[] sequence) {736    checkNotNullIterables(info, actual, sequence);737    // if both actual and values are empty, then assertion passes.738    if (!actual.iterator().hasNext() && sequence.length == 0) return true;739    failIfEmptySinceActualIsNotEmpty(sequence);740    return false;741  }742  private void checkNotNullIterables(AssertionInfo info, Iterable<?> actual, Object[] sequence) {743    checkIsNotNull(sequence);744    assertNotNull(info, actual);745  }746  /**747   * Asserts that the given {@code Iterable} contains at least a null element.748   *749   * @param info contains information about the assertion.750   * @param actual the given {@code Iterable}.751   * @throws AssertionError if the given {@code Iterable} is {@code null}.752   * @throws AssertionError if the given {@code Iterable} does not contain at least a null element.753   */754  public void assertContainsNull(AssertionInfo info, Iterable<?> actual) {755    assertNotNull(info, actual);756    if (!iterableContains(actual, null)) throw failures.failure(info, shouldContainNull(actual));...

checkNotNullIterables

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.assertThatThrownBy;3import static org.assertj.core.api.Assertions.catchThrowable;4import static org.assertj.core.util.Lists.newArrayList;5import static org.assertj.core.util.Sets.newLinkedHashSet;6import static org.assertj.core.util.Sets.newTreeSet;7import static org.assertj.core.util.Sets.newHashSet;8import org.junit.jupiter.api.Test;9import java.util.ArrayList;10import java.util.Arrays;11import java.util.HashSet;12import java.util.List;13import java.util.Set;14import java.util.TreeSet;15import org.assertj.core.internal.Iterables;16public class Iterables_checkNotNullIterables_Test {17  Iterables iterables = new Iterables();18  public void should_pass_if_actual_is_empty() {19    List<?> actual = new ArrayList<>();20    List<?> other = newArrayList("Luke");21    iterables.checkNotNullIterables(actual, other);22  }23  public void should_pass_if_both_actual_and_other_are_null() {24    List<?> actual = null;25    List<?> other = null;26    iterables.checkNotNullIterables(actual, other);27  }28  public void should_pass_if_actual_is_null_and_other_is_empty() {29    List<?> actual = null;30    List<?> other = new ArrayList<>();31    iterables.checkNotNullIterables(actual, other);32  }33  public void should_pass_if_other_is_null_and_actual_is_empty() {34    List<?> actual = new ArrayList<>();35    List<?> other = null;36    iterables.checkNotNullIterables(actual, other);37  }38  public void should_pass_if_both_actual_and_other_are_empty() {39    List<?> actual = new ArrayList<>();40    List<?> other = new ArrayList<>();41    iterables.checkNotNullIterables(actual, other);42  }43  public void should_fail_if_actual_is_null_and_other_is_not_empty() {44    List<?> actual = null;45    List<?> other = newArrayList("Luke");46    assertThatThrownBy(() -> iterables.checkNotNullIterables(actual, other)).isInstanceOf(AssertionError.class);47  }48  public void should_fail_if_other_is_null_and_actual_is_not_empty() {49    List<?> actual = newArrayList("Luke");50    List<?> other = null;51    assertThatThrownBy(() -> iterables.checkNotNullIterables(actual, other)).isInstanceOf(AssertionError.class);52  }

checkNotNullIterables

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.assertThatThrownBy;3import static org.assertj.core.api.Assertions.catchThrowable;4import static org.assertj.core.error.ShouldNotContain.shouldNotContain;5import static org.assertj.core.util.Lists.list;6import static org.assertj.core.util.Sets.newLinkedHashSet;7import java.util.ArrayList;8import java.util.HashSet;9import java.util.List;10import java.util.Set;11import org.assertj.core.api.AbstractAssert;12import org.assertj.core.api.AbstractIterableAssert;13import org.assertj.core.api.Assertions;14import org.assertj.core.api.Condition;15import org.assertj.core.api.ObjectAssert;16import org.assertj.core.api.ObjectAssertFactory;17import org.assertj.core.api.ObjectArrayAssert;18import org.assertj.core.api.ObjectArrayAssertFactory;19import org.assertj.core.api.ObjectEnumerableAssert;20import org.assertj.core.api.ObjectEnumerableAssertFactory;21import org.assertj.core.api.ObjectGroupAssert;22import org.assertj.core.api.ObjectGroupAssertFactory;23import org.assertj.core.api.ObjectIterableAssert;24import org.assertj.core.api.ObjectIterableAssertFactory;25import org.assertj.core.api.ObjectListAssert;26import org.assertj.core.api.ObjectListAssertFactory;27import org.assertj.core.api.ObjectSetAssert;28import org.assertj.core.api.ObjectSetAssertFactory;29import org.assertj.core.api.ThrowableAssert;30import org.assertj.core.api.ThrowableAssert.ThrowingCallable;31import org.assertj.core.api.ThrowableAssertFactory;32import org.assertj.core.api.ThrowableAssertAlternative;33import org.assertj.core.api.ThrowableAssertAlternative.ThrowingCallable;34import org.assertj.core.api.ThrowableAssertAlternativeFactory;35import org.assertj.core.api.ThrowableAssertAlternativeFactory.ThrowingCallable;36import org.assertj.core.api.ThrowableAssertAlternativeWithMessage;37import org.assertj.core.api.ThrowableAssertAlternativeWithMessage.ThrowingCallable;38import org.assertj.core.api.ThrowableAssertAlternativeWithMessageFactory;39import org.assertj.core.api.ThrowableAssertAlternativeWithMessageFactory.ThrowingCallable;40import org.assertj.core.api.ThrowableAssertNoExpectedType;41import org.assertj.core.api.ThrowableAssertNoExpectedType.ThrowingCallable;42import org.assertj.core.api.ThrowableAssertNoExpectedTypeFactory;43import org.assertj.core.api.ThrowableAssertNoExpectedTypeFactory.ThrowingCallable;44import org.assertj.core.api.ThrowableAssertWithMessage;45import org.assertj.core.api.ThrowableAssertWithMessage.ThrowingCallable;46import org.assertj.core.api.ThrowableAssertWithMessageFactory;47import org.assertj.core.api.ThrowableAssertWithMessageFactory.ThrowingCallable;48import org.assertj.core.api.ThrowableAssert

checkNotNullIterables

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.util.Lists.newArrayList;3import java.util.List;4import org.junit.Test;5public class AssertJCheckNotNullIterablesTest {6	public void checkNotNullIterablesTest() {7		List<String> list = newArrayList("One", "Two", "Three");8		assertThat(list).isNotNull();9	}10}11AssertJ checkNotNullIterables() method example 212package com.journaldev.junit;13import static org.assertj.core.api.Assertions.assertThat;14import static org.assertj.core.util.Lists.newArrayList;15import java.util.List;16import org.junit.Test;17public class AssertJCheckNotNullIterablesTest {18	public void checkNotNullIterablesTest() {19		List<String> list = null;20		assertThat(list).isNotNull();21	}22}23AssertJ checkNotNullIterables() method example 324package com.journaldev.junit;25import static org.assertj.core.api.Assertions.assertThat;26import static org.assertj.core.util.Lists.newArrayList;27import java.util.List;28import org.junit.Test;29public class AssertJCheckNotNullIterablesTest {30	public void checkNotNullIterablesTest() {31		List<String> list = newArrayList("One", "Two", "Three");32		assertThat(list).isNotNull();33		list = null;34		assertThat(list).isNotNull();35	}36}37AssertJ checkNotNullIterables() method example 438package com.journaldev.junit;39import static org.assertj.core.api.Assertions.assertThat;40import static org.assertj.core.util.Lists.newArrayList;41import java.util.List;42import org.junit.Test

checkNotNullIterables

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.internal.Iterables;3import org.junit.Test;4public class TestIterables {5    public void testCheckNotNullIterables() {6        Iterables iterables = new Iterables();7        iterables.checkNotNullIterables(null, null);8    }9}10	at org.assertj.core.internal.Iterables.checkNotNullIterables(Iterables.java:65)11	at TestIterables.testCheckNotNullIterables(TestIterables.java:11)

checkNotNullIterables

Using AI Code Generation

1assertThat(people).usingElementComparatorOnFields("name", "age").containsOnly(2    new Person("Yoda", 800),3    new Person("Luke", 26),4    new Person("Leia", 26));5assertThat(people).usingElementComparatorOnFields("name", "age").containsOnlyElementsOf(6    newArrayList(new Person("Yoda", 800), new Person("Luke", 26), new Person("Leia", 26)));7assertThat(people).usingElementComparatorOnFields("name", "age").containsOnlyOnce(8    new Person("Yoda", 800),9    new Person("Luke", 26),10    new Person("Leia", 26));11assertThat(people).usingElementComparatorOnFields("name", "age").containsOnlyOnceElementsOf(12    newArrayList(new Person("Yoda", 800), new Person("Luke", 26), new Person("Leia", 26)));13assertThat(people).usingElementComparatorOnFields("name", "age").containsExactly(14    new Person("Yoda", 800),15    new Person("Luke", 26),16    new Person("Leia", 26));17assertThat(people).usingElementComparatorOnFields("name", "age").containsExactlyElementsOf(18    newArrayList(new Person("Yoda", 800), new Person("Luke", 26), new Person("Leia", 26)));19assertThat(people).usingElementComparatorOnFields("name", "age").containsExactlyInAnyOrder(20    new Person("Yoda", 800),21    new Person("Luke", 26),22    new Person("Leia", 26));23assertThat(people).usingElementComparatorOnFields("name", "age").containsExactlyInAnyOrderElements

checkNotNullIterables

Using AI Code Generation

1public void should_pass_if_actual_contains_all_given_values() {2  iterables.assertContainsAll(someInfo(), actual, Arrays.asList("Luke", "Yoda"));3}4public void should_fail_if_actual_is_null() {5  thrown.expectAssertionError(actualIsNull());6  iterables.assertContainsAll(someInfo(), null, Arrays.asList("Yoda"));7}8public void should_fail_if_given_values_are_null() {9  thrown.expectNullPointerException(valuesToLookForIsNull());10  iterables.assertContainsAll(someInfo(), actual, null);11}12public void should_fail_if_given_values_are_empty() {13  thrown.expectIllegalArgumentException(valuesToLookForIsEmpty());14  iterables.assertContainsAll(someInfo(), actual, emptyList());15}16public void should_fail_if_actual_does_not_contain_all_given_values() {17  AssertionInfo info = someInfo();18  List<String> expected = Arrays.asList("Luke", "Yoda", "Han");19  try {20    iterables.assertContainsAll(info, actual, expected);21  } catch (AssertionError e) {22    verify(failures).failure(info, shouldContainAll(actual, expected));23    return;24  }25  failBecauseExpectedAssertionErrorWasNotThrown();26}27public void should_fail_if_actual_contains_all_given_values_but_in_different_order() {28  AssertionInfo info = someInfo();29  List<String> expected = Arrays.asList("Yoda", "Luke");30  try {31    iterables.assertContainsAll(info, actual, expected);32  } catch (AssertionError e) {33    verify(failures).failure(info, shouldContainAll(actual, expected));34    return;35  }36  failBecauseExpectedAssertionErrorWasNotThrown();37}38public void should_fail_if_actual_contains_duplicates_and_expected_does_not() {39  AssertionInfo info = someInfo();40  actual.addAll(Arrays.asList("Luke", "Yoda"));

checkNotNullIterables

Using AI Code Generation

1package org.assertj.core.internal;2import static org.assertj.core.util.IterableUtil.sizeOf;3import static org.assertj.core.util.Preconditions.checkNotNull;4import static org.assertj.core.util.Preconditions.checkNotNullIterables;5import static org.assertj.core.util.Preconditions.checkNoNullElements;6import java.util.ArrayList;7import java.util.Arrays;8import java.util.Collection;9import java.util.Collections;10import java.util.Comparator;11import java.util.HashSet;12import java.util.List;13import java.util.Set;14import org.assertj.core.api.AssertionInfo;15import org.assertj.core.api.filter.Filters;16import org.assertj.core.data.Index;17import org.assertj.core.error.ShouldContain;18import org.assertj.core.error.ShouldContainAtIndex;19import org.assertj.core.error.ShouldContainOnly;20import org.assertj.core.error.ShouldContainSequence;21import org.assertj.core.error.ShouldContainSubsequence;22import org.assertj.core.error.ShouldEndWith;23import org.assertj.core.error.ShouldHaveSameSizeAs;24import org.assertj.core.error.ShouldHaveSameSizeAsActual;25import org.assertj.core.error.ShouldHaveSameSizeAsArray;26import org.assertj.core.error.ShouldHaveSameSizeAsIterable;27import org.assertj.core.error.ShouldHaveSameSizeAsMap;28import org.assertj.core.error.ShouldHaveSameSizeAsMultimap;29import org.assertj.core.error.ShouldHaveSameSizeAsMultiset;30import org.assertj.core.error.ShouldHaveSameSizeAsQueue;31import org.assertj.core.error.ShouldHaveSameSizeAsSet;32import org.assertj.core.error.ShouldHaveSameSizeAsStack;33import org.assertj.core.error.ShouldHaveSameSizeAsValues;34import org.assertj.core.error.ShouldHaveSize;35import org.assertj.core.error.ShouldHaveSizeGreaterThanOrEqualTo;36import org.assertj.core.error.ShouldHaveSizeLessThanOrEqualTo;37import org.assertj.core.error.ShouldHaveSizeWithin;38import org.assertj.core.error.ShouldNotContain;39import org.assertj.core.error.ShouldNotContainAtIndex;40import org.assertj.core.error.ShouldNotContainNull;41import org.assertj.core.error.ShouldNotHaveDuplicates;42import org.assertj.core.error.ShouldNotHaveSameSizeAs;43import org.assertj.core.error.ShouldNotHaveSameSizeAsActual;44import org.assertj.core.error.ShouldNotHaveSameSizeAsArray;45import org.assertj.core.error.ShouldNotHaveSameSizeAsIterable;46import org.assertj.core.error.ShouldNotHaveSameSizeAsMap;47import org.assertj.core.error.ShouldNotHaveSameSizeAsMultimap;48import org.assertj.core.error.ShouldNotHaveSameSizeAsMultiset;49import org.assertj.core

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.