Uses of Interface
org.assertj.core.error.ErrorMessageFactory
-
Packages that use ErrorMessageFactory Package Description org.assertj.core.api org.assertj.core.error org.assertj.core.error.future org.assertj.core.error.uri org.assertj.core.internal -
-
Uses of ErrorMessageFactory in org.assertj.core.api
Methods in org.assertj.core.api with parameters of type ErrorMessageFactory Modifier and Type Method Description protected void
AbstractAssert. throwAssertionError(ErrorMessageFactory errorMessageFactory)
Utility method to throw anAssertionError
given aBasicErrorMessageFactory
. -
Uses of ErrorMessageFactory in org.assertj.core.error
Classes in org.assertj.core.error that implement ErrorMessageFactory Modifier and Type Class Description class
AbstractShouldHaveTextContent
Base class for text content error.class
AnyElementShouldMatch
class
BasicErrorMessageFactory
A factory of error messages typically shown when an assertion fails.class
ClassModifierShouldBe
Creates an error message indicating that an assertion that verifies that a class is (or is not) final.class
ConditionAndGroupGenericParameterTypeShouldBeTheSame
Creates an error message indicating that an assertion that verifies type of elements of group andCondition
A group of elements can be a collection, an array.class
ElementsShouldBe
Creates an error message indicating that an assertion that verifies that each element of a group satisfies aCondition
A group of elements can be a collection, an array.class
ElementsShouldBeAtLeast
Creates an error message indicating that an assertion that verifies elements of a group satisfies at least n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldBeAtMost
Creates an error message indicating that an assertion that verifies elements of a group satisfies at most n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldBeExactly
Creates an error message indicating that an assertion that verifies elements of a group satisfies exactly n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldHave
Creates an error message indicating that an assertion that verifies that each element of a group satisfies aCondition
A group of elements can be a collection, an array.class
ElementsShouldHaveAtLeast
Creates an error message indicating that an assertion that verifies elements of a group satisfies at least n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldHaveAtMost
Creates an error message indicating that an assertion that verifies elements of a group satisfies at most n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldHaveExactly
Creates an error message indicating that an assertion that verifies elements of a group satisfies exactly n times aCondition
A group of elements can be a collection, an array.class
ElementsShouldMatch
class
ElementsShouldNotBe
Creates an error message indicating that an assertion that not verifies that each element of a group satisfies aCondition
A group of elements can be a collection, an array.class
ElementsShouldNotHave
Creates an error message indicating that an assertion that verifies that each element of a group satisfies aCondition
A group of elements can be a collection, an array.class
ElementsShouldSatisfy
class
NoElementsShouldMatch
class
NoElementsShouldSatisfy
class
OptionalDoubleShouldHaveValueCloseToOffset
Build error message when anOptionalDouble
should have a specific value close to an offset.class
OptionalDoubleShouldHaveValueCloseToPercentage
Build error message when anOptionalDouble
should be close to an expected value within a positive percentage.class
OptionalShouldBeEmpty
Build error message when anOptional
should be empty.class
OptionalShouldBePresent
Build error message when a value should be present in anOptional
.class
OptionalShouldContain
Build error message when anOptional
,OptionalDouble
,OptionalInt
orOptionalLong
should contain a specific value.class
OptionalShouldContainInstanceOf
Build an error message when a value should be instance of a specific class.class
ShouldAccept
Creates an error message indicating that an assertion that verifies that
accepts a value failed.Predicate
class
ShouldBe
Creates an error message indicating that an assertion that verifies that a value satisfies a
failed.Condition
class
ShouldBeAbsolutePath
class
ShouldBeAbstract
class
ShouldBeAfter
Creates an error message indicating that an assertion that verifies that aDate
is after another one failed.class
ShouldBeAfterOrEqualTo
Creates an error message indicating that an assertion that verifies that anObject
is after or equal to another one failed.class
ShouldBeAfterYear
Creates an error message indicating that an assertion that verifies that aDate
is after given year failed.class
ShouldBeAnArray
Creates an error message indicating that a group of elements should have been an array.class
ShouldBeAnnotation
Creates an error message indicating that an assertion that verifies that a class is (or not) an annotation.class
ShouldBeAssignableFrom
Creates an error message indicating that an assertion that verifies that a class is assignable from.class
ShouldBeAtIndex
Creates an error message indicating that an assertion that verifies a group of elements contains a value at a given index that satisfies a
failed.Condition
class
ShouldBeAtSameInstant
Creates an error message indicating that an assertion that verifies that twoOffsetDateTimes
have the sameInstant
, failed.class
ShouldBeBefore
Creates an error message indicating that an assertion that verifies that aObject
is before another one failed.class
ShouldBeBeforeOrEqualTo
Creates an error message indicating that an assertion that verifies that anObject
is before or equal to another one failed.class
ShouldBeBeforeYear
Creates an error message indicating that an assertion that verifies that aDate
is before given year failed.class
ShouldBeBetween
Creates an error message indicating that an assertion that verifies that aDate
is between start - end dates (inclusive or not) failed.class
ShouldBeBlank
Creates an error message indicating that an assertion that verifies aCharSequence
is blank.class
ShouldBeCanonicalPath
Creates an error message indicating that an assertion that verifies that aPath
is canonical has failed.class
ShouldBeCloseTo
Creates an error message indicating that an assertion that verifies that aDate
is close to another one from some delta failed.class
ShouldBeDirectory
class
ShouldBeEmpty
Creates an error message indicating that an assertion that verifies a group of elements is empty failed.class
ShouldBeEmptyDirectory
class
ShouldBeEqualByComparingFieldByFieldRecursively
class
ShouldBeEqualByComparingOnlyGivenFields
Creates an
indicating that an assertion that verifies that two objects are lenient equal by accepting fields failed.AssertionError
class
ShouldBeEqualIgnoringCase
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are equal, ignoring case considerations, failed.class
ShouldBeEqualIgnoringHours
Creates an error message indicating that an assertion that verifies that twoZonedDateTime
have same year, month, and day fields failed.class
ShouldBeEqualIgnoringMinutes
Creates an error message indicating that an assertion that verifies that twoZonedDateTime
have same year, month, day and hour fields failed.class
ShouldBeEqualIgnoringNanos
Creates an error message indicating that an assertion that verifies that : twoZonedDateTime
,LocalDateTime
have same year, month, day, hour, minute and second failed. twoLocalTime
have same hour, minute and second failed. twoOffsetTime
have same hour, minute and second failed.class
ShouldBeEqualIgnoringNewLineDifferences
class
ShouldBeEqualIgnoringNewLines
class
ShouldBeEqualIgnoringSeconds
Creates an error message indicating that an assertion that verifies that twoZonedDateTime
have same year, month, day, hour and minute failed.class
ShouldBeEqualIgnoringTimezone
Creates an error message indicating that an assertion that verifies that twoOffsetTime
have same time fields except the timezone.class
ShouldBeEqualIgnoringWhitespace
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are equal, ignoring whitespace differences, failed.class
ShouldBeEqualNormalizingWhitespace
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are equal, after the whitespace of both strings has been normalized, failed.class
ShouldBeEqualToIgnoringFields
Creates an
indicating that an assertion that verifies that two objects are lenient equal by ignoring fields failed.AssertionError
class
ShouldBeEqualWithinOffset
Creates an error message indicating that an assertion that verifies that two numbers are equal within a positive offset failed.class
ShouldBeEqualWithinPercentage
Creates an error message indicating that an assertion that verifies that two numbers are equal within a positive percentage failed.class
ShouldBeEqualWithTimePrecision
Creates an
indicating that an assertion that verifies that two dates are equals up to a given precision failed.AssertionError
class
ShouldBeExactlyInstanceOf
Creates an error message indicating that an assertion that verifies that an object is exactly an instance of some type failed.class
ShouldBeExecutable
Creates an error message indicating that an assertion that verifies that a
is executable failed.File
class
ShouldBeExhausted
Creates an error message indicating that an assertion that verifies that anIterator
has no more elements failed.class
ShouldBeFile
Creates an error message indicating that an assertion that verifies that a
is an existing file failed.File
class
ShouldBeGreater
Creates an error message indicating that an assertion that verifies that a value is greater than another one failed.class
ShouldBeGreaterOrEqual
Creates an error message indicating that an assertion that verifies that a value is greater than or equal to another one failed.class
ShouldBeIn
Creates an error message indicating that an assertion that verifies that a value is in a group of values (e.g.class
ShouldBeInSameDay
Creates an error message indicating that an assertion that verifies that aDate
is in same year, month and day of month as another one failed.class
ShouldBeInSameHour
Creates an error message indicating that an assertion that verifies that aDate
is in same year, month, day of month and hour as another one failed.class
ShouldBeInSameHourWindow
Creates an error message indicating that an assertion that verifies that aDate
is in same hour window as another one failed.class
ShouldBeInSameMinute
Creates an error message indicating that an assertion that verifies that aDate
is in same year, month, day of month, hour and minute as another one failed.class
ShouldBeInSameMinuteWindow
Creates an error message indicating that an assertion that verifies that aDate
is in minute window as another one failed.class
ShouldBeInSameMonth
Creates an error message indicating that an assertion that verifies that aDate
is in same year and month as another one failed.class
ShouldBeInSameSecond
Creates an error message indicating that an assertion that verifies that aDate
is in same year, month, day of month, hour, minute and second as another one failed.class
ShouldBeInSameSecondWindow
Creates an error message indicating that an assertion that verifies that aDate
is in second window as another one failed.class
ShouldBeInSameYear
Creates an error message indicating that an assertion that verifies that aDate
is in same year as another one failed.class
ShouldBeInstance
Creates an error message indicating that an assertion that verifies that an object is an instance of some type failed.class
ShouldBeInstanceOfAny
Creates an error message indicating that an assertion that verifies that an object is an instance of one or more types failed.class
ShouldBeInterface
Creates an error message indicating that an assertion that verifies that a class is (or not) an interface.class
ShouldBeInTheFuture
Creates an error message indicating that an assertion that verifies that aDate
is in the future failed.class
ShouldBeInThePast
Creates an error message indicating that an assertion that verifies that aDate
is in the past failed.class
ShouldBeLess
Creates an error message indicating that an assertion that verifies that a value is less than another one failed.class
ShouldBeLessOrEqual
Creates an error message indicating that an assertion that verifies that a value is less than or equal to another one failed.class
ShouldBeLowerCase
Creates an error message that indicates an assertion that verifies that a character is lowercase failed.class
ShouldBeMarked
class
ShouldBeNormalized
Assertion error message delivered when aPath
is not normalizedclass
ShouldBeNullOrEmpty
Creates an error message indicating that an assertion that verifies a group of elements isnull
or empty failed.class
ShouldBeOfClassIn
Creates an error message indicating that an assertion that verifies that an object is of type in group of types failed.class
ShouldBeReadable
class
ShouldBeRegularFile
Creates an error message indicating that an assertion that verifies that aPath
is a regular file has failed.class
ShouldBeRelativePath
class
ShouldBeSame
Creates an error message indicating that an assertion that verifies that two object refer to same object failed.class
ShouldBeSorted
Creates an error message indicating that an assertion that verifies a group of elements is sorted failed.
A group of elements can be a collection or an array.class
ShouldBeSubsetOf
Creates an error message indicating that an assertion that verifies that anIterable
is a subset of an other setIterable
failed.class
ShouldBeSubstring
class
ShouldBeSymbolicLink
Creates an error message indicating that an assertion that verifies that aPath
is a regular file has failed.class
ShouldBeToday
Creates an error message indicating that an assertion that verifies that aDate
is today (matching only year, month and day but not hours).class
ShouldBeUpperCase
Creates an error message that indicates an assertion that verifies that a character is uppercase failed.class
ShouldBeWritable
Creates an error message indicating that an assertion that verifies that a
is writable failed.File
class
ShouldContain
Creates an error message indicating that an assertion that verifies a group of elements contains a given set of values failed.class
ShouldContainAnyOf
class
ShouldContainAtIndex
Creates an error message indicating that an assertion that verifies a group of elements contains a value at a given index failed.class
ShouldContainCharSequence
Creates an error message indicating that an assertion that verifies that aCharSequence
contains anotherCharSequence
failed.class
ShouldContainCharSequenceOnlyOnce
Creates an error message indicating that an assertion that verifies that aCharSequence
contains anotherCharSequence
only once failed.class
ShouldContainEntry
Creates an error message indicating that an assertion that verifies a map contains an entry..class
ShouldContainExactly
Creates an error message indicating that an assertion that verifies a group of elements contains exactly a given set of values and nothing else failed, exactly meaning same elements in same order.class
ShouldContainExactlyInAnyOrder
Creates an error message indicating that an assertion that verifies a group of elements contains exactly a given set of values and nothing else failed.class
ShouldContainKey
Creates an error message indicating that an assertion that verifies a map contains a key..class
ShouldContainKeys
Creates an error message indicating that an assertion that verifies a map contains a key..class
ShouldContainNull
Creates an error message indicating that an assertion that verifies a group of elements contains a null element failed.class
ShouldContainOneOrMoreWhitespaces
Creates an error message indicating that an assertion that verifies that aCharSequence
contains one or more whitespaces.class
ShouldContainOnly
Creates an error message indicating that an assertion that verifies a group of elements contains only a given set of values and nothing else failed.class
ShouldContainOnlyDigits
Creates an error message indicating that an assertion that verifies a CharSequence contains only digits failed.class
ShouldContainOnlyKeys
Creates an error message indicating that an assertion that verifies map contains only a given set of keys and nothing else failed.class
ShouldContainOnlyNulls
Creates an error message indicating that an assertion that verifies a group of elements contains only null elements failed.class
ShouldContainOnlyWhitespaces
Creates an error message indicating that an assertion that verifies aCharSequence
contains only whitespaces.class
ShouldContainPattern
Creates an error message indicating that an assertion that verifies that aCharSequence
contains a pattern failed.class
ShouldContainSequence
Creates an error message indicating that an assertion that verifies that a group of elements contains a sequence of values failed.class
ShouldContainSequenceOfCharSequence
Creates an error message indicating that an assertion that verifies that aCharSequence
contains a Sequence of severalCharSequence
s in order failed.class
ShouldContainsOnlyOnce
Creates an error message indicating that an assertion that verifies a group of elements contains only a given set of values and nothing else failed.class
ShouldContainSubsequence
Creates an error message indicating that an assertion that verifies that a group of elements contains a subsequence of values failed.class
ShouldContainSubsequenceOfCharSequence
Creates an error message indicating that an assertion that verifies that aCharSequence
contains a Subsequence of severalCharSequence
s in order failed.class
ShouldContainValue
Creates an error message indicating that an assertion that verifies a map contains a value.class
ShouldContainValues
Creates an error message indicating that an assertion that verifies a map contains a values.class
ShouldEndWith
Creates an error message indicating that an assertion that verifies that a group of elements ends with a given value or sequence of values failed.class
ShouldEndWithPath
class
ShouldExist
class
ShouldHave
Creates an error message indicating that an assertion that verifies that a value satisfies a
failed.Condition
class
ShouldHaveAllNullFields
Creates an
indicating that an assertion that verifies that an object has null fields failed.AssertionError
class
ShouldHaveAnnotations
Creates an error message indicating that an assertion that verifies that a class have an annotation.class
ShouldHaveAtIndex
Creates an error message indicating that an assertion that verifies a group of elements contains a value at a given index that satisfies a
failed.Condition
class
ShouldHaveAtLeastOneElementOfType
Creates an error message indicating that a group does not have an element of the given type.class
ShouldHaveBinaryContent
Creates an error message indicating that an assertion that verifies that a file/path has a given binary content failed.class
ShouldHaveCause
class
ShouldHaveCauseExactlyInstance
Creates an error message indicating that an assertion that verifies that aThrowable
have a cause exactly instance of a certain type.class
ShouldHaveCauseInstance
Creates an error message indicating that an assertion that verifies that aThrowable
have a cause instance of a certain type.class
ShouldHaveCauseReference
class
ShouldHaveContent
Creates an error message indicating that an assertion that verifies that a file/path has a given text content failed.class
ShouldHaveDateField
Creates an error message indicating that an assertion that verifies that aDate
has a year, month, day, ...class
ShouldHaveDigest
Creates an error message indicating that an assertion that verifies that file/inputStream/path have digest failed.class
ShouldHaveExtension
Creates an error message indicating that aFile
should have extension.class
ShouldHaveFields
Creates an error message indicating that an assertion that verifies that a class have field.class
ShouldHaveLineCount
Creates an error message indicating that an assertion that verifies that a value have certain number of lines failed.class
ShouldHaveMessage
Creates an error message indicating that an assertion that verifies that aThrowable
have certain message failed.class
ShouldHaveMessageFindingMatchRegex
Creates an error message indicating that an assertion that verifies that aCharSequence
matches given regular expression.class
ShouldHaveMessageMatchingRegex
Creates an error message indicating that an assertion that verifies that aCharSequence
matches given regular expression.class
ShouldHaveMethods
Creates an error message indicating that an assertion that verifies that a class have methods.class
ShouldHaveName
Creates an error message indicating that aFile
should have name.class
ShouldHaveNext
Creates an error message indicating that an assertion that verifies that anIterator
has a next element failed.class
ShouldHaveNoCause
Creates an error message indicating that an assertion that verifies that anThrowable
has no cause failed.class
ShouldHaveNoFields
class
ShouldHaveNoNullFields
Creates an
indicating that an assertion that verifies that an object has no null fields failed.AssertionError
class
ShouldHaveNoParent
Creates an error message when aFile
should not have a parent.class
ShouldHaveNoSuppressedExceptions
Creates an error message indicating that an assertion that verifies that aThrowable
has no suppressed exceptions failed.class
ShouldHaveOnlyElementsOfType
Creates an error message indicating that a group does not have an element of the given type.class
ShouldHaveParent
Creates an error message indicating that aFile
should have a parent.class
ShouldHavePropertyOrField
Creates an error message indicating that an assertion that verifies that a class has a given field/property.class
ShouldHavePropertyOrFieldWithValue
Creates an error message indicating that an assertion that verifies that a class has a field/property with a value.class
ShouldHaveReference
class
ShouldHaveRootCause
class
ShouldHaveRootCauseExactlyInstance
Creates an error message indicating that an assertion that verifies that aThrowable
have a root cause exactly instance of a certain type.class
ShouldHaveRootCauseInstance
Creates an error message indicating that an assertion that verifies that aThrowable
have a root cause instance of a certain type.class
ShouldHaveSameClass
Creates an error message indicating that an assertion that verifies that an object have same class as another instance failed.class
ShouldHaveSameContent
Creates an error message indicating that an assertion that verifies that two files/inputStreams/paths have same content failed.class
ShouldHaveSameHashCode
class
ShouldHaveSameHourAs
Creates an error message indicating that an assertion that verifies that twoZonedDateTime
have same year, month, day and hour fields failed.class
ShouldHaveSameSizeAs
Creates an error message indicating that an assertion that verifies that a value have certain size failed.class
ShouldHaveSameTime
Creates an error message indicating that an assertion that verifies that a date has same time as other date.class
ShouldHaveSize
Creates an error message indicating that an assertion that verifies that a value have certain size failed.class
ShouldHaveSizeBetween
Creates an error message indicating that an assertion - that verifies that size of a value is between two given values - failed.class
ShouldHaveSizeGreaterThan
Creates an error message indicating that an assertion that verifies a minimum size failed.class
ShouldHaveSizeGreaterThanOrEqualTo
Creates an error message indicating that an assertion that verifies a minimum size failed.class
ShouldHaveSizeLessThan
Creates an error message indicating that an assertion that verifies a maximum size failed.class
ShouldHaveSizeLessThanOrEqualTo
Creates an error message indicating that an assertion that verifies a maximum size failed.class
ShouldHaveStamp
class
ShouldHaveSuppressedException
Creates an error message indicating that an assertion that verifies that aThrowable
has a given suppressed exception failed.class
ShouldHaveTime
Creates an error message indicating that an assertion that verifies that a date have a certain timestamp.class
ShouldHaveToString
class
ShouldHaveValue
class
ShouldMatch
Creates an error message indicating that an assertion that verifies that a value satisfies a
failed.Predicate
class
ShouldMatchPattern
Creates an error message indicating that an assertion that verifies that aCharSequence
matches a pattern failed.class
ShouldNotAccept
Creates an error message indicating that an assertion that verifies that
not accepting a value failed.Predicate
class
ShouldNotBe
Creates an error message indicating that an assertion that verifies that a value does not satisfy a
failed.Condition
class
ShouldNotBeBetween
Creates an error message indicating that an assertion that verifies that aDate
is not between start - end dates (inclusive or not) failed.class
ShouldNotBeBlank
Creates an error message indicating that an assertion that verifiesCharSequence
is not blank.class
ShouldNotBeEmpty
Creates an error message indicating that an assertion that verifies a group of elements is not empty failed.class
ShouldNotBeEqual
Creates an error message indicating that an assertion that verifies that two objects are not equal failed.class
ShouldNotBeEqualIgnoringCase
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are not equal, ignoring case considerations, failed.class
ShouldNotBeEqualIgnoringWhitespace
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are not equal, ignoring whitespace differences, failed.class
ShouldNotBeEqualNormalizingWhitespace
Creates an error message indicating that an assertion that verifies that twoCharSequence
s are not equal, after the whitespace of both strings has been normalized, failed.class
ShouldNotBeEqualWithinOffset
Creates an error message indicating that an assertion that verifies that two numbers are not equal within a positive offset failed.class
ShouldNotBeEqualWithinPercentage
Creates an error message indicating that an assertion that verifies that two numbers are not equal within a positive percentage failed.class
ShouldNotBeExactlyInstanceOf
Creates an error message indicating that an assertion that verifies that an object is not exactly an instance of some type failed.class
ShouldNotBeIn
Creates an error message indicating that an assertion that verifies that a value is not in a group of values (e.g.class
ShouldNotBeInstance
Creates an error message indicating that an assertion that verifies that an object is not an instance of some type failed.class
ShouldNotBeInstanceOfAny
Creates an error message indicating that an assertion that verifies that an object is not an instance of one or more types failed.class
ShouldNotBeNull
Creates an error message that indicates an assertion that verifies that an object is notnull
failed.class
ShouldNotBeOfClassIn
Creates an error message indicating that an assertion that verifies that an object is not of type in group of types failed.class
ShouldNotBeSame
Creates an error message indicating an assertion that verifies that two objects do not refer to the same object failed.class
ShouldNotContain
Creates an error message indicating that an assertion that verifies a group of elements does not contain a given set of values failed.class
ShouldNotContainAnyWhitespaces
Creates an error message indicating that an assertion that verifies that aCharSequence
does not contain whitespace characters.class
ShouldNotContainAtIndex
Creates an error message indicating that an assertion that verifies a group of elements does not contain a value at a given index failed.class
ShouldNotContainCharSequence
Creates an error message indicating that an assertion that verifies that aCharSequence
does not contain anotherCharSequence
failed.class
ShouldNotContainKey
Creates an error message indicating that an assertion that verifies a map does not contains a key failed.class
ShouldNotContainKeys
Creates an error message indicating that an assertion that verifies a map does not contain keys.class
ShouldNotContainNull
Creates an error message indicating that an assertion that verifies a group of elements does not contain null elements failed.class
ShouldNotContainOnlyWhitespaces
Creates an error message indicating that an assertion that verifiesCharSequence
is not blank.class
ShouldNotContainPattern
Creates an error message indicating that an assertion that verifies that aCharSequence
does not contain a regular expression failed.class
ShouldNotContainSequence
Creates an error message indicating that an assertion that verifies that a group of elements does not contain a sequence of values failed.class
ShouldNotContainSubsequence
Creates an error message indicating that an assertion that verifies that a group of elements does not contains a subsequence of values failed.class
ShouldNotContainValue
Creates an error message indicating that an assertion that verifies a map does not contains a value.class
ShouldNotEndWith
Creates an error message indicating that an assertion that verifies that a group of elements does not end with a given value or sequence of values failed.class
ShouldNotExist
class
ShouldNotHave
Creates an error message indicating that an assertion that verifies that a value does not satisfy a
failed.Condition
class
ShouldNotHaveAnyElementsOfTypes
class
ShouldNotHaveDuplicates
Creates an error message indicating that an assertion that verifies a group of elements is does not have duplicates failed.class
ShouldNotHaveSameClass
Creates an error message indicating that an assertion that verifies that an object has same class as another instance failed.class
ShouldNotHaveThrown
class
ShouldNotMatch
Creates an error message indicating that an assertion that verifies that a value not satisfying a
failed.Predicate
class
ShouldNotMatchPattern
Creates an error message indicating that an assertion that verifies that aCharSequence
does not match a pattern failed.class
ShouldNotStartWith
Creates an error message indicating that an assertion that verifies that a group of elements does not start with a given value or sequence of values failed.class
ShouldOnlyHaveElementsOfTypes
Creates an error message indicating that an assertion that verifies a group of elements contains elements that are not an instance of one of the given types.class
ShouldOnlyHaveFields
Creates an error message indicating that an assertion that verifies that a class has only the fields.class
ShouldSatisfy
class
ShouldStartWith
Creates an error message indicating that an assertion that verifies that a group of elements starts with a given value or sequence of values failed.class
ShouldStartWithPath
class
ZippedElementsShouldSatisfy
Methods in org.assertj.core.error that return ErrorMessageFactory Modifier and Type Method Description static ErrorMessageFactory
AnyElementShouldMatch. anyElementShouldMatch(Object actual, PredicateDescription predicateDescription)
private static ErrorMessageFactory
ShouldOnlyHaveFields. create(Class<?> actual, Collection<String> expected, Collection<String> notFound, Collection<String> notExpected, boolean declared)
static ErrorMessageFactory
ShouldContain. directoryShouldContain(File actual, List<String> directoryContent, String filterDescription)
static ErrorMessageFactory
ShouldContain. directoryShouldContain(Path actual, List<String> directoryContent, String filterDescription)
static ErrorMessageFactory
ShouldNotContain. directoryShouldNotContain(File actual, List<String> matchingContent, String filterDescription)
static ErrorMessageFactory
ShouldNotContain. directoryShouldNotContain(Path actual, List<String> matchingContent, String filterDescription)
static ErrorMessageFactory
ShouldContainExactly. elementsDifferAtIndex(Object actualElement, Object expectedElement, int indexOfDifferentElements)
Creates a new
for the case where actual and expected have the same elements in different order.ShouldContainExactly
static ErrorMessageFactory
ShouldContainExactly. elementsDifferAtIndex(Object actualElement, Object expectedElement, int indexOfDifferentElements, ComparisonStrategy comparisonStrategy)
Creates a new
for the case where actual and expected have the same elements in different order according to the givenShouldContainExactly
ComparisonStrategy
.static ErrorMessageFactory
ElementsShouldBe. elementsShouldBe(Object actual, Object notSatisfies, Condition<?> condition)
Creates a new
.ElementsShouldBe
static ErrorMessageFactory
ElementsShouldBeAtLeast. elementsShouldBeAtLeast(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldBeAtLeast
static ErrorMessageFactory
ElementsShouldBeAtMost. elementsShouldBeAtMost(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldBeAtMost
static ErrorMessageFactory
ElementsShouldBeExactly. elementsShouldBeExactly(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldBeExactly
static ErrorMessageFactory
ElementsShouldHave. elementsShouldHave(Object actual, Object notSatisfies, Condition<?> condition)
Creates a new
.ElementsShouldHave
static ErrorMessageFactory
ElementsShouldHaveAtLeast. elementsShouldHaveAtLeast(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldHaveAtLeast
static ErrorMessageFactory
ElementsShouldHaveAtMost. elementsShouldHaveAtMost(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldHaveAtMost
static ErrorMessageFactory
ElementsShouldHaveExactly. elementsShouldHaveExactly(Object actual, int times, Condition<?> condition)
Creates a new
.ElementsShouldHaveExactly
static <T> ErrorMessageFactory
ElementsShouldMatch. elementsShouldMatch(Object actual, T elementsNotMatchingPredicate, PredicateDescription predicateDescription)
static ErrorMessageFactory
ElementsShouldNotBe. elementsShouldNotBe(Object actual, Object satisfies, Condition<?> condition)
Creates a new
.ElementsShouldNotBe
static ErrorMessageFactory
ElementsShouldNotHave. elementsShouldNotHave(Object actual, Object notSatisfies, Condition<?> condition)
Creates a new
.ElementsShouldNotHave
static ErrorMessageFactory
ElementsShouldSatisfy. elementsShouldSatisfy(Object actual, List<ElementsShouldSatisfy.UnsatisfiedRequirement> elementsNotSatisfyingRestrictions, AssertionInfo info)
static ErrorMessageFactory
ElementsShouldSatisfy. elementsShouldSatisfyAny(Object actual, List<ElementsShouldSatisfy.UnsatisfiedRequirement> elementsNotSatisfyingRequirements, AssertionInfo info)
static <T> ErrorMessageFactory
NoElementsShouldMatch. noElementsShouldMatch(Object actual, T elementMatchingPredicate, PredicateDescription predicateDescription)
static ErrorMessageFactory
NoElementsShouldSatisfy. noElementsShouldSatisfy(Object actual, Object faultyElement)
static <T> ErrorMessageFactory
ShouldAccept. shouldAccept(Predicate<? super T> predicate, T value, PredicateDescription description)
Creates a new
.ShouldAccept
static <T> ErrorMessageFactory
ShouldBe. shouldBe(T actual, Condition<? super T> condition)
Creates a new
.ShouldBe
static ErrorMessageFactory
ShouldBeAbsolutePath. shouldBeAbsolutePath(File actual)
Creates a new
.ShouldBeAbsolutePath
static ErrorMessageFactory
ShouldBeAbsolutePath. shouldBeAbsolutePath(Path actual)
static ErrorMessageFactory
ShouldBeAbstract. shouldBeAbstract(Class<?> actual)
static ErrorMessageFactory
ShouldBeAfter. shouldBeAfter(Object actual, Object other)
Creates a new
.ShouldBeAfter
static ErrorMessageFactory
ShouldBeAfter. shouldBeAfter(Object actual, Object other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeAfter
static ErrorMessageFactory
ShouldBeAfter. shouldBeAfter(Date actual, int year)
Creates a new
.ShouldBeAfter
static ErrorMessageFactory
ShouldBeAfterOrEqualTo. shouldBeAfterOrEqualTo(Object actual, Object other)
Creates a new
.ShouldBeAfterOrEqualTo
static ErrorMessageFactory
ShouldBeAfterOrEqualTo. shouldBeAfterOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeAfterOrEqualTo
static ErrorMessageFactory
ShouldBeAfterYear. shouldBeAfterYear(Date actual, int year)
Creates a new
.ShouldBeAfterYear
static ErrorMessageFactory
ShouldBeAfterYear. shouldBeAfterYear(Date actual, int year, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeAfterYear
static ErrorMessageFactory
ShouldBeAnArray. shouldBeAnArray(Object object)
Creates a new instance of
.ShouldBeAnArray
static ErrorMessageFactory
ShouldBeAnnotation. shouldBeAnnotation(Class<?> actual)
Creates a new
.ShouldBeAnnotation
static ErrorMessageFactory
ShouldBeAssignableFrom. shouldBeAssignableFrom(Class<?> actual, Set<Class<?>> expectedAssignableFrom, Set<Class<?>> missingAssignableFrom)
Creates a new
.ShouldBeAssignableFrom
static <T> ErrorMessageFactory
ShouldBeAtIndex. shouldBeAtIndex(List<? extends T> actual, Condition<? super T> condition, Index index, T found)
Creates a new
.ShouldBeAtIndex
static ErrorMessageFactory
ShouldBeAtSameInstant. shouldBeAtSameInstant(OffsetDateTime actual, OffsetDateTime other)
Creates a new
.ShouldBeAtSameInstant
static ErrorMessageFactory
ShouldBeBefore. shouldBeBefore(Object actual, Object other)
Creates a new
.ShouldBeBefore
static ErrorMessageFactory
ShouldBeBefore. shouldBeBefore(Object actual, Object other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeBefore
static ErrorMessageFactory
ShouldBeBeforeOrEqualTo. shouldBeBeforeOrEqualTo(Object actual, Object other)
Creates a new
.ShouldBeBeforeOrEqualTo
static ErrorMessageFactory
ShouldBeBeforeOrEqualTo. shouldBeBeforeOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeBeforeOrEqualTo
static ErrorMessageFactory
ShouldBeBeforeYear. shouldBeBeforeYear(Date actual, int year)
Creates a new
.ShouldBeBeforeYear
static ErrorMessageFactory
ShouldBeBeforeYear. shouldBeBeforeYear(Date actual, int year, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeBeforeYear
static ErrorMessageFactory
ShouldBeBetween. shouldBeBetween(Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)
Creates a new
.ShouldBeBetween
static ErrorMessageFactory
ShouldBeBetween. shouldBeBetween(Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeBetween
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeBetween. shouldBeBetween(T actual, T start, T end, boolean inclusiveStart, boolean inclusiveEnd)
Creates a new
.ShouldBeBetween
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeBetween. shouldBeBetween(T actual, T start, T end, boolean inclusiveStart, boolean inclusiveEnd, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeBetween
static ErrorMessageFactory
ShouldBeBlank. shouldBeBlank(CharSequence actual)
Creates a new
.ShouldBeBlank
static ErrorMessageFactory
ShouldBeCanonicalPath. shouldBeCanonicalPath(Path actual)
static ErrorMessageFactory
ShouldBeCloseTo. shouldBeCloseTo(Temporal actual, Temporal other, String differenceDescription)
Creates a new
.ShouldBeCloseTo
static ErrorMessageFactory
ShouldBeCloseTo. shouldBeCloseTo(Date actual, Date other, long deltaInMilliseconds, long difference)
Creates a new
.ShouldBeCloseTo
static ErrorMessageFactory
ShouldBeDirectory. shouldBeDirectory(File actual)
static ErrorMessageFactory
ShouldBeDirectory. shouldBeDirectory(Path actual)
static ErrorMessageFactory
ShouldBeEmpty. shouldBeEmpty(File actual)
Creates a new
.ShouldBeEmpty
static ErrorMessageFactory
ShouldBeEmpty. shouldBeEmpty(Object actual)
Creates a new
.ShouldBeEmpty
static ErrorMessageFactory
ShouldBeEmptyDirectory. shouldBeEmptyDirectory(File actual, List<File> directoryContent)
static ErrorMessageFactory
ShouldBeEmptyDirectory. shouldBeEmptyDirectory(Path actual, List<Path> directoryContent)
static ErrorMessageFactory
ShouldBeEqualIgnoringCase. shouldBeEqual(CharSequence actual, CharSequence expected)
Creates a new
.ShouldBeEqualIgnoringCase
static <T extends Number>
ErrorMessageFactoryShouldBeEqualWithinOffset. shouldBeEqual(T actual, T expected, Offset<T> offset, T difference)
Creates a new
.ShouldBeEqualWithinOffset
static ErrorMessageFactory
ShouldBeEqualWithTimePrecision. shouldBeEqual(Date actual, Date expected, TimeUnit precision)
Creates a new
.ShouldBeEqualWithTimePrecision
static ErrorMessageFactory
ShouldBeEqualByComparingFieldByFieldRecursively. shouldBeEqualByComparingFieldByFieldRecursive(Object actual, Object other, List<DeepDifference.Difference> differences, Representation representation)
static ErrorMessageFactory
ShouldBeEqualByComparingFieldByFieldRecursively. shouldBeEqualByComparingFieldByFieldRecursively(Object actual, Object other, List<ComparisonDifference> differences, RecursiveComparisonConfiguration recursiveComparisonConfiguration, Representation representation)
static ErrorMessageFactory
ShouldBeEqualByComparingOnlyGivenFields. shouldBeEqualComparingOnlyGivenFields(Object actual, List<String> rejectedFields, List<Object> rejectedValues, List<Object> expectedValues, List<String> acceptedFields)
Creates a new
.ShouldBeEqualByComparingOnlyGivenFields
static ErrorMessageFactory
ShouldBeEqualIgnoringHours. shouldBeEqualIgnoringHours(Object actual, Object other)
Creates a new
.ShouldBeEqualIgnoringHours
static ErrorMessageFactory
ShouldBeEqualIgnoringMinutes. shouldBeEqualIgnoringMinutes(Object actual, Object other)
Creates a new
.ShouldBeEqualIgnoringMinutes
static ErrorMessageFactory
ShouldBeEqualIgnoringMinutes. shouldBeEqualIgnoringMinutes(LocalTime actual, LocalTime other)
Creates a new
.ShouldBeEqualIgnoringSeconds
static ErrorMessageFactory
ShouldBeEqualIgnoringMinutes. shouldBeEqualIgnoringMinutes(OffsetTime actual, OffsetTime other)
Creates a new
.ShouldBeEqualIgnoringSeconds
static ErrorMessageFactory
ShouldBeEqualIgnoringNanos. shouldBeEqualIgnoringNanos(Object actual, Object other)
Creates a new
.ShouldBeEqualIgnoringNanos
static ErrorMessageFactory
ShouldBeEqualIgnoringNanos. shouldBeEqualIgnoringNanos(LocalTime actual, LocalTime other)
Creates a new
.ShouldBeEqualIgnoringNanos
static ErrorMessageFactory
ShouldBeEqualIgnoringNanos. shouldBeEqualIgnoringNanos(OffsetTime actual, OffsetTime other)
Creates a new
.ShouldBeEqualIgnoringNanos
static ErrorMessageFactory
ShouldBeEqualIgnoringNewLineDifferences. shouldBeEqualIgnoringNewLineDifferences(CharSequence actual, CharSequence expected)
static ErrorMessageFactory
ShouldBeEqualIgnoringNewLines. shouldBeEqualIgnoringNewLines(CharSequence actual, CharSequence expected)
static ErrorMessageFactory
ShouldBeEqualIgnoringSeconds. shouldBeEqualIgnoringSeconds(Object actual, Object other)
Creates a new
.ShouldBeEqualIgnoringSeconds
static ErrorMessageFactory
ShouldBeEqualIgnoringSeconds. shouldBeEqualIgnoringSeconds(LocalTime actual, LocalTime other)
Creates a new
.ShouldBeEqualIgnoringSeconds
static ErrorMessageFactory
ShouldBeEqualIgnoringSeconds. shouldBeEqualIgnoringSeconds(OffsetTime actual, OffsetTime other)
Creates a new
.ShouldBeEqualIgnoringSeconds
static ErrorMessageFactory
ShouldBeEqualIgnoringTimezone. shouldBeEqualIgnoringTimezone(OffsetDateTime actual, OffsetDateTime other)
Creates a new
.ShouldBeEqualIgnoringTimezone
static ErrorMessageFactory
ShouldBeEqualIgnoringTimezone. shouldBeEqualIgnoringTimezone(OffsetTime actual, OffsetTime other)
Creates a new
.ShouldBeEqualIgnoringTimezone
static ErrorMessageFactory
ShouldBeEqualIgnoringWhitespace. shouldBeEqualIgnoringWhitespace(CharSequence actual, CharSequence expected)
Creates a new
.ShouldBeEqualIgnoringWhitespace
static ErrorMessageFactory
ShouldBeEqualNormalizingWhitespace. shouldBeEqualNormalizingWhitespace(CharSequence actual, CharSequence expected)
Creates a new
.ShouldBeEqualNormalizingWhitespace
static ErrorMessageFactory
ShouldBeEqualToIgnoringFields. shouldBeEqualToIgnoringGivenFields(Object actual, List<String> rejectedFields, List<Object> rejectedValues, List<Object> expectedValues, List<String> ignoredFields)
Creates a new
.ShouldBeEqualToIgnoringFields
static <T extends Number>
ErrorMessageFactoryShouldBeEqualWithinPercentage. shouldBeEqualWithinPercentage(T actual, T expected, Percentage percentage, T difference)
Creates a new
.ShouldBeEqualWithinPercentage
static ErrorMessageFactory
ShouldBeExactlyInstanceOf. shouldBeExactlyInstance(Object actual, Class<?> type)
Creates a new
.ShouldBeExactlyInstanceOf
static ErrorMessageFactory
ShouldBeExecutable. shouldBeExecutable(File actual)
Creates a new
.ShouldBeExecutable
static ErrorMessageFactory
ShouldBeExecutable. shouldBeExecutable(Path actual)
static ErrorMessageFactory
ShouldBeExhausted. shouldBeExhausted()
Creates a new
.ShouldBeExhausted
static ErrorMessageFactory
ShouldBeFile. shouldBeFile(File actual)
Creates a new
.ShouldBeFile
static ErrorMessageFactory
ClassModifierShouldBe. shouldBeFinal(Class<?> actual)
Creates a newClassModifierShouldBe
.static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeGreater. shouldBeGreater(T actual, T other)
Creates a new
.ShouldBeGreater
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeGreater. shouldBeGreater(T actual, T other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeGreater
static <T extends Comparable<T>>
ErrorMessageFactoryShouldBeGreaterOrEqual. shouldBeGreaterOrEqual(T actual, T other)
Creates a new
.ShouldBeGreaterOrEqual
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeGreaterOrEqual. shouldBeGreaterOrEqual(T actual, T other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeGreaterOrEqual
static ErrorMessageFactory
ShouldBeIn. shouldBeIn(Object actual, Object values)
Creates a new
.ShouldBeIn
static ErrorMessageFactory
ShouldBeIn. shouldBeIn(Object actual, Object values, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeIn
static ErrorMessageFactory
ShouldBeInSameDay. shouldBeInSameDay(Date actual, Date other)
Creates a new
.ShouldBeInSameDay
static ErrorMessageFactory
ShouldBeInSameHour. shouldBeInSameHour(Date actual, Date other)
Creates a new
.ShouldBeInSameHour
static ErrorMessageFactory
ShouldBeInSameHourWindow. shouldBeInSameHourWindow(Date actual, Date other)
Creates a new
.ShouldBeInSameHourWindow
static ErrorMessageFactory
ShouldBeInSameMinute. shouldBeInSameMinute(Date actual, Date other)
Creates a new
.ShouldBeInSameMinute
static ErrorMessageFactory
ShouldBeInSameMinuteWindow. shouldBeInSameMinuteWindow(Date actual, Date other)
Creates a new
.ShouldBeInSameMinuteWindow
static ErrorMessageFactory
ShouldBeInSameMonth. shouldBeInSameMonth(Date actual, Date other)
Creates a new
.ShouldBeInSameMonth
static ErrorMessageFactory
ShouldBeInSameSecond. shouldBeInSameSecond(Date actual, Date other)
Creates a new
.ShouldBeInSameSecond
static ErrorMessageFactory
ShouldBeInSameSecondWindow. shouldBeInSameSecondWindow(Date actual, Date other)
static ErrorMessageFactory
ShouldBeInSameYear. shouldBeInSameYear(Date actual, Date other)
Creates a new
.ShouldBeInSameYear
static ErrorMessageFactory
ShouldBeInstance. shouldBeInstance(Object object, Class<?> type)
Creates a new
.ShouldBeInstance
static ErrorMessageFactory
ShouldBeInstance. shouldBeInstanceButWasNull(String objectDescription, Class<?> type)
Creates a new
when object we want to check type is null.ShouldBeInstance
static ErrorMessageFactory
ShouldBeInstanceOfAny. shouldBeInstanceOfAny(Object actual, Class<?>[] types)
Creates a new
.ShouldBeInstanceOfAny
static ErrorMessageFactory
ShouldBeInterface. shouldBeInterface(Class<?> actual)
Creates a new
.ShouldBeInterface
static ErrorMessageFactory
ShouldBeInTheFuture. shouldBeInTheFuture(Date actual)
Creates a new
.ShouldBeInTheFuture
static ErrorMessageFactory
ShouldBeInTheFuture. shouldBeInTheFuture(Date actual, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeInTheFuture
static ErrorMessageFactory
ShouldBeInThePast. shouldBeInThePast(Date actual)
Creates a new
.ShouldBeInThePast
static ErrorMessageFactory
ShouldBeInThePast. shouldBeInThePast(Date actual, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeInThePast
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeLess. shouldBeLess(T actual, T other)
Creates a new
.ShouldBeLess
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeLess. shouldBeLess(T actual, T other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeLess
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeLessOrEqual. shouldBeLessOrEqual(T actual, T other)
Creates a new
.ShouldBeLessOrEqual
static <T extends Comparable<? super T>>
ErrorMessageFactoryShouldBeLessOrEqual. shouldBeLessOrEqual(T actual, T other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeLessOrEqual
static ErrorMessageFactory
ShouldBeLowerCase. shouldBeLowerCase(Object actual)
Creates a new
.ShouldBeLowerCase
static ErrorMessageFactory
ShouldBeMarked. shouldBeMarked(AtomicMarkableReference<?> actual)
static ErrorMessageFactory
ShouldBeNormalized. shouldBeNormalized(Path actual)
static ErrorMessageFactory
ShouldBeNullOrEmpty. shouldBeNullOrEmpty(Object actual)
Creates a new instance of
.ShouldBeNullOrEmpty
static ErrorMessageFactory
ShouldBeOfClassIn. shouldBeOfClassIn(Object actual, Object types)
Creates a new
.ShouldBeOfClassIn
static ErrorMessageFactory
ClassModifierShouldBe. shouldBeProtected(Class<?> actual)
Creates a newClassModifierShouldBe
.static ErrorMessageFactory
ClassModifierShouldBe. shouldBePublic(Class<?> actual)
Creates a newClassModifierShouldBe
.static ErrorMessageFactory
ShouldBeReadable. shouldBeReadable(File actual)
Creates a new
.ShouldBeReadable
static ErrorMessageFactory
ShouldBeReadable. shouldBeReadable(Path actual)
static ErrorMessageFactory
ShouldBeRegularFile. shouldBeRegularFile(Path actual)
static ErrorMessageFactory
ShouldBeRelativePath. shouldBeRelativePath(File actual)
Creates a new
.ShouldBeRelativePath
static ErrorMessageFactory
ShouldBeRelativePath. shouldBeRelativePath(Path actual)
static ErrorMessageFactory
ShouldBeSame. shouldBeSame(Object actual, Object expected)
Creates a new
.ShouldBeSame
static ErrorMessageFactory
ConditionAndGroupGenericParameterTypeShouldBeTheSame. shouldBeSameGenericBetweenIterableAndCondition(Object actual, Condition<?> condition)
Creates a newConditionAndGroupGenericParameterTypeShouldBeTheSame
static ErrorMessageFactory
ShouldBeSorted. shouldBeSorted(int i, Object group)
Creates a new
.ShouldBeSorted
static ErrorMessageFactory
ShouldBeSorted. shouldBeSortedAccordingToGivenComparator(int i, Object group, Comparator<?> comparator)
static ErrorMessageFactory
ShouldBeSubsetOf. shouldBeSubsetOf(Object actual, Object values, Iterable<?> unexpected)
Creates a new
.ShouldBeSubsetOf
static ErrorMessageFactory
ShouldBeSubsetOf. shouldBeSubsetOf(Object actual, Object values, Iterable<?> unexpected, ComparisonStrategy comparisonStrategy)
Creates a newShouldBeSubsetOf
static ErrorMessageFactory
ShouldBeSubstring. shouldBeSubstring(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeSubstring
static ErrorMessageFactory
ShouldBeSymbolicLink. shouldBeSymbolicLink(Path actual)
static ErrorMessageFactory
ShouldBeToday. shouldBeToday(LocalDate actual)
Creates a new
.ShouldBeToday
static ErrorMessageFactory
ShouldBeToday. shouldBeToday(Date actual)
Creates a new
.ShouldBeToday
static ErrorMessageFactory
ShouldBeToday. shouldBeToday(Date actual, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldBeToday
static ErrorMessageFactory
ShouldBeUpperCase. shouldBeUpperCase(Object actual)
Creates a new
.ShouldBeUpperCase
static ErrorMessageFactory
ShouldBeWritable. shouldBeWritable(File actual)
Creates a new
.ShouldBeWritable
static ErrorMessageFactory
ShouldBeWritable. shouldBeWritable(Path actual)
static ErrorMessageFactory
ShouldContain. shouldContain(Object actual, Object expected, Object notFound)
Creates a new
.ShouldContain
static ErrorMessageFactory
ShouldContain. shouldContain(Object actual, Object expected, Object notFound, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContain
static ErrorMessageFactory
ShouldContainCharSequence. shouldContain(CharSequence actual, CharSequence sequence)
Creates a new
.ShouldContainCharSequence
static ErrorMessageFactory
ShouldContainCharSequence. shouldContain(CharSequence actual, CharSequence[] strings, Set<? extends CharSequence> notFound)
Creates a new
.ShouldContainCharSequence
static ErrorMessageFactory
ShouldContainCharSequence. shouldContain(CharSequence actual, CharSequence[] strings, Set<? extends CharSequence> notFound, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainCharSequence
static ErrorMessageFactory
ShouldContainCharSequence. shouldContain(CharSequence actual, CharSequence sequence, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainCharSequence
static ErrorMessageFactory
ShouldContainAnyOf. shouldContainAnyOf(Object actual, Object expected)
static ErrorMessageFactory
ShouldContainAnyOf. shouldContainAnyOf(Object actual, Object expected, ComparisonStrategy comparisonStrategy)
static ErrorMessageFactory
ShouldContainAtIndex. shouldContainAtIndex(Object actual, Object expected, Index index, Object found)
Creates a new
.ShouldContainAtIndex
static ErrorMessageFactory
ShouldContainAtIndex. shouldContainAtIndex(Object actual, Object expected, Index index, Object found, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainAtIndex
static <K,V>
ErrorMessageFactoryShouldContainEntry. shouldContainEntry(Map<K,V> actual, Condition<?> entryCondition)
Creates a new
.ShouldContainEntry
static <K,V>
ErrorMessageFactoryShouldContainEntry. shouldContainEntry(Map<K,V> actual, Condition<? super K> keyCondition, Condition<? super V> valueCondition)
Creates a new
.ShouldContainEntry
static ErrorMessageFactory
ShouldContainExactly. shouldContainExactly(Object actual, Iterable<?> expected, Iterable<?> notFound, Iterable<?> notExpected)
Creates a new
.ShouldContainExactly
static ErrorMessageFactory
ShouldContainExactly. shouldContainExactly(Object actual, Iterable<?> expected, Iterable<?> notFound, Iterable<?> notExpected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainExactly
static ErrorMessageFactory
ShouldContainExactlyInAnyOrder. shouldContainExactlyInAnyOrder(Object actual, Object expected, Iterable<?> notFound, Iterable<?> notExpected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainExactlyInAnyOrder
static ErrorMessageFactory
ShouldContainCharSequence. shouldContainIgnoringCase(CharSequence actual, CharSequence sequence)
Creates a new
.ShouldContainCharSequence
static ErrorMessageFactory
ShouldContainKey. shouldContainKey(Object actual, Condition<?> keyCondition)
Creates a new
.ShouldContainKey
static <K> ErrorMessageFactory
ShouldContainKeys. shouldContainKeys(Object actual, Set<K> keys)
Creates a new
.ShouldContainKeys
static ErrorMessageFactory
ShouldContainNull. shouldContainNull(Object actual)
Creates a new
.ShouldContainNull
static ErrorMessageFactory
ShouldContainOneOrMoreWhitespaces. shouldContainOneOrMoreWhitespaces(CharSequence actual)
Creates a new
.ShouldContainOneOrMoreWhitespaces
static ErrorMessageFactory
ShouldContainOnly. shouldContainOnly(Object actual, Object expected, Iterable<?> notFound, Iterable<?> notExpected)
Creates a new
.ShouldContainOnly
static ErrorMessageFactory
ShouldContainOnly. shouldContainOnly(Object actual, Object expected, Iterable<?> notFound, Iterable<?> notExpected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainOnly
static ErrorMessageFactory
ShouldContainOnlyDigits. shouldContainOnlyDigits(CharSequence actual)
Creates a new
.ShouldContainOnlyDigits
static ErrorMessageFactory
ShouldContainOnlyDigits. shouldContainOnlyDigits(CharSequence actual, char character, int index)
Creates a new
.ShouldContainOnlyDigits
static ErrorMessageFactory
ShouldContainOnlyKeys. shouldContainOnlyKeys(Object actual, Object expected, Object notFound, Iterable<?> notExpected)
Creates a new
.ShouldContainOnlyKeys
static ErrorMessageFactory
ShouldContainOnlyKeys. shouldContainOnlyKeys(Object actual, Object expected, Object notFound, Object notExpected)
Creates a new
.ShouldContainOnlyKeys
static ErrorMessageFactory
ShouldContainOnlyNulls. shouldContainOnlyNulls(Object actual)
Creates a new
.ShouldContainOnlyNulls
static ErrorMessageFactory
ShouldContainOnlyNulls. shouldContainOnlyNulls(Object actual, Iterable<?> nonNullElements)
static ErrorMessageFactory
ShouldContainCharSequenceOnlyOnce. shouldContainOnlyOnce(CharSequence actual, CharSequence sequence, int occurrences)
Creates a new
.ShouldContainCharSequenceOnlyOnce
static ErrorMessageFactory
ShouldContainCharSequenceOnlyOnce. shouldContainOnlyOnce(CharSequence actual, CharSequence sequence, int occurrences, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainCharSequenceOnlyOnce
static ErrorMessageFactory
ShouldContainOnlyWhitespaces. shouldContainOnlyWhitespaces(CharSequence actual)
Creates a new
.ShouldContainOnlyWhitespaces
static ErrorMessageFactory
ShouldContainPattern. shouldContainPattern(CharSequence actual, CharSequence pattern)
Creates a new
.ShouldContainPattern
static ErrorMessageFactory
ShouldContainSequence. shouldContainSequence(Object actual, Object sequence)
Creates a new
.ShouldContainSequence
static ErrorMessageFactory
ShouldContainSequence. shouldContainSequence(Object actual, Object sequence, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainSequence
static ErrorMessageFactory
ShouldContainSequenceOfCharSequence. shouldContainSequence(CharSequence actual, CharSequence[] sequence)
Create a new
.ShouldContainSequenceOfCharSequence
static ErrorMessageFactory
ShouldContainSequenceOfCharSequence. shouldContainSequence(CharSequence actual, CharSequence[] sequence, ComparisonStrategy comparisonStrategy)
Create a new
.ShouldContainSequenceOfCharSequence
static ErrorMessageFactory
ShouldContainsOnlyOnce. shouldContainsOnlyOnce(Object actual, Object expected, Set<?> notFound, Set<?> notOnlyOnce)
Creates a new
.ShouldContainsOnlyOnce
static ErrorMessageFactory
ShouldContainsOnlyOnce. shouldContainsOnlyOnce(Object actual, Object expected, Set<?> notFound, Set<?> notOnlyOnce, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainsOnlyOnce
static ErrorMessageFactory
ShouldContainSubsequence. shouldContainSubsequence(Object actual, Object subsequence)
Creates a new
.ShouldContainSubsequence
static ErrorMessageFactory
ShouldContainSubsequence. shouldContainSubsequence(Object actual, Object subsequence, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainSubsequence
static ErrorMessageFactory
ShouldContainSubsequenceOfCharSequence. shouldContainSubsequence(CharSequence actual, CharSequence[] strings, int firstBadOrderIndex)
Creates a new
.ShouldContainSubsequenceOfCharSequence
static ErrorMessageFactory
ShouldContainSubsequenceOfCharSequence. shouldContainSubsequence(CharSequence actual, CharSequence[] strings, int badOrderIndex, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldContainSubsequenceOfCharSequence
static ErrorMessageFactory
ShouldContainValue. shouldContainValue(Object actual, Object value)
Creates a new
.ShouldContainValue
static ErrorMessageFactory
ShouldContainValue. shouldContainValue(Object actual, Condition<?> valueCondition)
Creates a new
.ShouldContainValue
static <V> ErrorMessageFactory
ShouldContainValues. shouldContainValues(Object actual, Set<V> values)
Creates a new
.ShouldContainValues
static ErrorMessageFactory
ShouldEndWith. shouldEndWith(Object actual, Object expected)
Creates a new
.ShouldEndWith
static ErrorMessageFactory
ShouldEndWith. shouldEndWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldEndWith
static ErrorMessageFactory
ShouldEndWithPath. shouldEndWith(Path actual, Path other)
static ErrorMessageFactory
ShouldExist. shouldExist(File actual)
Creates a new
.ShouldExist
static ErrorMessageFactory
ShouldExist. shouldExist(Path actual)
static ErrorMessageFactory
ShouldExist. shouldExistNoFollowLinks(Path actual)
static ErrorMessageFactory
ShouldNotExist. shouldExistNoFollowLinks(Path actual)
static <T> ErrorMessageFactory
ShouldHave. shouldHave(T actual, Condition<? super T> condition)
Creates a new
.ShouldHave
static ErrorMessageFactory
ShouldHaveAnnotations. shouldHaveAnnotations(Class<?> actual, Collection<Class<? extends Annotation>> expected, Collection<Class<? extends Annotation>> missing)
Creates a new
.ShouldHaveAnnotations
static <T> ErrorMessageFactory
ShouldHaveAtIndex. shouldHaveAtIndex(List<? extends T> actual, Condition<? super T> condition, Index index, T found)
Creates a new
.ShouldHaveAtIndex
static ErrorMessageFactory
ShouldHaveBinaryContent. shouldHaveBinaryContent(File actual, BinaryDiffResult diff)
Creates a new
.ShouldHaveBinaryContent
static ErrorMessageFactory
ShouldHaveBinaryContent. shouldHaveBinaryContent(Path actual, BinaryDiffResult diff)
Creates a new
.ShouldHaveBinaryContent
static ErrorMessageFactory
ShouldHaveCause. shouldHaveCause(Throwable actualCause, Throwable expectedCause)
static ErrorMessageFactory
ShouldHaveCauseExactlyInstance. shouldHaveCauseExactlyInstance(Throwable actual, Class<? extends Throwable> expectedCauseType)
Creates a new
.BasicErrorMessageFactory
static ErrorMessageFactory
ShouldHaveCauseInstance. shouldHaveCauseInstance(Throwable actual, Class<? extends Throwable> expectedCauseType)
Creates a new
.BasicErrorMessageFactory
static ErrorMessageFactory
ShouldHaveCauseReference. shouldHaveCauseReference(Throwable actualCause, Throwable expectedCause)
static ErrorMessageFactory
ShouldBeSorted. shouldHaveComparableElementsAccordingToGivenComparator(Object actual, Comparator<?> comparator)
static ErrorMessageFactory
ShouldHaveContent. shouldHaveContent(File actual, Charset charset, List<Delta<String>> diffs)
Creates a new
.ShouldHaveContent
static ErrorMessageFactory
ShouldHaveContent. shouldHaveContent(Path actual, Charset charset, List<Delta<String>> diffs)
Creates a new
.ShouldHaveContent
static ErrorMessageFactory
ShouldHaveDateField. shouldHaveDateField(Date actual, String fieldDescription, int fieldValue)
Creates a new
.ShouldHaveDateField
static ErrorMessageFactory
ShouldHaveFields. shouldHaveDeclaredFields(Class<?> actual, Set<String> expected, Set<String> missing)
Creates a new
.ShouldHaveFields
static ErrorMessageFactory
ShouldHaveDigest. shouldHaveDigest(File actualSource, DigestDiff diff)
static ErrorMessageFactory
ShouldHaveDigest. shouldHaveDigest(InputStream actualSource, DigestDiff diff)
static ErrorMessageFactory
ShouldHaveDigest. shouldHaveDigest(Path actualSource, DigestDiff diff)
static ErrorMessageFactory
ShouldHaveFields. shouldHaveFields(Class<?> actual, Set<String> expected, Set<String> missing)
Creates a new
.ShouldHaveFields
static ErrorMessageFactory
ShouldHaveLineCount. shouldHaveLinesCount(Object actual, int actualSize, int expectedSize)
Creates a new
.ShouldHaveLineCount
static ErrorMessageFactory
ShouldHaveMessage. shouldHaveMessage(Throwable actual, String expectedMessage)
Creates a new
.ShouldHaveMessage
static ErrorMessageFactory
ShouldHaveMessageFindingMatchRegex. shouldHaveMessageFindingMatchRegex(Throwable actual, CharSequence regex)
static ErrorMessageFactory
ShouldHaveMessageMatchingRegex. shouldHaveMessageMatchingRegex(Throwable actual, CharSequence regex)
static ErrorMessageFactory
ShouldHaveMethods. shouldHaveMethods(Class<?> actual, boolean declared, SortedSet<String> expected, String modifier, Map<String,String> nonMatching)
static ErrorMessageFactory
ShouldHaveMethods. shouldHaveMethods(Class<?> actual, boolean declared, SortedSet<String> expected, SortedSet<String> missing)
Creates a new
.ShouldHaveMethods
static ErrorMessageFactory
ShouldBeSorted. shouldHaveMutuallyComparableElements(Object actual)
static ErrorMessageFactory
ShouldHaveNext. shouldHaveNext()
Creates a new
.ShouldHaveNext
static ErrorMessageFactory
ShouldHaveNoCause. shouldHaveNoCause(Throwable actual)
Creates a new
.ShouldHaveNoCause
static ErrorMessageFactory
ShouldHaveNoFields. shouldHaveNoDeclaredFields(Class<?> actual, Set<String> fields)
static ErrorMessageFactory
ShouldHaveNoFields. shouldHaveNoPublicFields(Class<?> actual, Set<String> fields)
static ErrorMessageFactory
ShouldHaveNoSuppressedExceptions. shouldHaveNoSuppressedExceptions(Object actual)
Creates a new
.ShouldHaveNoSuppressedExceptions
static ErrorMessageFactory
ShouldHavePropertyOrField. shouldHavePropertyOrField(Object actual, String name)
Creates a new
.ShouldHavePropertyOrField
static ErrorMessageFactory
ShouldHavePropertyOrFieldWithValue. shouldHavePropertyOrFieldWithValue(Object actual, String name, Object expectedValue, Object actualValue)
Creates a new
.ShouldHavePropertyOrFieldWithValue
static <REF> ErrorMessageFactory
ShouldHaveReference. shouldHaveReference(Object actual, REF actualReference, REF expectedReference)
static ErrorMessageFactory
ShouldHaveRootCause. shouldHaveRootCause(Throwable actual, Throwable actualCause, Throwable expectedCause)
static ErrorMessageFactory
ShouldHaveRootCauseExactlyInstance. shouldHaveRootCauseExactlyInstance(Throwable actual, Class<? extends Throwable> expectedCauseType)
Creates a new
.BasicErrorMessageFactory
static ErrorMessageFactory
ShouldHaveRootCauseInstance. shouldHaveRootCauseInstance(Throwable actual, Class<? extends Throwable> expectedCauseType)
Creates a new
.BasicErrorMessageFactory
static ErrorMessageFactory
ShouldHaveRootCause. shouldHaveRootCauseWithMessage(Throwable actual, Throwable actualCause, String expectedMessage)
static ErrorMessageFactory
ShouldHaveSameClass. shouldHaveSameClass(Object actual, Object other)
Creates a new
.ShouldHaveSameClass
static ErrorMessageFactory
ShouldHaveSameContent. shouldHaveSameContent(File actual, File expected, List<Delta<String>> diffs)
Creates a new
.ShouldHaveSameContent
static ErrorMessageFactory
ShouldHaveSameContent. shouldHaveSameContent(InputStream actual, InputStream expected, List<Delta<String>> diffs)
Creates a new
.ShouldHaveSameContent
static ErrorMessageFactory
ShouldHaveSameContent. shouldHaveSameContent(InputStream actual, String expected, List<Delta<String>> diffs)
Creates a new
.ShouldHaveSameContent
static ErrorMessageFactory
ShouldHaveSameContent. shouldHaveSameContent(Path actual, Path expected, List<Delta<String>> diffs)
Creates a new
.ShouldHaveSameContent
static ErrorMessageFactory
ShouldHaveSameHashCode. shouldHaveSameHashCode(Object actual, Object other)
static ErrorMessageFactory
ShouldHaveSameHourAs. shouldHaveSameHourAs(Temporal actual, Temporal other)
Creates a new
.ShouldHaveSameHourAs
static ErrorMessageFactory
ShouldHaveSameSizeAs. shouldHaveSameSizeAs(Object actual, Object expected, Object actualSize, Object expectedSize)
Creates a new
.ShouldHaveSameSizeAs
static ErrorMessageFactory
ShouldHaveSameTime. shouldHaveSameTime(Date actual, Date expected)
Creates a new
.ShouldHaveSameTime
static ErrorMessageFactory
ShouldHaveSize. shouldHaveSize(File actual, long expectedSize)
Creates a new
for file size.ShouldHaveSize
static ErrorMessageFactory
ShouldHaveSize. shouldHaveSize(Object actual, int actualSize, int expectedSize)
Creates a new
.ShouldHaveSize
static ErrorMessageFactory
ShouldHaveSizeBetween. shouldHaveSizeBetween(Object actual, int actualSize, int lowerBoundary, int higherBoundary)
Creates a new
.ShouldHaveSizeBetween
static ErrorMessageFactory
ShouldHaveSizeGreaterThan. shouldHaveSizeGreaterThan(Object actual, int actualSize, int expectedMinSize)
Creates a new
.ShouldHaveSizeGreaterThan
static ErrorMessageFactory
ShouldHaveSizeGreaterThanOrEqualTo. shouldHaveSizeGreaterThanOrEqualTo(Object actual, int actualSize, int expectedMinSize)
Creates a new
.ShouldHaveSizeGreaterThanOrEqualTo
static ErrorMessageFactory
ShouldHaveSizeLessThan. shouldHaveSizeLessThan(Object actual, int actualSize, int expectedMaxSize)
Creates a new
.ShouldHaveSizeLessThan
static ErrorMessageFactory
ShouldHaveSizeLessThanOrEqualTo. shouldHaveSizeLessThanOrEqualTo(Object actual, int actualSize, int expectedMaxSize)
Creates a new
.ShouldHaveSizeLessThanOrEqualTo
static ErrorMessageFactory
ShouldHaveStamp. shouldHaveStamp(AtomicStampedReference<?> actual, int expectedStamp)
static ErrorMessageFactory
ShouldHaveSuppressedException. shouldHaveSuppressedException(Throwable actual, Throwable expectedSuppressedException)
Creates a new
.ShouldHaveSuppressedException
static ErrorMessageFactory
ShouldHaveTime. shouldHaveTime(Date actual, long expectedTimestamp)
Creates a new
.ShouldHaveTime
static ErrorMessageFactory
ShouldHaveToString. shouldHaveToString(Object actual, String expectedToString)
static <REF> ErrorMessageFactory
ShouldHaveValue. shouldHaveValue(Object actual, REF expectedValue)
static <REF> ErrorMessageFactory
ShouldHaveValue. shouldHaveValue(Object actual, REF actualValue, REF expectedValue, Object objectToUpdate)
static <T> ErrorMessageFactory
ShouldMatch. shouldMatch(T actual, Predicate<? super T> predicate, PredicateDescription predicateDescription)
Creates a new
.ShouldMatch
static ErrorMessageFactory
ShouldMatchPattern. shouldMatch(CharSequence actual, CharSequence pattern)
Creates a new
.ShouldMatchPattern
static <T> ErrorMessageFactory
ShouldNotAccept. shouldNotAccept(Predicate<? super T> predicate, T value, PredicateDescription description)
Creates a new
.ShouldNotAccept
static <T> ErrorMessageFactory
ShouldNotBe. shouldNotBe(T actual, Condition<? super T> condition)
Creates a new
.ShouldNotBe
static ErrorMessageFactory
ShouldBeAnnotation. shouldNotBeAnnotation(Class<?> actual)
Creates a new
.ShouldBeAnnotation
static ErrorMessageFactory
ShouldNotBeBetween. shouldNotBeBetween(Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)
Creates a new
.ShouldNotBeBetween
static ErrorMessageFactory
ShouldNotBeBetween. shouldNotBeBetween(Date actual, Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotBeBetween
static ErrorMessageFactory
ShouldNotBeBlank. shouldNotBeBlank(CharSequence actual)
Creates a new
.ShouldNotBeBlank
static ErrorMessageFactory
ShouldNotBeEmpty. shouldNotBeEmpty()
Returns the singleton instance of this class.static ErrorMessageFactory
ShouldNotBeEmpty. shouldNotBeEmpty(File actual)
Creates a new
.ShouldNotBeEmpty
static ErrorMessageFactory
ShouldNotBeEqual. shouldNotBeEqual(Object actual, Object other)
Creates a new
.ShouldNotBeEqual
static ErrorMessageFactory
ShouldNotBeEqual. shouldNotBeEqual(Object actual, Object other, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotBeEqual
static <T extends Number>
ErrorMessageFactoryShouldNotBeEqualWithinOffset. shouldNotBeEqual(T actual, T expected, Offset<T> offset, T difference)
Creates a new
.ShouldNotBeEqualWithinOffset
static ErrorMessageFactory
ShouldNotBeEqualIgnoringCase. shouldNotBeEqualIgnoringCase(CharSequence actual, CharSequence expected)
Creates a new
.ShouldNotBeEqualIgnoringCase
static ErrorMessageFactory
ShouldNotBeEqualIgnoringWhitespace. shouldNotBeEqualIgnoringWhitespace(CharSequence actual, CharSequence expected)
Creates a new
.ShouldNotBeEqualIgnoringWhitespace
static ErrorMessageFactory
ShouldNotBeEqualNormalizingWhitespace. shouldNotBeEqualNormalizingWhitespace(CharSequence actual, CharSequence expected)
Creates a new
.ShouldNotBeEqualNormalizingWhitespace
static <T extends Number>
ErrorMessageFactoryShouldNotBeEqualWithinPercentage. shouldNotBeEqualWithinPercentage(T actual, T expected, Percentage percentage, T difference)
Creates a new
.ShouldNotBeEqualWithinPercentage
static ErrorMessageFactory
ShouldNotBeExactlyInstanceOf. shouldNotBeExactlyInstance(Object actual, Class<?> type)
Creates a new
.ShouldNotBeExactlyInstanceOf
static ErrorMessageFactory
ClassModifierShouldBe. shouldNotBeFinal(Class<?> actual)
Creates a newClassModifierShouldBe
.static ErrorMessageFactory
ShouldNotBeIn. shouldNotBeIn(Object actual, Object values)
Creates a new
.ShouldNotBeIn
static ErrorMessageFactory
ShouldNotBeIn. shouldNotBeIn(Object actual, Object values, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotBeIn
static ErrorMessageFactory
ShouldNotBeInstance. shouldNotBeInstance(Object actual, Class<?> type)
Creates a new
.ShouldNotBeInstance
static ErrorMessageFactory
ShouldNotBeInstanceOfAny. shouldNotBeInstanceOfAny(Object actual, Class<?>[] types)
Creates a new
.ShouldNotBeInstanceOfAny
static ErrorMessageFactory
ShouldBeInterface. shouldNotBeInterface(Class<?> actual)
Creates a new
.ShouldBeInterface
static ErrorMessageFactory
ShouldBeMarked. shouldNotBeMarked(AtomicMarkableReference<?> actual)
static ErrorMessageFactory
ShouldNotBeNull. shouldNotBeNull()
Returns the default instance of this class.static ErrorMessageFactory
ShouldNotBeOfClassIn. shouldNotBeOfClassIn(Object actual, Object types)
Creates a new
.ShouldNotBeOfClassIn
static ErrorMessageFactory
ShouldNotBeSame. shouldNotBeSame(Object actual)
Creates a new
.ShouldNotBeSame
static ErrorMessageFactory
ShouldNotContain. shouldNotContain(Object actual, Object expected, Object found)
Creates a new
.ShouldNotContain
static ErrorMessageFactory
ShouldNotContain. shouldNotContain(Object actual, Object expected, Object found, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotContain
static ErrorMessageFactory
ShouldNotContainCharSequence. shouldNotContain(CharSequence actual, CharSequence sequence)
static ErrorMessageFactory
ShouldNotContainCharSequence. shouldNotContain(CharSequence actual, CharSequence[] values, Set<? extends CharSequence> found, ComparisonStrategy comparisonStrategy)
Creates a newShouldNotContainCharSequence
static ErrorMessageFactory
ShouldNotContainCharSequence. shouldNotContain(CharSequence actual, CharSequence sequence, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotContainCharSequence
static ErrorMessageFactory
ShouldNotContainAnyWhitespaces. shouldNotContainAnyWhitespaces(CharSequence actual)
Creates a new
.ShouldNotContainAnyWhitespaces
static ErrorMessageFactory
ShouldNotContainAtIndex. shouldNotContainAtIndex(Object actual, Object expected, Index index)
Creates a new
.ShouldNotContainAtIndex
static ErrorMessageFactory
ShouldNotContainAtIndex. shouldNotContainAtIndex(Object actual, Object expected, Index index, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotContainAtIndex
static ErrorMessageFactory
ShouldNotContainKey. shouldNotContainKey(Object actual, Object key)
Creates a new
.ShouldNotContainKey
static <K> ErrorMessageFactory
ShouldNotContainKeys. shouldNotContainKeys(Object actual, Set<K> keys)
Creates a new
.ShouldNotContainKeys
static ErrorMessageFactory
ShouldNotContainNull. shouldNotContainNull(Object actual)
Creates a new
.ShouldNotContainNull
static ErrorMessageFactory
ShouldNotContainOnlyWhitespaces. shouldNotContainOnlyWhitespaces(CharSequence actual)
Creates a new
.ShouldNotContainOnlyWhitespaces
static ErrorMessageFactory
ShouldNotContainPattern. shouldNotContainPattern(CharSequence actual, CharSequence pattern)
Creates a new
.ShouldNotContainPattern
static ErrorMessageFactory
ShouldNotContainSequence. shouldNotContainSequence(Object actual, Object sequence, int index)
Creates a new
.ShouldNotContainSequence
static ErrorMessageFactory
ShouldNotContainSequence. shouldNotContainSequence(Object actual, Object sequence, int index, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotContainSequence
static ErrorMessageFactory
ShouldNotContainSubsequence. shouldNotContainSubsequence(Object actual, Object subsequence, int index)
Creates a new
.ShouldNotContainSubsequence
static ErrorMessageFactory
ShouldNotContainSubsequence. shouldNotContainSubsequence(Object actual, Object subsequence, ComparisonStrategy comparisonStrategy, int index)
Creates a new
.ShouldNotContainSubsequence
static ErrorMessageFactory
ShouldNotContainValue. shouldNotContainValue(Object actual, Object value)
Creates a new
.ShouldNotContainValue
static ErrorMessageFactory
ShouldNotEndWith. shouldNotEndWith(Object actual, Object expected)
Creates a new
.ShouldNotEndWith
static ErrorMessageFactory
ShouldNotEndWith. shouldNotEndWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotEndWith
static ErrorMessageFactory
ShouldNotExist. shouldNotExist(File actual)
Creates a new
.ShouldNotExist
static ErrorMessageFactory
ShouldNotExist. shouldNotExist(Path actual)
static <T> ErrorMessageFactory
ShouldNotHave. shouldNotHave(T actual, Condition<? super T> condition)
Creates a new
.ShouldNotHave
static ErrorMessageFactory
ShouldNotHaveDuplicates. shouldNotHaveDuplicates(Object actual, Object duplicates)
Creates a new
.ShouldNotHaveDuplicates
static ErrorMessageFactory
ShouldNotHaveDuplicates. shouldNotHaveDuplicates(Object actual, Object duplicates, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotHaveDuplicates
static ErrorMessageFactory
ShouldHaveMethods. shouldNotHaveMethods(Class<?> actual, boolean declared, SortedSet<String> actualMethodsHavingModifier)
static ErrorMessageFactory
ShouldHaveMethods. shouldNotHaveMethods(Class<?> actual, String modifier, boolean declared, SortedSet<String> actualMethodsHavingModifier)
static ErrorMessageFactory
ShouldNotHaveSameClass. shouldNotHaveSameClass(Object actual, Object other)
Creates a new
.ShouldNotHaveSameClass
static ErrorMessageFactory
ShouldNotHaveThrown. shouldNotHaveThrown(Throwable throwable)
static <T> ErrorMessageFactory
ShouldNotMatch. shouldNotMatch(T actual, Predicate<? super T> predicate, PredicateDescription predicateDescription)
Creates a new
.ShouldNotMatch
static ErrorMessageFactory
ShouldNotMatchPattern. shouldNotMatch(CharSequence actual, CharSequence pattern)
Creates a new
.ShouldStartWith
static ErrorMessageFactory
ShouldNotStartWith. shouldNotStartWith(Object actual, Object expected)
Creates a new
.ShouldNotStartWith
static ErrorMessageFactory
ShouldNotStartWith. shouldNotStartWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldNotStartWith
static ErrorMessageFactory
ShouldOnlyHaveFields. shouldOnlyHaveDeclaredFields(Class<?> actual, Collection<String> expected, Collection<String> notFound, Collection<String> notExpected)
Creates a new
.ShouldOnlyHaveFields
static ErrorMessageFactory
ShouldOnlyHaveFields. shouldOnlyHaveFields(Class<?> actual, Collection<String> expected, Collection<String> notFound, Collection<String> notExpected)
Creates a new
.ShouldOnlyHaveFields
static <T> ErrorMessageFactory
ShouldSatisfy. shouldSatisfy(T actual, Condition<? super T> condition)
static ErrorMessageFactory
ShouldStartWith. shouldStartWith(Object actual, Object expected)
Creates a new
.ShouldStartWith
static ErrorMessageFactory
ShouldStartWith. shouldStartWith(Object actual, Object expected, ComparisonStrategy comparisonStrategy)
Creates a new
.ShouldStartWith
static ErrorMessageFactory
ShouldStartWithPath. shouldStartWith(Path actual, Path other)
static ErrorMessageFactory
ZippedElementsShouldSatisfy. zippedElementsShouldSatisfy(AssertionInfo info, Iterable<?> actual, Iterable<?> other, List<ZippedElementsShouldSatisfy.ZipSatisfyError> zipSatisfyErrors)
-
Uses of ErrorMessageFactory in org.assertj.core.error.future
Classes in org.assertj.core.error.future that implement ErrorMessageFactory Modifier and Type Class Description class
ShouldBeCancelled
class
ShouldBeCompleted
class
ShouldBeCompletedExceptionally
class
ShouldBeDone
class
ShouldHaveFailed
class
ShouldNotBeCancelled
class
ShouldNotBeCompleted
class
ShouldNotBeCompletedExceptionally
class
ShouldNotBeDone
class
ShouldNotHaveFailed
-
Uses of ErrorMessageFactory in org.assertj.core.error.uri
Classes in org.assertj.core.error.uri that implement ErrorMessageFactory Modifier and Type Class Description class
ShouldHaveAnchor
class
ShouldHaveAuthority
class
ShouldHaveFragment
class
ShouldHaveHost
class
ShouldHaveParameter
class
ShouldHavePath
class
ShouldHavePort
class
ShouldHaveProtocol
class
ShouldHaveQuery
class
ShouldHaveScheme
class
ShouldHaveUserInfo
Methods in org.assertj.core.error.uri that return ErrorMessageFactory Modifier and Type Method Description static ErrorMessageFactory
ShouldHaveAnchor. shouldHaveAnchor(URL actual, String expectedAnchor)
static ErrorMessageFactory
ShouldHaveAuthority. shouldHaveAuthority(URI actual, String expectedAuthority)
static ErrorMessageFactory
ShouldHaveAuthority. shouldHaveAuthority(URL actual, String expectedAuthority)
static ErrorMessageFactory
ShouldHaveFragment. shouldHaveFragment(URI actual, String expectedFragment)
static ErrorMessageFactory
ShouldHaveHost. shouldHaveHost(URI actual, String expectedHost)
static ErrorMessageFactory
ShouldHaveHost. shouldHaveHost(URL actual, String expectedHost)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveNoParameter(Object actual, String name, String unwantedValue, List<String> actualValues)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveNoParameter(Object actual, String name, List<String> actualValues)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveNoParameters(Object actual, Set<String> parameterNames)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveParameter(Object actual, String name)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveParameter(Object actual, String name, String expectedValue)
static ErrorMessageFactory
ShouldHaveParameter. shouldHaveParameter(Object actual, String name, String expectedValue, List<String> actualValues)
static ErrorMessageFactory
ShouldHavePath. shouldHavePath(URI actual, String expectedPath)
static ErrorMessageFactory
ShouldHavePath. shouldHavePath(URL actual, String expectedPath)
static ErrorMessageFactory
ShouldHavePort. shouldHavePort(URI actual, int expectedPort)
static ErrorMessageFactory
ShouldHavePort. shouldHavePort(URL actual, int expectedPort)
static ErrorMessageFactory
ShouldHaveProtocol. shouldHaveProtocol(URL actual, String expectedProtocol)
static ErrorMessageFactory
ShouldHaveQuery. shouldHaveQuery(URI actual, String expectedQuery)
static ErrorMessageFactory
ShouldHaveQuery. shouldHaveQuery(URL actual, String expectedQuery)
static ErrorMessageFactory
ShouldHaveScheme. shouldHaveScheme(URI actual, String expectedScheme)
static ErrorMessageFactory
ShouldHaveUserInfo. shouldHaveUserInfo(URI actual, String expectedUserInfo)
static ErrorMessageFactory
ShouldHaveUserInfo. shouldHaveUserInfo(URL actual, String expectedUserInfo)
-
Uses of ErrorMessageFactory in org.assertj.core.internal
Methods in org.assertj.core.internal with parameters of type ErrorMessageFactory Modifier and Type Method Description protected String
Failures. assertionErrorMessage(AssertionInfo info, ErrorMessageFactory messageFactory)
AssertionError
Failures. failure(AssertionInfo info, ErrorMessageFactory messageFactory)
Creates a
following this pattern: creates aAssertionError
usingAssertionError
as the error message if such value is notAssertionInfo.overridingErrorMessage()
null
, or uses the given
to create the detail message of theErrorMessageFactory
, prepending the value ofAssertionError
to the error messageAssertionInfo.description()
AssertionError
Failures. failure(AssertionInfo info, ErrorMessageFactory messageFactory, Object actual, Object expected)
-