common-ext/io.github.caijiang.common.test.assertion/FakeJsonArrayAssert

FakeJsonArrayAssert

class FakeJsonArrayAssert<AT : AbstractJsonNodeAssert<AT>>(actual: MutableList<JsonNode>?, assertType: Class<*>) : AbstractListAssert<FakeJsonArrayAssert<AT>, MutableList<JsonNode>, JsonNode, AT>

Parameters

元素断言的类型

Constructors

FakeJsonArrayAssert

constructor(actual: MutableList<JsonNode>?, assertType: Class<*>)

Properties

info

val info: WritableAssertionInfo

Functions

allMatch

open override fun allMatch(p0: Predicate<in JsonNode>): FakeJsonArrayAssert<AT>

open override fun allMatch(p0: Predicate<in JsonNode>, p1: String): FakeJsonArrayAssert<AT>

allSatisfy

open override fun allSatisfy(p0: Consumer<in JsonNode>): FakeJsonArrayAssert<AT>

anyMatch

open override fun anyMatch(p0: Predicate<in JsonNode>): FakeJsonArrayAssert<AT>

anySatisfy

open override fun anySatisfy(p0: Consumer<in JsonNode>): FakeJsonArrayAssert<AT>

are

open override fun are(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

areAtLeast

open override fun areAtLeast(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

areAtLeastOne

open override fun areAtLeastOne(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

areAtMost

open override fun areAtMost(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

areExactly

open override fun areExactly(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

areNot

open override fun areNot(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

open override fun as(p0: Description): FakeJsonArrayAssert<AT>

open override fun as(p0: String, vararg p1: Any): FakeJsonArrayAssert<AT>

asList

open override fun asList(): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

asString

open override fun asString(): AbstractStringAssert<*>

contains

open override fun contains(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun contains(p0: JsonNode, p1: Index): FakeJsonArrayAssert<AT>

containsAll

open override fun containsAll(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsAnyElementsOf

open override fun containsAnyElementsOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsAnyOf

open override fun containsAnyOf(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

containsExactly

open override fun containsExactly(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

containsExactlyElementsOf

open override fun containsExactlyElementsOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsExactlyInAnyOrder

open override fun containsExactlyInAnyOrder(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

containsExactlyInAnyOrderElementsOf

open override fun containsExactlyInAnyOrderElementsOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsNull

open override fun containsNull(): FakeJsonArrayAssert<AT>

containsOnly

open override fun containsOnly(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

containsOnlyElementsOf

open override fun containsOnlyElementsOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsOnlyNulls

open override fun containsOnlyNulls(): FakeJsonArrayAssert<AT>

containsOnlyOnce

open override fun containsOnlyOnce(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

containsSequence

open override fun containsSequence(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun containsSequence(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

containsSubsequence

open override fun containsSubsequence(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun containsSubsequence(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

describedAs

open override fun describedAs(p0: Description): FakeJsonArrayAssert<AT>

open override fun describedAs(p0: String, vararg p1: Any): FakeJsonArrayAssert<AT>

descriptionText

open fun descriptionText(): String

doesNotContain

open override fun doesNotContain(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun doesNotContain(p0: JsonNode, p1: Index): FakeJsonArrayAssert<AT>

doesNotContainAnyElementsOf

open override fun doesNotContainAnyElementsOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

doesNotContainNull

open override fun doesNotContainNull(): FakeJsonArrayAssert<AT>

doesNotContainSequence

open override fun doesNotContainSequence(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun doesNotContainSequence(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

doesNotContainSubsequence

open override fun doesNotContainSubsequence(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun doesNotContainSubsequence(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

doesNotHave

open override fun doesNotHave(p0: Condition<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

doesNotHaveAnyElementsOfTypes

open override fun doesNotHaveAnyElementsOfTypes(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

doesNotHaveDuplicates

open override fun doesNotHaveDuplicates(): FakeJsonArrayAssert<AT>

doesNotHaveSameClassAs

open override fun doesNotHaveSameClassAs(p0: Any): FakeJsonArrayAssert<AT>

doNotHave

open override fun doNotHave(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

element

open fun element(p0: Int): AT

endsWith

open override fun endsWith(p0: Array<JsonNode>): FakeJsonArrayAssert<AT>

open override fun endsWith(p0: JsonNode, vararg p1: JsonNode): FakeJsonArrayAssert<AT>

equals

open operator override fun ~~equals~~(other: Any?): Boolean

extracting

open fun extracting(vararg p0: Function<JsonNode, *>): AbstractListAssert<*, MutableList<out Tuple>, Tuple, ObjectAssert<Tuple>>

open fun extracting(vararg p0: String): AbstractListAssert<*, MutableList<out Tuple>, Tuple, ObjectAssert<Tuple>>

open fun extracting(p0: String): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun <V : Any> extracting(p0: Extractor<in JsonNode, V>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

open fun <V : Any, EXCEPTION : Exception> extracting(p0: ThrowingExtractor<in JsonNode, V, EXCEPTION>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

open fun extracting(p0: String, p1: Class): AbstractListAssert<*, MutableList<out P>, P, ObjectAssert>

extractingResultOf

open fun extractingResultOf(p0: String): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun extractingResultOf(p0: String, p1: Class): AbstractListAssert<*, MutableList<out P>, P, ObjectAssert>

filteredOn

open fun filteredOn(p0: Predicate<in JsonNode>): FakeJsonArrayAssert<AT>

open fun filteredOn(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

open fun filteredOn(p0: String, p1: Any): FakeJsonArrayAssert<AT>

open fun filteredOn(p0: String, p1: FilterOperator<*>): FakeJsonArrayAssert<AT>

filteredOnAssertions

open fun filteredOnAssertions(p0: Consumer<in JsonNode>): FakeJsonArrayAssert<AT>

filteredOnNull

open fun filteredOnNull(p0: String): FakeJsonArrayAssert<AT>

first

open fun first(): AT

flatExtracting

open fun flatExtracting(vararg p0: String): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun flatExtracting(vararg p0: Extractor<in JsonNode, *>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun <EXCEPTION : Exception> flatExtracting(vararg p0: ThrowingExtractor<in JsonNode, *, EXCEPTION>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun flatExtracting(p0: String): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun <V : Any> flatExtracting(p0: Extractor<in JsonNode, out MutableCollection<V>>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

open fun <V : Any, EXCEPTION : Exception> flatExtracting(p0: ThrowingExtractor<in JsonNode, out MutableCollection<V>, EXCEPTION>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

getWritableAssertionInfo

open fun getWritableAssertionInfo(): WritableAssertionInfo

has

open override fun has(p0: Condition<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open fun has(p0: Condition<in JsonNode>, p1: Index): FakeJsonArrayAssert<AT>

hasAtLeastOneElementOfType

open override fun hasAtLeastOneElementOfType(p0: Class<*>): FakeJsonArrayAssert<AT>

hashCode

open override fun hashCode(): Int

hasOnlyElementsOfType

open override fun hasOnlyElementsOfType(p0: Class<*>): FakeJsonArrayAssert<AT>

hasOnlyElementsOfTypes

open override fun hasOnlyElementsOfTypes(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

hasOnlyOneElementSatisfying

open fun hasOnlyOneElementSatisfying(p0: Consumer<JsonNode>)

hasSameClassAs

open override fun hasSameClassAs(p0: Any): FakeJsonArrayAssert<AT>

hasSameElementsAs

open override fun hasSameElementsAs(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

hasSameHashCodeAs

open override fun hasSameHashCodeAs(p0: Any): FakeJsonArrayAssert<AT>

hasSameSizeAs

open override fun hasSameSizeAs(p0: Any): FakeJsonArrayAssert<AT>

open override fun hasSameSizeAs(p0: MutableIterable<*>): FakeJsonArrayAssert<AT>

hasSize

open override fun hasSize(p0: Int): FakeJsonArrayAssert<AT>

hasToString

open override fun hasToString(p0: String): FakeJsonArrayAssert<AT>

have

open override fun have(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

haveAtLeast

open override fun haveAtLeast(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

haveAtLeastOne

open override fun haveAtLeastOne(p0: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

haveAtMost

open override fun haveAtMost(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

haveExactly

open override fun haveExactly(p0: Int, p1: Condition<in JsonNode>): FakeJsonArrayAssert<AT>

inBinary

open override fun inBinary(): FakeJsonArrayAssert<AT>

inHexadecimal

open override fun inHexadecimal(): FakeJsonArrayAssert<AT>

open override fun is(p0: Condition<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open fun is(p0: Condition<in JsonNode>, p1: Index): FakeJsonArrayAssert<AT>

isEmpty

open override fun isEmpty()

isEqualTo

open override fun isEqualTo(p0: Any): FakeJsonArrayAssert<AT>

isExactlyInstanceOf

open override fun isExactlyInstanceOf(p0: Class<*>): FakeJsonArrayAssert<AT>

isIn

open override fun isIn(vararg p0: Any): FakeJsonArrayAssert<AT>

open override fun isIn(p0: MutableIterable<*>): FakeJsonArrayAssert<AT>

isInstanceOf

open override fun isInstanceOf(p0: Class<*>): FakeJsonArrayAssert<AT>

isInstanceOfAny

open override fun isInstanceOfAny(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

isInstanceOfSatisfying

open override fun <T : Any> isInstanceOfSatisfying(p0: Class<T>, p1: Consumer<T>): FakeJsonArrayAssert<AT>

isNot

open override fun isNot(p0: Condition<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

isNotEmpty

open override fun isNotEmpty(): FakeJsonArrayAssert<AT>

isNotEqualTo

open override fun isNotEqualTo(p0: Any): FakeJsonArrayAssert<AT>

isNotExactlyInstanceOf

open override fun isNotExactlyInstanceOf(p0: Class<*>): FakeJsonArrayAssert<AT>

isNotIn

open override fun isNotIn(vararg p0: Any): FakeJsonArrayAssert<AT>

open override fun isNotIn(p0: MutableIterable<*>): FakeJsonArrayAssert<AT>

isNotInstanceOf

open override fun isNotInstanceOf(p0: Class<*>): FakeJsonArrayAssert<AT>

isNotInstanceOfAny

open override fun isNotInstanceOfAny(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

isNotNull

open override fun isNotNull(): FakeJsonArrayAssert<AT>

isNotOfAnyClassIn

open override fun isNotOfAnyClassIn(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

isNotSameAs

open override fun isNotSameAs(p0: Any): FakeJsonArrayAssert<AT>

isNull

open override fun isNull()

isNullOrEmpty

open override fun isNullOrEmpty()

isOfAnyClassIn

open override fun isOfAnyClassIn(vararg p0: Class<*>): FakeJsonArrayAssert<AT>

isSameAs

open override fun isSameAs(p0: Any): FakeJsonArrayAssert<AT>

isSorted

open fun isSorted(): FakeJsonArrayAssert<AT>

isSortedAccordingTo

open fun isSortedAccordingTo(p0: Comparator<in JsonNode>): FakeJsonArrayAssert<AT>

isSubsetOf

open override fun isSubsetOf(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

open override fun isSubsetOf(p0: MutableIterable<JsonNode>): FakeJsonArrayAssert<AT>

last

open fun last(): AT

matches

open fun matches(p0: Predicate<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open fun matches(p0: Predicate<in MutableList<JsonNode>>, p1: String): FakeJsonArrayAssert<AT>

noneMatch

open override fun noneMatch(p0: Predicate<in JsonNode>): FakeJsonArrayAssert<AT>

noneSatisfy

open override fun noneSatisfy(p0: Consumer<in JsonNode>): FakeJsonArrayAssert<AT>

overridingErrorMessage

open override fun overridingErrorMessage(p0: String, vararg p1: Any): FakeJsonArrayAssert<AT>

satisfies

open fun satisfies(p0: Consumer<MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open override fun satisfies(p0: Condition<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open fun satisfies(p0: Consumer<in JsonNode>, p1: Index): FakeJsonArrayAssert<AT>

size

open fun size(): AbstractIterableSizeAssert<FakeJsonArrayAssert<AT>, MutableList<JsonNode>, JsonNode, AT>

startsWith

open override fun startsWith(vararg p0: JsonNode): FakeJsonArrayAssert<AT>

usingComparator

open override fun usingComparator(p0: Comparator<in MutableList<JsonNode>>): FakeJsonArrayAssert<AT>

open override fun usingComparator(p0: Comparator<in MutableList<JsonNode>>, p1: String): FakeJsonArrayAssert<AT>

usingComparatorForElementFieldsWithNames

open fun <T : Any> usingComparatorForElementFieldsWithNames(p0: Comparator<T>, vararg p1: String): FakeJsonArrayAssert<AT>

usingComparatorForElementFieldsWithType

open fun <T : Any> usingComparatorForElementFieldsWithType(p0: Comparator<T>, p1: Class<T>): FakeJsonArrayAssert<AT>

usingComparatorForType

open fun <T : Any> usingComparatorForType(p0: Comparator<T>, p1: Class<T>): FakeJsonArrayAssert<AT>

usingDefaultComparator

open override fun usingDefaultComparator(): FakeJsonArrayAssert<AT>

usingDefaultElementComparator

open override fun usingDefaultElementComparator(): FakeJsonArrayAssert<AT>

usingElementComparator

open override fun usingElementComparator(p0: Comparator<in JsonNode>): FakeJsonArrayAssert<AT>

usingElementComparatorIgnoringFields

open fun usingElementComparatorIgnoringFields(vararg p0: String): FakeJsonArrayAssert<AT>

usingElementComparatorOnFields

open fun usingElementComparatorOnFields(vararg p0: String): FakeJsonArrayAssert<AT>

usingFieldByFieldElementComparator

open fun usingFieldByFieldElementComparator(): FakeJsonArrayAssert<AT>

usingRecursiveFieldByFieldElementComparator

open fun usingRecursiveFieldByFieldElementComparator(): FakeJsonArrayAssert<AT>

withFailMessage

open override fun withFailMessage(p0: String, vararg p1: Any): FakeJsonArrayAssert<AT>

withRepresentation

open override fun withRepresentation(p0: Representation): FakeJsonArrayAssert<AT>

withThreadDumpOnError

open override fun withThreadDumpOnError(): FakeJsonArrayAssert<AT>

zipSatisfy

open fun <OTHER_ELEMENT : Any> zipSatisfy(p0: MutableIterable<OTHER_ELEMENT>, p1: BiConsumer<in JsonNode, OTHER_ELEMENT>): FakeJsonArrayAssert<AT>