entries

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain an entry for assertionCreatorOrNull as well as for the otherAssertionCreatorsOrNulls where it does not matter in which order they appear -- an entry is contained if it either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

Parameters

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain only an entry for assertionCreatorOrNull as well as for the otherAssertionCreatorsOrNulls where it does not matter in which order they appear -- an entry is contained if it either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

Notice, that a first-wins strategy applies which means your assertion creator lambdas -- which kind of serve as identification lambdas -- should be ordered in such a way that the most specific identification lambda appears first, not that a less specific lambda wins. For instance, given a setOf(1, 2) you should not search for entries({ isGreaterThan(0) }, { toEqual(1) }) but for entries({ toEqual(1) }, { isGreaterThan(0) }) otherwise isGreaterThan(0) matches 1 before toEqual(1) would match it. As a consequence toEqual(1) could only match the entry which is left -- in this case 2 -- and of course this would fail.

Parameters

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain only an entry for assertionCreatorOrNull as well as for the otherAssertionCreatorsOrNulls in the specified order -- an entry is contained if it either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

Parameters

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain the given keyValuePair as well as the otherPairs where it does not matter in which order they appear.

Notice, that it does not search for unique matches. Meaning, if the map is mapOf('a' to 1) and keyValuePair is defined as 'a' to 1 and one of the otherPairs is defined as 'a' to 1 as well, then both match, even though they match the same entry.

Samples

expect(mapOf(1 to "a", 2 to "b")).toContain.inAnyOrder.entries(
    2 to "b"
)

fails { // because the value ("b") of key 1 (which exists in the subject) is not "b"
    expect(mapOf(1 to "a", 2 to "b")).toContain.inAnyOrder.entries(1 to "b")
}

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain the given keyValue as well as the otherKeyValues where it does not matter in which order they appear -- an entry is contained if it has a key as defined by keyValue's KeyValue.key and a corresponding value which either holds all assertions keyValue's KeyValue.valueAssertionCreatorOrNull creates or needs to be null in case KeyValue.valueAssertionCreatorOrNull is defined as null.

Notice, that it does not search for unique matches. Meaning, if the map is mapOf('a' to 1) and keyValue is defined as Key('a') { isGreaterThan(0) } and one of the otherKeyValues is defined as Key('a') { isLessThan(2) } , then both match, even though they match the same entry.

Samples

expect(mapOf(1 to "apple", 2 to "banana")).toContain.inAnyOrder.entries(
    KeyValue(2) { toStartWith("b") }
)

fails { // because the value ("apple") of key 1 (which exists in the subject) does not start with "b"
    expect(mapOf(1 to "apple", 2 to "banana")).toContain.inAnyOrder.entries(
        KeyValue(1) { toStartWith("b") }
    )
}

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given keyValuePair as well as the otherPairs where it does not matter in which order they appear.

Samples

expect(mapOf(1 to "a", 2 to "b")).toContain.inAnyOrder.only.entries(
    2 to "b", 1 to "a"
)

fails { // because subject has additional entries
    expect(mapOf(1 to "a", 2 to "b")).toContain.inAnyOrder.only.entries(1 to "a")
}

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given keyValue as well as the otherKeyValues where it does not matter in which order they appear -- an entry is contained if it has a key as defined by keyValue's KeyValue.key and a corresponding value which either holds all assertions keyValue's KeyValue.valueAssertionCreatorOrNull creates or needs to be null in case KeyValue.valueAssertionCreatorOrNull is defined as null.

Samples

expect(mapOf(1 to "apple", 2 to "banana")).toContain.inAnyOrder.only.entries(
    KeyValue(2) { toStartWith("b") },
    KeyValue(1) { toStartWith("a") },
)

fails { // because subject has additional entries
    expect(mapOf(1 to "apple", 2 to "banana")).toContain.inAnyOrder.only.entries(
        KeyValue(1) { toStartWith("a") },
    )
}

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given keyValuePair as well as the otherPairs in the specified order.

Parameters

Samples

expect(mapOf(1 to "a", 2 to "b")).toContain.inOrder.only.entries(
    1 to "a", 2 to "b"
)

fails { // because the pair entries (which all exist in the subject) do not have the same order
    expect(mapOf(1 to "a", 2 to "b")).toContain.inOrder.only.entries(
        2 to "b",
        1 to "a",
    )
}

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given keyValue as well as the otherKeyValues in the specified order -- an entry is contained if it has a key as defined by keyValue's KeyValue.key and a corresponding value which either holds all assertions keyValue's KeyValue.valueAssertionCreatorOrNull creates or needs to be null in case KeyValue.valueAssertionCreatorOrNull is defined as null.

Parameters

Samples

expect(mapOf(1 to "apple", 2 to "banana")).toContain.inOrder.only.entries(
    KeyValue(1) { toStartWith("a") },
    KeyValue(2) { toStartWith("b") },
)

fails { // because the key-value entries (which all exist in the subject) do not have the same order
    expect(mapOf(1 to "apple", 2 to "banana")).toContain.inOrder.only.entries(
        KeyValue(2) { toStartWith("b") },
        KeyValue(1) { toStartWith("a") },
    )
}