Class AssertionsForClassTypes
- java.lang.Object
-
- org.assertj.core.api.AssertionsForClassTypes
-
- Direct Known Subclasses:
AssertionsForInterfaceTypes
public class AssertionsForClassTypes extends Object
Java 8 is picky when choosing the rightassertThat
method if the object under test is generic and bounded, for example if foo is instance of T that extends Exception, java 8 will complain that it can't resolve the properassertThat
method (normallyassertThat(Throwable)
as foo might implement an interface like List, if that occurredassertThat(List)
would also be a possible choice - thus confusing java 8.This why
Assertions
have been split inAssertionsForClassTypes
andAssertionsForInterfaceTypes
(see http://stackoverflow.com/questions/29499847/ambiguous-method-in-java-8-why).
-
-
Constructor Summary
Constructors Modifier Constructor Description protected
AssertionsForClassTypes()
Creates a new
.AssertionsForClassTypes
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static <T> Condition<T>
allOf(Iterable<? extends Condition<? super T>> conditions)
Creates a newAllOf
static <T> Condition<T>
allOf(Condition<? super T>... conditions)
Creates a newAllOf
static <T> Condition<T>
anyOf(Iterable<? extends Condition<? super T>> conditions)
Creates a newAnyOf
static <T> Condition<T>
anyOf(Condition<? super T>... conditions)
Only delegate toAnyOf.anyOf(Condition...)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useAnyOf
if you prefer).static AbstractBooleanAssert<?>
assertThat(boolean actual)
Creates a new instance of
.BooleanAssert
static AbstractBooleanArrayAssert<?>
assertThat(boolean[] actual)
Creates a new instance of
.BooleanArrayAssert
static AbstractByteAssert<?>
assertThat(byte actual)
Creates a new instance of
.ByteAssert
static AbstractByteArrayAssert<?>
assertThat(byte[] actual)
Creates a new instance of
.ByteArrayAssert
static AbstractCharacterAssert<?>
assertThat(char actual)
Creates a new instance of
.CharacterAssert
static AbstractCharArrayAssert<?>
assertThat(char[] actual)
Creates a new instance of
.CharArrayAssert
static AbstractDoubleAssert<?>
assertThat(double actual)
Creates a new instance of
.DoubleAssert
static AbstractDoubleArrayAssert<?>
assertThat(double[] actual)
Creates a new instance of
.DoubleArrayAssert
static AbstractFloatAssert<?>
assertThat(float actual)
Creates a new instance of
.FloatAssert
static AbstractFloatArrayAssert<?>
assertThat(float[] actual)
Creates a new instance of
.FloatArrayAssert
static AbstractIntegerAssert<?>
assertThat(int actual)
Creates a new instance of
.IntegerAssert
static AbstractIntArrayAssert<?>
assertThat(int[] actual)
Creates a new instance of
.IntArrayAssert
static AbstractLongAssert<?>
assertThat(long actual)
Creates a new instance of
.LongAssert
static AbstractLongArrayAssert<?>
assertThat(long[] actual)
Creates a new instance of
.LongArrayAssert
static AbstractShortAssert<?>
assertThat(short actual)
Creates a new instance of
.ShortAssert
static AbstractShortArrayAssert<?>
assertThat(short[] actual)
Creates a new instance of
.ShortArrayAssert
static AbstractFileAssert<?>
assertThat(File actual)
Creates a new instance of
.FileAssert
static AbstractInputStreamAssert<?,? extends InputStream>
assertThat(InputStream actual)
Creates a new instance of
.InputStreamAssert
static AbstractBooleanAssert<?>
assertThat(Boolean actual)
Creates a new instance of
.BooleanAssert
static AbstractByteAssert<?>
assertThat(Byte actual)
Creates a new instance of
.ByteAssert
static AbstractCharacterAssert<?>
assertThat(Character actual)
Creates a new instance of
.CharacterAssert
static ClassAssert
assertThat(Class<?> actual)
Creates a new instance ofClassAssert
static AbstractDoubleAssert<?>
assertThat(Double actual)
Creates a new instance of
.DoubleAssert
static AbstractFloatAssert<?>
assertThat(Float actual)
Creates a new instance of
.FloatAssert
static AbstractIntegerAssert<?>
assertThat(Integer actual)
Creates a new instance of
.IntegerAssert
static AbstractLongAssert<?>
assertThat(Long actual)
Creates a new instance of
.LongAssert
static AbstractShortAssert<?>
assertThat(Short actual)
Creates a new instance of
.ShortAssert
static AbstractStringAssert<?>
assertThat(String actual)
Creates a new instance of
.StringAssert
static AbstractCharSequenceAssert<?,? extends CharSequence>
assertThat(StringBuffer actual)
Creates a new instance of
from aCharSequenceAssert
StringBuffer
.static AbstractCharSequenceAssert<?,? extends CharSequence>
assertThat(StringBuilder actual)
Creates a new instance of
from aCharSequenceAssert
StringBuilder
.static AbstractThrowableAssert<?,? extends Throwable>
assertThat(Throwable actual)
Creates a new instance of
.ThrowableAssert
static AbstractBigDecimalAssert<?>
assertThat(BigDecimal actual)
Creates a new instance of
.BigDecimalAssert
static AbstractUriAssert<?>
assertThat(URI actual)
Creates a new instance of
.UriAssert
static AbstractUrlAssert<?>
assertThat(URL actual)
Creates a new instance of
.UrlAssert
static AbstractInstantAssert<?>
assertThat(Instant instant)
Creates a new instance of
.InstantAssert
static AbstractLocalDateAssert<?>
assertThat(LocalDate localDate)
Creates a new instance of
.LocalDateAssert
static AbstractLocalDateTimeAssert<?>
assertThat(LocalDateTime actual)
Creates a new instance of
.LocalDateTimeAssert
static AbstractLocalTimeAssert<?>
assertThat(LocalTime actual)
Creates a new instance of
.LocalTimeAssert
static AbstractOffsetDateTimeAssert<?>
assertThat(OffsetDateTime actual)
Creates a new instance of
.OffsetDateTime
static AbstractOffsetTimeAssert<?>
assertThat(OffsetTime actual)
Create assertion forOffsetTime
.static AbstractZonedDateTimeAssert<?>
assertThat(ZonedDateTime actual)
Creates a new instance of
.ZonedDateTimeAssert
static <RESULT> CompletableFutureAssert<RESULT>
assertThat(CompletableFuture<RESULT> actual)
Create assertion forCompletableFuture
.static AbstractDateAssert<?>
assertThat(Date actual)
Creates a new instance of
.DateAssert
static <VALUE> OptionalAssert<VALUE>
assertThat(Optional<VALUE> actual)
Create assertion forOptional
.static OptionalDoubleAssert
assertThat(OptionalDouble actual)
Create assertion forOptionalDouble
.static OptionalIntAssert
assertThat(OptionalInt actual)
Create assertion forOptionalInt
.static OptionalLongAssert
assertThat(OptionalLong actual)
Create assertion forOptionalInt
.static <T> ObjectAssert<T>
assertThat(T actual)
Creates a new instance of
.ObjectAssert
static <T> ObjectArrayAssert<T>
assertThat(T[] actual)
Creates a new instance of
.ObjectArrayAssert
static AbstractThrowableAssert<?,? extends Throwable>
assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.static <T extends Throwable>
ThrowableTypeAssert<T>assertThatExceptionOfType(Class<? extends T> exceptionType)
Entry point to check that an exception of type T is thrown by a giventhrowingCallable
which allows to chain assertions on the thrown exception.static AbstractThrowableAssert<?,? extends Throwable>
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on aThrowable
(easier done with lambdas).static AbstractThrowableAssert<?,? extends Throwable>
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)
Allows to capture and then assert on aThrowable
likeassertThatThrownBy(ThrowingCallable)
but this method let you set the assertion description the same way you do withas(String, Object...)
.static Index
atIndex(int index)
Only delegate toIndex.atIndex(int)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useIndex
if you prefer).static Throwable
catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows catching aThrowable
more easily when used with Java 8 lambdas.static <THROWABLE extends Throwable>
THROWABLEcatchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)
Allows catching aThrowable
of a specific type.static String
contentOf(File file)
Loads the text content of a file with the default character set, so that it can be passed toassertThat(String)
.static String
contentOf(File file, String charsetName)
Loads the text content of a file, so that it can be passed toassertThat(String)
.static String
contentOf(File file, Charset charset)
Loads the text content of a file, so that it can be passed toassertThat(String)
.static String
contentOf(URL url)
Loads the text content of a URL with the default character set, so that it can be passed toassertThat(String)
.static String
contentOf(URL url, String charsetName)
Loads the text content of a URL, so that it can be passed toassertThat(String)
.static String
contentOf(URL url, Charset charset)
Loads the text content of a URL, so that it can be passed toassertThat(String)
.static <T> DoesNotHave<T>
doesNotHave(Condition<? super T> condition)
Creates a new
.DoesNotHave
static <K,V>
MapEntry<K,V>entry(K key, V value)
Only delegate toMapEntry.entry(Object, Object)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useMapEntry
if you prefer).static Properties<Object>
extractProperty(String propertyName)
Only delegate toProperties.extractProperty(String)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useProperties
if you prefer).static <T> Properties<T>
extractProperty(String propertyName, Class<T> propertyType)
Only delegate toProperties.extractProperty(String)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useProperties
if you prefer).static void
fail(String failureMessage)
Only delegate toFail.fail(String)
so that Assertions offers a full feature entry point to all Assertj Assert features (but you can use Fail if you prefer).static void
fail(String failureMessage, Throwable realCause)
Only delegate toFail.fail(String, Throwable)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).static void
failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
Only delegate toFail.failBecauseExceptionWasNotThrown(Class)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).static <E> Filters<E>
filter(E[] array)
Only delegate toFilters.filter(Object[])
so that Assertions offers a full feature entry point to all AssertJ features (but you can useFilters
if you prefer).static <E> Filters<E>
filter(Iterable<E> iterableToFilter)
Only delegate toFilters.filter(Object[])
so that Assertions offers a full feature entry point to all AssertJ features (but you can useFilters
if you prefer).static InFilter
in(Object... values)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches one of the given values.static List<String>
linesOf(File file)
Loads the text content of a file into a list of strings with the default charset, each string corresponding to a line.static List<String>
linesOf(File file, String charsetName)
Loads the text content of a file into a list of strings, each string corresponding to a line.static List<String>
linesOf(File file, Charset charset)
Loads the text content of a file into a list of strings, each string corresponding to a line.static List<String>
linesOf(URL url)
Loads the text content of a URL into a list of strings with the default charset, each string corresponding to a line.static List<String>
linesOf(URL url, String charsetName)
Loads the text content of a URL into a list of strings, each string corresponding to a line.static List<String>
linesOf(URL url, Charset charset)
Loads the text content of a URL into a list of strings, each string corresponding to a line.static NotFilter
not(Object valueNotToMatch)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches does not match the given value.static <T> Not<T>
not(Condition<? super T> condition)
Creates a new
.Not
static NotInFilter
notIn(Object... valuesNotToMatch)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches does not match any of the given values.static Offset<Double>
offset(Double value)
Assertions entry point for doubleOffset
.static Offset<Float>
offset(Float value)
Assertions entry point for floatOffset
.static void
registerCustomDateFormat(String userCustomDateFormatPattern)
Add the given date format to the ones used to parse date String in String based Date assertions likeAbstractDateAssert.isEqualTo(String)
.static void
registerCustomDateFormat(DateFormat userCustomDateFormat)
Add the given date format to the ones used to parse date String in String based Date assertions likeAbstractDateAssert.isEqualTo(String)
.static void
setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
Globally sets whether the use of private fields is allowed for comparison.static void
setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
Globally sets whether
andIterableAssert#extracting(String)
should be allowed to extract private fields, if not and they try it fails with exception.ObjectArrayAssert#extracting(String)
static void
setLenientDateParsing(boolean value)
Instead of using default strict date/time parsing, it is possible to use lenient parsing mode for default date formats parser to interpret inputs that do not precisely match supported date formats (lenient parsing).static void
setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
In error messages, sets the threshold when iterable/array formatting will on one line (if their String description is less than this parameter) or it will be formatted with one element per line.static void
setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
Only delegate toFail.setRemoveAssertJRelatedElementsFromStackTrace(boolean)
so that Assertions offers a full feature entry point to all AssertJ Assert features (but you can useFail
if you prefer).static void
shouldHaveThrown(Class<? extends Throwable> throwableClass)
Only delegate toFail.shouldHaveThrown(Class)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).static Tuple
tuple(Object... values)
Utility method to build nicely aTuple
when working withAbstractIterableAssert.extracting(String...)
orAbstractObjectArrayAssert.extracting(String...)
static void
useDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.static Offset<Byte>
within(Byte value)
Assertions entry point for ByteOffset
to use with isCloseTo assertions.static Offset<Double>
within(Double value)
Alias foroffset(Double)
to use with isCloseTo assertions.static Offset<Float>
within(Float value)
Alias foroffset(Float)
to use with isCloseTo assertions.static Offset<Integer>
within(Integer value)
Assertions entry point for IntegerOffset
to use with isCloseTo assertions.static Offset<Long>
within(Long value)
Assertions entry point for LongOffset
to use with isCloseTo assertions.static Offset<Short>
within(Short value)
Assertions entry point for ShortOffset
to use with isCloseTo assertions.static Offset<BigDecimal>
within(BigDecimal value)
Assertions entry point for BigDecimalOffset
to use with isCloseTo assertions.static Percentage
withinPercentage(Double value)
Assertions entry point for DoublePercentage
to use with isCloseTo assertions for percentages.static Percentage
withinPercentage(Integer value)
Assertions entry point for IntegerPercentage
to use with isCloseTo assertions for percentages.static Percentage
withinPercentage(Long value)
Assertions entry point for LongPercentage
to use with isCloseTo assertions for percentages.
-
-
-
Constructor Detail
-
AssertionsForClassTypes
protected AssertionsForClassTypes()
Creates a new
.AssertionsForClassTypes
-
-
Method Detail
-
assertThat
public static <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletableFuture<RESULT> actual)
Create assertion forCompletableFuture
.- Type Parameters:
RESULT
- the type of the value contained in theCompletableFuture
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <VALUE> OptionalAssert<VALUE> assertThat(Optional<VALUE> actual)
Create assertion forOptional
.- Type Parameters:
VALUE
- the type of the value contained in theOptional
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static OptionalDoubleAssert assertThat(OptionalDouble actual)
Create assertion forOptionalDouble
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static OptionalIntAssert assertThat(OptionalInt actual)
Create assertion forOptionalInt
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static OptionalLongAssert assertThat(OptionalLong actual)
Create assertion forOptionalInt
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)
Creates a new instance of
.BigDecimalAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractUriAssert<?> assertThat(URI actual)
Creates a new instance of
.UriAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractUrlAssert<?> assertThat(URL actual)
Creates a new instance of
.UrlAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractBooleanAssert<?> assertThat(boolean actual)
Creates a new instance of
.BooleanAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractBooleanAssert<?> assertThat(Boolean actual)
Creates a new instance of
.BooleanAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)
Creates a new instance of
.BooleanArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractByteAssert<?> assertThat(byte actual)
Creates a new instance of
.ByteAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractByteAssert<?> assertThat(Byte actual)
Creates a new instance of
.ByteAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractByteArrayAssert<?> assertThat(byte[] actual)
Creates a new instance of
.ByteArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractCharacterAssert<?> assertThat(char actual)
Creates a new instance of
.CharacterAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractCharArrayAssert<?> assertThat(char[] actual)
Creates a new instance of
.CharArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractCharacterAssert<?> assertThat(Character actual)
Creates a new instance of
.CharacterAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static ClassAssert assertThat(Class<?> actual)
Creates a new instance ofClassAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractDoubleAssert<?> assertThat(double actual)
Creates a new instance of
.DoubleAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractDoubleAssert<?> assertThat(Double actual)
Creates a new instance of
.DoubleAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractDoubleArrayAssert<?> assertThat(double[] actual)
Creates a new instance of
.DoubleArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractFileAssert<?> assertThat(File actual)
Creates a new instance of
.FileAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)
Creates a new instance of
.InputStreamAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractFloatAssert<?> assertThat(float actual)
Creates a new instance of
.FloatAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractFloatAssert<?> assertThat(Float actual)
Creates a new instance of
.FloatAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractFloatArrayAssert<?> assertThat(float[] actual)
Creates a new instance of
.FloatArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractIntegerAssert<?> assertThat(int actual)
Creates a new instance of
.IntegerAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractIntArrayAssert<?> assertThat(int[] actual)
Creates a new instance of
.IntArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractIntegerAssert<?> assertThat(Integer actual)
Creates a new instance of
.IntegerAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLongAssert<?> assertThat(long actual)
Creates a new instance of
.LongAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLongAssert<?> assertThat(Long actual)
Creates a new instance of
.LongAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLongArrayAssert<?> assertThat(long[] actual)
Creates a new instance of
.LongArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <T> ObjectAssert<T> assertThat(T actual)
Creates a new instance of
.ObjectAssert
- Type Parameters:
T
- the actual value type.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static <T> ObjectArrayAssert<T> assertThat(T[] actual)
Creates a new instance of
.ObjectArrayAssert
- Type Parameters:
T
- the actual elements type.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractShortAssert<?> assertThat(short actual)
Creates a new instance of
.ShortAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractShortAssert<?> assertThat(Short actual)
Creates a new instance of
.ShortAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractShortArrayAssert<?> assertThat(short[] actual)
Creates a new instance of
.ShortArrayAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuilder actual)
Creates a new instance of
from aCharSequenceAssert
StringBuilder
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.11.0
-
assertThat
public static AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuffer actual)
Creates a new instance of
from aCharSequenceAssert
StringBuffer
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.11.0
-
assertThat
public static AbstractStringAssert<?> assertThat(String actual)
Creates a new instance of
.StringAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractDateAssert<?> assertThat(Date actual)
Creates a new instance of
.DateAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)
Creates a new instance of
.ZonedDateTimeAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime actual)
Creates a new instance of
.LocalDateTimeAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime actual)
Creates a new instance of
.OffsetDateTime
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractOffsetTimeAssert<?> assertThat(OffsetTime actual)
Create assertion forOffsetTime
.- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLocalTimeAssert<?> assertThat(LocalTime actual)
Creates a new instance of
.LocalTimeAssert
- Parameters:
actual
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractLocalDateAssert<?> assertThat(LocalDate localDate)
Creates a new instance of
.LocalDateAssert
- Parameters:
localDate
- the actual value.- Returns:
- the created assertion object.
-
assertThat
public static AbstractInstantAssert<?> assertThat(Instant instant)
Creates a new instance of
.InstantAssert
- Parameters:
instant
- the actual value.- Returns:
- the created assertion object.
- Since:
- 3.7.0
-
assertThat
public static AbstractThrowableAssert<?,? extends Throwable> assertThat(Throwable actual)
Creates a new instance of
.ThrowableAssert
- Parameters:
actual
- the actual value.- Returns:
- the created
ThrowableAssert
.
-
assertThatThrownBy
public static AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on aThrowable
(easier done with lambdas).Java 8 example :
If the provided@Test public void testException() { assertThatThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class) .hasMessageContaining("boom"); }
ThrowableAssert.ThrowingCallable
does not raise an exception, an error is immediately thrown, in that case the test description provided withas(String, Object...)
is not honored.
To use a test description, usecatchThrowable(ThrowableAssert.ThrowingCallable)
as shown below:
Alternatively you can also use// assertion will fail but "display me" won't appear in the error assertThatThrownBy(() -> {}).as("display me") .isInstanceOf(Exception.class); // assertion will fail AND "display me" will appear in the error Throwable thrown = catchThrowable(() -> {}); assertThat(thrown).as("display me") .isInstanceOf(Exception.class);
assertThatCode(ThrowingCallable)
for the test description provided withas(String, Object...)
to always be honored.- Parameters:
shouldRaiseThrowable
- TheThrowableAssert.ThrowingCallable
or lambda with the code that should raise the throwable.- Returns:
- the created
ThrowableAssert
.
-
assertThatThrownBy
public static AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)
Allows to capture and then assert on aThrowable
likeassertThatThrownBy(ThrowingCallable)
but this method let you set the assertion description the same way you do withas(String, Object...)
.Example:
If the provided@Test public void testException() { // if this assertion failed (but it doesn't), the error message would start with [Test explosive code] assertThatThrownBy(() -> { throw new IOException("boom!") }, "Test explosive code") .isInstanceOf(IOException.class) .hasMessageContaining("boom"); }
ThrowingCallable
does not raise an exception, an error is immediately thrown.The test description provided is honored but not the one with
as(String, Object...)
, example:// assertion will fail but "display me" won't appear in the error message assertThatThrownBy(() -> {}).as("display me") .isInstanceOf(Exception.class); // assertion will fail AND "display me" will appear in the error message assertThatThrownBy(() -> {}, "display me") .isInstanceOf(Exception.class);
- Parameters:
shouldRaiseThrowable
- TheThrowableAssert.ThrowingCallable
or lambda with the code that should raise the throwable.description
- the new description to set.args
- optional parameter if description is a format String.- Returns:
- the created
ThrowableAssert
. - Since:
- 3.9.0
-
assertThatExceptionOfType
public static <T extends Throwable> ThrowableTypeAssert<T> assertThatExceptionOfType(Class<? extends T> exceptionType)
Entry point to check that an exception of type T is thrown by a giventhrowingCallable
which allows to chain assertions on the thrown exception.Example:
This method is more or less the same ofassertThatExceptionOfType(IOException.class) .isThrownBy(() -> { throw new IOException("boom!"); }) .withMessage("boom!");
assertThatThrownBy(ThrowableAssert.ThrowingCallable)
but in a more natural way.- Type Parameters:
T
- the exception type.- Parameters:
exceptionType
- the class of exception type.- Returns:
- the created
ThrowableTypeAssert
.
-
assertThatCode
public static AbstractThrowableAssert<?,? extends Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on aThrowable
more easily when used with Java 8 lambdas.Example :
If the providedThrowingCallable callable = () -> { throw new Exception("boom!"); }; // assertion succeeds assertThatCode(callable).isInstanceOf(Exception.class) .hasMessageContaining("boom"); // assertion fails assertThatCode(callable).doesNotThrowAnyException();
ThrowableAssert.ThrowingCallable
does not validate against next assertions, an error is immediately raised, in that case the test description provided withas(String, Object...)
is not honored.
To use a test description, usecatchThrowable(ThrowableAssert.ThrowingCallable)
as shown below.ThrowingCallable doNothing = () -> { // do nothing }; // assertion fails and "display me" appears in the assertion error assertThatCode(doNothing).as("display me") .isInstanceOf(Exception.class); // assertion will fail AND "display me" will appear in the error Throwable thrown = catchThrowable(doNothing); assertThatCode(thrown).as("display me") .isInstanceOf(Exception.class);
This method was not named
assertThat
because the java compiler reported it ambiguous when used directly with a lambda :(- Parameters:
shouldRaiseOrNotThrowable
- TheThrowableAssert.ThrowingCallable
or lambda with the code that should raise the throwable.- Returns:
- The captured exception or
null
if none was raised by the callable. - Since:
- 3.7.0
-
catchThrowable
public static Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows catching aThrowable
more easily when used with Java 8 lambdas.This caught
Throwable
can then be asserted.Example:
@Test public void testException() { // when Throwable thrown = catchThrowable(() -> { throw new Exception("boom!"); }); // then assertThat(thrown).isInstanceOf(Exception.class) .hasMessageContaining("boom"); }
- Parameters:
shouldRaiseThrowable
- The lambda with the code that should raise the exception.- Returns:
- The captured exception or
null
if none was raised by the callable. - See Also:
catchThrowableOfType(ThrowableAssert.ThrowingCallable, Class)
-
catchThrowableOfType
public static <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)
Allows catching aThrowable
of a specific type.A call is made to
catchThrowable(ThrowingCallable)
, if no exception is throwncatchThrowableOfType
returns null, otherwise it checks that the caughtThrowable
has the specified type then casts it to it before returning it, making it convenient to perform subtype-specific assertions on the result.Example:
class CustomParseException extends Exception { int line; int column; public CustomParseException(String msg, int l, int c) { super(msg); line = l; column = c; } } CustomParseException e = catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); }, CustomParseException.class); // assertions pass assertThat(e).hasMessageContaining("boom"); assertThat(e.line).isEqualTo(1); assertThat(e.column).isEqualTo(5); // fails as CustomParseException is not a RuntimeException catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); }, RuntimeException.class);
- Type Parameters:
THROWABLE
- theThrowable
type.- Parameters:
shouldRaiseThrowable
- The lambda with the code that should raise the exception.type
- The type of exception that the code is expected to raise.- Returns:
- The captured exception or
null
if none was raised by the callable. - Since:
- 3.9.0
- See Also:
catchThrowable(ThrowableAssert.ThrowingCallable)
-
setRemoveAssertJRelatedElementsFromStackTrace
public static void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
Only delegate toFail.setRemoveAssertJRelatedElementsFromStackTrace(boolean)
so that Assertions offers a full feature entry point to all AssertJ Assert features (but you can useFail
if you prefer).- Parameters:
removeAssertJRelatedElementsFromStackTrace
- flag.
-
fail
public static void fail(String failureMessage)
Only delegate toFail.fail(String)
so that Assertions offers a full feature entry point to all Assertj Assert features (but you can use Fail if you prefer).- Parameters:
failureMessage
- error message.- Throws:
AssertionError
- with the given message.
-
fail
public static void fail(String failureMessage, Throwable realCause)
Only delegate toFail.fail(String, Throwable)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).- Parameters:
failureMessage
- the description of the failed assertion. It can benull
.realCause
- cause of the error.- Throws:
AssertionError
- with the given message and with theThrowable
that caused the failure.
-
failBecauseExceptionWasNotThrown
public static void failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
Only delegate toFail.failBecauseExceptionWasNotThrown(Class)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).Assertions.shouldHaveThrown(Class)
can be used as a replacement.- Parameters:
throwableClass
- the Throwable class that was expected to be thrown.- Throws:
AssertionError
- with a message explaining that aThrowable
of given class was expected to be thrown but had not been.
-
shouldHaveThrown
public static void shouldHaveThrown(Class<? extends Throwable> throwableClass)
Only delegate toFail.shouldHaveThrown(Class)
so that Assertions offers a full feature entry point to all AssertJ features (but you can use Fail if you prefer).- Parameters:
throwableClass
- the Throwable class that was expected to be thrown.- Throws:
AssertionError
- with a message explaining that aThrowable
of given class was expected to be thrown but had not been.
-
setMaxLengthForSingleLineDescription
public static void setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
In error messages, sets the threshold when iterable/array formatting will on one line (if their String description is less than this parameter) or it will be formatted with one element per line.The following array will be formatted on one line as its length < 80
whereas this array is formatted on multiple lines (one element per line)String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"); // formatted as: ["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"]
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards! (Discworld)"); // formatted as: ["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards! (Discworld)"]
- Parameters:
maxLengthForSingleLineDescription
- the maximum length for an iterable/array to be displayed on one line
-
extractProperty
public static <T> Properties<T> extractProperty(String propertyName, Class<T> propertyType)
Only delegate toProperties.extractProperty(String)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useProperties
if you prefer).Typical usage is to chain
extractProperty
withfrom
method, see examples below :// extract simple property values having a java standard type (here String) assertThat(extractProperty("name", String.class).from(fellowshipOfTheRing)) .contains("Boromir", "Gandalf", "Frodo", "Legolas") .doesNotContain("Sauron", "Elrond"); // extracting property works also with user's types (here Race) assertThat(extractProperty("race", String.class).from(fellowshipOfTheRing)) .contains(HOBBIT, ELF).doesNotContain(ORC); // extract nested property on Race assertThat(extractProperty("race.name", String.class).from(fellowshipOfTheRing)) .contains("Hobbit", "Elf") .doesNotContain("Orc");
- Type Parameters:
T
- the type of value to extract.- Parameters:
propertyName
- the name of the property to be read from the elements of aIterable
. It may be a nested property (e.g. "address.street.number").propertyType
- the type of property to extract- Returns:
- the created
Properties
. - Throws:
NullPointerException
- if the given property name isnull
.IllegalArgumentException
- if the given property name is empty.
-
extractProperty
public static Properties<Object> extractProperty(String propertyName)
Only delegate toProperties.extractProperty(String)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useProperties
if you prefer).Typical usage is to chain
extractProperty
withfrom
method, see examples below :// extract simple property values, as no type has been defined the extracted property will be considered as Object // to define the real property type (here String) use extractProperty("name", String.class) instead. assertThat(extractProperty("name").from(fellowshipOfTheRing)) .contains("Boromir", "Gandalf", "Frodo", "Legolas") .doesNotContain("Sauron", "Elrond"); // extracting property works also with user's types (here Race), even though it will be considered as Object // to define the real property type (here String) use extractProperty("name", Race.class) instead. assertThat(extractProperty("race").from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC); // extract nested property on Race assertThat(extractProperty("race.name").from(fellowshipOfTheRing)).contains("Hobbit", "Elf").doesNotContain("Orc");
- Parameters:
propertyName
- the name of the property to be read from the elements of aIterable
. It may be a nested property (e.g. "address.street.number").- Returns:
- the created
Properties
. - Throws:
NullPointerException
- if the given property name isnull
.IllegalArgumentException
- if the given property name is empty.
-
tuple
public static Tuple tuple(Object... values)
Utility method to build nicely aTuple
when working withAbstractIterableAssert.extracting(String...)
orAbstractObjectArrayAssert.extracting(String...)
-
setAllowExtractingPrivateFields
public static void setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
Globally sets whether
andIterableAssert#extracting(String)
should be allowed to extract private fields, if not and they try it fails with exception.ObjectArrayAssert#extracting(String)
- Parameters:
allowExtractingPrivateFields
- allow private fields extraction. Defaulttrue
.
-
setAllowComparingPrivateFields
public static void setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
Globally sets whether the use of private fields is allowed for comparison. The following (incomplete) list of methods will be impacted by this change :AbstractIterableAssert.usingElementComparatorOnFields(java.lang.String...)
AbstractObjectAssert.isEqualToComparingFieldByField(Object)
false
and these methods try to compare private fields, it will fail with an exception.- Parameters:
allowComparingPrivateFields
- allow private fields comparison. Defaulttrue
.
-
entry
public static <K,V> MapEntry<K,V> entry(K key, V value)
Only delegate toMapEntry.entry(Object, Object)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useMapEntry
if you prefer).Typical usage is to call
entry
in MapAssertcontains
assertion, see examples below :Map<Ring, TolkienCharacter> ringBearers = ... // init omitted assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));
- Type Parameters:
K
- the type of the key of this entry.V
- the type of the value of this entry.- Parameters:
key
- the key of the entry to create.value
- the value of the entry to create.- Returns:
- the created
MapEntry
.
-
atIndex
public static Index atIndex(int index)
Only delegate toIndex.atIndex(int)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useIndex
if you prefer).Typical usage :
List<Ring> elvesRings = newArrayList(vilya, nenya, narya); assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2));
- Parameters:
index
- the value of the index.- Returns:
- the created
Index
. - Throws:
IllegalArgumentException
- if the given value is negative.
-
offset
public static Offset<Double> offset(Double value)
Assertions entry point for doubleOffset
.Typical usage :
assertThat(8.1).isEqualTo(8.0, offset(0.1));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
offset
public static Offset<Float> offset(Float value)
Assertions entry point for floatOffset
.Typical usage :
assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Double> within(Double value)
Alias foroffset(Double)
to use with isCloseTo assertions.Typical usage :
assertThat(8.1).isCloseTo(8.0, within(0.1));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Float> within(Float value)
Alias foroffset(Float)
to use with isCloseTo assertions.Typical usage :
assertThat(8.2f).isCloseTo(8.0f, within(0.2f));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<BigDecimal> within(BigDecimal value)
Assertions entry point for BigDecimalOffset
to use with isCloseTo assertions.Typical usage :
assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), within(BigDecimal.ONE));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Byte> within(Byte value)
Assertions entry point for ByteOffset
to use with isCloseTo assertions.Typical usage :
assertThat((byte)10).isCloseTo((byte)11, within((byte)1));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Integer> within(Integer value)
Assertions entry point for IntegerOffset
to use with isCloseTo assertions.Typical usage :
assertThat(10).isCloseTo(11, within(1));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Short> within(Short value)
Assertions entry point for ShortOffset
to use with isCloseTo assertions.Typical usage :
assertThat(10).isCloseTo(11, within(1));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
within
public static Offset<Long> within(Long value)
Assertions entry point for LongOffset
to use with isCloseTo assertions.Typical usage :
assertThat(5l).isCloseTo(7l, within(2l));
- Parameters:
value
- the value of the offset.- Returns:
- the created
Offset
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
withinPercentage
public static Percentage withinPercentage(Double value)
Assertions entry point for DoublePercentage
to use with isCloseTo assertions for percentages.Typical usage :
assertThat(11.0).isCloseTo(10.0, withinPercentage(10.0));
- Parameters:
value
- the value of the percentage.- Returns:
- the created
Percentage
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
withinPercentage
public static Percentage withinPercentage(Integer value)
Assertions entry point for IntegerPercentage
to use with isCloseTo assertions for percentages.Typical usage :
assertThat(11).isCloseTo(10, withinPercentage(10));
- Parameters:
value
- the value of the percentage.- Returns:
- the created
Percentage
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
withinPercentage
public static Percentage withinPercentage(Long value)
Assertions entry point for LongPercentage
to use with isCloseTo assertions for percentages.Typical usage :
assertThat(11L).isCloseTo(10L, withinPercentage(10L));
- Parameters:
value
- the value of the percentage.- Returns:
- the created
Percentage
. - Throws:
NullPointerException
- if the given value isnull
.IllegalArgumentException
- if the given value is negative.
-
allOf
@SafeVarargs public static <T> Condition<T> allOf(Condition<? super T>... conditions)
Creates a newAllOf
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
conditions
- the conditions to evaluate.- Returns:
- the created
AnyOf
. - Throws:
NullPointerException
- if the given array isnull
.NullPointerException
- if any of the elements in the given array isnull
.
-
allOf
public static <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)
Creates a newAllOf
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
conditions
- the conditions to evaluate.- Returns:
- the created
AnyOf
. - Throws:
NullPointerException
- if the given iterable isnull
.NullPointerException
- if any of the elements in the given iterable isnull
.
-
anyOf
@SafeVarargs public static <T> Condition<T> anyOf(Condition<? super T>... conditions)
Only delegate toAnyOf.anyOf(Condition...)
so that Assertions offers a full feature entry point to all AssertJ features (but you can useAnyOf
if you prefer).Typical usage (
jedi
andsith
areCondition
) :assertThat("Vader").is(anyOf(jedi, sith));
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
conditions
- the conditions to evaluate.- Returns:
- the created
AnyOf
. - Throws:
NullPointerException
- if the given array isnull
.NullPointerException
- if any of the elements in the given array isnull
.
-
anyOf
public static <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)
Creates a newAnyOf
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
conditions
- the conditions to evaluate.- Returns:
- the created
AnyOf
. - Throws:
NullPointerException
- if the given iterable isnull
.NullPointerException
- if any of the elements in the given iterable isnull
.
-
doesNotHave
public static <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
Creates a new
.DoesNotHave
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
condition
- the condition to inverse.- Returns:
- The Not condition created.
-
not
public static <T> Not<T> not(Condition<? super T> condition)
Creates a new
.Not
- Type Parameters:
T
- the type of object the given condition accept.- Parameters:
condition
- the condition to inverse.- Returns:
- The Not condition created.
-
filter
public static <E> Filters<E> filter(E[] array)
Only delegate toFilters.filter(Object[])
so that Assertions offers a full feature entry point to all AssertJ features (but you can useFilters
if you prefer).Note that the given array is not modified, the filters are performed on an
Iterable
copy of the array.Typical usage with
Condition
:assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);
and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20).and("assistsPerGame").greaterThan(7).get()) .containsOnly(james, rose);
- Type Parameters:
E
- the array elements type.- Parameters:
array
- the array to filter.- Returns:
- the created
.Filters
- Throws:
NullPointerException
- if the given array isnull
.
-
filter
public static <E> Filters<E> filter(Iterable<E> iterableToFilter)
Only delegate toFilters.filter(Object[])
so that Assertions offers a full feature entry point to all AssertJ features (but you can useFilters
if you prefer).Note that the given
Iterable
is not modified, the filters are performed on a copy.Typical usage with
Condition
:assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);
and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20) .and("assistsPerGame").greaterThan(7).get()) .containsOnly(james, rose);
- Type Parameters:
E
- the iterable elements type.- Parameters:
iterableToFilter
- the iterable to filter.- Returns:
- the created
.Filters
- Throws:
NullPointerException
- if the given array isnull
.
-
in
public static InFilter in(Object... values)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches one of the given values.As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800); Employee obiwan = new Employee(2L, new Name("Obiwan"), 800); Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26); Employee noname = new Employee(4L, null, 50); List<Employee> employees = newArrayList(yoda, luke, obiwan, noname); assertThat(employees).filteredOn("age", in(800, 26)) .containsOnly(yoda, obiwan, luke);
- Parameters:
values
- values to match (one match is sufficient)- Returns:
- the created "in" filter
-
notIn
public static NotInFilter notIn(Object... valuesNotToMatch)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches does not match any of the given values.As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800); Employee obiwan = new Employee(2L, new Name("Obiwan"), 800); Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26); Employee noname = new Employee(4L, null, 50); List<Employee> employees = newArrayList(yoda, luke, obiwan, noname); assertThat(employees).filteredOn("age", notIn(800, 50)) .containsOnly(luke);
- Parameters:
valuesNotToMatch
- values not to match (none of the values must match)- Returns:
- the created "not in" filter
-
not
public static NotFilter not(Object valueNotToMatch)
Create aFilterOperator
to use infilteredOn(String, FilterOperation)
to express a filter keeping all Iterable elements whose property/field value matches does not match the given value.As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800); Employee obiwan = new Employee(2L, new Name("Obiwan"), 800); Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26); Employee noname = new Employee(4L, null, 50); List<Employee> employees = newArrayList(yoda, luke, obiwan, noname); assertThat(employees).filteredOn("age", not(800)) .containsOnly(luke, noname);
- Parameters:
valueNotToMatch
- the value not to match- Returns:
- the created "not" filter
-
contentOf
public static String contentOf(File file, Charset charset)
Loads the text content of a file, so that it can be passed toassertThat(String)
.Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with
assertThat(File)
.- Parameters:
file
- the file.charset
- the character set to use.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
contentOf
public static String contentOf(File file, String charsetName)
Loads the text content of a file, so that it can be passed toassertThat(String)
.Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with
assertThat(File)
.- Parameters:
file
- the file.charsetName
- the name of the character set to use.- Returns:
- the content of the file.
- Throws:
IllegalArgumentException
- if the given character set is not supported on this platform.UncheckedIOException
- if an I/O exception occurs.
-
contentOf
public static String contentOf(File file)
Loads the text content of a file with the default character set, so that it can be passed toassertThat(String)
.Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with
assertThat(File)
.- Parameters:
file
- the file.- Returns:
- the content of the file.
- Throws:
UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(File file)
Loads the text content of a file into a list of strings with the default charset, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
file
- the file.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(File file, Charset charset)
Loads the text content of a file into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
file
- the file.charset
- the character set to use.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(File file, String charsetName)
Loads the text content of a file into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
file
- the file.charsetName
- the name of the character set to use.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
contentOf
public static String contentOf(URL url, Charset charset)
Loads the text content of a URL, so that it can be passed toassertThat(String)
.Note that this will load the entire contents in memory.
- Parameters:
url
- the URL.charset
- the character set to use.- Returns:
- the content of the URL.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
contentOf
public static String contentOf(URL url, String charsetName)
Loads the text content of a URL, so that it can be passed toassertThat(String)
.Note that this will load the entire contents in memory.
- Parameters:
url
- the URL.charsetName
- the name of the character set to use.- Returns:
- the content of the URL.
- Throws:
IllegalArgumentException
- if the given character set is not supported on this platform.UncheckedIOException
- if an I/O exception occurs.
-
contentOf
public static String contentOf(URL url)
Loads the text content of a URL with the default character set, so that it can be passed toassertThat(String)
.Note that this will load the entire file in memory; for larger files.
- Parameters:
url
- the URL.- Returns:
- the content of the file.
- Throws:
UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(URL url)
Loads the text content of a URL into a list of strings with the default charset, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
url
- the URL.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(URL url, Charset charset)
Loads the text content of a URL into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
url
- the URL.charset
- the character set to use.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
linesOf
public static List<String> linesOf(URL url, String charsetName)
Loads the text content of a URL into a list of strings, each string corresponding to a line. The line endings are either \n, \r or \r\n.- Parameters:
url
- the URL.charsetName
- the name of the character set to use.- Returns:
- the content of the file.
- Throws:
NullPointerException
- if the given charset isnull
.UncheckedIOException
- if an I/O exception occurs.
-
setLenientDateParsing
public static void setLenientDateParsing(boolean value)
Instead of using default strict date/time parsing, it is possible to use lenient parsing mode for default date formats parser to interpret inputs that do not precisely match supported date formats (lenient parsing).With strict parsing, inputs must match exactly date/time format.
Example:
To revert to default strict date parsing, callfinal Date date = Dates.parse("2001-02-03"); final Date dateTime = parseDatetime("2001-02-03T04:05:06"); final Date dateTimeWithMs = parseDatetimeWithMs("2001-02-03T04:05:06.700"); Assertions.setLenientDateParsing(true); // assertions will pass assertThat(date).isEqualTo("2001-01-34"); assertThat(date).isEqualTo("2001-02-02T24:00:00"); assertThat(date).isEqualTo("2001-02-04T-24:00:00.000"); assertThat(dateTime).isEqualTo("2001-02-03T04:05:05.1000"); assertThat(dateTime).isEqualTo("2001-02-03T04:04:66"); assertThat(dateTimeWithMs).isEqualTo("2001-02-03T04:05:07.-300"); // assertions will fail assertThat(date).hasSameTimeAs("2001-02-04"); // different date assertThat(dateTime).hasSameTimeAs("2001-02-03 04:05:06"); // leniency does not help here
setLenientDateParsing(false)
.- Parameters:
value
- whether lenient parsing mode should be enabled or not
-
registerCustomDateFormat
public static void registerCustomDateFormat(DateFormat userCustomDateFormat)
Add the given date format to the ones used to parse date String in String based Date assertions likeAbstractDateAssert.isEqualTo(String)
.User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)
AbstractDateAssert.withDateFormat(java.text.DateFormat)
registerCustomDateFormat(java.text.DateFormat)
registerCustomDateFormat(String)
Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite
To revert to default formats only, call
useDefaultDateFormatsOnly()
orAbstractDateAssert.withDefaultDateFormatsOnly()
.Code examples:
Date date = ... // set to 2003 April the 26th assertThat(date).isEqualTo("2003-04-26"); try { // date with a custom format : failure since the default formats don't match. assertThat(date).isEqualTo("2003/04/26"); } catch (AssertionError e) { assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " + "[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]"); } // registering a custom date format to make the assertion pass registerCustomDateFormat(new SimpleDateFormat("yyyy/MM/dd")); // registerCustomDateFormat("yyyy/MM/dd") would work to. assertThat(date).isEqualTo("2003/04/26"); // the default formats are still available and should work assertThat(date).isEqualTo("2003-04-26");
- Parameters:
userCustomDateFormat
- the new Date format used for String based Date assertions.
-
registerCustomDateFormat
public static void registerCustomDateFormat(String userCustomDateFormatPattern)
Add the given date format to the ones used to parse date String in String based Date assertions likeAbstractDateAssert.isEqualTo(String)
.User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)
AbstractDateAssert.withDateFormat(java.text.DateFormat)
registerCustomDateFormat(java.text.DateFormat)
registerCustomDateFormat(String)
Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite
To revert to default formats only, call
useDefaultDateFormatsOnly()
orAbstractDateAssert.withDefaultDateFormatsOnly()
.Code examples:
Date date = ... // set to 2003 April the 26th assertThat(date).isEqualTo("2003-04-26"); try { // date with a custom format : failure since the default formats don't match. assertThat(date).isEqualTo("2003/04/26"); } catch (AssertionError e) { assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " + "[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]"); } // registering a custom date format to make the assertion pass registerCustomDateFormat("yyyy/MM/dd"); assertThat(date).isEqualTo("2003/04/26"); // the default formats are still available and should work assertThat(date).isEqualTo("2003-04-26");
- Parameters:
userCustomDateFormatPattern
- the new Date format pattern used for String based Date assertions.
-
useDefaultDateFormatsOnly
public static void useDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.Beware that the default formats are expressed in the current local timezone.
Defaults date format are:
yyyy-MM-dd'T'HH:mm:ss.SSS
yyyy-MM-dd HH:mm:ss.SSS
(forTimestamp
String representation support)yyyy-MM-dd'T'HH:mm:ss
yyyy-MM-dd
Example of valid string date representations:
2003-04-26T03:01:02.999
2003-04-26 03:01:02.999
2003-04-26T13:01:02
2003-04-26
-
-