jlengrand/atrium
1
0
Fork 0
mirror of https://github.com/jlengrand/atrium.git synced 2026-03-10 08:01:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #732 from robstoll/cleanup-0.15.0

Browse Source 
Cleanup 0.15.0
This commit is contained in:
Robert Stoll
2020-12-22 22:33:02 +01:00
committed by GitHub
parent 6345a9e689 c6b33b57b4
commit d1fa72c59f
92 changed files with 780 additions and 827 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableAllAssertionsSpec.kt
View File

@@ -10,18 +10,18 @@ object IterableAllAssertionsSpec : ch.tutteli.atrium.specs.integration.IterableA
fun1(Expect<Iterable<Double?>>::all).withNullableSuffix(),
"◆ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ "
) {
@Suppress("unused", "UNUSED_VALUE")
private fun ambiguityTest() {
var a1: Expect<List<Double>> = notImplemented()
var a1b: Expect<Set<Double?>> = notImplemented()
var list: Expect<List<Number>> = notImplemented()
var nList: Expect<Set<Number?>> = notImplemented()
var subList: Expect<ArrayList<out Number>> = notImplemented()
var star: Expect<Collection<*>> = notImplemented()
a1 = a1.all {}
a1b = a1b.all {}
a1b = a1b.all(null)
list = list.all {}
nList = nList.all {}
subList = subList.all {}
star = star.all {}
}
}

56
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableAnyAssertionsSpec.kt
View File

@@ -1,7 +1,6 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.domain.builders.ExpectImpl
import ch.tutteli.atrium.logic._logic
import ch.tutteli.atrium.logic.changeSubject
import ch.tutteli.atrium.specs.fun1
@@ -9,6 +8,7 @@ import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction2
import ch.tutteli.atrium.api.fluent.en_GB.IterableAnyAssertionsSpec.Companion as C
class IterableAnyAssertionsSpec : Spek({
include(PredicateSpec)
@@ -24,19 +24,22 @@ class IterableAnyAssertionsSpec : Spek({
)
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableAnyAssertionsSpec(
getContainsPair(),
getContainsNullablePair().withNullableSuffix(),
functionDescription to C::containsEntry,
(functionDescription to C::containsNullableEntry).withNullableSuffix(),
"◆ ",
"[Atrium][Builder] "
)
// TODO 0.17.0 #722 this will differ once we don't implement the same behaviour for contains and none
// that's fine and we can simply remove this test here
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableAnyAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair().withNullableSuffix(),
shortcutDescription to C::containsEntryShortcut,
(shortcutDescription to C::containsNullableEntryShortcut).withNullableSuffix(),
"◆ ",
"[Atrium][Shortcut] "
)
// TODO move to own SequenceSpec if we really need this (maybe we can also just delete it?)
object SequenceSpec : ch.tutteli.atrium.specs.integration.IterableAnyAssertionsSpec(
getContainsSequencePair(),
getContainsNullableSequencePair().withNullableSuffix(),
@@ -45,31 +48,19 @@ class IterableAnyAssertionsSpec : Spek({
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderEntries" to Companion::containsInAnyOrderEntry
val functionDescription = "$contains.$inAnyOrder.$atLeast(1).$entry"
val shortcutDescription = "$contains"
private fun containsInAnyOrderEntry(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
private fun containsEntry(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
expect.contains.inAnyOrder.atLeast(1).entry(a)
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderEntries" to Companion::containsNullableEntry
private fun containsNullableEntry(expect: Expect<Iterable<Double?>>, a: (Expect<Double>.() -> Unit)?) =
expect.contains.inAnyOrder.atLeast(1).entry(a)
private val containsShortcutFun: KFunction2<Expect<Iterable<Double>>, Expect<Double>.() -> Unit, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::contains
fun getContainsShortcutPair() = containsShortcutFun.name to Companion::containsInAnyOrderEntryShortcut
private fun containsInAnyOrderEntryShortcut(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
private fun containsEntryShortcut(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
expect.contains(a)
private val containsShortcutNullableFun: KFunction2<Expect<Iterable<Double?>>, (Expect<Double>.() -> Unit)?, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::contains
fun getContainsNullableShortcutPair() =
containsShortcutNullableFun.name to Companion::containsNullableEntryShortcut
private fun containsNullableEntryShortcut(
expect: Expect<Iterable<Double?>>,
@@ -78,13 +69,13 @@ class IterableAnyAssertionsSpec : Spek({
private fun getContainsSequencePair() =
"asSequence().${Sequence<*>::asIterable.name}().${containsShortcutFun.name}" to Companion::containsInAnyOrderEntrySequence
"asSequence().${Sequence<*>::asIterable.name}().$contains" to Companion::containsInAnyOrderEntrySequence
private fun containsInAnyOrderEntrySequence(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
expect._logic.changeSubject.unreported { it.asSequence() }.asIterable().contains(a)
fun getContainsNullableSequencePair() =
"asSequence().${Sequence<*>::asIterable.name}().${containsShortcutNullableFun.name}" to Companion::containsNullableEntrySequence
"asSequence().${Sequence<*>::asIterable.name}().$contains" to Companion::containsNullableEntrySequence
private fun containsNullableEntrySequence(
expect: Expect<Iterable<Double?>>,
@@ -92,22 +83,17 @@ class IterableAnyAssertionsSpec : Spek({
) = expect._logic.changeSubject.unreported { it.asSequence() }.asIterable().contains(a)
}
@Suppress("unused", "UNUSED_VALUE")
private fun ambiguityTest() {
var a1: Expect<List<Double>> = notImplemented()
var a1b: Expect<Set<Double?>> = notImplemented()
var list: Expect<List<Number>> = notImplemented()
var nList: Expect<Set<Number?>> = notImplemented()
var subList: Expect<ArrayList<out Number>> = notImplemented()
var star: Expect<Collection<*>> = notImplemented()
a1 = a1.any {}
a1 = a1.contains {}
a1b = a1b.any {}
a1b = a1b.any(null)
a1b = a1b.contains {}
a1b = a1b.contains(null)
list = list.any {}
nList = nList.any {}
subList = subList.any {}
star = star.any {}
star = star.contains {}
}
}

58
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderAtLeast1ElementsOfAssertionsSpec.kt
View File

@@ -1,8 +1,10 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction2
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInAnyOrderAtLeast1ElementsOfAssertionsSpec.Companion as C
class IterableContainsInAnyOrderAtLeast1ElementsOfAssertionsSpec : Spek({
include(BuilderSpec)
@@ -11,33 +13,34 @@ class IterableContainsInAnyOrderAtLeast1ElementsOfAssertionsSpec : Spek({
include(ShortcutIterableLikeToIterableSpec)
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsValues,
(functionDescription to C::containsNullableValues).withNullableSuffix(),
"◆ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
shortcutDescription to C::containsInAnyOrderShortcut,
(shortcutDescription to C::containsInAnyOrderNullableShortcut).withNullableSuffix(),
"◆ ",
"[Atrium][Shortcut] "
)
object BuilderIterableLikeToIterableSpec : ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderElementsOf",
functionDescription,
listOf(1, 2),
{ input -> contains.inAnyOrder.atLeast(1).elementsOf(input) }
)
object ShortcutIterableLikeToIterableSpec : ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
"containsElementsOf",
shortcutDescription,
listOf(1, 2),
{ input -> containsElementsOf(input) }
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() = "$contains.$inAnyOrder.$atLeast(1).$inAnyOrderElementsOf" to Companion::containsValues
val functionDescription = "$contains.$inAnyOrder.$atLeast(1).$elementsOf"
val shortcutDescription = Expect<Iterable<Double>>::containsElementsOf.name
private fun containsValues(
expect: Expect<Iterable<Double>>,
@@ -45,37 +48,46 @@ class IterableContainsInAnyOrderAtLeast1ElementsOfAssertionsSpec : Spek({
aX: Array<out Double>
): Expect<Iterable<Double>> = expect.contains.inAnyOrder.atLeast(1).elementsOf(listOf(a, *aX))
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderElementsOf" to Companion::containsNullableValues
private fun containsNullableValues(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> = expect.contains.inAnyOrder.atLeast(1).elementsOf(sequenceOf(a, *aX))
private val containsElementsOfShortcutFun: KFunction2<Expect<Iterable<Double>>, Iterable<Double>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::containsElementsOf
private fun getContainsShortcutPair() =
containsElementsOfShortcutFun.name to Companion::containsInAnyOrderShortcut
private fun containsInAnyOrderShortcut(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> = expect.containsElementsOf(arrayOf(a, *aX))
private val containsElementsOfNullableShortcutFun: KFunction2<Expect<Iterable<Double?>>, Iterable<Double?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::containsElementsOf
private fun getContainsNullableShortcutPair() =
containsElementsOfNullableShortcutFun.name to Companion::containsInAnyOrderNullableShortcut;
private fun containsInAnyOrderNullableShortcut(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> = expect.containsElementsOf(sequenceOf(a, *aX).asIterable())
}
@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.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1))
nList = nList.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1))
subList = subList.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1))
star = star.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1))
list = list.containsElementsOf(listOf(1))
nList = nList.containsElementsOf(listOf(1))
subList = subList.containsElementsOf(listOf(1))
star = star.containsElementsOf(listOf(1))
list = list.containsElementsOf(listOf(1, 1.2))
nList = nList.containsElementsOf(listOf(1, 1.2))
subList = subList.containsElementsOf(listOf(1, 2.2))
subList = subList.containsElementsOf(listOf(1))
star = star.containsElementsOf(listOf(1, 1.2, "asdf"))
}
}

73
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec.kt
View File

@@ -1,30 +1,32 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.fun2
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction3
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec.Companion as C
class IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec : Spek({
include(BuilderSpec)
include(ShortcutSpec)
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsInAnyOrderEntries,
(functionDescription to C::containsNullableEntries).withNullableSuffix(),
"◆ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
fun2<Iterable<Double>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>>(Expect<Iterable<Double>>::contains),
fun2<Iterable<Double?>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>>(Expect<Iterable<Double?>>::contains).withNullableSuffix(),
"◆ ",
"[Atrium][Shortcut] "
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderEntries" to Companion::containsInAnyOrderEntries
val functionDescription = "$contains.$inAnyOrder.$atLeast(1).$entry/$entries"
private fun containsInAnyOrderEntries(
expect: Expect<Iterable<Double>>,
@@ -34,9 +36,6 @@ class IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec : Spek({
if (aX.isEmpty()) expect.contains.inAnyOrder.atLeast(1).entry(a)
else expect.contains.inAnyOrder.atLeast(1).entries(a, *aX)
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderEntries" to Companion::containsNullableEntries
private fun containsNullableEntries(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
@@ -44,32 +43,46 @@ class IterableContainsInAnyOrderAtLeast1EntriesAssertionsSpec : Spek({
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inAnyOrder.atLeast(1).entry(a)
else expect.contains.inAnyOrder.atLeast(1).entries(a, *aX)
}
private val containsShortcutFun: KFunction3<Expect<Iterable<Double>>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::contains
@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()
fun getContainsShortcutPair() = containsShortcutFun.name to Companion::containsInAnyOrderEntriesShortcut
list = list.contains.inAnyOrder.atLeast(1).entry {}
nList = nList.contains.inAnyOrder.atLeast(1).entry {}
subList = subList.contains.inAnyOrder.atLeast(1).entry {}
star = star.contains.inAnyOrder.atLeast(1).entry {}
private fun containsInAnyOrderEntriesShortcut(
expect: Expect<Iterable<Double>>,
a: Expect<Double>.() -> Unit,
aX: Array<out Expect<Double>.() -> Unit>
): Expect<Iterable<Double>> =
if (aX.isEmpty()) expect.contains(a)
else expect.contains(a, *aX)
nList = nList.contains.inAnyOrder.atLeast(1).entry(null)
star = star.contains.inAnyOrder.atLeast(1).entry(null)
private val containsEntriesFun: KFunction3<Expect<Iterable<Double?>>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::contains
list = list.contains.inAnyOrder.atLeast(1).entries({}, {})
nList = nList.contains.inAnyOrder.atLeast(1).entries({}, {})
subList = subList.contains.inAnyOrder.atLeast(1).entries({}, {})
star = star.contains.inAnyOrder.atLeast(1).entries({}, {})
fun getContainsNullableShortcutPair() = containsEntriesFun.name to Companion::containsNullableEntriesShortcut
nList = nList.contains.inAnyOrder.atLeast(1).entries(null, {}, null)
star = star.contains.inAnyOrder.atLeast(1).entries(null, {}, null)
private fun containsNullableEntriesShortcut(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
aX: Array<out (Expect<Double>.() -> Unit)?>
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains(a)
else expect.contains(a, *aX)
list = list.contains {}
nList = nList.contains {}
subList = subList.contains {}
star = star.contains {}
nList = nList.contains(null)
star = star.contains(null)
list = list.contains({}, {})
nList = nList.contains({}, {})
subList = subList.contains({}, {})
star = star.contains({}, {})
nList = nList.contains(null, {}, null)
star = star.contains(null, {}, null)
}
}

67
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec.kt
View File

@@ -1,29 +1,32 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.fun2
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction3
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec.Companion as C
class IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec : Spek({
include(BuilderSpec)
include(ShortcutSpec)
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsValues,
(functionDescription to C::containsNullableValues).withNullableSuffix(),
"◆ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
fun2<Iterable<Double>, Double, Array<out Double>>(Expect<Iterable<Double>>::contains),
fun2<Iterable<Double?>, Double?, Array<out Double?>>(Expect<Iterable<Double?>>::contains),
"◆ ",
"[Atrium][Shortcut] "
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() = "$contains.$inAnyOrder.$atLeast(1).$inAnyOrderValues" to Companion::containsValues
val functionDescription = "$contains.$inAnyOrder.$atLeast(1).$value/$values"
private fun containsValues(
expect: Expect<Iterable<Double>>,
@@ -33,9 +36,6 @@ class IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec : Spek({
if (aX.isEmpty()) expect.contains.inAnyOrder.atLeast(1).value(a)
else expect.contains.inAnyOrder.atLeast(1).values(a, *aX)
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$atLeast(1).$inAnyOrderValues" to Companion::containsNullableValues
private fun containsNullableValues(
expect: Expect<Iterable<Double?>>,
a: Double?,
@@ -43,34 +43,35 @@ class IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec : Spek({
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inAnyOrder.atLeast(1).value(a)
else expect.contains.inAnyOrder.atLeast(1).values(a, *aX)
}
@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()
private val containsFun: KFunction3<Expect<Iterable<Double>>, Double, Array<out Double>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::contains
list = list.contains.inAnyOrder.atLeast(1).value(1)
nList = nList.contains.inAnyOrder.atLeast(1).value(1)
subList = subList.contains.inAnyOrder.atLeast(1).value(1)
star = star.contains.inAnyOrder.atLeast(1).value(1)
fun getContainsShortcutPair() = containsFun.name to Companion::containsValuesShortcut
list = list.contains.inAnyOrder.atLeast(1).values(1, 1.2)
nList = nList.contains.inAnyOrder.atLeast(1).values(1, 1.2)
subList = subList.contains.inAnyOrder.atLeast(1).values(1, 2.2)
star = star.contains.inAnyOrder.atLeast(1).values(1, 1.2, "asdf")
private fun containsValuesShortcut(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> =
if (aX.isEmpty()) expect.contains(a)
else expect.contains(a, *aX)
private val containsNullableFun: KFunction3<Expect<Iterable<Double?>>, Double?, Array<out Double?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::contains
fun getContainsNullableShortcutPair() = containsNullableFun.name to Companion::containsNullableValuesShortcut
private fun containsNullableValuesShortcut(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains(a)
else expect.contains(a, *aX)
list = list.contains(1)
nList = nList.contains(1)
subList = subList.contains(1)
star = star.contains(1)
list = list.contains(1, 1.2)
nList = nList.contains(1, 1.2)
subList = subList.contains(1, 2.2)
// TODO would wish this does not work, maybe @OnlyInputTypes would help?
subList = subList.contains("asdf")
star = star.contains(1, 1.2, "asdf")
}
}

2
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderAtLeastValuesAssertionsSpec.kt
View File

@@ -52,4 +52,6 @@ class IterableContainsInAnyOrderAtLeastValuesAssertionsSpec :
internal fun getErrorMsgAtLeastButAtMost(timesAtLeast: Int, timesButAtMost: Int) =
"specifying $butAtMost($timesButAtMost) does not make sense if $atLeast($timesAtLeast) was used before"
}
// ambiguityTests see IterableContainsInAnyOrderAtLeast1ValuesAssertionsSpec
}

19
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderAtMostValuesAssertionsSpec.kt
View File

@@ -1,6 +1,7 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
class IterableContainsInAnyOrderAtMostValuesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderAtMostValuesAssertionSpec(
@@ -29,4 +30,22 @@ class IterableContainsInAnyOrderAtMostValuesAssertionsSpec :
private fun getErrorMsgExactly(times: Int) =
"use $exactly($times) instead of $atMost($times); $atMost($times) defines implicitly $atLeast($times) as well"
}
@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.contains.inAnyOrder.atMost(2).value(1)
nList = nList.contains.inAnyOrder.atMost(2).value(1)
subList = subList.contains.inAnyOrder.atMost(2).value(1)
star = star.contains.inAnyOrder.atMost(2).value(1)
list = list.contains.inAnyOrder.atMost(2).values(1, 1.2)
nList = nList.contains.inAnyOrder.atMost(2).values(1, 1.2)
subList = subList.contains.inAnyOrder.atMost(2).values(1, 2.2)
star = star.contains.inAnyOrder.atMost(2).values(1, 1.2, "asdf")
}
}

21
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderExactlyValuesAssertionsSpec.kt
View File

@@ -1,6 +1,7 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
class IterableContainsInAnyOrderExactlyValuesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderExactlyValuesAssertionsSpec(
@@ -27,6 +28,24 @@ class IterableContainsInAnyOrderExactlyValuesAssertionsSpec :
private fun getContainsNotPair() = containsNot to Companion::getErrorMsgContainsNot
private fun getErrorMsgContainsNot(times: Int) = "use $containsNot instead of $exactly($times)"
}
@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.contains.inAnyOrder.exactly(2).value(1)
nList = nList.contains.inAnyOrder.exactly(2).value(1)
subList = subList.contains.inAnyOrder.exactly(2).value(1)
star = star.contains.inAnyOrder.exactly(2).value(1)
list = list.contains.inAnyOrder.exactly(2).values(1, 1.2)
nList = nList.contains.inAnyOrder.exactly(2).values(1, 1.2)
subList = subList.contains.inAnyOrder.exactly(2).values(1, 2.2)
star = star.contains.inAnyOrder.exactly(2).values(1, 1.2, "asdf")
}
}

18
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderNotOrAtMostValuesAssertionsSpec.kt
View File

@@ -1,6 +1,7 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
class IterableContainsInAnyOrderNotOrAtMostValuesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderNotOrAtMostValuesAssertionsSpec(
@@ -25,6 +26,23 @@ class IterableContainsInAnyOrderNotOrAtMostValuesAssertionsSpec :
private fun getContainsNotPair() = containsNot to Companion::getErrorMsgContainsNot
private fun getErrorMsgContainsNot(times: Int) = "use $containsNot instead of $notOrAtMost($times)"
}
@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.contains.inAnyOrder.notOrAtMost(1).value(1)
nList = nList.contains.inAnyOrder.notOrAtMost(1).value(1)
subList = subList.contains.inAnyOrder.notOrAtMost(1).value(1)
star = star.contains.inAnyOrder.notOrAtMost(1).value(1)
list = list.contains.inAnyOrder.notOrAtMost(1).values(1, 1.2)
nList = nList.contains.inAnyOrder.notOrAtMost(1).values(1, 1.2)
subList = subList.contains.inAnyOrder.notOrAtMost(1).values(1, 2.2)
star = star.contains.inAnyOrder.notOrAtMost(1).values(1, 1.2, "asdf")
}
}

33
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderOnlyElementsOfAssertionsSpec.kt
View File

@@ -1,41 +1,54 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInAnyOrderOnlyElementsOfAssertionsSpec.Companion as C
class IterableContainsInAnyOrderOnlyElementsOfAssertionsSpec : Spek({
include(BuilderSpec)
include(BuilderIterableLikeToIterableSpec)
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderOnlyValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsElementsOf,
(functionDescription to C::containsElementsOfNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» "
)
object BuilderIterableLikeToIterableSpec : ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyElementsOf",
functionDescription,
listOf(1, 2),
{ input -> contains.inAnyOrder.only.elementsOf(input) }
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyElementsOf" to Companion::getContainsValues
val functionDescription = "$contains.$inAnyOrder.$only.$elementsOf"
private fun getContainsValues(
private fun containsElementsOf(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> = expect.contains.inAnyOrder.only.elementsOf(listOf(a, *aX))
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyElementsOf" to Companion::getContainsNullableValues
private fun getContainsNullableValues(
private fun containsElementsOfNullable(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> = expect.contains.inAnyOrder.only.elementsOf(sequenceOf(a, *aX))
}
@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.contains.inAnyOrder.only.elementsOf(listOf<Int>())
nList = nList.contains.inAnyOrder.only.elementsOf(listOf<Int>())
subList = subList.contains.inAnyOrder.only.elementsOf(listOf<Int>())
star = star.contains.inAnyOrder.only.elementsOf(listOf<Int>())
}
}

37
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -1,16 +1,17 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
class IterableContainsInAnyOrderOnlyEntriesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderOnlyEntriesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to Companion::containsInAnyOrderOnlyEntries,
(functionDescription to Companion::containsInAnyOrderOnlyNullableEntries).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» "
) {
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyEntries" to Companion::containsInAnyOrderOnlyEntries
val functionDescription = "$contains.$inAnyOrder.$only.$entry/$entries"
private fun containsInAnyOrderOnlyEntries(
expect: Expect<Iterable<Double>>,
@@ -20,10 +21,6 @@ class IterableContainsInAnyOrderOnlyEntriesAssertionsSpec :
if (aX.isEmpty()) expect.contains.inAnyOrder.only.entry(a)
else expect.contains.inAnyOrder.only.entries(a, *aX)
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyEntries" to Companion::containsInAnyOrderOnlyNullableEntries
private fun containsInAnyOrderOnlyNullableEntries(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
@@ -31,6 +28,30 @@ class IterableContainsInAnyOrderOnlyEntriesAssertionsSpec :
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inAnyOrder.only.entry(a)
else expect.contains.inAnyOrder.only.entries(a, *aX)
}
@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.contains.inAnyOrder.only.entry {}
nList = nList.contains.inAnyOrder.only.entry {}
subList = subList.contains.inAnyOrder.only.entry {}
star = star.contains.inAnyOrder.only.entry {}
nList = nList.contains.inAnyOrder.only.entry(null)
star = star.contains.inAnyOrder.only.entry(null)
list = list.contains.inAnyOrder.only.entries({}, {})
nList = nList.contains.inAnyOrder.only.entries({}, {})
subList = subList.contains.inAnyOrder.only.entries({}, {})
star = star.contains.inAnyOrder.only.entries({}, {})
nList = nList.contains.inAnyOrder.only.entries(null, {}, null)
star = star.contains.inAnyOrder.only.entries(null, {}, null)
}
}

30
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInAnyOrderOnlyValuesAssertionsSpec.kt
View File

@@ -1,16 +1,17 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
class IterableContainsInAnyOrderOnlyValuesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInAnyOrderOnlyValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to Companion::containsInAnyOrderOnlyValues,
(functionDescription to Companion::containsInAnyOrderOnlyNullableValues).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ "
) {
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyValues" to Companion::containsInAnyOrderOnlyValues
val functionDescription = "$contains.$inAnyOrder.$only.$value/$values"
private fun containsInAnyOrderOnlyValues(
expect: Expect<Iterable<Double>>,
@@ -20,10 +21,6 @@ class IterableContainsInAnyOrderOnlyValuesAssertionsSpec :
if (aX.isEmpty()) expect.contains.inAnyOrder.only.value(a)
else expect.contains.inAnyOrder.only.values(a, *aX)
fun getContainsNullablePair() =
"$contains.$inAnyOrder.$only.$inAnyOrderOnlyValues" to Companion::containsInAnyOrderOnlyNullableValues
private fun containsInAnyOrderOnlyNullableValues(
expect: Expect<Iterable<Double?>>,
a: Double?,
@@ -31,6 +28,23 @@ class IterableContainsInAnyOrderOnlyValuesAssertionsSpec :
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inAnyOrder.only.value(a)
else expect.contains.inAnyOrder.only.values(a, *aX)
}
@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.contains.inAnyOrder.only.value(1)
nList = nList.contains.inAnyOrder.only.value(1)
subList = subList.contains.inAnyOrder.only.value(1)
star = star.contains.inAnyOrder.only.value(1)
list = list.contains.inAnyOrder.only.values(1, 1.2)
nList = nList.contains.inAnyOrder.only.values(1, 1.2)
subList = subList.contains.inAnyOrder.only.values(1, 2.2)
star = star.contains.inAnyOrder.only.values(1, 1.2, "asdf")
}
}

80
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInOrderOnlyElementsOfAssertionsSpec.kt
View File

@@ -1,8 +1,10 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction2
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInOrderOnlyElementsOfAssertionsSpec.Companion as C
class IterableContainsInOrderOnlyElementsOfAssertionsSpec : Spek({
include(BuilderSpec)
@@ -11,75 +13,85 @@ class IterableContainsInOrderOnlyElementsOfAssertionsSpec : Spek({
include(ShortcutIterableLikeToIterableSpec)
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsInOrderOnlyValues,
(functionDescription to C::containsInOrderOnlyNullableValues).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyValuesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
shortcutDescription to C::containsExactlyElementsOfShortcut,
(shortcutDescription to C::containsExactlyElementsOfNullableShortcut).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Shortcut] "
)
object BuilderIterableLikeToIterableSpec : ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
"$contains.$inOrder.$only.$inOrderElementsOf",
listOf(1, 2),
{ input -> contains.inOrder.only.elementsOf(input) }
)
object BuilderIterableLikeToIterableSpec :
ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
functionDescription,
listOf(1, 2),
{ input -> contains.inOrder.only.elementsOf(input) }
)
object ShortcutIterableLikeToIterableSpec : ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
"containsExactlyElementsOf",
listOf(1, 2),
{ input -> containsExactlyElementsOf(input) }
)
object ShortcutIterableLikeToIterableSpec :
ch.tutteli.atrium.specs.integration.IterableLikeToIterableSpec<List<Int>>(
shortcutDescription,
listOf(1, 2),
{ input -> containsExactlyElementsOf(input) }
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() = "$contains.$inOrder.$only.$inOrderElementsOf" to Companion::containsInOrderOnlyValues
val functionDescription = "$contains.$inOrder.$only.$elementsOf"
val shortcutDescription = Expect<Iterable<Int>>::containsExactlyElementsOf.name
private fun containsInOrderOnlyValues(
fun containsInOrderOnlyValues(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> = expect.contains.inOrder.only.elementsOf(listOf(a, *aX))
fun getContainsNullablePair() =
"$contains.$inOrder.$only.$inOrderElementsOf" to Companion::containsInOrderOnlyNullableValues
private fun containsInOrderOnlyNullableValues(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> = expect.contains.inOrder.only.elementsOf(sequenceOf(a, *aX))
private val containsExactlyElementsOfShortcutFun: KFunction2<Expect<Iterable<Double>>, Iterable<Double>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::containsExactlyElementsOf
private fun getContainsShortcutPair() =
Pair(containsExactlyElementsOfShortcutFun.name, Companion::containsExactlyElementsOfShortcut)
private fun containsExactlyElementsOfShortcut(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> = expect.containsExactlyElementsOf(arrayOf(a, *aX))
private val containsExactlyElementsOfNullableShortcutFun: KFunction2<Expect<Iterable<Double?>>, Iterable<Double?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::containsExactlyElementsOf
private fun getContainsNullableShortcutPair() = Pair(
containsExactlyElementsOfNullableShortcutFun.name,
Companion::containsExactlyElementsOfNullableShortcut
)
private fun containsExactlyElementsOfNullableShortcut(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> = expect.containsExactlyElementsOf(sequenceOf(a, *aX).asIterable())
}
@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.contains.inOrder.only.elementsOf(listOf<Int>())
nList = nList.contains.inOrder.only.elementsOf(listOf<Int>())
subList = subList.contains.inOrder.only.elementsOf(listOf<Int>())
star = star.contains.inOrder.only.elementsOf(listOf<Int>())
list = list.containsExactlyElementsOf(1)
nList = nList.containsExactlyElementsOf(1)
subList = subList.containsExactlyElementsOf(1)
star = star.containsExactlyElementsOf(1)
list = list.containsExactlyElementsOf(listOf(1, 1.2))
nList = nList.containsExactlyElementsOf(listOf(1, 1.2))
subList = subList.containsExactlyElementsOf(listOf(1, 2.2))
subList = subList.containsExactlyElementsOf(listOf(1))
star = star.containsExactlyElementsOf(listOf(1, 1.2, "asdf"))
}
}

79
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -1,8 +1,11 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.fun2
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction3
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInOrderOnlyEntriesAssertionsSpec.Companion as C
class IterableContainsInOrderOnlyEntriesAssertionsSpec : Spek({
@@ -11,21 +14,21 @@ class IterableContainsInOrderOnlyEntriesAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyEntriesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsInOrderOnly,
(functionDescription to C::containsInOrderOnlyNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyEntriesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
fun2<Iterable<Double>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>>(Expect<Iterable<Double>>::containsExactly),
fun2<Iterable<Double?>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>>(Expect<Iterable<Double?>>::containsExactly).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Shortcut] "
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() = "$contains.$inOrder.$only.$inOrderOnlyEntries" to Companion::containsInOrderOnly
val functionDescription = "$contains.$inOrder.$only.$entry/$entries"
private fun containsInOrderOnly(
expect: Expect<Iterable<Double>>,
@@ -35,46 +38,52 @@ class IterableContainsInOrderOnlyEntriesAssertionsSpec : Spek({
if (aX.isEmpty()) expect.contains.inOrder.only.entry(a)
else expect.contains.inOrder.only.entries(a, *aX)
fun getContainsNullablePair() =
"$contains.$inOrder.$only.$inOrderOnlyEntries" to Companion::containsInOrderOnlyNullableEntriesPair
private fun containsInOrderOnlyNullableEntriesPair(
private fun containsInOrderOnlyNullable(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
aX: Array<out (Expect<Double>.() -> Unit)?>
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inOrder.only.entry(a)
else expect.contains.inOrder.only.entries(a, *aX)
}
private val containsShortcutFun: KFunction3<Expect<Iterable<Double>>, Expect<Double>.() -> Unit, Array<out Expect<Double>.() -> Unit>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::containsExactly
@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()
fun getContainsShortcutPair() = containsShortcutFun.name to Companion::containsInOrderOnlyEntriesShortcut
list = list.contains.inOrder.only.entry {}
nList = nList.contains.inOrder.only.entry {}
subList = subList.contains.inOrder.only.entry {}
star = star.contains.inOrder.only.entry {}
private fun containsInOrderOnlyEntriesShortcut(
expect: Expect<Iterable<Double>>,
a: Expect<Double>.() -> Unit,
aX: Array<out Expect<Double>.() -> Unit>
): Expect<Iterable<Double>> =
if (aX.isEmpty()) expect.containsExactly { a() }
else expect.containsExactly(a, *aX)
nList = nList.contains.inOrder.only.entry(null)
star = star.contains.inOrder.only.entry(null)
private val containsNullableShortcutFun: KFunction3<Expect<Iterable<Double?>>, (Expect<Double>.() -> Unit)?, Array<out (Expect<Double>.() -> Unit)?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::containsExactly
list = list.contains.inOrder.only.entries({}, {})
nList = nList.contains.inOrder.only.entries({}, {})
subList = subList.contains.inOrder.only.entries({}, {})
star = star.contains.inOrder.only.entries({}, {})
fun getContainsNullableShortcutPair() =
containsNullableShortcutFun.name to Companion::containsInOrderOnlyNullableEntriesShortcut
nList = nList.contains.inOrder.only.entries(null, {}, null)
star = star.contains.inOrder.only.entries(null, {}, null)
private fun containsInOrderOnlyNullableEntriesShortcut(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
aX: Array<out (Expect<Double>.() -> Unit)?>
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) {
if (a == null) expect.containsExactly(a)
else expect.containsExactly { a() }
} else {
expect.containsExactly(a, *aX)
}
list = list.containsExactly {}
nList = nList.containsExactly {}
subList = subList.containsExactly {}
star = star.containsExactly {}
nList = nList.containsExactly(null)
star = star.containsExactly(null)
list = list.containsExactly({}, {})
nList = nList.containsExactly({}, {})
subList = subList.containsExactly({}, {})
star = star.containsExactly({}, {})
nList = nList.containsExactly(null, {}, null)
star = star.containsExactly(null, {}, null)
}
}

24
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec.kt
View File

@@ -2,17 +2,17 @@ package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.domain.builders.utils.Group
import ch.tutteli.atrium.specs.notImplemented
class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
getContainsPair(),
functionDescription to Companion::containsInOrderOnlyGroupedInAnyOrderEntries,
Companion::groupFactory,
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
) {
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inOrder.$only.$grouped.$within.$withinInAnyOrder" to Companion::containsInOrderOnlyGroupedInAnyOrderEntries
val functionDescription = "$contains.$inOrder.$only.$grouped.$within.$withinInAnyOrder"
private fun containsInOrderOnlyGroupedInAnyOrderEntries(
expect: Expect<Iterable<Double?>>,
@@ -30,4 +30,22 @@ class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec :
else -> Entries(groups[0], *groups.drop(1).toTypedArray())
}
}
@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.contains.inOrder.only.grouped.within.inAnyOrder(Entry{}, Entries({}, {}))
nList = nList.contains.inOrder.only.grouped.within.inAnyOrder(Entry {}, Entries({}, {}))
subList = subList.contains.inOrder.only.grouped.within.inAnyOrder(Entry {}, Entries({}, {}))
// TODO 1.0.0: not supported, but OK for this rare case, maybe supported with Kotlin 1.4
//star = star.contains.inOrder.only.grouped.within.inAnyOrder(Entry {}, Entries({}, {}))
nList = nList.contains.inOrder.only.grouped.within.inAnyOrder(Entry(null), Entries({}, null))
// TODO 1.0.0: not supported, but OK for this rare case, maybe supported with Kotlin 1.4
//star = star.contains.inOrder.only.grouped.within.inAnyOrder(Entry(null), Entries(null, {}))
}
}

29
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInOrderOnlyGroupedValuesAssertionsSpec.kt
View File

@@ -2,19 +2,20 @@ package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.domain.builders.utils.Group
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
getContainsPair(),
functionDescription to Companion::containsInOrderOnlyGroupedInAnyOrderValues,
Companion::groupFactory,
getContainsNullablePair(),
(functionDescription to Companion::containsInOrderOnlyGroupedInAnyOrderNullableValues).withNullableSuffix(),
Companion::nullableGroupFactory,
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
) {
companion object : IterableContainsSpecBase() {
fun getContainsPair() =
"$contains.$inOrder.$only.$grouped.$within.$withinInAnyOrder" to Companion::containsInOrderOnlyGroupedInAnyOrderValues
val functionDescription = "$contains.$inOrder.$only.$grouped.$within.$withinInAnyOrder"
private fun containsInOrderOnlyGroupedInAnyOrderValues(
expect: Expect<Iterable<Double>>,
@@ -32,10 +33,6 @@ class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec :
else -> Values(groups[0], *groups.drop(1).toTypedArray())
}
fun getContainsNullablePair() =
"$contains.$inOrder.$only.$grouped.$within.$withinInAnyOrder" to Companion::containsInOrderOnlyGroupedInAnyOrderNullableValues
private fun containsInOrderOnlyGroupedInAnyOrderNullableValues(
expect: Expect<Iterable<Double?>>,
a1: Group<Double?>,
@@ -52,4 +49,20 @@ class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec :
else -> Values(groups[0], *groups.drop(1).toTypedArray())
}
}
@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.contains.inOrder.only.grouped.within.inAnyOrder(Value(1), Values(1, 2))
nList = nList.contains.inOrder.only.grouped.within.inAnyOrder(Value(1), Values(1, 2))
subList = subList.contains.inOrder.only.grouped.within.inAnyOrder(Value(1), Values(1, 2))
star = star.contains.inOrder.only.grouped.within.inAnyOrder(Value(1), Values(1, 2))
nList = nList.contains.inOrder.only.grouped.within.inAnyOrder(Value(null), Values(1, null))
star = star.contains.inOrder.only.grouped.within.inAnyOrder(Value(null), Values(null, 2))
}
}

64
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsInOrderOnlyValuesAssertionsSpec.kt
View File

@@ -1,8 +1,11 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.fun2
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction3
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsInOrderOnlyValuesAssertionsSpec.Companion as C
class IterableContainsInOrderOnlyValuesAssertionsSpec : Spek({
@@ -11,21 +14,21 @@ class IterableContainsInOrderOnlyValuesAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyValuesAssertionsSpec(
getContainsPair(),
getContainsNullablePair(),
functionDescription to C::containsInOrderOnlyValues,
(functionDescription to C::containsInOrderOnlyNullableValues).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsInOrderOnlyValuesAssertionsSpec(
getContainsShortcutPair(),
getContainsNullableShortcutPair(),
fun2<Iterable<Double>, Double, Array<out Double>>(Expect<Iterable<Double>>::containsExactly),
fun2<Iterable<Double?>, Double?, Array<out Double?>>(Expect<Iterable<Double?>>::containsExactly).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Shortcut] "
)
companion object : IterableContainsSpecBase() {
fun getContainsPair() = "$contains.$inOrder.$only.$inOrderOnlyValues" to Companion::containsInOrderOnlyValues
val functionDescription = "$contains.$inOrder.$only.$value/$values"
private fun containsInOrderOnlyValues(
expect: Expect<Iterable<Double>>,
@@ -35,9 +38,6 @@ class IterableContainsInOrderOnlyValuesAssertionsSpec : Spek({
if (aX.isEmpty()) expect.contains.inOrder.only.value(a)
else expect.contains.inOrder.only.values(a, *aX)
fun getContainsNullablePair() =
"$contains.$inOrder.$only.$inOrderOnlyValues" to Companion::containsInOrderOnlyNullableValues
private fun containsInOrderOnlyNullableValues(
expect: Expect<Iterable<Double?>>,
a: Double?,
@@ -45,33 +45,37 @@ class IterableContainsInOrderOnlyValuesAssertionsSpec : Spek({
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.contains.inOrder.only.value(a)
else expect.contains.inOrder.only.values(a, *aX)
}
private val containsShortcutFun: KFunction3<Expect<Iterable<Double>>, Double, Array<out Double>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::containsExactly
@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()
fun getContainsShortcutPair() = containsShortcutFun.name to Companion::containsInOrderOnlyValuesShortcut
private fun containsInOrderOnlyValuesShortcut(
expect: Expect<Iterable<Double>>,
a: Double,
aX: Array<out Double>
): Expect<Iterable<Double>> =
if (aX.isEmpty()) expect.containsExactly(a)
else expect.containsExactly(a, *aX)
list = list.contains.inOrder.only.value(1)
nList = nList.contains.inOrder.only.value(1)
subList = subList.contains.inOrder.only.value(1)
star = star.contains.inOrder.only.value(1)
private val containsNullableShortcutFun: KFunction3<Expect<Iterable<Double?>>, Double?, Array<out Double?>, Expect<Iterable<Double?>>> =
Expect<Iterable<Double?>>::containsExactly
list = list.contains.inOrder.only.values(1, 1.2)
nList = nList.contains.inOrder.only.values(1, 1.2)
subList = subList.contains.inOrder.only.values(1, 2.2)
star = star.contains.inOrder.only.values(1, 1.2, "asdf")
fun getContainsNullableShortcutPair() =
containsNullableShortcutFun.name to Companion::containsInOrderOnlyNullableValuesShortcut
list = list.containsExactly(1)
nList = nList.containsExactly(1)
subList = subList.containsExactly(1)
star = star.containsExactly(1)
private fun containsInOrderOnlyNullableValuesShortcut(
expect: Expect<Iterable<Double?>>,
a: Double?,
aX: Array<out Double?>
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.containsExactly(a)
else expect.containsExactly(a, *aX)
list = list.containsExactly(1, 1.2)
nList = nList.containsExactly(1, 1.2)
subList = subList.containsExactly(1, 2.2)
// TODO would wish this does not work, maybe @OnlyInputTypes would help?
subList = subList.containsExactly("asdf")
star = star.containsExactly(1, 1.2, "asdf")
}
}

36
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsNotEntriesAssertionsSpec.kt
View File

@@ -1,17 +1,18 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
class IterableContainsNotEntriesAssertionsSpec :
ch.tutteli.atrium.specs.integration.IterableContainsNotEntriesAssertionsSpec(
getContainsNotPair(),
getContainsNotNullablePair(),
functionDescription to Companion::containsNotFun,
(functionDescription to Companion::containsNotNullableFun).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
) {
companion object : IterableContainsSpecBase() {
private fun getContainsNotPair() = containsNot to Companion::containsNotFun
private val functionDescription = "$containsNot.$entry/$entries"
private fun containsNotFun(
expect: Expect<Iterable<Double>>,
@@ -21,8 +22,6 @@ class IterableContainsNotEntriesAssertionsSpec :
if (aX.isEmpty()) expect.containsNot.entry(a)
else expect.containsNot.entries(a, *aX)
private fun getContainsNotNullablePair() = "$containsNot nullable" to Companion::containsNotNullableFun
private fun containsNotNullableFun(
expect: Expect<Iterable<Double?>>,
a: (Expect<Double>.() -> Unit)?,
@@ -31,4 +30,29 @@ class IterableContainsNotEntriesAssertionsSpec :
if (aX.isEmpty()) expect.containsNot.entry(a)
else expect.containsNot.entries(a, *aX)
}
@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.containsNot.entry {}
nList = nList.containsNot.entry {}
subList = subList.containsNot.entry {}
star = star.containsNot.entry {}
nList = nList.containsNot.entry(null)
star = star.containsNot.entry(null)
list = list.containsNot.entries({}, {})
nList = nList.containsNot.entries({}, {})
subList = subList.containsNot.entries({}, {})
star = star.containsNot.entries({}, {})
nList = nList.containsNot.entries(null, {}, null)
star = star.containsNot.entries(null, {}, null)
}
}

47
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsNotValuesAssertionsSpec.kt
View File

@@ -1,8 +1,11 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.fun2
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import kotlin.reflect.KFunction3
import ch.tutteli.atrium.api.fluent.en_GB.IterableContainsNotValuesAssertionsSpec.Companion as C
class IterableContainsNotValuesAssertionsSpec : Spek({
@@ -12,22 +15,21 @@ class IterableContainsNotValuesAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableContainsNotValuesAssertionsSpec(
getContainsNotPair(),
getContainsNotNullablePair(),
functionDescription to C::containsNotFun,
(functionDescription to C::containsNotNullableFun).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "⚬ ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.IterableContainsNotValuesAssertionsSpec(
getContainsNotShortcutPair(),
getContainsNotNullablePair(),
fun2<Iterable<Double>,Double, Array<out Double>>(Expect<Iterable<Double>>::containsNot),
fun2<Iterable<Double?>,Double?, Array<out Double?>>(Expect<Iterable<Double?>>::containsNot).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "⚬ ", "▶ ", "◾ ",
"[Atrium][Shortcut] "
)
companion object : IterableContainsSpecBase() {
private fun getContainsNotPair() = containsNot to Companion::containsNotFun
private val functionDescription = "$containsNot.$value/$values"
private fun containsNotFun(
expect: Expect<Iterable<Double>>,
@@ -37,8 +39,6 @@ class IterableContainsNotValuesAssertionsSpec : Spek({
if (aX.isEmpty()) expect.containsNot.value(a)
else expect.containsNot.values(a, *aX)
private fun getContainsNotNullablePair() = containsNot to Companion::containsNotNullableFun
private fun containsNotNullableFun(
expect: Expect<Iterable<Double?>>,
a: Double?,
@@ -46,13 +46,32 @@ class IterableContainsNotValuesAssertionsSpec : Spek({
): Expect<Iterable<Double?>> =
if (aX.isEmpty()) expect.containsNot.value(a)
else expect.containsNot.values(a, *aX)
}
private val containsNotShortcutFun: KFunction3<Expect<Iterable<Double>>, Double, Array<out Double>, Expect<Iterable<Double>>> =
Expect<Iterable<Double>>::containsNot
private fun getContainsNotShortcutPair() = containsNotShortcutFun.name to Companion::containsNotShortcut
@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()
private fun containsNotShortcut(expect: Expect<Iterable<Double>>, a: Double, aX: Array<out Double>) =
expect.containsNot(a, *aX)
list = list.containsNot.value(1)
nList = nList.containsNot.value(1)
subList = subList.containsNot.value(1)
star = star.containsNot.value(1)
list = list.containsNot.values(1, 1.2)
nList = nList.containsNot.values(1, 1.2)
subList = subList.containsNot.values(1, 2.2)
star = star.containsNot.values(1, 1.2, "asdf")
list = list.containsNot(1, 1.2)
nList = nList.containsNot(1, 1.2)
subList = subList.containsNot(1, 2.2)
// TODO would wish this does not work, maybe @OnlyInputTypes would help?
subList = subList.containsNot("asdf")
star = star.containsNot(1, 1.2, "asdf")
}
}

278
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableContainsSpecBase.kt
View File

@@ -14,6 +14,12 @@ abstract class IterableContainsSpecBase {
protected val contains = containsProp.name
private val containsNotProp: KProperty<*> = Expect<Iterable<*>>::containsNot
protected val containsNot = containsNotProp.name
protected val value = IterableLikeContains.EntryPointStep<Int, List<Int>, InOrderOnlySearchBehaviour>::value.name
protected val values = IterableLikeContains.EntryPointStep<Int, List<Int>, InOrderOnlySearchBehaviour>::values.name
protected val entry = IterableLikeContains.EntryPointStep<Int, List<Int>, InOrderOnlySearchBehaviour>::entry.name
protected val entries = IterableLikeContains.EntryPointStep<*, *, InOrderOnlySearchBehaviour>::entries.name
protected val elementsOf =
IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlySearchBehaviour>::elementsOf.name
//@formatter:off
protected val atLeast = IterableLikeContains.EntryPointStep<*, *, InAnyOrderSearchBehaviour>::atLeast.name
@@ -22,284 +28,12 @@ abstract class IterableContainsSpecBase {
protected val atMost = IterableLikeContains.EntryPointStep<*, *, InAnyOrderSearchBehaviour>::atMost.name
protected val notOrAtMost = IterableLikeContains.EntryPointStep<*, *, InAnyOrderSearchBehaviour>::notOrAtMost.name
protected val inAnyOrder = IterableLikeContains.EntryPointStep<Int, List<Int>, NoOpSearchBehaviour>::inAnyOrder.name
protected val inAnyOrderValues = IterableLikeContains.CheckerStep<Int, Iterable<Int>, InAnyOrderSearchBehaviour>::values.name
protected val inAnyOrderEntries = IterableLikeContains.CheckerStep<Int, Iterable<Int>, InAnyOrderSearchBehaviour>::entries.name
protected val inAnyOrderElementsOf = IterableLikeContains.CheckerStep<Int, Iterable<Int>, InAnyOrderSearchBehaviour>::elementsOf.name
protected val inAnyOrderOnlyValues = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InAnyOrderOnlySearchBehaviour>::values.name
protected val inAnyOrderOnlyEntries = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InAnyOrderOnlySearchBehaviour>::entries.name
protected val inAnyOrderOnlyElementsOf = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InAnyOrderOnlySearchBehaviour>::elementsOf.name
protected val inOrder = IterableLikeContains.EntryPointStep<Int, List<Int>, NoOpSearchBehaviour>::inOrder.name
protected val only = IterableLikeContains.EntryPointStep<Int, List<Int>, InAnyOrderSearchBehaviour>::only.name
protected val inOrderOnlyValues = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlySearchBehaviour>::values.name
protected val inOrderOnlyEntries = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlySearchBehaviour>::entries.name
protected val inOrderElementsOf = IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlySearchBehaviour>::elementsOf.name
protected val grouped = IterableLikeContains.EntryPointStep<Int, List<Int>, InOrderOnlySearchBehaviour>::grouped.name
protected val within = IterableLikeContains.EntryPointStep<Int, List<Int>, InOrderOnlyGroupedSearchBehaviour>::within.name
private val withinInAnyOrderFun: KFunction4<IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlyGroupedWithinSearchBehaviour>, Group<Int>, Group<Int>, Array<out Group<Int>>, Expect<Iterable<Int>>> =
IterableLikeContains.EntryPointStep<Int, Iterable<Int>, InOrderOnlyGroupedWithinSearchBehaviour>::inAnyOrder
protected val withinInAnyOrder = withinInAnyOrderFun.name
//@formatter:on
@Suppress("unused")
private fun ambiguityTest() {
val list: Expect<List<Number>> = notImplemented()
val nullableList: Expect<Set<Number?>> = notImplemented()
val subList: Expect<ArrayList<out Number>> = notImplemented()
val star: Expect<Collection<*>> = notImplemented()
val any: Expect<Collection<Any>> = notImplemented()
list.contains(1)
list.contains(1f)
list.contains(1, 2f)
list.contains {}
list.contains({}, {})
list.containsNot(1)
list.containsNot(1f)
list.containsNot(1, 2f)
list.containsNot.entry {}
list.containsNot.entries({}, {})
subList.contains(1)
subList.contains(1f)
subList.contains(1, 2f)
subList.contains {}
subList.contains({}, {})
subList.containsNot(1)
subList.containsNot(1f)
subList.containsNot(1, 2f)
subList.containsNot.entry {}
subList.containsNot.entries({}, {})
nullableList.contains(1)
nullableList.contains(1f)
nullableList.contains(1, 2f)
nullableList.contains {}
nullableList.contains({}, {})
nullableList.containsNot(1)
nullableList.containsNot(1f)
nullableList.containsNot(1, 2f)
nullableList.containsNot.entry {}
nullableList.containsNot.entries({}, {})
nullableList.contains(null)
nullableList.contains({}, null)
nullableList.contains(null, {})
nullableList.contains(null, null)
nullableList.containsNot(null)
nullableList.containsNot.entries({}, null)
nullableList.containsNot.entries(null, {})
nullableList.containsNot.entries(null, null)
star.contains(1)
star.contains(1f)
star.contains(1, 2f)
star.contains {}
star.contains({}, {})
star.containsNot(1)
star.containsNot(1f)
star.containsNot(1, 2f)
star.containsNot.entry {}
star.containsNot.entries({}, {})
star.contains(null)
star.contains({}, null)
star.contains(null, {})
star.contains(null, null)
star.containsNot(null)
star.containsNot.entries({}, null)
star.containsNot.entries(null, {})
star.containsNot.entries(null, null)
list.containsExactly(1)
list.containsExactly(1, 2f)
list.containsExactly {}
list.containsExactly({}, {})
subList.containsExactly(1)
subList.containsExactly(1, 2f)
subList.containsExactly {}
subList.containsExactly({}, {})
nullableList.containsExactly(1)
nullableList.containsExactly(1, 1f)
nullableList.containsExactly {}
nullableList.containsExactly(null)
nullableList.containsExactly({}, null)
nullableList.containsExactly({}, {})
nullableList.containsExactly(null, {})
list.contains.inAnyOrder.atLeast(1).value(1)
list.contains.inAnyOrder.atLeast(1).values(2, 1f)
list.contains.inAnyOrder.atLeast(1).entry {}
list.contains.inAnyOrder.atLeast(1).entries({}, {})
list.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1, 2f))
subList.contains.inAnyOrder.atLeast(1).value(1)
subList.contains.inAnyOrder.atLeast(1).values(2, 1)
subList.contains.inAnyOrder.atLeast(1).entry {}
subList.contains.inAnyOrder.atLeast(1).entries({}, {})
subList.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1, 2f))
nullableList.contains.inAnyOrder.atLeast(1).value(1)
nullableList.contains.inAnyOrder.atLeast(1).values(2, 1f)
nullableList.contains.inAnyOrder.atLeast(1).entry {}
nullableList.contains.inAnyOrder.atLeast(1).entries({}, {})
nullableList.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1, 2f))
nullableList.contains.inAnyOrder.atLeast(1).value(null)
nullableList.contains.inAnyOrder.atLeast(1).values(null, 1)
nullableList.contains.inAnyOrder.atLeast(1).values(2f, null)
nullableList.contains.inAnyOrder.atLeast(1).values(null, null)
nullableList.contains.inAnyOrder.atLeast(1).entry(null)
nullableList.contains.inAnyOrder.atLeast(1).entries(null, {})
nullableList.contains.inAnyOrder.atLeast(1).entries({}, null)
nullableList.contains.inAnyOrder.atLeast(1).entries(null, null)
star.contains.inAnyOrder.atLeast(1).value(1)
star.contains.inAnyOrder.atLeast(1).values(2, 1f)
star.contains.inAnyOrder.atLeast(1).entry {}
star.contains.inAnyOrder.atLeast(1).entries({}, {})
star.contains.inAnyOrder.atLeast(1).elementsOf(listOf(1, 2f))
star.contains.inAnyOrder.atLeast(1).value(null)
star.contains.inAnyOrder.atLeast(1).values(null, 1)
star.contains.inAnyOrder.atLeast(1).values(2, null)
star.contains.inAnyOrder.atLeast(1).values(null, null)
star.contains.inAnyOrder.atLeast(1).entry(null)
star.contains.inAnyOrder.atLeast(1).entries(null, {})
star.contains.inAnyOrder.atLeast(1).entries({}, null)
star.contains.inAnyOrder.atLeast(1).entries(null, null)
list.contains.inAnyOrder.only.value(1)
list.contains.inAnyOrder.only.values(2, 1)
list.contains.inAnyOrder.only.entry {}
list.contains.inAnyOrder.only.entries({}, {})
list.contains.inAnyOrder.only.elementsOf(listOf(1, 2f))
subList.contains.inAnyOrder.only.value(1)
subList.contains.inAnyOrder.only.values(2, 1)
subList.contains.inAnyOrder.only.entry {}
subList.contains.inAnyOrder.only.entries({}, {})
subList.contains.inAnyOrder.only.elementsOf(listOf(1, 2f))
nullableList.contains.inAnyOrder.only.value(1)
nullableList.contains.inAnyOrder.only.values(2, 1f)
nullableList.contains.inAnyOrder.only.entry {}
nullableList.contains.inAnyOrder.only.entries({}, {})
nullableList.contains.inAnyOrder.only.elementsOf(listOf(1, 2f))
nullableList.contains.inAnyOrder.only.value(null)
nullableList.contains.inAnyOrder.only.values(null, 1)
nullableList.contains.inAnyOrder.only.values(2f, null)
nullableList.contains.inAnyOrder.only.values(null, null)
nullableList.contains.inAnyOrder.only.entry(null)
nullableList.contains.inAnyOrder.only.entries(null, {})
nullableList.contains.inAnyOrder.only.entries({}, null)
nullableList.contains.inAnyOrder.only.entries(null, null)
star.contains.inAnyOrder.only.value(1)
star.contains.inAnyOrder.only.values(2, 1f)
star.contains.inAnyOrder.only.entry {}
star.contains.inAnyOrder.only.entries({}, {})
star.contains.inAnyOrder.only.elementsOf(listOf(1, 2f))
star.contains.inAnyOrder.only.value(null)
star.contains.inAnyOrder.only.values(null, 1)
star.contains.inAnyOrder.only.values(2f, null)
star.contains.inAnyOrder.only.values(null, null)
star.contains.inAnyOrder.only.entry(null)
star.contains.inAnyOrder.only.entries(null, {})
star.contains.inAnyOrder.only.entries({}, null)
star.contains.inAnyOrder.only.entries(null, null)
list.contains.inOrder.only.value(1)
list.contains.inOrder.only.values(2, 1)
list.contains.inOrder.only.entry {}
list.contains.inOrder.only.entries({}, {})
list.contains.inOrder.only.elementsOf(listOf(1, 2f))
subList.contains.inOrder.only.value(1)
subList.contains.inOrder.only.values(2, 1f)
subList.contains.inOrder.only.entry {}
subList.contains.inOrder.only.entries({}, {})
subList.contains.inOrder.only.elementsOf(listOf(1, 2f))
nullableList.contains.inOrder.only.value(1)
nullableList.contains.inOrder.only.values(2, 1)
nullableList.contains.inOrder.only.entry {}
nullableList.contains.inOrder.only.entries({}, {})
nullableList.contains.inOrder.only.elementsOf(listOf(1, 2f))
nullableList.contains.inOrder.only.value(null)
nullableList.contains.inOrder.only.values(null, 1)
nullableList.contains.inOrder.only.values(2f, null)
nullableList.contains.inOrder.only.values(null, null)
nullableList.contains.inOrder.only.entry(null)
nullableList.contains.inOrder.only.entries(null, {})
nullableList.contains.inOrder.only.entries({}, null)
nullableList.contains.inOrder.only.entries(null, null)
star.contains.inOrder.only.value(1)
star.contains.inOrder.only.values(2, 1f)
star.contains.inOrder.only.entry {}
star.contains.inOrder.only.entries({}, {})
star.contains.inOrder.only.elementsOf(listOf(1, 2f))
star.contains.inOrder.only.value(null)
star.contains.inOrder.only.values(null, 1)
star.contains.inOrder.only.values(2f, null)
star.contains.inOrder.only.values(null, null)
star.contains.inOrder.only.entry(null)
star.contains.inOrder.only.entries(null, {})
star.contains.inOrder.only.entries({}, null)
star.contains.inOrder.only.entries(null, null)
star.contains.inOrder.only.entries(null, null)
list.contains.inOrder.only.grouped.within.inAnyOrder(
Value(1),
Values(1f),
//TODO check if this is resolved correctly with kotlin 1.4 otherwise report an issue
Values<Number>(1f, 1)
)
subList.contains.inOrder.only.grouped.within.inAnyOrder(
Value(1),
Values(1f),
Values<Number>(1f, 1)
)
nullableList.contains.inOrder.only.grouped.within.inAnyOrder(
Value(null),
Values(null),
Values(null, 2),
Values(1, null),
Values(null, null)
)
star.contains.inOrder.only.grouped.within.inAnyOrder(
Value(null),
Values(null),
Values(null, 2),
Values(1, null),
Values(null, null)
)
any.contains.inOrder.only.grouped.within.inAnyOrder(
Value(1),
Values(2),
Values(1f, 2),
Values(1, 1),
Values("je", 'a')
)
list.contains.inOrder.only.grouped.within.inAnyOrder(
Entry {},
Entries({}),
Entries({}, {})
)
subList.contains.inOrder.only.grouped.within.inAnyOrder(
Entry {},
Entries({}),
Entries({}, {})
)
nullableList.contains.inOrder.only.grouped.within.inAnyOrder(
Entry(null),
Entries(null),
Entries(null, {}),
Entries({}, null),
Entries(null, null)
)
//TODO check if this is resolved correctly with kotlin 1.4 otherwise report an issue
star.contains.inOrder.only.grouped.within.inAnyOrder<Any, Collection<Any?>>(
Entry(null),
Entries(null),
Entries(null, {}),
Entries({}, null),
Entries(null, null)
)
any.contains.inOrder.only.grouped.within.inAnyOrder(
Entry(null),
Entries(null),
Entries(null, {}),
Entries({}, null),
Entries(null, null)
)
}
}

34
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/IterableNoneAssertionsSpec.kt
View File

@@ -5,12 +5,11 @@ import ch.tutteli.atrium.specs.fun1
import ch.tutteli.atrium.specs.notImplemented
import ch.tutteli.atrium.specs.withNullableSuffix
import org.spekframework.spek2.Spek
import ch.tutteli.atrium.api.fluent.en_GB.IterableNoneAssertionsSpec.Companion as C
class IterableNoneAssertionsSpec : Spek({
include(PredicateSpec)
include(BuilderSpec)
}) {
object PredicateSpec : ch.tutteli.atrium.specs.integration.IterableNoneAssertionsSpec(
fun1(Expect<Iterable<Double>>::none),
@@ -19,42 +18,35 @@ class IterableNoneAssertionsSpec : Spek({
"[Atrium][Predicate] "
)
// TODO 0.17.0 #722 this will differ once we don't implement the same behaviour for contains and none
// that's fine and we can simply remove this test here
object BuilderSpec : ch.tutteli.atrium.specs.integration.IterableNoneAssertionsSpec(
getContainsNotPair(),
getContainsNotNullablePair().withNullableSuffix(),
functionDescription to C::containsNotFun,
(functionDescription to C::containsNotNullableFun).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
companion object : IterableContainsSpecBase() {
private fun getContainsNotPair() = containsNot to Companion::containsNotFun
val functionDescription = "$containsNot.$entry"
private fun containsNotFun(expect: Expect<Iterable<Double>>, a: Expect<Double>.() -> Unit) =
expect.containsNot.entry(a)
private fun getContainsNotNullablePair() = containsNot to Companion::containsNotNullableFun
private fun containsNotNullableFun(expect: Expect<Iterable<Double?>>, a: (Expect<Double>.() -> Unit)?) =
expect.containsNot.entry(a)
}
@Suppress("unused", "UNUSED_VALUE")
private fun ambiguityTest() {
var a1: Expect<List<Double>> = notImplemented()
var a1b: Expect<Set<Double?>> = notImplemented()
var list: Expect<List<Number>> = notImplemented()
var nList: Expect<Set<Number?>> = notImplemented()
var subList: Expect<ArrayList<out Number>> = notImplemented()
var star: Expect<Collection<*>> = notImplemented()
a1 = a1.none {}
a1 = a1.containsNot.entry {}
a1b = a1b.none {}
a1b = a1b.none(null)
a1b = a1b.containsNot.entry {}
a1b = a1b.containsNot.entry(null)
star = star.none {}
star = star.containsNot.entry {}
list = list.none{}
nList = nList.none{}
subList = subList.none{}
star = star.none{}
}
}

10
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderEntriesOfAssertionsSpec.kt
View File

@@ -17,8 +17,8 @@ class MapContainsInAnyOrderEntriesOfAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"[Atrium][Builder] "
)
@@ -30,20 +30,20 @@ class MapContainsInAnyOrderEntriesOfAssertionsSpec : Spek({
object BuilderMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$contains.$inAnyOrder.$only.$entriesOf",
functionDescription,
mapOf("a" to 1),
{ input -> contains.inAnyOrder.entriesOf(input) }
)
object ShortcutMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$containsEntriesOf",
containsEntriesOf,
mapOf("a" to 1),
{ input -> containsEntriesOf(input) }
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inAnyOrder.$entriesOf"
val functionDescription = "$contains.$inAnyOrder.$entriesOf"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

6
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderKeyValueAssertionsSpec.kt
View File

@@ -14,8 +14,8 @@ class MapContainsInAnyOrderKeyValueAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderKeyValueAssertionsSpec(
containsKeyValue_s to C::containsKeyValues,
(containsKeyValue_s to C::containsKeyValuesNullable).withNullableSuffix(),
functionDescription to C::containsKeyValues,
(functionDescription to C::containsKeyValuesNullable).withNullableSuffix(),
"[Atrium][Builder] "
)
@@ -27,7 +27,7 @@ class MapContainsInAnyOrderKeyValueAssertionsSpec : Spek({
)
companion object : MapContainsSpecBase() {
val containsKeyValue_s = "$contains.$inAnyOrder.$keyValue/$keyValues"
val functionDescription = "$contains.$inAnyOrder.$keyValue/$keyValues"
private fun containsKeyValues(
expect: Expect<Map<out String, Int>>,

8
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderKeyValuePairsAssertionsSpec.kt
View File

@@ -1,11 +1,9 @@
package ch.tutteli.atrium.api.fluent.en_GB
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.logic.utils.mapArguments
import ch.tutteli.atrium.specs.*
import ch.tutteli.atrium.specs.integration.mfun2
import org.spekframework.spek2.Spek
import kotlin.jvm.JvmName
import ch.tutteli.atrium.api.fluent.en_GB.MapContainsInAnyOrderKeyValuePairsAssertionsSpec.Companion as C
class MapContainsInAnyOrderKeyValuePairsAssertionsSpec : Spek({
@@ -14,8 +12,8 @@ class MapContainsInAnyOrderKeyValuePairsAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"[Atrium][Builder] "
)
@@ -26,7 +24,7 @@ class MapContainsInAnyOrderKeyValuePairsAssertionsSpec : Spek({
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inAnyOrder.$keyValuePair/$keyValuePairs"
val functionDescription = "$contains.$inAnyOrder.$keyValuePair/$keyValuePairs"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

10
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec.kt
View File

@@ -16,8 +16,8 @@ class MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
@@ -32,20 +32,20 @@ class MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec : Spek({
object BuilderMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$contains.$inAnyOrder.$only.$entriesOf",
functionDescription,
mapOf("a" to 1),
{ input -> contains.inAnyOrder.only.entriesOf(input) }
)
object ShortcutMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$containsOnlyEntriesOf",
containsOnlyEntriesOf,
mapOf("a" to 1),
{ input -> containsOnlyEntriesOf(input) }
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inAnyOrder.$only.$entriesOf"
val functionDescription = "$contains.$inAnyOrder.$only.$entriesOf"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

6
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderOnlyKeyValueAssertionsSpec.kt
View File

@@ -14,8 +14,8 @@ class MapContainsInAnyOrderOnlyKeyValueAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderOnlyKeyValueAssertionsSpec(
containsKeyValue_s to C::containsKeyValues,
(containsKeyValue_s to C::containsKeyValuesNullable).withNullableSuffix(),
functionDescription to C::containsKeyValues,
(functionDescription to C::containsKeyValuesNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
@@ -29,7 +29,7 @@ class MapContainsInAnyOrderOnlyKeyValueAssertionsSpec : Spek({
)
companion object : MapContainsSpecBase() {
val containsKeyValue_s = "$contains.$inAnyOrder.$only.$keyValue/$keyValues"
val functionDescription = "$contains.$inAnyOrder.$only.$keyValue/$keyValues"
private fun containsKeyValues(
expect: Expect<Map<out String, Int>>,

7
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec.kt
View File

@@ -4,7 +4,6 @@ import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.*
import ch.tutteli.atrium.specs.integration.mfun2
import org.spekframework.spek2.Spek
import kotlin.jvm.JvmName
import ch.tutteli.atrium.api.fluent.en_GB.MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec.Companion as C
class MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec : Spek({
@@ -13,8 +12,8 @@ class MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
@@ -27,7 +26,7 @@ class MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec : Spek({
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inAnyOrder.$only.$keyValuePair/$keyValuePairs"
val functionDescription = "$contains.$inAnyOrder.$only.$keyValuePair/$keyValuePairs"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

8
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInOrderOnlyEntriesOfAssertionsSpec.kt
View File

@@ -12,21 +12,21 @@ class MapContainsInOrderOnlyEntriesOfAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInOrderOnlyKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
object BuilderMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$contains.$inOrder.only.$only.$entriesOf",
functionDescription,
mapOf("a" to 1),
{ input -> contains.inOrder.only.entriesOf(input) }
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inOrder.$only.$keyValuePair/$keyValuePairs"
val functionDescription = "$contains.$inOrder.$only.$entriesOf"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

6
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInOrderOnlyKeyValueAssertionsSpec.kt
View File

@@ -12,14 +12,14 @@ class MapContainsInOrderOnlyKeyValueAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInOrderOnlyKeyValueAssertionsSpec(
containsKeyValue_s to C::containsKeyValues,
(containsKeyValue_s to C::containsKeyValuesNullable).withNullableSuffix(),
functionDescription to C::containsKeyValues,
(functionDescription to C::containsKeyValuesNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
companion object : MapContainsSpecBase() {
val containsKeyValue_s = "$contains.$inOrder.$only.$keyValue/$keyValues"
val functionDescription = "$contains.$inOrder.$only.$keyValue/$keyValues"
private fun containsKeyValues(
expect: Expect<Map<out String, Int>>,

6
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsInOrderOnlyKeyValuePairsAssertionsSpec.kt
View File

@@ -11,14 +11,14 @@ class MapContainsInOrderOnlyKeyValuePairsAssertionsSpec : Spek({
}) {
object BuilderSpec : ch.tutteli.atrium.specs.integration.MapContainsInOrderOnlyKeyValuePairsAssertionsSpec(
containsKeyValuePair_s to C::containsKeyValuePairs,
(containsKeyValuePair_s to C::containsKeyValuePairsNullable).withNullableSuffix(),
functionDescription to C::containsKeyValuePairs,
(functionDescription to C::containsKeyValuePairsNullable).withNullableSuffix(),
"◆ ", "✔ ", "✘ ", "❗❗ ", "⚬ ", "» ", "▶ ", "◾ ",
"[Atrium][Builder] "
)
companion object : MapContainsSpecBase() {
val containsKeyValuePair_s = "$contains.$inOrder.$only.$keyValuePair/$keyValuePairs"
val functionDescription = "$contains.$inOrder.$only.$keyValuePair/$keyValuePairs"
private fun containsKeyValuePairs(
expect: Expect<Map<out String, Int>>,

4
apis/fluent-en_GB/atrium-api-fluent-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/MapContainsSpecBase.kt
View File

@@ -10,8 +10,8 @@ import kotlin.reflect.KFunction3
abstract class MapContainsSpecBase {
private val containsProp: KProperty<*> = Expect<Map<*, *>>::contains
protected val contains = containsProp.name
protected val containsEntriesOf = Expect<Map<*, *>>::containsEntriesOf
protected val containsOnlyEntriesOf = Expect<Map<*, *>>::containsOnlyEntriesOf
protected val containsEntriesOf = Expect<Map<*, *>>::containsEntriesOf.name
protected val containsOnlyEntriesOf = Expect<Map<*, *>>::containsOnlyEntriesOf.name
//@formatter:off
protected val inAnyOrder = MapLikeContains.EntryPointStep<String, Int, Map<String, Int>, NoOpSearchBehaviour>::inAnyOrder.name

2
apis/infix-en_GB/atrium-api-infix-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/infix/en_GB/MapContainsInAnyOrderEntriesOfAssertionsSpec.kt
View File

@@ -35,7 +35,7 @@ class MapContainsInAnyOrderEntriesOfAssertionsSpec : Spek({
object ShortcutMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$containsEntriesOf",
containsEntriesOf,
mapOf("a" to 1),
{ input -> it containsOnlyEntriesOf input }
)

16
apis/infix-en_GB/atrium-api-infix-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/infix/en_GB/MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec.kt
View File

@@ -23,8 +23,8 @@ class MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec : Spek({
)
object ShortcutSpec : ch.tutteli.atrium.specs.integration.MapContainsInAnyOrderOnlyKeyValuePairsAssertionsSpec(
mfun2<String, Int, Int>(C::containsInAnyOrderOnlyEntriesOf),
mfun2<String?, Int?, Int?>(C::containsInAnyOrderOnlyEntriesOf).withNullableSuffix(),
mfun2<String, Int, Int>(C::containsOnlyEntriesOf),
mfun2<String?, Int?, Int?>(C::containsOnlyEntriesOf).withNullableSuffix(),
"* ", "(/) ", "(x) ", "(!) ", "- ", ">> ", "=> ",
"[Atrium][Shortcut] "
)
@@ -39,7 +39,7 @@ class MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec : Spek({
object ShortcutMapLikeToIterablePairSpec :
ch.tutteli.atrium.specs.integration.MapLikeToIterablePairSpec<Map<String, Int>>(
"$containsOnlyEntriesOf",
containsOnlyEntriesOf,
mapOf("a" to 1),
{ input -> it containsOnlyEntriesOf input }
)
@@ -67,22 +67,20 @@ class MapContainsInAnyOrderOnlyEntriesOfAssertionsSpec : Spek({
): Expect<Map<out String?, Int?>> =
expect contains o inAny order but only entriesOf listOf(a, *aX)
private fun containsInAnyOrderOnlyEntriesOf(
private fun containsOnlyEntriesOf(
expect: Expect<Map<out String, Int>>,
a: Pair<String, Int>,
aX: Array<out Pair<String, Int>>
): Expect<Map<out String, Int>> =
//TODO 0.15.0: change to shortcut
expect contains o inAny order but only entriesOf sequenceOf(a, *aX)
expect containsOnlyEntriesOf sequenceOf(a, *aX)
@JvmName("containsInAnyOrderOnlyEntriesOfNullable")
private fun containsInAnyOrderOnlyEntriesOf(
private fun containsOnlyEntriesOf(
expect: Expect<Map<out String?, Int?>>,
a: Pair<String?, Int?>,
aX: Array<out Pair<String?, Int?>>
): Expect<Map<out String?, Int?>> =
//TODO 0.15.0: change to shortcut
expect contains o inAny order but only entriesOf arrayOf(a, *aX)
expect containsOnlyEntriesOf arrayOf(a, *aX)
}
@Suppress("unused", "UNUSED_VALUE")

4
apis/infix-en_GB/atrium-api-infix-en_GB-common/src/test/kotlin/ch/tutteli/atrium/api/infix/en_GB/MapContainsSpecBase.kt
View File

@@ -15,8 +15,8 @@ abstract class MapContainsSpecBase : WithAsciiReporter() {
private val containsProp: KFunction2<Expect<Map<*, *>>, o, *> = Expect<Map<*, *>>::contains
protected val contains = containsProp.name
protected val filler = o::class.simpleName
protected val containsEntriesOf = Expect<Map<*, *>>::containsEntriesOf
protected val containsOnlyEntriesOf = Expect<Map<*, *>>::containsOnlyEntriesOf
protected val containsEntriesOf = Expect<Map<*, *>>::containsEntriesOf.name
protected val containsOnlyEntriesOf = Expect<Map<*, *>>::containsOnlyEntriesOf.name
//@formatter:off
protected val inAnyOrder = "${MapLikeContains.EntryPointStep<String, Int, List<Int>, NoOpSearchBehaviour>::inAny.name} ${order::class.simpleName}"

2
core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/common/HoldsStep.kt
View File

@@ -34,6 +34,6 @@ interface HoldsStep<R> {
*
* @return `true` in case [SubjectProvider.maybeSubject] is None or the result of [test] passing the subject.
*/
//TODO move to logic and expect AssertionContainer with 0.15.0
//TODO move to logic and expect AssertionContainer with 0.16.0
fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): R
}

2
core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/descriptive.kt
View File

@@ -42,7 +42,7 @@ interface Descriptive {
* fun <T> withTest(expect: Expect, test: (T) -> Boolean): DescriptionOption<FinalStep>
* ```
*/
//TODO move to logic and expect AssertionContainer with 0.15.0
//TODO move to logic and expect AssertionContainer with 0.16.0
fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): DescriptionOption<FinalStep>
companion object {

2
core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/descriptiveWithFailureHint.kt
View File

@@ -33,7 +33,7 @@ fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHint(
* Or use [withFailureHint] which does not expect a [subjectProvider] in case your [DescriptiveAssertion] is not based
* on the subject of the assertion.
*/
//TODO move to logic and expect AssertionContainer with 0.15.0
//TODO move to logic and expect AssertionContainer with 0.16.0
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHintBasedOnDefinedSubject(
subjectProvider: SubjectProvider<T>,
failureHintFactory: (T) -> Assertion

2
core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/creating/AssertionContainer.kt
View File

@@ -16,7 +16,7 @@ import kotlin.reflect.KClass
*
* @param T The type of the subject of the assertion.
*/
//TODO 0.15.0 remove SubjectProvider
//TODO 0.16.0 remove SubjectProvider
interface AssertionContainer<T> : SubjectProvider<T> {
override val maybeSubject: Option<T>

2
core/robstoll/atrium-core-robstoll-js/src/main/kotlin/ch/tutteli/atrium/core/robstoll/dependOnMe.kt
View File

@@ -4,6 +4,6 @@ package ch.tutteli.atrium.core.robstoll
* Dummy function in order that other modules can define a dependency on atrium-core-robstoll-js
*/
@Suppress("FunctionName")
//TODO 0.15.0 deprecated if core-robstoll is deprecated
//TODO 0.16.0 deprecated if core-robstoll is deprecated
fun dependOn_atrium_core_robstoll() {
}

2
logic/atrium-logic-common/src/generated/kotlin/ch/tutteli/atrium/logic/any.kt
View File

@@ -20,6 +20,8 @@ fun <T> AssertionContainer<T>.notToBe(expected: T): Assertion = impl.notToBe(thi
fun <T> AssertionContainer<T>.isSameAs(expected: T): Assertion = impl.isSameAs(this, expected)
fun <T> AssertionContainer<T>.isNotSameAs(expected: T): Assertion = impl.isNotSameAs(this, expected)
// TODO remove with 0.16.0 it is enough to have toBe
// TODO deprecate with 0.15.0
fun <T : Any?> AssertionContainer<T>.toBeNull(): Assertion = impl.toBeNull(this)
fun <T : Any> AssertionContainer<T?>.toBeNullIfNullGivenElse(type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion =

2
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/AnyAssertions.kt
View File

@@ -15,6 +15,8 @@ interface AnyAssertions {
fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
// TODO remove with 0.16.0 it is enough to have toBe
// TODO deprecate with 0.15.0
fun <T : Any?> toBeNull(container: AssertionContainer<T>): Assertion
fun <T : Any> toBeNullIfNullGivenElse(

3
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/creating/charsequence/contains/creators/impl/CharSequenceContainsAssertionCreator.kt
View File

@@ -46,7 +46,8 @@ class CharSequenceContainsAssertionCreator<T : CharSequence, in SC : Any, S : Se
container.changeSubject.unreported { it.toString() }.toAssertionContainer()
override fun search(multiConsumableContainer: AssertionContainer<String>, searchCriterion: SC): Int =
// if the maybeSubject is None it means we are in an explanation like context in which it does not matter if it is found or not.
// if the maybeSubject is None it means we are in an explanation like context in which
// it should not matter what this number is. Moreover, we check in the atMostChecker that times is >= 0
multiConsumableContainer.maybeSubject.fold({ -1 }) { searcher.search(it, searchCriterion) }
override fun decorateAssertion(

2
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/creating/transformers/FeatureExtractorBuilder.kt
View File

@@ -39,7 +39,7 @@ interface FeatureExtractorBuilder {
* Use [withDescription] in case the feature extraction is not based on a method call.
*/
fun methodCall(methodName: String, vararg arguments: Any?): RepresentationInCaseOfFailureStep<T> =
//TODO use methodCallFormatter from container 0.15.0
//TODO use methodCallFormatter from container 0.16.0
withDescription(coreFactory.newMethodCallFormatter().formatCall(methodName, arguments))
/**

2
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/creating/transformers/impl/DefaultFeatureExtractor.kt
View File

@@ -42,7 +42,7 @@ class DefaultFeatureExtractor : FeatureExtractor {
try {
featureExtraction(subject).fold({ Left(None) }, { Right(it) })
} catch (throwable: Throwable) {
//TODO 0.15.0 should be taken from `container`
//TODO 0.16.0 should be taken from `container`
reporter.atriumErrorAdjuster.adjust(throwable)
Left(Some(throwable))
}

4
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/featureExtensions.kt
View File

@@ -19,7 +19,7 @@ fun <T, R> AssertionContainer<T>.manualFeature(
provider: T.() -> R
): FeatureExtractorBuilder.ExecutionStep<T, R> = manualFeature(Untranslatable(description), provider)
//TODO use MetaFeature from logic with 0.15.0
//TODO use MetaFeature from logic with 0.16.0
fun <T, R> AssertionContainer<T>.genericSubjectBasedFeature(
provider: (T) -> MetaFeature<R>
): FeatureExtractorBuilder.ExecutionStep<T, R> =
@@ -27,7 +27,7 @@ fun <T, R> AssertionContainer<T>.genericSubjectBasedFeature(
private fun <R> createFeatureSubjectNotDefined(): MetaFeature<R> =
MetaFeature(
ErrorMessages.DEDSCRIPTION_BASED_ON_SUBJECT,
ErrorMessages.DESCRIPTION_BASED_ON_SUBJECT,
ErrorMessages.REPRESENTATION_BASED_ON_SUBJECT_NOT_DEFINED,
None
)

2
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/impl/DefaultFeatureAssertions.kt
View File

@@ -19,7 +19,7 @@ class DefaultFeatureAssertions : FeatureAssertions {
extractFeature(container, property.name, property::get)
override fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R> =
//TODO 0.15.0 use methodCallFormatter from container via getImpl
//TODO 0.16.0 use methodCallFormatter from container via getImpl
extractFeature(container, coreFactory.newMethodCallFormatter().formatCall(f.name, arrayOf()), f::invoke)
override fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R> =

2
logic/atrium-logic-common/src/main/kotlin/ch/tutteli/atrium/logic/impl/DefaultThrowableAssertions.kt
View File

@@ -20,7 +20,7 @@ class DefaultThrowableAssertions : ThrowableAssertions {
expectedType: KClass<TExpected>
): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected> =
container.manualFeature(OCCURRED_EXCEPTION_CAUSE) { cause }.transform().let { previousExpect ->
//TODO 0.15.0 factor out a pattern, we are doing this more than once, in API we have withOptions
//TODO 0.16.0 factor out a pattern, we are doing this more than once, in API we have withOptions
FeatureExpect(
previousExpect,
FeatureExpectOptions(representationInsteadOfFeature = {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceAssertionsSpec.kt
View File

@@ -93,8 +93,8 @@ abstract class CharSequenceAssertionsSpec(
val hello = TestTranslatable.HELLO.getDefault()
val welcome = TestTranslatable.WELCOME.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsDefaultTranslationOf, containsNotDefaultTranslationOf) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsAtLeastAssertionsSpec.kt
View File

@@ -68,8 +68,8 @@ abstract class CharSequenceContainsAtLeastAssertionsSpec(
val (containsNot, errorMsgContainsNot) = containsNotPair
val (exactly, errorMsgExactly) = exactlyPair
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsAtLeast, containsAtLeastButAtMost) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsAtMostAssertionsSpec.kt
View File

@@ -54,8 +54,8 @@ abstract class CharSequenceContainsAtMostAssertionsSpec(
val (containsNot, errorMsgContainsNot) = containsNotPair
val (exactly, errorMsgExactly) = exactlyPair
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsAtMost) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsContainsNotAssertionsSpec.kt
View File

@@ -49,8 +49,8 @@ abstract class CharSequenceContainsContainsNotAssertionsSpec(
fun Assert<CharSequence>.containsNotFun(t: String, vararg tX: String)
= containsNotFunArr(t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
val containsNotDescr = CONTAINS_NOT.getDefault()
describeFun(containsFunName, containsNot) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsExactlyAssertionsSpec.kt
View File

@@ -52,8 +52,8 @@ abstract class CharSequenceContainsExactlyAssertionsSpec(
val (containsNot, errorMsgContainsNot) = containsNotPair
val exactly = EXACTLY.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsExactly) {
context("throws an $illegalArgumentException") {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsNotAssertionsSpec.kt
View File

@@ -53,8 +53,8 @@ abstract class CharSequenceContainsNotAssertionsSpec(
val containsNotDescr = DescriptionCharSequenceAssertion.CONTAINS_NOT.getDefault()
val containsNotIgnoringCaseDescr = String.format(DescriptionCharSequenceAssertion.IGNORING_CASE.getDefault(), containsNotDescr)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsNot) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsNotOrAtMostAssertionsSpec.kt
View File

@@ -51,8 +51,8 @@ abstract class CharSequenceContainsNotOrAtMostAssertionsSpec(
val (containsNot, errorMsgContainsNot) = containsNotPair
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsNotOrAtMost) {

4
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/CharSequenceContainsRegexAssertionsSpec.kt
View File

@@ -77,8 +77,8 @@ abstract class CharSequenceContainsRegexAssertionsSpec(
fun Assert<CharSequence>.containsAtMostIgnoringCaseFun(atLeast: Int, a: String, vararg aX: String)
= containsAtMostIgnoringCaseFunArr(atLeast, a, aX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val regexWithIndent = "$indentBulletPoint$listBulletPoint$stringMatchingRegex"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val regexWithIndent = "$indentRootBulletPoint$listBulletPoint$stringMatchingRegex"
describeFun(containsRegex) {
context("throws an ${PatternSyntaxException::class.simpleName}") {

6
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableAllAssertionsSpec.kt
View File

@@ -42,12 +42,12 @@ abstract class IterableAllAssertionsSpec(
val all = DescriptionIterableAssertion.ALL.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val explanatoryPointWithIndent = "$indentBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val explanatoryPointWithIndent = "$indentRootBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
fun index(index: Int)
= listBulletPoint + String.format(DescriptionIterableAssertion.INDEX.getDefault(), index)
@@ -66,7 +66,7 @@ abstract class IterableAllAssertionsSpec(
}.toThrow<AssertionError> {
messageContains(
"$rootBulletPoint$featureArrow$hasElement: false$separator"+
"$indentBulletPoint$indentFeatureArrow$featureBulletPoint$isDescr: true"
"$indentRootBulletPoint$indentFeatureArrow$featureBulletPoint$isDescr: true"
)
}
}

6
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsInAnyOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -44,13 +44,13 @@ abstract class IterableContainsInAnyOrderOnlyEntriesAssertionsSpec(
fun Assert<Iterable<Double?>>.containsInAnyOrderOnlyNullableEntriesFun(t: (Assert<Double>.() -> Unit)?, vararg tX: (Assert<Double>.() -> Unit)?)
= containsInAnyOrderOnlyNullableEntriesArr(t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val anEntryAfterSuccess = "$anEntryWhich: $separator$indentBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterFailing = "$anEntryWhich: $separator$indentBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterSuccess = "$anEntryWhich: $separator$indentRootBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterFailing = "$anEntryWhich: $separator$indentRootBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
nonNullableCases(describePrefix,
containsInAnyOrderOnlyEntriesPair,

10
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsInOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -49,7 +49,7 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
fun Assert<Iterable<Double?>>.containsInOrderOnlyNullableEntriesFun(t: (Assert<Double>.() -> Unit)?, vararg tX: (Assert<Double>.() -> Unit)?)
= containsInOrderOnlyNullableEntriesArr(t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
@@ -59,8 +59,8 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
val explanatoryPointWithIndent = "$indentFeatureArrow$indentFeatureBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val entryWhichWithFeature = "$indentFeatureArrow$featureBulletPoint$anEntryWhich"
val anEntryAfterSuccess = "$entryWhichWithFeature: $separator$indentBulletPoint$indentSuccessfulBulletPoint$explanatoryPointWithIndent"
val anEntryAfterFailing = "$entryWhichWithFeature: $separator$indentBulletPoint$indentFailingBulletPoint$explanatoryPointWithIndent"
val anEntryAfterSuccess = "$entryWhichWithFeature: $separator$indentRootBulletPoint$indentSuccessfulBulletPoint$explanatoryPointWithIndent"
val anEntryAfterFailing = "$entryWhichWithFeature: $separator$indentRootBulletPoint$indentFailingBulletPoint$explanatoryPointWithIndent"
fun entry(index: Int)
= String.format(entryWithIndex, index)
@@ -68,13 +68,13 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
fun Assert<CharSequence>.entrySuccess(index: Int, actual: Any, expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${entry(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentSuccessfulBulletPoint$anEntryAfterSuccess$expected")
"$indentRootBulletPoint$indentSuccessfulBulletPoint$anEntryAfterSuccess$expected")
}
fun Assert<CharSequence>.entryFailing(index: Int, actual: Any, expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${entry(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$anEntryAfterFailing$expected")
"$indentRootBulletPoint$indentFailingBulletPoint$anEntryAfterFailing$expected")
}
nonNullableCases(describePrefix,

30
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec.kt
View File

@@ -45,7 +45,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun Assert<Iterable<Double?>>.containsInOrderOnlyGroupedEntriesFun(t1: Group<(Assert<Double>.() -> Unit)?>, t2: Group<(Assert<Double>.() -> Unit)?>, vararg tX: Group<(Assert<Double>.() -> Unit)?>)
= containsInOrderOnlyGroupedEntriesFunArr(t1, t2, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
@@ -62,17 +62,17 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun index(fromIndex: Int, toIndex: Int)
= String.format(DescriptionIterableAssertion.INDEX_FROM_TO.getDefault(), fromIndex, toIndex)
fun entry(prefix: String, bulletPoint: String, indentBulletPoint: String, expected: Array<out String>)
fun entry(prefix: String, bulletPoint: String, indentRootBulletPoint: String, expected: Array<out String>)
= expected.joinToString(".*$separator") {
"$prefix\\Q$bulletPoint$anEntryWhich: \\E$separator" +
"$prefix$indentBulletPoint$indentListBulletPoint$explanatoryBulletPoint$it"
"$prefix$indentRootBulletPoint$indentListBulletPoint$explanatoryBulletPoint$it"
}
fun size(prefix: String, bulletPoint: String, actual: Int, expected: Int)
= "$prefix\\Q$bulletPoint\\E${featureArrow}size: $actual[^:]+: $expected"
val afterFail = "$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterFail = "$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun failAfterFail(vararg expected: String)
= entry(afterFail, failingBulletPoint, indentFailingBulletPoint, expected)
@@ -96,7 +96,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
= warning(additionalEntries, entryWithValue) { "${entryWithIndex(it.first)}: ${it.second}" }
val afterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun successAfterSuccess(vararg expected: String)
= entry(afterSuccess, successfulBulletPoint, indentSuccessfulBulletPoint, expected)
@@ -107,14 +107,14 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun Assert<CharSequence>.indexSuccess(index: Int, actual: Any, expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$anEntryWhich: $separator" +
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$anEntryWhich: $separator" +
"$afterSuccess$indentListBulletPoint$explanatoryBulletPoint$expected")
}
fun Assert<CharSequence>.indexSuccess(fromIndex: Int, toIndex: Int, actual: List<Double?>, vararg expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
@@ -123,14 +123,14 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun Assert<CharSequence>.indexFail(index: Int, actual: Any, expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$anEntryWhich: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$anEntryWhich: $separator" +
"$afterFail$indentListBulletPoint$explanatoryBulletPoint$expected")
}
fun Assert<CharSequence>.indexFail(fromIndex: Int, toIndex: Int, actual: List<Double?>, vararg expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
}
@@ -253,7 +253,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successSizeAfterFail(3),
mismatchesAfterFail(4.0)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -281,7 +281,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterSuccess("$toBeDescr: 4.0"),
successSizeAfterFail(3)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -301,7 +301,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterSuccess("$toBeDescr: 4.0", "$toBeDescr: 2.0", "$toBeDescr: 3.0"),
successSizeAfterSuccess(3)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 4))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 4))
containsRegex(additional(4 to 4.0))
}
}
@@ -315,7 +315,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
contains.exactly(1).value("$rootBulletPoint$containsInOrderOnlyGrouped:")
indexSuccess(0, 1.0, "$toBeDescr: 1.0")
indexFail(1, 2.0, "$toBeDescr: 4.0")
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 2))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 2))
containsRegex(additional(2 to 3.0, 3 to 4.0, 4 to 4.0))
}
}
@@ -337,7 +337,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
mismatchesAfterFail(2.0)
)
indexFail(2, 3.0, "$toBeDescr: 5.0")
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 3))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 3))
containsRegex(additional(3 to 4.0, 4 to 4.0))
}
}
@@ -367,7 +367,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterFail("$toBeDescr: 4.0"),
failSizeAfterFail(1, 2)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 6))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 6))
}
}
}

26
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsInOrderOnlyGroupedValuesAssertionsSpec.kt
View File

@@ -52,7 +52,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
fun Assert<Iterable<Double?>>.containsInOrderOnlyGroupedNullableValuesFun(t1: Group<Double?>, t2: Group<Double?>, vararg tX: Group<Double?>)
= containsInOrderOnlyGroupedNullableValuesFunArr(t1,t2, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
@@ -60,8 +60,8 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
val indentWarningBulletPoint = " ".repeat(warningBulletPoint.length)
val toBeWithFeature = "$indentFeatureArrow$featureBulletPoint${TO_BE.getDefault()}"
val toBeAfterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentBulletPoint$indentFailingBulletPoint$toBeWithFeature"
val toBeAfterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentRootBulletPoint$indentFailingBulletPoint$toBeWithFeature"
fun index(index: Int)
= String.format(DescriptionIterableAssertion.INDEX.getDefault(), index)
@@ -79,7 +79,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
= "$prefix\\Q$bulletPoint\\E${featureArrow}size: $actual[^:]+: $expected"
val afterFail = "$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterFail = "$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun failAfterFail(vararg expected: Double?)
= entry(afterFail, failingBulletPoint, expected)
@@ -103,7 +103,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
= warning(additionalEntries, entryWithValue) { "${entryWithIndex(it.first)}: ${it.second}" }
val afterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun successAfterSuccess(vararg expected: Double?)
= entry(afterSuccess, successfulBulletPoint, expected)
@@ -120,7 +120,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
fun Assert<CharSequence>.indexSuccess(fromIndex: Int, toIndex: Int, actual: List<Double?>, vararg expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
@@ -135,7 +135,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
fun Assert<CharSequence>.indexFail(fromIndex: Int, toIndex: Int, actual: List<Double?>, vararg expected: String): Assert<CharSequence> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
}
@@ -231,7 +231,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successSizeAfterFail(3),
mismatchesAfterFail(4.0)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -247,7 +247,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successAfterSuccess(4.0, 2.0, 3.0),
successSizeAfterSuccess(3)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 4))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 4))
containsRegex(additional(4 to 4.0))
}
}
@@ -261,7 +261,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
contains.exactly(1).value("$rootBulletPoint$containsInOrderOnlyGrouped:")
indexSuccess(0, 1.0)
indexFail(1, 2.0, 4.0)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 2))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 2))
containsRegex(additional(2 to 3.0, 3 to 4.0, 4 to 4.0))
}
}
@@ -279,7 +279,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
mismatchesAfterFail(2.0)
)
indexFail(2, 3.0, 5.0)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 3))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 3))
containsRegex(additional(3 to 4.0, 4 to 4.0))
}
}
@@ -299,7 +299,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successAfterFail(4.0),
failSizeAfterFail(1, 2)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 6))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 6))
}
}
}
@@ -352,7 +352,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
failAfterFail(1.0),
successSizeAfterFail(2)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 4, 4))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 4, 4))
}
}
}

6
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsInOrderOnlyValuesAssertionsSpec.kt
View File

@@ -44,14 +44,14 @@ abstract class IterableContainsInOrderOnlyValuesAssertionsSpec(
fun Assert<Iterable<Double?>>.containsInOrderOnlyNullableValuesFun(t: Double?, vararg tX: Double?)
= containsInOrderOnlyNullableValuesFunArr(t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val toBeWithFeature = "$indentFeatureArrow$featureBulletPoint${TO_BE.getDefault()}"
val toBeAfterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentBulletPoint$indentFailingBulletPoint$toBeWithFeature"
val toBeAfterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentRootBulletPoint$indentFailingBulletPoint$toBeWithFeature"
fun entry(index: Int)
= String.format(entryWithIndex, index)

24
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsNotEntriesAssertionsSpec.kt
View File

@@ -49,17 +49,17 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
nonNullableCases(
describePrefix,
@@ -80,7 +80,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureSuccess$numberOfOccurrences: 0$separator"+
"$isAfterSuccess: 0.*$separator"+
@@ -115,7 +115,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$isLessThanDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator"+
"$isAfterFailing: 0.*$separator"+
@@ -132,13 +132,13 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$toBeDescr: 1.0.*$separator" +
"$featureFailing$numberOfOccurrences: 1$separator"+
"$isAfterFailing: 0.*$separator"+
"$featureSuccess$hasElement: true$separator" +
"$isAfterSuccess: true$separator"+
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator"+
"$isAfterFailing: 0.*$separator"+
@@ -178,7 +178,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -196,7 +196,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator" +
"$isAfterFailing: 0.*$separator" +

12
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableContainsNotValuesAssertionsSpec.kt
View File

@@ -50,18 +50,18 @@ abstract class IterableContainsNotValuesAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val anEntryWhichIsWithIndent = "$indentBulletPoint$listBulletPoint$anEntryWhichIs"
val anEntryWhichIsWithIndent = "$indentRootBulletPoint$listBulletPoint$anEntryWhichIs"
nonNullableCases(
describePrefix,

18
misc/deprecated/atrium-spec/src/main/kotlin/ch/tutteli/atrium/spec/integration/IterableNoneAssertionsSpec.kt
View File

@@ -46,17 +46,17 @@ abstract class IterableNoneAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
nonNullableCases(
describePrefix,
@@ -83,7 +83,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator"+
"$isAfterFailing: 0.*$separator"+
@@ -112,7 +112,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator"+
"$isAfterFailing: 0.*$separator"+
@@ -130,7 +130,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anEntryWhich: $separator"+
"$afterExplanatory$toBeDescr: 1.0.*$separator" +
"$featureFailing$numberOfOccurrences: 1$separator"+
"$isAfterFailing: 0.*$separator"+

4
misc/deprecated/domain/api/atrium-domain-api-common/src/main/kotlin/ch/tutteli/atrium/domain/creating/collectors/AssertionCollector.kt
View File

@@ -17,13 +17,13 @@ import ch.tutteli.atrium.reporting.translating.Translatable
*
* It loads the implementation lazily via [loadSingleService].
*/
//TODO 0.15.0 move to atrium-logic
//TODO 0.16.0 move to atrium-logic
val assertionCollector: AssertionCollector by lazy { loadSingleService(AssertionCollector::class) }
/**
* Responsible to collect assertions made in an `assertionCreator`-lambda.
*/
//TODO 0.15.0 move to atrium-logic
//TODO 0.16.0 move to atrium-logic
interface AssertionCollector {
/**

2
misc/deprecated/domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/creating/NewFeatureAssertionsBuilder.kt
View File

@@ -115,7 +115,7 @@ object NewFeatureAssertionsBuilder : NewFeatureAssertions {
* a function which expects 2 arguments).
*/
//TODO move to API, this could potentially be different per API
//TODO deprecate in 0.15.0
//TODO deprecate in 0.16.0
class MetaFeatureOption<T>(private val expect: Expect<T>) {
/**

4
misc/deprecated/domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/creating/collectors/AssertionOptionExplantoryExtensions.kt
View File

@@ -10,7 +10,7 @@ import ch.tutteli.atrium.domain.creating.collectors.assertionCollector
/**
* Collects the assertions [assertionCreator] creates and uses them as [AssertionGroup.assertions].
*/
//TODO move to atrium-logic with 0.15.0
//TODO move to atrium-logic with 0.16.0
fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAssertions(
expect: Expect<T>,
assertionCreator: Expect<T>.() -> Unit
@@ -19,7 +19,7 @@ fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAsse
/**
* Collects the assertions [assertionCreator] creates and uses them as [AssertionGroup.assertions].
*/
//TODO move to atrium-logic with 0.15.0
//TODO move to atrium-logic with 0.16.0
fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAssertions(
maybeSubject: Option<T>,
assertionCreator: Expect<T>.() -> Unit

4
misc/deprecated/domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/reporting/ExpectBuilder.kt
View File

@@ -19,7 +19,7 @@ import ch.tutteli.atrium.reporting.translating.Untranslatable
/**
* Defines the contract to create custom assertion verbs, `Expect<T>` respectively.
*/
//TODO move to atrium-logic with 0.15.0
//TODO move to atrium-logic with 0.16.0
interface ExpectBuilder {
companion object {
@@ -106,7 +106,7 @@ interface ExpectBuilder {
*
* Calling multiple times the same method overrides the previously defined value.
*/
//TODO move to atrium-core with 0.15.0 (or to logic and move FeatureExpectOptionsChooser to logic as well?)
//TODO move to atrium-core with 0.16.0 (or to logic and move FeatureExpectOptionsChooser to logic as well?)
interface OptionsChooser<T> {
/**

2
misc/deprecated/domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/utils/VarArgHelper.kt
View File

@@ -10,7 +10,7 @@ import ch.tutteli.kbox.glue
* Represents a parameter object used to express the arguments `T, vararg T`
* and provides utility functions to transform them.
*/
//TODO copy/move to atrium-logic with 0.15.0
//TODO copy/move to atrium-logic with 0.16.0
interface VarArgHelper<out T> {
/**
* The first argument in the argument list `T, vararg T`

4
misc/deprecated/domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/utils/groupsToList.kt
View File

@@ -3,7 +3,7 @@ package ch.tutteli.atrium.domain.builders.utils
/**
* Represents a group of [T].
*/
//TODO copy and move to atrium-logic 0.15.0
//TODO copy and move to atrium-logic 0.16.0
interface Group<out T> {
/**
* Returns the members of the group as [List].
@@ -27,7 +27,7 @@ interface GroupWithNullableEntries<out T : Any?> : Group<T>
* Adds the given [firstGroup], the [secondGroup] and the [otherGroups] into a new [List] and returns it.
* @return a [List] containing [firstGroup], [secondGroup] and [otherGroups].
*/
//TODO copy and move to atrium-logic 0.15.0
//TODO copy and move to atrium-logic 0.16.0
fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>> {
val groups = ArrayList<List<T>>(otherGroups.size + 2)
requireNotEmptyAndAdd(groups, firstGroup)

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsAtLeastAssertionsSpec.kt
View File

@@ -52,8 +52,8 @@ abstract class CharSequenceContainsAtLeastAssertionsSpec(
atLeast: Int, atMost: Int, a: Any, vararg aX: Any
) = containsAtLeastButAtMostIgnoringCase(this, atLeast, atMost, a, aX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsAtLeast.name, containsAtLeastButAtMost.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsAtMostAssertionsSpec.kt
View File

@@ -37,8 +37,8 @@ abstract class CharSequenceContainsAtMostAssertionsSpec(
fun Expect<CharSequence>.containsAtMostIgnoringCaseFun(atLeast: Int, a: Any, vararg aX: Any) =
containsAtMostIgnoringCase(this, atLeast, a, aX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsAtMost.name, containsAtMostIgnoringCase.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsContainsNotAssertionsSpec.kt
View File

@@ -31,8 +31,8 @@ abstract class CharSequenceContainsContainsNotAssertionsSpec(
fun Expect<CharSequence>.containsNotFun(t: String, vararg tX: String) = containsNot.invoke(this, t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
val containsNotDescr = CONTAINS_NOT.getDefault()
describeFun(contains.name, containsNot.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsExactlyAssertionsSpec.kt
View File

@@ -38,8 +38,8 @@ abstract class CharSequenceContainsExactlyAssertionsSpec(
containsExactlyIgnoringCase(this, atLeast, a, aX)
val exactly = EXACTLY.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsExactly.name, containsExactlyIgnoringCase.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsNotAssertionsSpec.kt
View File

@@ -40,8 +40,8 @@ abstract class CharSequenceContainsNotAssertionsSpec(
val containsNotIgnoringCaseDescr =
String.format(DescriptionCharSequenceAssertion.IGNORING_CASE.getDefault(), containsNotDescr)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsNot.name, containsNotIgnoringCase.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsNotOrAtMostAssertionsSpec.kt
View File

@@ -37,8 +37,8 @@ abstract class CharSequenceContainsNotOrAtMostAssertionsSpec(
fun Expect<CharSequence>.containsNotOrAtMostIgnoringCaseFun(atLeast: Int, a: Any, vararg aX: Any) =
containsNotOrAtMostIgnoringCase(this, atLeast, a, aX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentBulletPoint$listBulletPoint$value"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val valueWithIndent = "$indentRootBulletPoint$listBulletPoint$value"
describeFun(containsNotOrAtMost.name, containsNotOrAtMostIgnoringCase.name) {

4
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/CharSequenceContainsRegexAssertionsSpec.kt
View File

@@ -61,8 +61,8 @@ abstract class CharSequenceContainsRegexAssertionsSpec(
fun Expect<CharSequence>.containsAtMostIgnoringCaseFun(atLeast: Int, a: String, vararg aX: String) =
containsAtMostIgnoringCase(this, atLeast, a, aX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val regexWithIndent = "$indentBulletPoint$listBulletPoint$stringMatchingRegex"
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val regexWithIndent = "$indentRootBulletPoint$listBulletPoint$stringMatchingRegex"
describeFun(containsRegex) {
context("throws an ${IllegalArgumentException::class.simpleName}") {

2
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/FeatureAssertionsSpec.kt
View File

@@ -159,7 +159,7 @@ abstract class FeatureAssertionsSpec(
if (isAbleToEvaluateDescription) {
messageContains(stringInExceptionMessage)
} else {
messageContains(ch.tutteli.atrium.translations.ErrorMessages.DEDSCRIPTION_BASED_ON_SUBJECT.getDefault())
messageContains(ch.tutteli.atrium.translations.ErrorMessages.DESCRIPTION_BASED_ON_SUBJECT.getDefault())
}
}
}

6
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableAllAssertionsSpec.kt
View File

@@ -37,12 +37,12 @@ abstract class IterableAllAssertionsSpec(
val allDescr = DescriptionIterableAssertion.ALL.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val explanatoryPointWithIndent = "$indentBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val explanatoryPointWithIndent = "$indentRootBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
fun index(index: Int) = listBulletPoint + String.format(DescriptionIterableAssertion.INDEX.getDefault(), index)
@@ -59,7 +59,7 @@ abstract class IterableAllAssertionsSpec(
}.toThrow<AssertionError> {
messageContains(
"$rootBulletPoint$featureArrow$hasElement: false$separator" +
"$indentBulletPoint$indentFeatureArrow$featureBulletPoint$isDescr: true"
"$indentRootBulletPoint$indentFeatureArrow$featureBulletPoint$isDescr: true"
)
}
}

6
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsInAnyOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -50,14 +50,14 @@ abstract class IterableContainsInAnyOrderOnlyEntriesAssertionsSpec(
vararg tX: (Expect<Double>.() -> Unit)?
) = containsInAnyOrderOnlyNullableEntries(this, t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
//@formatter:off
val anEntryAfterSuccess = "$anElementWhich: $separator$indentBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterFailing = "$anElementWhich: $separator$indentBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterSuccess = "$anElementWhich: $separator$indentRootBulletPoint$indentSuccessfulBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
val anEntryAfterFailing = "$anElementWhich: $separator$indentRootBulletPoint$indentFailingBulletPoint$indentListBulletPoint$explanatoryBulletPoint"
//@formatter:on
nonNullableCases(

6
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsInOrderOnlyEntriesAssertionsSpec.kt
View File

@@ -53,7 +53,7 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
vararg tX: (Expect<Double>.() -> Unit)?
) = containsInOrderOnlyNullableEntries(this, t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
@@ -62,7 +62,7 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
fun Expect<String>.elementSuccess(index: Int, actual: Any, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${elementWithIndex(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
)
}
@@ -74,7 +74,7 @@ abstract class IterableContainsInOrderOnlyEntriesAssertionsSpec(
): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${elementWithIndex(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow${if (explaining) "$indentFeatureBulletPoint$explanatoryBulletPoint" else featureBulletPoint}$expected"
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow${if (explaining) "$indentFeatureBulletPoint$explanatoryBulletPoint" else featureBulletPoint}$expected"
)
}

30
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec.kt
View File

@@ -61,7 +61,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
vararg tX: Group<(Expect<Double>.() -> Unit)?>
) = containsInOrderOnlyGroupedEntries(this, t1, t2, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
@@ -69,17 +69,17 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
val indentFeatureBulletPoint = " ".repeat(featureBulletPoint.length)
val indentWarningBulletPoint = " ".repeat(warningBulletPoint.length)
fun element(prefix: String, bulletPoint: String, indentBulletPoint: String, expected: Array<out String>) =
fun element(prefix: String, bulletPoint: String, indentRootBulletPoint: String, expected: Array<out String>) =
expected.joinToString(".*$separator") {
"$prefix\\Q$bulletPoint$anElementWhich: \\E$separator" +
"$prefix$indentBulletPoint$indentListBulletPoint$explanatoryBulletPoint$it"
"$prefix$indentRootBulletPoint$indentListBulletPoint$explanatoryBulletPoint$it"
}
fun size(prefix: String, bulletPoint: String, actual: Int, expected: Int) =
"$prefix\\Q$bulletPoint\\E${featureArrow}${DescriptionCollectionAssertion.SIZE.getDefault()}: $actual[^:]+: $expected"
val afterFail = "$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterFail = "$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun failAfterFail(vararg expected: String) =
element(afterFail, failingBulletPoint, indentFailingBulletPoint, expected)
@@ -100,7 +100,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
warning(additionalElements, entryWithValue) { "${elementWithIndex(it.first)}: ${it.second}" }
val afterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun successAfterSuccess(vararg expected: String) =
element(afterSuccess, successfulBulletPoint, indentSuccessfulBulletPoint, expected)
@@ -110,7 +110,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun Expect<String>.indexSuccess(index: Int, actual: Any, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
)
}
@@ -122,7 +122,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
@@ -131,7 +131,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
fun Expect<String>.indexFail(index: Int, actual: Any, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(index)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
)
}
@@ -151,7 +151,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
}
@@ -280,7 +280,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successSizeAfterFail(3),
mismatchesAfterFail(4.0)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -308,7 +308,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterSuccess("$toBeDescr: 4.0"),
successSizeAfterFail(3)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -328,7 +328,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterSuccess("$toBeDescr: 4.0", "$toBeDescr: 2.0", "$toBeDescr: 3.0"),
successSizeAfterSuccess(3)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 4))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 4))
containsRegex(additional(4 to 4.0))
}
}
@@ -346,7 +346,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
contains.exactly(1).value("$rootBulletPoint$containsInOrderOnlyGrouped:")
indexSuccess(0, 1.0, "$toBeDescr: 1.0")
indexFail(1, 2.0, "$toBeDescr: 4.0")
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 2))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 2))
containsRegex(additional(2 to 3.0, 3 to 4.0, 4 to 4.0))
}
}
@@ -368,7 +368,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
mismatchesAfterFail(2.0)
)
indexFail(2, 3.0, "$toBeDescr: 5.0")
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 3))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 3))
containsRegex(additional(3 to 4.0, 4 to 4.0))
}
}
@@ -398,7 +398,7 @@ abstract class IterableContainsInOrderOnlyGroupedEntriesAssertionsSpec(
successAfterFail("$toBeDescr: 4.0"),
failSizeAfterFail(1, 2)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 6))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 6))
}
}
}

26
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsInOrderOnlyGroupedValuesAssertionsSpec.kt
View File

@@ -41,7 +41,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
vararg tX: Group<Double?>
) = containsInOrderOnlyGroupedNullableValues(this, t1, t2, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
@@ -49,8 +49,8 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
val indentWarningBulletPoint = " ".repeat(warningBulletPoint.length)
val toBeWithFeature = "$indentFeatureArrow$featureBulletPoint$toBeDescr"
val toBeAfterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentBulletPoint$indentFailingBulletPoint$toBeWithFeature"
val toBeAfterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentRootBulletPoint$indentFailingBulletPoint$toBeWithFeature"
fun element(prefix: String, bulletPoint: String, expected: Array<out Double?>) =
@@ -59,7 +59,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
fun size(prefix: String, bulletPoint: String, actual: Int, expected: Int) =
"$prefix\\Q$bulletPoint\\E${featureArrow}${DescriptionCollectionAssertion.SIZE.getDefault()}: $actual[^:]+: $expected"
val afterFail = "$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterFail = "$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun failAfterFail(vararg expected: Double?) = element(afterFail, failingBulletPoint, expected)
fun successAfterFail(vararg expected: Double?) = element(afterFail, successfulBulletPoint, expected)
@@ -78,7 +78,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
warning(additionalElements, entryWithValue) { "${elementWithIndex(it.first)}: ${it.second}" }
val afterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
val afterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint"
fun successAfterSuccess(vararg expected: Double?) = element(afterSuccess, successfulBulletPoint, expected)
fun successSizeAfterSuccess(size: Int) = size(afterSuccess, successfulBulletPoint, size, size)
@@ -99,7 +99,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$successfulBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
@@ -120,7 +120,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${index(fromIndex, toIndex)}: $actual\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$featureBulletPoint$containsInAnyOrderOnly: $separator" +
expected.joinToString(".*$separator")
)
}
@@ -222,7 +222,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successSizeAfterFail(3),
mismatchesAfterFail(4.0)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 5, 5))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 5, 5))
}
}
}
@@ -239,7 +239,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successAfterSuccess(4.0, 2.0, 3.0),
successSizeAfterSuccess(3)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 4))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 4))
containsRegex(additional(4 to 4.0))
}
}
@@ -253,7 +253,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
contains.exactly(1).value("$rootBulletPoint$containsInOrderOnlyGrouped:")
indexSuccess(0, 1.0)
indexFail(1, 2.0, 4.0)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 2))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 2))
containsRegex(additional(2 to 3.0, 3 to 4.0, 4 to 4.0))
}
}
@@ -272,7 +272,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
mismatchesAfterFail(2.0)
)
indexFail(2, 3.0, 5.0)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 3))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 3))
containsRegex(additional(3 to 4.0, 4 to 4.0))
}
}
@@ -294,7 +294,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
successAfterFail(4.0),
failSizeAfterFail(1, 2)
)
containsRegex(size(indentBulletPoint, failingBulletPoint, 5, 6))
containsRegex(size(indentRootBulletPoint, failingBulletPoint, 5, 6))
}
}
}
@@ -347,7 +347,7 @@ abstract class IterableContainsInOrderOnlyGroupedValuesAssertionsSpec(
failAfterFail(1.0),
successSizeAfterFail(2)
)
containsRegex(size(indentBulletPoint, successfulBulletPoint, 4, 4))
containsRegex(size(indentRootBulletPoint, successfulBulletPoint, 4, 4))
}
}
}

8
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsInOrderOnlyValuesAssertionsSpec.kt
View File

@@ -32,15 +32,15 @@ abstract class IterableContainsInOrderOnlyValuesAssertionsSpec(
fun Expect<Iterable<Double?>>.containsInOrderOnlyNullableValuesFun(t: Double?, vararg tX: Double?) =
containsInOrderOnlyNullableValues(this, t, tX)
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
val indentFeatureBulletPoint = " ".repeat(featureBulletPoint.length)
val toBeWithFeature = "$indentFeatureArrow$featureBulletPoint$toBeDescr"
val toBeAfterSuccess = "$indentBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentBulletPoint$indentFailingBulletPoint$toBeWithFeature"
val toBeAfterSuccess = "$indentRootBulletPoint$indentSuccessfulBulletPoint$toBeWithFeature"
val toBeAfterFailing = "$indentRootBulletPoint$indentFailingBulletPoint$toBeWithFeature"
fun Expect<String>.elementSuccess(index: Int, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
@@ -61,7 +61,7 @@ abstract class IterableContainsInOrderOnlyValuesAssertionsSpec(
fun Expect<String>.elementNonExisting(index: Int, expected: Double): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${elementWithIndex(index)}: $sizeExceeded\\E.*$separator" +
"$indentBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$toBeDescr: $expected"
"$indentRootBulletPoint$indentFailingBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$toBeDescr: $expected"
)
}

24
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsNotEntriesAssertionsSpec.kt
View File

@@ -54,18 +54,18 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
//@formatter:off
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
//@formatter:on
nonNullableCases(
@@ -89,7 +89,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureSuccess$numberOfOccurrences: 0$separator" +
"$isAfterSuccess: 0.*$separator" +
@@ -123,7 +123,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$isLessThanDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -140,13 +140,13 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$toBeDescr: 1.0.*$separator" +
"$featureFailing$numberOfOccurrences: 1$separator" +
"$isAfterFailing: 0.*$separator" +
"$featureSuccess$hasElement: true$separator" +
"$isAfterSuccess: true$separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -186,7 +186,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -204,7 +204,7 @@ abstract class IterableContainsNotEntriesAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator" +
"$isAfterFailing: 0.*$separator" +

12
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableContainsNotValuesAssertionsSpec.kt
View File

@@ -36,20 +36,20 @@ abstract class IterableContainsNotValuesAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
//@formatter:off
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
//@formatter:on
val anElementWhichIsWithIndent = "$indentBulletPoint$listBulletPoint$anElementWhichIs"
val anElementWhichIsWithIndent = "$indentRootBulletPoint$listBulletPoint$anElementWhichIs"
nonNullableCases(
describePrefix,

18
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/IterableNoneAssertionsSpec.kt
View File

@@ -38,18 +38,18 @@ abstract class IterableNoneAssertionsSpec(
val containsNotDescr = DescriptionIterableAssertion.CONTAINS_NOT.getDefault()
val hasElement = DescriptionIterableAssertion.HAS_ELEMENT.getDefault()
val indentBulletPoint = " ".repeat(rootBulletPoint.length)
val indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
val indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
val indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
val indentListBulletPoint = " ".repeat(listBulletPoint.length)
val indentFeatureArrow = " ".repeat(featureArrow.length)
//@formatter:off
val featureSuccess = "$indentBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
val featureSuccess = "$indentRootBulletPoint$indentListBulletPoint\\Q$successfulBulletPoint$featureArrow\\E"
val featureFailing = "$indentRootBulletPoint$indentListBulletPoint\\Q$failingBulletPoint$featureArrow\\E"
val isAfterFailing = "$indentRootBulletPoint$indentListBulletPoint$indentFailingBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val isAfterSuccess = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow\\Q$featureBulletPoint\\E$isDescr"
val afterExplanatory = "$indentRootBulletPoint$indentListBulletPoint$indentSuccessfulBulletPoint\\Q$explanatoryBulletPoint\\E"
//@formatter:on
nonNullableCases(
@@ -85,7 +85,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$toBeDescr: 4.0.*$separator" +
"$featureFailing$numberOfOccurrences: 3$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -115,7 +115,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$isDescr: null$separator" +
"$featureFailing$numberOfOccurrences: 2$separator" +
"$isAfterFailing: 0.*$separator" +
@@ -133,7 +133,7 @@ abstract class IterableNoneAssertionsSpec(
message {
containsRegex(
"\\Q$rootBulletPoint\\E$containsNotDescr: $separator" +
"$indentBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$indentRootBulletPoint\\Q$listBulletPoint\\E$anElementWhich: $separator" +
"$afterExplanatory$toBeDescr: 1.0.*$separator" +
"$featureFailing$numberOfOccurrences: 1$separator" +
"$isAfterFailing: 0.*$separator" +

2
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/MapContainsInOrderOnlyKeyValueAssertionsSpec.kt
View File

@@ -91,7 +91,7 @@ abstract class MapContainsInOrderOnlyKeyValueAssertionsSpec(
val keyValueBulletPoint = if (explaining) explanatoryBulletPoint else featureBulletPoint
val indentKeyValueBulletPoint = " ".repeat(keyValueBulletPoint.length)
val indentToKeyValue =
"$indentBulletPoint$indent$indentFeatureArrow" + (if (explaining) indentFeatureBulletPoint else "")
"$indentRootBulletPoint$indent$indentFeatureArrow" + (if (explaining) indentFeatureBulletPoint else "")
return this.contains.exactly(1).regex(
"\\Q$successFailureBulletPoint$featureArrow${entry(index)}: $actual\\E.*$separator" +

2
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/MapContainsInOrderOnlyKeyValuePairsAssertionsSpec.kt
View File

@@ -58,7 +58,7 @@ abstract class MapContainsInOrderOnlyKeyValuePairsAssertionsSpec(
val keyValueBulletPoint = if (explaining) explanatoryBulletPoint else featureBulletPoint
val indentKeyValueBulletPoint = " ".repeat(keyValueBulletPoint.length)
val indentToKeyValue =
"$indentBulletPoint$indent$indentFeatureArrow" + (if (explaining) indentFeatureBulletPoint else "")
"$indentRootBulletPoint$indent$indentFeatureArrow" + (if (explaining) indentFeatureBulletPoint else "")
return this.contains.exactly(1).regex(
"\\Q$successFailureBulletPoint$featureArrow${entry(index)}: $actual\\E.*$separator" +

14
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/MapLikeContainsFormatSpecBase.kt
View File

@@ -29,7 +29,7 @@ abstract class MapLikeContainsFormatSpecBase(
Companion.featureArrow = featureArrow
Companion.featureBulletPoint = featureBulletPoint
indentBulletPoint = " ".repeat(rootBulletPoint.length)
indentRootBulletPoint = " ".repeat(rootBulletPoint.length)
indentSuccessfulBulletPoint = " ".repeat(successfulBulletPoint.length)
indentFailingBulletPoint = " ".repeat(failingBulletPoint.length)
indentListBulletPoint = " ".repeat(listBulletPoint.length)
@@ -49,7 +49,7 @@ abstract class MapLikeContainsFormatSpecBase(
var explanatoryBulletPoint = ""
var featureArrow = ""
var featureBulletPoint = ""
var indentBulletPoint = " "
var indentRootBulletPoint = " "
var indentSuccessfulBulletPoint = ""
var indentFailingBulletPoint = ""
var indentListBulletPoint = ""
@@ -84,29 +84,29 @@ abstract class MapLikeContainsFormatSpecBase(
fun Expect<String>.entrySuccess(key: String, actual: Any?, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"$indentBulletPoint\\Q$successfulBulletPoint$featureArrow${entry(key)}: $actual\\E.*${separator}" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
"$indentRootBulletPoint\\Q$successfulBulletPoint$featureArrow${entry(key)}: $actual\\E.*${separator}" +
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
)
}
fun Expect<String>.entryFailing(key: String?, actual: Any?, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${entry(key)}: $actual\\E.*${separator}" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$featureBulletPoint$expected"
)
}
fun Expect<String>.entryFailingExplaining(key: String?, actual: Any?, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${entry(key)}: $actual\\E.*${separator}" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$expected"
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$expected"
)
}
fun Expect<String>.entryNonExisting(key: String, expected: String): Expect<String> {
return this.contains.exactly(1).regex(
"\\Q$failingBulletPoint$featureArrow${entry(key)}: $keyDoesNotExist\\E.*${separator}" +
"$indentBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$expected"
"$indentRootBulletPoint$indentSuccessfulBulletPoint$indentFeatureArrow$indentFeatureBulletPoint$explanatoryBulletPoint$expected"
)
}

5
translations/de_CH/atrium-translations-de_CH-common/src/main/kotlin/ch/tutteli/atrium/translations/ErrorMessages.kt
View File

@@ -8,6 +8,11 @@ import ch.tutteli.atrium.reporting.translating.StringBasedTranslatable
*/
enum class ErrorMessages(override val value: String) : StringBasedTranslatable {
DESCRIPTION_BASED_ON_SUBJECT("Kann die Beschreibung NICHT anzeigen, da sie auf dem Subjekt der Behauptung beruht, welches nicht definiert ist"),
@Deprecated(
"Use DESCRIPTION_BASED_ON_SUBJECT; will be removed with 1.0.0",
ReplaceWith("DESCRIPTION_BASED_ON_SUBJECT")
)
DEDSCRIPTION_BASED_ON_SUBJECT("Kann die Beschreibung NICHT anzeigen, da sie auf dem Subjekt der Behauptung beruht, welches nicht definiert ist"),
REPRESENTATION_BASED_ON_SUBJECT_NOT_DEFINED("kann die Representation NICHT evaluieren, da sie auf dem Subjekt der Behauptung beruht, welches nicht definiert ist."),

5
translations/en_GB/atrium-translations-en_GB-common/src/main/kotlin/ch/tutteli/atrium/translations/ErrorMessages.kt
View File

@@ -9,6 +9,11 @@ import ch.tutteli.atrium.reporting.translating.StringBasedTranslatable
enum class ErrorMessages(override val value: String) : StringBasedTranslatable {
DESCRIPTION_BASED_ON_SUBJECT("CANNOT show description as it is based on subject which is not defined"),
@Deprecated(
"Use DESCRIPTION_BASED_ON_SUBJECT; will be removed with 1.0.0",
ReplaceWith("DESCRIPTION_BASED_ON_SUBJECT")
)
DEDSCRIPTION_BASED_ON_SUBJECT("CANNOT show description as it is based on subject which is not defined"),
REPRESENTATION_BASED_ON_SUBJECT_NOT_DEFINED("CANNOT evaluate representation as it is based on subject which is not defined."),