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

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

Source:Iterables.java

...595   */596  public void assertEndsWith(AssertionInfo info, Iterable<?> actual, Object[] sequence) {597    checkNotNullIterables(info, actual, sequence);598    int sizeOfActual = sizeOf(actual);599    if (sizeOfActual < sequence.length) throw actualDoesNotEndWithSequence(info, actual, sequence);600    int start = sizeOfActual - sequence.length;601    int sequenceIndex = 0, indexOfActual = 0;602    for (Object actualElement : actual) {603      if (indexOfActual++ < start) continue;604      if (areEqual(actualElement, sequence[sequenceIndex++])) continue;605      throw actualDoesNotEndWithSequence(info, actual, sequence);606    }607  }608  private boolean commonCheckThatIterableAssertionSucceeds(AssertionInfo info, Iterable<?> actual, Object[] sequence) {609    checkNotNullIterables(info, actual, sequence);610    // if both actual and values are empty, then assertion passes.611    if (!actual.iterator().hasNext() && sequence.length == 0) return true;612    failIfEmptySinceActualIsNotEmpty(sequence);613    return false;614  }615  private void checkNotNullIterables(AssertionInfo info, Iterable<?> actual, Object[] sequence) {616    checkIsNotNull(sequence);617    assertNotNull(info, actual);618  }619  /**620   * Asserts that the given {@code Iterable} contains at least a null element.621   * 622   * @param info contains information about the assertion.623   * @param actual the given {@code Iterable}.624   * @throws AssertionError if the given {@code Iterable} is {@code null}.625   * @throws AssertionError if the given {@code Iterable} does not contain at least a null element.626   */627  public void assertContainsNull(AssertionInfo info, Iterable<?> actual) {628    assertNotNull(info, actual);629    if (!iterableContains(actual, null)) throw failures.failure(info, shouldContainNull(actual));630  }631  /**632   * Asserts that the given {@code Iterable} does not contain null elements.633   * 634   * @param info contains information about the assertion.635   * @param actual the given {@code Iterable}.636   * @throws AssertionError if the given {@code Iterable} is {@code null}.637   * @throws AssertionError if the given {@code Iterable} contains a null element.638   */639  public void assertDoesNotContainNull(AssertionInfo info, Iterable<?> actual) {640    assertNotNull(info, actual);641    if (iterableContains(actual, null)) throw failures.failure(info, shouldNotContainNull(actual));642  }643  /**644   * Assert that each element of given {@code Iterable} satisfies the given condition.645   * 646   * @param info contains information about the assertion.647   * @param actual the given {@code Iterable}.648   * @param condition the given {@code Condition}.649   * @throws NullPointerException if the given condition is {@code null}.650   * @throws AssertionError if an element cannot be cast to E.651   * @throws AssertionError if one or more elements do not satisfy the given condition.652   */653  public <E> void assertAre(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) {654    assertNotNull(info, actual);655    conditions.assertIsNotNull(condition);656    try {657      List<E> notSatisfiesCondition = notSatisfyingCondition(actual, condition);658      if (!notSatisfiesCondition.isEmpty())659        throw failures.failure(info, elementsShouldBe(actual, notSatisfiesCondition, condition));660    } catch (ClassCastException e) {661      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));662    }663  }664  /**665   * Assert that each element of given {@code Iterable} not satisfies the given condition.666   * 667   * @param info contains information about the assertion.668   * @param actual the given {@code Iterable}.669   * @param condition the given {@code Condition}.670   * @throws NullPointerException if the given condition is {@code null}.671   * @throws AssertionError if an element cannot be cast to E.672   * @throws AssertionError if one or more elements satisfy the given condition.673   */674  public <E> void assertAreNot(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) {675    assertNotNull(info, actual);676    conditions.assertIsNotNull(condition);677    try {678      List<E> satisfiesCondition = satisfiesCondition(actual, condition);679      if (!satisfiesCondition.isEmpty())680        throw failures.failure(info, elementsShouldNotBe(actual, satisfiesCondition, condition));681    } catch (ClassCastException e) {682      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));683    }684  }685  /**686   * Assert that each element of given {@code Iterable} satisfies the given condition.687   * 688   * @param info contains information about the assertion.689   * @param actual the given {@code Iterable}.690   * @param condition the given {@code Condition}.691   * @throws NullPointerException if the given condition is {@code null}.692   * @throws AssertionError if an element cannot be cast to E.693   * @throws AssertionError if one or more elements do not satisfy the given condition.694   */695  public <E> void assertHave(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) {696    assertNotNull(info, actual);697    conditions.assertIsNotNull(condition);698    try {699      List<E> notSatisfiesCondition = notSatisfyingCondition(actual, condition);700      if (!notSatisfiesCondition.isEmpty())701        throw failures.failure(info, elementsShouldHave(actual, notSatisfiesCondition, condition));702    } catch (ClassCastException e) {703      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));704    }705  }706  /**707   * Assert that each element of given {@code Iterable} not satisfies the given condition.708   * 709   * @param info contains information about the assertion.710   * @param actual the given {@code Iterable}.711   * @param condition the given {@code Condition}.712   * @throws NullPointerException if the given condition is {@code null}.713   * @throws AssertionError if an element cannot be cast to E.714   * @throws AssertionError if one or more elements satisfy the given condition.715   */716  public <E> void assertDoNotHave(AssertionInfo info, Iterable<? extends E> actual, Condition<? super E> condition) {717    assertNotNull(info, actual);718    conditions.assertIsNotNull(condition);719    try {720      List<E> satisfiesCondition = satisfiesCondition(actual, condition);721      if (!satisfiesCondition.isEmpty())722        throw failures.failure(info, elementsShouldNotHave(actual, satisfiesCondition, condition));723    } catch (ClassCastException e) {724      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));725    }726  }727  /**728   * Assert that there are <b>at least</b> <i>n</i> elements in the actual {@code Iterable} satisfying the given729   * condition.730   * 731   * @param info contains information about the assertion.732   * @param actual the given {@code Iterable}.733   * @param times the minimum number of times the condition should be verified.734   * @param condition the given {@code Condition}.735   * @throws NullPointerException if the given condition is {@code null}.736   * @throws AssertionError if an element cannot be cast to E.737   * @throws AssertionError if the number of elements satisfying the given condition is &lt; n.738   */739  public <E> void assertAreAtLeast(AssertionInfo info, Iterable<? extends E> actual, int times,740                                   Condition<? super E> condition) {741    assertNotNull(info, actual);742    conditions.assertIsNotNull(condition);743    try {744      if (!conditionIsSatisfiedAtLeastNTimes(actual, times, condition))745        throw failures.failure(info, elementsShouldBeAtLeast(actual, times, condition));746    } catch (ClassCastException e) {747      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));748    }749  }750  private <E> boolean conditionIsSatisfiedAtLeastNTimes(Iterable<? extends E> actual, int n,751                                                        Condition<? super E> condition) {752    List<E> satisfiesCondition = satisfiesCondition(actual, condition);753    return satisfiesCondition.size() >= n;754  }755  /**756   * Assert that there are <b>at most</b> <i>n</i> elements in the actual {@code Iterable} satisfying the given757   * condition.758   * 759   * @param info contains information about the assertion.760   * @param actual the given {@code Iterable}.761   * @param n the number of times the condition should be at most verified.762   * @param condition the given {@code Condition}.763   * @throws NullPointerException if the given condition is {@code null}.764   * @throws AssertionError if an element cannot be cast to E.765   * @throws AssertionError if the number of elements satisfying the given condition is &gt; n.766   */767  public <E> void assertAreAtMost(AssertionInfo info, Iterable<? extends E> actual, int n,768                                  Condition<? super E> condition) {769    assertNotNull(info, actual);770    conditions.assertIsNotNull(condition);771    try {772      if (!conditionIsSatisfiedAtMostNTimes(actual, condition, n))773        throw failures.failure(info, elementsShouldBeAtMost(actual, n, condition));774    } catch (ClassCastException e) {775      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));776    }777  }778  private <E> boolean conditionIsSatisfiedAtMostNTimes(Iterable<? extends E> actual, Condition<? super E> condition,779                                                       int n) {780    List<E> satisfiesCondition = satisfiesCondition(actual, condition);781    return satisfiesCondition.size() <= n;782  }783  /**784   * Verifies that there are <b>exactly</b> <i>n</i> elements in the actual {@code Iterable} satisfying the given785   * condition.786   * 787   * @param info contains information about the assertion.788   * @param actual the given {@code Iterable}.789   * @param times the exact number of times the condition should be verified.790   * @param condition the given {@code Condition}.791   * @throws NullPointerException if the given condition is {@code null}.792   * @throws AssertionError if an element cannot be cast to E.793   * @throws AssertionError if the number of elements satisfying the given condition is &ne; n.794   */795  public <E> void assertAreExactly(AssertionInfo info, Iterable<? extends E> actual, int times,796                                   Condition<? super E> condition) {797    assertNotNull(info, actual);798    conditions.assertIsNotNull(condition);799    try {800      if (!conditionIsSatisfiedNTimes(actual, condition, times))801        throw failures.failure(info, elementsShouldBeExactly(actual, times, condition));802    } catch (ClassCastException e) {803      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));804    }805  }806  private <E> boolean conditionIsSatisfiedNTimes(Iterable<? extends E> actual, Condition<? super E> condition,807                                                 int times) {808    List<E> satisfiesCondition = satisfiesCondition(actual, condition);809    return satisfiesCondition.size() == times;810  }811  /**812   * An alias method of {@link #assertAreAtLeast(AssertionInfo, Iterable, int, Condition)} to provide a richer fluent813   * api (same logic, only error message differs).814   */815  public <E> void assertHaveAtLeast(AssertionInfo info, Iterable<? extends E> actual, int times,816                                    Condition<? super E> condition) {817    assertNotNull(info, actual);818    conditions.assertIsNotNull(condition);819    try {820      if (!conditionIsSatisfiedAtLeastNTimes(actual, times, condition))821        throw failures.failure(info, elementsShouldHaveAtLeast(actual, times, condition));822    } catch (ClassCastException e) {823      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));824    }825  }826  /**827   * An alias method of {@link #assertAreAtMost(AssertionInfo, Iterable, int, Condition)} to provide a richer fluent api828   * (same logic, only error message differs).829   */830  public <E> void assertHaveAtMost(AssertionInfo info, Iterable<? extends E> actual, int times,831                                   Condition<? super E> condition) {832    assertNotNull(info, actual);833    conditions.assertIsNotNull(condition);834    try {835      if (!conditionIsSatisfiedAtMostNTimes(actual, condition, times))836        throw failures.failure(info, elementsShouldHaveAtMost(actual, times, condition));837    } catch (ClassCastException e) {838      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));839    }840  }841  /**842   * An alias method of {@link #assertAreExactly(AssertionInfo, Iterable, int, Condition)} to provide a richer fluent843   * api (same logic, only error message differs).844   */845  public <E> void assertHaveExactly(AssertionInfo info, Iterable<? extends E> actual, int times,846                                    Condition<? super E> condition) {847    assertNotNull(info, actual);848    conditions.assertIsNotNull(condition);849    try {850      if (!conditionIsSatisfiedNTimes(actual, condition, times))851        throw failures.failure(info, elementsShouldHaveExactly(actual, times, condition));852    } catch (ClassCastException e) {853      throw failures.failure(info, shouldBeSameGenericBetweenIterableAndCondition(actual, condition));854    }855  }856  /**857   * Asserts that the given {@code Iterable} contains all the elements of the other {@code Iterable}, in any order.858   * 859   * @param info contains information about the assertion.860   * @param actual the given {@code Iterable}.861   * @param other the other {@code Iterable}.862   * @throws NullPointerException if {@code Iterable} is {@code null}.863   * @throws AssertionError if the given {@code Iterable} is {@code null}.864   * @throws AssertionError if the given {@code Iterable} does not contain all the elements of the other865   *           {@code Iterable}, in any order.866   */867  public void assertContainsAll(AssertionInfo info, Iterable<?> actual, Iterable<?> other) {868    if (other == null) throw iterableToLookForIsNull();869    assertNotNull(info, actual);870    Object[] values = newArrayList(other).toArray();871    assertIterableContainsGivenValues(actual, values, info);872  }873  /**874   * Asserts that the given {@code Iterable} contains exactly the given values and nothing else, <b>in order</b>.875   * 876   * @param info contains information about the assertion.877   * @param actual the given {@code Iterable}.878   * @param values the values that are expected to be in the given {@code Iterable} in order.879   * @throws NullPointerException if the array of values is {@code null}.880   * @throws AssertionError if the given {@code Iterable} is {@code null}.881   * @throws AssertionError if the given {@code Iterable} does not contain the given values or if the given882   *           {@code Iterable} contains values that are not in the given array, in order.883   */884  public void assertContainsExactly(AssertionInfo info, Iterable<?> actual, Object[] values) {885    checkIsNotNull(values);886    assertNotNull(info, actual);887    int actualSize = sizeOf(actual);888    if (values.length != actualSize)889      throw failures.failure(info, shouldHaveSameSize(actual, values, actualSize, values.length, comparisonStrategy));890    assertHasSameSizeAs(info, actual, values); // include check that actual is not null891    List<Object> actualAsList = newArrayList(actual);892    IterableDiff diff = diff(actualAsList, asList(values), comparisonStrategy);893    if (!diff.differencesFound()) {894      // actual and values have the same elements but are they in the same order ?895      int i = 0;896      for (Object elementFromActual : actual) {897        if (!areEqual(elementFromActual, values[i])) {898          throw failures.failure(info, elementsDifferAtIndex(elementFromActual, values[i], i, comparisonStrategy));899        }900        i++;901      }902      return;903    }904    throw failures.failure(info,905                           shouldContainExactly(actual, values, diff.missing, diff.unexpected, comparisonStrategy));906  }907  /**908   * Asserts that the given {@code Iterable} contains at least one of the given {@code values}.909   *910   * @param info contains information about the assertion.911   * @param actual the given {@code Iterable}.912   * @param values the values that, at least one of which is expected to be in the given {@code Iterable}.913   * @throws NullPointerException if the array of values is {@code null}.914   * @throws IllegalArgumentException if the array of values is empty and given {@code Iterable} is not empty.915   * @throws AssertionError if the given {@code Iterable} is {@code null}.916   * @throws AssertionError if the given {@code Iterable} does not contain any of given {@code values}.917   */918  public void assertContainsAnyOf(AssertionInfo info, Iterable<?> actual, Object[] values) {919    if (commonCheckThatIterableAssertionSucceeds(info, actual, values))920      return;921    Set<Object> valuesToSearchFor = newTreeSet(values);922    for (Object element : actual) {923      if (iterableContains(valuesToSearchFor, element)) return;924    }925    throw failures.failure(info, shouldContainAnyOf(actual, values, comparisonStrategy));926  }927  public void assertContainsExactlyInAnyOrder(AssertionInfo info, Iterable<?> actual, Object[] values) {928    checkIsNotNull(values);929    assertNotNull(info, actual);930    List<Object> notExpected = newArrayList(actual);931    List<Object> notFound = newArrayList(values);932    for (Object value : values) {933      if (iterableContains(notExpected, value)) {934        iterablesRemoveFirst(notExpected, value);935        iterablesRemoveFirst(notFound, value);936      }937    }938    if (notExpected.isEmpty() && notFound.isEmpty()) return;939    throw failures.failure(info,940                           shouldContainExactlyInAnyOrder(actual, values, notFound, notExpected, comparisonStrategy));941  }942  void assertNotNull(AssertionInfo info, Iterable<?> actual) {943    Objects.instance().assertNotNull(info, actual);944  }945  private AssertionError actualDoesNotEndWithSequence(AssertionInfo info, Iterable<?> actual, Object[] sequence) {946    return failures.failure(info, shouldEndWith(actual, sequence, comparisonStrategy));947  }948  private <E> List<E> notSatisfyingCondition(Iterable<? extends E> actual, Condition<? super E> condition) {949    List<E> notSatisfiesCondition = new LinkedList<>();950    for (E o : actual) {951      if (!condition.matches(o)) notSatisfiesCondition.add(o);952    }953    return notSatisfiesCondition;954  }955  private <E> List<E> satisfiesCondition(Iterable<? extends E> actual, Condition<? super E> condition) {956    List<E> satisfiesCondition = new LinkedList<>();957    for (E o : actual) {958      if (condition.matches(o)) satisfiesCondition.add(o);959    }...

actualDoesNotEndWithSequence

Using AI Code Generation

1import org.assertj.core.api.AbstractIterableAssert;2import org.assertj.core.internal.Iterables;3import org.assertj.core.internal.IterablesBaseTest;4import org.junit.jupiter.api.Test;5import java.util.List;6import static org.assertj.core.api.Assertions.assertThat;7import static org.assertj.core.test.TestData.someInfo;8import static org.assertj.core.util.Arrays.array;9import static org.mockito.Mockito.verify;10public class Iterables_doesNotEndWithSequence_Test extends IterablesBaseTest {11    protected void initActualArray() {12        actual = array("Luke", "Yoda", "Leia");13    }14    protected void initActualIterable() {15        actual = List.of("Luke", "Yoda", "Leia");16    }17    protected AbstractIterableAssert<?, ? extends Iterable<?>, Object, Object> invoke_api_method() {18        return assertions.doesNotEndWithSequence("Luke", "Yoda");19    }20    protected void verify_internal_effects() {21        verify(iterables).actualDoesNotEndWithSequence(getInfo(assertions), getActual(assertions), array("Luke", "Yoda"));22    }23    public void should_pass_if_actual_does_not_end_with_sequence() {24        assertThat(List.of("Luke", "Yoda", "Leia")).doesNotEndWithSequence("Yoda", "Leia", "Han");25    }26    public void should_fail_if_actual_ends_with_sequence() {27        assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(List.of("Luke", "Yoda", "Leia")).doesNotEndWithSequence("Yoda", "Leia"))28                                                       .withMessageContaining("[Yoda, Leia] does not end with [Yoda, Leia]");29    }30    public void should_fail_if_actual_ends_with_first_elements_of_sequence() {31        assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(List.of("Luke", "Yoda", "Leia")).doesNotEndWithSequence("Yoda", "Leia", "Luke"))32                                                       .withMessageContaining("[Yoda, Leia, Luke] does not end with [Yoda, Leia, Luke]");33    }34    public void should_fail_if_actual_and_sequence_are_equal() {

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.