16f6c0aecf
Inline adoc files when they are included exactly once. Also fix language tags because this inlining gives us better information on what language the code is written in.
146 lines
8.2 KiB
Plaintext
146 lines
8.2 KiB
Plaintext
== 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.
|
||
|
||
[frame=all]
|
||
[cols="^1,^1"]
|
||
|===
|
||
|Original|Dedicated
|
||
|
||
s|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)++``
|
||
|
||
s|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)++``
|
||
|
||
s|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)++``
|
||
|
||
s| 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()++``
|
||
|
||
s| 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()++``
|
||
|
||
s| 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)++``
|
||
|
||
s|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)++``
|
||
|
||
s|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)++``
|
||
|
||
s|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
|
||
|
||
[source,java]
|
||
----
|
||
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
|
||
|
||
[source,java]
|
||
----
|
||
assertThat(getObject()).isNull();
|
||
assertThat(getObject()).isNotNull();
|
||
|
||
assertThat(getString()).isBlank();
|
||
assertThat(getFile()).canRead();
|
||
assertThat(getPath()).hasNoParentRaw();
|
||
----
|
||
|
||
ifdef::env-github,rspecator-view[]
|
||
|
||
'''
|
||
== Implementation Specification
|
||
(visible only on this page)
|
||
|
||
=== Message
|
||
|
||
Use XXX instead.
|
||
|
||
|
||
=== Highlighting
|
||
|
||
assertThat(expression).method()
|
||
|
||
* Primary: method
|
||
* Secondary: expression
|
||
|
||
|
||
endif::env-github,rspecator-view[]
|