ch.tutteli.atrium.assertions

Package ch.tutteli.atrium.assertions

Contains different types of Assertion, e.g. DescriptiveAssertion. Currently it contains also @Deprecated impl-functions which will be removed with 1.0.0

Types

Assertion	`interface Assertion` The base interface of all assertions, providing the method holds.
AssertionGroup	`interface AssertionGroup : Assertion` The base interface for Assertion groups, providing a default implementation for Assertion.holds which returns `true` if all its assertions hold.
AssertionGroupType	`interface AssertionGroupType : BulletPointIdentifier` Represents a type of an AssertionGroup.
BasicAssertionGroup	`data class BasicAssertionGroup : AssertionGroup` A default implementation for AssertionGroup -- it has a certain type, a description, a representation and of course assertions.
BasicDescriptiveAssertion	`class BasicDescriptiveAssertion : DescriptiveAssertion` A default implementation for DescriptiveAssertion which lazily evaluates holds.
BasicExplanatoryAssertion	`class BasicExplanatoryAssertion : ExplanatoryAssertion` A default implementation for ExplanatoryAssertion -- an assertion which only wants to give an explanation.
BulletPointIdentifier	`interface BulletPointIdentifier` A marker interface for types which can be used to identify bullet points in CoreFactory.registerTextAssertionFormatterCapabilities.
DefaultExplanatoryAssertionGroupType	`object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions are used to explain something rather than pointing something out -- accordingly the AssertionGroup.holds should always return `true`.
DefaultFeatureAssertionGroupType	`object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType` The AssertionGroupType for AssertionGroups which contain any kind of feature assertions.
DefaultIndentAssertionGroupType	`object DefaultIndentAssertionGroupType : IndentAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions should be displayed with an extra indent.
DefaultListAssertionGroupType	`object DefaultListAssertionGroupType : ListAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions should be displayed in a list.
DefaultSummaryAssertionGroupType	`object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions should not be filtered (by a Reporter) and for which an AssertionFormatter should state whether they hold or not.
DescriptionAnyAssertion	`enum class DescriptionAnyAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Any.
DescriptionBasic	`enum class DescriptionBasic : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions which are so basic that one does not want to use a different wording in a two different assertion functions.
DescriptionBigDecimalAssertion	`enum class DescriptionBigDecimalAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to BigDecimal.
DescriptionCharSequenceAssertion	`enum class DescriptionCharSequenceAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to CharSequence.
DescriptionCollectionAssertion	`enum class DescriptionCollectionAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Collection.
DescriptionComparableAssertion	`enum class DescriptionComparableAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Comparable.
DescriptionFloatingPointAssertion	`enum class DescriptionFloatingPointAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Float, Double and BigDecimal.
DescriptionIterableAssertion	`enum class DescriptionIterableAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Iterable.
DescriptionThrowableAssertion	`enum class DescriptionThrowableAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which are applicable to Throwable.
DescriptionTypeTransformationAssertion	`enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable` Contains the DescriptiveAssertion.descriptions of the assertion functions which postulate that a AssertionPlant.subject of type `T` can be transformed (usually down-casting or unboxing) to `TSub`.
DescriptiveAssertion	`interface DescriptiveAssertion : Assertion` The base interface for Assertions which consist of a representation of an expected result with a complementary description.
DoNotFilterAssertionGroupType	`interface DoNotFilterAssertionGroupType : AssertionGroupType` An AssertionGroupType which indicates that a Reporter should not filter its AssertionGroup.assertions.
EmptyNameAndRepresentationAssertionGroup	`open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup` Represents a base class for AssertionGroups which have an empty description and representation.
ExplanatoryAssertion	`interface ExplanatoryAssertion : Assertion` Represents an Assertion which can be used to explain/show an instance which is eventually formatted by an ObjectFormatter in reporting -- it needs to be a child of an AssertionGroup with an ExplanatoryAssertionGroupType.
ExplanatoryAssertionGroup	`class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup` Represents an AssertionGroup with an ExplanatoryAssertionGroupType, which means a Reporter should not show whether the assertions hold or not.
ExplanatoryAssertionGroupType	`interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType` Represents the AssertionGroupType for AssertionGroups whose assertions are mainly used to explain something -- hence in the normal case it should not be of importance whether they hold or not and thus such AssertionGroups should usually return `true` for holds.
FeatureAssertionGroupType	`interface FeatureAssertionGroupType : AssertionGroupType` Represents the AssertionGroupType for AssertionGroups which contain some kind of feature assertions.
IndentAssertionGroup	`class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup` Represents an AssertionGroup with a DefaultIndentAssertionGroupType, which means the assertions shall be indented one extra level and description and representation shall be neglected (not reported to the output).
IndentAssertionGroupType	`interface IndentAssertionGroupType : AssertionGroupType` Represents the AssertionGroupType for AssertionGroups whose assertions should be displayed with an extra indent. Such a group might have a AssertionGroup.description and AssertionGroup.representation (by accident) but should not be mentioned in reporting.
InformationAssertionGroupType	`data class InformationAssertionGroupType : ExplanatoryAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions are used to document the reason for one or multiple assertions.
InvisibleAssertionGroup	`class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup` Represents an AssertionGroup with an InvisibleAssertionGroupType, which means the grouping should be invisible in reporting.
InvisibleAssertionGroupType	`object InvisibleAssertionGroupType : AssertionGroupType` Represents the AssertionGroupType for AssertionGroups whose assertions should be displayed in a manner that the user does not even notice that the Assertions have been grouped.
ListAssertionGroupType	`interface ListAssertionGroupType : AssertionGroupType` Represents the AssertionGroupType for AssertionGroups whose assertions should be displayed in a list (up to the Reporter if it is a list with bullets, squares etc.).
PrefixFailingSummaryAssertion	`class PrefixFailingSummaryAssertion : BulletPointIdentifier` Represents the identifier for bullet points used to prefix Assertions which do not hold, in context of an AssertionGroup with type SummaryAssertionGroupType.
PrefixFeatureAssertionGroupHeader	`class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier` This class is only used as identifier for CoreFactory.registerTextAssertionFormatterCapabilities.
PrefixSuccessfulSummaryAssertion	`class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier` Represents the identifier for bullet points used to prefix Assertions which hold, in context of an AssertionGroup with type SummaryAssertionGroupType.
RepresentationOnlyAssertion	`interface RepresentationOnlyAssertion : Assertion` The base interface for Assertions which only consist of a representation (next to holds).
RootAssertionGroupType	`object RootAssertionGroupType : AssertionGroupType` The AssertionGroupType for AssertionGroups which are the root of all assertions.
SummaryAssertionGroupType	`interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType` Represents the AssertionGroupType for AssertionGroups whose assertions should all be reported in reporting (no filtering by a Reporter) since it represents a summary which itself will point out which assertions hold and which do not.
WarningAssertionGroupType	`object WarningAssertionGroupType : ExplanatoryAssertionGroupType` The AssertionGroupType for AssertionGroups whose assertions are used to state a warning rather than making an assumption.

Functions

_containsBuilder	`fun <T : CharSequence> _containsBuilder(plant: AssertionPlant<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>`
_containsNotBuilder	`fun <T : CharSequence> _containsNotBuilder(plant: AssertionPlant<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>`
_downCast	`fun <T : Any, TSub : T> _downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit`
_endsNotWith	`fun <T : CharSequence> _endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion`
_endsWith	`fun <T : CharSequence> _endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion`
_hasSize	`fun <T : Collection<*>> _hasSize(plant: AssertionPlant<T>, size: Int): Assertion`
_isA	`fun <TSub : Any> _isA(plant: AssertionPlant<Any>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit`
_isEmpty	`fun <T : CharSequence> _isEmpty(plant: AssertionPlant<T>): Assertion`
_isEqualIncludingScale	`fun <T : BigDecimal> _isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion`
_isGreaterOrEquals	`fun <T : Comparable<T>> _isGreaterOrEquals(plant: AssertionPlant<T>, expected: T): Assertion`
_isGreaterThan	`fun <T : Comparable<T>> _isGreaterThan(plant: AssertionPlant<T>, expected: T): Assertion`
_isLessOrEquals	`fun <T : Comparable<T>> _isLessOrEquals(plant: AssertionPlant<T>, expected: T): Assertion`
_isLessThan	`fun <T : Comparable<T>> _isLessThan(plant: AssertionPlant<T>, expected: T): Assertion`
_isNotEmpty	`fun <T : CharSequence> _isNotEmpty(plant: AssertionPlant<T>): Assertion`
_isNotEqualIncludingScale	`fun <T : BigDecimal> _isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): Assertion`
_isNotNull	`fun <T : Any> _isNotNull(plant: AssertionPlantNullable<T?>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit`
_isNotNumericallyEqualTo	`fun <T : BigDecimal> _isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion`
_isNotSame	`fun <T : Any> _isNotSame(plant: AssertionPlant<T>, expected: T): Assertion`
_isNull	`fun <T> _isNull(plant: AssertionPlantNullable<T>): Assertion`
_isNumericallyEqualTo	`fun <T : BigDecimal> _isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion`
_isSame	`fun <T : Any> _isSame(plant: AssertionPlant<T>, expected: T): Assertion`
_method	`fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue): AssertionPlant<TReturnValue>` `fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1): AssertionPlant<TReturnValue>` `fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>`
_notToBe	`fun <T : Any> _notToBe(plant: AssertionPlant<T>, expected: T): Assertion`
_property	`fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>` `fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>`
_returnValueOf	`fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>` `fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>` `fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>` `fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>`
_startsNotWith	`fun <T : CharSequence> _startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion`
_startsWith	`fun <T : CharSequence> _startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion`
_toBe	`fun <T : Any> _toBe(plant: AssertionPlant<T>, expected: T): Assertion`
_toBeWithErrorTolerance	`fun _toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion` `fun _toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion` `fun <T : BigDecimal> _toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion`
_toThrow	`fun <TExpected : Throwable> _toThrow(throwableThrownBuilder: ThrowableThrownBuilder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit`
_typeTransformation	`fun <T : Any, TSub : Any> _typeTransformation(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit`