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

Copied to Clipboard!

How to use commonChecks method of org.assertj.core.internal.Arrays class

Best Assertj code snippet using org.assertj.core.internal.Arrays.commonChecks

Source:Arrays.java

...142    hasSameSizeAsCheck(info, array, other, sizeOf(array));143  }144  @VisibleForTesting145  public void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {146    if (commonChecks(info, actual, values)) return;147    Set<Object> notFound = new LinkedHashSet<>();148    int valueCount = sizeOf(values);149    for (int i = 0; i < valueCount; i++) {150      Object value = Array.get(values, i);151      if (!arrayContains(actual, value)) notFound.add(value);152    }153    if (!notFound.isEmpty())154      throw failures.failure(info, shouldContain(actual, values, notFound, comparisonStrategy));155  }156  void assertcontainsAll(AssertionInfo info, Failures failures, Object array, Iterable<?> iterable) {157    if (iterable == null) throw iterableToLookForIsNull();158    assertNotNull(info, array);159    Object[] values = newArrayList(iterable).toArray();160    Set<Object> notFound = new LinkedHashSet<>();161    for (Object value : values) {162      if (!arrayContains(array, value)) notFound.add(value);163    }164    if (!notFound.isEmpty())165      throw failures.failure(info, shouldContain(array, values, notFound, comparisonStrategy));166  }167  void assertContains(AssertionInfo info, Failures failures, Object array, Object value, Index index) {168    assertNotNull(info, array);169    assertNotEmpty(info, failures, array);170    checkIndexValueIsValid(index, sizeOf(array) - 1);171    Object actualElement = Array.get(array, index.value);172    if (!areEqual(actualElement, value))173      throw failures.failure(info, shouldContainAtIndex(array, value, index, Array.get(array, index.value),174                                                        comparisonStrategy));175  }176  void assertNotEmpty(AssertionInfo info, Failures failures, Object array) {177    assertNotNull(info, array);178    if (isArrayEmpty(array)) throw failures.failure(info, shouldNotBeEmpty());179  }180  void assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object value, Index index) {181    assertNotNull(info, array);182    checkIndexValueIsValid(index, Integer.MAX_VALUE);183    if (index.value >= sizeOf(array)) return;184    if (areEqual(Array.get(array, index.value), value))185      throw failures.failure(info, shouldNotContainAtIndex(array, value, index, comparisonStrategy));186  }187  void assertContainsOnly(AssertionInfo info, Failures failures, Object actual, Object values) {188    if (commonChecks(info, actual, values)) return;189    List<Object> notExpected = asList(actual);190    List<Object> notFound = asList(values);191    for (Object value : asList(values)) {192      if (iterableContains(notExpected, value)) {193        iterableRemoves(notExpected, value);194        iterableRemoves(notFound, value);195      }196    }197    if (!notExpected.isEmpty() || !notFound.isEmpty()) {198      throw failures.failure(info, shouldContainOnly(actual, values,199                                                     notFound, notExpected,200                                                     comparisonStrategy));201    }202  }203  void assertContainsOnlyNulls(AssertionInfo info, Failures failures, Object[] actual) {204    assertNotNull(info, actual);205    // empty => no null elements => failure206    if (actual.length == 0) throw failures.failure(info, shouldContainOnlyNulls(actual));207    // look for any non null elements208    List<Object> nonNullElements = new ArrayList<>();209    for (Object element : actual) {210      if (element != null) nonNullElements.add(element);211    }212    if (nonNullElements.size() > 0) throw failures.failure(info, shouldContainOnlyNulls(actual, nonNullElements));213  }214  void assertContainsExactly(AssertionInfo info, Failures failures, Object actual, Object values) {215    if (commonChecks(info, actual, values)) return;216    assertIsArray(info, actual);217    assertIsArray(info, values);218    int actualSize = sizeOf(actual);219    int expectedSize = sizeOf(values);220    if (actualSize != expectedSize)221      throw failures.failure(info, shouldHaveSameSize(actual, values, actualSize, expectedSize, comparisonStrategy));222    List<Object> actualAsList = asList(actual);223    IterableDiff diff = diff(actualAsList, asList(values), comparisonStrategy);224    if (!diff.differencesFound()) {225      // actual and values have the same elements but are they in the same order ?226      int arrayLength = sizeOf(actual);227      for (int i = 0; i < arrayLength; i++) {228        Object actualElement = Array.get(actual, i);229        Object expectedElement = Array.get(values, i);230        if (!areEqual(actualElement, expectedElement))231          throw failures.failure(info, elementsDifferAtIndex(actualElement, expectedElement, i, comparisonStrategy));232      }233      return;234    }235    throw failures.failure(info,236                           shouldContainExactly(actual, values, diff.missing, diff.unexpected, comparisonStrategy));237  }238  void assertContainsExactlyInAnyOrder(AssertionInfo info, Failures failures, Object actual, Object values) {239    if (commonChecks(info, actual, values)) return;240    List<Object> notExpected = asList(actual);241    List<Object> notFound = asList(values);242    for (Object value : asList(values)) {243      if (iterableContains(notExpected, value)) {244        iterablesRemoveFirst(notExpected, value);245        iterablesRemoveFirst(notFound, value);246      }247    }248    if (notExpected.isEmpty() && notFound.isEmpty()) return;249    throw failures.failure(info,250                           shouldContainExactlyInAnyOrder(actual, values, notFound, notExpected, comparisonStrategy));251  }252  void assertContainsOnlyOnce(AssertionInfo info, Failures failures, Object actual, Object values) {253    if (commonChecks(info, actual, values))254      return;255    Iterable<?> actualDuplicates = comparisonStrategy.duplicatesFrom(asList(actual));256    Set<Object> notFound = new LinkedHashSet<>();257    Set<Object> notOnlyOnce = new LinkedHashSet<>();258    for (Object expectedElement : asList(values)) {259      if (!arrayContains(actual, expectedElement)) {260        notFound.add(expectedElement);261      } else if (iterableContains(actualDuplicates, expectedElement)) {262        notOnlyOnce.add(expectedElement);263      }264    }265    if (!notFound.isEmpty() || !notOnlyOnce.isEmpty())266      throw failures.failure(info, shouldContainsOnlyOnce(actual, values, notFound, notOnlyOnce, comparisonStrategy));267    // assertion succeeded268  }269  /**270   * Delegates to {@link ComparisonStrategy#iterableContains(Iterable, Object)}271   */272  private boolean iterableContains(Iterable<?> actual, Object value) {273    return comparisonStrategy.iterableContains(actual, value);274  }275  private void iterablesRemoveFirst(Collection<?> actual, Object value) {276    comparisonStrategy.iterablesRemoveFirst(actual, value);277  }278  /**279   * Delegates to {@link ComparisonStrategy#iterableRemoves(Iterable, Object)}280   */281  private void iterableRemoves(Collection<?> actual, Object value) {282    comparisonStrategy.iterableRemoves(actual, value);283  }284  void assertContainsSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) {285    if (commonChecks(info, actual, sequence)) return;286    // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence287    int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence);288    for (int actualIndex = 0; actualIndex <= lastIndexWhereSequenceCanBeFound; actualIndex++) {289      if (containsSequenceAtGivenIndex(actualIndex, actual, sequence)) return;290    }291    throw failures.failure(info, shouldContainSequence(actual, sequence, comparisonStrategy));292  }293  void assertDoesNotContainSequence(AssertionInfo info, Failures failures, Object actual, Object sequence) {294    if (commonChecks(info, actual, sequence)) return;295    // look for given sequence, stop check when there are not enough elements remaining in actual to contain sequence296    int lastIndexWhereSequenceCanBeFound = sizeOf(actual) - sizeOf(sequence);297    for (int actualIndex = 0; actualIndex <= lastIndexWhereSequenceCanBeFound; actualIndex++) {298      if (containsSequenceAtGivenIndex(actualIndex, actual, sequence)) {299        throw failures.failure(info, shouldNotContainSequence(actual, sequence, actualIndex, comparisonStrategy));300      }301    }302  }303  /**304   * Return true if actualArray contains exactly the given sequence at given starting index, false otherwise.305   * 306   * 307   * @param actualStartIndex the index to start looking for sequence in actualArray308   * @param actualArray the actual array to search sequence in309   * @param sequence the sequence to look for310   * @return true if actualArray contains exactly the given sequence at given starting index, false otherwise.311   */312  private boolean containsSequenceAtGivenIndex(int actualStartIndex, Object actualArray, Object sequence) {313    int sequenceSize = sizeOf(sequence);314    for (int i = 0; i < sequenceSize; i++) {315      if (areEqual(Array.get(sequence, i), Array.get(actualArray, i + actualStartIndex)))316        continue;317      return false;318    }319    return true;320  }321  void assertContainsSubsequence(AssertionInfo info, Failures failures, Object actual, Object subsequence) {322    if (commonChecks(info, actual, subsequence)) return;323    int sizeOfActual = sizeOf(actual);324    int sizeOfSubsequence = sizeOf(subsequence);325    // look for given subsequence, stop check when there is not enough elements remaining in actual to contain326    // subsequence327    int lastIndexWhereEndOfSubsequenceCanBeFound = sizeOfActual - sizeOfSubsequence;328    int actualIndex = 0;329    int subsequenceIndex = 0;330    while (actualIndex <= lastIndexWhereEndOfSubsequenceCanBeFound && subsequenceIndex < sizeOfSubsequence) {331      if (areEqual(Array.get(actual, actualIndex), Array.get(subsequence, subsequenceIndex))) {332        subsequenceIndex++;333        lastIndexWhereEndOfSubsequenceCanBeFound++;334      }335      actualIndex++;336    }337    if (subsequenceIndex < sizeOfSubsequence)338      throw failures.failure(info, shouldContainSubsequence(actual, subsequence, comparisonStrategy));339  }340  void assertHasOnlyElementsOfTypes(AssertionInfo info, Failures failures, Object actual, Class<?>[] expectedTypes) {341    checkIsNotNull(expectedTypes);342    assertNotNull(info, actual);343    List<Object> nonMatchingElements = newArrayList();344    for (Object value : asList(actual)) {345      boolean matching = false;346      for (Class<?> expectedType : expectedTypes) {347        if (expectedType.isInstance(value)) matching = true;348      }349      if (!matching) nonMatchingElements.add(value);350    }351    if (!nonMatchingElements.isEmpty()) {352      throw failures.failure(info, shouldOnlyHaveElementsOfTypes(actual, expectedTypes, nonMatchingElements));353    }354  }355  void assertDoesNotContainSubsequence(AssertionInfo info, Failures failures, Object actual, Object subsequence) {356    if (commonChecks(info, actual, subsequence)) return;357    int sizeOfActual = sizeOf(actual);358    int sizeOfSubsequence = sizeOf(subsequence);359    // look for given subsequence, stop check when there is not enough elements remaining in actual to contain360    // subsequence361    int lastIndexWhereEndOfSubsequenceCanBeFound = sizeOfActual - sizeOfSubsequence;362    int actualIndex = 0;363    int subsequenceIndex = 0;364    int subsequenceStartIndex = 0;365    while (actualIndex <= lastIndexWhereEndOfSubsequenceCanBeFound && subsequenceIndex < sizeOfSubsequence) {366      if (areEqual(Array.get(actual, actualIndex), Array.get(subsequence, subsequenceIndex))) {367        if (subsequenceIndex == 0) {368          subsequenceStartIndex = actualIndex;369        }370        subsequenceIndex++;371        lastIndexWhereEndOfSubsequenceCanBeFound++;372      }373      actualIndex++;374      if (subsequenceIndex == sizeOfSubsequence) {375        throw failures.failure(info, shouldNotContainSubsequence(actual, subsequence, comparisonStrategy,376                                                                 subsequenceStartIndex));377      }378    }379  }380  /**381   * Delegates to {@link ComparisonStrategy#areEqual(Object, Object)}382   */383  private boolean areEqual(Object actual, Object other) {384    return comparisonStrategy.areEqual(actual, other);385  }386  void assertDoesNotContain(AssertionInfo info, Failures failures, Object array, Object values) {387    checkIsNotNullAndNotEmpty(values);388    assertNotNull(info, array);389    Set<Object> found = new LinkedHashSet<>();390    int valuesSize = sizeOf(values);391    for (int i = 0; i < valuesSize; i++) {392      Object value = Array.get(values, i);393      if (arrayContains(array, value)) found.add(value);394    }395    if (!found.isEmpty()) throw failures.failure(info, shouldNotContain(array, values, found, comparisonStrategy));396  }397  /**398   * Delegates to {@link ComparisonStrategy#arrayContains(Object, Object)}399   */400  private boolean arrayContains(Object array, Object value) {401    return comparisonStrategy.arrayContains(array, value);402  }403  void assertDoesNotHaveDuplicates(AssertionInfo info, Failures failures, Object array) {404    assertNotNull(info, array);405    ArrayWrapperList wrapped = wrap(array);406    Iterable<?> duplicates = comparisonStrategy.duplicatesFrom(wrapped);407    if (!isNullOrEmpty(duplicates))408      throw failures.failure(info, shouldNotHaveDuplicates(array, duplicates, comparisonStrategy));409  }410  void assertStartsWith(AssertionInfo info, Failures failures, Object actual, Object sequence) {411    if (commonChecks(info, actual, sequence))412      return;413    int sequenceSize = sizeOf(sequence);414    int arraySize = sizeOf(actual);415    if (arraySize < sequenceSize) throw arrayDoesNotStartWithSequence(info, failures, actual, sequence);416    for (int i = 0; i < sequenceSize; i++) {417      if (!areEqual(Array.get(sequence, i), Array.get(actual, i)))418        throw arrayDoesNotStartWithSequence(info, failures, actual, sequence);419    }420  }421  private static boolean commonChecks(AssertionInfo info, Object actual, Object sequence) {422    checkNulls(info, actual, sequence);423    // if both actual and values are empty arrays, then assertion passes.424    if (isArrayEmpty(actual) && isArrayEmpty(sequence)) return true;425    failIfEmptySinceActualIsNotEmpty(sequence);426    return false;427  }428  private static void checkNulls(AssertionInfo info, Object actual, Object sequence) {429    checkIsNotNull(sequence);430    assertNotNull(info, actual);431  }432  private AssertionError arrayDoesNotStartWithSequence(AssertionInfo info, Failures failures, Object array,433                                                       Object sequence) {434    return failures.failure(info, shouldStartWith(array, sequence, comparisonStrategy));435  }436  void assertEndsWith(AssertionInfo info, Failures failures, Object actual, Object first, Object[] rest) {437    Object[] sequence = prepend(first, rest);438    assertEndsWith(info, failures, actual, sequence);439  }440  void assertEndsWith(AssertionInfo info, Failures failures, Object actual, Object sequence) {441    checkNulls(info, actual, sequence);442    int sequenceSize = sizeOf(sequence);443    int arraySize = sizeOf(actual);444    if (arraySize < sequenceSize) throw arrayDoesNotEndWithSequence(info, failures, actual, sequence);445    for (int i = 0; i < sequenceSize; i++) {446      int sequenceIndex = sequenceSize - (i + 1);447      int arrayIndex = arraySize - (i + 1);448      if (!areEqual(Array.get(sequence, sequenceIndex), Array.get(actual, arrayIndex)))449        throw arrayDoesNotEndWithSequence(info, failures, actual, sequence);450    }451  }452  public void assertIsSubsetOf(AssertionInfo info, Failures failures, Object actual, Iterable<?> values) {453    assertNotNull(info, actual);454    checkIterableIsNotNull(info, values);455    List<Object> extra = newArrayList();456    int sizeOfActual = sizeOf(actual);457    for (int i = 0; i < sizeOfActual; i++) {458      Object actualElement = Array.get(actual, i);459      if (!iterableContains(values, actualElement)) {460        extra.add(actualElement);461      }462    }463    if (extra.size() > 0) {464      throw failures.failure(info, shouldBeSubsetOf(actual, values, extra, comparisonStrategy));465    }466  }467  void assertContainsNull(AssertionInfo info, Failures failures, Object array) {468    assertNotNull(info, array);469    if (!arrayContains(array, null)) throw failures.failure(info, shouldContainNull(array));470  }471  void assertDoesNotContainNull(AssertionInfo info, Failures failures, Object array) {472    assertNotNull(info, array);473    if (arrayContains(array, null)) throw failures.failure(info, shouldNotContainNull(array));474  }475  public <E> void assertAre(AssertionInfo info, Failures failures, Conditions conditions, Object array,476                            Condition<E> condition) {477    List<E> notMatchingCondition = getElementsNotMatchingCondition(info, failures, conditions, array, condition);478    if (!notMatchingCondition.isEmpty())479      throw failures.failure(info, elementsShouldBe(array, notMatchingCondition, condition));480  }481  public <E> void assertAreNot(AssertionInfo info, Failures failures, Conditions conditions, Object array,482                               Condition<E> condition) {483    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);484    if (!matchingElements.isEmpty())485      throw failures.failure(info, elementsShouldNotBe(array, matchingElements, condition));486  }487  public <E> void assertHave(AssertionInfo info, Failures failures, Conditions conditions, Object array,488                             Condition<E> condition) {489    List<E> notMatchingCondition = getElementsNotMatchingCondition(info, failures, conditions, array, condition);490    if (!notMatchingCondition.isEmpty())491      throw failures.failure(info, elementsShouldHave(array, notMatchingCondition, condition));492  }493  public <E> void assertHaveNot(AssertionInfo info, Failures failures, Conditions conditions, Object array,494                                Condition<E> condition) {495    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);496    if (!matchingElements.isEmpty())497      throw failures.failure(info, elementsShouldNotHave(array, matchingElements, condition));498  }499  public <E> void assertAreAtLeast(AssertionInfo info, Failures failures, Conditions conditions, Object array,500                                   int times, Condition<E> condition) {501    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);502    if (matchingElements.size() < times)503      throw failures.failure(info, elementsShouldBeAtLeast(array, times, condition));504  }505  public <E> void assertAreAtMost(AssertionInfo info, Failures failures, Conditions conditions, Object array,506                                  int times, Condition<E> condition) {507    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);508    if (matchingElements.size() > times) throw failures.failure(info, elementsShouldBeAtMost(array, times, condition));509  }510  public <E> void assertAreExactly(AssertionInfo info, Failures failures, Conditions conditions, Object array,511                                   int times, Condition<E> condition) {512    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);513    if (matchingElements.size() != times)514      throw failures.failure(info, elementsShouldBeExactly(array, times, condition));515  }516  public <E> void assertHaveAtLeast(AssertionInfo info, Failures failures, Conditions conditions, Object array,517                                    int times, Condition<E> condition) {518    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);519    if (matchingElements.size() < times)520      throw failures.failure(info, elementsShouldHaveAtLeast(array, times, condition));521  }522  public <E> void assertHaveAtMost(AssertionInfo info, Failures failures, Conditions conditions, Object array,523                                   int times, Condition<E> condition) {524    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);525    if (matchingElements.size() > times)526      throw failures.failure(info, elementsShouldHaveAtMost(array, times, condition));527  }528  public <E> void assertHaveExactly(AssertionInfo info, Failures failures, Conditions conditions, Object array,529                                    int times, Condition<E> condition) {530    List<E> matchingElements = getElementsMatchingCondition(info, failures, conditions, array, condition);531    if (matchingElements.size() != times)532      throw failures.failure(info, elementsShouldHaveExactly(array, times, condition));533  }534  public void assertContainsAnyOf(AssertionInfo info, Failures failures, Object actual, Object values) {535    if (commonChecks(info, actual, values)) return;536    assertIsArray(info, actual);537    assertIsArray(info, values);538    List<Object> valuesToSearchFor = asList(values);539    for (Object element : asList(actual)) {540      if (iterableContains(valuesToSearchFor, element)) return;541    }542    throw failures.failure(info, shouldContainAnyOf(actual, values, comparisonStrategy));543  }544  private <E> List<E> getElementsMatchingCondition(AssertionInfo info, Failures failures, Conditions conditions,545                                                   Object array, Condition<E> condition) {546    return filterElements(info, failures, conditions, array, condition, false);547  }548  private <E> List<E> getElementsNotMatchingCondition(AssertionInfo info, Failures failures, Conditions conditions,549                                                      Object array, Condition<E> condition) {...

commonChecks

Using AI Code Generation

1package org.assertj.core.api;2import org.assertj.core.internal.Arrays;3import org.assertj.core.internal.Objects;4import org.assertj.core.util.VisibleForTesting;5import static org.assertj.core.error.ShouldBeEmpty.shouldBeEmpty;6import static org.assertj.core.error.ShouldBeNullOrEmpty.shouldBeNullOrEmpty;7import static org.assertj.core.error.ShouldContain.shouldContain;8import static org.assertj.core.error.ShouldContainAtIndex.shouldContainAtIndex;9import static org.assertj.core.error.ShouldContainNull.shouldContainNull;10import static org.assertj.core.error.ShouldContainOnly.shouldContainOnly;11import static org.assertj.core.error.ShouldContainSequence.shouldContainSequence;12import static org.assertj.core.error.ShouldEndWith.shouldEndWith;13import static org.assertj.core.error.ShouldHaveSameSizeAs.shouldHaveSameSizeAs;14import static org.assertj.core.error.ShouldHaveSize.shouldHaveSize;15import static org.assertj.core.error.ShouldNotBeEmpty.shouldNotBeEmpty;16import static org.assertj.core.error.ShouldNotContain.shouldNotContain;17import static org.assertj.core.error.ShouldNotContainNull.shouldNotContainNull;18import static org.assertj.core.error.ShouldNotContainSequence.shouldNotContainSequence;19import static org.assertj.core.error.ShouldNotHaveDuplicates.shouldNotHaveDuplicates;20import static org.assertj.core.error.ShouldNotHaveSameSizeAs.shouldNotHaveSameSizeAs;21import static org.assertj.core.error.ShouldStartWith.shouldStartWith;22import static org.assertj.core.util.Preconditions.checkNotNull;23import java.util.Arrays;24import java.util.List;25import static org.assertj.core.util.IterableUtil.toArray;26 *          target="_blank">Emulating 'self types' using Java Generics to simplify fluent API implementation</a>&quot;27    implements EnumerableAssert<S, T> {28  protected T[] actual;29  protected ObjectArrayAssert(T[] actual) {

commonChecks

Using AI Code Generation

1Arrays arrays = new Arrays();2Object[] array = new Object[] { "one", "two", "three" };3arrays.assertContainsOnlyNulls(getInfo(assertions), array);4Objects objects = new Objects();5Object[] array = new Object[] { "one", "two", "three" };6objects.assertContainsOnlyNulls(getInfo(assertions), array);7Objects objects = new Objects();8Object[] array = new Object[] { "one", "two", "three" };9objects.assertContainsOnlyNulls(getInfo(assertions), array);10Objects objects = new Objects();11Object[] array = new Object[] { "one", "two", "three" };12objects.assertContainsOnlyNulls(getInfo(assertions), array);13Objects objects = new Objects();14Object[] array = new Object[] { "one", "two", "three" };15objects.assertContainsOnlyNulls(getInfo(assertions), array);16Objects objects = new Objects();17Object[] array = new Object[] { "one", "two", "three" };18objects.assertContainsOnlyNulls(getInfo(assertions), array);19Objects objects = new Objects();20Object[] array = new Object[] { "one", "two", "three" };21objects.assertContainsOnlyNulls(getInfo(assertions), array);22Objects objects = new Objects();23Object[] array = new Object[] { "one", "two", "three" };24objects.assertContainsOnlyNulls(getInfo(assertions), array);25Objects objects = new Objects();26Object[] array = new Object[] { "one", "two", "three" };27objects.assertContainsOnlyNulls(getInfo(assertions), array);28Objects objects = new Objects();29Object[] array = new Object[] { "one", "two", "three" };

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.