diff --git a/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt b/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
deleted file mode 100644
index 62e46d52e6..0000000000
--- a/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
+++ /dev/null
@@ -1,71 +0,0 @@
-package ch.tutteli.atrium.api.fluent.en_GB
-
-import ch.tutteli.atrium.creating.Expect
-import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
-import ch.tutteli.atrium.specs.notImplemented
-import ch.tutteli.atrium.specs.withNullableSuffix
-
-class IterableToContainInAnyOrderOnlyEntriesExpectationsSpec :
-    ch.tutteli.atrium.specs.integration.IterableToContainInAnyOrderOnlyEntriesExpectationsSpec(
-        functionDescription to Companion::toContainInAnyOrderOnlyEntries,
-        (functionDescription to Companion::toContainInAnyOrderOnlyNullableEntries).withNullableSuffix()
-    ) {
-    companion object : IterableToContainSpecBase() {
-        val functionDescription = "$toContain.$inAnyOrder.$only.$entry/$entries"
-
-        private fun toContainInAnyOrderOnlyEntries(
-            expect: Expect<Iterable<Double>>,
-            a: Expect<Double>.() -> Unit,
-            aX: Array<out Expect<Double>.() -> Unit>,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit
-        ): Expect<Iterable<Double>> =
-            if (report === emptyInOrderOnlyReportOptions) {
-                if (aX.isEmpty()) expect.toContain.inAnyOrder.only.entry(a)
-                else expect.toContain.inAnyOrder.only.entries(a, *aX)
-            } else expect.toContain.inAnyOrder.only.entries(a, *aX, report = report)
-
-
-        private fun toContainInAnyOrderOnlyNullableEntries(
-            expect: Expect<Iterable<Double?>>,
-            a: (Expect<Double>.() -> Unit)?,
-            aX: Array<out (Expect<Double>.() -> Unit)?>,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit
-        ): Expect<Iterable<Double?>> =
-            if (report === emptyInOrderOnlyReportOptions) {
-                if (aX.isEmpty()) expect.toContain.inAnyOrder.only.entry(a)
-                else expect.toContain.inAnyOrder.only.entries(a, *aX)
-            } else expect.toContain.inAnyOrder.only.entries(a, *aX, report = report)
-    }
-
-    @Suppress("unused", "UNUSED_VALUE")
-    private fun ambiguityTest() {
-        var list: Expect<List<Number>> = notImplemented()
-        var nList: Expect<Set<Number?>> = notImplemented()
-        var subList: Expect<ArrayList<Number>> = notImplemented()
-        var star: Expect<Collection<*>> = notImplemented()
-
-        list = list.toContain.inAnyOrder.only.entry {}
-        nList = nList.toContain.inAnyOrder.only.entry {}
-        subList = subList.toContain.inAnyOrder.only.entry {}
-        star = star.toContain.inAnyOrder.only.entry {}
-
-        nList = nList.toContain.inAnyOrder.only.entry(null)
-        star = star.toContain.inAnyOrder.only.entry(null)
-
-        list = list.toContain.inAnyOrder.only.entries({}, {})
-        nList = nList.toContain.inAnyOrder.only.entries({}, {})
-        subList = subList.toContain.inAnyOrder.only.entries({}, {})
-        star = star.toContain.inAnyOrder.only.entries({}, {})
-
-        list = list.toContain.inAnyOrder.only.entries({}, {}, report = {})
-        nList = nList.toContain.inAnyOrder.only.entries({}, {}, report = {})
-        subList = subList.toContain.inAnyOrder.only.entries({}, {}, report = {})
-        star = star.toContain.inAnyOrder.only.entries({}, {}, report = {})
-
-        nList = nList.toContain.inAnyOrder.only.entries(null, {}, null)
-        star = star.toContain.inAnyOrder.only.entries(null, {}, null)
-
-        nList = nList.toContain.inAnyOrder.only.entries(null, {}, null, report = {})
-        star = star.toContain.inAnyOrder.only.entries(null, {}, null, report = {})
-    }
-}
diff --git a/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt b/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
new file mode 100644
index 0000000000..de19846988
--- /dev/null
+++ b/apis/fluent/atrium-api-fluent/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
@@ -0,0 +1,113 @@
+package ch.tutteli.atrium.api.fluent.en_GB
+
+import ch.tutteli.atrium.creating.Expect
+import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
+import ch.tutteli.atrium.api.verbs.expect
+import ch.tutteli.atrium.specs.withNullableSuffix
+import ch.tutteli.atrium.specs.integration.AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.emptyInOrderOnlyReportOptions
+import kotlin.test.Test
+
+class IterableToContainInAnyOrderOnlyEntriesExpectationsTest :
+    AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest(
+        functionDescription to Companion::toContainInAnyOrderOnlyEntries,
+        (functionDescription to Companion::toContainInAnyOrderOnlyNullableEntries).withNullableSuffix()
+    ) {
+    companion object : IterableToContainSpecBase() {
+        val functionDescription = "$toContain.$inAnyOrder.$only.$entry/$entries"
+
+        private fun toContainInAnyOrderOnlyEntries(
+            expect: Expect<Iterable<Double>>,
+            a: Expect<Double>.() -> Unit,
+            aX: Array<out Expect<Double>.() -> Unit>,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit
+        ): Expect<Iterable<Double>> =
+            if (report === emptyInOrderOnlyReportOptions) {
+                if (aX.isEmpty()) expect.toContain.inAnyOrder.only.entry(a)
+                else expect.toContain.inAnyOrder.only.entries(a, *aX)
+            } else expect.toContain.inAnyOrder.only.entries(a, *aX, report = report)
+
+
+        private fun toContainInAnyOrderOnlyNullableEntries(
+            expect: Expect<Iterable<Double?>>,
+            a: (Expect<Double>.() -> Unit)?,
+            aX: Array<out (Expect<Double>.() -> Unit)?>,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit
+        ): Expect<Iterable<Double?>> =
+            if (report === emptyInOrderOnlyReportOptions) {
+                if (aX.isEmpty()) expect.toContain.inAnyOrder.only.entry(a)
+                else expect.toContain.inAnyOrder.only.entries(a, *aX)
+            } else expect.toContain.inAnyOrder.only.entries(a, *aX, report = report)
+    }
+
+    @Suppress("AssignedValueIsNeverRead", "UNUSED_VARIABLE", "UNUSED_VALUE")
+    @Test
+    fun ambiguityTest() {
+
+        var list: Expect<List<Number>> = expect(listOf(1))
+        var nSet: Expect<Set<Number?>> = expect(setOf(1))
+        var subList: Expect<ArrayList<Number>> = expect(arrayListOf(1))
+        var star: Expect<Collection<*>> = expect(listOf(1))
+
+        var nSetNullable: Expect<Set<Number?>> = expect(setOf(null))
+        var starNullable: Expect<Collection<*>> = expect(listOf(null))
+
+        list = list.toContain.inAnyOrder.only.entry { toEqual(1) }
+        nSet = nSet.toContain.inAnyOrder.only.entry { toEqual(1) }
+        subList = subList.toContain.inAnyOrder.only.entry { toEqual(1) }
+        star = star.toContain.inAnyOrder.only.entry { toEqual(1) }
+
+        nSetNullable = nSetNullable.toContain.inAnyOrder.only.entry(null)
+        starNullable = starNullable.toContain.inAnyOrder.only.entry(null)
+
+        var listEntries: Expect<List<Number>> = expect(listOf(1, 2))
+        var nSetEntries: Expect<Set<Number?>> = expect(setOf(1, 2))
+        var subListEntries: Expect<ArrayList<Number>> = expect(arrayListOf(1, 2))
+        var starEntries: Expect<Collection<*>> = expect(listOf(1, 2))
+
+        var nCollectionEntries: Expect<Collection<Number?>> =
+            expect(listOf(null, 1, null))
+
+        var starNullableEntries: Expect<Collection<*>> =
+            expect(listOf(null, 1, null))
+
+        listEntries = listEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        nSetEntries = nSetEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        subListEntries = subListEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        starEntries = starEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+
+        listEntries = listEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }, report = {}
+        )
+        nSetEntries = nSetEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }, report = {}
+        )
+        subListEntries = subListEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }, report = {}
+        )
+        starEntries = starEntries.toContain.inAnyOrder.only.entries(
+            { toEqual(1) }, { toEqual(2) }, report = {}
+        )
+
+
+        nCollectionEntries =
+            nCollectionEntries.toContain.inAnyOrder.only.entries(null, { toEqual(1) }, null)
+
+        starNullableEntries =
+            starNullableEntries.toContain.inAnyOrder.only.entries(null, { toEqual(1) }, null)
+
+        nCollectionEntries =
+            nCollectionEntries.toContain.inAnyOrder.only.entries(null, { toEqual(1) }, null, report = {})
+
+        starNullableEntries =
+            starNullableEntries.toContain.inAnyOrder.only.entries(null, { toEqual(1) }, null, report = {})
+    }
+}
diff --git a/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt b/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
deleted file mode 100644
index 82b0d6a215..0000000000
--- a/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
+++ /dev/null
@@ -1,76 +0,0 @@
-package ch.tutteli.atrium.api.infix.en_GB
-
-
-import ch.tutteli.atrium.creating.Expect
-import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
-import ch.tutteli.atrium.specs.notImplemented
-
-class IterableToContainInAnyOrderOnlyEntriesExpectationsSpec :
-    ch.tutteli.atrium.specs.integration.IterableToContainInAnyOrderOnlyEntriesExpectationsSpec(
-        getContainsPair(),
-        getContainsNullablePair()
-    ) {
-
-    companion object : IterableToContainSpecBase() {
-        fun getContainsPair() =
-            "$toContain $filler $inAnyOrder $butOnly $inAnyOrderOnlyEntries" to Companion::toContainInAnyOrderOnlyEntries
-
-        private fun toContainInAnyOrderOnlyEntries(
-            expect: Expect<Iterable<Double>>,
-            a: Expect<Double>.() -> Unit,
-            aX: Array<out Expect<Double>.() -> Unit>,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit
-        ): Expect<Iterable<Double>> =
-            if (report === emptyInAnyOrderOnlyReportOptions) {
-                if (aX.isEmpty()) expect toContain o inAny order but only entry a
-                else expect toContain o inAny order but only the entries(a, *aX)
-            } else expect toContain o inAny order but only the entries(a, *aX, reportOptionsInAnyOrderOnly = report)
-
-
-        fun getContainsNullablePair() =
-            "$toContain $filler $inAnyOrder $butOnly $inAnyOrderOnlyEntries" to Companion::toContainInAnyOrderOnlyNullableEntries
-
-        private fun toContainInAnyOrderOnlyNullableEntries(
-            expect: Expect<Iterable<Double?>>,
-            a: (Expect<Double>.() -> Unit)?,
-            aX: Array<out (Expect<Double>.() -> Unit)?>,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit
-        ): Expect<Iterable<Double?>> =
-            if (report === emptyInAnyOrderOnlyReportOptions) {
-                if (aX.isEmpty()) expect toContain o inAny order but only entry a
-                else expect toContain o inAny order but only the entries(a, *aX)
-            } else expect toContain o inAny order but only the entries(a, *aX, reportOptionsInAnyOrderOnly = report)
-    }
-
-    @Suppress("unused", "UNUSED_VALUE")
-    private fun ambiguityTest() {
-        var list: Expect<List<Number>> = notImplemented()
-        var nList: Expect<Set<Number?>> = notImplemented()
-        var subList: Expect<ArrayList<Number>> = notImplemented()
-        var star: Expect<Collection<*>> = notImplemented()
-
-        list = list toContain o inAny order but only entry {}
-        nList = nList toContain o inAny order but only entry {}
-        subList = subList toContain o inAny order but only entry {}
-        star = star toContain o inAny order but only entry {}
-
-        nList = nList toContain o inAny order but only entry (null)
-        star = star toContain o inAny order but only entry (null)
-
-        list = list toContain o inAny order but only the entries({}, {})
-        nList = nList toContain o inAny order but only the entries({}, {})
-        subList = subList toContain o inAny order but only the entries({}, {})
-        star = star toContain o inAny order but only the entries({}, {})
-
-        list = list toContain o inAny order but only the entries({}, {}, reportOptionsInAnyOrderOnly = {})
-        nList = nList toContain o inAny order but only the entries({}, {}, reportOptionsInAnyOrderOnly = {})
-        subList = subList toContain o inAny order but only the entries({}, {}, reportOptionsInAnyOrderOnly = {})
-        star = star toContain o inAny order but only the entries({}, {}, reportOptionsInAnyOrderOnly = {})
-
-        nList = nList toContain o inAny order but only the entries(null, {}, null)
-        star = star toContain o inAny order but only the entries(null, {}, null)
-
-        nList = nList toContain o inAny order but only the entries(null, {}, null, reportOptionsInAnyOrderOnly = {})
-        star = star toContain o inAny order but only the entries(null, {}, null, reportOptionsInAnyOrderOnly = {})
-    }
-}
diff --git a/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt b/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
new file mode 100644
index 0000000000..7739e4f6c6
--- /dev/null
+++ b/apis/infix/atrium-api-infix/src/commonTest/kotlin/ch/tutteli/atrium/api/infix/en_GB/IterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
@@ -0,0 +1,131 @@
+package ch.tutteli.atrium.api.infix.en_GB
+
+
+import ch.tutteli.atrium.creating.Expect
+import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
+import ch.tutteli.atrium.api.verbs.expect
+import ch.tutteli.atrium.specs.integration.AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.emptyInAnyOrderOnlyReportOptions
+import kotlin.test.Test
+
+class IterableToContainInAnyOrderOnlyEntriesExpectationsTest :
+    AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest(
+        getContainsPair(),
+        getContainsNullablePair()
+    ) {
+
+    companion object : IterableToContainSpecBase() {
+        fun getContainsPair() =
+            "$toContain $filler $inAnyOrder $butOnly $inAnyOrderOnlyEntries" to Companion::toContainInAnyOrderOnlyEntries
+
+        private fun toContainInAnyOrderOnlyEntries(
+            expect: Expect<Iterable<Double>>,
+            a: Expect<Double>.() -> Unit,
+            aX: Array<out Expect<Double>.() -> Unit>,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit
+        ): Expect<Iterable<Double>> =
+            if (report === emptyInAnyOrderOnlyReportOptions) {
+                if (aX.isEmpty()) expect toContain o inAny order but only entry a
+                else expect toContain o inAny order but only the entries(a, *aX)
+            } else expect toContain o inAny order but only the entries(a, *aX, reportOptionsInAnyOrderOnly = report)
+
+
+        fun getContainsNullablePair() =
+            "$toContain $filler $inAnyOrder $butOnly $inAnyOrderOnlyEntries" to Companion::toContainInAnyOrderOnlyNullableEntries
+
+        private fun toContainInAnyOrderOnlyNullableEntries(
+            expect: Expect<Iterable<Double?>>,
+            a: (Expect<Double>.() -> Unit)?,
+            aX: Array<out (Expect<Double>.() -> Unit)?>,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit
+        ): Expect<Iterable<Double?>> =
+            if (report === emptyInAnyOrderOnlyReportOptions) {
+                if (aX.isEmpty()) expect toContain o inAny order but only entry a
+                else expect toContain o inAny order but only the entries(a, *aX)
+            } else expect toContain o inAny order but only the entries(a, *aX, reportOptionsInAnyOrderOnly = report)
+    }
+
+    @Suppress("AssignedValueIsNeverRead", "UNUSED_VARIABLE", "UNUSED_VALUE")
+    @Test
+    fun ambiguityTest() {
+        var list: Expect<List<Number>> = expect(listOf(1))
+        var nSet: Expect<Set<Number?>> = expect(setOf(1))
+        var subList: Expect<ArrayList<Number>> = expect(arrayListOf(1))
+        var star: Expect<Collection<*>> = expect(listOf(1))
+
+        var nNullable: Expect<Collection<Number?>> = expect(listOf(null))
+        var starNullable: Expect<Collection<*>> = expect(listOf(null))
+
+        var listEntries: Expect<List<Number>> = expect(listOf(1, 2))
+        var nSetEntries: Expect<Set<Number?>> = expect(setOf(1, 2))
+        var subListEntries: Expect<ArrayList<Number>> = expect(arrayListOf(1, 2))
+        var starEntries: Expect<Collection<*>> = expect(listOf(1, 2))
+
+        var nCollectionEntries: Expect<Collection<Number?>> =
+            expect(listOf(null, 1, null))
+
+        var starNullableEntries: Expect<Collection<*>> =
+            expect(listOf(null, 1, null))
+
+        list = list toContain o inAny order but only entry { toEqual(1) }
+        nSet = nSet toContain o inAny order but only entry { toEqual(1) }
+        subList = subList toContain o inAny order but only entry { toEqual(1) }
+        star = star toContain o inAny order but only entry { toEqual(1) }
+
+        nNullable = nNullable toContain o inAny order but only entry (null)
+        starNullable = starNullable toContain o inAny order but only entry (null)
+
+        listEntries = listEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        nSetEntries = nSetEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        subListEntries = subListEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+        starEntries = starEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) }
+        )
+
+
+        listEntries = listEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) },
+            reportOptionsInAnyOrderOnly = {}
+        )
+        nSetEntries = nSetEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) },
+            reportOptionsInAnyOrderOnly = {}
+        )
+        subListEntries = subListEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) },
+            reportOptionsInAnyOrderOnly = {}
+        )
+        starEntries = starEntries toContain o inAny order but only the entries(
+            { toEqual(1) }, { toEqual(2) },
+            reportOptionsInAnyOrderOnly = {}
+        )
+
+        nCollectionEntries =
+            nCollectionEntries toContain o inAny order but only the entries(
+                null, { toEqual(1) }, null
+            )
+
+        starNullableEntries =
+            starNullableEntries toContain o inAny order but only the entries(
+                null, { toEqual(1) }, null
+            )
+
+        nCollectionEntries =
+            nCollectionEntries toContain o inAny order but only the entries(
+                null, { toEqual(1) }, null,
+                reportOptionsInAnyOrderOnly = {}
+            )
+
+        starNullableEntries =
+            starNullableEntries toContain o inAny order but only the entries(
+                null, { toEqual(1) }, null,
+                reportOptionsInAnyOrderOnly = {}
+            )
+    }
+}
diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
new file mode 100644
index 0000000000..0870fb32c7
--- /dev/null
+++ b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest.kt
@@ -0,0 +1,623 @@
+package ch.tutteli.atrium.specs.integration
+
+import ch.tutteli.atrium.api.fluent.en_GB.*
+import ch.tutteli.atrium.api.verbs.internal.expect
+import ch.tutteli.atrium.creating.Expect
+import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
+import ch.tutteli.atrium.logic.utils.expectLambda
+import ch.tutteli.atrium.specs.integration.utils.SubjectLessTestData
+import ch.tutteli.atrium.testfactories.TestFactory
+import ch.tutteli.atrium.specs.integration.utils.ExpectationCreatorTestData
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.anElementWhichNeedsDescr
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.toBeGreaterThanFun
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.toBeLessThanFun
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.toEqualFun
+
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.additionalElements
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.emptyInAnyOrderOnlyReportOptions
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.emptyIterable
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.mismatches
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.mismatchesAdditionalElements
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.oneToEleven
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.oneToFour
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.separator
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.sizeDescr
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.toContainInAnyOrderOnly
+import ch.tutteli.atrium.specs.integration.IterableToContainSpecBase.Companion.toContainSize
+
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.toBeGreaterThanDescr
+import ch.tutteli.atrium.specs.integration.IterableToContainEntriesSpecBase.Companion.toBeLessThanDescr
+import ch.tutteli.atrium.specs.*
+
+@Suppress("FunctionName")
+abstract class AbstractIterableToContainInAnyOrderOnlyEntriesExpectationsTest(
+    private val toContainInAnyOrderOnlyEntriesSpec: Fun3<Iterable<Double>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>, InAnyOrderOnlyReportingOptions.() -> Unit>,
+    private val toContainInAnyOrderOnlyNullableEntriesSpec: Fun3<Iterable<Double?>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>, InAnyOrderOnlyReportingOptions.() -> Unit>
+) : ExpectationFunctionBaseTest() {
+
+    @TestFactory
+    fun subjectLessTest() = subjectLessTestFactory(
+        SubjectLessTestData(
+            toContainInAnyOrderOnlyEntriesSpec.forSubjectLessTest(
+                { toEqual(2.5) },
+                arrayOf(),
+                emptyInAnyOrderOnlyReportOptions
+            )
+        ),
+        SubjectLessTestData(
+            toContainInAnyOrderOnlyNullableEntriesSpec.forSubjectLessTest(
+                null,
+                arrayOf(),
+                emptyInAnyOrderOnlyReportOptions
+            )
+        )
+    )
+    @TestFactory
+    fun expectationCreatorTest() = expectationCreatorTestFactory(
+        ExpectationCreatorTestData(
+            listOf(1.2, 2.1),
+            toContainInAnyOrderOnlyEntriesSpec.forExpectationCreatorTest(
+                "$toEqualDescr: 1.2",
+                "$toEqualDescr: 2.1",
+                { toEqual(1.2) },
+                arrayOf(expectLambda { toEqual(2.1) }),
+                emptyInAnyOrderOnlyReportOptions
+            )
+        ),
+        ExpectationCreatorTestData(
+            listOf(1.2, 2.1),
+            toContainInAnyOrderOnlyNullableEntriesSpec.forExpectationCreatorTest(
+                "$toEqualDescr: 1.2",
+                "$toEqualDescr: 2.1",
+                { toEqual(1.2) },
+                arrayOf(expectLambda { toEqual(2.1) }),
+                emptyInAnyOrderOnlyReportOptions
+            )
+        )
+    )
+
+
+    //@formatter:off
+    val anEntryAfterSuccess = "$anElementWhichNeedsDescr: $separator$indentRootBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
+    val anEntryAfterFailing = "$anElementWhichNeedsDescr: $separator$indentRootBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
+    //@formatter:on
+
+    @TestFactory
+    fun empty_collection() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("$toBeLessThanFun(1.1) throws AssertionError") {
+            expect {
+                expect(emptyIterable()).toContainEntriesFun({ toBeLessThan(1.1) })
+            }.toThrow<AssertionError> {
+                message {
+                    toContain(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$failingBulletPoint$anEntryAfterFailing$toBeLessThanDescr: 1.1"
+                    )
+                    notToContain(additionalElements)
+                    toContainSize(0, 1)
+                }
+            }
+        }
+
+        it("$toBeLessThanFun(1.1) and $toBeGreaterThanFun(4.1) throws AssertionError") {
+            expect {
+                expect(emptyIterable()).toContainEntriesFun(
+                    { toBeLessThan(1.1) },
+                    { toBeGreaterThan(4.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$failingBulletPoint$anEntryAfterFailing$toBeLessThanDescr: 1.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toBeGreaterThanDescr: 4.1"
+                    )
+                    notToContain(additionalElements)
+                    toContainSize(0, 2)
+                }
+            }
+        }
+    }
+
+    @TestFactory
+    fun happy_cases() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        listOf(
+            arrayOf(1.1, 2.1, 3.1, 4.1, 4.1),
+            arrayOf(1.1, 3.1, 2.1, 4.1, 4.1),
+            arrayOf(3.1, 4.1, 2.1, 1.1, 4.1),
+            arrayOf(2.1, 4.1, 4.1, 1.1, 3.1),
+            arrayOf(2.1, 4.1, 1.1, 4.1, 3.1),
+            arrayOf(4.1, 4.1, 3.1, 2.1, 1.1)
+        ).forEach {
+            it("${it.joinToString()} with matcher $toEqualFun") {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(it.first()) },
+                    *(it.drop(1).map {
+                        val f: Expect<Double>.() -> Unit = { toEqual(it) }
+                        f
+                    }).toTypedArray()
+                )
+            }
+        }
+
+        it("1.1, 2.1, 3.1, 4.1 and $toBeGreaterThanFun(0.1)") {
+            expect(oneToFour()).toContainEntriesFun(
+                { toEqual(1.1) },
+                { toEqual(2.1) },
+                { toEqual(3.1) },
+                { toEqual(4.1) },
+                { toBeGreaterThan(0.1) }
+            )
+        }
+
+        it(" $toBeLessThanFun(3.1), 2.1, 3.1, 4.1 and 4.1") {
+            expect(oneToFour()).toContainEntriesFun(
+                { toBeLessThan(3.1) },
+                { toEqual(2.1) },
+                { toEqual(3.1) },
+                { toEqual(4.1) },
+                { toEqual(4.1) }
+            )
+        }
+
+        it("2.1, $toBeLessThanFun(5.1), 3.1, 4.1 and 4.1") {
+            expect(oneToFour()).toContainEntriesFun(
+                { toEqual(2.1) },
+                { toBeLessThan(5.1) },
+                { toEqual(3.1) },
+                { toEqual(4.1) },
+                { toEqual(4.1) }
+            )
+        }
+    }
+
+
+    @TestFactory
+    fun error_case_additional_entries() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("1.1, 2.1, 3.1, 4.1 -- 4.1 was missing") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
+                        "$warningBulletPoint$additionalElements:",
+                        "${listBulletPoint}4.1"
+                    )
+                    toContainSize(5, 4)
+                }
+            }
+        }
+
+        it("$toBeLessThanFun(3.1), isGreaterThan(3.1) -- 2.1, 3.1 and 4.1 was missing") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toBeLessThan(3.1) },
+                    { toBeGreaterThan(3.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 3.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toBeGreaterThanDescr: 3.1",
+                        "$warningBulletPoint$additionalElements:",
+                        "${listBulletPoint}2.1",
+                        "${listBulletPoint}3.1",
+                        "${listBulletPoint}4.1"
+                    )
+                    toContainSize(5, 2)
+                }
+            }
+        }
+    }
+
+    @TestFactory
+    fun error_case_mismatches() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("first wins: $toBeLessThanFun(5.1), 1.1, 2.1, 3.1, 4.1") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toBeLessThan(5.1) },
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 5.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
+                        "$warningBulletPoint$mismatches:",
+                        "${listBulletPoint}4.1"
+                    )
+                    notToContain(sizeDescr)
+                }
+            }
+        }
+    }
+
+    @TestFactory
+    fun error_case_mismatches_and_additional_entries() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("1.1, $toBeGreaterThanFun(3.1), $toBeGreaterThanFun(4.1) -- $toBeGreaterThanFun(4.1) is wrong and 2.1, 3.1 and 4.1 are missing") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toBeGreaterThan(3.1) },
+                    { toBeGreaterThan(4.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toBeGreaterThanDescr: 3.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toBeGreaterThanDescr: 4.1",
+                        "$warningBulletPoint$mismatchesAdditionalElements:",
+                        "${listBulletPoint}2.1",
+                        "${listBulletPoint}3.1",
+                        "${listBulletPoint}4.1"
+                    )
+                    toContainSize(5, 3)
+                }
+            }
+        }
+    }
+
+    @TestFactory
+    fun error_case_too_many_matchers() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("1.1, 2.1, 3.1, 4.1, 4.1, 5.1 -- 5.1 was too much") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) },
+                    { toEqual(4.1) },
+                    { toEqual(5.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
+                        "$failingBulletPoint$anEntryAfterSuccess$toEqualDescr: 5.1"
+                    )
+                    toContain.exactly(2)
+                        .value("$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1")
+                    toContainSize(5, 6)
+                    notToContain(
+                        additionalElements,
+                        mismatches,
+                        mismatchesAdditionalElements
+                    )
+                }
+            }
+        }
+    }
+
+
+    @TestFactory
+    fun report_options() = testFactoryNonNullable(
+        toContainInAnyOrderOnlyEntriesSpec,
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainEntriesFunArr ->
+        fun Expect<Iterable<Double>>.toContainEntriesFun(
+            t: Expect<Double>.() -> Unit,
+            vararg tX: Expect<Double>.() -> Unit,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
+        ) = toContainEntriesFunArr(t, tX, report)
+
+        it("shows only failing with report option `showOnlyFailing`") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(2.1) },
+                    report = { showOnlyFailing() }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContainSize(5, 1)
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$warningBulletPoint$additionalElements:",
+                        "${listBulletPoint}1.1",
+                        "${listBulletPoint}3.1"
+                    )
+                    toContain.exactly(2).value("${listBulletPoint}4.1")
+                    notToContain("$toEqualDescr: 2.1")
+                }
+            }
+        }
+
+        it("shows only failing with report option `showOnlyFailingIfMoreExpectedElementsThan(3)` because there are 5") {
+            expect {
+                expect(oneToFour()).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) },
+                    { toEqual(4.1) },
+                    { toEqual(5.1) },
+                    report = { showOnlyFailingIfMoreExpectedElementsThan(3) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContainSize(5, 6)
+                    toContain.exactly(1).values(
+                        "$listBulletPoint$anEntryAfterSuccess$toEqualDescr: 5.1"
+                    )
+                    notToContain(
+                        "$toEqualDescr: 1.1",
+                        "$toEqualDescr: 2.1",
+                        "$toEqualDescr: 3.1",
+                        "$toEqualDescr: 4.1"
+                    )
+                    notToContain(
+                        additionalElements,
+                        mismatches,
+                        mismatchesAdditionalElements
+                    )
+                }
+            }
+        }
+
+        it("shows only failing per default as there are more than 10 expected elements") {
+            expect {
+                expect(oneToEleven).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) },
+                    { toEqual(-1.1) },
+                    { toEqual(6.1) },
+                    { toEqual(7.1) },
+                    { toEqual(-2.1) },
+                    { toEqual(9.1) },
+                    { toEqual(10.1) },
+                    { toEqual(11.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$listBulletPoint$anEntryAfterSuccess$toEqualDescr: -1.1",
+                        "$listBulletPoint$anEntryAfterSuccess$toEqualDescr: -2.1",
+                        "$warningBulletPoint$mismatches:",
+                        "${listBulletPoint}5.1",
+                        "${listBulletPoint}8.1"
+                    )
+                    notToContain(
+                        "$toEqualDescr: 1.1",
+                        "$toEqualDescr: 2.1",
+                        "$toEqualDescr: 3.1",
+                        "$toEqualDescr: 4.1",
+                        "$toEqualDescr: 6.1",
+                        "$toEqualDescr: 7.1",
+                        "$toEqualDescr: 9.1",
+                        "$toEqualDescr: 10.1",
+                        "$toEqualDescr: 11.1",
+                        additionalElements,
+                        mismatchesAdditionalElements
+                    )
+                }
+            }
+        }
+
+        it("shows all with report option `showAlwaysSummary`") {
+            expect {
+                expect(oneToEleven).toContainEntriesFun(
+                    { toEqual(1.1) },
+                    { toEqual(2.1) },
+                    { toEqual(3.1) },
+                    { toEqual(4.1) },
+                    { toEqual(-1.1) },
+                    { toEqual(6.1) },
+                    { toEqual(7.1) },
+                    { toEqual(-2.1) },
+                    { toEqual(9.1) },
+                    { toEqual(10.1) },
+                    { toEqual(11.1) },
+                    report = { showAlwaysSummary() }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: -1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 6.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 7.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: -2.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 9.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 10.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 11.1",
+                        "$warningBulletPoint$mismatches:",
+                        "${listBulletPoint}5.1",
+                        "${listBulletPoint}8.1"
+                    )
+                    notToContain(
+                        additionalElements,
+                        mismatchesAdditionalElements
+                    )
+                }
+            }
+        }
+    }
+    private val null1null3 = { sequenceOf(null, 1.1, null, 3.1).constrainOnce().asIterable() }
+
+    @TestFactory
+    fun nullable_happy_cases() = testFactory(
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainInAnyOrderOnlyNullableEntriesFunArr ->
+
+        fun Expect<Iterable<Double?>>.toContainFun(
+            t: (Expect<Double>.() -> Unit)?,
+            vararg tX: (Expect<Double>.() -> Unit)?,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = emptyInAnyOrderOnlyReportOptions
+        ) = toContainInAnyOrderOnlyNullableEntriesFunArr(this, t, tX, report)
+
+        it("null, $toEqualFun(1.1), null, $toEqualFun(3.1)") {
+            expect(null1null3()).toContainFun(
+                null, { toEqual(1.1) }, null, { toEqual(3.1) }
+            )
+        }
+
+        it("$toEqualFun(1.1), null, null, $toEqualFun(3.1)") {
+            expect(null1null3()).toContainFun(
+                { toEqual(1.1) }, null, null, { toEqual(3.1) }
+            )
+        }
+
+        it("$toEqualFun(1.1), null, $toEqualFun(3.1), null") {
+            expect(null1null3()).toContainFun(
+                { toEqual(1.1) }, null, { toEqual(3.1) }, null
+            )
+        }
+
+        it("$toEqualFun(1.1), $toEqualFun(3.1), null, null") {
+            expect(null1null3()).toContainFun(
+                { toEqual(1.1) }, { toEqual(3.1) }, null, null
+            )
+        }
+    }
+
+    @TestFactory
+    fun nullable_error_case_additional_entries() = testFactory(
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainInAnyOrderOnlyNullableEntriesFunArr ->
+
+        fun Expect<Iterable<Double?>>.toContainFun(
+            t: (Expect<Double>.() -> Unit)?,
+            vararg tX: (Expect<Double>.() -> Unit)?,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = emptyInAnyOrderOnlyReportOptions
+        ) = toContainInAnyOrderOnlyNullableEntriesFunArr(this, t, tX, report)
+
+        it("null, $toEqualFun(1.1), $toEqualFun(3.1) -- second null was missing") {
+            expect {
+                expect(null1null3()).toContainFun(
+                    null, { toEqual(1.1) }, { toEqual(3.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
+                        "$warningBulletPoint$additionalElements:",
+                        "${listBulletPoint}null"
+                    )
+                    toContainSize(4, 3)
+                }
+            }
+        }
+    }
+
+    @TestFactory
+    fun nullable_error_case_mismatches() = testFactory(
+        toContainInAnyOrderOnlyNullableEntriesSpec
+    ) { toContainInAnyOrderOnlyNullableEntriesFunArr ->
+
+        fun Expect<Iterable<Double?>>.toContainFun(
+            t: (Expect<Double>.() -> Unit)?,
+            vararg tX: (Expect<Double>.() -> Unit)?,
+            report: InAnyOrderOnlyReportingOptions.() -> Unit = emptyInAnyOrderOnlyReportOptions
+        ) = toContainInAnyOrderOnlyNullableEntriesFunArr(this, t, tX, report)
+
+        it("first wins: $toBeLessThanFun(4.1), null, null, $toEqualDescr(1.1)") {
+            expect {
+                expect(null1null3()).toContainFun(
+                    { toBeLessThan(4.1) },
+                    null,
+                    null,
+                    { toEqual(1.1) }
+                )
+            }.toThrow<AssertionError> {
+                message {
+                    toContain.exactly(2).values(
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null"
+                    )
+                    toContain.exactly(1).values(
+                        "$rootBulletPoint$toContainInAnyOrderOnly:",
+                        "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 4.1",
+                        "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: 1.1",
+                        "$warningBulletPoint$mismatches:",
+                        "${listBulletPoint}3.1"
+                    )
+                    notToContain(sizeDescr)
+                }
+            }
+        }
+    }
+}
diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
deleted file mode 100644
index 95e800aba5..0000000000
--- a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/IterableToContainInAnyOrderOnlyEntriesExpectationsSpec.kt
+++ /dev/null
@@ -1,476 +0,0 @@
-package ch.tutteli.atrium.specs.integration
-
-import ch.tutteli.atrium.api.fluent.en_GB.*
-import ch.tutteli.atrium.api.verbs.internal.expect
-import ch.tutteli.atrium.creating.Expect
-import ch.tutteli.atrium.logic.creating.iterablelike.contains.reporting.InAnyOrderOnlyReportingOptions
-import ch.tutteli.atrium.logic.utils.expectLambda
-import ch.tutteli.atrium.specs.*
-
-abstract class IterableToContainInAnyOrderOnlyEntriesExpectationsSpec(
-    toContainInAnyOrderOnlyEntries: Fun3<Iterable<Double>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>, InAnyOrderOnlyReportingOptions.() -> Unit>,
-    toContainInAnyOrderOnlyNullableEntries: Fun3<Iterable<Double?>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>, InAnyOrderOnlyReportingOptions.() -> Unit>,
-    describePrefix: String = "[Atrium] "
-) : IterableToContainEntriesSpecBase({
-
-    include(object : SubjectLessSpec<Iterable<Double>>(
-        describePrefix,
-        toContainInAnyOrderOnlyEntries.forSubjectLessTest({ toEqual(2.5) }, arrayOf(), emptyInAnyOrderOnlyReportOptions)
-    ) {})
-    include(object : SubjectLessSpec<Iterable<Double?>>(
-        describePrefix,
-        toContainInAnyOrderOnlyNullableEntries.forSubjectLessTest(null, arrayOf(), emptyInAnyOrderOnlyReportOptions)
-    ) {})
-    include(object : AssertionCreatorSpec<Iterable<Double>>(
-        describePrefix, listOf(1.2, 2.1),
-        toContainInAnyOrderOnlyEntries.forExpectationCreatorTest(
-            "$toEqualDescr: 1.2", "$toEqualDescr: 2.1",
-            { toEqual(1.2) }, arrayOf(expectLambda { toEqual(2.1) }), emptyInAnyOrderOnlyReportOptions
-        )
-    ) {})
-    include(object : AssertionCreatorSpec<Iterable<Double?>>(
-        "$describePrefix[nullable] ", listOf(1.2, 2.1),
-        toContainInAnyOrderOnlyNullableEntries.forExpectationCreatorTest(
-            "$toEqualDescr: 1.2", "$toEqualDescr: 2.1",
-            { toEqual(1.2) }, arrayOf(expectLambda { toEqual(2.1) }), emptyInAnyOrderOnlyReportOptions
-        )
-    ) {})
-
-
-    //@formatter:off
-    val anEntryAfterSuccess = "$anElementWhichNeedsDescr: $separator$indentRootBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
-    val anEntryAfterFailing = "$anElementWhichNeedsDescr: $separator$indentRootBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
-    //@formatter:on
-
-    nonNullableCases(
-        describePrefix,
-        toContainInAnyOrderOnlyEntries,
-        toContainInAnyOrderOnlyNullableEntries
-    ) { toContainEntriesFunArr ->
-        fun Expect<Iterable<Double>>.toContainEntriesFun(
-            t: Expect<Double>.() -> Unit,
-            vararg tX: Expect<Double>.() -> Unit,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit = {}
-        ) = toContainEntriesFunArr(t, tX, report)
-
-        context("empty collection") {
-            it("$toBeLessThanFun(1.1) throws AssertionError") {
-                expect {
-                    expect(emptyIterable()).toContainEntriesFun({ toBeLessThan(1.1) })
-                }.toThrow<AssertionError> {
-                    message {
-                        toContain(
-                            "$rootBulletPoint$toContainInAnyOrderOnly:",
-                            "$failingBulletPoint$anEntryAfterFailing$toBeLessThanDescr: 1.1"
-                        )
-                        notToContain(additionalElements)
-                        toContainSize(0, 1)
-                    }
-                }
-            }
-            it("$toBeLessThanFun(1.1) and $toBeGreaterThanFun(4.1) throws AssertionError") {
-                expect {
-                    expect(emptyIterable()).toContainEntriesFun({ toBeLessThan(1.1) }, { toBeGreaterThan(4.1) })
-                }.toThrow<AssertionError> {
-                    message {
-                        toContain.exactly(1).values(
-                            "$rootBulletPoint$toContainInAnyOrderOnly:",
-                            "$failingBulletPoint$anEntryAfterFailing$toBeLessThanDescr: 1.1",
-                            "$failingBulletPoint$anEntryAfterFailing$toBeGreaterThanDescr: 4.1"
-                        )
-                        notToContain(additionalElements)
-                        toContainSize(0, 2)
-                    }
-                }
-            }
-        }
-
-        context("iterable ${oneToFour().toList()}") {
-
-            context("happy cases") {
-
-                listOf(
-                    arrayOf(1.1, 2.1, 3.1, 4.1, 4.1),
-                    arrayOf(1.1, 3.1, 2.1, 4.1, 4.1),
-                    arrayOf(3.1, 4.1, 2.1, 1.1, 4.1),
-                    arrayOf(2.1, 4.1, 4.1, 1.1, 3.1),
-                    arrayOf(2.1, 4.1, 1.1, 4.1, 3.1),
-                    arrayOf(4.1, 4.1, 3.1, 2.1, 1.1)
-                ).forEach {
-                    it("${it.joinToString()} with matcher $toEqualFun") {
-                        expect(oneToFour()).toContainEntriesFun(
-                            { toEqual(it.first()) },
-                            *(it.drop(1).map { val f: Expect<Double>.() -> Unit = { toEqual(it) }; f }).toTypedArray()
-                        )
-                    }
-                }
-
-                it("1.1, 2.1, 3.1, 4.1 and $toBeGreaterThanFun(0.1)") {
-                    expect(oneToFour()).toContainEntriesFun(
-                        { toEqual(1.1) },
-                        { toEqual(2.1) },
-                        { toEqual(3.1) },
-                        { toEqual(4.1) },
-                        { toBeGreaterThan(0.1) })
-                }
-                it(" $toBeLessThanFun(3.1), 2.1, 3.1, 4.1 and 4.1") {
-                    expect(oneToFour()).toContainEntriesFun(
-                        { toBeLessThan(3.1) },
-                        { toEqual(2.1) },
-                        { toEqual(3.1) },
-                        { toEqual(4.1) },
-                        { toEqual(4.1) })
-                }
-                it("2.1, $toBeLessThanFun(5.1), 3.1, 4.1 and 4.1") {
-                    expect(oneToFour()).toContainEntriesFun(
-                        { toEqual(2.1) },
-                        { toBeLessThan(5.1) },
-                        { toEqual(3.1) },
-                        { toEqual(4.1) },
-                        { toEqual(4.1) })
-                }
-            }
-
-            context("error cases (throws AssertionError)") {
-
-                context("additional entries") {
-                    it("1.1, 2.1, 3.1, 4.1 -- 4.1 was missing") {
-                        expect {
-                            expect(oneToFour()).toContainEntriesFun(
-                                { toEqual(1.1) },
-                                { toEqual(2.1) },
-                                { toEqual(3.1) },
-                                { toEqual(4.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
-                                    "$warningBulletPoint$additionalElements:",
-                                    "${listBulletPoint}4.1"
-                                )
-                                toContainSize(5, 4)
-                            }
-                        }
-                    }
-
-                    it("$toBeLessThanFun(3.1), isGreaterThan(3.1) -- 2.1, 3.1 and 4.1 was missing") {
-                        expect {
-                            expect(oneToFour()).toContainEntriesFun({ toBeLessThan(3.1) }, { toBeGreaterThan(3.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 3.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toBeGreaterThanDescr: 3.1",
-                                    "$warningBulletPoint$additionalElements:",
-                                    "${listBulletPoint}2.1",
-                                    "${listBulletPoint}3.1",
-                                    "${listBulletPoint}4.1"
-                                )
-                                toContainSize(5, 2)
-                            }
-                        }
-                    }
-                }
-
-                context("mismatches") {
-                    it("first wins: $toBeLessThanFun(5.1), 1.1, 2.1, 3.1, 4.1") {
-                        expect {
-                            expect(oneToFour()).toContainEntriesFun(
-                                { toBeLessThan(5.1) },
-                                { toEqual(1.1) },
-                                { toEqual(2.1) },
-                                { toEqual(3.1) },
-                                { toEqual(4.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 5.1",
-                                    "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: 1.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
-                                    "$warningBulletPoint$mismatches:",
-                                    "${listBulletPoint}4.1"
-                                )
-                                notToContain(sizeDescr)
-                            }
-                        }
-                    }
-                }
-
-                context("mismatches and additional entries") {
-                    it("1.1, $toBeGreaterThanFun(3.1), $toBeGreaterThanFun(4.1) -- $toBeGreaterThanFun(4.1) is wrong and 2.1, 3.1 and 4.1 are missing") {
-                        expect {
-                            expect(oneToFour()).toContainEntriesFun(
-                                { toEqual(1.1) },
-                                { toBeGreaterThan(3.1) },
-                                { toBeGreaterThan(4.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toBeGreaterThanDescr: 3.1",
-                                    "$failingBulletPoint$anEntryAfterFailing$toBeGreaterThanDescr: 4.1",
-                                    "$warningBulletPoint$mismatchesAdditionalElements:",
-                                    "${listBulletPoint}2.1",
-                                    "${listBulletPoint}3.1",
-                                    "${listBulletPoint}4.1"
-                                )
-                                toContainSize(5, 3)
-                            }
-                        }
-                    }
-                }
-
-                context("too many matcher") {
-                    it("1.1, 2.1, 3.1, 4.1, 4.1, 5.1 -- 5.1 was too much") {
-                        expect {
-                            expect(oneToFour()).toContainEntriesFun(
-                                { toEqual(1.1) },
-                                { toEqual(2.1) },
-                                { toEqual(3.1) },
-                                { toEqual(4.1) },
-                                { toEqual(4.1) },
-                                { toEqual(5.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
-                                    "$failingBulletPoint$anEntryAfterSuccess$toEqualDescr: 5.1"
-                                )
-                                toContain.exactly(2)
-                                    .value("$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1")
-                                toContainSize(5, 6)
-                                notToContain(additionalElements, mismatches, mismatchesAdditionalElements)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        context("report options") {
-            context("iterable ${oneToFour().toList()}") {
-                it("shows only failing with report option `showOnlyFailing`") {
-                    expect {
-                        expect(oneToFour()).toContainEntriesFun({ toEqual(2.1) }, report = { showOnlyFailing() })
-                    }.toThrow<AssertionError> {
-                        message {
-                            toContainSize(5, 1)
-                            toContain.exactly(1).values(
-                                "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                "$warningBulletPoint$additionalElements:",
-                                "${listBulletPoint}1.1",
-                                "${listBulletPoint}3.1"
-                            )
-                            toContain.exactly(2).value("${listBulletPoint}4.1")
-                            notToContain("$toEqualDescr: 2.1")
-
-                        }
-                    }
-                }
-                it("shows only failing with report option `showOnlyFailingIfMoreExpectedElementsThan(3)` because there are 5") {
-                    expect {
-                        expect(oneToFour()).toContainEntriesFun(
-                            { toEqual(1.1) },
-                            { toEqual(2.1) },
-                            { toEqual(3.1) },
-                            { toEqual(4.1) },
-                            { toEqual(4.1) },
-                            { toEqual(5.1) },
-                            report = { showOnlyFailingIfMoreExpectedElementsThan(3) })
-                    }.toThrow<AssertionError> {
-                        message {
-                            toContainSize(5, 6)
-                            toContain.exactly(1).values("$listBulletPoint$anEntryAfterSuccess$toEqualDescr: 5.1")
-                            notToContain(
-                                "$toEqualDescr: 1.1",
-                                "$toEqualDescr: 2.1",
-                                "$toEqualDescr: 3.1",
-                                "$toEqualDescr: 4.1"
-                            )
-                            notToContain(additionalElements, mismatches, mismatchesAdditionalElements)
-                        }
-                    }
-                }
-
-            }
-
-            context("iterable $oneToEleven") {
-                it("shows only failing per default as there are more than 10 expected elements") {
-                    expect {
-                        expect(oneToEleven).toContainEntriesFun(
-                            { toEqual(1.1) },
-                            { toEqual(2.1) },
-                            { toEqual(3.1) },
-                            { toEqual(4.1) },
-                            { toEqual(-1.1) },
-                            { toEqual(6.1) },
-                            { toEqual(7.1) },
-                            { toEqual(-2.1) },
-                            { toEqual(9.1) },
-                            { toEqual(10.1) },
-                            { toEqual(11.1) }
-                        )
-                    }.toThrow<AssertionError> {
-                        message {
-                            toContain.exactly(1).values(
-                                "$listBulletPoint$anEntryAfterSuccess$toEqualDescr: -1.1",
-                                "$listBulletPoint$anEntryAfterSuccess$toEqualDescr: -2.1",
-                                "$warningBulletPoint$mismatches:",
-                                "${listBulletPoint}5.1",
-                                "${listBulletPoint}8.1"
-                            )
-                            notToContain(
-                                "$toEqualDescr: 1.1",
-                                "$toEqualDescr: 2.1",
-                                "$toEqualDescr: 3.1",
-                                "$toEqualDescr: 4.1",
-                                "$toEqualDescr: 6.1",
-                                "$toEqualDescr: 7.1",
-                                "$toEqualDescr: 9.1",
-                                "$toEqualDescr: 10.1",
-                                "$toEqualDescr: 11.1",
-
-                                additionalElements, mismatchesAdditionalElements
-                            )
-                        }
-                    }
-                }
-                it("shows all with report option `showAlwaysSummary`") {
-                    expect {
-                        expect(oneToEleven).toContainEntriesFun(
-                            { toEqual(1.1) },
-                            { toEqual(2.1) },
-                            { toEqual(3.1) },
-                            { toEqual(4.1) },
-                            { toEqual(-1.1) },
-                            { toEqual(6.1) },
-                            { toEqual(7.1) },
-                            { toEqual(-2.1) },
-                            { toEqual(9.1) },
-                            { toEqual(10.1) },
-                            { toEqual(11.1) },
-                            report = { showAlwaysSummary() }
-                        )
-                    }.toThrow<AssertionError> {
-                        message {
-                            toContain.exactly(1).values(
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 2.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 4.1",
-                                "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: -1.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 6.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 7.1",
-                                "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: -2.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 9.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 10.1",
-                                "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 11.1",
-                                "$warningBulletPoint$mismatches:",
-                                "${listBulletPoint}5.1",
-                                "${listBulletPoint}8.1"
-                            )
-                            notToContain(additionalElements, mismatchesAdditionalElements)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    nullableCases(describePrefix) {
-
-        fun Expect<Iterable<Double?>>.toContainFun(
-            t: (Expect<Double>.() -> Unit)?,
-            vararg tX: (Expect<Double>.() -> Unit)?,
-            report: InAnyOrderOnlyReportingOptions.() -> Unit = emptyInAnyOrderOnlyReportOptions
-        ) = toContainInAnyOrderOnlyNullableEntries(this, t, tX, report)
-
-        describeFun(toContainInAnyOrderOnlyNullableEntries) {
-            val null1null3 = { sequenceOf(null, 1.1, null, 3.1).constrainOnce().asIterable() }
-
-            context("iterable ${null1null3().toList()}") {
-                context("happy cases (do not throw)") {
-                    it("null, $toEqualFun(1.1), null, $toEqualFun(3.1)") {
-                        expect(null1null3()).toContainFun(
-                            null, { toEqual(1.1) }, null, { toEqual(3.1) }
-                        )
-                    }
-                    it("$toEqualFun(1.1), null, null, $toEqualFun(3.1)") {
-                        expect(null1null3()).toContainFun(
-                            { toEqual(1.1) }, null, null, { toEqual(3.1) }
-                        )
-                    }
-                    it("$toEqualFun(1.1), null, $toEqualFun(3.1), null") {
-                        expect(null1null3()).toContainFun(
-                            { toEqual(1.1) }, null, { toEqual(3.1) }, null
-                        )
-                    }
-                    it("$toEqualFun(1.1), $toEqualFun(3.1), null, null") {
-                        expect(null1null3()).toContainFun(
-                            { toEqual(1.1) }, { toEqual(3.1) }, null, null
-                        )
-                    }
-                }
-
-                context("failing cases") {
-                    it("null, $toEqualFun(1.1), $toEqualFun(3.1) -- second null was missing") {
-                        expect {
-                            expect(null1null3()).toContainFun(
-                                null, { toEqual(1.1) }, { toEqual(3.1) }
-                            )
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 1.1",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: 3.1",
-                                    "$warningBulletPoint$additionalElements:",
-                                    "${listBulletPoint}null"
-                                )
-                                toContainSize(4, 3)
-                            }
-                        }
-                    }
-
-                    it("first wins: $toBeLessThanFun(4.1), null, null, $toEqualDescr(1.1)") {
-                        expect {
-                            expect(null1null3()).toContainFun(
-                                { toBeLessThan(4.1) },
-                                null,
-                                null,
-                                { toEqual(1.1) })
-                        }.toThrow<AssertionError> {
-                            message {
-                                toContain.exactly(2).values(
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toEqualDescr: null"
-                                )
-                                toContain.exactly(1).values(
-                                    "$rootBulletPoint$toContainInAnyOrderOnly:",
-                                    "$successfulBulletPoint$anEntryAfterSuccess$toBeLessThanDescr: 4.1",
-                                    "$failingBulletPoint$anEntryAfterFailing$toEqualDescr: 1.1",
-                                    "$warningBulletPoint$mismatches:",
-                                    "${listBulletPoint}3.1"
-                                )
-                                notToContain(sizeDescr)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-})