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

FindingAssert

class FindingAssert(val actual: Finding?) : AbstractAssert<FindingAssert, Finding>

Constructors

FindingAssert

constructor(actual: Finding?)

Properties

actual

val actual: Finding?

info

var info: WritableAssertionInfo

Functions

actual

open fun actual(): Finding

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

open fun as(description: Description): FindingAssert

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

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<*>

describedAs

open override fun describedAs(description: Description): FindingAssert

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

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

descriptionText

open fun descriptionText(): String

doesNotHave

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

doesNotHaveSameClassAs

open override fun doesNotHaveSameClassAs(other: Any): FindingAssert

doesNotHaveSameHashCodeAs

open override fun doesNotHaveSameHashCodeAs(other: Any): FindingAssert

doesNotHaveToString

open override fun doesNotHaveToString(otherToString: String): FindingAssert

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

doesNotMatch

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

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

equals

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

getWritableAssertionInfo

open fun getWritableAssertionInfo(): WritableAssertionInfo

has

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

hashCode

open override fun hashCode(): Int

hasMessage

fun hasMessage(expectedMessage: String): FindingAssert

hasSameClassAs

open override fun hasSameClassAs(other: Any): FindingAssert

hasSameHashCodeAs

open override fun hasSameHashCodeAs(other: Any): FindingAssert

hasSourceLocation

fun hasSourceLocation(line: Int, column: Int): FindingAssert

hasToString

open override fun hasToString(expectedToString: String): FindingAssert

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

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

isEqualTo

open override fun isEqualTo(expected: Any): FindingAssert

isExactlyInstanceOf

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

isIn

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

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

isInstanceOf

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

isInstanceOfAny

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

isInstanceOfSatisfying

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

isNot

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

isNotEqualTo

open override fun isNotEqualTo(other: Any): FindingAssert

isNotExactlyInstanceOf

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

isNotIn

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

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

isNotInstanceOf

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

isNotInstanceOfAny

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

isNotNull

open override fun isNotNull(): FindingAssert

isNotOfAnyClassIn

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

isNotSameAs

open override fun isNotSameAs(other: Any): FindingAssert

isNull

open override fun isNull()

isOfAnyClassIn

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

isSameAs

open override fun isSameAs(expected: Any): FindingAssert

matches

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

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

overridingErrorMessage

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

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

satisfies

@SafeVarargs

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

@SafeVarargs

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

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

satisfiesAnyOf

@SafeVarargs

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

@SafeVarargs

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

usingComparator

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

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

usingDefaultComparator

open override fun usingDefaultComparator(): FindingAssert

usingEquals

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

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

withFailMessage

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

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

withRepresentation

open override fun withRepresentation(representation: Representation): FindingAssert

withThreadDumpOnError

open override fun withThreadDumpOnError(): FindingAssert