Add assorted AssertJTemplates (part 2)

This is for `byte`, `int`, `long` and `short`.

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

@@ -7,6 +7,7 @@ import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigDecimalAssert;
 
 // XXX: If we add a rule which drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
@@ -86,4 +87,48 @@ final class AssertJBigDecimalTemplates {
       return bigDecimalAssert.isEqualTo(1);
     }
   }
+
+  static final class AbstractBigDecimalAssertIsEqualToBigDecimal {
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, BigInteger bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, char[] bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, double bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, int bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, long bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @BeforeTemplate
+    AbstractBigDecimalAssert<?> before(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, String bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(new BigDecimal(bigDecimal));
+    }
+
+    @AfterTemplate
+    AbstractBigDecimalAssert<?> after(
+        AbstractBigDecimalAssert<?> abstractBigDecimalAssert, Object bigDecimal) {
+      return abstractBigDecimalAssert.isEqualTo(bigDecimal);
+    }
+  }
 }

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

@@ -12,6 +12,19 @@ import org.assertj.core.api.AbstractAssert;
 final class AssertJCharSequenceTemplates {
   private AssertJCharSequenceTemplates() {}
 
+  static final class AbstractCharSequenceAssertContains {
+    @BeforeTemplate
+    void before(String string, CharSequence charSequence) {
+      assertThat(string.contains(charSequence)).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    void after(String string, CharSequence charSequence) {
+      assertThat(string).contains(charSequence);
+    }
+  }
+
   static final class AssertThatCharSequenceIsEmpty {
     @BeforeTemplate
     void before(CharSequence charSequence) {

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

@@ -0,0 +1,35 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.Map;
+import org.assertj.core.api.AbstractMapAssert;
+
+final class AssertJMapTemplates {
+  private AssertJMapTemplates() {}
+
+  static final class AbstractMapAssertContainsExactlyInAnyOrderEntriesOf<K, V> {
+    @BeforeTemplate
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+      return mapAssert.isEqualTo(map);
+    }
+
+    @AfterTemplate
+    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, Map<K, V> map) {
+      return mapAssert.containsExactlyInAnyOrderEntriesOf(map);
+    }
+  }
+
+  static final class AbstractMapAssertContainsExactlyEntriesOf<K, V> {
+    @BeforeTemplate
+    AbstractMapAssert<?, ?, K, V> before(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
+      return mapAssert.containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(key, value));
+    }
+
+    @AfterTemplate
+    AbstractMapAssert<?, ?, K, V> after(AbstractMapAssert<?, ?, K, V> mapAssert, K key, V value) {
+      return mapAssert.containsExactlyEntriesOf(ImmutableMap.of(key, value));
+    }
+  }
+}

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

@@ -1,8 +1,12 @@
 package tech.picnic.errorprone.refastertemplates;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.errorprone.refaster.ImportPolicy;
 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 java.math.BigDecimal;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigDecimalAssert;
@@ -221,4 +225,60 @@ final class AssertJNumberTemplates {
       return numberAssert.isNotNegative();
     }
   }
+
+  static final class AssertThatIsOdd {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(byte number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(int number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @BeforeTemplate
+    AbstractLongAssert<?> before(long number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(short number) {
+      return assertThat(number % 2).isEqualTo(1);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    NumberAssert<?, ?> after(Integer number) {
+      return assertThat(number).isOdd();
+    }
+  }
+
+  static final class AssertThatIsEven {
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(byte number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(int number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @BeforeTemplate
+    AbstractLongAssert<?> before(long number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @BeforeTemplate
+    AbstractIntegerAssert<?> before(short number) {
+      return assertThat(number % 2).isEqualTo(0);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    NumberAssert<?, ?> after(Integer number) {
+      return assertThat(number).isEven();
+    }
+  }
 }

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

@@ -0,0 +1,101 @@
+package tech.picnic.errorprone.refastertemplates;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.Arrays;
+import org.assertj.core.api.ObjectEnumerableAssert;
+
+final class AssertJObjectEnumerableTemplates {
+  private AssertJObjectEnumerableTemplates() {}
+
+  static final class ObjectEnumerableAssertContains<
+      S, T extends S, C extends Comparable<? super C>> {
+    @BeforeTemplate
+    ObjectEnumerableAssert<?, C> before(ObjectEnumerableAssert<?, C> iterAssert, C element) {
+      return Refaster.anyOf(
+          iterAssert.containsAnyElementsOf(ImmutableSortedSet.of(element)),
+          iterAssert.containsAll(ImmutableSortedSet.of(element)),
+          iterAssert.containsSequence(ImmutableSortedSet.of(element)),
+          iterAssert.containsSubsequence(ImmutableSortedSet.of(element)));
+    }
+
+    @BeforeTemplate
+    @SuppressWarnings("unchecked")
+    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
+      return Refaster.anyOf(
+          iterAssert.containsAnyElementsOf(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.containsAnyOf(element),
+          iterAssert.containsAll(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.containsSequence(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.containsSequence(element),
+          iterAssert.containsSubsequence(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.containsSubsequence(element));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
+      return iterAssert.contains(element);
+    }
+  }
+
+  static final class ObjectEnumerableAssertDoesNotContain<
+      S, T extends S, C extends Comparable<? super C>> {
+    @BeforeTemplate
+    ObjectEnumerableAssert<?, C> before(ObjectEnumerableAssert<?, C> iterAssert, C element) {
+      return Refaster.anyOf(
+          iterAssert.doesNotContainAnyElementsOf(ImmutableSortedSet.of(element)),
+          iterAssert.doesNotContainSequence(ImmutableSortedSet.of(element)));
+    }
+
+    @BeforeTemplate
+    @SuppressWarnings("unchecked")
+    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
+      return Refaster.anyOf(
+          iterAssert.doesNotContainAnyElementsOf(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.doesNotContainSequence(
+              Refaster.anyOf(
+                  ImmutableList.of(element),
+                  Arrays.asList(element),
+                  ImmutableSet.of(element),
+                  ImmutableMultiset.of(element))),
+          iterAssert.doesNotContainSequence(element));
+    }
+
+    @AfterTemplate
+    @SuppressWarnings("unchecked")
+    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
+      return iterAssert.doesNotContain(element);
+    }
+  }
+}

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

@@ -61,4 +61,30 @@ final class AssertJStringTemplates {
       return assertThat(string).isNotEmpty();
     }
   }
+
+  static final class AssertThatMatches {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(String string, String regex) {
+      return assertThat(string.matches(regex)).isTrue();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    AbstractAssert<?, ?> after(String string, String regex) {
+      return assertThat(string).matches(regex);
+    }
+  }
+
+  static final class AssertThatDoesNotMatch {
+    @BeforeTemplate
+    AbstractAssert<?, ?> before(String string, String regex) {
+      return assertThat(string.matches(regex)).isFalse();
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
+    AbstractAssert<?, ?> after(String string, String regex) {
+      return assertThat(string).doesNotMatch(regex);
+    }
+  }
 }

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

@@ -257,74 +257,6 @@ final class AssertJTemplates {
     }
   }
 
-  static final class ObjectEnumerableContainsOneElement<S, T extends S> {
-    @BeforeTemplate
-    @SuppressWarnings("unchecked")
-    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return Refaster.anyOf(
-          iterAssert.containsAnyElementsOf(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.containsAnyOf(element),
-          iterAssert.containsAll(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.containsSequence(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.containsSequence(element),
-          iterAssert.containsSubsequence(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.containsSubsequence(element));
-    }
-
-    @AfterTemplate
-    @SuppressWarnings("unchecked")
-    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return iterAssert.contains(element);
-    }
-  }
-
-  static final class ObjectEnumerableDoesNotContainOneElement<S, T extends S> {
-    @BeforeTemplate
-    @SuppressWarnings("unchecked")
-    ObjectEnumerableAssert<?, S> before(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return Refaster.anyOf(
-          iterAssert.doesNotContainAnyElementsOf(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.doesNotContainSequence(
-              Refaster.anyOf(
-                  ImmutableList.of(element),
-                  Arrays.asList(element),
-                  ImmutableSet.of(element),
-                  ImmutableMultiset.of(element))),
-          iterAssert.doesNotContainSequence(element));
-    }
-
-    @AfterTemplate
-    @SuppressWarnings("unchecked")
-    ObjectEnumerableAssert<?, S> after(ObjectEnumerableAssert<?, S> iterAssert, T element) {
-      return iterAssert.doesNotContain(element);
-    }
-  }
-
   static final class ObjectEnumerableContainsExactlyOneElement<S, T extends S> {
     @BeforeTemplate
     @SuppressWarnings("unchecked")

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

@@ -189,6 +189,18 @@ final class AssortedTemplates {
     }
   }
 
+  static final class ImmutableSetOf<T> {
+    @BeforeTemplate
+    Set<T> before(T element) {
+      return Collections.singleton(element);
+    }
+
+    @AfterTemplate
+    ImmutableSet<T> after(T element) {
+      return ImmutableSet.of(element);
+    }
+  }
+
   /** Prefer {@link Iterables#isEmpty(Iterable)} over more contrived alternatives. */
   static final class IterableIsEmpty<T> {
     @BeforeTemplate

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

@@ -55,7 +55,7 @@ final class ImmutableMapTemplates {
 
   /**
    * Prefer {@link ImmutableMap#of(Object, Object)} over more contrived alternatives and
-   * alternatives that don't communicate the immutability of the resulting map at the type level..
+   * alternatives that don't communicate the immutability of the resulting map at the type level.
    */
   // XXX: One can define variants for more than one key-value pair, but at some point the builder
   // actually produces nicer code. So it's not clear we should add Refaster templates for those
@@ -219,6 +219,8 @@ final class ImmutableMapTemplates {
   /**
    * Prefer creating an immutable copy of the result of {@link Maps#transformValues(Map,
    * com.google.common.base.Function)} over more contrived alternatives.
+   *
+   * <p>Additionally, this way it is easier to see that only values are being transformed.
    */
   abstract static class TransformMapValuesToImmutableMap<K, V1, V2> {
     @Placeholder(allowsIdentity = true)

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/RefasterCheckTest.java

@@ -34,7 +34,9 @@ public final class RefasterCheckTest {
           "AssertJInteger",
           "AssertJLong",
           "AssertJNumber",
+          "AssertJMap",
           "AssertJObject",
+          "AssertJObjectEnumerable",
           "AssertJOptional",
           "AssertJShort",
           "AssertJString",

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestInput.java

@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 
 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigDecimalAssert;
 
 final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
@@ -46,4 +47,14 @@ final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
         assertThat(BigDecimal.ZERO).isEqualTo(1L),
         assertThat(BigDecimal.ZERO).isEqualTo(BigDecimal.ONE));
   }
+
+  ImmutableSet<AbstractBigDecimalAssert<?>> testAbstractBigDecimalAssertIsEqualToBigDecimal() {
+    return ImmutableSet.of(
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal(BigInteger.ONE)),
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal(new char[] {'1'})),
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal(1D)),
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal(1)),
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal(1L)),
+        assertThat(BigDecimal.ZERO).isEqualTo(new BigDecimal("1")));
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestOutput.java

@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 
 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigDecimalAssert;
 
 final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
@@ -46,4 +47,14 @@ final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
         assertThat(BigDecimal.ZERO).isEqualTo(1),
         assertThat(BigDecimal.ZERO).isEqualTo(1));
   }
+
+  ImmutableSet<AbstractBigDecimalAssert<?>> testAbstractBigDecimalAssertIsEqualToBigDecimal() {
+    return ImmutableSet.of(
+        assertThat(BigDecimal.ZERO).isEqualTo(BigInteger.ONE),
+        assertThat(BigDecimal.ZERO).isEqualTo(new char[] {'1'}),
+        assertThat(BigDecimal.ZERO).isEqualTo(1D),
+        assertThat(BigDecimal.ZERO).isEqualTo(1),
+        assertThat(BigDecimal.ZERO).isEqualTo(1L),
+        assertThat(BigDecimal.ZERO).isEqualTo("1"));
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestInput.java

@@ -6,6 +6,10 @@ import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractAssert;
 
 final class AssertJCharSequenceTemplatesTest implements RefasterTemplateTestCase {
+  void testAbstractCharSequenceAssertContains() {
+    assertThat("foo".contains("f")).isTrue();
+  }
+
   void testAssertThatCharSequenceIsEmpty1() {
     assertThat("foo".length()).isEqualTo(0L);
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestOutput.java

@@ -6,6 +6,10 @@ import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractAssert;
 
 final class AssertJCharSequenceTemplatesTest implements RefasterTemplateTestCase {
+  void testAbstractCharSequenceAssertContains() {
+    assertThat("foo").contains("f");
+  }
+
   void testAssertThatCharSequenceIsEmpty1() {
     assertThat("foo").isEmpty();
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJMapTemplatesTestInput.java

@@ -0,0 +1,18 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableMap;
+import org.assertj.core.api.AbstractMapAssert;
+
+final class AssertJMapTemplatesTest implements RefasterTemplateTestCase {
+  AbstractMapAssert<?, ?, Integer, Integer>
+      testAbstractMapAssertContainsExactlyInAnyOrderEntriesOf() {
+    return assertThat(ImmutableMap.of(1, 2, 3, 4)).isEqualTo(ImmutableMap.of(1, 2, 3, 4));
+  }
+
+  AbstractMapAssert<?, ?, Integer, Integer> testAbstractMapAssertContainsExactlyEntriesOf() {
+    return assertThat(ImmutableMap.of(1, 2))
+        .containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(1, 2));
+  }
+}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJMapTemplatesTestOutput.java

@@ -0,0 +1,18 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableMap;
+import org.assertj.core.api.AbstractMapAssert;
+
+final class AssertJMapTemplatesTest implements RefasterTemplateTestCase {
+  AbstractMapAssert<?, ?, Integer, Integer>
+      testAbstractMapAssertContainsExactlyInAnyOrderEntriesOf() {
+    return assertThat(ImmutableMap.of(1, 2, 3, 4))
+        .containsExactlyInAnyOrderEntriesOf(ImmutableMap.of(1, 2, 3, 4));
+  }
+
+  AbstractMapAssert<?, ?, Integer, Integer> testAbstractMapAssertContainsExactlyEntriesOf() {
+    return assertThat(ImmutableMap.of(1, 2)).containsExactlyEntriesOf(ImmutableMap.of(1, 2));
+  }
+}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestInput.java

@@ -75,4 +75,28 @@ final class AssertJNumberTemplatesTest implements RefasterTemplateTestCase {
         assertThat(BigInteger.ZERO).isGreaterThan(BigInteger.valueOf(-1)),
         assertThat(BigDecimal.ZERO).isGreaterThanOrEqualTo(BigDecimal.ZERO));
   }
+
+  ImmutableSet<NumberAssert<?, ?>> testAssertThatIsOdd() {
+    return ImmutableSet.of(
+        assertThat((byte) 1 % 2).isEqualTo(1),
+        assertThat(Byte.valueOf((byte) 1) % 2).isEqualTo(1),
+        assertThat((int) 1 % 2).isEqualTo(1),
+        assertThat(Integer.valueOf(1) % 2).isEqualTo(1),
+        assertThat((long) 1 % 2).isEqualTo(1),
+        assertThat(Long.valueOf(1L) % 2).isEqualTo(1),
+        assertThat((short) 1 % 2).isEqualTo(1),
+        assertThat(Short.valueOf((short) 1) % 2).isEqualTo(1));
+  }
+
+  ImmutableSet<NumberAssert<?, ?>> testAssertThatIsEven() {
+    return ImmutableSet.of(
+        assertThat((byte) 1 % 2).isEqualTo(0),
+        assertThat(Byte.valueOf((byte) 1) % 2).isEqualTo(0),
+        assertThat((int) 1 % 2).isEqualTo(0),
+        assertThat(Integer.valueOf(1) % 2).isEqualTo(0),
+        assertThat((long) 1 % 2).isEqualTo(0),
+        assertThat(Long.valueOf(1L) % 2).isEqualTo(0),
+        assertThat((short) 1 % 2).isEqualTo(0),
+        assertThat(Short.valueOf((short) 1) % 2).isEqualTo(0));
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestOutput.java

@@ -75,4 +75,28 @@ final class AssertJNumberTemplatesTest implements RefasterTemplateTestCase {
         assertThat(BigInteger.ZERO).isNotNegative(),
         assertThat(BigDecimal.ZERO).isNotNegative());
   }
+
+  ImmutableSet<NumberAssert<?, ?>> testAssertThatIsOdd() {
+    return ImmutableSet.of(
+        assertThat((byte) 1).isOdd(),
+        assertThat(Byte.valueOf((byte) 1)).isOdd(),
+        assertThat((int) 1).isOdd(),
+        assertThat(Integer.valueOf(1)).isOdd(),
+        assertThat((long) 1).isOdd(),
+        assertThat(Long.valueOf(1L)).isOdd(),
+        assertThat((short) 1).isOdd(),
+        assertThat(Short.valueOf((short) 1)).isOdd());
+  }
+
+  ImmutableSet<NumberAssert<?, ?>> testAssertThatIsEven() {
+    return ImmutableSet.of(
+        assertThat((byte) 1).isEven(),
+        assertThat(Byte.valueOf((byte) 1)).isEven(),
+        assertThat((int) 1).isEven(),
+        assertThat(Integer.valueOf(1)).isEven(),
+        assertThat((long) 1).isEven(),
+        assertThat(Long.valueOf(1L)).isEven(),
+        assertThat((short) 1).isEven(),
+        assertThat(Short.valueOf((short) 1)).isEven());
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectEnumerableTemplatesTestInput.java

@@ -0,0 +1,34 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import org.assertj.core.api.ObjectEnumerableAssert;
+
+final class AssertJObjectEnumerableTemplatesTest implements RefasterTemplateTestCase {
+  ImmutableSet<ObjectEnumerableAssert<?, ?>> testObjectEnumerableAssertContains() {
+    return ImmutableSet.of(
+        assertThat(ImmutableSortedSet.of(1)).containsAnyElementsOf(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableSortedSet.of(1)).containsAll(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableSortedSet.of(1)).containsSequence(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableSortedSet.of(1)).containsSubsequence(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableList.of(1)).containsAnyElementsOf(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).containsAnyOf(1),
+        assertThat(ImmutableList.of(1)).containsAll(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).containsSequence(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).containsSequence(1),
+        assertThat(ImmutableList.of(1)).containsSubsequence(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).containsSubsequence(1));
+  }
+
+  ImmutableSet<ObjectEnumerableAssert<?, ?>> testObjectEnumerableAssertDoesNotContain() {
+    return ImmutableSet.of(
+        assertThat(ImmutableSortedSet.of(1)).doesNotContainAnyElementsOf(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableSortedSet.of(1)).doesNotContainSequence(ImmutableSortedSet.of(1)),
+        assertThat(ImmutableList.of(1)).doesNotContainAnyElementsOf(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).doesNotContainSequence(ImmutableList.of(1)),
+        assertThat(ImmutableList.of(1)).doesNotContainSequence(1));
+  }
+}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectEnumerableTemplatesTestOutput.java

@@ -0,0 +1,34 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import org.assertj.core.api.ObjectEnumerableAssert;
+
+final class AssertJObjectEnumerableTemplatesTest implements RefasterTemplateTestCase {
+  ImmutableSet<ObjectEnumerableAssert<?, ?>> testObjectEnumerableAssertContains() {
+    return ImmutableSet.of(
+        assertThat(ImmutableSortedSet.of(1)).contains(1),
+        assertThat(ImmutableSortedSet.of(1)).contains(1),
+        assertThat(ImmutableSortedSet.of(1)).contains(1),
+        assertThat(ImmutableSortedSet.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1),
+        assertThat(ImmutableList.of(1)).contains(1));
+  }
+
+  ImmutableSet<ObjectEnumerableAssert<?, ?>> testObjectEnumerableAssertDoesNotContain() {
+    return ImmutableSet.of(
+        assertThat(ImmutableSortedSet.of(1)).doesNotContain(1),
+        assertThat(ImmutableSortedSet.of(1)).doesNotContain(1),
+        assertThat(ImmutableList.of(1)).doesNotContain(1),
+        assertThat(ImmutableList.of(1)).doesNotContain(1),
+        assertThat(ImmutableList.of(1)).doesNotContain(1));
+  }
+}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestInput.java

@@ -21,4 +21,12 @@ final class AssertJStringTemplatesTest implements RefasterTemplateTestCase {
   AbstractAssert<?, ?> testAssertThatStringIsNotEmpty() {
     return assertThat("foo".isEmpty()).isFalse();
   }
+
+  AbstractAssert<?, ?> testAssertThatMatches() {
+    return assertThat("foo".matches(".*")).isTrue();
+  }
+
+  AbstractAssert<?, ?> testAssertThatDoesNotMatch() {
+    return assertThat("foo".matches(".*")).isFalse();
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestOutput.java

@@ -21,4 +21,12 @@ final class AssertJStringTemplatesTest implements RefasterTemplateTestCase {
   AbstractAssert<?, ?> testAssertThatStringIsNotEmpty() {
     return assertThat("foo").isNotEmpty();
   }
+
+  AbstractAssert<?, ?> testAssertThatMatches() {
+    return assertThat("foo").matches(".*");
+  }
+
+  AbstractAssert<?, ?> testAssertThatDoesNotMatch() {
+    return assertThat("foo").doesNotMatch(".*");
+  }
 }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestInput.java

@@ -16,6 +16,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Stream;
 
 final class AssortedTemplatesTest implements RefasterTemplateTestCase {
@@ -84,6 +85,10 @@ final class AssortedTemplatesTest implements RefasterTemplateTestCase {
         Collections.disjoint(ImmutableList.of(7), new HashSet<>(ImmutableList.of(8))));
   }
 
+  Set<String> testImmutableSetOf() {
+    return Collections.singleton("foo");
+  }
+
   boolean testIterableIsEmpty() {
     return !ImmutableList.of().iterator().hasNext();
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestOutput.java

@@ -20,6 +20,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Stream;
 
 final class AssortedTemplatesTest implements RefasterTemplateTestCase {
@@ -86,6 +87,10 @@ final class AssortedTemplatesTest implements RefasterTemplateTestCase {
         Collections.disjoint(ImmutableList.of(7), ImmutableList.of(8)));
   }
 
+  Set<String> testImmutableSetOf() {
+    return ImmutableSet.of("foo");
+  }
+
   boolean testIterableIsEmpty() {
     return Iterables.isEmpty(ImmutableList.of());
   }