Chained AssertJ assertions should be simplified to the corresponding dedicated assertion

intentionality - clear

maintainability

Code Smell

Quick FixIDE quick fixes available with SonarQube for IDE

Why is this an issue?

AssertJ contains many assertions methods specific to common types. Both versions will test the same things, but the dedicated one will provide a better error message, simplifying the debugging process.

This rule reports an issue when an assertion can be simplified to a dedicated one.

The array below gives a non-exhaustive list of assertion reported by the rule. Code behaving similarly, or with a negation will also be reported.

Original	Dedicated
Related to Object
`assertThat(getObject()).isEqualTo(null)`	`assertThat(getObject()).isNull()`
`assertThat(getBoolean()).isEqualTo(true)`	`assertThat(getBoolean()).isTrue()`
`assertThat(getBoolean()).isEqualTo(false)`	`assertThat(getBoolean()).isFalse()`
`assertThat(x.equals(y)).isTrue()`	`assertThat(x).isEqualTo(y)`
`assertThat(x == y).isTrue()`	`assertThat(x).isSameAs(y)`
`assertThat(x == null).isTrue()`	`assertThat(x).isNull()`
`assertThat(x.toString()).isEqualTo(y)`	`assertThat(x).hasToString(y)`
`assertThat(x.hashCode()).isEqualTo(y.hashCode())`	`assertThat(x).hasSameHashCodeAs(y)`
`assertThat(getObject() instanceof MyClass).isTrue()`	`assertThat(getObject()).isInstanceOf(MyClass.class)`
Related to `Comparable`
`assertThat(x.compareTo(y)).isZero()`	`assertThat(x).isEqualByComparingTo(y)`
`assertThat(x >= y).isTrue()`	`assertThat(x).isGreaterThanOrEqualTo(y)`
`assertThat(x > y).isTrue()`	`assertThat(x).isGreaterThan(y)`
`assertThat(x <= y).isTrue()`	`assertThat(x).isLessThanOrEqualTo(y)`
`assertThat(x < y).isTrue()`	`assertThat(x).isLessThan(y)`
Related to `String`
`assertThat(getString().isEmpty()).isTrue()`	`assertThat(getString()).isEmpty()`
`assertThat(getString()).hasSize(0)`	`assertThat(getString()).isEmpty()`
`assertThat(getString().equals(expected)).isTrue()`	`assertThat(getString()).isEqualTo(expected)`
`assertThat(getString().equalsIgnoreCase(expected)).isTrue()`	`assertThat(getString()).isEqualToIgnoringCase(expected)`
`assertThat(getString().contains(expected)).isTrue()`	`assertThat(getString()).contains(expected)`
`assertThat(getString().startsWith(expected)).isTrue()`	`assertThat(getString()).startsWith(expected)`
`assertThat(getString().endsWith(expected)).isTrue()`	`assertThat(getString()).endsWith(expected)`
`assertThat(getString().matches(expected)).isTrue()`	`assertThat(getString()).matches(expected)`
`assertThat(getString().trim()).isEmpty()`	`assertThat(getString()).isBlank()`
`assertThat(getString().length()).isEqualTo(length)`	`assertThat(getString()).hasSize(length)`
`assertThat(getString().length()).hasSize(expected.length())`	`assertThat(getString()).hasSameSizeAs(expected)`
Related to `File`
`assertThat(getFile()).hasSize(0)`	`assertThat(getFile()).isEmpty()`
`assertThat(getFile().length()).isZero()`	`assertThat(getFile()).isEmpty()`
`assertThat(getFile().length()).isEqualTo(length)`	`assertThat(getFile()).hasSize(length)`
`assertThat(getFile().canRead()).isTrue()`	`assertThat(getFile()).canRead()`
`assertThat(getFile().canWrite()).isTrue()`	`assertThat(getFile()).canWrite()`
`assertThat(getFile().exists()).isTrue()`	`assertThat(getFile()).exists()`
`assertThat(getFile().getName()).isEqualTo(name)`	`assertThat(getFile()).hasName(name)`
`assertThat(getFile().getParent()).isEqualTo(pathname)`	`assertThat(getFile()).hasParent(pathname)`
`assertThat(getFile().getParentFile()).isNull()`	`assertThat(getFile()).hasNoParent()`
`assertThat(getFile().isAbsolute()).isTrue()`	`assertThat(getFile()).isAbsolute()`
`assertThat(getFile().isAbsolute()).isFalse()`	`assertThat(getFile()).isRelative()`
`assertThat(getFile().isDirectory()).isTrue()`	`assertThat(getFile()).isDirectory()`
`assertThat(getFile().isFile()).isTrue()`	`assertThat(getFile()).isFile()`
`assertThat(getFile().list()).isEmpty()`	`assertThat(getFile()).isEmptyDirectory()`
Related to `Path`
`assertThat(getPath().startsWith(path)).isTrue()`	`assertThat(getPath()).startsWithRaw(path)`
`assertThat(getPath().endsWith(path)).isTrue()`	`assertThat(getPath()).endsWithRaw(path)`
`assertThat(getPath().getParent()).isEqualTo(name)`	`assertThat(getPath()).hasParentRaw(name)`
`assertThat(getPath().getParent()).isNull()`	`assertThat(getPath()).hasNoParentRaw()`
`assertThat(getPath().isAbsolute()).isTrue()`	`assertThat(getPath()).isAbsolute()`
`assertThat(getPath().isAbsolute()).isFalse()`	`assertThat(getPath()).isRelative()`
Related to `Array`
`assertThat(getArray().length).isZero()`	`assertThat(getArray()).isEmpty()`
`assertThat(getArray().length).isEqualTo(length)`	`assertThat(getArray()).hasSize(length)`
`assertThat(getArray().length).isEqualTo(anotherArray.length)`	`assertThat(getArray()).hasSameSizeAs(anotherArray)`
`assertThat(getArray().length).isLessThanOrEqualTo(expression)`	`assertThat(getArray()).hasSizeLessThanOrEqualTo(expression)`
`assertThat(getArray().length).isLessThan(expression)`	`assertThat(getArray()).hasSizeLessThan(expression)`
`assertThat(getArray().length).isGreaterThan(expression)`	`assertThat(getArray()).hasSizeGreaterThan(expression)`
`assertThat(getArray().length).isGreaterThanOrEqualTo(expression)`	`assertThat(getArray()).hasSizeGreaterThanOrEqualTo(expression)`
Related to `Collection`
`assertThat(getCollection().isEmpty()).isTrue()`	`assertThat(getCollection()).isEmpty()`
`assertThat(getCollection().size()).isZero()`	`assertThat(getCollection()).isEmpty()`
`assertThat(getCollection().contains(something)).isTrue()`	`assertThat(getCollection()).contains(something)`
`assertThat(getCollection().containsAll(otherCollection)).isTrue()`	`assertThat(getCollection()).containsAll(otherCollection)`
Related to `Map`
`assertThat(getMap().size()).isEqualTo(otherMap().size()`	`assertThat(getMap()).hasSameSizeAs(otherMap())`
`assertThat(getMap().containsKey(key)).isTrue()`	`assertThat(getMap()).containsKey(key)`
`assertThat(getMap().keySet()).contains(key)`	`assertThat(getMap()).containsKey(key)`
`assertThat(getMap().keySet()).containsOnlyKey(key)`	`assertThat(getMap()).containsOnlyKey(key)`
`assertThat(getMap().containsValue(value)).isTrue()`	`assertThat(getMap()).containsValue(value)`
`assertThat(getMap().values()).contains(value)`	`assertThat(getMap()).containsValue(value)`
`assertThat(getMap().get(key)).isEqualTo(value)`	`assertThat(getMap()).containsEntry(key, value)`
Related to `Optional`
`assertThat(getOptional().isPresent()).isTrue()`	`assertThat(getOptional()).isPresent()`
`assertThat(getOptional().get()).isEqualTo(something)`	`assertThat(getOptional()).contains(something)`
`assertThat(getOptional().get()).isSameAs(something)`	`assertThat(getOptional()).containsSame(something)`

Noncompliant code example

assertThat(getObject()).isEqualTo(null); // Noncompliant
assertThat(getObject()).isNotEqualTo(null); // Noncompliant - not listed above but also supported

assertThat(getString().trim()).isEmpty();
assertThat(getFile().canRead()).isTrue();
assertThat(getPath().getParent()).isNull();

Compliant solution

assertThat(getObject()).isNull();
assertThat(getObject()).isNotNull();

assertThat(getString()).isBlank();
assertThat(getFile()).canRead();
assertThat(getPath()).hasNoParentRaw();

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

Available Since
9.1

Analyze code in your
on-premise CI

Developer Edition
Available Since
9.1

In-IDE

SaaS

Self-Hosted