Skip to content

Commit

Permalink
Extend size-related AssertJEnumerableRules Refaster rules (#1512)
Browse files Browse the repository at this point in the history 
By also matching expressions ending in `.returnToIterable()`.
  • Loading branch information
@rickie
rickie authored Feb 2, 2025
1 parent 9088369 commit 77557c8
Show file tree
Hide file tree
Showing 3 changed files with 118 additions and 34 deletions.
71 changes: 64 additions & 7 deletions ...ne-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJEnumerableRules.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,16 @@ EnumerableAssert<?, E> before(EnumerableAssert<?, E> enumAssert) {
}

@BeforeTemplate
AbstractIntegerAssert<?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
AbstractIterableAssert<?, ?, E, ?> before(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
return Refaster.anyOf(
enumAssert.size().isNotEqualTo(0).returnToIterable(),
enumAssert.size().isPositive().returnToIterable());
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIntegerAssert<?> before2(AbstractIterableAssert<?, ?, E, ?> enumAssert) {
return Refaster.anyOf(enumAssert.size().isNotEqualTo(0), enumAssert.size().isPositive());
}

Expand All @@ -55,7 +64,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert) {

static final class EnumerableAssertHasSize<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isEqualTo(size).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isEqualTo(size);
}
Expand All @@ -68,7 +85,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {

static final class EnumerableAssertHasSizeLessThan<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isLessThan(size).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isLessThan(size);
}
Expand All @@ -81,7 +106,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {

static final class EnumerableAssertHasSizeLessThanOrEqualTo<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isLessThanOrEqualTo(size).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isLessThanOrEqualTo(size);
}
Expand All @@ -94,7 +127,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {

static final class EnumerableAssertHasSizeGreaterThan<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isGreaterThan(size).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isGreaterThan(size);
}
Expand All @@ -107,7 +148,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {

static final class EnumerableAssertHasSizeGreaterThanOrEqualTo<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isGreaterThanOrEqualTo(size).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int size) {
return enumAssert.size().isGreaterThanOrEqualTo(size);
}
Expand All @@ -120,7 +169,15 @@ EnumerableAssert<?, E> after(EnumerableAssert<?, E> enumAssert, int size) {

static final class EnumerableAssertHasSizeBetween<E> {
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> before(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
return enumAssert.size().isBetween(lower, upper).returnToIterable();
}

// XXX: If this template matches, then the expression's return type changes incompatibly.
// Consider moving this template to a separate block (statement) rule.
@BeforeTemplate
AbstractIterableSizeAssert<?, ?, E, ?> before2(
AbstractIterableAssert<?, ?, E, ?> enumAssert, int lower, int upper) {
return enumAssert.size().isBetween(lower, upper);
}
Expand Down
42 changes: 28 additions & 14 deletions .../test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,32 +25,46 @@ void testEnumerableAssertIsEmpty() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeGreaterThan(0),
assertThat(ImmutableSet.of(2)).hasSizeGreaterThanOrEqualTo(1),
assertThat(ImmutableSet.of(3)).size().isNotEqualTo(0),
assertThat(ImmutableSet.of(4)).size().isPositive());
assertThat(ImmutableSet.of(3)).size().isNotEqualTo(0).returnToIterable(),
assertThat(ImmutableSet.of(4)).size().isPositive().returnToIterable(),
assertThat(ImmutableSet.of(5)).size().isNotEqualTo(0),
assertThat(ImmutableSet.of(6)).size().isPositive());
}

AbstractAssert<?, ?> testEnumerableAssertHasSize() {
return assertThat(ImmutableSet.of(1)).size().isEqualTo(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSize() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isEqualTo(2).returnToIterable(),
assertThat(ImmutableSet.of(3)).size().isEqualTo(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeLessThan() {
return assertThat(ImmutableSet.of(1)).size().isLessThan(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThan() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isLessThan(2).returnToIterable(),
assertThat(ImmutableSet.of(3)).size().isLessThan(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeLessThanOrEqualTo() {
return assertThat(ImmutableSet.of(1)).size().isLessThanOrEqualTo(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThanOrEqualTo() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isLessThanOrEqualTo(2).returnToIterable(),
assertThat(ImmutableSet.of(3)).size().isLessThanOrEqualTo(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeGreaterThan() {
return assertThat(ImmutableSet.of(1)).size().isGreaterThan(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThan() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isGreaterThan(2).returnToIterable(),
assertThat(ImmutableSet.of(3)).size().isGreaterThan(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
return assertThat(ImmutableSet.of(1)).size().isGreaterThanOrEqualTo(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isGreaterThanOrEqualTo(2).returnToIterable(),
assertThat(ImmutableSet.of(3)).size().isGreaterThanOrEqualTo(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeBetween() {
return assertThat(ImmutableSet.of(1)).size().isBetween(2, 3);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeBetween() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).size().isBetween(2, 3).returnToIterable(),
assertThat(ImmutableSet.of(4)).size().isBetween(5, 6));
}

ImmutableSet<EnumerableAssert<?, Integer>> testEnumerableAssertHasSameSizeAs() {
Expand Down
39 changes: 26 additions & 13 deletions ...test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,31 +26,44 @@ void testEnumerableAssertIsEmpty() {
assertThat(ImmutableSet.of(1)).isNotEmpty(),
assertThat(ImmutableSet.of(2)).isNotEmpty(),
assertThat(ImmutableSet.of(3)).isNotEmpty(),
assertThat(ImmutableSet.of(4)).isNotEmpty());
assertThat(ImmutableSet.of(4)).isNotEmpty(),
assertThat(ImmutableSet.of(5)).isNotEmpty(),
assertThat(ImmutableSet.of(6)).isNotEmpty());
}

AbstractAssert<?, ?> testEnumerableAssertHasSize() {
return assertThat(ImmutableSet.of(1)).hasSize(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSize() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSize(2), assertThat(ImmutableSet.of(3)).hasSize(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeLessThan() {
return assertThat(ImmutableSet.of(1)).hasSizeLessThan(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThan() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeLessThan(2),
assertThat(ImmutableSet.of(3)).hasSizeLessThan(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeLessThanOrEqualTo() {
return assertThat(ImmutableSet.of(1)).hasSizeLessThanOrEqualTo(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeLessThanOrEqualTo() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeLessThanOrEqualTo(2),
assertThat(ImmutableSet.of(3)).hasSizeLessThanOrEqualTo(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeGreaterThan() {
return assertThat(ImmutableSet.of(1)).hasSizeGreaterThan(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThan() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeGreaterThan(2),
assertThat(ImmutableSet.of(3)).hasSizeGreaterThan(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
return assertThat(ImmutableSet.of(1)).hasSizeGreaterThanOrEqualTo(2);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeGreaterThanOrEqualTo() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeGreaterThanOrEqualTo(2),
assertThat(ImmutableSet.of(3)).hasSizeGreaterThanOrEqualTo(4));
}

AbstractAssert<?, ?> testEnumerableAssertHasSizeBetween() {
return assertThat(ImmutableSet.of(1)).hasSizeBetween(2, 3);
ImmutableSet<AbstractAssert<?, ?>> testEnumerableAssertHasSizeBetween() {
return ImmutableSet.of(
assertThat(ImmutableSet.of(1)).hasSizeBetween(2, 3),
assertThat(ImmutableSet.of(4)).hasSizeBetween(5, 6));
}

ImmutableSet<EnumerableAssert<?, Integer>> testEnumerableAssertHasSameSizeAs() {
Expand Down

0 comments on commit 77557c8

Please sign in to comment.