Assertions comparing incompatible types always fail, and negative assertions always pass. At best, negative assertions are useless. At worst, the developer loses time trying to fix his code logic before noticing wrong assertions.
Dissimilar types are:
This rule also raises issues for unrelated class
and interface
or unrelated interface
types in negative
assertions. Because except in some corner cases, those types are more likely to be dissimilar. And inside a negative assertion, there is no test
failure to inform the developer about this unusual comparison.
Supported test frameworks:
interface KitchenTool {} interface Plant {} class Spatula implements KitchenTool {} class Tree implements Plant {} void assertValues(int size, Spatula spatula, KitchenTool tool, KitchenTool[] tools, Tree tree, Plant plant, Tree[] trees) { // Whatever the given values, those negative assertions will always pass due to dissimilar types: assertThat(size).isNotNull(); // Noncompliant; primitives can not be null assertThat(spatula).isNotEqualTo(tree); // Noncompliant; unrelated classes assertThat(tool).isNotSameAs(tools); // Noncompliant; array & non-array assertThat(trees).isNotEqualTo(tools); // Noncompliant; incompatible arrays // Those assertions will always fail assertThat(size).isNull(); // Noncompliant assertThat(spatula).isEqualTo(tree); // Noncompliant // Those negative assertions are more likely to always pass assertThat(spatula).isNotEqualTo(plant); // Noncompliant; unrelated class and interface assertThat(tool).isNotEqualTo(plant); // Noncompliant; unrelated interfaces }