How to use assertContainsExactlyInAnyOrder method of org.assertj.core.internal.ObjectArrays class

Best Assertj code snippet using org.assertj.core.internal.ObjectArrays.assertContainsExactlyInAnyOrder

Source:ObjectArrays_assertContainsExactlyInAnyOrder_Test.java

...24import org.assertj.core.util.Lists;25import org.junit.jupiter.api.Test;26import org.mockito.Mockito;27/**28 * Tests for <code>{@link Iterables#assertContainsExactlyInAnyOrder(AssertionInfo, Iterable, Object[])}</code>.29 *30 * @author Lovro Pandzic31 */32public class ObjectArrays_assertContainsExactlyInAnyOrder_Test extends ObjectArraysBaseTest {33    @Test34    public void should_pass_if_actual_contains_exactly_in_any_order_given_values() {35        arrays.assertContainsExactlyInAnyOrder(TestData.someInfo(), actual, Arrays.array("Leia", "Yoda", "Luke"));36    }37    @Test38    public void should_pass_if_actual_contains_given_values_exactly_in_any_order_with_null_elements() {39        actual = Arrays.array("Luke", "Yoda", "Leia", null);40        arrays.assertContainsExactlyInAnyOrder(TestData.someInfo(), actual, Arrays.array("Leia", null, "Yoda", "Luke"));41    }42    @Test43    public void should_pass_if_actual_and_given_values_are_empty() {44        arrays.assertContainsExactlyInAnyOrder(TestData.someInfo(), Arrays.array(), Arrays.array());45    }46    @Test47    public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not() {48        Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array()));49    }50    @Test51    public void should_fail_if_arrays_have_different_sizes() {52        Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Luke", "Yoda")));53    }54    @Test55    public void should_throw_error_if_array_of_values_to_look_for_is_null() {56        Assertions.assertThatNullPointerException().isThrownBy(() -> arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, null)).withMessage(ErrorMessages.valuesToLookForIsNull());57    }58    @Test59    public void should_fail_if_actual_is_null() {60        Assertions.assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> arrays.assertContainsExactlyInAnyOrder(someInfo(), null, array("Yoda"))).withMessage(FailureMessages.actualIsNull());61    }62    @Test63    public void should_fail_if_actual_does_not_contain_given_values_exactly_in_any_order() {64        AssertionInfo info = TestData.someInfo();65        Object[] expected = new Object[]{ "Luke", "Yoda", "Han" };66        try {67            arrays.assertContainsExactlyInAnyOrder(info, actual, expected);68        } catch (AssertionError e) {69            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.newArrayList("Han"), Lists.newArrayList("Leia"), StandardComparisonStrategy.instance()));70            return;71        }72        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();73    }74    @Test75    public void should_fail_if_actual_contains_duplicates_and_expected_does_not() {76        AssertionInfo info = TestData.someInfo();77        actual = Arrays.array("Luke", "Leia", "Luke");78        Object[] expected = new Object[]{ "Luke", "Leia" };79        try {80            arrays.assertContainsExactlyInAnyOrder(info, actual, expected);81        } catch (AssertionError e) {82            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.emptyList(), Lists.newArrayList("Luke"), StandardComparisonStrategy.instance()));83            return;84        }85        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();86    }87    @Test88    public void should_fail_if_expected_contains_duplicates_and_actual_does_not() {89        AssertionInfo info = TestData.someInfo();90        actual = Arrays.array("Luke", "Leia");91        Object[] expected = new Object[]{ "Luke", "Leia", "Luke" };92        try {93            arrays.assertContainsExactlyInAnyOrder(info, actual, expected);94        } catch (AssertionError e) {95            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.newArrayList("Luke"), Lists.emptyList(), StandardComparisonStrategy.instance()));96            return;97        }98        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();99    }100    // ------------------------------------------------------------------------------------------------------------------101    // tests using a custom comparison strategy102    // ------------------------------------------------------------------------------------------------------------------103    @Test104    public void should_pass_if_actual_contains_given_values_exactly_in_any_order_according_to_custom_comparison_strategy() {105        arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(TestData.someInfo(), actual, Arrays.array("LUKE", "YODA", "Leia"));106    }107    @Test108    public void should_fail_if_actual_does_not_contain_given_values_exactly_in_any_order_according_to_custom_comparison_strategy() {109        AssertionInfo info = TestData.someInfo();110        Object[] expected = new Object[]{ "Luke", "Yoda", "Han" };111        try {112            arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);113        } catch (AssertionError e) {114            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.newArrayList("Han"), Lists.newArrayList("Leia"), caseInsensitiveStringComparisonStrategy));115            return;116        }117        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();118    }119    @Test120    public void should_fail_if_actual_contains_duplicates_and_expected_does_not_according_to_custom_comparison_strategy() {121        AssertionInfo info = TestData.someInfo();122        actual = Arrays.array("Luke", "Leia", "Luke");123        Object[] expected = new Object[]{ "Luke", "Leia" };124        try {125            arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);126        } catch (AssertionError e) {127            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.emptyList(), Lists.newArrayList("Luke"), caseInsensitiveStringComparisonStrategy));128            return;129        }130        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();131    }132    @Test133    public void should_fail_if_expected_contains_duplicates_and_actual_does_not_according_to_custom_comparison_strategy() {134        AssertionInfo info = TestData.someInfo();135        actual = Arrays.array("Luke", "Leia");136        Object[] expected = new Object[]{ "Luke", "Leia", "Luke" };137        try {138            arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);139        } catch (AssertionError e) {140            Mockito.verify(failures).failure(info, ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder(actual, expected, Lists.newArrayList("Luke"), Lists.emptyList(), caseInsensitiveStringComparisonStrategy));141            return;142        }143        TestFailures.failBecauseExpectedAssertionErrorWasNotThrown();144    }145}...

Source:Iterables_assertContainsExactlyInAnyOrder_Test.java

...26import org.assertj.core.internal.IterablesBaseTest;27import org.assertj.core.internal.StandardComparisonStrategy;28import org.junit.Test;29/**30 * Tests for <code>{@link Iterables#assertContainsExactlyInAnyOrder(AssertionInfo, Iterable, Object[])} </code>.31 *32 * @author Lovro Pandzic33 */34public class Iterables_assertContainsExactlyInAnyOrder_Test extends IterablesBaseTest {35  @Test36  public void should_pass_if_actual_contains_exactly_given_values() {37    iterables.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Luke", "Yoda", "Leia"));38  }39  @Test40  public void should_pass_if_actual_contains_given_values_exactly_with_null_elements() {41    iterables.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Leia", "Yoda", "Luke"));42    actual.add(null);43    iterables.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Leia", null, "Yoda", "Luke"));44  }45  @Test46  public void should_pass_if_actual_and_given_values_are_empty() {47    actual.clear();48    iterables.assertContainsExactlyInAnyOrder(someInfo(), actual, array());49  }50  @Test51  public void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not() {52    thrown.expectAssertionError();53    iterables.assertContainsExactlyInAnyOrder(someInfo(), actual, emptyArray());54  }55  @Test56  public void should_fail_if_expected_is_null() {57    thrown.expectNullPointerException(valuesToLookForIsNull());58    iterables.assertContainsExactlyInAnyOrder(someInfo(), emptyList(), null);59  }60  @Test61  public void should_fail_if_actual_is_null() {62    thrown.expectAssertionError(actualIsNull());63    iterables.assertContainsExactlyInAnyOrder(someInfo(), null, emptyArray());64  }65  @Test66  public void should_fail_if_actual_does_not_contain_given_values_exactly() {67    AssertionInfo info = someInfo();68    Object[] expected = { "Luke", "Yoda", "Han" };69    try {70      iterables.assertContainsExactlyInAnyOrder(info, actual, expected);71    } catch (AssertionError e) {72      verify(failures).failure(info,73          shouldContainExactlyInAnyOrder(actual, expected, newArrayList("Han"), newArrayList("Leia"), StandardComparisonStrategy.instance()));74      return;75    }76    failBecauseExpectedAssertionErrorWasNotThrown();77  }78  @Test79  public void should_pass_if_actual_contains_all_given_values_in_different_order() {80    AssertionInfo info = someInfo();81    Object[] expected = { "Luke", "Leia", "Yoda" };82    iterables.assertContainsExactlyInAnyOrder(info, actual, expected);83  }84  @Test85  public void should_fail_if_actual_contains_duplicates_and_expected_does_not() {86    AssertionInfo info = someInfo();87    actual = newArrayList("Luke", "Leia", "Luke");88    Object[] expected = { "Luke", "Leia" };89    try {90      iterables.assertContainsExactlyInAnyOrder(info, actual, expected);91    } catch (AssertionError e) {92      verify(failures).failure(info,93          shouldContainExactlyInAnyOrder(actual, expected, emptyList(), newArrayList("Luke"), StandardComparisonStrategy.instance()));94      return;95    }96    failBecauseExpectedAssertionErrorWasNotThrown();97  }98  @Test99  public void should_fail_if_expected_contains_duplicates_and_actual_does_not() {100    AssertionInfo info = someInfo();101    actual = newArrayList("Luke", "Leia");102    Object[] expected = { "Luke", "Leia", "Luke"};103    try {104      iterables.assertContainsExactlyInAnyOrder(info, actual, expected);105    } catch (AssertionError e) {106      verify(failures).failure(info,107          shouldContainExactlyInAnyOrder(actual, expected, newArrayList("Luke"), emptyList(), StandardComparisonStrategy.instance()));108      return;109    }110    failBecauseExpectedAssertionErrorWasNotThrown();111  }112  // ------------------------------------------------------------------------------------------------------------------113  // tests using a custom comparison strategy114  // ------------------------------------------------------------------------------------------------------------------115  @Test116  public void should_pass_if_actual_contains_given_values_exactly_according_to_custom_comparison_strategy() {117    iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactlyInAnyOrder(someInfo(), actual,118                                                                         array("LUKE", "YODA", "Leia"));119  }120  @Test121  public void should_fail_if_actual_does_not_contain_given_values_exactly_according_to_custom_comparison_strategy() {122    AssertionInfo info = someInfo();123    Object[] expected = { "Luke", "Yoda", "Han" };124    try {125      iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);126    } catch (AssertionError e) {127      verify(failures).failure(info, shouldContainExactlyInAnyOrder(actual, expected, newArrayList("Han"),128          newArrayList("Leia"), comparisonStrategy));129      return;130    }131    failBecauseExpectedAssertionErrorWasNotThrown();132  }133  @Test134  public void should_pass_if_actual_contains_all_given_values_in_different_order_according_to_custom_comparison_strategy() {135    AssertionInfo info = someInfo();136    Object[] expected = { "Luke", "Leia", "Yoda" };137    iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);138  }139  @Test140  public void should_fail_if_actual_contains_all_given_values_but_size_differ_according_to_custom_comparison_strategy() {141    AssertionInfo info = someInfo();142    actual = newArrayList("Luke", "Leia", "Luke");143    Object[] expected = { "LUKE", "Leia" };144    try {145      iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactlyInAnyOrder(info, actual, expected);146    } catch (AssertionError e) {147      verify(failures).failure(info, shouldContainExactlyInAnyOrder(actual, expected, emptyList(), newArrayList("Luke"), comparisonStrategy));148      return;149    }150    failBecauseExpectedAssertionErrorWasNotThrown();151  }152}...

Source:EntryAssert.java

...26        }27        @Override28        public ValuesAssert hasParameters(Parameter<?>... parameters) {29            String[] actualParams = actual.toMap().keySet().toArray(new String[0]);30            ObjectArrays.instance().assertContainsExactlyInAnyOrder(info, actualParams, map(parameters, Parameter::getName));31            return new Values(parameters);32        }33        @Override34        public Impl as(String description, Object... args) {35            return super.as(description, args);36        }37        @Override38        public Impl as(Description description) {39            return super.as(description);40        }41        @Override42        public Impl describedAs(String description, Object... args) {43            return super.describedAs(description, args);44        }...

assertContainsExactlyInAnyOrder

Using AI Code Generation

1package org.assertj.core.internal.objectarrays;2import static org.assertj.core.api.Assertions.assertThat;3import static org.assertj.core.error.ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder;4import static org.assertj.core.test.TestData.someInfo;5import static org.assertj.core.util.FailureMessages.actualIsNull;6import static org.assertj.core.util.Lists.newArrayList;7import static org.assertj.core.util.Sets.newLinkedHashSet;8import static org.mockito.Mockito.verify;9import org.assertj.core.api.AssertionInfo;10import org.assertj.core.internal.ObjectArrays;11import org.assertj.core.internal.ObjectArraysBaseTest;12import org.junit.Test;13public class ObjectArrays_assertContainsExactlyInAnyOrder_Test extends ObjectArraysBaseTest {14  protected void initActualArray() {15    actual = array("Luke", "Yoda", "Leia");16  }17  public void should_pass_if_actual_contains_given_values_exactly_in_any_order() {18    arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Leia", "Luke", "Yoda"));19  }20  public void should_pass_if_actual_contains_given_values_exactly_in_any_order_according_to_custom_comparison_strategy() {21    arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(someInfo(), actual,22                                                                     array("LEIA", "LUKE", "YODA"));23  }24  public void should_pass_if_actual_contains_given_values_exactly_in_any_order_with_duplicated_elements() {25    actual = array("Luke", "Yoda", "Yoda", "Leia");26    arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Luke", "Luke", "Yoda", "Yoda", "Leia"));27  }28  public void should_fail_if_arrays_have_different_sizes() {29    thrown.expectAssertionError(shouldContainExactlyInAnyOrder(actual, newLinkedHashSet("Han"), newArrayList("Luke", "Yoda", "Leia"),30                                                              newLinkedHashSet("Han")).create());31    arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Han", "Luke", "Yoda"));32  }33  public void should_fail_if_expected_is_empty_and_actual_is_not() {34    thrown.expectAssertionError(shouldContainExactlyInAnyOrder(actual, newLinkedHashSet(), newArrayList("Luke", "Yoda", "Leia"),35                                                              newLinkedHashSet("Luke", "

assertContainsExactlyInAnyOrder

Using AI Code Generation

1package org.assertj.core.internal.objectarrays;2import static org.assertj.core.api.Assertions.assertThat;3import static org.assertj.core.api.Assertions.catchThrowable;4import static org.assertj.core.error.ShouldContainExactlyInAnyOrder.shouldContainExactlyInAnyOrder;5import static org.assertj.core.test.TestData.someInfo;6import static org.assertj.core.util.Arrays.array;7import static org.assertj.core.util.FailureMessages.actualIsNull;8import static org.assertj.core.util.Lists.list;9import static org.mockito.Mockito.verify;10import org.assertj.core.api.AssertionInfo;11import org.assertj.core.internal.ObjectArrays;12import org.assertj.core.internal.ObjectArraysBaseTest;13import org.junit.jupiter.api.Test;14class ObjectArrays_assertContainsExactlyInAnyOrder_Test extends ObjectArraysBaseTest {15  void should_pass_if_actual_contains_given_values_exactly_in_any_order() {16    arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Luke", "Yoda", "Leia"));17  }18  void should_pass_if_actual_contains_given_values_exactly_in_any_order_according_to_custom_comparison_strategy() {19    arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(someInfo(), actual,20                                                                     array("LUKE", "Yoda", "Leia"));21  }22  void should_pass_if_actual_contains_given_values_exactly_in_any_order_with_duplicated_values() {23    actual = array("Luke", "Yoda", "Leia", "Luke");24    arrays.assertContainsExactlyInAnyOrder(someInfo(), actual, array("Luke", "Luke", "Yoda", "Leia"));25  }26  void should_pass_if_actual_contains_given_values_exactly_in_any_order_with_duplicated_values_according_to_custom_comparison_strategy() {27    actual = array("Luke", "Yoda", "Leia", "Luke");28    arraysWithCustomComparisonStrategy.assertContainsExactlyInAnyOrder(someInfo(), actual,29                                                                       array("LUKE", "LUKE", "Yoda", "Leia"));30  }31  void should_fail_if_actual_contains_given_values_exactly_but_not_in_same_order() {32    AssertionInfo info = someInfo();33    Object[] expected = { "Yoda", "Luke", "Leia" };34    Throwable error = catchThrowable(() -> arrays.assertContainsExactlyInAnyOrder(info, actual, expected));35    assertThat(error).isInstanceOf(AssertionError.class);36    verify(failures

assertContainsExactlyInAnyOrder

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.internal.ObjectArrays;3import org.junit.Test;4public class AssertContainsExactlyInAnyOrderTest {5    public void test() {6        ObjectArrays arrays = new ObjectArrays();7        String[] actual = {"A", "B", "C"};8        String[] expected = {"B", "A", "C"};9        arrays.assertContainsExactlyInAnyOrder(Assertions.assertThat(actual), expected);10    }11}

assertContainsExactlyInAnyOrder

Using AI Code Generation

1import org.assertj.core.internal.ObjectArrays;2import java.util.ArrayList;3import java.util.List;4public class Main {5    public static void main(String[] args) {6        ObjectArrays objectArrays = new ObjectArrays();7        List<String> actual = new ArrayList<>();8        actual.add("one");9        actual.add("two");10        actual.add("three");11        List<String> expected = new ArrayList<>();12        expected.add("one");13        expected.add("two");14        expected.add("three");15        objectArrays.assertContainsExactlyInAnyOrder(null, actual.toArray(), expected.toArray());16    }17}18to contain exactly (and in same order):19	at org.assertj.core.internal.ObjectArrays.assertContainsExactlyInAnyOrder(ObjectArrays.java:366)20	at org.assertj.core.internal.ObjectArrays.assertContainsExactlyInAnyOrder(ObjectArrays.java:59)21	at Main.main(Main.java:16)22import org.assertj.core.api.Assertions;23import java.util.ArrayList;24import java.util.List;25public class Main {26    public static void main(String[] args) {27        List<String> actual = new ArrayList<>();28        actual.add("one");29        actual.add("two");30        actual.add("three");31        List<String> expected = new ArrayList<>();32        expected.add("one");33        expected.add("two");34        expected.add("three");35        Assertions.assertThat(actual.toArray()).containsExactlyInAnyOrder(expected.toArray());36    }37}38to contain exactly (and in same order):39	at org.assertj.core.internal.ObjectArrays.assertContainsExactlyInAnyOrder(ObjectArrays.java:366)40	at org.assertj.core.internal.ObjectArrays.assertContainsExactlyInAnyOrder(ObjectArrays.java:59)41	at org.assertj.core.error.ShouldContainExactlyInAnyOrder.create(ShouldContainExactlyInAnyOrder.java:46)

assertContainsExactlyInAnyOrder

Using AI Code Generation

1import java.util.ArrayList;2import java.util.Arrays;3import java.util.List;4import org.assertj.core.api.Assertions;5import org.assertj.core.internal.ObjectArrays;6import org.junit.Test;7public class MyTest {8  public void test() {9    ObjectArrays arrays = new ObjectArrays();10    List<String> actual = new ArrayList<>();11    actual.add("A");12    actual.add("B");13    actual.add("C");14    actual.add("D");15    actual.add("E");16    actual.add("F");17    actual.add("G");18    actual.add("H");19    actual.add("I");20    actual.add("J");21    actual.add("K");22    actual.add("L");23    actual.add("M");24    actual.add("N");25    actual.add("O");26    actual.add("P");27    actual.add("Q");28    actual.add("R");29    actual.add("S");30    actual.add("T");31    actual.add("U");32    actual.add("V");33    actual.add("W");34    actual.add("X");35    actual.add("Y");36    actual.add("Z");37    List<String> expected = new ArrayList<>();38    expected.add("A");39    expected.add("B");40    expected.add("C");41    expected.add("D");42    expected.add("E");43    expected.add("F");44    expected.add("G");45    expected.add("H");46    expected.add("I");47    expected.add("J");48    expected.add("K");49    expected.add("L");50    expected.add("M");51    expected.add("N");52    expected.add("O");53    expected.add("P");54    expected.add("Q");55    expected.add("R");56    expected.add("S");57    expected.add("T");58    expected.add("U");59    expected.add("V");60    expected.add("W");61    expected.add("X");62    expected.add("Y");63    expected.add("Z");64    arrays.assertContainsExactlyInAnyOrder(Assertions.assertThat(actual), actual.toArray(), expected.toArray());65  }66}

assertContainsExactlyInAnyOrder

Using AI Code Generation

1import org.assertj.core.internal.ObjectArrays;2import org.junit.Test;3public class AssertContainsExactlyInAnyOrderTest {4   public void test() {5      ObjectArrays array = new ObjectArrays();6      String[] array1 = { "java", "python", "c++", "c" };7      String[] array2 = { "c++", "c", "java", "python" };8      array.assertContainsExactlyInAnyOrder(null, array1, array2);9   }10}

assertContainsExactlyInAnyOrder

Using AI Code Generation

1import org.assertj.core.internal.ObjectArrays;2import org.junit.Test;3import static org.assertj.core.api.Assertions.assertThat;4import static org.assertj.core.api.Assertions.fail;5public class AssertJTest {6    public void test1() {7        ObjectArrays objectArrays = new ObjectArrays();8        try {9            objectArrays.assertContainsExactlyInAnyOrder(null, new Object[2], new Object[2]);10            fail("Expecting AssertionError");11        } catch (AssertionError e) {12            assertThat(e).hasMessage("The array to look for should not be null");13        }14        try {15            objectArrays.assertContainsExactlyInAnyOrder(new Object[2], null, new Object[2]);16            fail("Expecting AssertionError");17        } catch (AssertionError e) {18            assertThat(e).hasMessage("The given array should not be null");19        }20        try {21            objectArrays.assertContainsExactlyInAnyOrder(new Object[2], new Object[2], null);22            fail("Expecting AssertionError");23        } catch (AssertionError e) {24            assertThat(e).hasMessage("The given array should not be null");25        }26    }27}

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.