Introduce Refaster templates for AbstractComparableAsserts

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJComparableTemplates.java

@@ -0,0 +1,92 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import org.assertj.core.api.AbstractComparableAssert;
+import org.assertj.core.api.AbstractIntegerAssert;
+
+final class AssertJComparableTemplates {
+  private AssertJComparableTemplates() {}
+
+  static final class AssertThatIsEqualByComparingTo<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isEqualTo(0);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isEqualByComparingTo(expected);
+    }
+  }
+
+  static final class AssertThatIsNotEqualByComparingTo<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isNotEqualTo(0);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isNotEqualByComparingTo(expected);
+    }
+  }
+
+  static final class AssertThatIsLessThan<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isNegative();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isLessThan(expected);
+    }
+  }
+
+  static final class AssertThatIsLessThanOrEqualTo<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isNotPositive();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isLessThanOrEqualTo(expected);
+    }
+  }
+
+  static final class AssertThatIsGreaterThan<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isPositive();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isGreaterThan(expected);
+    }
+  }
+
+  static final class AssertThatIsGreaterThanOrEqualTo<T extends Comparable<? super T>> {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(T actual, T expected) {
+      return assertThat(actual.compareTo(expected)).isNotNegative();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractComparableAssert<?, ?> after(T actual, T expected) {
+      return assertThat(actual).isGreaterThanOrEqualTo(expected);
+    }
+  }
+}

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJPrimitiveTemplates.java

@@ -0,0 +1,111 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import org.assertj.core.api.AbstractBooleanAssert;
+import org.assertj.core.api.AbstractDoubleAssert;
+
+final class AssertJPrimitiveTemplates {
+  private AssertJPrimitiveTemplates() {}
+
+  static final class AssertThatIsEqualTo {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(boolean actual, boolean expected) {
+      return Refaster.anyOf(
+          assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
+    }
+
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractBooleanAssert<?> after(boolean actual, boolean expected) {
+      return assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  static final class AssertThatIsNotEqualTo {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(boolean actual, boolean expected) {
+      return Refaster.anyOf(
+          assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());
+    }
+
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractBooleanAssert<?> after(boolean actual, boolean expected) {
+      return assertThat(actual).isNotEqualTo(expected);
+    }
+  }
+
+  static final class AssertThatIsLessThan {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual < expected).isTrue(), assertThat(actual >= expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractDoubleAssert<?> after(double actual, double expected) {
+      return assertThat(actual).isLessThan(expected);
+    }
+  }
+
+  static final class AssertThatIsLessThanOrEqualTo {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual <= expected).isTrue(), assertThat(actual > expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractDoubleAssert<?> after(double actual, double expected) {
+      return assertThat(actual).isLessThanOrEqualTo(expected);
+    }
+  }
+
+  static final class AssertThatIsGreaterThan {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual > expected).isTrue(), assertThat(actual <= expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractDoubleAssert<?> after(double actual, double expected) {
+      return assertThat(actual).isGreaterThan(expected);
+    }
+  }
+
+  static final class AssertThatIsGreaterThanOrEqualTo {
+    @BeforeTemplate
+    AbstractBooleanAssert<?> before(double actual, double expected) {
+      return Refaster.anyOf(
+          assertThat(actual >= expected).isTrue(), assertThat(actual < expected).isFalse());
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    AbstractDoubleAssert<?> after(double actual, double expected) {
+      return assertThat(actual).isGreaterThanOrEqualTo(expected);
+    }
+  }
+}

error-prone-contrib/src/test/java/tech/picnic/errorprone/refastertemplates/RefasterTemplatesTest.java

@@ -19,6 +19,7 @@ final class RefasterTemplatesTest {
           AssertJBooleanTemplates.class,
           AssertJByteTemplates.class,
           AssertJCharSequenceTemplates.class,
+          AssertJComparableTemplates.class,
           AssertJDoubleTemplates.class,
           AssertJEnumerableTemplates.class,
           AssertJFloatTemplates.class,
@@ -28,6 +29,7 @@ final class RefasterTemplatesTest {
           AssertJMapTemplates.class,
           AssertJObjectTemplates.class,
           AssertJOptionalTemplates.class,
+          AssertJPrimitiveTemplates.class,
           AssertJShortTemplates.class,
           AssertJStringTemplates.class,
           AssertJThrowingCallableTemplates.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/AssertJComparableTemplatesTestInput.java

@@ -0,0 +1,33 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigDecimal;
+import org.assertj.core.api.AbstractComparableAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;
+
+final class AssertJComparableTemplatesTest implements RefasterTemplateTestCase {
+  AbstractComparableAssert<?, ?> testAssertThatIsEqualByComparingTo() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isEqualTo(0);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsNotEqualByComparingTo() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isNotEqualTo(0);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsLessThan() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isNegative();
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsLessThanOrEqualTo() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isNotPositive();
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsGreaterThan() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isPositive();
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsGreaterThanOrEqualTo() {
+    return assertThat(BigDecimal.ZERO.compareTo(BigDecimal.ONE)).isNotNegative();
+  }
+}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/AssertJComparableTemplatesTestOutput.java

@@ -0,0 +1,33 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigDecimal;
+import org.assertj.core.api.AbstractComparableAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;
+
+final class AssertJComparableTemplatesTest implements RefasterTemplateTestCase {
+  AbstractComparableAssert<?, ?> testAssertThatIsEqualByComparingTo() {
+    return assertThat(BigDecimal.ZERO).isEqualByComparingTo(BigDecimal.ONE);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsNotEqualByComparingTo() {
+    return assertThat(BigDecimal.ZERO).isNotEqualByComparingTo(BigDecimal.ONE);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsLessThan() {
+    return assertThat(BigDecimal.ZERO).isLessThan(BigDecimal.ONE);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsLessThanOrEqualTo() {
+    return assertThat(BigDecimal.ZERO).isLessThanOrEqualTo(BigDecimal.ONE);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsGreaterThan() {
+    return assertThat(BigDecimal.ZERO).isGreaterThan(BigDecimal.ONE);
+  }
+
+  AbstractComparableAssert<?, ?> testAssertThatIsGreaterThanOrEqualTo() {
+    return assertThat(BigDecimal.ZERO).isGreaterThanOrEqualTo(BigDecimal.ONE);
+  }
+}