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.array2d
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 AssertionError	AbstractAssert.assertionError(ErrorMessageFactory errorMessageFactory)
protected void	AbstractAssert.throwAssertionError(ErrorMessageFactory errorMessageFactory)	Utility method to throw an AssertionError given a BasicErrorMessageFactory.

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	ActualIsNotEmpty
class	AnyElementShouldMatch
class	BasicErrorMessageFactory	A factory of error messages typically shown when an assertion fails.
class	ClassModifierShouldBe	Error message factory for an assertion which checks that a class has (or has not) a specific modifier.
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	ElementsShouldSatisfy
class	MatcherShouldMatch	Build error message when an Matcher should match.
class	NoElementsShouldMatch
class	NoElementsShouldSatisfy
class	OptionalDoubleShouldHaveValueCloseToOffset	Build error message when an OptionalDouble should have a specific value close to an offset.
class	OptionalDoubleShouldHaveValueCloseToPercentage	Build error message when an OptionalDouble should be close to an expected value within a positive percentage.
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 Predicate accepts a value failed.
class	ShouldBe	Creates an error message indicating that an assertion that verifies that a value satisfies a Condition failed.
class	ShouldBeAbsolutePath	Creates an error message indicating that an assertion that verifies that a File or Path is an absolute path failed.
class	ShouldBeAbstract
class	ShouldBeAfter	Creates an error message indicating that an assertion that verifies that a Date is after another one failed.
class	ShouldBeAfterOrEqualTo	Creates an error message indicating that an assertion that verifies that an Object is after or equal 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	ShouldBeAlphabetic
class	ShouldBeAlphanumeric
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	ShouldBeASCII
class	ShouldBeAssignableFrom	Creates an error message indicating that an assertion that verifies that a class is assignable from.
class	ShouldBeAssignableTo	Creates an error message indicating that an assertion that verifies that a class is assignable to.
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 Condition failed.
class	ShouldBeAtSameInstant	Creates an error message indicating that an assertion that verifies that two OffsetDateTimes have the same Instant, failed.
class	ShouldBeBase64	Creates an error message that indicates an assertion that verifies that a string is a valid Base64 encoded string failed.
class	ShouldBeBefore	Creates an error message indicating that an assertion that verifies that a Object is before another one failed.
class	ShouldBeBeforeOrEqualTo	Creates an error message indicating that an assertion that verifies that an Object is before or equal 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 value is between a start and an end (inclusive or not) failed.
class	ShouldBeBlank	Creates an error message indicating that an assertion that verifies a CharSequence is blank.
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	ShouldBeCurrentYearMonth	Creates an error message indicating that an assertion that verifies that a YearMonth is the current one (matching year and month).
class	ShouldBeDirectory	Creates an error message indicating that an assertion that verifies that a File or Path is an existing directory failed
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 AssertionError 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 CharSequences 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	ShouldBeEqualIgnoringNewLineDifferences
class	ShouldBeEqualIgnoringNewLines
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 CharSequences are equal, ignoring whitespace differences, failed.
class	ShouldBeEqualNormalizingPunctuationAndWhitespace	Creates an error message indicating that an assertion that verifies that two CharSequences are equal, after the punctuation of both strings have been normalized, failed.
class	ShouldBeEqualNormalizingUnicode	Creates an error message indicating that an assertion that verifies that two CharSequences are equal, on their canonical form relying on Normalizer, failed.
class	ShouldBeEqualNormalizingWhitespace	Creates an error message indicating that an assertion that verifies that two CharSequences are equal, after the whitespace of both strings has been normalized, failed.
class	ShouldBeEqualToIgnoringFields	Creates an AssertionError 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 AssertionError indicating that an assertion that verifies that two dates are equals up to a given precision failed.
class	ShouldBeEven	Creates an error message that indicates an assertion that verifies that a whole number is even 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 File is executable failed.
class	ShouldBeExhausted	Creates an error message indicating that an assertion that verifies that an Iterator has no more elements failed.
class	ShouldBeFalse
class	ShouldBeFile	Creates an error message indicating that an assertion that verifies that a File is an existing file failed.
class	ShouldBeFinite
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	ShouldBeHexadecimal
class	ShouldBeIn	Creates an error message indicating that an assertion that verifies that a value is in a group of values (e.g.
class	ShouldBeInfinite
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 or a Temporal is in the future failed.
class	ShouldBeInThePast	Creates an error message indicating that an assertion that verifies that a Date or a Temporal 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	ShouldBeMixedCase	Creates an error message that indicates an assertion that verifies that a CharSequence is mixed case 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	ShouldBeNumeric	Creates an error message that indicates an assertion that cast string to a number (byte, short, integer, long, float or double) failed.
class	ShouldBeOdd	Creates an error message that indicates an assertion that verifies that a whole number is odd 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	ShouldBePeriod
class	ShouldBePrimitive	Creates an error message indicating that an assertion that verifies that a class is (or not) a primitive data type, i.e, byte, short, int, long, float, double, char and boolean.
class	ShouldBePrintable
class	ShouldBeReadable	Creates an error message indicating that an assertion that verifies that a File or a a Path is readable failed.
class	ShouldBeRecord	Creates an error message indicating that an assertion that verifies that a class is (or not) a record.
class	ShouldBeRegularFile	Creates an error message indicating that an assertion that verifies that a Path is a regular file has failed.
class	ShouldBeRelativePath	Creates an error message indicating that an assertion that verifies that a File or a Path is a relative path failed.
class	ShouldBeSame	Creates an error message indicating that an assertion that verifies that two object refer to same object failed.
class	ShouldBeSealed	Creates an error message indicating that an assertion that verifies that a class is (or not) sealed.
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	ShouldBeTrue
class	ShouldBeUnmodifiable
class	ShouldBeUpperCase	Creates an error message that indicates an assertion that verifies that a character is uppercase failed.
class	ShouldBeVisible
class	ShouldBeWritable	Creates an error message indicating that an assertion that verifies that a File 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	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 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	ShouldContainEntries
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 a CharSequence 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 a CharSequence contains only whitespaces.
class	ShouldContainPattern	Creates an error message indicating that an assertion that verifies that a CharSequence contains a pattern failed.
class	ShouldContainRecursively	Creates an error message indicating that an assertion that verifies a group of elements contains recursively a given set of values 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 a CharSequence contains a Sequence of several CharSequences 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 a CharSequence contains a Subsequence of several CharSequences 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	ShouldEndWithIgnoringCase	Creates an error message indicating that an assertion that verifies that CharSequence ends with a given value (ignoring case considerations) failed.
class	ShouldEndWithPath
class	ShouldExist	Creates an error message indicating that an assertion that verifies that a File or Path exists failed.
class	ShouldHave	Creates an error message indicating that an assertion that verifies that a value satisfies a Condition failed.
class	ShouldHaveAllNullFields	Creates an AssertionError indicating that an assertion that verifies that an object has null fields failed.
class	ShouldHaveAnnotations	Creates an error message indicating that an assertion that verifies that a class has annotations failed.
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 Condition 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	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 a Date 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	ShouldHaveDimensions
class	ShouldHaveDuration
class	ShouldHaveExactlyTypes
class	ShouldHaveExtension	Creates an error message indicating that a File or a Path should have extension.
class	ShouldHaveFields	Creates an error message indicating that an assertion that verifies that a class have field.
class	ShouldHaveFileSystem	Creates an error message indicating that an assertion that verifies the FileSystem for a given path does not match a given file system.
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	ShouldHaveMessageFindingMatchRegex	Creates an error message indicating that an assertion that verifies that a CharSequence matches given regular expression.
class	ShouldHaveMessageMatchingRegex	Creates an error message indicating that an assertion that verifies that a CharSequence 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 a File should have name.
class	ShouldHaveNext	Creates an error message indicating that an assertion that verifies that an Iterator has a next element failed.
class	ShouldHaveNoCause	Creates an error message indicating that an assertion that verifies that an Throwable has no cause failed.
class	ShouldHaveNoExtension	Creates an error message indicating that a Path should have no extension.
class	ShouldHaveNoFields
class	ShouldHaveNoNullFields	Creates an AssertionError indicating that an assertion that verifies that an object has no null fields failed.
class	ShouldHaveNoPackage	Creates an error message indicating that an assertion that verifies that a class has no package failed.
class	ShouldHaveNoParent	Creates an error message when a File should not have a parent.
class	ShouldHaveNoSuperclass	Creates an error message indicating that an assertion that verifies that a class has no superclass failed.
class	ShouldHaveNoSuppressedExceptions	Creates an error message indicating that an assertion that verifies that a Throwable 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	ShouldHavePackage	Creates an error message indicating that a Class should have a given package.
class	ShouldHaveParent	Creates an error message indicating that a File should have a parent.
class	ShouldHavePeriod
class	ShouldHavePermittedSubclasses
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	ShouldHaveRecordComponents	Creates an error message indicating that an assertion that verifies that a class has record components failed.
class	ShouldHaveReference
class	ShouldHaveRootCause
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	ShouldHaveSameDimensionsAs
class	ShouldHaveSameFileSystemAs	Creates an error message indicating that an assertion that verifies the FileSystem for a given path does not match a given path's file system.
class	ShouldHaveSameHashCode
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	ShouldHaveScale
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	ShouldHaveSuperclass	Creates an error message indicating that an assertion that verifies that a class has a given superclass failed.
class	ShouldHaveSuppressedException	Creates an error message indicating that an assertion that verifies that a Throwable 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 Predicate 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 Predicate not accepting a value failed.
class	ShouldNotBe	Creates an error message indicating that an assertion that verifies that a value does not satisfy a Condition 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	ShouldNotBeBlank	Creates an error message indicating that an assertion that verifies CharSequence 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	ShouldNotBeEqualComparingFieldByFieldRecursively
class	ShouldNotBeEqualIgnoringCase	Creates an error message indicating that an assertion that verifies that two CharSequences are not equal, ignoring case considerations, failed.
class	ShouldNotBeEqualIgnoringWhitespace	Creates an error message indicating that an assertion that verifies that two CharSequences are not equal, ignoring whitespace differences, failed.
class	ShouldNotBeEqualNormalizingWhitespace	Creates an error message indicating that an assertion that verifies that two CharSequences 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	ShouldNotBeFinite
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	ShouldNotBeInfinite
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	ShouldNotBePrimitive	Creates an error message indicating that an assertion that verifies that a class is (or not) a primitive data type, i.e, byte, short, int, long, float, double, char and boolean.
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 a CharSequence 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 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	ShouldNotContainOnlyWhitespaces	Creates an error message indicating that an assertion that verifies CharSequence is not blank.
class	ShouldNotContainPattern	Creates an error message indicating that an assertion that verifies that a CharSequence 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	ShouldNotEndWithIgnoringCase	Creates an error message indicating that an assertion that verifies that CharSequence does not end with a given value (ignoring case considerations) failed.
class	ShouldNotEndWithWhitespaces	Creates an error message indicating that an assertion that verifies that a CharSequence does not end with whitespace characters.
class	ShouldNotExist	Creates an error message indicating that an assertion that verifies that a File or Path does not exist failed.
class	ShouldNotHave	Creates an error message indicating that an assertion that verifies that a value does not satisfy a Condition failed.
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	ShouldNotHaveSameHashCode
class	ShouldNotHaveThrown
class	ShouldNotHaveThrownExcept
class	ShouldNotHaveToString
class	ShouldNotMatch	Creates an error message indicating that an assertion that verifies that a value not satisfying a Predicate failed.
class	ShouldNotMatchPattern	Creates an error message indicating that an assertion that verifies that a CharSequence does not match a pattern failed.
class	ShouldNotSatisfyPredicateRecursively
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	ShouldNotStartWithIgnoringCase	Creates an error message indicating that an assertion that verifies CharSequence does not start with a given value (ignoring case considerations) failed.
class	ShouldNotStartWithWhitespaces	Creates an error message indicating that an assertion that verifies that a CharSequence does not start with whitespace characters.
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	Creates an error message indicating that an assertion that verifies that a Condition or a list of Consumers cannot be satisfied.
class	ShouldSatisfyOnlyOnce	Creates an error message indicating that an assertion that verifies that requirements are not satisfied only once.
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	ShouldStartWithIgnoringCase	Creates an error message indicating that an assertion that verifies CharSequence starts with a given value (ignoring case considerations) failed.
class	ShouldStartWithPath
class	SubarraysShouldHaveSameSize	Creates an error message indicating that an assertion that verifies that some subarray (in multidimensional arrays) has certain size failed.
class	ZippedElementsShouldSatisfy

Methods in org.assertj.core.error that return ErrorMessageFactory

Modifier and Type	Method	Description
static ErrorMessageFactory	ActualIsNotEmpty.actualIsNotEmpty(Object expected)
static ErrorMessageFactory	AnyElementShouldMatch.anyElementShouldMatch(Object actual, PredicateDescription predicateDescription)
static ErrorMessageFactory	ShouldContainCharSequence.containsIgnoringNewLines(CharSequence actual, CharSequence[] expectedValues, Set<? extends CharSequence> notFound, ComparisonStrategy comparisonWay)	Creates a new ShouldContainCharSequence.
static ErrorMessageFactory	ShouldContain.directoryShouldContain(File actual, List<File> directoryContent, String filterDescription)
static ErrorMessageFactory	ShouldContain.directoryShouldContain(Path actual, List<Path> directoryContent, String filterDescription)
static ErrorMessageFactory	ShouldContainRecursively.directoryShouldContainRecursively(File actual, List<File> directoryContent, String filterDescription)
static ErrorMessageFactory	ShouldContainRecursively.directoryShouldContainRecursively(Path actual, List<Path> directoryContent, String filterDescription)
static ErrorMessageFactory	ShouldNotContain.directoryShouldNotContain(File actual, List<File> matchingContent, String filterDescription)
static ErrorMessageFactory	ShouldNotContain.directoryShouldNotContain(Path actual, List<Path> matchingContent, String filterDescription)
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 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<UnsatisfiedRequirement> elementsNotSatisfyingRestrictions, AssertionInfo info)
static ErrorMessageFactory	ElementsShouldSatisfy.elementsShouldSatisfyAny(Object actual, List<UnsatisfiedRequirement> elementsNotSatisfyingRequirements, AssertionInfo info)
static ErrorMessageFactory	ElementsShouldSatisfy.elementsShouldSatisfyExactly(Object actual, Map<Integer,UnsatisfiedRequirement> unsatisfiedRequirements, AssertionInfo info)
static ErrorMessageFactory	ShouldHaveExactlyTypes.elementsTypesDifferAtIndex(Object actualElement, Class<?> expectedElement, int indexOfDifference)
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	ShouldBeAlphabetic.shouldBeAlphabetic(Object actual)
static ErrorMessageFactory	ShouldBeAlphanumeric.shouldBeAlphanumeric(Object actual)
static ErrorMessageFactory	ShouldBeAnArray.shouldBeAnArray(Object object)	Creates a new instance of ShouldBeAnArray.
static ErrorMessageFactory	ShouldBeAnnotation.shouldBeAnnotation(Class<?> actual)	Creates a new ShouldBeAnnotation.
static ErrorMessageFactory	ShouldBeASCII.shouldBeASCII(Object actual)
static ErrorMessageFactory	ShouldBeAssignableFrom.shouldBeAssignableFrom(Class<?> actual, Set<Class<?>> expectedAssignableFrom, Set<Class<?>> missingAssignableFrom)	Creates a new ShouldBeAssignableFrom.
static ErrorMessageFactory	ShouldBeAssignableTo.shouldBeAssignableTo(Class<?> actual, Class<?> other)	Creates a new ShouldBeAssignableTo.
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	ShouldBeBase64.shouldBeBase64(String actual)	Creates a new ShouldBeBase64.
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 <T> ErrorMessageFactory	ShouldBeBetween.shouldBeBetween(Comparable<? super T> actual, Comparable<? super T> start, Comparable<? super T> end, boolean inclusiveStart, boolean inclusiveEnd)	Creates a new ShouldBeBetween.
static <T> ErrorMessageFactory	ShouldBeBetween.shouldBeBetween(Comparable<? super T> actual, Comparable<? super T> start, Comparable<? super T> end, boolean inclusiveStart, boolean inclusiveEnd, ComparisonStrategy comparisonStrategy)	Deprecated. Use ShouldBeBetween.shouldBeBetween(Object, Object, Object, boolean, boolean, ComparisonStrategy) instead.
static <T> ErrorMessageFactory	ShouldBeBetween.shouldBeBetween(Object actual, Object start, Object end, boolean inclusiveStart, boolean inclusiveEnd, ComparisonStrategy comparisonStrategy)	Creates a new ShouldBeBetween.
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 ErrorMessageFactory	ShouldBeBlank.shouldBeBlank(CharSequence actual)	Creates a new ShouldBeBlank.
static ErrorMessageFactory	ShouldBeCanonicalPath.shouldBeCanonicalPath(Path actual)
static ErrorMessageFactory	ShouldBeCloseTo.shouldBeCloseTo(TemporalAmount actual, TemporalAmount other, TemporalAmount allowedDifference, TemporalAmount difference)
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	ShouldBeCurrentYearMonth.shouldBeCurrentYearMonth(YearMonth actual)	Creates a new ShouldBeCurrentYearMonth.
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	ShouldBeEmpty.shouldBeEmpty(Path 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> ErrorMessageFactory	ShouldBeEqualWithinOffset.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	ShouldBeEqualNormalizingPunctuationAndWhitespace.shouldBeEqualNormalizingPunctuationAndWhitespace(CharSequence actual, CharSequence expected)	Creates a new ShouldBeEqualNormalizingPunctuationAndWhitespace.
static ErrorMessageFactory	ShouldBeEqualNormalizingUnicode.shouldBeEqualNormalizingUnicode(CharSequence actual, CharSequence expected, CharSequence normalizedActual, CharSequence normalizedExpected)	Creates a new ShouldBeEqualNormalizingUnicode.
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> ErrorMessageFactory	ShouldBeEqualWithinPercentage.shouldBeEqualWithinPercentage(T actual, T expected, Percentage percentage, T difference)	Creates a new ShouldBeEqualWithinPercentage.
static ErrorMessageFactory	ShouldBeEven.shouldBeEven(Number actual)	Creates a new ShouldBeEven.
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	ShouldBeFalse.shouldBeFalse(boolean actual)
static ErrorMessageFactory	ShouldBeFile.shouldBeFile(File actual)	Creates a new ShouldBeFile.
static ErrorMessageFactory	ClassModifierShouldBe.shouldBeFinal(Class<?> actual)	Creates a new instance for a positive check of the final modifier.
static ErrorMessageFactory	ShouldBeFinite.shouldBeFinite(Number actual)
static <T> ErrorMessageFactory	ShouldBeGreater.shouldBeGreater(Comparable<? super T> actual, Comparable<? super T> other)	Creates a new ShouldBeGreater.
static <T> ErrorMessageFactory	ShouldBeGreater.shouldBeGreater(Comparable<? super T> actual, Comparable<? super T> other, ComparisonStrategy comparisonStrategy)	Deprecated. Use ShouldBeGreater.shouldBeGreater(Object, Object, ComparisonStrategy) instead.
static ErrorMessageFactory	ShouldBeGreater.shouldBeGreater(Object actual, Object other, ComparisonStrategy comparisonStrategy)	Creates a new ShouldBeGreater.
static <T> ErrorMessageFactory	ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(Comparable<? super T> actual, Comparable<? super T> other)	Creates a new ShouldBeGreaterOrEqual.
static <T> ErrorMessageFactory	ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(Comparable<? super T> actual, Comparable<? super T> other, ComparisonStrategy comparisonStrategy)	Deprecated. Use ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(Object, Object, ComparisonStrategy) instead.
static ErrorMessageFactory	ShouldBeGreaterOrEqual.shouldBeGreaterOrEqual(Object actual, Object other, ComparisonStrategy comparisonStrategy)	Creates a new ShouldBeGreaterOrEqual.
static ErrorMessageFactory	ShouldBeHexadecimal.shouldBeHexadecimal(Object actual)
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	ShouldBeInfinite.shouldBeInfinite(Number actual)
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(Temporal actual)	Creates a new ShouldBeInTheFuture.
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(Temporal actual)	Creates a new ShouldBeInThePast.
static ErrorMessageFactory	ShouldBeInThePast.shouldBeInThePast(Date actual)	Creates a new ShouldBeInThePast.
static ErrorMessageFactory	ShouldBeInThePast.shouldBeInThePast(Date actual, ComparisonStrategy comparisonStrategy)	Creates a new ShouldBeInThePast.
static <T> ErrorMessageFactory	ShouldBeLess.shouldBeLess(Comparable<? super T> actual, Comparable<? super T> other)	Creates a new ShouldBeLess.
static ErrorMessageFactory	ShouldBeLess.shouldBeLess(Object actual, Object other, ComparisonStrategy comparisonStrategy)	Creates a new ShouldBeLess.
static <T extends Comparable<? super T>> ErrorMessageFactory	ShouldBeLess.shouldBeLess(T actual, T other, ComparisonStrategy comparisonStrategy)	Deprecated. Use ShouldBeLess.shouldBeLess(Object, Object, ComparisonStrategy) instead.
static <T> ErrorMessageFactory	ShouldBeLessOrEqual.shouldBeLessOrEqual(Comparable<? super T> actual, Comparable<? super T> other)	Creates a new ShouldBeLessOrEqual.
static <T> ErrorMessageFactory	ShouldBeLessOrEqual.shouldBeLessOrEqual(Comparable<? super T> actual, Comparable<? super T> other, ComparisonStrategy comparisonStrategy)	Deprecated. Use ShouldBeLessOrEqual.shouldBeLessOrEqual(Object, Object, ComparisonStrategy) instead.
static <T> ErrorMessageFactory	ShouldBeLessOrEqual.shouldBeLessOrEqual(Object actual, Object 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	ShouldBeMixedCase.shouldBeMixedCase(CharSequence actual)	Creates a new ShouldBeMixedCase.
static ErrorMessageFactory	ShouldBeNormalized.shouldBeNormalized(Path actual)
static ErrorMessageFactory	ShouldBeNullOrEmpty.shouldBeNullOrEmpty(Object actual)	Creates a new instance of ShouldBeNullOrEmpty.
static ErrorMessageFactory	ShouldBeNumeric.shouldBeNumeric(String actual, ShouldBeNumeric.NumericType type)	Creates a new ShouldBeNumeric.
static ErrorMessageFactory	ShouldBeOdd.shouldBeOdd(Number actual)	Creates a new ShouldBeOdd.
static ErrorMessageFactory	ShouldBeOfClassIn.shouldBeOfClassIn(Object actual, Object types)	Creates a new ShouldBeOfClassIn.
static ErrorMessageFactory	ClassModifierShouldBe.shouldBePackagePrivate(Class<?> actual)	Creates a new instance for a positive check of the package-private modifier.
static ErrorMessageFactory	ShouldBePrintable.shouldBePrintable(Object actual)
static ErrorMessageFactory	ClassModifierShouldBe.shouldBePrivate(Class<?> actual)	Creates a new instance for a positive check of the private modifier.
static ErrorMessageFactory	ClassModifierShouldBe.shouldBeProtected(Class<?> actual)	Creates a new instance for a positive check of the protected modifier.
static ErrorMessageFactory	ClassModifierShouldBe.shouldBePublic(Class<?> actual)	Creates a new instance for a positive check of the public modifier.
static ErrorMessageFactory	ShouldBeReadable.shouldBeReadable(File actual)	Creates a new ShouldBeReadable.
static ErrorMessageFactory	ShouldBeReadable.shouldBeReadable(Path actual)
static ErrorMessageFactory	ShouldBeRecord.shouldBeRecord(Class<?> actual)	Creates a new ShouldBeRecord.
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 new ConditionAndGroupGenericParameterTypeShouldBeTheSame
static ErrorMessageFactory	ShouldBeSealed.shouldBeSealed(Class<?> actual)	Creates a new ShouldBeSealed.
static ErrorMessageFactory	ShouldBeSorted.shouldBeSorted(int i, Object group)	Creates a new ShouldBeSorted.
static ErrorMessageFactory	ShouldBeSorted.shouldBeSortedAccordingToGivenComparator(int i, Object group, Comparator<?> comparator)
static ErrorMessageFactory	ClassModifierShouldBe.shouldBeStatic(Class<?> actual)	Creates a new instance for a positive check of the static modifier.
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 new ShouldBeSubsetOf
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	ShouldBeTrue.shouldBeTrue(boolean actual)
static ErrorMessageFactory	ShouldBeUnmodifiable.shouldBeUnmodifiable(String method)
static ErrorMessageFactory	ShouldBeUnmodifiable.shouldBeUnmodifiable(String method, RuntimeException cause)
static ErrorMessageFactory	ShouldBeUpperCase.shouldBeUpperCase(Object actual)	Creates a new ShouldBeUpperCase.
static ErrorMessageFactory	ShouldBeVisible.shouldBeVisible(Object actual)
static ErrorMessageFactory	ShouldBeWritable.shouldBeWritable(File actual)	Creates a new ShouldBeWritable.
static ErrorMessageFactory	ShouldBeWritable.shouldBeWritable(Path actual)
static ErrorMessageFactory	ShouldContain.shouldContain(Class<?> clazz, Object actual, Object expected, Object notFound, ComparisonStrategy comparisonStrategy)	Creates a new ShouldContain.
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	ShouldContainCharSequence.shouldContain(Throwable actual, CharSequence sequence)
static ErrorMessageFactory	ShouldContainCharSequence.shouldContain(Throwable actual, CharSequence[] sequence, Set<? extends CharSequence> notFound)
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> ErrorMessageFactory	ShouldContainEntries.shouldContainEntries(Map<? extends K,? extends V> actual, Map.Entry<? extends K,? extends V>[] expectedEntries, Set<Map.Entry<? extends K,? extends V>> entriesWithWrongValue, Set<Map.Entry<? extends K,? extends V>> entriesWithKeyNotFound, Representation representation)
static <K, V> ErrorMessageFactory	ShouldContainEntry.shouldContainEntry(Map<K,V> actual, Condition<?> entryCondition)	Creates a new ShouldContainEntry.
static <K, V> ErrorMessageFactory	ShouldContainEntry.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	ShouldContainExactly.shouldContainExactlyWithIndexes(Object actual, Iterable<?> expected, List<IndexedDiff> indexDifferences)	Creates a new ShouldContainExactly.
static ErrorMessageFactory	ShouldContainExactly.shouldContainExactlyWithIndexes(Object actual, Iterable<?> expected, List<IndexedDiff> indexDifferences, ComparisonStrategy comparisonStrategy)	Creates a new ShouldContainExactly.
static ErrorMessageFactory	ShouldContainCharSequence.shouldContainIgnoringCase(CharSequence actual, CharSequence sequence)	Creates a new ShouldContainCharSequence.
static ErrorMessageFactory	ShouldContainCharSequence.shouldContainIgnoringWhitespaces(CharSequence actual, CharSequence[] strings, Set<? extends CharSequence> notFound, ComparisonStrategy comparisonStrategy)	Creates a new ShouldContainCharSequence.
static ErrorMessageFactory	ShouldContainCharSequence.shouldContainIgnoringWhitespaces(CharSequence actual, CharSequence sequence, ComparisonStrategy comparisonStrategy)	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, GroupTypeDescription groupTypeDescription)
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	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	ShouldContainSubsequenceOfCharSequence.shouldContainSubsequence(CharSequence actual, CharSequence[] strings, Map<CharSequence,Integer> notFoundRepeatedSubsequence, ComparisonStrategy comparisonStrategy)	Creates a new ShouldContainSubsequenceOfCharSequence with detailed error messages about missing subsequences.
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	ShouldEndWithIgnoringCase.shouldEndWithIgnoringCase(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy)	Creates a new ShouldEndWithIgnoringCase.
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(InputStream 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)
static ErrorMessageFactory	ShouldHaveCause.shouldHaveCause(Throwable actual, 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(Temporal actual, String fieldDescription, int fieldValue)
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	ShouldHaveFileSystem.shouldHaveFileSystem(Path actual, FileSystem fileSystem)
static ErrorMessageFactory	ShouldHaveDimensions.shouldHaveFirstDimension(Object actual, int actualSize, int expectedSize)
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	ShouldHaveDateField.shouldHaveMonth(Temporal actual, Month month)
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	ShouldHaveNoPackage.shouldHaveNoPackage(Class<?> actual)	Creates a new ShouldHaveNoPackage.
static ErrorMessageFactory	ShouldHaveNoFields.shouldHaveNoPublicFields(Class<?> actual, Set<String> fields)
static ErrorMessageFactory	ShouldHaveNoSuperclass.shouldHaveNoSuperclass(Class<?> actual)	Creates a new ShouldHaveNoSuperclass.
static ErrorMessageFactory	ShouldHaveNoSuppressedExceptions.shouldHaveNoSuppressedExceptions(Throwable actual)	Creates a new ShouldHaveNoSuppressedExceptions.
static ErrorMessageFactory	ShouldHavePackage.shouldHavePackage(Class<?> actual, Package aPackage)	Creates a new ShouldHavePackage with a Package instance.
static ErrorMessageFactory	ShouldHavePackage.shouldHavePackage(Class<?> actual, String packageName)	Creates a new ShouldHavePackage with a package name.
static ErrorMessageFactory	ShouldHavePermittedSubclasses.shouldHavePermittedSubclasses(Class<?> actual, Class<?>[] permittedSubclasses, Collection<Class<?>> missingSubclasses)
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	ShouldHaveRecordComponents.shouldHaveRecordComponents(Class<?> actual, Set<String> expected, Set<String> missing)	Creates a new ShouldHaveRecordComponents
static <REF> ErrorMessageFactory	ShouldHaveReference.shouldHaveReference(Object actual, REF actualReference, REF expectedReference)
static ErrorMessageFactory	ShouldHaveRootCause.shouldHaveRootCause(Throwable actualCause)
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	ShouldHaveSameDimensionsAs.shouldHaveSameDimensionsAs(int rowIndex, int actualRowSize, int expectedRowSize, Object actualRow, Object expectedRow, Object actual, Object expected)
static ErrorMessageFactory	ShouldHaveSameDimensionsAs.shouldHaveSameDimensionsAs(Object actual, Object expected, Object actualSize, Object expectedSize)	Creates a new ShouldHaveSameDimensionsAs.
static ErrorMessageFactory	ShouldHaveSameFileSystemAs.shouldHaveSameFileSystemAs(Path actual, Path expected)
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	ShouldHaveScale.shouldHaveScale(BigDecimal actual, int expectedScale)
static ErrorMessageFactory	ShouldHaveDimensions.shouldHaveSize(Object actual, int actualSize, int expectedSize, int rowIndex)
static ErrorMessageFactory	ShouldHaveSize.shouldHaveSize(File actual, long expectedSize)	Creates a new ShouldHaveSize for file size.
static ErrorMessageFactory	ShouldHaveSize.shouldHaveSize(Object actual, int actualSize, int expectedSize)	Creates a new ShouldHaveSize.
static ErrorMessageFactory	ShouldHaveSize.shouldHaveSize(Object actual, int actualSize, int expectedSize, int firstDimensionArrayIndex)	Creates a new ShouldHaveSize.
static ErrorMessageFactory	ShouldHaveSize.shouldHaveSize(Path actual, long expectedSize)	Creates a new ShouldHaveSize for Path file size
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	ShouldHaveSuperclass.shouldHaveSuperclass(Class<?> actual, Class<?> superclass)	Creates a new ShouldHaveSuperclass.
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 ErrorMessageFactory	ShouldHaveExactlyTypes.shouldHaveTypes(Object actual, Iterable<Class<?>> expectedTypes, Iterable<Class<?>> expectedTypesNotFoundInActual, Iterable<Class<?>> actualTypesNotExpected)
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	ShouldNotBeEmpty.shouldNotBeEmpty(Path 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> ErrorMessageFactory	ShouldNotBeEqualWithinOffset.shouldNotBeEqual(T actual, T expected, Offset<T> offset, T difference)	Creates a new ShouldNotBeEqualWithinOffset.
static ErrorMessageFactory	ShouldNotBeEqualComparingFieldByFieldRecursively.shouldNotBeEqualComparingFieldByFieldRecursively(Object actual)
static ErrorMessageFactory	ShouldNotBeEqualComparingFieldByFieldRecursively.shouldNotBeEqualComparingFieldByFieldRecursively(Object actual, Object other, RecursiveComparisonConfiguration recursiveComparisonConfiguration, Representation representation)
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> ErrorMessageFactory	ShouldNotBeEqualWithinPercentage.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 new instance for a negative check of the final modifier.
static ErrorMessageFactory	ShouldNotBeFinite.shouldNotBeFinite(Number actual)
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	ShouldNotBeInfinite.shouldNotBeInfinite(Number actual)
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	ShouldBeRecord.shouldNotBeRecord(Class<?> actual)	Creates a new ShouldBeRecord.
static ErrorMessageFactory	ShouldNotBeSame.shouldNotBeSame(Object actual)	Creates a new ShouldNotBeSame.
static ErrorMessageFactory	ShouldBeSealed.shouldNotBeSealed(Class<?> actual)	Creates a new ShouldBeSealed.
static ErrorMessageFactory	ClassModifierShouldBe.shouldNotBeStatic(Class<?> actual)	Creates a new instance for a negative check of the static modifier.
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 new ShouldNotContainCharSequence
static ErrorMessageFactory	ShouldNotContainCharSequence.shouldNotContain(CharSequence actual, CharSequence sequence, ComparisonStrategy comparisonStrategy)	Creates a new ShouldNotContainCharSequence.
static ErrorMessageFactory	ShouldNotContainCharSequence.shouldNotContain(Throwable actual, CharSequence sequence)
static ErrorMessageFactory	ShouldNotContainCharSequence.shouldNotContain(Throwable actual, CharSequence[] sequence, Set<? extends CharSequence> found)
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	ShouldNotContainCharSequence.shouldNotContainIgnoringCase(CharSequence actual, CharSequence sequence)	Creates a new ShouldContainCharSequence.
static ErrorMessageFactory	ShouldNotContainCharSequence.shouldNotContainIgnoringCase(CharSequence actual, CharSequence[] sequences, Set<CharSequence> foundSequences)
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	ShouldNotEndWithIgnoringCase.shouldNotEndWithIgnoringCase(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy)	Creates a new ShouldNotEndWithIgnoringCase.
static ErrorMessageFactory	ShouldNotEndWithWhitespaces.shouldNotEndWithWhitespaces(CharSequence actual)	Creates a new ShouldNotEndWithWhitespaces.
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	ShouldNotHaveSameHashCode.shouldNotHaveSameHashCode(Object actual, Object other)
static ErrorMessageFactory	ShouldNotHaveThrown.shouldNotHaveThrown(Throwable throwable)
static ErrorMessageFactory	ShouldNotHaveThrownExcept.shouldNotHaveThrownExcept(Throwable throwable, Class<? extends Throwable>... throwableClasses)
static ErrorMessageFactory	ShouldNotHaveToString.shouldNotHaveToString(String other)
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	ShouldNotSatisfyPredicateRecursively.shouldNotSatisfyRecursively(RecursiveAssertionConfiguration recursiveAssertionConfiguration, List<FieldLocation> failedFields)
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	ShouldNotStartWithIgnoringCase.shouldNotStartWithIgnoringCase(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy)	Creates a new ShouldNotStartWithIgnoringCase.
static ErrorMessageFactory	ShouldNotStartWithWhitespaces.shouldNotStartWithWhitespaces(CharSequence actual)	Creates a new ShouldNotStartWithWhitespaces.
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	ShouldSatisfy.shouldSatisfyAll(Object actual, Description d)
static <E> ErrorMessageFactory	ShouldSatisfy.shouldSatisfyExactlyInAnyOrder(Iterable<E> actual)	Creates a new ShouldSatisfy.
static <E> ErrorMessageFactory	ShouldSatisfyOnlyOnce.shouldSatisfyOnlyOnce(Iterable<? extends E> actual, List<? extends E> satisfiedElements)	Creates a new ShouldSatisfyOnlyOnce.
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	ShouldStartWithIgnoringCase.shouldStartWithIgnoringCase(CharSequence actual, CharSequence expected, ComparisonStrategy comparisonStrategy)	Creates a new ShouldStartWithIgnoringCase.
static ErrorMessageFactory	SubarraysShouldHaveSameSize.subarraysShouldHaveSameSize(Object actual, Object expected, Object actualSubArray, int actualSubArrayLength, Object expectedSubArray, int expectedSubArrayLength, int index)	Creates a new SubarraysShouldHaveSameSize.
static ErrorMessageFactory	ZippedElementsShouldSatisfy.zippedElementsShouldSatisfy(AssertionInfo info, Iterable<?> actual, Iterable<?> other, List<ZippedElementsShouldSatisfy.ZipSatisfyError> zipSatisfyErrors)

Uses of ErrorMessageFactory in org.assertj.core.error.array2d

Classes in org.assertj.core.error.array2d that implement ErrorMessageFactory

Modifier and Type	Class	Description
class	Array2dElementShouldBeDeepEqual	Creates an AssertionError indicating that an assertion that verifies that two 2D arrays are deeply equal failed.

Methods in org.assertj.core.error.array2d that return ErrorMessageFactory

Modifier and Type	Method	Description
static ErrorMessageFactory	Array2dElementShouldBeDeepEqual.elementShouldBeEqual(Object actualElement, Object expectedElement, int rowIndex, int columnIndex)

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	ShouldBeCompletedWithin
class	ShouldBeDone
class	ShouldHaveCompletedExceptionallyWithin
class	ShouldHaveFailed
class	ShouldHaveFailedWithin
class	ShouldNotBeCancelled
class	ShouldNotBeCompleted
class	ShouldNotBeCompletedExceptionally
class	ShouldNotBeDone
class	ShouldNotHaveFailed

Methods in org.assertj.core.error.future that return ErrorMessageFactory

Modifier and Type	Method	Description
static ErrorMessageFactory	ShouldBeCancelled.shouldBeCancelled(Future<?> actual)
static ErrorMessageFactory	ShouldBeCompleted.shouldBeCompleted(CompletableFuture<?> actual)
static ErrorMessageFactory	ShouldBeCompletedWithin.shouldBeCompletedWithin(Future<?> actual, long timeout, TimeUnit timeUnit, Exception exception)
static ErrorMessageFactory	ShouldBeCompletedWithin.shouldBeCompletedWithin(Future<?> actual, Duration duration, Exception exception)
static ErrorMessageFactory	ShouldBeDone.shouldBeDone(Future<?> actual)
static ErrorMessageFactory	ShouldBeCompletedExceptionally.shouldHaveCompletedExceptionally(CompletableFuture<?> actual)
static ErrorMessageFactory	ShouldHaveCompletedExceptionallyWithin.shouldHaveCompletedExceptionallyWithin(Future<?> actual, long timeout, TimeUnit unit)
static ErrorMessageFactory	ShouldHaveCompletedExceptionallyWithin.shouldHaveCompletedExceptionallyWithin(Future<?> actual, Duration timeout)
static ErrorMessageFactory	ShouldHaveFailed.shouldHaveFailed(CompletableFuture<?> actual)
static ErrorMessageFactory	ShouldHaveFailedWithin.shouldHaveFailedWithin(Future<?> actual, long timeout, TimeUnit unit)
static ErrorMessageFactory	ShouldHaveFailedWithin.shouldHaveFailedWithin(Future<?> actual, Duration timeout)
static ErrorMessageFactory	ShouldNotBeCancelled.shouldNotBeCancelled(Future<?> actual)
static ErrorMessageFactory	ShouldNotBeCompleted.shouldNotBeCompleted(CompletableFuture<?> actual)
static ErrorMessageFactory	ShouldNotBeDone.shouldNotBeDone(Future<?> actual)
static ErrorMessageFactory	ShouldNotBeCompletedExceptionally.shouldNotHaveCompletedExceptionally(CompletableFuture<?> actual)
static ErrorMessageFactory	ShouldNotHaveFailed.shouldNotHaveFailed(CompletableFuture<?> actual)

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	ShouldBeEqualToWithSortedQueryParameters
class	ShouldHaveAnchor
class	ShouldHaveAuthority
class	ShouldHaveFragment
class	ShouldHaveHost
class	ShouldHaveNoHost
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	ShouldBeEqualToWithSortedQueryParameters.shouldBeEqualToWithSortedQueryParameters(URL actual, URL expected)
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	ShouldHaveNoHost.shouldHaveNoHost(URI actual)
static ErrorMessageFactory	ShouldHaveNoHost.shouldHaveNoHost(URL actual)
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 AssertionError following this pattern: creates a AssertionError using AssertionInfo.overridingErrorMessage() as the error message if such value is not null, or uses the given ErrorMessageFactory to create the detail message of the AssertionError, prepending the value of AssertionInfo.description() to the error message
AssertionError	Failures.failure(AssertionInfo info, ErrorMessageFactory messageFactory, Object actual, Object expected)