How to use shouldContainExactlyWithIndexes method of org.assertj.core.error.ShouldContainExactly class
Best Assertj code snippet using org.assertj.core.error.ShouldContainExactly.shouldContainExactlyWithIndexes
Source:ShouldContainExactly_create_Test.java 
...16import static org.assertj.core.api.BDDAssertions.then;17import static org.assertj.core.configuration.Configuration.MAX_INDICES_FOR_PRINTING;18import static org.assertj.core.error.ShouldContainExactly.elementsDifferAtIndex;19import static org.assertj.core.error.ShouldContainExactly.shouldContainExactly;20import static org.assertj.core.error.ShouldContainExactly.shouldContainExactlyWithIndexes;21import static org.assertj.core.util.Lists.list;22import static org.assertj.core.util.Sets.newLinkedHashSet;23import java.util.ArrayList;24import java.util.Comparator;25import java.util.List;26import java.util.stream.Collectors;27import java.util.stream.IntStream;28import org.assertj.core.description.TextDescription;29import org.assertj.core.internal.ComparatorBasedComparisonStrategy;30import org.assertj.core.internal.IndexedDiff;31import org.assertj.core.internal.StandardComparisonStrategy;32import org.assertj.core.test.CaseInsensitiveStringComparator;33import org.junit.jupiter.api.Test;34class ShouldContainExactly_create_Test {35 private static final ComparatorBasedComparisonStrategy CASE_INSENSITIVE_COMPARISON_STRATEGY = new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.INSTANCE);36 @Test37 void should_display_full_expected_and_actual_sets_with_index_when_order_does_not_match() {38 // GIVEN39 List<String> actual = list("Yoda", "Han", "Luke", "Anakin");40 List<String> expected = list("Yoda", "Luke", "Han", "Anakin");41 List<IndexedDiff> indexDifferences = list(new IndexedDiff(actual.get(1), expected.get(1), 1),42 new IndexedDiff(actual.get(2), expected.get(2), 2));43 ErrorMessageFactory factory = shouldContainExactlyWithIndexes(actual, expected, indexDifferences,44 StandardComparisonStrategy.instance());45 // WHEN46 final String message = factory.create(new TextDescription("Test"));47 // THEN48 then(message).isEqualTo(format("[Test] %n" +49 "Expecting actual:%n" +50 " [\"Yoda\", \"Han\", \"Luke\", \"Anakin\"]%n" +51 "to contain exactly (and in same order):%n" +52 " [\"Yoda\", \"Luke\", \"Han\", \"Anakin\"]%n" +53 "but there were differences at these indexes:%n" +54 " - element at index 1: expected \"Luke\" but was \"Han\"%n" +55 " - element at index 2: expected \"Han\" but was \"Luke\"%n"));56 }57 @Test58 void should_display_only_configured_max_amount_of_indices() {59 // GIVEN60 List<Integer> expected = IntStream.rangeClosed(0, MAX_INDICES_FOR_PRINTING)61 .boxed()62 .collect(Collectors.toList());63 List<Integer> actual = IntStream.rangeClosed(0, MAX_INDICES_FOR_PRINTING)64 .boxed()65 .sorted(Comparator.reverseOrder())66 .collect(Collectors.toList());67 List<IndexedDiff> indexDifferences = new ArrayList<>();68 for (int i = 0; i < actual.size(); i++) {69 indexDifferences.add(new IndexedDiff(actual.get(i), expected.get(i), i));70 }71 ErrorMessageFactory factory = shouldContainExactlyWithIndexes(actual, expected, indexDifferences,72 StandardComparisonStrategy.instance());73 // WHEN74 final String message = factory.create(new TextDescription("Test"));75 // THEN76 then(message).contains(format("only showing the first %d mismatches", MAX_INDICES_FOR_PRINTING));77 }78 @Test79 void should_display_full_expected_and_actual_sets_with_missing_and_unexpected_elements() {80 // GIVEN81 ErrorMessageFactory factory = shouldContainExactly(list("Yoda", "Han", "Luke", "Anakin"),82 list("Yoda", "Han", "Anakin", "Anakin"),83 list("Anakin"), list("Luke"));84 // WHEN85 final String message = factory.create(new TextDescription("Test"));...
Source:ShouldContainExactly.java
...73 * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.74 * @return the created {@code ErrorMessageFactory}.75 *76 */77 public static ErrorMessageFactory shouldContainExactlyWithIndexes(Object actual, Iterable<?> expected,78 List<IndexedDiff> indexDifferences,79 ComparisonStrategy comparisonStrategy) {80 return new ShouldContainExactly(actual, expected, indexDifferences, comparisonStrategy);81 }82 /**83 * Creates a new {@link ShouldContainExactly}.84 *85 * @param actual the actual value in the failed assertion.86 * @param expected values expected to be contained in {@code actual}.87 * @param indexDifferences the {@link IndexedDiff} the actual and expected differ at.88 * @return the created {@code ErrorMessageFactory}.89 *90 */91 public static ErrorMessageFactory shouldContainExactlyWithIndexes(Object actual, Iterable<?> expected,92 List<IndexedDiff> indexDifferences) {93 return new ShouldContainExactly(actual, expected, indexDifferences, StandardComparisonStrategy.instance());94 }95 private ShouldContainExactly(Object actual, Object expected, ComparisonStrategy comparisonStrategy) {96 super("%n" +97 "Expecting actual:%n" +98 " %s%n" +99 "to contain exactly (and in same order):%n" +100 " %s%n",101 actual, expected, comparisonStrategy);102 }103 private ShouldContainExactly(Object actual, Object expected, Object notFound, Object notExpected,104 ComparisonStrategy comparisonStrategy) {105 super("%n" +...
Source:Iterables_assertContainsExactly_Test.java
...17import static org.assertj.core.api.Assertions.assertThatNullPointerException;18import static org.assertj.core.api.BDDAssertions.then;19import static org.assertj.core.configuration.Configuration.MAX_INDICES_FOR_PRINTING;20import static org.assertj.core.error.ShouldContainExactly.shouldContainExactly;21import static org.assertj.core.error.ShouldContainExactly.shouldContainExactlyWithIndexes;22import static org.assertj.core.internal.ErrorMessages.valuesToLookForIsNull;23import static org.assertj.core.internal.iterables.SinglyIterableFactory.createSinglyIterable;24import static org.assertj.core.test.ObjectArrays.emptyArray;25import static org.assertj.core.util.Arrays.array;26import static org.assertj.core.util.Arrays.asList;27import static org.assertj.core.util.AssertionsUtil.expectAssertionError;28import static org.assertj.core.util.FailureMessages.actualIsNull;29import static org.assertj.core.util.Lists.list;30import static org.mockito.Mockito.verify;31import java.util.List;32import java.util.stream.IntStream;33import org.assertj.core.api.AssertionInfo;34import org.assertj.core.internal.IndexedDiff;35import org.assertj.core.internal.Iterables;36import org.assertj.core.internal.IterablesBaseTest;37import org.junit.jupiter.api.Test;38/**39 * Tests for <code>{@link Iterables#assertContainsExactly(AssertionInfo, Iterable, Object[])}</code>.40 *41 * @author Joel Costigliola42 */43class Iterables_assertContainsExactly_Test extends IterablesBaseTest {44 @Test45 void should_pass_if_actual_contains_exactly_given_values() {46 iterables.assertContainsExactly(INFO, actual, array("Luke", "Yoda", "Leia"));47 }48 @Test49 void should_pass_if_non_restartable_actual_contains_exactly_given_values() {50 iterables.assertContainsExactly(INFO, createSinglyIterable(actual), array("Luke", "Yoda", "Leia"));51 }52 @Test53 void should_pass_if_actual_contains_given_values_exactly_with_null_elements() {54 // GIVEN55 actual.add(null);56 // WHEN/THEN57 iterables.assertContainsExactly(INFO, actual, array("Luke", "Yoda", "Leia", null));58 }59 @Test60 void should_pass_if_actual_and_given_values_are_empty() {61 // GIVEN62 actual.clear();63 // WHEN/THEN64 iterables.assertContainsExactly(INFO, actual, array());65 }66 @Test67 void should_fail_if_array_of_values_to_look_for_is_empty_and_actual_is_not() {68 // GIVEN69 Object[] values = emptyArray();70 // WHEN/THEN71 expectAssertionError(() -> iterables.assertContainsExactly(INFO, actual, values));72 }73 @Test74 void should_throw_error_if_array_of_values_to_look_for_is_null() {75 assertThatNullPointerException().isThrownBy(() -> iterables.assertContainsExactly(INFO, emptyList(), null))76 .withMessage(valuesToLookForIsNull());77 }78 @Test79 void should_fail_if_actual_is_null() {80 // GIVEN81 actual = null;82 // WHEN83 AssertionError assertionError = expectAssertionError(() -> iterables.assertContainsExactly(INFO, actual, array("Yoda")));84 // THEN85 then(assertionError).hasMessage(actualIsNull());86 }87 @Test88 void should_fail_if_actual_does_not_contain_given_values_exactly() {89 // GIVEN90 Object[] expected = { "Luke", "Yoda", "Han" };91 // WHEN92 expectAssertionError(() -> iterables.assertContainsExactly(INFO, actual, expected));93 // THEN94 List<String> notFound = list("Han");95 List<String> notExpected = list("Leia");96 verify(failures).failure(INFO, shouldContainExactly(actual, asList(expected), notFound, notExpected));97 }98 @Test99 void should_fail_if_actual_contains_all_given_values_in_different_order() {100 // GIVEN101 Object[] expected = { "Luke", "Leia", "Yoda" };102 // WHEN103 expectAssertionError(() -> iterables.assertContainsExactly(INFO, actual, expected));104 // THEN105 List<IndexedDiff> indexDiffs = list(new IndexedDiff("Yoda", "Leia", 1),106 new IndexedDiff("Leia", "Yoda", 2));107 verify(failures).failure(INFO, shouldContainExactlyWithIndexes(actual, list(expected), indexDiffs));108 }109 @Test110 void should_fail_if_actual_contains_all_given_values_but_size_differ() {111 // GIVEN112 actual = list("Luke", "Leia", "Luke");113 Object[] expected = { "Luke", "Leia" };114 // WHEN115 expectAssertionError(() -> iterables.assertContainsExactly(INFO, actual, expected));116 // THEN117 verify(failures).failure(INFO, shouldContainExactly(actual, asList(expected), emptyList(), list("Luke")));118 }119 // ------------------------------------------------------------------------------------------------------------------120 // tests using a custom comparison strategy121 // ------------------------------------------------------------------------------------------------------------------122 @Test123 void should_pass_if_actual_contains_given_values_exactly_according_to_custom_comparison_strategy() {124 iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactly(INFO, actual, array("LUKE", "YODA", "Leia"));125 }126 @Test127 void should_fail_if_actual_does_not_contain_given_values_exactly_according_to_custom_comparison_strategy() {128 // GIVEN129 Object[] expected = { "Luke", "Yoda", "Han" };130 // WHEN131 expectAssertionError(() -> iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactly(INFO, actual, expected));132 // THEN133 verify(failures).failure(INFO, shouldContainExactly(actual, asList(expected), list("Han"), list("Leia"), comparisonStrategy));134 }135 @Test136 void should_fail_if_actual_contains_all_given_values_in_different_order_according_to_custom_comparison_strategy() {137 // GIVEN138 Object[] expected = { "Luke", "Leia", "Yoda" };139 // WHEN140 expectAssertionError(() -> iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactly(INFO, actual, expected));141 // THEN142 List<IndexedDiff> indexDiffs = list(new IndexedDiff("Yoda", "Leia", 1),143 new IndexedDiff("Leia", "Yoda", 2));144 verify(failures).failure(INFO, shouldContainExactlyWithIndexes(actual, list(expected), indexDiffs, comparisonStrategy));145 }146 @Test147 void should_fail_if_actual_contains_all_given_values_but_size_differ_according_to_custom_comparison_strategy() {148 // GIVEN149 actual = list("Luke", "Leia", "Luke");150 Object[] expected = { "LUKE", "Leia" };151 // WHEN152 expectAssertionError(() -> iterablesWithCaseInsensitiveComparisonStrategy.assertContainsExactly(INFO, actual, expected));153 // THEN154 verify(failures).failure(INFO, shouldContainExactly(actual, asList(expected), emptyList(), list("Luke"), comparisonStrategy));155 }156 @Test157 void should_fail_if_order_does_not_match_and_total_printed_indexes_should_be_equal_to_max_elements_for_printing() {158 // GIVEN...
shouldContainExactlyWithIndexes
Using AI Code Generation
1import org.assertj.core.error.ShouldContainExactly;2import org.assertj.core.error.ErrorMessageFactory;3import org.assertj.core.description.Description;4import org.assertj.core.internal.TestDescription;5import org.assertj.core.presentation.StandardRepresentation;6import org.assertj.core.presentation.Representation;7public class ShouldContainExactlyWithIndexes {8 public static void main(String[] args) {9 ErrorMessageFactory factory = ShouldContainExactly.shouldContainExactly("Yoda", newArrayList("Luke", "Yoda"), newArrayList("Han"), newLinkedHashSet("Luke"), newLinkedHashSet("Han"), newArrayList(0), newArrayList(1));10 System.out.println(factory.create(new TestDescription("Test"), new StandardRepresentation()));11 }12}
shouldContainExactlyWithIndexes
Using AI Code Generation
1import static org.assertj.core.api.Assertions.assertThat;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.TestDescription;4import org.assertj.core.presentation.StandardRepresentation;5import org.junit.Test;6public class ShouldContainExactlyWithIndexesTest {7 public void shouldContainExactlyWithIndexesTest() {8 String[] actual = {"a", "b", "c", "d"};9 String[] expected = {"a", "b", "c", "d"};10 Integer[] indexes = {1, 2, 3, 4};11 String errorMessage = ShouldContainExactly.shouldContainExactly(actual, expected, indexes).create(new TestDescription("Test"), new StandardRepresentation());12 assertThat(errorMessage).isEqualTo(String.format("[Test] %n" +13 "to contain exactly (and in same order):%n" +14 " [\"d\"] at index 4"));15 }16}17to contain exactly (and in same order):
shouldContainExactlyWithIndexes
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.Failures;4import org.assertj.core.presentation.StandardRepresentation;5import org.assertj.core.util.VisibleForTesting;6import java.util.List;7import static org.assertj.core.error.ShouldContainExactly.shouldContainExactly;8public class 1 {9 public static void main(String[] args) {10 Failures failures = new Failures();11 StandardRepresentation representation = new StandardRepresentation();12 List<String> actual = Arrays.asList("a", "b", "c");13 List<String> expected = Arrays.asList("a", "b", "c");14 ShouldContainExactly shouldContainExactly = shouldContainExactly(actual, expected, newArrayList("b", "c"), newArrayList("b", "c"), newArrayList());15 String message = failures.failureMessage(shouldContainExactly);16 System.out.println(message);17 String errorMessage = failures.create(new TestDescription("Test"), shouldContainExactly).create();18 System.out.println(errorMessage);19 }20 static class TestDescription implements Description {21 private final String value;22 TestDescription(String value) {23 this.value = value;24 }25 public String value() {26 return value;27 }28 public String toString() {29 return value;30 }31 }32}33to contain exactly (and in same order):34to contain exactly (and in same order):
shouldContainExactlyWithIndexes
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.Failures;4import org.assertj.core.internal.StandardComparisonStrategy;5import org.assertj.core.presentation.StandardRepresentation;6public class Example {7 public static void main(String[] args) {8 Failures failures = Failures.instance();9 AssertionError error = failures.failure(info, shouldContainExactly(actual, newArrayList("Luke", "Yoda", "Leia"), newArrayList("Han"), newArrayList("Leia"), newArrayList("Han"), comparisonStrategy));10 assertThat(error).hasMessage(String.format("[Test] %n" +11 "to contain exactly (and in same order):%n" +12 "when comparing values using 'CaseInsensitiveStringComparator'"));13 }14 private static StandardRepresentation representation = new StandardRepresentation();15 private static StandardComparisonStrategy comparisonStrategy = StandardComparisonStrategy.instance();16 private static Failures failures = Failures.instance();17 private static List<String> actual = newArrayList("Luke", "Yoda", "Leia");18 private static Description info = new TestDescription("Test");19 private static ShouldContainExactly shouldContainExactly = new ShouldContainExactly(actual, newArrayList("Luke", "Yoda", "Leia"), newArrayList("Han"), newArrayList("Leia"), newArrayList("Han"), comparisonStrategy);20}21import static org.assertj.core.api.Assertions.assertThat;22import static org.assertj.core.error.ShouldContainExactly.shouldContainExactly;23import static org.assertj.core.test.ExpectedException.none;24import static org.assertj.core.util.Lists.newArrayList;25import static org.assertj.core.util.Sets.newLinkedHashSet;26import static org.mockito.Mockito.verify;27import org.assertj.core.api.AssertionInfo;28import org.assertj.core.api.Assertions;29import org.assertj.core.error.ErrorMessageFactory;30import org.assertj.core.internal.Failures;31import org.assertj.core.internal.StandardComparisonStrategy;32import org.assertj
shouldContainExactlyWithIndexes
Using AI Code Generation
1import org.assertj.core.error.ShouldContainExactly;2import org.assertj.core.util.Lists;3import org.assertj.core.internal.TestDescription;4import org.assertj.core.presentation.StandardRepresentation;5import org.assertj.core.error.ErrorMessageFactory;6import java.util.List;7import java.util.Map;8public class Test {9 public static void main(String[] args) {10 List<String> expected = Lists.newArrayList("Luke", "Leia", "Yoda");11 List<String> actual = Lists.newArrayList("Luke", "Yoda");12 List<Integer> indexes = Lists.newArrayList(1, 3);13 ErrorMessageFactory factory = ShouldContainExactly.shouldContainExactly(expected, actual, indexes, StandardRepresentation.STANDARD_REPRESENTATION);14 System.out.println(factory.create(new TestDescription("Test"), StandardRepresentation.STANDARD_REPRESENTATION));15 }16}17to contain exactly (and in same order):
shouldContainExactlyWithIndexes
Using AI Code Generation
1package com.example;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.Failures;4public class Example {5 public static void main(String[] args) {6 Failures.instance().failureInfo("test", "test", ShouldContainExactly.shouldContainExactly(new String[] {"1", "2", "3"}, new String[] {"1", "3", "2"}, new int[] {0, 2, 1}, new int[] {1, 0, 2}));7 }8}
shouldContainExactlyWithIndexes
Using AI Code Generation
1package org.assertj.core.error;2import java.util.List;3public class ShouldContainExactlyWithIndexes extends BasicErrorMessageFactory {4 public static ErrorMessageFactory shouldContainExactlyWithIndexes(Object actual, List<?> expected, List<?> actualList, List<?> indexes) {5 return new ShouldContainExactlyWithIndexes(actual, expected, actualList, indexes);6 }7 private ShouldContainExactlyWithIndexes(Object actual, List<?> expected, List<?> actualList, List<?> indexes) {8 super("%n" +9 " <%s>", actual, expected, actualList, indexes);10 }11}12package org.assertj.core.api;13import org.assertj.core.error.ShouldContainExactlyWithIndexes;14import org.assertj.core.internal.Failures;15import org.assertj.core.internal.Objects;16import org.assertj.core.util.VisibleForTesting;17import java.util.List;18import static org.assertj.core.error.ShouldContainExactlyWithIndexes.shouldContainExactlyWithIndexes;19import static org.assertj.core.util.Iterables.sizeOf;20public abstract class AbstractListAssert<S extends AbstractListAssert<S,T,E>, T extends List<E>, E> extends AbstractIterableAssert<S,T,E> {21 protected Objects objects = Objects.instance();22 protected AbstractListAssert(T actual, Class<?> selfType) {23 super(actual, selfType);24 }25 * <pre><code class='java'> List<String> list = newArrayList("Yoda", "Luke");26 * assertThat(list).containsExactly("Yoda", "Luke");27 * assertThat(list).containsExactly("Yoda", "Luke");28 * assertThat(list).containsExactly("Luke", "Yoda");29 * assertThat(list).containsExactly("Yoda");30 * assertThat(list).containsExactly("Yoda
shouldContainExactlyWithIndexes
Using AI Code Generation
1public class 1 {2 public static void main(String[] args) {3 this.value = value;4 }5 public String value() {6 return value;7 }8 public String toString() {9 return value;10 }11 }12}13to contain exactly (and in same order):14to contain exactly (and in same order):
shouldContainExactlyWithIndexes
Using AI Code Generation
1package com.example;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.Failures;4public class Example {5 public static void main(String[] args) {6 Failures.instance().failureInfo("test", "test", ShouldContainExactly.shouldContainExactly(new String[] {"1", "2", "3"}, new String[] {"1", "3", "2"}, new int[] {0, 2, 1}, new int[] {1, 0, 2}));7 }8}
shouldContainExactlyWithIndexes
Using AI Code Generation
1package com.example;2import org.assertj.core.error.ShouldContainExactly;3import org.assertj.core.internal.Failures;4public class Example {5 public static void main(String[] args) {6 Failures.instance().failureInfo("test", "test", ShouldContainExactly.shouldContainExactly(new String[] {"1", "2", "3"}, new String[] {"1", "3", "2"}, new int[] {0, 2, 1}, new int[] {1, 0, 2}));7 }8}
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.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Assertj automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in ShouldContainExactly
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
