doc / ch.tutteli.atrium.api.fluent.en_GB / asList

asList

fun <E> Expect<out Array<out E>>.asList(): Expect<List<E>> (source)

Turns Expect<Array<E>> into Expect<List<E>>.

The transformation as such is not reflected in reporting. Use feature(Array<out E>::asList) if you want to show the transformation in reporting.

expect(arrayOf("A", "B"))
    .asList()  // subject is now of type List<String>
    .toBe(listOf("A", "B"))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>> (source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(Array<out E>::asList, assertionCreator) if you want to show the transformation in reporting.

expect(arrayOf("A", "B"))
    .asList { // subject within this block is of type List<String>
        toBe(listOf("A", "B"))
    } // subject here is back to type Array<String>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(arrayOf("A", "B"))
        .asList {
            contains("C")  // fails
            contains("D")  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(): Expect<List<Byte>> (source)

Turns Expect<CharArray> into Expect<List<Byte>>.

The transformation as such is not reflected in reporting. Use feature(ByteArray::asList) if you want to show the transformation in reporting.

expect(byteArrayOf(1, 2, 3))
    .asList() // subject is now of type List<Byte>
    .toBe(listOf<Byte>(1, 2, 3))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(ByteArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(byteArrayOf(1, 2, 3))
    .asList { // subject within this block is of type List<Byte>
        toBe(listOf<Byte>(1, 2, 3))
    } // subject here is back to type Array<Byte>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(byteArrayOf(1, 2, 3))
        .asList {
            contains(98)  // fails
            contains(99)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("charArrAsList") fun Expect<CharArray>.asList(): Expect<List<Char>> (source)

Turns Expect<CharArray> into Expect<List<Char>>.

The transformation as such is not reflected in reporting. Use feature(CharArray::asList) if you want to show the transformation in reporting.

expect(charArrayOf('A', 'B', 'C'))
    .asList() // subject is now of type List<Char>
    .toBe(listOf('A', 'B', 'C'))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("charArrAsList") fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(CharArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(charArrayOf('A', 'B', 'C'))
    .asList { // subject within this block is of type List<Char>
        toBe(listOf('A', 'B', 'C'))
    } // subject here is back to type Array<Char>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(charArrayOf('A', 'B', 'C'))
        .asList {
            contains('X')  // fails
            contains('Y')  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(): Expect<List<Short>> (source)

Turns Expect<ShortArray> into Expect<List<Short>>.

The transformation as such is not reflected in reporting. Use feature(ShortArray::asList) if you want to show the transformation in reporting.

expect(shortArrayOf(1, 2, 3))
    .asList() // subject is now of type List<Short>
    .toBe(listOf<Short>(1, 2, 3))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(ShortArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(shortArrayOf(1, 2, 3))
    .asList { // subject within this block is of type List<Short>
        toBe(listOf<Short>(1, 2, 3))
    } // subject here is back to type Array<Short>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(shortArrayOf(1, 2, 3))
        .asList {
            contains(98)  // fails
            contains(99)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("intArrAsList") fun Expect<IntArray>.asList(): Expect<List<Int>> (source)

Turns Expect<IntArray> into Expect<List<Int>>.

The transformation as such is not reflected in reporting. Use feature(IntArray::asList) if you want to show the transformation in reporting.

expect(intArrayOf(1, 2, 3))
    .asList() // subject is now of type List<Int>
    .toBe(listOf(1, 2, 3))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("intArrAsList") fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(IntArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(intArrayOf(1, 2, 3))
    .asList { // subject within this block is of type List<Int>
        toBe(listOf(1, 2, 3))
    } // subject here is back to type Array<Int>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(intArrayOf(1, 2, 3))
        .asList {
            contains(98)  // fails
            contains(99)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("longArrAsList") fun Expect<LongArray>.asList(): Expect<List<Long>> (source)

Turns Expect<LongArray> into Expect<List<Double>>.

The transformation as such is not reflected in reporting. Use feature(LongArray::asList) if you want to show the transformation in reporting.

expect(longArrayOf(1L, 2L, 3L)) // subject is now of type List<Long>
    .asList()
    .toBe(listOf(1L, 2L, 3L))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("longArrAsList") fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(LongArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(longArrayOf(1L, 2L, 3L))
    .asList { // subject within this block is of type List<Long>
        toBe(listOf(1L, 2L, 3L))
    } // subject here is back to type Array<Long>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(longArrayOf(1L, 2L, 3L))
        .asList {
            contains(98L)  // fails
            contains(99L)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(): Expect<List<Float>> (source)

Turns Expect<FloatArray> into Expect<List<Float>>.

The transformation as such is not reflected in reporting. Use feature(FloatArray::asList) if you want to show the transformation in reporting.

expect(floatArrayOf(1f, 2f, 3f))
    .asList() // subject is now of type List<Float>
    .toBe(listOf(1f, 2f, 3f))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(FloatArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(floatArrayOf(1f, 2f, 3f))
    .asList { // subject within this block is of type List<Float>
        toBe(listOf(1f, 2f, 3f))
    } // subject here is back to type Array<Float>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(floatArrayOf(1f, 2f, 3f))
        .asList {
            contains(98f)  // fails
            contains(99f)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(): Expect<List<Double>> (source)

Turns Expect<DoubleArray> into Expect<List<Double>>.

The transformation as such is not reflected in reporting. Use feature(DoubleArray::asList) if you want to show the transformation in reporting.

expect(doubleArrayOf(1.1, 2.2, 3.3))
    .asList() // subject is now of type List<Double>
    .toBe(listOf(1.1, 2.2, 3.3))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(DoubleArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(doubleArrayOf(1.1, 2.2, 3.3))
    .asList { // subject within this block is of type List<Double>
        toBe(listOf(1.1, 2.2, 3.3))
    } // subject here is back to type Array<Double>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(doubleArrayOf(1.1, 2.2, 3.3))
        .asList {
            contains(98.1)  // fails
            contains(99.2)  // still evaluated, use `.asList().` if you want a fail fast behaviour
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(): Expect<List<Boolean>> (source)

Turns Expect<BooleanArray> into Expect<List<Boolean>>.

The transformation as such is not reflected in reporting. Use feature(BooleanArray::asList) if you want to show the transformation in reporting.

expect(booleanArrayOf(true, false))
    .asList() // subject is now of type List<Boolean>
    .toBe(listOf(true, false))

Return
The newly created Expect for the transformed subject.

Since
0.9.0

@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>

(source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature(BooleanArray::asList, assertionCreator) if you want to show the transformation in reporting.

expect(booleanArrayOf(true, false))
    .asList { // subject within this block is of type List<Boolean>
        toBe(listOf(true, false))
    } // subject here is back to type Array<Boolean>

fails {
    // all assertions are evaluated inside an assertion group block; for more details:
    // https://github.com/robstoll/atrium#define-single-assertions-or-assertion-groups

    expect(booleanArrayOf(true, true))
        .asList {
            // fails
            contains(false)

            // still evaluated, use `.asList().` if you want a fail fast behaviour
            contains.inAnyOrder.atLeast(3).value(true)
        }
}

Return
The newly created Expect for the transformed subject.

Since
0.9.0

fun <E, T : Iterable<E>> Expect<T>.asList(): Expect<List<E>> (source)

Turns Expect<E, T : Iterable<E>> into Expect<List<E>.

The transformation as such is not reflected in reporting. Use feature { f(it::toList) } if you want to show the transformation in reporting.

Return
The newly created Expect for the transformed subject.

Since
0.14.0

fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T> (source)

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

The transformation as such is not reflected in reporting. Use feature of({ f(it::toList) }, assertionCreator) if you want to show the transformation in reporting.

Return
an Expect for the subject of this expectation.

Since
0.14.0