Extended JUnitAssertToAssertJ inspection to convert JUnit assume-Statements, too.

Improved JUnitAssertToAssertJ quick fix to swap expected and actual expressions if the actual one is a constant.

src/test/java/de/platon42/intellij/plugins/cajon/inspections/JUnitAssertToAssertJInspectionTest.kt

@@ -18,7 +18,8 @@ internal class JUnitAssertToAssertJInspectionTest : AbstractCajonTest() {
         runTest {
             myFixture.enableInspections(JUnitAssertToAssertJInspection::class.java)
             myFixture.configureByFile("JUnitAssertToAssertJInspectionBefore.java")
-            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 38)
+            executeQuickFixes(myFixture, Regex("Convert assert.*\\(\\) to assertThat\\(\\).*"), 48)
+            executeQuickFixes(myFixture, Regex("Convert assume.*\\(\\) to assumeThat\\(\\).*"), 7)
             myFixture.checkResultByFile("JUnitAssertToAssertJInspectionAfter.java")
         }
     }

src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionAfter.java

@@ -1,12 +1,18 @@
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.data.Offset.offset;
 import static org.junit.Assert.*;
+import static org.junit.Assume.*;
 
 public class JUnitAssertToAssertJ {
 
     private void jUnitAssertToAssertJ() {
         String foo = "foo";
         String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
         assertThat(foo == "foo").isTrue();
         assertThat(foo == "foo").as("oh no!").isTrue();
         assertThat(foo == "bar").isFalse();
@@ -52,5 +58,35 @@ public class JUnitAssertToAssertJ {
         assertThat(new double[1]).as("array equals").containsExactly(new double[2], offset(1.0));
         assertThat(new float[1]).containsExactly(new float[2], offset(1.0f));
         assertThat(new float[1]).as("array equals").containsExactly(new float[2], offset(1.0f));
+
+        assertThat(foo).isEqualTo("bar");
+        assertThat(bar).as("equals").isEqualTo("foo");
+        assertThat(bar).isNotEqualTo("foo");
+        assertThat(foo).as("equals").isNotEqualTo("bar");
+
+        assertThat(someInt).isEqualTo(2);
+        assertThat(someDouble).isCloseTo(2.0, offset(0.1));
+        assertThat(someDouble).as("equals").isEqualTo(1.0);
+        assertThat(someDouble).as("equals").isCloseTo(1.0, offset(0.1));
+        assertThat(someFloat).isEqualTo(1.0f);
+        assertThat(someFloat).isCloseTo(2.0f, offset(0.1f));
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnitAssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeThat(foo == "foo").isTrue();
+        assumeThat(foo == "foo").as("oh no!").isTrue();
+        assumeThat(foo == "bar").isFalse();
+        assumeThat(foo == "bar").as("boom!").isFalse();
+
+        assumeThat(foo).isNotNull();
+        assumeNotNull(foo, bar);
+
+        assumeThat(new IllegalArgumentException()).doesNotThrowAnyException();
+        assumeThat(new IllegalArgumentException()).as("oh no!").doesNotThrowAnyException();
     }
 }

src/test/resources/inspections/JUnitAssertToAssertJ/JUnitAssertToAssertJInspectionBefore.java

@@ -1,10 +1,15 @@
 import static org.junit.Assert.*;
+import static org.junit.Assume.*;
 
 public class JUnitAssertToAssertJ {
 
     private void jUnitAssertToAssertJ() {
         String foo = "foo";
         String bar = "bar";
+        int someInt = 1;
+        double someDouble = 1.0;
+        float someFloat = 1.0f;
+
         assertTrue(foo == "foo");
         assertTrue("oh no!", foo == "foo");
         assertFalse(foo == "bar");
@@ -50,5 +55,35 @@ public class JUnitAssertToAssertJ {
         assertArrayEquals("array equals", new double[2], new double[1], 1.0);
         assertArrayEquals(new float[2], new float[1], 1.0f);
         assertArrayEquals("array equals", new float[2], new float[1], 1.0f);
+
+        assertEquals("bar", foo);
+        assertEquals("equals", bar, "foo");
+        assertNotEquals(bar, "foo");
+        assertNotEquals("equals", "bar", foo);
+
+        assertEquals(someInt, 2);
+        assertEquals(someDouble, 2.0, 0.1);
+        assertEquals("equals",1.0, someDouble);
+        assertEquals("equals",1.0, someDouble, 0.1);
+        assertEquals(1.0f, someFloat);
+        assertEquals(someFloat, 2.0f, 0.1f);
+
+        fail();
+        fail("oh no!")
+    }
+
+    private void jUnitAssumeToAssertJ() {
+        String foo = "foo";
+        String bar = "bar";
+        assumeTrue(foo == "foo");
+        assumeTrue("oh no!", foo == "foo");
+        assumeFalse(foo == "bar");
+        assumeFalse("boom!", foo == "bar");
+
+        assumeNotNull(foo);
+        assumeNotNull(foo, bar);
+
+        assumeNoException(new IllegalArgumentException());
+        assumeNoException("oh no!", new IllegalArgumentException());
     }
 }