Package | Description |
---|---|
org.assertj.core.api | |
org.assertj.core.error | |
org.assertj.core.error.future | |
org.assertj.core.error.uri | |
org.assertj.core.internal |
Modifier and Type | Method and Description |
---|---|
protected void |
AbstractAssert.throwAssertionError(ErrorMessageFactory errorMessageFactory)
Utility method to throw an
AssertionError given a BasicErrorMessageFactory . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractShouldHaveTextContent
Base class for text content error.
|
class |
BasicErrorMessageFactory
A factory of error messages typically shown when an assertion fails.
|
class |
ConditionAndGroupGenericParameterTypeShouldBeTheSame
Creates an error message indicating that an assertion that verifies type of elements of group and
Condition 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 a
Condition
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 a
Condition 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 a
Condition 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 a
Condition 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 a
Condition
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 a
Condition 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 a
Condition 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 a
Condition 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 a
Condition 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 a
Condition
A group of elements can be a collection, an array. |
class |
NoElementsShouldMatch |
class |
OptionalDoubleShouldHaveValueCloseTo
Build error message when an
OptionalDouble should have a specific value close to an offset. |
class |
OptionalShouldBeEmpty
Build error message when an
Optional should be empty. |
class |
OptionalShouldBePresent
Build error message when a value should be present in an
Optional . |
class |
OptionalShouldContain
Build error message when an
Optional , OptionalDouble , OptionalInt or OptionalLong
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. |
class |
ShouldBe
Creates an error message indicating that an assertion that verifies that a value satisfies a
failed. |
class |
ShouldBeAbsolutePath
|
class |
ShouldBeAfter
Creates an error message indicating that an assertion that verifies that a
Date is after another one failed. |
class |
ShouldBeAfterOrEqualsTo
Creates an error message indicating that an assertion that verifies that a
Date is after or equals to another
one
failed. |
class |
ShouldBeAfterYear
Creates an error message indicating that an assertion that verifies that a
Date 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. |
class |
ShouldBeBefore
Creates an error message indicating that an assertion that verifies that a
Object is before another one failed. |
class |
ShouldBeBeforeOrEqualsTo
Creates an error message indicating that an assertion that verifies that a
Object is before or equals to another one
failed. |
class |
ShouldBeBeforeYear
Creates an error message indicating that an assertion that verifies that a
Date is before given year failed. |
class |
ShouldBeBetween
Creates an error message indicating that an assertion that verifies that a
Date is between start - end dates (inclusive
or not) failed. |
class |
ShouldBeCanonicalPath
Creates an error message indicating that an assertion that verifies that a
Path is canonical has failed. |
class |
ShouldBeCloseTo
Creates an error message indicating that an assertion that verifies that a
Date 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 |
ShouldBeEqualByComparingFieldByFieldRecursively |
class |
ShouldBeEqualByComparingOnlyGivenFields
Creates an
indicating that an assertion that verifies that two objects are
lenient equal by accepting fields failed. |
class |
ShouldBeEqualIgnoringCase
Creates an error message indicating that an assertion that verifies that two
CharSequence s are equal, ignoring case
considerations, failed. |
class |
ShouldBeEqualIgnoringHours
Creates an error message indicating that an assertion that verifies that two
ZonedDateTime have same year,
month, and day fields failed. |
class |
ShouldBeEqualIgnoringMinutes
Creates an error message indicating that an assertion that verifies that two
ZonedDateTime have same year,
month, day and hour fields failed. |
class |
ShouldBeEqualIgnoringNanos
Creates an error message indicating that an assertion that verifies that :
two
ZonedDateTime , LocalDateTime have same year, month, day, hour, minute and second failed.
two LocalTime have same hour, minute and second failed.
two OffsetTime have same hour, minute and second failed.
|
class |
ShouldBeEqualIgnoringSeconds
Creates an error message indicating that an assertion that verifies that two
ZonedDateTime have same year,
month, day, hour and minute failed. |
class |
ShouldBeEqualIgnoringTimezone
Creates an error message indicating that an assertion that verifies that two
OffsetTime have same
time fields except the timezone. |
class |
ShouldBeEqualIgnoringWhitespace
Creates an error message indicating that an assertion that verifies that two
CharSequence s are equal, ignoring whitespace
differences, failed. |
class |
ShouldBeEqualToIgnoringFields
Creates an
indicating that an assertion that verifies that two objects are lenient equal by
ignoring fields failed. |
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. |
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. |
class |
ShouldBeFile
Creates an error message indicating that an assertion that verifies that a
is an existing file
failed. |
class |
ShouldBeFinal
Creates an error message indicating that an assertion that verifies that a class is (or is not) final.
|
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 a
Date 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 a
Date 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 a
Date is in same hour window as
another one failed. |
class |
ShouldBeInSameMinute
Creates an error message indicating that an assertion that verifies that a
Date 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 a
Date is in minute window as
another one failed. |
class |
ShouldBeInSameMonth
Creates an error message indicating that an assertion that verifies that a
Date is in same year and month as another
one failed. |
class |
ShouldBeInSameSecond
Creates an error message indicating that an assertion that verifies that a
Date 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 a
Date is in second window as
another one failed. |
class |
ShouldBeInSameYear
Creates an error message indicating that an assertion that verifies that a
Date 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 a
Date is in the future failed. |
class |
ShouldBeInThePast
Creates an error message indicating that an assertion that verifies that a
Date 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 |
ShouldBeNormalized
Assertion error message delivered when a
Path is not normalized |
class |
ShouldBeNullOrEmpty
Creates an error message indicating that an assertion that verifies a group of elements is
null 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 a
Path 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 an
Iterable is a subset of an other set
Iterable failed. |
class |
ShouldBeSubstring |
class |
ShouldBeSymbolicLink
Creates an error message indicating that an assertion that verifies that a
Path is a regular file has failed. |
class |
ShouldBeToday
Creates an error message indicating that an assertion that verifies that a
Date 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. |
class |
ShouldContain
Creates an error message indicating that an assertion that verifies a group of elements contains a given set of values failed.
|
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 a
CharSequence contains another
CharSequence failed. |
class |
ShouldContainCharSequenceOnlyOnce
Creates an error message indicating that an assertion that verifies that a
CharSequence contains another CharSequence only
once failed. |
class |
ShouldContainCharSequenceSequence
Creates an error message indicating that an assertion that verifies that a
CharSequence contains a sequence of
several CharSequence s in order failed. |
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 |
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 |
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 |
ShouldContainPattern
Creates an error message indicating that an assertion that verifies that a
CharSequence 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 |
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 |
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. |
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. |
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 a
Throwable have a cause
exactly instance of a certain type. |
class |
ShouldHaveCauseInstance
Creates an error message indicating that an assertion that verifies that a
Throwable have a cause instance of
a certain type. |
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 a
Date has a year, month, day, ... |
class |
ShouldHaveExtension
Creates an error message indicating that a
File 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 a
Throwable have certain message failed. |
class |
ShouldHaveMessageMatchingRegex
Creates an error message indicating that an assertion that verifies that a
CharSequence matches given regular
expression. |
class |
ShouldHaveName
Creates an error message indicating that a
File should have name. |
class |
ShouldHaveNoCause
Creates an error message indicating that an assertion that verifies that an
Throwable has no cause failed. |
class |
ShouldHaveNoNullFields
Creates an
indicating that an assertion that verifies that an object
has no null fields failed. |
class |
ShouldHaveNoParent
Creates an error message when a
File should not have a parent. |
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 a
File 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 have field/property with value.
|
class |
ShouldHaveRootCauseExactlyInstance
Creates an error message indicating that an assertion that verifies that a
Throwable have a root cause
exactly instance of a certain type. |
class |
ShouldHaveRootCauseInstance
Creates an error message indicating that an assertion that verifies that a
Throwable 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 |
ShouldHaveSameHourAs
Creates an error message indicating that an assertion that verifies that two
ZonedDateTime 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 |
ShouldHaveTime
Creates an error message indicating that an assertion that verifies that a date have a certain timestamp.
|
class |
ShouldHaveToString |
class |
ShouldMatch
Creates an error message indicating that an assertion that verifies that a value satisfies a
failed. |
class |
ShouldMatchPattern
Creates an error message indicating that an assertion that verifies that a
CharSequence matches a pattern failed. |
class |
ShouldNotAccept
Creates an error message indicating that an assertion that verifies that
not accepting a value failed. |
class |
ShouldNotBe
Creates an error message indicating that an assertion that verifies that a value does not satisfy a
failed. |
class |
ShouldNotBeBetween
Creates an error message indicating that an assertion that verifies that a
Date is not between start - end dates
(inclusive or not) failed. |
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 two
CharSequence s are not equal,
ignoring case
considerations, failed. |
class |
ShouldNotBeEqualIgnoringWhitespace
Creates an error message indicating that an assertion that verifies that two
CharSequence s are not equal,
ignoring whitespace differences, 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 not
null 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 |
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 a
CharSequence does not contain another
CharSequence 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 |
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. |
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 |
ShouldNotMatch
Creates an error message indicating that an assertion that verifies that a value not satisfying a
failed. |
class |
ShouldNotMatchPattern
Creates an error message indicating that an assertion that verifies that a
CharSequence 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 |
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 |
Modifier and Type | Method and Description |
---|---|
static ErrorMessageFactory |
ShouldContainExactly.elementsDifferAtIndex(Object actualElement,
Object expectedElement,
int indexOfDifferentElements)
Creates a new
ShouldContainExactly for the case where actual and expected have the same
elements in different order. |
static ErrorMessageFactory |
ShouldContainExactly.elementsDifferAtIndex(Object actualElement,
Object expectedElement,
int indexOfDifferentElements,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldContainExactly for the case where actual and expected have the same
elements in different order according to the given 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 <E> ErrorMessageFactory |
ElementsShouldHaveExactly.elementsShouldHaveExactly(Object actual,
int times,
Condition<?> condition)
Creates a new
ElementsShouldHaveExactly . |
static <T> ErrorMessageFactory |
ElementsShouldMatch.elementsShouldMatch(Object actual,
T elementNotMatchingPredicate,
Predicate<? super T> predicate) |
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 <T> ErrorMessageFactory |
NoElementsShouldMatch.noElementsShouldMatch(Object actual,
T elementMatchingPredicate) |
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
. |
static ErrorMessageFactory |
ShouldBeAbsolutePath.shouldBeAbsolutePath(Path actual) |
static ErrorMessageFactory |
ShouldBeAfter.shouldBeAfter(Date actual,
int year)
Creates a new
ShouldBeAfter . |
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 |
ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo(Object actual,
Object other)
Creates a new
ShouldBeAfterOrEqualsTo . |
static ErrorMessageFactory |
ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo(Object actual,
Object other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeAfterOrEqualsTo . |
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
. |
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 |
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 |
ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo(Object actual,
Object other)
Creates a new
ShouldBeBeforeOrEqualsTo . |
static ErrorMessageFactory |
ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo(Object actual,
Object other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeBeforeOrEqualsTo . |
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>> |
ShouldBeBetween.shouldBeBetween(T actual,
T start,
T end,
boolean inclusiveStart,
boolean inclusiveEnd)
Creates a new
ShouldBeBetween . |
static <T extends Comparable<? super T>> |
ShouldBeBetween.shouldBeBetween(T actual,
T start,
T end,
boolean inclusiveStart,
boolean inclusiveEnd,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeBetween . |
static ErrorMessageFactory |
ShouldBeCanonicalPath.shouldBeCanonicalPath(Path actual) |
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(Object actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringCase.shouldBeEqual(CharSequence actual,
CharSequence expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualWithTimePrecision.shouldBeEqual(Date actual,
Date expected,
TimeUnit precision)
Creates a new
. |
static <T extends Number> |
ShouldBeEqualWithinOffset.shouldBeEqual(T actual,
T expected,
Offset<T> offset,
T difference)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualByComparingFieldByFieldRecursively.shouldBeEqualByComparingFieldByFieldRecursive(Object actual,
Object other,
List<DeepDifference.Difference> differences) |
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
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes(LocalTime actual,
LocalTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes(Object actual,
Object other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes(OffsetTime actual,
OffsetTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos(LocalTime actual,
LocalTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos(Object actual,
Object other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos(OffsetTime actual,
OffsetTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds(LocalTime actual,
LocalTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds(Object actual,
Object other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds(OffsetTime actual,
OffsetTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringTimezone.shouldBeEqualIgnoringTimezone(OffsetDateTime actual,
OffsetDateTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringTimezone.shouldBeEqualIgnoringTimezone(OffsetTime actual,
OffsetTime other)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeEqualIgnoringWhitespace.shouldBeEqualIgnoringWhitespace(CharSequence actual,
CharSequence expected)
Creates a new
. |
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> |
ShouldBeEqualWithinPercentage.shouldBeEqualWithinPercentage(T actual,
T expected,
Percentage percentage,
T difference)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeExactlyInstanceOf.shouldBeExactlyInstance(Object actual,
Class<?> type)
Creates a new
ShouldBeExactlyInstanceOf . |
static ErrorMessageFactory |
ShouldBeExecutable.shouldBeExecutable(File actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeExecutable.shouldBeExecutable(Path actual) |
static ErrorMessageFactory |
ShouldBeFile.shouldBeFile(File actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeFinal.shouldBeFinal(Class<?> actual)
Creates a new
ShouldBeFinal . |
static <T extends Comparable<? super T>> |
ShouldBeGreater.shouldBeGreater(T actual,
T other)
Creates a new
ShouldBeGreater . |
static <T extends Comparable<? super T>> |
ShouldBeGreater.shouldBeGreater(T actual,
T other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeGreater . |
static <T extends Comparable<T>> |
ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(T actual,
T other)
Creates a new
ShouldBeGreaterOrEqual . |
static <T extends Comparable<? super T>> |
ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(T actual,
T other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeGreaterOrEqual . |
static ErrorMessageFactory |
ShouldBeIn.shouldBeIn(Object actual,
Object values)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeIn.shouldBeIn(Object actual,
Object values,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
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
ShouldBeInstance when object we want to check type is null. |
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>> |
ShouldBeLess.shouldBeLess(T actual,
T other)
Creates a new
ShouldBeLess . |
static <T extends Comparable<? super T>> |
ShouldBeLess.shouldBeLess(T actual,
T other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeLess . |
static <T extends Comparable<? super T>> |
ShouldBeLessOrEqual.shouldBeLessOrEqual(T actual,
T other)
Creates a new
ShouldBeLessOrEqual . |
static <T extends Comparable<? super T>> |
ShouldBeLessOrEqual.shouldBeLessOrEqual(T actual,
T other,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeLessOrEqual . |
static ErrorMessageFactory |
ShouldBeLowerCase.shouldBeLowerCase(Character actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeNormalized.shouldBeNormalized(Path actual) |
static ErrorMessageFactory |
ShouldBeNullOrEmpty.shouldBeNullOrEmpty(Object actual)
Creates a new instance of
. |
static ErrorMessageFactory |
ShouldBeOfClassIn.shouldBeOfClassIn(Object actual,
Object types)
Creates a new
ShouldBeOfClassIn . |
static ErrorMessageFactory |
ShouldBeReadable.shouldBeReadable(File actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeReadable.shouldBeReadable(Path actual) |
static ErrorMessageFactory |
ShouldBeRegularFile.shouldBeRegularFile(Path actual) |
static ErrorMessageFactory |
ShouldBeRelativePath.shouldBeRelativePath(File actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeRelativePath.shouldBeRelativePath(Path actual) |
static ErrorMessageFactory |
ShouldBeSame.shouldBeSame(Object actual,
Object expected)
Creates a new
. |
static ErrorMessageFactory |
ConditionAndGroupGenericParameterTypeShouldBeTheSame.shouldBeSameGenericBetweenIterableAndCondition(Object actual,
Condition<?> condition)
Creates a new
ConditionAndGroupGenericParameterTypeShouldBeTheSame |
static ErrorMessageFactory |
ShouldBeSorted.shouldBeSorted(int i,
Object group)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeSorted.shouldBeSortedAccordingToGivenComparator(int i,
Object group,
Comparator<?> comparator) |
static ErrorMessageFactory |
ShouldBeSubsetOf.shouldBeSubsetOf(Object actual,
Object values,
Iterable<?> unexpected)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeSubsetOf.shouldBeSubsetOf(Object actual,
Object values,
Iterable<?> unexpected,
ComparisonStrategy comparisonStrategy)
Creates a new
|
static ErrorMessageFactory |
ShouldBeSubstring.shouldBeSubstring(CharSequence actual,
CharSequence expected,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeSymbolicLink.shouldBeSymbolicLink(Path actual) |
static ErrorMessageFactory |
ShouldBeToday.shouldBeToday(Date actual)
Creates a new
ShouldBeToday . |
static ErrorMessageFactory |
ShouldBeToday.shouldBeToday(Date actual,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldBeToday . |
static ErrorMessageFactory |
ShouldBeToday.shouldBeToday(LocalDate actual)
Creates a new
ShouldBeToday . |
static ErrorMessageFactory |
ShouldBeUpperCase.shouldBeUpperCase(Character actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeWritable.shouldBeWritable(File actual)
Creates a new
. |
static ErrorMessageFactory |
ShouldBeWritable.shouldBeWritable(Path actual) |
static ErrorMessageFactory |
ShouldContainCharSequence.shouldContain(CharSequence actual,
CharSequence sequence)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequence.shouldContain(CharSequence actual,
CharSequence[] strings,
Set<? extends CharSequence> notFound)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequence.shouldContain(CharSequence actual,
CharSequence[] strings,
Set<? extends CharSequence> notFound,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequence.shouldContain(CharSequence actual,
CharSequence sequence,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
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 |
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 ErrorMessageFactory |
ShouldContainExactly.shouldContainExactly(Object actual,
Object expected,
Object notFound,
Iterable<?> notExpected)
Creates a new
ShouldContainExactly . |
static ErrorMessageFactory |
ShouldContainExactly.shouldContainExactly(Object actual,
Object expected,
Object notFound,
Iterable<?> notExpected,
ComparisonStrategy comparisonStrategy)
Creates a new
ShouldContainExactly . |
static ErrorMessageFactory |
ShouldContainExactly.shouldContainExactly(Object actual,
Object expected,
Object notFound,
Object notExpected)
Creates a new
ShouldContainExactly . |
static ErrorMessageFactory |
ShouldContainExactly.shouldContainExactly(Object actual,
Object expected,
Object notFound,
Object 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
. |
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 |
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 |
ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce(CharSequence actual,
CharSequence sequence,
int occurences)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequenceOnlyOnce.shouldContainOnlyOnce(CharSequence actual,
CharSequence sequence,
int occurences,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainPattern.shouldContainPattern(CharSequence actual,
CharSequence pattern)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequenceSequence.shouldContainSequence(CharSequence actual,
CharSequence[] strings,
int firstBadOrderIndex)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainCharSequenceSequence.shouldContainSequence(CharSequence actual,
CharSequence[] strings,
int badOrderIndex,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainSequence.shouldContainSequence(Object actual,
Object sequence)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainSequence.shouldContainSequence(Object actual,
Object sequence,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
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
. |
static ErrorMessageFactory |
ShouldContainSubsequence.shouldContainSubsequence(Object actual,
Object subsequence,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainValue.shouldContainValue(Object actual,
Object value)
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
. |
static ErrorMessageFactory |
ShouldEndWith.shouldEndWith(Object actual,
Object expected,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldEndWithPath.shouldEndWith(Path actual,
Path other) |
static ErrorMessageFactory |
ShouldExist.shouldExist(File actual)
Creates a new
. |
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
. |
static ErrorMessageFactory |
ShouldHaveBinaryContent.shouldHaveBinaryContent(Path actual,
BinaryDiffResult diff)
Creates a new
. |
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 |
ShouldBeSorted.shouldHaveComparableElementsAccordingToGivenComparator(Object actual,
Comparator<?> comparator) |
static ErrorMessageFactory |
ShouldHaveContent.shouldHaveContent(File actual,
Charset charset,
List<Delta<String>> diffs)
Creates a new
. |
static ErrorMessageFactory |
ShouldHaveContent.shouldHaveContent(Path actual,
Charset charset,
List<Delta<String>> diffs)
Creates a new
. |
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 |
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 |
ShouldHaveMessageMatchingRegex.shouldHaveMessageMatchingRegex(Throwable actual,
CharSequence regex) |
static ErrorMessageFactory |
ShouldBeSorted.shouldHaveMutuallyComparableElements(Object actual) |
static ErrorMessageFactory |
ShouldHaveNoCause.shouldHaveNoCause(Throwable actual)
Creates a new
ShouldHaveNoCause . |
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 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 |
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
. |
static ErrorMessageFactory |
ShouldHaveSameContent.shouldHaveSameContent(InputStream actual,
InputStream expected,
List<Delta<String>> diffs)
Creates a new
. |
static ErrorMessageFactory |
ShouldHaveSameContent.shouldHaveSameContent(Path actual,
Path expected,
List<Delta<String>> diffs)
Creates a new
. |
static ErrorMessageFactory |
ShouldHaveSameHourAs.shouldHaveSameHourAs(Temporal actual,
Temporal other)
Creates a new
. |
static ErrorMessageFactory |
ShouldContainExactly.shouldHaveSameSize(Object actual,
Object expected,
int actualSize,
int expectedSize,
ComparisonStrategy comparisonStrategy) |
static ErrorMessageFactory |
ShouldHaveSameSizeAs.shouldHaveSameSizeAs(Object actual,
Object actualSize,
Object expectedSize)
Creates a new
ShouldHaveSameSizeAs . |
static ErrorMessageFactory |
ShouldHaveSameTime.shouldHaveSameTime(Date actual,
Date expected)
Creates a new
ShouldHaveSameTime . |
static ErrorMessageFactory |
ShouldHaveSize.shouldHaveSize(Object actual,
int actualSize,
int expectedSize)
Creates a new
ShouldHaveSize . |
static ErrorMessageFactory |
ShouldHaveTime.shouldHaveTime(Date actual,
long expectedTimestamp)
Creates a new
ShouldHaveTime . |
static ErrorMessageFactory |
ShouldHaveToString.shouldHaveToString(Object actual,
String expectedToString) |
static ErrorMessageFactory |
ShouldMatchPattern.shouldMatch(CharSequence actual,
CharSequence pattern)
Creates a new
. |
static <T> ErrorMessageFactory |
ShouldMatch.shouldMatch(T actual,
Predicate<? super T> predicate,
PredicateDescription predicateDescription)
Creates a new
ShouldMatch . |
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 |
ShouldNotBeEmpty.shouldNotBeEmpty()
Returns the singleton instance of this class.
|
static ErrorMessageFactory |
ShouldNotBeEqual.shouldNotBeEqual(Object actual,
Object other)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotBeEqual.shouldNotBeEqual(Object actual,
Object other,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotBeEqualIgnoringCase.shouldNotBeEqualIgnoringCase(CharSequence actual,
CharSequence expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotBeEqualIgnoringWhitespace.shouldNotBeEqualIgnoringWhitespace(CharSequence actual,
CharSequence expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotBeExactlyInstanceOf.shouldNotBeExactlyInstance(Object actual,
Class<?> type)
Creates a new
ShouldNotBeExactlyInstanceOf . |
static ErrorMessageFactory |
ShouldBeFinal.shouldNotBeFinal(Class<?> actual)
Creates a new
ShouldBeFinal . |
static ErrorMessageFactory |
ShouldNotBeIn.shouldNotBeIn(Object actual,
Object values)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotBeIn.shouldNotBeIn(Object actual,
Object values,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
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 |
ShouldNotBeNull.shouldNotBeNull()
Returns the singleton 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
. |
static ErrorMessageFactory |
ShouldNotContainCharSequence.shouldNotContain(CharSequence actual,
CharSequence sequence)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotContainCharSequence.shouldNotContain(CharSequence actual,
CharSequence sequence,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
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 |
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 |
ShouldNotContainValue.shouldNotContainValue(Object actual,
Object value)
Creates a new
ShouldNotContainValue . |
static ErrorMessageFactory |
ShouldNotEndWith.shouldNotEndWith(Object actual,
Object expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotEndWith.shouldNotEndWith(Object actual,
Object expected,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotExist.shouldNotExist(File actual)
Creates a new
. |
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
. |
static ErrorMessageFactory |
ShouldNotHaveDuplicates.shouldNotHaveDuplicates(Object actual,
Object duplicates,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotHaveSameClass.shouldNotHaveSameClass(Object actual,
Object other)
Creates a new
ShouldNotHaveSameClass . |
static ErrorMessageFactory |
ShouldNotMatchPattern.shouldNotMatch(CharSequence actual,
CharSequence pattern)
Creates a new
. |
static <T> ErrorMessageFactory |
ShouldNotMatch.shouldNotMatch(T actual,
Predicate<? super T> predicate,
PredicateDescription predicateDescription)
Creates a new
ShouldNotMatch . |
static ErrorMessageFactory |
ShouldNotStartWith.shouldNotStartWith(Object actual,
Object expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldNotStartWith.shouldNotStartWith(Object actual,
Object expected,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldStartWith.shouldStartWith(Object actual,
Object expected)
Creates a new
. |
static ErrorMessageFactory |
ShouldStartWith.shouldStartWith(Object actual,
Object expected,
ComparisonStrategy comparisonStrategy)
Creates a new
. |
static ErrorMessageFactory |
ShouldStartWithPath.shouldStartWith(Path actual,
Path other) |
Modifier and Type | Class and Description |
---|---|
class |
ShouldBeCancelled |
class |
ShouldBeCompleted |
class |
ShouldBeCompletedExceptionally |
class |
ShouldBeDone |
class |
ShouldHaveFailed |
class |
ShouldNotBeCancelled |
class |
ShouldNotBeCompleted |
class |
ShouldNotBeCompletedExceptionally |
class |
ShouldNotBeDone |
class |
ShouldNotHaveFailed |
Modifier and Type | Class and Description |
---|---|
class |
ShouldHaveAnchor |
class |
ShouldHaveAuthority |
class |
ShouldHaveFragment |
class |
ShouldHaveHost |
class |
ShouldHaveParameter |
class |
ShouldHavePath |
class |
ShouldHavePort |
class |
ShouldHaveProtocol |
class |
ShouldHaveQuery |
class |
ShouldHaveScheme |
class |
ShouldHaveUserInfo |
Modifier and Type | Method and 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,
List<String> actualValues) |
static ErrorMessageFactory |
ShouldHaveParameter.shouldHaveNoParameter(Object actual,
String name,
String unwantedValue,
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) |
Modifier and Type | Method and Description |
---|---|
AssertionError |
Failures.failure(AssertionInfo info,
ErrorMessageFactory message)
Creates a
following this pattern:
creates a using
as the error message if such value is not null , or
uses the given to create the detail message of the
, prepending the value of to
the error message
|
Copyright © 2014–2016 AssertJ. All rights reserved.