From 03514f9f6a4248c7a151c60dcbc5f9042f52759c Mon Sep 17 00:00:00 2001 From: Stephan Schroevers Date: Wed, 1 Jan 2025 01:27:07 +0100 Subject: [PATCH] Generalize assorted Refaster rules (#1481) --- .../AssertJCharSequenceRules.java | 2 ++ .../refasterrules/AssertJMapRules.java | 5 ++- .../refasterrules/AssertJRules.java | 12 +++---- .../refasterrules/AssertJStringRules.java | 34 +++---------------- .../refasterrules/AssortedRules.java | 12 +++---- .../refasterrules/CollectionRules.java | 10 +++--- .../refasterrules/ImmutableMapRules.java | 8 ++--- .../AssertJCharSequenceRulesTestInput.java | 9 +++-- .../AssertJCharSequenceRulesTestOutput.java | 8 +++-- .../AssertJStringRulesTestInput.java | 8 ----- .../AssertJStringRulesTestOutput.java | 8 ----- .../CollectionRulesTestInput.java | 2 +- .../CollectionRulesTestOutput.java | 2 +- 13 files changed, 43 insertions(+), 77 deletions(-) diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRules.java index 573f9efa..5332f4ec 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRules.java @@ -18,6 +18,7 @@ final class AssertJCharSequenceRules { @BeforeTemplate void before(CharSequence charSequence) { Refaster.anyOf( + assertThat(charSequence.isEmpty()).isTrue(), assertThat(charSequence.length()).isEqualTo(0L), assertThat(charSequence.length()).isNotPositive()); } @@ -33,6 +34,7 @@ final class AssertJCharSequenceRules { @BeforeTemplate AbstractAssert before(CharSequence charSequence) { return Refaster.anyOf( + assertThat(charSequence.isEmpty()).isFalse(), assertThat(charSequence.length()).isNotEqualTo(0), assertThat(charSequence.length()).isPositive()); } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJMapRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJMapRules.java index 7ce1551c..86383926 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJMapRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJMapRules.java @@ -11,7 +11,6 @@ import com.google.errorprone.refaster.annotation.Matches; import com.google.errorprone.refaster.annotation.UseImportPolicy; import java.util.Collection; import java.util.Map; -import java.util.Set; import org.assertj.core.api.AbstractAssert; import org.assertj.core.api.AbstractBooleanAssert; import org.assertj.core.api.AbstractCollectionAssert; @@ -182,13 +181,13 @@ final class AssertJMapRules { static final class AssertThatMapContainsOnlyKeys { @BeforeTemplate AbstractCollectionAssert, K, ?> before( - Map map, Set keys) { + Map map, Iterable keys) { return assertThat(map.keySet()).hasSameElementsAs(keys); } @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - MapAssert after(Map map, Set keys) { + MapAssert after(Map map, Iterable keys) { return assertThat(map).containsOnlyKeys(keys); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java index 8e24755f..c325dcec 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java @@ -362,13 +362,13 @@ final class AssertJRules { static final class AssertThatListsAreEqual { @BeforeTemplate - ListAssert before(List list1, List list2) { + ListAssert before(List list1, Iterable list2) { return assertThat(list1).isEqualTo(list2); } @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - ListAssert after(List list1, List list2) { + ListAssert after(List list1, Iterable list2) { return assertThat(list1).containsExactlyElementsOf(list2); } } @@ -379,7 +379,7 @@ final class AssertJRules { static final class AssertThatSetsAreEqual { @BeforeTemplate - AbstractCollectionAssert before(Set set1, Set set2) { + AbstractCollectionAssert before(Set set1, Iterable set2) { return Refaster.anyOf( assertThat(set1).isEqualTo(set2), assertThat(set1).containsExactlyInAnyOrderElementsOf(set2)); @@ -387,7 +387,7 @@ final class AssertJRules { @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - AbstractCollectionAssert after(Set set1, Set set2) { + AbstractCollectionAssert after(Set set1, Iterable set2) { return assertThat(set1).hasSameElementsAs(set2); } } @@ -398,13 +398,13 @@ final class AssertJRules { static final class AssertThatMultisetsAreEqual { @BeforeTemplate - AbstractCollectionAssert before(Multiset multiset1, Multiset multiset2) { + AbstractCollectionAssert before(Multiset multiset1, Iterable multiset2) { return assertThat(multiset1).isEqualTo(multiset2); } @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - AbstractCollectionAssert after(Multiset multiset1, Multiset multiset2) { + AbstractCollectionAssert after(Multiset multiset1, Iterable multiset2) { return assertThat(multiset1).containsExactlyInAnyOrderElementsOf(multiset2); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJStringRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJStringRules.java index af4e03a3..c0ba58a8 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJStringRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJStringRules.java @@ -32,19 +32,6 @@ final class AssertJStringRules { } } - static final class AssertThatStringIsEmpty { - @BeforeTemplate - void before(String string) { - assertThat(string.isEmpty()).isTrue(); - } - - @AfterTemplate - @UseImportPolicy(STATIC_IMPORT_ALWAYS) - void after(String string) { - assertThat(string).isEmpty(); - } - } - static final class AbstractStringAssertStringIsNotEmpty { @BeforeTemplate AbstractStringAssert before(AbstractStringAssert stringAssert) { @@ -57,41 +44,28 @@ final class AssertJStringRules { } } - static final class AssertThatStringIsNotEmpty { - @BeforeTemplate - AbstractAssert before(String string) { - return assertThat(string.isEmpty()).isFalse(); - } - - @AfterTemplate - @UseImportPolicy(STATIC_IMPORT_ALWAYS) - AbstractAssert after(String string) { - return assertThat(string).isNotEmpty(); - } - } - static final class AssertThatStringContains { @BeforeTemplate - AbstractBooleanAssert before(String string, String substring) { + AbstractBooleanAssert before(String string, CharSequence substring) { return assertThat(string.contains(substring)).isTrue(); } @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - AbstractStringAssert after(String string, String substring) { + AbstractStringAssert after(String string, CharSequence substring) { return assertThat(string).contains(substring); } } static final class AssertThatStringDoesNotContain { @BeforeTemplate - AbstractBooleanAssert before(String string, String substring) { + AbstractBooleanAssert before(String string, CharSequence substring) { return assertThat(string.contains(substring)).isFalse(); } @AfterTemplate @UseImportPolicy(STATIC_IMPORT_ALWAYS) - AbstractStringAssert after(String string, String substring) { + AbstractStringAssert after(String string, CharSequence substring) { return assertThat(string).doesNotContain(substring); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java index a38a823e..a387af14 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java @@ -121,18 +121,18 @@ final class AssortedRules { */ static final class DisjointSets { @BeforeTemplate - boolean before(Set set1, Set set2) { - return Sets.intersection(set1, set2).isEmpty(); + boolean before(Set collection1, Set collection2) { + return Sets.intersection(collection1, collection2).isEmpty(); } @BeforeTemplate - boolean before2(Set set1, Set set2) { - return set1.stream().noneMatch(set2::contains); + boolean before2(Collection collection1, Collection collection2) { + return collection1.stream().noneMatch(collection2::contains); } @AfterTemplate - boolean after(Set set1, Set set2) { - return disjoint(set1, set2); + boolean after(Collection collection1, Collection collection2) { + return disjoint(collection1, collection2); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java index 3a02f6fe..25ed6663 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java @@ -158,14 +158,14 @@ final class CollectionRules { } } - static final class SetRemoveAllCollection { + static final class CollectionRemoveAllFromCollectionBlock { @BeforeTemplate - void before(Set removeFrom, Collection elementsToRemove) { + void before(Collection removeFrom, Collection elementsToRemove) { elementsToRemove.forEach(removeFrom::remove); } @BeforeTemplate - void before2(Set removeFrom, Collection elementsToRemove) { + void before2(Collection removeFrom, Collection elementsToRemove) { for (T element : elementsToRemove) { removeFrom.remove(element); } @@ -175,14 +175,14 @@ final class CollectionRules { // that this is supported out of the box. After doing so, also drop the `S extends T` type // constraint; ideally this check applies to any `S`. @BeforeTemplate - void before3(Set removeFrom, Collection elementsToRemove) { + void before3(Collection removeFrom, Collection elementsToRemove) { for (S element : elementsToRemove) { removeFrom.remove(element); } } @AfterTemplate - void after(Set removeFrom, Collection elementsToRemove) { + void after(Collection removeFrom, Collection elementsToRemove) { removeFrom.removeAll(elementsToRemove); } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java index fa976d33..3afed69c 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java @@ -337,14 +337,14 @@ final class ImmutableMapRules { abstract boolean keyFilter(@MayOptionallyUse K key); @BeforeTemplate - ImmutableMap before(ImmutableMap map) { + ImmutableMap before(Map map) { return map.entrySet().stream() .filter(e -> keyFilter(e.getKey())) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)); } @AfterTemplate - ImmutableMap after(ImmutableMap map) { + ImmutableMap after(Map map) { return ImmutableMap.copyOf(Maps.filterKeys(map, k -> keyFilter(k))); } } @@ -358,14 +358,14 @@ final class ImmutableMapRules { abstract boolean valueFilter(@MayOptionallyUse V value); @BeforeTemplate - ImmutableMap before(ImmutableMap map) { + ImmutableMap before(Map map) { return map.entrySet().stream() .filter(e -> valueFilter(e.getValue())) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue)); } @AfterTemplate - ImmutableMap after(ImmutableMap map) { + ImmutableMap after(Map map) { return ImmutableMap.copyOf(Maps.filterValues(map, v -> valueFilter(v))); } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestInput.java index e45d056c..4f904dff 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestInput.java @@ -8,13 +8,16 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJCharSequenceRulesTest implements RefasterRuleCollectionTestCase { void testAssertThatCharSequenceIsEmpty() { - assertThat("foo".length()).isEqualTo(0L); - assertThat("foo".length()).isNotPositive(); + assertThat("foo".isEmpty()).isTrue(); + assertThat("bar".length()).isEqualTo(0L); + assertThat("baz".length()).isNotPositive(); } ImmutableSet> testAssertThatCharSequenceIsNotEmpty() { return ImmutableSet.of( - assertThat("foo".length()).isNotEqualTo(0), assertThat("bar".length()).isPositive()); + assertThat("foo".isEmpty()).isFalse(), + assertThat("bar".length()).isNotEqualTo(0), + assertThat("baz".length()).isPositive()); } AbstractAssert testAssertThatCharSequenceHasSize() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestOutput.java index 50f906a5..71f6f863 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJCharSequenceRulesTestOutput.java @@ -9,11 +9,15 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase; final class AssertJCharSequenceRulesTest implements RefasterRuleCollectionTestCase { void testAssertThatCharSequenceIsEmpty() { assertThat("foo").isEmpty(); - assertThat("foo").isEmpty(); + assertThat("bar").isEmpty(); + assertThat("baz").isEmpty(); } ImmutableSet> testAssertThatCharSequenceIsNotEmpty() { - return ImmutableSet.of(assertThat("foo").isNotEmpty(), assertThat("bar").isNotEmpty()); + return ImmutableSet.of( + assertThat("foo").isNotEmpty(), + assertThat("bar").isNotEmpty(), + assertThat("baz").isNotEmpty()); } AbstractAssert testAssertThatCharSequenceHasSize() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java index a19b0779..305610df 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java @@ -21,18 +21,10 @@ final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase { assertThat("foo").isEqualTo(""); } - void testAssertThatStringIsEmpty() { - assertThat("foo".isEmpty()).isTrue(); - } - AbstractStringAssert testAbstractStringAssertStringIsNotEmpty() { return assertThat("foo").isNotEqualTo(""); } - AbstractAssert testAssertThatStringIsNotEmpty() { - return assertThat("foo".isEmpty()).isFalse(); - } - AbstractAssert testAssertThatStringContains() { return assertThat("foo".contains("bar")).isTrue(); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java index 7938bf16..a0ed9f56 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java @@ -22,18 +22,10 @@ final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase { assertThat("foo").isEmpty(); } - void testAssertThatStringIsEmpty() { - assertThat("foo").isEmpty(); - } - AbstractStringAssert testAbstractStringAssertStringIsNotEmpty() { return assertThat("foo").isNotEmpty(); } - AbstractAssert testAssertThatStringIsNotEmpty() { - return assertThat("foo").isNotEmpty(); - } - AbstractAssert testAssertThatStringContains() { return assertThat("foo").contains("bar"); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java index 6936af32..90dc6898 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java @@ -62,7 +62,7 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase { return Iterables.removeAll(new ArrayList<>(), ImmutableSet.of("foo")); } - void testSetRemoveAllCollection() { + void testCollectionRemoveAllFromCollectionBlock() { ImmutableSet.of("foo").forEach(new HashSet<>()::remove); for (Number element : ImmutableList.of(1)) { new HashSet().remove(element); diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java index 59367ba2..b35493ba 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java @@ -58,7 +58,7 @@ final class CollectionRulesTest implements RefasterRuleCollectionTestCase { return new ArrayList<>().removeAll(ImmutableSet.of("foo")); } - void testSetRemoveAllCollection() { + void testCollectionRemoveAllFromCollectionBlock() { new HashSet<>().removeAll(ImmutableSet.of("foo")); new HashSet().removeAll(ImmutableList.of(1)); new HashSet().removeAll(ImmutableSet.of(2));