Deprecated API

use asInstanceOf(InstanceOfAssertFactories.LIST) instead

Custom element Comparator is not supported for Boolean array comparison.

Custom Comparator is not supported for Boolean comparison.

use asBase64Encoded() instead.

Encodes the actual array into a Base64 string, the encoded string becoming the new object under test.

Examples:

 // assertion succeeds
assertThat("AssertJ".getBytes()).encodedAsBase64().isEqualTo("QXNzZXJ0Sg==");

Use isNotBlank() instead.

Custom element Comparator is not supported for CharSequence comparison.

Combine isCompletedExceptionally with isNotCancelled instead:

 assertThat(future).isCompletedExceptionally()
                  .isNotCancelled();

Original javadoc

Verifies that the CompletableFuture has completed exceptionally but has not been cancelled, this assertion is equivalent to:

 assertThat(future).isCompletedExceptionally()
                  .isNotCancelled();

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
future.completeExceptionally(new RuntimeException());
assertThat(future).hasFailed();

 CompletableFuture future = new CompletableFuture();
future.cancel(true);
assertThat(future).hasFailed();

Use matches with the following combination instead:

 assertThat(future).matches (f -> f.isNotCompletedExceptionally() || f.isCancelled());

Original javadoc

Verifies that the CompletableFuture has not failed i.e: incomplete, completed or cancelled.
This is different from isNotCompletedExceptionally() as a cancelled future has not failed but is completed exceptionally.

Assertion will pass :

 CompletableFuture future = new CompletableFuture();
future.cancel(true);
assertThat(future).hasNotFailed();

 CompletableFuture future = new CompletableFuture();
future.completeExceptionally(new RuntimeException());
assertThat(future).hasNotFailed();

prefer calling isAfterOrEqualTo(String)

prefer calling isBeforeOrEqualTo(String)

Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

use hasDayOfWeek(int) instead.

use hasMillisecond(int) instead.

use hasMonth(int) instead.

use hasYear(int) instead.

use hasSameTextualContentAs(File) instead.

Verifies that the content of the actual File is equal to the content of the given one. The charset to use when reading the actual file can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset#defaultCharset()) will be used. Examples:

 // use the default charset
File xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes()).toFile();
File xFileClone = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes()).toFile();
File xFileFrench = Files.write(Paths.get("xfile-french.txt"), "La Vérité Est Ailleurs".getBytes()).toFile();
// use UTF-8 charset
File xFileUTF8 = Files.write(Paths.get("xfile-clone.txt"), Arrays.asList("The Truth Is Out There"), StandardCharsets.UTF_8).toFile();

// The following assertion succeeds (default charset is used):
assertThat(xFile).hasSameContentAs(xFileClone);
// The following assertion succeeds (UTF-8 charset is used to read xFile):
assertThat(xFileUTF8).usingCharset("UTF-8").hasSameContentAs(xFileClone);

// The following assertion fails:
assertThat(xFile).hasSameContentAs(xFileFrench);

use hasSameContentAs(InputStream) instead

use singleElement() instead

This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or usingRecursiveComparison().

When using usingRecursiveComparison() the equivalent is:

• RecursiveComparisonAssert#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonAssert#withComparatorForType(Comparator, Class)

and when using RecursiveComparisonConfiguration:

• RecursiveComparisonConfiguration.Builder#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonConfiguration.Builder#withComparatorForType(Comparator, Class)

This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparatorOnFields(String...) instead.
See https://assertj.github.io/doc/#assertj-core-recursive-comparison

Use isCloseTo(LocalDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(LocalDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(LocalTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

use extractingByKey(Object) instead

Custom element Comparator is not supported for MapEntry comparison.

This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or usingRecursiveComparison().

When using usingRecursiveComparison() the equivalent is:

• RecursiveComparisonAssert#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonAssert#withComparatorForType(Comparator, Class)

and when using RecursiveComparisonConfiguration:

• RecursiveComparisonConfiguration.Builder#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonConfiguration.Builder#withComparatorForType(Comparator, Class)

This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparatorOnFields(String...) instead.
See https://assertj.github.io/doc/#assertj-core-recursive-comparison

Use the recursive comparison by calling usingRecursiveComparison().

This method is deprecated because it only compares the first level of fields while the recursive comparison traverses all fields recursively (only stopping at java types).

For example suppose actual and expected are of type A which has the following structure:

 A
|— B b
|    |— String s
|    |— C c
|         |— String s
|         |— Date d
|— int i 

Concretely instead of writing:

 assertThat(actual).isEqualToComparingFieldByField(expected);

 assertThat(actual).usingRecursiveComparison()
                  .isEqualTo(expected);

Asserts that actual object is equal to the given object based on a property/field by property/field comparison (including inherited ones). This can be handy if equals implementation of objects to compare does not suit you.

Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its equals method.

If an object has a field and a property with the same name, the property value will be used over the field.

Private fields are used in comparison but this can be disabled using Assertions#setAllowComparingPrivateFields(boolean), if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.

The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected the other object to also have one.

Example:

 // equals not overridden in TolkienCharacter
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);

// Fail as equals compares object references
assertThat(frodo).isEqualTo(frodoClone);

// frodo and frodoClone are equals when doing a field by field comparison.
assertThat(frodo).isEqualToComparingFieldByField(frodoClone);

Use the recursive comparison by calling usingRecursiveComparison() and specify the fields to ignore.

Warning: the recursive comparison does not provide a strictly equivalent feature, instead it provides several ways to ignore fields in the comparison by specifying fields to ignore, or fields by type or fields matching regexes. The idea being that it is best to compare as many fields as possible and only ignore the ones that are not relevant (for example generated ids).

This method is deprecated because it only compares the first level of fields while the recursive comparison traverses all fields recursively (only stopping at java types).

For example suppose actual and expected are of type A which has the following structure:

 A
|— B b
|    |— String s
|    |— C c
|         |— String s
|         |— Date d
|— int i

Assuming actual has 4 fields f1, f2, f3, f4, instead of writing:

 assertThat(actual).isEqualToComparingOnlyGivenFields(expected, f1, f2);

 assertThat(actual).usingRecursiveComparison()
                  .ignoringFields(f3, f4)
                  .isEqualTo(expected);

Asserts that the actual object is equal to the given one using a property/field by property/field comparison on the given properties/fields only (fields can be inherited fields or nested fields). This can be handy if equals implementation of objects to compare does not suit you.

Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its equals method.

If an object has a field and a property with the same name, the property value will be used over the field.

Private fields are used in comparison but this can be disabled using Assertions#setAllowComparingPrivateFields(boolean), if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.

The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected the other object to also have one.

Example:

 TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);

// frodo and sam both are hobbits, so they are equals when comparing only race
assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "race"); // OK

// they are also equals when comparing only race name (nested field).
assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "race.name"); // OK

// ... but not when comparing both name and race
assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "name", "race"); // FAIL

Use the recursive comparison by calling usingRecursiveComparison() and chain with ignoringExpectedNullFields().

This method is deprecated because it only compares the first level of fields while the recursive comparison traverses all fields recursively (only stopping at java types).

For example suppose actual and expected are of type A which has the following structure:

 A
|— B b
|    |— String s
|    |— C c
|         |— String s
|         |— Date d
|— int i

Concretely instead of writing:

 assertThat(actual).isEqualToIgnoringNullFields(expected);

 assertThat(actual).usingRecursiveComparison()
                  .ignoringExpectedNullFields()
                  .isEqualTo(expected);

Note that the recursive comparison also allows to ignore actual's null fields with ignoringActualNullFields(). Original javadoc

Asserts that the actual object is equal to the given one by comparing actual's properties/fields with other's not null properties/fields only (including inherited ones).

It means that if an actual field is not null and the corresponding field in other is null, this field will be ignored in comparison, but the opposite will make assertion fail (null field in actual, not null in other) as the field is used in the performed comparison and the values differ.

Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its equals method.

If an object has a field and a property with the same name, the property value will be used over the field.

Private fields are used in comparison but this can be disabled using Assertions#setAllowComparingPrivateFields(boolean), if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.

The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected other object to also have one.

Example:

 TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter mysteriousHobbit = new TolkienCharacter(null, 33, HOBBIT);

// Null fields in other/expected object are ignored, the mysteriousHobbit has null name thus name is ignored
assertThat(frodo).isEqualToIgnoringNullFields(mysteriousHobbit); // OK

// ... but this is not reversible !
assertThat(mysteriousHobbit).isEqualToIgnoringNullFields(frodo); // FAIL

Use isCloseTo(OffsetDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(OffsetDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(OffsetTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

use hasSameTextualContentAs(Path) instead

Verifies that the content of the actual Path is the same as the given one (both paths must be a readable files). The charset to use when reading the actual path can be provided with usingCharset(Charset) or usingCharset(String) prior to calling this method; if not, the platform's default charset (as returned by Charset#defaultCharset()) will be used. Examples:

 // use the default charset
Path xFile = Files.write(Paths.get("xfile.txt"), "The Truth Is Out There".getBytes());
Path xFileUTF8 = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes("UTF-8"));
Path xFileClone = Files.write(Paths.get("xfile-clone.txt"), "The Truth Is Out There".getBytes());
Path xFileFrench = Files.write(Paths.get("xfile-french.txt"), "La Vérité Est Ailleurs".getBytes());

// The following assertion succeeds (default charset is used):
assertThat(xFile).hasSameContentAs(xFileClone);
// The following assertion succeeds (UTF-8 charset is used to read xFile):
assertThat(xFileUTF8).usingCharset("UTF-8").hasContent(xFileClone);

// The following assertion fails:
assertThat(xFile).hasSameContentAs(xFileFrench);

use asBase64Decoded() instead.

Decodes the actual value as a Base64 encoded string, the decoded bytes becoming the new array under test.

Examples:

 // assertion succeeds
assertThat("QXNzZXJ0Sg==").decodedAsBase64().containsExactly("AssertJ".getBytes());

// assertion succeeds even without padding as it is optional by specification
assertThat("QXNzZXJ0Sg").decodedAsBase64().containsExactly("AssertJ".getBytes());

// assertion fails as it has invalid Base64 characters
assertThat("inv@lid").decodedAsBase64();

use rootCause() instead.

Returns a new assertion object that uses the root cause of the current Throwable as the actual Throwable under test.

Examples:

 Throwable rootCause =  new JdbcException("invalid query");
Throwable cause =  new RuntimeException(rootCause);
Throwable exception = new Exception("boom!", cause);

// typical use:
assertThat(throwableWithMessage).getRootCause()
                                .hasMessageStartingWith("invalid");

Use isCloseTo(ZonedDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Use isCloseTo(ZonedDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.

Throws UnsupportedOperationException if called. It is easy to accidentally call equals(Object) instead of isEqualTo(Object).

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

use catchThrowableOfType(Class, ThrowingCallable) instead.

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

Custom Comparator is not supported for Boolean comparison.

This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or usingRecursiveComparison().

When using usingRecursiveComparison() the equivalent is:

• RecursiveComparisonAssert#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonAssert#withComparatorForType(Comparator, Class)

and when using RecursiveComparisonConfiguration:

• RecursiveComparisonConfiguration.Builder#withEqualsForType(java.util.function.BiPredicate, Class)
• RecursiveComparisonConfiguration.Builder#withComparatorForType(Comparator, Class)

This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparatorOnFields(String...) instead.
See https://assertj.github.io/doc/#assertj-core-recursive-comparison

use catchThrowableOfType(Class, ThrowingCallable) instead.

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
then(hobbits, StringAssert.class).first()
                                 .startsWith("fro")
                                 .endsWith("do");

New way:

 then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
             .startsWith("fro")
             .endsWith("do");

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
then(hobbits, StringAssert.class).first()
                                 .startsWith("fro")
                                 .endsWith("do");

New way:

 then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
             .startsWith("fro")
             .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

use SoftAssertionsExtension instead. Same as SoftAssertions, but with the following differences:
First, it's a JUnit Jupiter extension, which can be used without having to call assertAll(), example:

 public class SoftlyTest {

    @RegisterExtension
    public final JUnitJupiterSoftAssertions softly = new JUnitJupiterSoftAssertions();

    @Test
    public void testSoftly() throws Exception {
      softly.assertThat(1).isEqualTo(2);
      softly.assertThat(Lists.newArrayList(1, 2)).containsOnly(1, 2);
    }
 }

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert::new).first()
                                      .startsWith("fro")
                                      .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert::new).first()
                                      .startsWith("fro")
                                      .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

use catchThrowableOfType(Class, ThrowingCallable) instead.

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
then(hobbits, StringAssert::new).first()
                                .startsWith("fro")
                                .endsWith("do");

New way:

 then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
             .startsWith("fro")
             .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
then(hobbits, StringAssert::new).first()
                                .startsWith("fro")
                                .endsWith("do");

New way:

 then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
             .startsWith("fro")
             .endsWith("do");

For Android compatible assertions use the latest assertj 2.x version which is based on Java 7 only.

BDD-style Android-compatible soft assertions. Duplicated from BDDSoftAssertions.

For Android compatible assertions use the latest assertj 2.x version which is based on Java 7 only.

JUnitSoftAssertions rule compatible with Android. Duplicated from JUnitSoftAssertions.

use assertThat(actual.get()) or AtomicReferenceAssert#hasValueSatisfying(Consumer).

This was added to help creating type-specific assertions for the elements of an Iterable instance.

Deprecated way:

 Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert::new).first()
                                      .startsWith("fro")
                                      .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

This was added to help creating type-specific assertions for the elements of an List instance.

Deprecated way:

 List<String> hobbits = List.of("frodo", "sam", "Pippin");
assertThat(hobbits, StringAssert.class).first()
                                       .startsWith("fro")
                                       .endsWith("do");

New way:

 assertThat(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
                   .startsWith("fro")
                   .endsWith("do");

use catchThrowableOfType(Class, ThrowingCallable) instead.

This functionality (and more) has been rolled into SoftAssertionsExtension as of AssertJ 3.18.0.

use exactlyMatches(String) instead.

use AssertionErrorMessagesAggregator instead

Deprecated as a consequence of AssertionErrorFactory being deprecated.

Deprecated as a consequence of AssertionErrorFactory being deprecated. See corresponding docs for further information.

Use shouldBeGreaterOrEqual(Object, Object, ComparisonStrategy) instead.

Use shouldBeLessOrEqual(Object, Object, ComparisonStrategy) instead.

This comparator is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use AbstractIterableAssert#usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or AbstractObjectAssert#usingRecursiveComparison() instead to perform a true recursive comparison.

This comparator is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use AbstractIterableAssert#usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or AbstractObjectAssert#usingRecursiveComparison() instead to perform a true recursive comparison.

Use either org.junit.jupiter.api.io.TempDir or org.junit.rules.TemporaryFolder

use StandardRepresentation#toStringOf(Map) instead.

Use java.util.Objects#deepEquals(Object, Object) instead.

use java.util.Objects#requireNonNull(Object) instead.