chrisly42/cajon-plugin
1
0
Fork 0
Code Issues 4 Pull Requests 1 Packages Projects Releases Wiki Activity

Added new TwistedAssertion inspection that will warn about assertions with the actual expression being a constant indicating swapped use of actual and expected expressions.

Browse Source 
Added new BogusAssertion inspection that showing typical copy and paste errors where actual and expected expressions are the same.
This commit is contained in:
chrisly42
2020-02-14 13:36:04 +01:00
parent 58298fabc6
commit 62f59b0fe2
18 changed files with 702 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/resources/inspections/BogusAssertion/BogusAssertionBefore.java
+196
View File
@@ -0,0 +1,196 @@
import java.util.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
public class BogusAssertions {
private void bogusAssertions() {
boolean[] boolarray = new boolean[10];
byte[] bytearray = new byte[10];
short[] shortarray = new short[10];
int[] intarray = new int[10];
long[] longarray = new long[10];
float[] floatarray = new float[10];
double[] doublearray = new double[10];
char[] chararray = new char[10];
Object[] objarray = new Object[10];
String string = "foo";
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
String bar = "bar";
assertThat(boolarray).isEqualTo(boolarray);
assertThat(boolarray).isSameAs(boolarray);
assertThat(boolarray).hasSameClassAs(boolarray);
assertThat(boolarray).hasSameHashCodeAs(boolarray);
assertThat(boolarray).hasSameSizeAs(boolarray);
assertThat(boolarray).contains(boolarray);
assertThat(boolarray).containsAnyOf(boolarray);
assertThat(boolarray).containsExactly(boolarray);
assertThat(boolarray).containsExactlyInAnyOrder(boolarray);
assertThat(boolarray).containsOnly(boolarray);
assertThat(boolarray).containsSequence(boolarray);
assertThat(boolarray).containsSubsequence(boolarray);
assertThat(boolarray).startsWith(boolarray);
assertThat(boolarray).endsWith(boolarray);
assertThat(bytearray).isEqualTo(bytearray);
assertThat(bytearray).isSameAs(bytearray);
assertThat(bytearray).hasSameClassAs(bytearray);
assertThat(bytearray).hasSameHashCodeAs(bytearray);
assertThat(bytearray).hasSameSizeAs(bytearray);
assertThat(bytearray).contains(bytearray);
assertThat(bytearray).containsAnyOf(bytearray);
assertThat(bytearray).containsExactly(bytearray);
assertThat(bytearray).containsExactlyInAnyOrder(bytearray);
assertThat(bytearray).containsOnly(bytearray);
assertThat(bytearray).containsSequence(bytearray);
assertThat(bytearray).containsSubsequence(bytearray);
assertThat(bytearray).startsWith(bytearray);
assertThat(bytearray).endsWith(bytearray);
assertThat(shortarray).isEqualTo(shortarray);
assertThat(shortarray).isSameAs(shortarray);
assertThat(shortarray).hasSameClassAs(shortarray);
assertThat(shortarray).hasSameHashCodeAs(shortarray);
assertThat(shortarray).hasSameSizeAs(shortarray);
assertThat(shortarray).contains(shortarray);
assertThat(shortarray).containsAnyOf(shortarray);
assertThat(shortarray).containsExactly(shortarray);
assertThat(shortarray).containsExactlyInAnyOrder(shortarray);
assertThat(shortarray).containsOnly(shortarray);
assertThat(shortarray).containsSequence(shortarray);
assertThat(shortarray).containsSubsequence(shortarray);
assertThat(shortarray).startsWith(shortarray);
assertThat(shortarray).endsWith(shortarray);
assertThat(intarray).isEqualTo(intarray);
assertThat(intarray).isSameAs(intarray);
assertThat(intarray).hasSameClassAs(intarray);
assertThat(intarray).hasSameHashCodeAs(intarray);
assertThat(intarray).hasSameSizeAs(intarray);
assertThat(intarray).contains(intarray);
assertThat(intarray).containsAnyOf(intarray);
assertThat(intarray).containsExactly(intarray);
assertThat(intarray).containsExactlyInAnyOrder(intarray);
assertThat(intarray).containsOnly(intarray);
assertThat(intarray).containsSequence(intarray);
assertThat(intarray).containsSubsequence(intarray);
assertThat(intarray).startsWith(intarray);
assertThat(intarray).endsWith(intarray);
assertThat(longarray).isEqualTo(longarray);
assertThat(longarray).isSameAs(longarray);
assertThat(longarray).hasSameClassAs(longarray);
assertThat(longarray).hasSameHashCodeAs(longarray);
assertThat(longarray).hasSameSizeAs(longarray);
assertThat(longarray).contains(longarray);
assertThat(longarray).containsAnyOf(longarray);
assertThat(longarray).containsExactly(longarray);
assertThat(longarray).containsExactlyInAnyOrder(longarray);
assertThat(longarray).containsOnly(longarray);
assertThat(longarray).containsSequence(longarray);
assertThat(longarray).containsSubsequence(longarray);
assertThat(longarray).startsWith(longarray);
assertThat(longarray).endsWith(longarray);
assertThat(floatarray).isEqualTo(floatarray);
assertThat(floatarray).isSameAs(floatarray);
assertThat(floatarray).hasSameClassAs(floatarray);
assertThat(floatarray).hasSameHashCodeAs(floatarray);
assertThat(floatarray).hasSameSizeAs(floatarray);
assertThat(floatarray).contains(floatarray);
assertThat(floatarray).containsAnyOf(floatarray);
assertThat(floatarray).containsExactly(floatarray);
assertThat(floatarray).containsExactlyInAnyOrder(floatarray);
assertThat(floatarray).containsOnly(floatarray);
assertThat(floatarray).containsSequence(floatarray);
assertThat(floatarray).containsSubsequence(floatarray);
assertThat(floatarray).startsWith(floatarray);
assertThat(floatarray).endsWith(floatarray);
assertThat(doublearray).isEqualTo(doublearray);
assertThat(doublearray).isSameAs(doublearray);
assertThat(doublearray).hasSameClassAs(doublearray);
assertThat(doublearray).hasSameHashCodeAs(doublearray);
assertThat(doublearray).hasSameSizeAs(doublearray);
assertThat(doublearray).contains(doublearray);
assertThat(doublearray).containsAnyOf(doublearray);
assertThat(doublearray).containsExactly(doublearray);
assertThat(doublearray).containsExactlyInAnyOrder(doublearray);
assertThat(doublearray).containsOnly(doublearray);
assertThat(doublearray).containsSequence(doublearray);
assertThat(doublearray).containsSubsequence(doublearray);
assertThat(doublearray).startsWith(doublearray);
assertThat(doublearray).endsWith(doublearray);
assertThat(chararray).isEqualTo(chararray);
assertThat(chararray).isSameAs(chararray);
assertThat(chararray).hasSameClassAs(chararray);
assertThat(chararray).hasSameHashCodeAs(chararray);
assertThat(chararray).hasSameSizeAs(chararray);
assertThat(chararray).contains(chararray);
assertThat(chararray).containsAnyOf(chararray);
assertThat(chararray).containsExactly(chararray);
assertThat(chararray).containsExactlyInAnyOrder(chararray);
assertThat(chararray).containsOnly(chararray);
assertThat(chararray).containsSequence(chararray);
assertThat(chararray).containsSubsequence(chararray);
assertThat(chararray).startsWith(chararray);
assertThat(chararray).endsWith(chararray);
assertThat(objarray).isEqualTo(objarray);
assertThat(objarray).isSameAs(objarray);
assertThat(objarray).hasSameClassAs(objarray);
assertThat(objarray).hasSameHashCodeAs(objarray);
assertThat(objarray).hasSameSizeAs(objarray);
assertThat(objarray).contains(objarray);
assertThat(objarray).containsAnyOf(objarray);
assertThat(objarray).containsExactly(objarray);
assertThat(objarray).containsExactlyInAnyOrder(objarray);
assertThat(objarray).containsOnly(objarray);
assertThat(objarray).containsSequence(objarray);
assertThat(objarray).containsSubsequence(objarray);
assertThat(objarray).startsWith(objarray);
assertThat(objarray).endsWith(objarray);
assertThat(string).as("foo").isEqualTo(string);
assertThat(string).as("foo").isSameAs(string);
assertThat(string).as("foo").hasSameClassAs(string);
assertThat(string).as("foo").hasSameHashCodeAs(string);
assertThat(string).as("foo").hasSameSizeAs(string);
assertThat(string).as("foo").isEqualToIgnoringCase(string);
assertThat(string).as("foo").containsSequence(string);
assertThat(string).as("foo").containsSubsequence(string);
assertThat(string).as("foo").startsWith(string);
assertThat(string).as("foo").endsWith(string);
assertThat(list).as("foo").isEqualTo(list);
assertThat(list).as("foo").isSameAs(list);
assertThat(list).as("foo").hasSameClassAs(list);
assertThat(list).as("foo").hasSameHashCodeAs(list);
assertThat(list).as("foo").hasSameSizeAs(list);
assertThat(list).as("foo").containsAll(list);
assertThat(list).as("foo").containsAnyElementsOf(list);
assertThat(list).as("foo").containsOnlyElementsOf(list);
assertThat(list).as("foo").containsExactlyElementsOf(list);
assertThat(list).as("foo").hasSameElementsAs(list);
assertThat(list).as("foo").containsSequence(list);
assertThat(list).as("foo").containsSubsequence(list);
assertThat(map).as("foo").isEqualTo(map);
assertThat(map).as("foo").isSameAs(map);
assertThat(map).as("foo").hasSameClassAs(map);
assertThat(map).as("foo").hasSameHashCodeAs(map);
assertThat(map).as("foo").hasSameSizeAs(map);
assertThat(map).as("foo").containsAllEntriesOf(map);
assertThat(map).as("foo").containsExactlyEntriesOf(map);
assertThat(map).as("foo").containsExactlyInAnyOrderEntriesOf(map);
assertThat(bar).isEqualTo(string);
org.junit.Assert.assertThat(list, null);
fail("oh no!");
}
}
src/test/resources/inspections/TwistedAssertion/TwistedAssertionAfter.java
+38
View File
@@ -0,0 +1,38 @@
import java.util.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
public class TwistedAssertions {
private static final int SOME_CONST = 10;
private static final String SOME_CONST_STRING = "bar";
private void twistedAssertions() {
List<String> list = new ArrayList<>();
String foo = "foo";
String bar = "bar";
int number = 4;
assertThat(number).as("foo").isEqualTo(5 + 2);
assertThat(number).as("foo").isNotEqualTo(8);
assertThat(number).as("foo").isLessThanOrEqualTo(5 * 2);
assertThat(number + 1).as("foo").isLessThan(4 + (1 - 2));
assertThat(number * 2).as("foo").isGreaterThanOrEqualTo(3);
assertThat(number / 2).as("foo").isGreaterThan(2 + SOME_CONST);
assertThat(foo).as("foo").isEqualTo("foo");
assertThat(foo).as("foo").isSameAs(SOME_CONST_STRING);
assertThat(foo).as("foo").isNotEqualTo("bar");
assertThat(foo).as("foo").isNotSameAs("bar");
assertThat("bar").as("foo").startsWith(foo);
assertThat("foo").as("foo").endsWith(foo);
assertThat(bar).isEqualTo(foo);
assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
org.junit.Assert.assertThat(list, null);
fail("oh no!");
}
}
src/test/resources/inspections/TwistedAssertion/TwistedAssertionBefore.java
+38
View File
@@ -0,0 +1,38 @@
import java.util.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
public class TwistedAssertions {
private static final int SOME_CONST = 10;
private static final String SOME_CONST_STRING = "bar";
private void twistedAssertions() {
List<String> list = new ArrayList<>();
String foo = "foo";
String bar = "bar";
int number = 4;
assertThat(5 + 2).as("foo").isEqualTo(number);
assertThat(8).as("foo").isNotEqualTo(number);
assertThat(5 * 2).as("foo").isGreaterThan(number);
assertThat(4 + (1 - 2)).as("foo").isGreaterThanOrEqualTo(number + 1);
assertThat(3).as("foo").isLessThan(number * 2);
assertThat(2 + SOME_CONST).as("foo").isLessThanOrEqualTo(number / 2);
assertThat("foo").as("foo").isEqualTo(foo);
assertThat(SOME_CONST_STRING).as("foo").isSameAs(foo);
assertThat("bar").as("foo").isNotEqualTo(foo);
assertThat("bar").as("foo").isNotSameAs(foo);
assertThat("bar").as("foo").startsWith(foo);
assertThat("foo").as("foo").endsWith(foo);
assertThat(bar).isEqualTo(foo);
assertThat(4).isEqualTo(number).isNotEqualTo(number * 2);
assertThat(4).usingComparator(Comparator.reverseOrder()).isGreaterThanOrEqualTo(number);
org.junit.Assert.assertThat(list, null);
fail("oh no!");
}
}