tech.picnic.errorprone.refasterrules.AssertJComparableRules Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of error-prone-contrib Show documentation
Extra Error Prone plugins by Picnic.
There is a newer version: 0.19.1
package tech.picnic.errorprone.refasterrules;

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;
import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;

@OnlineDocumentation
final class AssertJComparableRules {
  private AssertJComparableRules() {}

  static final class AssertThatIsEqualByComparingTo> {
    @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> {
    @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> {
    @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> {
    @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> {
    @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> {
    @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);
    }
  }
}