Unlock 30% off on Manual Testing Annual Plans this Holiday Season.
Copied to Clipboard!
How to use doCommonContainsCheck method of org.assertj.core.internal.Maps class

Best Assertj code snippet using org.assertj.core.internal.Maps.doCommonContainsCheck
Source:Maps.java
...75            .getOrElseThrow(() -> failures.failure(info, elementsShouldBe(actual, value, valueCondition)));76    }77    public <K, V> void assertContainsAnyOf(AssertionInfo info, Map<K, V> actual,78                                           Tuple2<K, V>[] entries) {79        doCommonContainsCheck(info, actual, entries);80        if (actual.isEmpty() && entries.length == 0) return;81        failIfEmptySinceActualIsNotEmpty(entries);82        for (Tuple2<? extends K, ? extends V> entry : entries) {83            if (containsEntry(actual, entry)) return;84        }85        throw failures.failure(info, ShouldContainAnyOf.shouldContainAnyOf(actual, entries));86    }87    /**88     * Asserts that the given {@code Map} contains the given entries, in any order.89     *90     * @param <K>     key type91     * @param <V>     value type92     * @param info    contains information about the assertion93     * @param actual  the given {@code Map}94     * @param entries the entries that are expected to be in the given {@code Map}95     * @throws NullPointerException     if the array of entries is {@code null}96     * @throws IllegalArgumentException if the array of entries is empty97     * @throws NullPointerException     if any of the entries in the given array is {@code null}98     * @throws AssertionError           if the given {@code Map} is {@code null}99     * @throws AssertionError           if the given {@code Map} does not contain the given entries100     */101    public <K, V> void assertContains(AssertionInfo info, Map<K, V> actual,102                                      Tuple2<K, V>[] entries) {103        doCommonContainsCheck(info, actual, entries);104        if (actual.isEmpty() && entries.length == 0) return;105        failIfEmptySinceActualIsNotEmpty(entries);106        final Set<Tuple2<K, V>> notFound = Array.of(entries).filter(entryNotPresentIn(actual)).toSet();107        if (isNotEmpty(notFound)) {108            throw failures.failure(info, shouldContain(actual, entries, notFound));109        }110    }111    /**112     * Asserts that the given {@code Map} does not contain the given entries.113     *114     * @param <K>     key type115     * @param <V>     value type116     * @param info    contains information about the assertion117     * @param actual  the given {@code Map}118     * @param entries the entries that are expected to be in the given {@code Map}119     * @throws NullPointerException     if the array of entries is {@code null}120     * @throws IllegalArgumentException if the array of entries is empty121     * @throws NullPointerException     if any of the entries in the given array is {@code null}122     * @throws AssertionError           if the given {@code Map} is {@code null}123     * @throws AssertionError           if the given {@code Map} contains any of the given entries124     */125    public <K, V> void assertDoesNotContain(AssertionInfo info, Map<K, V> actual,126                                            Tuple2<K, V>[] entries) {127        failIfNullOrEmpty(entries);128        assertNotNull(info, actual);129        failIfEmptySinceActualIsNotEmpty(entries);130        final Set<Tuple2<K, V>> found = Array.of(entries).filter(actual::contains).toSet();131        if (isNotEmpty(found)) {132            throw failures.failure(info, shouldNotContain(actual, entries, found));133        }134    }135    /**136     * Verifies that the actual {@code Map} contains the given keys.137     *138     * @param <K>    key type139     * @param <V>    value type140     * @param info   contains information about the assertion141     * @param actual the given {@code Map}142     * @param keys   the given keys143     * @throws NullPointerException     if the array of keys is {@code null}144     * @throws IllegalArgumentException if the array of keys is empty145     * @throws AssertionError           if the given {@code Map} is {@code null}146     * @throws AssertionError           if the given {@code Map} does not contain the given keys147     */148    public <K, V> void assertContainsKeys(AssertionInfo info, Map<K, V> actual,149                                          @SuppressWarnings("unchecked") K... keys) {150        doCommonContainsCheck(info, actual, keys);151        if (doCommonEmptinessChecks(actual, keys)) return;152        Set<K> expected = HashSet.of(keys);153        Set<K> notFound = expected.filter(keyNotPresentIn(actual.keySet()));154        if (isNotEmpty(notFound)) {155            throw failures.failure(info, shouldContainKeys(actual, notFound.toJavaSet()));156        }157    }158    /**159     * Verifies that the actual {@code Map} does not contain the given keys.160     *161     * @param <K>    key type162     * @param <V>    value type163     * @param info   contains information about the assertion164     * @param actual the given {@code Map}165     * @param keys   the given keys166     * @throws NullPointerException     if the array of keys is {@code null}167     * @throws IllegalArgumentException if the array of keys is empty168     * @throws AssertionError           if the given {@code Map} is {@code null}169     * @throws AssertionError           if the given {@code Map} contains the given keys170     */171    public <K, V> void assertDoesNotContainKeys(AssertionInfo info, Map<K, V> actual,172                                                @SuppressWarnings("unchecked") K... keys) {173        doCommonContainsCheck(info, actual, keys);174        if (doCommonEmptinessChecks(actual, keys)) return;175        Set<K> expected = HashSet.of(keys);176        Set<K> found = expected.filter(keyPresentIn(actual.keySet()));177        if (isNotEmpty(found)) {178            throw failures.failure(info, shouldNotContainKeys(actual, found.toJavaSet()));179        }180    }181    /**182     * Asserts that the given {@code Map} contains the given entries only.183     *184     * @param <K>     key type185     * @param <V>     value type186     * @param info    contains information about the assertion187     * @param actual  the given {@code Map}188     * @param entries the entries that are expected to only be in the given {@code Map}189     * @throws AssertionError           if the array of entries is {@code null}190     * @throws AssertionError           if the array of entries is empty191     * @throws NullPointerException     if any of the entries in the given array is {@code null}192     * @throws AssertionError           if the given {@code Map} is {@code null}193     * @throws AssertionError           if the given {@code Map} contains any of the given entries194     */195    public <K, V> void assertContainsOnly(AssertionInfo info, Map<K, V> actual, Iterable<Tuple2<K, V>> entries) {196        assertNotNull(info, actual);197        failIfNull(entries);198        if (actual.isEmpty() && !entries.iterator().hasNext()) return;199        failIfEmpty(entries);200        Map<K, V> expected = HashMap.ofEntries(entries);201        Map<K, V> notExpected = actual.filter(entryNotPresentIn(expected));202        if (isNotEmpty(notExpected)) {203            Map<K, V> notFound = expected.filter(entryNotPresentIn(actual));204            throw failures.failure(info, shouldContainOnly(actual, expected, notFound, notExpected));205        }206    }207    /**208     * Verifies that the actual map contains only the given entries and nothing else, <b>in order</b>.<br>209     * This assertion should only be used with map that have a consistent iteration order (i.e. don't use it with210     * {@link io.vavr.collection.HashMap}).211     *212     * @param <K>     key type213     * @param <V>     value type214     * @param info    contains information about the assertion215     * @param actual  the given {@code Map}216     * @param entries the given entries217     * @throws NullPointerException     if the given entries array is {@code null}218     * @throws AssertionError           if the actual map is {@code null}219     * @throws IllegalArgumentException if the given entries array is empty220     * @throws AssertionError           if the actual map does not contain the given entries with same order, i.e. the actual map221     *                                  contains some or none of the given entries, or the actual map contains more entries than the given ones222     *                                  or entries are the same but the order is not223     */224    public <K, V> void assertContainsExactly(AssertionInfo info, Map<K, V> actual,225                                             @SuppressWarnings("unchecked") Tuple2<? extends K, ? extends V>... entries) {226        doCommonContainsCheck(info, actual, entries);227        if (actual.isEmpty() && entries.length == 0) return;228        failIfEmpty(entries);229        assertHasSameSizeAs(info, actual, entries);230        final Map<K, V> expectedEntries = asLinkedMap(entries);231        final Map<K, V> notExpected = actual.filter(entry -> !expectedEntries.contains(entry));232        final Map<K, V> notFound = expectedEntries.filter(entry -> !actual.contains(entry));233        if (notExpected.isEmpty() && notFound.isEmpty()) {234            // check entries order235            int index = 0;236            for (K keyFromActual : actual.keySet()) {237                if (areNotEqual(keyFromActual, entries[index]._1)) {238                    Tuple2<K, V> actualEntry = Tuple.of(keyFromActual, actual.get(keyFromActual).get());239                    throw failures.failure(info, elementsDifferAtIndex(actualEntry, entries[index], index));240                }241                index++;242            }243            // all entries are in the same order.244            return;245        }246        throw failures.failure(info, shouldContainExactly(actual, List.of(entries), notFound, notExpected));247    }248    /**249     * Asserts that the given {@code Map} contains the given keys, in any order.250     *251     * @param <K>     key type252     * @param <V>     value type253     * @param info    contains information about the assertion254     * @param actual  the given {@code Map}255     * @param keys    the keys that are expected to be in the given {@code Map}256     * @throws NullPointerException     if the array of keys is {@code null}257     * @throws IllegalArgumentException if the array of keys is empty258     * @throws AssertionError           if the given {@code Map} is {@code null}259     * @throws AssertionError           if the given {@code Map} does not contain the given keys260     */261    public <K, V> void assertContainsOnlyKeys(AssertionInfo info, Map<K, V> actual, K[] keys) {262        doCommonContainsCheck(info, actual, keys);263        if (doCommonEmptinessChecks(actual, keys)) return;264        Set<K> expected = HashSet.of(keys);265        Set<K> notExpected = actual.keySet().filter(keyNotPresentIn(expected));266        if (isNotEmpty(notExpected)) {267            Set<K> notFound = expected.filter(keyNotPresentIn(actual.keySet()));268            throw failures.failure(info, shouldContainOnlyKeys(actual, expected, notFound, notExpected));269        }270    }271    /**272     * Verifies that the actual map contains the given values.273     *274     * @param <K>    key type275     * @param <V>    value type276     * @param info   contains information about the assertion277     * @param actual the given {@code Map}278     * @param values the given values279     * @throws AssertionError       if the actual map is {@code null}280     * @throws AssertionError       if the actual map does not contain the given values281     * @throws NullPointerException if values vararg is {@code null}282     */283    public <K, V> void assertContainsValues(AssertionInfo info, Map<K, V> actual,284                                            @SuppressWarnings("unchecked") V... values) {285        assertNotNull(info, actual);286        checkNotNull(values, "The array of values to look for should not be null");287        if (actual.isEmpty() && values.length == 0) return;288        Set<V> expected = HashSet.of(values);289        Set<V> notFound = expected.filter(valueNotPresentIn(actual.values()));290        if (isNotEmpty(notFound)) throw failures.failure(info, shouldContainValues(actual, notFound.toJavaSet()));291    }292    /**293     * Verifies that the actual map does not contain the given values.294     *295     * @param <K>    key type296     * @param <V>    value type297     * @param info   contains information about the assertion298     * @param actual the given {@code Map}299     * @param values the given values300     * @throws AssertionError       if the actual map is {@code null}301     * @throws AssertionError       if the actual map contains the given values302     * @throws NullPointerException if values vararg is {@code null}303     */304    public <K, V> void assertDoesNotContainValues(AssertionInfo info, Map<K, V> actual,305                                                  @SuppressWarnings("unchecked") V... values) {306        assertNotNull(info, actual);307        checkNotNull(values, "The array of values to look for should not be null");308        if (actual.isEmpty() && values.length == 0) return;309        Set<V> expected = HashSet.of(values);310        Set<V> found = expected.filter(valuePresentIn(actual.values()));311        if (isNotEmpty(found)) throw failures.failure(info, shouldNotContainValues(actual, found.toJavaSet()));312    }313    /**314     * Verifies that the actual map contains the given value.315     *316     * @param <K>    key type317     * @param <V>    value type318     * @param info   contains information about the assertion319     * @param actual the given {@code Map}320     * @param value  the given value321     * @throws AssertionError if the actual map is {@code null}322     * @throws AssertionError if the actual map does not contain the given value323     */324    public <K, V> void assertContainsValue(AssertionInfo info, Map<K, V> actual, V value) {325        assertNotNull(info, actual);326        if (!actual.containsValue(value)) throw failures.failure(info, shouldContainValue(actual, value));327    }328    /**329     * Verifies that the actual map does not contain the given value.330     *331     * @param <K>    key type332     * @param <V>    value type333     * @param info   contains information about the assertion334     * @param actual the given {@code Map}335     * @param value  the given value336     * @throws AssertionError if the actual map is {@code null}337     * @throws AssertionError if the actual map contains the given value338     */339    public <K, V> void assertDoesNotContainValue(AssertionInfo info, Map<K, V> actual, V value) {340        assertNotNull(info, actual);341        if (actual.containsValue(value)) throw failures.failure(info, shouldNotContainValue(actual, value));342    }343    /**344     * Asserts that the number of entries in the given {@code Map} has the same size as the other array.345     *346     * @param info  contains information about the assertion347     * @param map   the given {@code Map}348     * @param other the group to compare349     * @throws AssertionError if the given {@code Map} is {@code null}350     * @throws AssertionError if the given array is {@code null}351     * @throws AssertionError if the number of entries in the given {@code Map} does not have the same size352     */353    public void assertHasSameSizeAs(AssertionInfo info, Map<?, ?> map, Object other) {354        assertNotNull(info, map);355        assertIsArray(info, other);356        hasSameSizeAsCheck(info, map, other, map.size());357    }358    private <K, V> void doCommonContainsCheck(AssertionInfo info, Map<K, V> actual,359                                              Tuple2<? extends K, ? extends V>[] entries) {360        assertNotNull(info, actual);361        failIfNull(entries);362    }363    private <K, V> void doCommonContainsCheck(AssertionInfo info, Map<K, V> actual, K[] keys) {364        assertNotNull(info, actual);365        failIfNull(keys);366    }367    private <K, V> boolean doCommonEmptinessChecks(Map<K, V> actual, K[] keys) {368        if (actual.isEmpty() && keys.length == 0) {369            return true;370        }371        failIfEmpty(keys);372        return false;373    }374    private <K, V> boolean containsEntry(Map<K, V> actual, Tuple2<? extends K, ? extends V> entry) {375        checkNotNull(entry, "Entries to look for should not be null");376        return actual.containsKey(entry._1) && areEqual(actual.get(entry._1).get(), entry._2);377    }...
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.