detekt-test/io.gitlab.arturbosch.detekt.test/FindingsAssert

FindingsAssert

class FindingsAssert(actual: List<Finding>) : AbstractListAssert<FindingsAssert, List<Finding>, Finding, FindingAssert>

Constructors

FindingsAssert

constructor(actual: List<Finding>)

Properties

info

var info: WritableAssertionInfo

Functions

actual

open fun actual(): List<Finding>

allMatch

open override fun allMatch(predicate: Predicate<in Finding>): FindingsAssert

open override fun allMatch(predicate: Predicate<in Finding>, predicateDescription: String): FindingsAssert

allSatisfy

open override fun allSatisfy(requirements: Consumer<in Finding>): FindingsAssert

open override fun allSatisfy(requirements: ThrowingConsumer<in Finding>): FindingsAssert

anyMatch

open override fun anyMatch(predicate: Predicate<in Finding>): FindingsAssert

open override fun anyMatch(predicate: Predicate<in Finding>, predicateDescription: String): FindingsAssert

anySatisfy

open override fun anySatisfy(requirements: Consumer<in Finding>): FindingsAssert

open override fun anySatisfy(requirements: ThrowingConsumer<in Finding>): FindingsAssert

are

open override fun are(condition: Condition<in Finding>): FindingsAssert

areAtLeast

open override fun areAtLeast(times: Int, condition: Condition<in Finding>): FindingsAssert

areAtLeastOne

open override fun areAtLeastOne(condition: Condition<in Finding>): FindingsAssert

areAtMost

open override fun areAtMost(times: Int, condition: Condition<in Finding>): FindingsAssert

areExactly

open override fun areExactly(times: Int, condition: Condition<in Finding>): FindingsAssert

areNot

open override fun areNot(condition: Condition<in Finding>): FindingsAssert

open override fun as(description: Description): FindingsAssert

open override fun as(description: String, vararg args: Any): FindingsAssert

open fun as(descriptionSupplier: Supplier<String>): FindingsAssert

asInstanceOf

open override fun <ASSERT : AbstractAssert<*, *>> asInstanceOf(instanceOfAssertFactory: InstanceOfAssertFactory<*, ASSERT>): ASSERT

asList

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

asString

open override fun asString(): AbstractStringAssert<*>

contains

@SafeVarargs

override fun contains(vararg values: Finding): FindingsAssert

open override fun contains(value: Finding, index: Index): FindingsAssert

containsAll

open override fun containsAll(iterable: MutableIterable<Finding>): FindingsAssert

containsAnyElementsOf

open override fun containsAnyElementsOf(iterable: MutableIterable<Finding>): FindingsAssert

containsAnyOf

@SafeVarargs

override fun containsAnyOf(vararg values: Finding): FindingsAssert

containsExactly

@SafeVarargs

override fun containsExactly(vararg values: Finding): FindingsAssert

containsExactlyElementsOf

open override fun containsExactlyElementsOf(iterable: MutableIterable<Finding>): FindingsAssert

containsExactlyInAnyOrder

@SafeVarargs

override fun containsExactlyInAnyOrder(vararg values: Finding): FindingsAssert

containsExactlyInAnyOrderElementsOf

open override fun containsExactlyInAnyOrderElementsOf(values: MutableIterable<Finding>): FindingsAssert

containsNull

open override fun containsNull(): FindingsAssert

containsOnly

@SafeVarargs

override fun containsOnly(vararg values: Finding): FindingsAssert

containsOnlyElementsOf

open override fun ~~containsOnlyElementsOf~~(iterable: MutableIterable<Finding>): FindingsAssert

containsOnlyNulls

open override fun containsOnlyNulls(): FindingsAssert

containsOnlyOnce

@SafeVarargs

override fun containsOnlyOnce(vararg values: Finding): FindingsAssert

containsOnlyOnceElementsOf

open override fun containsOnlyOnceElementsOf(iterable: MutableIterable<Finding>): FindingsAssert

containsSequence

@SafeVarargs

override fun containsSequence(vararg sequence: Finding): FindingsAssert

open override fun containsSequence(sequence: MutableIterable<Finding>): FindingsAssert

containsSubsequence

@SafeVarargs

override fun containsSubsequence(vararg subsequence: Finding): FindingsAssert

open override fun containsSubsequence(subsequence: MutableIterable<Finding>): FindingsAssert

describedAs

open override fun describedAs(description: Description): FindingsAssert

open override fun describedAs(description: String, vararg args: Any): FindingsAssert

open fun describedAs(descriptionSupplier: Supplier<String>): FindingsAssert

descriptionText

open fun descriptionText(): String

doesNotContain

@SafeVarargs

override fun doesNotContain(vararg values: Finding): FindingsAssert

open override fun doesNotContain(value: Finding, index: Index): FindingsAssert

doesNotContainAnyElementsOf

open override fun doesNotContainAnyElementsOf(iterable: MutableIterable<Finding>): FindingsAssert

doesNotContainNull

open override fun doesNotContainNull(): FindingsAssert

doesNotContainSequence

@SafeVarargs

override fun doesNotContainSequence(vararg sequence: Finding): FindingsAssert

open override fun doesNotContainSequence(sequence: MutableIterable<Finding>): FindingsAssert

doesNotContainSubsequence

@SafeVarargs

override fun doesNotContainSubsequence(vararg subsequence: Finding): FindingsAssert

open override fun doesNotContainSubsequence(subsequence: MutableIterable<Finding>): FindingsAssert

doesNotHave

open override fun doesNotHave(condition: Condition<in List<Finding>>): FindingsAssert

doesNotHaveAnyElementsOfTypes

open override fun doesNotHaveAnyElementsOfTypes(vararg unexpectedTypes: Class<*>): FindingsAssert

doesNotHaveDuplicates

open override fun doesNotHaveDuplicates(): FindingsAssert

doesNotHaveSameClassAs

open override fun doesNotHaveSameClassAs(other: Any): FindingsAssert

doesNotHaveSameHashCodeAs

open override fun doesNotHaveSameHashCodeAs(other: Any): FindingsAssert

doesNotHaveToString

open override fun doesNotHaveToString(otherToString: String): FindingsAssert

open override fun doesNotHaveToString(expectedStringTemplate: String, vararg args: Any): FindingsAssert

doesNotMatch

open fun doesNotMatch(predicate: Predicate<in List<Finding>>): FindingsAssert

open fun doesNotMatch(predicate: Predicate<in List<Finding>>, predicateDescription: String): FindingsAssert

doNotHave

open override fun doNotHave(condition: Condition<in Finding>): FindingsAssert

element

open fun element(index: Int): FindingAssert

open fun <ASSERT : AbstractAssert<*, *>> element(index: Int, assertFactory: InstanceOfAssertFactory<*, ASSERT>): ASSERT

elements

open fun elements(vararg indices: Int): FindingsAssert

endsWith

open override fun endsWith(sequence: Array<Finding>): FindingsAssert

@SafeVarargs

override fun endsWith(first: Finding, vararg rest: Finding): FindingsAssert

equals

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

extracting

open fun <V : Any> extracting(extractor: Function<in Finding, V>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

@SafeVarargs

fun extracting(vararg extractors: Function<in Finding, *>): AbstractListAssert<*, MutableList<out Tuple>, Tuple, ObjectAssert<Tuple>>

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

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

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

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

extractingResultOf

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

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

filteredOn

open fun filteredOn(predicate: Predicate<in Finding>): FindingsAssert

open fun filteredOn(condition: Condition<in Finding>): FindingsAssert

open fun <T : Any> filteredOn(function: Function<in Finding, T>, expectedValue: T): FindingsAssert

open fun filteredOn(propertyOrFieldName: String, expectedValue: Any): FindingsAssert

open fun filteredOn(propertyOrFieldName: String, filterOperator: FilterOperator<*>): FindingsAssert

filteredOnAssertions

open fun filteredOnAssertions(elementAssertions: Consumer<in Finding>): FindingsAssert

open fun filteredOnAssertions(elementAssertions: ThrowingConsumer<in Finding>): FindingsAssert

filteredOnNull

open fun filteredOnNull(propertyOrFieldName: String): FindingsAssert

first

open fun first(): FindingAssert

open fun <ASSERT : AbstractAssert<*, *>> first(assertFactory: InstanceOfAssertFactory<*, ASSERT>): ASSERT

flatExtracting

open fun <V : Any> flatExtracting(extractor: Function<in Finding, out MutableCollection<V>>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

@SafeVarargs

fun flatExtracting(vararg extractors: Function<in Finding, *>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

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

@SafeVarargs

fun <EXCEPTION : Exception> flatExtracting(vararg extractors: ThrowingExtractor<in Finding, *, EXCEPTION>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

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

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

flatMap

open fun <V : Any> flatMap(mapper: Function<in Finding, out MutableCollection<V>>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

@SafeVarargs

fun flatMap(vararg mappers: Function<in Finding, *>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

@SafeVarargs

fun <EXCEPTION : Exception> flatMap(vararg mappers: ThrowingExtractor<in Finding, *, EXCEPTION>): AbstractListAssert<*, MutableList<out Any>, Any, ObjectAssert<Any>>

open fun <V : Any, EXCEPTION : Exception> flatMap(mapper: ThrowingExtractor<in Finding, out MutableCollection<V>, EXCEPTION>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

getWritableAssertionInfo

open fun getWritableAssertionInfo(): WritableAssertionInfo

has

open override fun has(condition: Condition<in List<Finding>>): FindingsAssert

open fun has(condition: Condition<in Finding>, index: Index): FindingsAssert

hasAtLeastOneElementOfType

open override fun hasAtLeastOneElementOfType(expectedType: Class<*>): FindingsAssert

hasEndSourceLocation

fun hasEndSourceLocation(line: Int, column: Int): FindingsAssert

hasEndSourceLocations

fun hasEndSourceLocations(vararg expected: SourceLocation): FindingsAssert

hasExactlyElementsOfTypes

open override fun hasExactlyElementsOfTypes(vararg types: Class<*>): FindingsAssert

hashCode

open override fun hashCode(): Int

hasOnlyElementsOfType

open override fun hasOnlyElementsOfType(expectedType: Class<*>): FindingsAssert

hasOnlyElementsOfTypes

open override fun hasOnlyElementsOfTypes(vararg types: Class<*>): FindingsAssert

hasOnlyOneElementSatisfying

open override fun ~~hasOnlyOneElementSatisfying~~(elementAssertions: Consumer<in Finding>): FindingsAssert

hasSameClassAs

open override fun hasSameClassAs(other: Any): FindingsAssert

hasSameElementsAs

open override fun hasSameElementsAs(iterable: MutableIterable<Finding>): FindingsAssert

hasSameHashCodeAs

open override fun hasSameHashCodeAs(other: Any): FindingsAssert

hasSameSizeAs

open override fun hasSameSizeAs(other: Any): FindingsAssert

open override fun hasSameSizeAs(other: MutableIterable<*>): FindingsAssert

hasSize

open override fun hasSize(expected: Int): FindingsAssert

hasSizeBetween

open override fun hasSizeBetween(lowerBoundary: Int, higherBoundary: Int): FindingsAssert

hasSizeGreaterThan

open override fun hasSizeGreaterThan(boundary: Int): FindingsAssert

hasSizeGreaterThanOrEqualTo

open override fun hasSizeGreaterThanOrEqualTo(boundary: Int): FindingsAssert

hasSizeLessThan

open override fun hasSizeLessThan(boundary: Int): FindingsAssert

hasSizeLessThanOrEqualTo

open override fun hasSizeLessThanOrEqualTo(boundary: Int): FindingsAssert

hasStartSourceLocation

fun hasStartSourceLocation(line: Int, column: Int): FindingsAssert

hasStartSourceLocations

fun hasStartSourceLocations(vararg expected: SourceLocation): FindingsAssert

hasTextLocations

fun hasTextLocations(vararg expected: Pair<Int, Int>): FindingsAssert

fun hasTextLocations(vararg expected: String): FindingsAssert

hasToString

open override fun hasToString(expectedStringTemplate: String, vararg args: Any): FindingsAssert

open override fun hasToString(expectedToString: String): FindingsAssert

have

open override fun have(condition: Condition<in Finding>): FindingsAssert

haveAtLeast

open override fun haveAtLeast(times: Int, condition: Condition<in Finding>): FindingsAssert

haveAtLeastOne

open override fun haveAtLeastOne(condition: Condition<in Finding>): FindingsAssert

haveAtMost

open override fun haveAtMost(times: Int, condition: Condition<in Finding>): FindingsAssert

haveExactly

open override fun haveExactly(times: Int, condition: Condition<in Finding>): FindingsAssert

inBinary

open override fun inBinary(): FindingsAssert

inHexadecimal

open override fun inHexadecimal(): FindingsAssert

open override fun is(condition: Condition<in List<Finding>>): FindingsAssert

open fun is(condition: Condition<in Finding>, index: Index): FindingsAssert

isEmpty

open override fun isEmpty()

isEqualTo

open override fun isEqualTo(expected: Any): FindingsAssert

isExactlyInstanceOf

open override fun isExactlyInstanceOf(type: Class<*>): FindingsAssert

isIn

open override fun isIn(vararg values: Any): FindingsAssert

open override fun isIn(values: MutableIterable<*>): FindingsAssert

isInstanceOf

open override fun isInstanceOf(type: Class<*>): FindingsAssert

isInstanceOfAny

open override fun isInstanceOfAny(vararg types: Class<*>): FindingsAssert

isInstanceOfSatisfying

open override fun <T : Any> isInstanceOfSatisfying(type: Class<T>, requirements: Consumer<T>): FindingsAssert

isNot

open override fun isNot(condition: Condition<in List<Finding>>): FindingsAssert

isNotEmpty

open override fun isNotEmpty(): FindingsAssert

isNotEqualTo

open override fun isNotEqualTo(other: Any): FindingsAssert

isNotExactlyInstanceOf

open override fun isNotExactlyInstanceOf(type: Class<*>): FindingsAssert

isNotIn

open override fun isNotIn(vararg values: Any): FindingsAssert

open override fun isNotIn(values: MutableIterable<*>): FindingsAssert

isNotInstanceOf

open override fun isNotInstanceOf(type: Class<*>): FindingsAssert

isNotInstanceOfAny

open override fun isNotInstanceOfAny(vararg types: Class<*>): FindingsAssert

isNotNull

open override fun isNotNull(): FindingsAssert

isNotOfAnyClassIn

open override fun isNotOfAnyClassIn(vararg types: Class<*>): FindingsAssert

isNotSameAs

open override fun isNotSameAs(other: Any): FindingsAssert

isNull

open override fun isNull()

isNullOrEmpty

open override fun isNullOrEmpty()

isOfAnyClassIn

open override fun isOfAnyClassIn(vararg types: Class<*>): FindingsAssert

isSameAs

open override fun isSameAs(expected: Any): FindingsAssert

isSorted

open fun isSorted(): FindingsAssert

isSortedAccordingTo

open fun isSortedAccordingTo(comparator: Comparator<in Finding>): FindingsAssert

isSubsetOf

@SafeVarargs

override fun isSubsetOf(vararg values: Finding): FindingsAssert

open override fun isSubsetOf(values: MutableIterable<Finding>): FindingsAssert

isUnmodifiable

open fun isUnmodifiable(): FindingsAssert

last

open fun last(): FindingAssert

open fun <ASSERT : AbstractAssert<*, *>> last(assertFactory: InstanceOfAssertFactory<*, ASSERT>): ASSERT

map

open fun <V : Any> map(mapper: Function<in Finding, V>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

@SafeVarargs

fun map(vararg mappers: Function<in Finding, *>): AbstractListAssert<*, MutableList<out Tuple>, Tuple, ObjectAssert<Tuple>>

open fun <V : Any, EXCEPTION : Exception> map(mapper: ThrowingExtractor<in Finding, V, EXCEPTION>): AbstractListAssert<*, MutableList<out V>, V, ObjectAssert<V>>

matches

open fun matches(predicate: Predicate<in List<Finding>>): FindingsAssert

open fun matches(predicate: Predicate<in List<Finding>>, predicateDescription: String): FindingsAssert

noneMatch

open override fun noneMatch(predicate: Predicate<in Finding>): FindingsAssert

open override fun noneMatch(predicate: Predicate<in Finding>, predicateDescription: String): FindingsAssert

noneSatisfy

open override fun noneSatisfy(restrictions: Consumer<in Finding>): FindingsAssert

open override fun noneSatisfy(restrictions: ThrowingConsumer<in Finding>): FindingsAssert

overridingErrorMessage

open fun overridingErrorMessage(supplier: Supplier<String>): FindingsAssert

open override fun overridingErrorMessage(newErrorMessage: String, vararg args: Any): FindingsAssert

satisfies

@SafeVarargs

fun satisfies(vararg requirements: Consumer<in List<Finding>>): FindingsAssert

@SafeVarargs

fun satisfies(vararg assertions: ThrowingConsumer<in List<Finding>>): FindingsAssert

open override fun satisfies(condition: Condition<in List<Finding>>): FindingsAssert

open fun satisfies(requirements: Consumer<in Finding>, index: Index): FindingsAssert

satisfiesAnyOf

@SafeVarargs

fun satisfiesAnyOf(vararg assertions: Consumer<in List<Finding>>): FindingsAssert

@SafeVarargs

fun satisfiesAnyOf(vararg assertions: ThrowingConsumer<in List<Finding>>): FindingsAssert

satisfiesExactly

@SafeVarargs

override fun satisfiesExactly(vararg requirements: Consumer<in Finding>): FindingsAssert

@SafeVarargs

override fun satisfiesExactly(vararg requirements: ThrowingConsumer<in Finding>): FindingsAssert

satisfiesExactlyInAnyOrder

@SafeVarargs

override fun satisfiesExactlyInAnyOrder(vararg requirements: Consumer<in Finding>): FindingsAssert

@SafeVarargs

override fun satisfiesExactlyInAnyOrder(vararg requirements: ThrowingConsumer<in Finding>): FindingsAssert

satisfiesOnlyOnce

open override fun satisfiesOnlyOnce(requirements: Consumer<in Finding>): FindingsAssert

open override fun satisfiesOnlyOnce(requirements: ThrowingConsumer<in Finding>): FindingsAssert

singleElement

open fun singleElement(): FindingAssert

open fun <ASSERT : AbstractAssert<*, *>> singleElement(assertFactory: InstanceOfAssertFactory<*, ASSERT>): ASSERT

size

open fun size(): AbstractIterableSizeAssert<FindingsAssert, List<Finding>, Finding, FindingAssert>

startsWith

@SafeVarargs

override fun startsWith(vararg sequence: Finding): FindingsAssert

usingComparator

open override fun usingComparator(customComparator: Comparator<in List<Finding>>): FindingsAssert

open override fun usingComparator(customComparator: Comparator<in List<Finding>>, customComparatorDescription: String): FindingsAssert

usingComparatorForElementFieldsWithNames

open fun <T : Any> ~~usingComparatorForElementFieldsWithNames~~(comparator: Comparator<T>, vararg elementPropertyOrFieldNames: String): FindingsAssert

usingComparatorForElementFieldsWithType

open fun <T : Any> ~~usingComparatorForElementFieldsWithType~~(comparator: Comparator<T>, type: Class<T>): FindingsAssert

usingComparatorForType

open fun <T : Any> usingComparatorForType(comparator: Comparator<T>, type: Class<T>): FindingsAssert

usingDefaultComparator

open override fun usingDefaultComparator(): FindingsAssert

usingDefaultElementComparator

open override fun usingDefaultElementComparator(): FindingsAssert

usingElementComparator

open override fun usingElementComparator(customComparator: Comparator<in Finding>): FindingsAssert

usingElementComparatorIgnoringFields

open fun ~~usingElementComparatorIgnoringFields~~(vararg fields: String): FindingsAssert

usingElementComparatorOnFields

open fun ~~usingElementComparatorOnFields~~(vararg fields: String): FindingsAssert

usingEquals

open override fun usingEquals(predicate: BiPredicate<in List<Finding>, in List<Finding>>): FindingsAssert

open override fun usingEquals(predicate: BiPredicate<in List<Finding>, in List<Finding>>, customEqualsDescription: String): FindingsAssert

usingFieldByFieldElementComparator

open fun ~~usingFieldByFieldElementComparator~~(): FindingsAssert

usingRecursiveAssertion

open override fun usingRecursiveAssertion(): RecursiveAssertionAssert

open override fun usingRecursiveAssertion(recursiveAssertionConfiguration: RecursiveAssertionConfiguration): RecursiveAssertionAssert

usingRecursiveComparison

open override fun usingRecursiveComparison(): RecursiveComparisonAssert<*>

open override fun usingRecursiveComparison(recursiveComparisonConfiguration: RecursiveComparisonConfiguration): RecursiveComparisonAssert<*>

usingRecursiveFieldByFieldElementComparator

open fun usingRecursiveFieldByFieldElementComparator(): FindingsAssert

open fun usingRecursiveFieldByFieldElementComparator(configuration: RecursiveComparisonConfiguration): FindingsAssert

usingRecursiveFieldByFieldElementComparatorIgnoringFields

open fun usingRecursiveFieldByFieldElementComparatorIgnoringFields(vararg fields: String): FindingsAssert

usingRecursiveFieldByFieldElementComparatorOnFields

open fun usingRecursiveFieldByFieldElementComparatorOnFields(vararg fields: String): FindingsAssert

withFailMessage

open fun withFailMessage(supplier: Supplier<String>): FindingsAssert

open override fun withFailMessage(newErrorMessage: String, vararg args: Any): FindingsAssert

withRepresentation

open override fun withRepresentation(representation: Representation): FindingsAssert

withThreadDumpOnError

open override fun withThreadDumpOnError(): FindingsAssert

zipSatisfy

open fun <OTHER_ELEMENT : Any> zipSatisfy(other: MutableIterable<OTHER_ELEMENT>, zipRequirements: BiConsumer<in Finding, OTHER_ELEMENT>): FindingsAssert