Apply suggestions

Remove validation in error-prone-contrib
2026-03-10 08:11:25 +00:00 · 2022-03-23 16:17:26 +01:00 · 2022-03-21 16:53:09 +01:00 · 2022-03-11 14:01:06 +01:00 · 2022-03-11 14:01:00 +01:00 · 2022-01-24 10:02:34 +01:00
130 changed files with 1634 additions and 283 deletions
--- a/error-prone-contrib/pom.xml
+++ b/error-prone-contrib/pom.xml
@@ -51,11 +51,21 @@
            <groupId>${project.groupId}</groupId>
            <artifactId>refaster-support</artifactId>
        </dependency>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>refaster-test-support</artifactId>
+            <scope>test</scope>
+        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <scope>test</scope>
        </dependency>
+        <dependency>
+            <groupId>com.google.auto</groupId>
+            <artifactId>auto-common</artifactId>
+            <scope>provided</scope>
+        </dependency>
        <dependency>
            <groupId>com.google.auto.service</groupId>
            <artifactId>auto-service-annotations</artifactId>
@@ -76,6 +86,11 @@
            <artifactId>guava</artifactId>
            <scope>provided</scope>
        </dependency>
+        <dependency>
+            <groupId>com.newrelic.agent.java</groupId>
+            <artifactId>newrelic-api</artifactId>
+            <scope>test</scope>
+        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-core</artifactId>
@@ -186,6 +201,11 @@
            <artifactId>spring-webflux</artifactId>
            <scope>provided</scope>
        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test</artifactId>
+            <scope>provided</scope>
+        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/FluxFlatMapUsageCheck.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/FluxFlatMapUsageCheck.java
@@ -0,0 +1,86 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.BugPattern.LinkType;
+import com.google.errorprone.BugPattern.SeverityLevel;
+import com.google.errorprone.BugPattern.StandardTags;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MemberReferenceTreeMatcher;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MemberReferenceTree;
+import com.sun.source.tree.MethodInvocationTree;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import reactor.core.publisher.Flux;
+
+/**
+ * A {@link BugChecker} which flags usages of {@link Flux#flatMap(Function)} and {@link
+ * Flux#flatMapSequential(Function)}.
+ *
+ * <p>{@link Flux#flatMap(Function)} and {@link Flux#flatMapSequential(Function)} eagerly perform up
+ * to {@link reactor.util.concurrent.Queues#SMALL_BUFFER_SIZE} subscriptions. Additionally, the
+ * former interleaves values as they are emitted, yielding nondeterministic results. In most cases
+ * {@link Flux#concatMap(Function)} should be preferred, as it produces consistent results and
+ * avoids potentially saturating the thread pool on which subscription happens. If {@code
+ * concatMap}'s single-subscription semantics are undesirable one should invoke a {@code flatMap} or
+ * {@code flatMapSequential} overload with an explicit concurrency level.
+ *
+ * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function, Supplier)} is not flagged
+ * by this check because there is no clear alternative to point to.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    name = "FluxFlatMapUsage",
+    summary =
+        "`Flux#flatMap` and `Flux#flatMapSequential` have subtle semantics; "
+            + "please use `Flux#concatMap` or explicitly specify the desired amount of concurrency",
+    linkType = LinkType.NONE,
+    severity = SeverityLevel.ERROR,
+    tags = StandardTags.LIKELY_ERROR)
+public final class FluxFlatMapUsageCheck extends BugChecker
+    implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final String MAX_CONCURRENCY_ARG_NAME = "MAX_CONCURRENCY";
+  private static final Matcher<ExpressionTree> FLUX_FLATMAP =
+      instanceMethod()
+          .onDescendantOf("reactor.core.publisher.Flux")
+          .namedAnyOf("flatMap", "flatMapSequential")
+          .withParameters(Function.class.getName());
+
+  @Override
+  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+    if (!FLUX_FLATMAP.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    return buildDescription(tree)
+        .addFix(SuggestedFixes.renameMethodInvocation(tree, "concatMap", state))
+        .addFix(
+            SuggestedFix.builder()
+                .postfixWith(
+                    Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
+                .build())
+        .build();
+  }
+
+  @Override
+  public Description matchMemberReference(MemberReferenceTree tree, VisitorState state) {
+    if (!FLUX_FLATMAP.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    // Method references are expected to occur very infrequently; generating both variants of
+    // suggested fixes is not worth the trouble.
+    return describeMatch(tree);
+  }
+}
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ScheduledTransactionTraceCheck.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ScheduledTransactionTraceCheck.java
@@ -0,0 +1,88 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.matchers.ChildMultiMatcher.MatchType.AT_LEAST_ONE;
+import static com.google.errorprone.matchers.Matchers.annotations;
+import static com.google.errorprone.matchers.Matchers.hasAnnotation;
+import static com.google.errorprone.matchers.Matchers.isType;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.BugPattern.LinkType;
+import com.google.errorprone.BugPattern.SeverityLevel;
+import com.google.errorprone.BugPattern.StandardTags;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodTreeMatcher;
+import com.google.errorprone.fixes.SuggestedFix;
+import com.google.errorprone.fixes.SuggestedFixes;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.matchers.MultiMatcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+
+/**
+ * A {@link BugChecker} which flags methods with Spring's {@code @Scheduled} annotation that lack
+ * New Relic Agent's {@code @Trace(dispatcher = true)}.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    name = "ScheduledTransactionTrace",
+    summary = "Scheduled operation must start a new New Relic transaction",
+    linkType = LinkType.NONE,
+    severity = SeverityLevel.ERROR,
+    tags = StandardTags.LIKELY_ERROR)
+public final class ScheduledTransactionTraceCheck extends BugChecker implements MethodTreeMatcher {
+  private static final long serialVersionUID = 1L;
+  private static final String TRACE_ANNOTATION_FQCN = "com.newrelic.api.agent.Trace";
+  private static final Matcher<Tree> IS_SCHEDULED =
+      hasAnnotation("org.springframework.scheduling.annotation.Scheduled");
+  private static final MultiMatcher<Tree, AnnotationTree> TRACE_ANNOTATION =
+      annotations(AT_LEAST_ONE, isType(TRACE_ANNOTATION_FQCN));
+
+  @Override
+  public Description matchMethod(MethodTree tree, VisitorState state) {
+    if (!IS_SCHEDULED.matches(tree, state)) {
+      return Description.NO_MATCH;
+    }
+
+    ImmutableList<AnnotationTree> traceAnnotations =
+        TRACE_ANNOTATION.multiMatchResult(tree, state).matchingNodes();
+    if (traceAnnotations.isEmpty()) {
+      /* This method completely lacks the `@Trace` annotation; add it. */
+      return describeMatch(
+          tree,
+          SuggestedFix.builder()
+              .addImport(TRACE_ANNOTATION_FQCN)
+              .prefixWith(tree, "@Trace(dispatcher = true)")
+              .build());
+    }
+
+    AnnotationTree traceAnnotation = Iterables.getOnlyElement(traceAnnotations);
+    if (isCorrectAnnotation(traceAnnotation)) {
+      return Description.NO_MATCH;
+    }
+
+    /*
+     * The `@Trace` annotation is present but does not specify `dispatcher = true`. Add or update
+     * the `dispatcher` annotation element.
+     */
+    return describeMatch(
+        traceAnnotation,
+        SuggestedFixes.updateAnnotationArgumentValues(
+                traceAnnotation, "dispatcher", ImmutableList.of("true"))
+            .build());
+  }
+
+  private static boolean isCorrectAnnotation(AnnotationTree traceAnnotation) {
+    return Boolean.TRUE.equals(
+        AnnotationMirrors.getAnnotationValue(
+                ASTHelpers.getAnnotationMirror(traceAnnotation), "dispatcher")
+            .getValue());
+  }
+}
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/StaticImportCheck.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/StaticImportCheck.java
@@ -19,14 +19,18 @@ import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
+import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
+import com.sun.tools.javac.code.Type;
 import java.util.Optional;

-/** A {@link BugChecker} which flags methods that can and should be statically imported. */
+/**
+ * A {@link BugChecker} which flags methods and constants that can and should be statically
+ * imported.
+ */
 // XXX: Tricky cases:
-// - `org.springframework.http.MediaType` (do except for `ALL`?)
 // - `org.springframework.http.HttpStatus` (not always an improvement, and `valueOf` must
 //    certainly be excluded)
 // - `com.google.common.collect.Tables`
@@ -42,15 +46,19 @@ import java.util.Optional;
@AutoService(BugChecker.class)
@BugPattern(
    name = "StaticImport",
-    summary = "Method should be statically imported",
+    summary = "Identifier should be statically imported",
    linkType = LinkType.NONE,
    severity = SeverityLevel.SUGGESTION,
    tags = StandardTags.SIMPLIFICATION)
 public final class StaticImportCheck extends BugChecker implements MemberSelectTreeMatcher {
  private static final long serialVersionUID = 1L;

+  /**
+   * Types whose members should be statically imported, unless exempted by {@link
+   * #STATIC_IMPORT_EXEMPTED_MEMBERS} or {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS}.
+   */
  @VisibleForTesting
-  static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_CLASSES =
+  static final ImmutableSet<String> STATIC_IMPORT_CANDIDATE_TYPES =
      ImmutableSet.of(
          "com.google.common.base.Preconditions",
          "com.google.common.base.Predicates",
@@ -80,14 +88,17 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
          "org.mockito.Answers",
          "org.mockito.ArgumentMatchers",
          "org.mockito.Mockito",
+          "org.springframework.boot.test.context.SpringBootTest.WebEnvironment",
          "org.springframework.format.annotation.DateTimeFormat.ISO",
          "org.springframework.http.HttpHeaders",
          "org.springframework.http.HttpMethod",
+          "org.springframework.http.MediaType",
          "org.testng.Assert",
          "reactor.function.TupleUtils");

+  /** Type members that should be statically imported. */
  @VisibleForTesting
-  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_CANDIDATE_METHODS =
+  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_CANDIDATE_MEMBERS =
      ImmutableSetMultimap.<String, String>builder()
          .putAll(
              "com.google.common.collect.ImmutableListMultimap",
@@ -122,9 +133,41 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
          .putAll("com.google.common.collect.Comparators", "emptiesFirst", "emptiesLast")
          .build();

+  /**
+   * Type members that should never be statically imported.
+   *
+   * <p>Identifiers listed by {@link #STATIC_IMPORT_EXEMPTED_IDENTIFIERS} should be omitted from
+   * this collection.
+   */
+  @VisibleForTesting
+  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_EXEMPTED_MEMBERS =
+      ImmutableSetMultimap.<String, String>builder()
+          .put("com.mongodb.client.model.Filters", "empty")
+          .put("org.springframework.http.MediaType", "ALL")
+          .build();
+
+  /**
+   * Identifiers that should never be statically imported.
+   *
+   * <p>This should be a superset of the identifiers flagged by {@link
+   * com.google.errorprone.bugpatterns.BadImport}.
+   */
+  @VisibleForTesting
+  static final ImmutableSet<String> STATIC_IMPORT_EXEMPTED_IDENTIFIERS =
+      ImmutableSet.of(
+          "builder",
+          "create",
+          "copyOf",
+          "from",
+          "getDefaultInstance",
+          "INSTANCE",
+          "newBuilder",
+          "of",
+          "valueOf");
+
  @Override
  public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
-    if (!isCandidate(state)) {
+    if (!isCandidateContext(state) || !isCandidate(tree)) {
      return Description.NO_MATCH;
    }

@@ -139,7 +182,7 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
        .orElse(Description.NO_MATCH);
  }

-  private static boolean isCandidate(VisitorState state) {
+  private static boolean isCandidateContext(VisitorState state) {
    Tree parentTree =
        requireNonNull(state.getPath().getParentPath(), "MemberSelectTree lacks enclosing node")
            .getLeaf();
@@ -154,6 +197,17 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
    }
  }

+  private static boolean isCandidate(MemberSelectTree tree) {
+    String identifier = tree.getIdentifier().toString();
+    if (STATIC_IMPORT_EXEMPTED_IDENTIFIERS.contains(identifier)) {
+      return false;
+    }
+
+    Type type = ASTHelpers.getType(tree.getExpression());
+    return type != null
+        && !STATIC_IMPORT_EXEMPTED_MEMBERS.containsEntry(type.toString(), identifier);
+  }
+
  private static Optional<String> getCandidateSimpleName(StaticImportInfo importInfo) {
    String canonicalName = importInfo.canonicalName();
    return importInfo
@@ -161,8 +215,8 @@ public final class StaticImportCheck extends BugChecker implements MemberSelectT
        .toJavaUtil()
        .filter(
            name ->
-                STATIC_IMPORT_CANDIDATE_CLASSES.contains(canonicalName)
-                    || STATIC_IMPORT_CANDIDATE_METHODS.containsEntry(canonicalName, name));
+                STATIC_IMPORT_CANDIDATE_TYPES.contains(canonicalName)
+                    || STATIC_IMPORT_CANDIDATE_MEMBERS.containsEntry(canonicalName, name));
  }

  private static Optional<Fix> tryStaticImport(
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJTemplates.java
@@ -365,6 +365,7 @@ final class AssertJTemplates {
    }

    @AfterTemplate
+    @UseImportPolicy(ImportPolicy.STATIC_IMPORT_ALWAYS)
    ObjectEnumerableAssert<?, S> after(Set<S> set, T element) {
      return assertThat(set).containsExactly(element);
    }
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java
@@ -162,7 +162,7 @@ final class ImmutableSetMultimapTemplates {
    @AfterTemplate
    ImmutableSetMultimap<K, V2> after(Multimap<K, V1> multimap) {
      return ImmutableSetMultimap.copyOf(
-          Multimaps.transformValues(multimap, v -> valueTransformation(v)));
+          Multimaps.transformValues(multimap, e -> valueTransformation(e)));
    }
  }

--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/OptionalTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/OptionalTemplates.java
@@ -14,6 +14,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
+import javax.annotation.Nullable;

 /** Refaster templates related to expressions dealing with {@link Optional}s. */
 final class OptionalTemplates {
@@ -24,7 +25,7 @@ final class OptionalTemplates {
    // parentheses around the null check, but that's currently not the case. Try to fix that.
    @BeforeTemplate
    @SuppressWarnings("TernaryOperatorOptionalNegativeFiltering" /* Special case. */)
-    Optional<T> before(T object) {
+    Optional<T> before(@Nullable T object) {
      return object == null ? Optional.empty() : Optional.of(object);
    }

--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java
@@ -142,6 +142,35 @@ final class ReactorTemplates {
    }
  }

+  /** Prefer {@link Flux#concatMap(Function)} over more contrived alternatives. */
+  static final class FluxConcatMap<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Flux<T> flux, Function<? super T, ? extends Publisher<? extends S>> function) {
+      return Refaster.anyOf(flux.flatMap(function, 1), flux.flatMapSequential(function, 1));
+    }
+
+    @AfterTemplate
+    Flux<S> after(Flux<T> flux, Function<? super T, ? extends Publisher<? extends S>> function) {
+      return flux.concatMap(function);
+    }
+  }
+
+  /**
+   * Prefer {@link Flux#concatMapIterable(Function)} over {@link Flux#concatMapIterable(Function)},
+   * as the former has equivalent semantics but a clearer name.
+   */
+  static final class FluxConcatMapIterable<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>> function) {
+      return flux.flatMapIterable(function);
+    }
+
+    @AfterTemplate
+    Flux<S> after(Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>> function) {
+      return flux.concatMapIterable(function);
+    }
+  }
+
  /**
   * Don't use {@link Mono#flatMapMany(Function)} to implicitly convert a {@link Mono} to a {@link
   * Flux}.
@@ -161,6 +190,32 @@ final class ReactorTemplates {
    }
  }

+  /** Prefer {@link Mono#flux()}} over more contrived alternatives. */
+  static final class MonoFlux<T> {
+    @BeforeTemplate
+    Flux<T> before(Mono<T> mono) {
+      return Flux.concat(mono);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Mono<T> mono) {
+      return mono.flux();
+    }
+  }
+
+  /** Don't unnecessarily invoke {@link Flux#concat(Publisher)}. */
+  static final class FluxIdentity<T> {
+    @BeforeTemplate
+    Flux<T> before(Flux<T> flux) {
+      return Flux.concat(flux);
+    }
+
+    @AfterTemplate
+    Flux<T> after(Flux<T> flux) {
+      return flux;
+    }
+  }
+
  /**
   * Prefer a collection using {@link MoreCollectors#toOptional()} over more contrived alternatives.
   */
@@ -194,6 +249,32 @@ final class ReactorTemplates {
    }
  }

+  /** Prefer {@link Mono#as(Function)} when creating a {@link StepVerifier}. */
+  static final class StepVerifierFromMono<T> {
+    @BeforeTemplate
+    StepVerifier.FirstStep<? extends T> before(Mono<T> mono) {
+      return StepVerifier.create(mono);
+    }
+
+    @AfterTemplate
+    StepVerifier.FirstStep<? extends T> after(Mono<T> mono) {
+      return mono.as(StepVerifier::create);
+    }
+  }
+
+  /** Prefer {@link Flux#as(Function)} when creating a {@link StepVerifier}. */
+  static final class StepVerifierFromFlux<T> {
+    @BeforeTemplate
+    StepVerifier.FirstStep<? extends T> before(Flux<T> flux) {
+      return StepVerifier.create(flux);
+    }
+
+    @AfterTemplate
+    StepVerifier.FirstStep<? extends T> after(Flux<T> flux) {
+      return flux.as(StepVerifier::create);
+    }
+  }
+
  /** Don't unnecessarily call {@link StepVerifier.Step#expectNext(Object[])}. */
  static final class StepVerifierStepExpectNextEmpty<T> {
    @BeforeTemplate
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/StringTemplates.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/StringTemplates.java
@@ -14,6 +14,7 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Optional;
+import javax.annotation.Nullable;

 /** Refaster templates related to expressions dealing with {@link String}s. */
 // XXX: Should we prefer `s -> !s.isEmpty()` or `not(String::isEmpty)`?
@@ -37,7 +38,7 @@ final class StringTemplates {
  /** Prefer {@link Strings#isNullOrEmpty(String)} over the more verbose alternative. */
  static final class StringIsNullOrEmpty {
    @BeforeTemplate
-    boolean before(String str) {
+    boolean before(@Nullable String str) {
      return str == null || str.isEmpty();
    }

--- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/FluxFlatMapUsageCheckTest.java
+++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/FluxFlatMapUsageCheckTest.java
@@ -0,0 +1,122 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import static com.google.errorprone.BugCheckerRefactoringTestHelper.newInstance;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+
+final class FluxFlatMapUsageCheckTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(FluxFlatMapUsageCheck.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      newInstance(FluxFlatMapUsageCheck.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import java.util.function.BiFunction;",
+            "import java.util.function.Function;",
+            "import reactor.core.publisher.Mono;",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).flatMap(Flux::just);",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).<String>flatMap(i -> Flux.just(String.valueOf(i)));",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).flatMapSequential(Flux::just);",
+            "    // BUG: Diagnostic contains:",
+            "    Flux.just(1).<String>flatMapSequential(i -> Flux.just(String.valueOf(i)));",
+            "",
+            "    Mono.just(1).flatMap(Mono::just);",
+            "    Flux.just(1).concatMap(Flux::just);",
+            "",
+            "    Flux.just(1).flatMap(Flux::just, 1);",
+            "    Flux.just(1).flatMap(Flux::just, 1, 1);",
+            "    Flux.just(1).flatMap(Flux::just, throwable -> Flux.empty(), Flux::empty);",
+            "",
+            "    Flux.just(1).flatMapSequential(Flux::just, 1);",
+            "    Flux.just(1).flatMapSequential(Flux::just, 1, 1);",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    this.<String, Flux<String>>sink(Flux::flatMap);",
+            "    // BUG: Diagnostic contains:",
+            "    this.<Integer, Flux<Integer>>sink(Flux::<Integer>flatMap);",
+            "",
+            "    // BUG: Diagnostic contains:",
+            "    this.<String, Flux<String>>sink(Flux::flatMapSequential);",
+            "    // BUG: Diagnostic contains:",
+            "    this.<Integer, Flux<Integer>>sink(Flux::<Integer>flatMapSequential);",
+            "",
+            "    this.<String, Mono<String>>sink(Mono::flatMap);",
+            "  }",
+            "",
+            "  private <T, P> void sink(BiFunction<P, Function<T, P>, P> fun) {}",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacementFirstSuggestedFix() {
+    refactoringTestHelper
+        .setFixChooser(FixChoosers.FIRST)
+        .addInputLines(
+            "in/A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Flux.just(1).flatMap(Flux::just);",
+            "    Flux.just(1).flatMapSequential(Flux::just);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "out/A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  void m() {",
+            "    Flux.just(1).concatMap(Flux::just);",
+            "    Flux.just(1).concatMap(Flux::just);",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  void replacementSecondSuggestedFix() {
+    refactoringTestHelper
+        .setFixChooser(FixChoosers.SECOND)
+        .addInputLines(
+            "in/A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  private static final int MAX_CONCURRENCY = 8;",
+            "",
+            "  void m() {",
+            "    Flux.just(1).flatMap(Flux::just);",
+            "    Flux.just(1).flatMapSequential(Flux::just);",
+            "  }",
+            "}")
+        .addOutputLines(
+            "out/A.java",
+            "import reactor.core.publisher.Flux;",
+            "",
+            "class A {",
+            "  private static final int MAX_CONCURRENCY = 8;",
+            "",
+            "  void m() {",
+            "    Flux.just(1).flatMap(Flux::just, MAX_CONCURRENCY);",
+            "    Flux.just(1).flatMapSequential(Flux::just, MAX_CONCURRENCY);",
+            "  }",
+            "}")
+        .doTest();
+  }
+}
--- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/RefasterCheckTest.java
+++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/RefasterCheckTest.java
@@ -1,172 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.common.collect.ImmutableSetMultimap.toImmutableSetMultimap;
-import static java.util.function.Function.identity;
-import static java.util.function.Predicate.not;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.junit.jupiter.params.provider.Arguments.arguments;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
-import java.util.regex.Pattern;
-import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-
-public final class RefasterCheckTest {
-  /** The names of all Refaster template groups defined in this module. */
-  private static final ImmutableSet<String> TEMPLATE_GROUPS =
-      ImmutableSet.of(
-          "AssertJ",
-          "AssertJBigDecimal",
-          "AssertJBigInteger",
-          "AssertJBoolean",
-          "AssertJByte",
-          "AssertJCharSequence",
-          "AssertJDouble",
-          "AssertJEnumerable",
-          "AssertJFloat",
-          "AssertJInteger",
-          "AssertJLong",
-          "AssertJNumber",
-          "AssertJObject",
-          "AssertJOptional",
-          "AssertJShort",
-          "AssertJString",
-          "Assorted",
-          "BigDecimal",
-          "Collection",
-          "Comparator",
-          "DoubleStream",
-          "Equality",
-          "ImmutableList",
-          "ImmutableListMultimap",
-          "ImmutableMap",
-          "ImmutableMultiset",
-          "ImmutableSet",
-          "ImmutableSetMultimap",
-          "ImmutableSortedMap",
-          "ImmutableSortedMultiset",
-          "ImmutableSortedSet",
-          "IntStream",
-          "JUnit",
-          "LongStream",
-          "MapEntry",
-          "Mockito",
-          "Multimap",
-          "Null",
-          "Optional",
-          "Primitive",
-          "Reactor",
-          "RxJava2Adapter",
-          "Stream",
-          "String",
-          "TestNGToAssertJ",
-          "Time",
-          "WebClient");
-  /**
-   * Matches the parts of the fully-qualified name of a template class that should be removed in
-   * order to produce the associated {@link #TEMPLATE_GROUPS template group name}.
-   */
-  private static final Pattern TEMPLATE_FQCN_TRIM_FOR_GROUP_NAME =
-      Pattern.compile(".*\\.|Templates\\$.*");
-  /**
-   * A mapping from template group names to associated template names.
-   *
-   * <p>In effect, the values correspond to nested classes that represent individual Refaster
-   * templates, while the keys correspond to the associated top-level "aggregator" classes.
-   */
-  private static final ImmutableSetMultimap<String, String> TEMPLATES_BY_GROUP =
-      indexTemplateNamesByGroup(RefasterCheck.ALL_CODE_TRANSFORMERS.get().keySet());
-
-  /** Returns every known template group name as a parameterized test argument. */
-  @SuppressWarnings("UnusedMethod" /* Used as a `@MethodSource`. */)
-  private static Stream<Arguments> templateGroupsUnderTest() {
-    // XXX: Drop the filter once we have added tests for AssertJ!
-    return TEMPLATES_BY_GROUP.keySet().stream().filter(not("AssertJ"::equals)).map(Arguments::of);
-  }
-
-  /**
-   * Returns every known (template group name, template name) pair as a parameterized test argument.
-   */
-  @SuppressWarnings("UnusedMethod" /* Used as a `@MethodSource`. */)
-  private static Stream<Arguments> templatesUnderTest() {
-    // XXX: Drop the filter once we have added tests for AssertJ!
-    return TEMPLATES_BY_GROUP.entries().stream()
-        .filter(e -> !"AssertJ".equals(e.getKey()))
-        .map(e -> arguments(e.getKey(), e.getValue()));
-  }
-
-  /**
-   * Verifies that {@link RefasterCheck#loadAllCodeTransformers} finds at least one code transformer
-   * for all of the {@link #TEMPLATE_GROUPS}.
-   *
-   * <p>This test is just as much about ensuring that {@link #TEMPLATE_GROUPS} is exhaustive, so
-   * that in turn {@link #replacement}'s coverage is exhaustive.
-   */
-  @Test
-  void loadAllCodeTransformers() {
-    assertThat(TEMPLATES_BY_GROUP.keySet()).hasSameElementsAs(TEMPLATE_GROUPS);
-  }
-
-  /**
-   * Verifies for each of the {@link #TEMPLATE_GROUPS} that the associated code transformers have
-   * the desired effect.
-   */
-  @MethodSource("templateGroupsUnderTest")
-  @ParameterizedTest
-  void replacement(String group) {
-    verifyRefactoring(group, namePattern(group));
-  }
-
-  /**
-   * Verifies that all loaded Refaster templates are covered by at least one test.
-   *
-   * <p>Note that this doesn't guarantee full coverage: this test cannot ascertain that all {@link
-   * com.google.errorprone.refaster.Refaster#anyOf} branches are tested. Idem for {@link
-   * com.google.errorprone.refaster.annotation.BeforeTemplate} methods in case there are multiple .
-   */
-  @MethodSource("templatesUnderTest")
-  @ParameterizedTest
-  void coverage(String group, String template) {
-    assertThatCode(() -> verifyRefactoring(group, namePattern(group, template)))
-        .withFailMessage(
-            "Template %s does not affect the tests for group %s; is it tested?", template, group)
-        .isInstanceOf(AssertionError.class)
-        .hasMessageFindingMatch("^(diff|expected):");
-  }
-
-  private static ImmutableSetMultimap<String, String> indexTemplateNamesByGroup(
-      ImmutableSet<String> templateNames) {
-    return templateNames.stream()
-        .collect(
-            toImmutableSetMultimap(
-                n -> TEMPLATE_FQCN_TRIM_FOR_GROUP_NAME.matcher(n).replaceAll(""), identity()));
-  }
-
-  private static String namePattern(String groupName, String excludedTemplate) {
-    return "(?!" + Pattern.quote(excludedTemplate) + ')' + namePattern(groupName);
-  }
-
-  private static String namePattern(String groupName) {
-    return Pattern.compile(Pattern.quote(groupName)) + "Templates.*";
-  }
-
-  private void verifyRefactoring(String groupName, String templateNamePattern) {
-    createRestrictedRefactoringTestHelper(templateNamePattern)
-        .addInput(groupName + "TemplatesTestInput.java")
-        .addOutput(groupName + "TemplatesTestOutput.java")
-        .doTest(TestMode.TEXT_MATCH);
-  }
-
-  private BugCheckerRefactoringTestHelper createRestrictedRefactoringTestHelper(
-      String namePattern) {
-    return BugCheckerRefactoringTestHelper.newInstance(RefasterCheck.class, getClass())
-        .setArgs("-XepOpt:Refaster:NamePattern=" + namePattern);
-  }
-}
--- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ScheduledTransactionTraceCheckTest.java
+++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ScheduledTransactionTraceCheckTest.java
@@ -0,0 +1,99 @@
+package tech.picnic.errorprone.bugpatterns;
+
+import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
+import com.google.errorprone.CompilationTestHelper;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledForJreRange;
+import org.junit.jupiter.api.condition.JRE;
+
+public final class ScheduledTransactionTraceCheckTest {
+  private final CompilationTestHelper compilationTestHelper =
+      CompilationTestHelper.newInstance(ScheduledTransactionTraceCheck.class, getClass());
+  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
+      BugCheckerRefactoringTestHelper.newInstance(ScheduledTransactionTraceCheck.class, getClass());
+
+  @Test
+  void identification() {
+    compilationTestHelper
+        .addSourceLines(
+            "A.java",
+            "import com.newrelic.api.agent.Trace;",
+            "import org.springframework.scheduling.annotation.Scheduled;",
+            "",
+            "class A {",
+            "  void notScheduled() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  // BUG: Diagnostic contains:",
+            "  void scheduledButNotTraced() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  // BUG: Diagnostic contains:",
+            "  @Trace",
+            "  void scheduledButImproperlyTraced1() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  // BUG: Diagnostic contains:",
+            "  @Trace(dispatcher = false)",
+            "  void scheduledButImproperlyTraced2() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(dispatcher = true)",
+            "  void scheduledAndProperlyTraced() {}",
+            "}")
+        .doTest();
+  }
+
+  // XXX: Enable this test for all JREs once https://github.com/google/error-prone/pull/2820 is
+  // merged and released.
+  @Test
+  @DisabledForJreRange(min = JRE.JAVA_12)
+  void replacement() {
+    refactoringTestHelper
+        .addInputLines(
+            "in/A.java",
+            "import com.newrelic.api.agent.Trace;",
+            "import org.springframework.scheduling.annotation.Scheduled;",
+            "",
+            "class A {",
+            "  @Scheduled(fixedDelay = 1)",
+            "  void scheduledButNotTraced() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace",
+            "  void scheduledButImproperlyTraced1() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(dispatcher = false)",
+            "  void scheduledButImproperlyTraced2() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(leaf = true)",
+            "  void scheduledButImproperlyTraced3() {}",
+            "}")
+        .addOutputLines(
+            "out/A.java",
+            "import com.newrelic.api.agent.Trace;",
+            "import org.springframework.scheduling.annotation.Scheduled;",
+            "",
+            "class A {",
+            "  @Trace(dispatcher = true)",
+            "  @Scheduled(fixedDelay = 1)",
+            "  void scheduledButNotTraced() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(dispatcher = true)",
+            "  void scheduledButImproperlyTraced1() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(dispatcher = true)",
+            "  void scheduledButImproperlyTraced2() {}",
+            "",
+            "  @Scheduled(fixedDelay = 1)",
+            "  @Trace(dispatcher = true, leaf = true)",
+            "  void scheduledButImproperlyTraced3() {}",
+            "}")
+        .doTest(TestMode.TEXT_MATCH);
+  }
+}
--- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/StaticImportCheckTest.java
+++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/StaticImportCheckTest.java
@@ -3,6 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import static org.assertj.core.api.Assertions.assertThat;

 import com.google.errorprone.BugCheckerRefactoringTestHelper;
+import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;

@@ -14,8 +15,20 @@ public final class StaticImportCheckTest {

  @Test
  void candidateMethodsAreNotRedundant() {
-    assertThat(StaticImportCheck.STATIC_IMPORT_CANDIDATE_METHODS.keySet())
-        .doesNotContainAnyElementsOf(StaticImportCheck.STATIC_IMPORT_CANDIDATE_CLASSES);
+    assertThat(StaticImportCheck.STATIC_IMPORT_CANDIDATE_MEMBERS.keySet())
+        .doesNotContainAnyElementsOf(StaticImportCheck.STATIC_IMPORT_CANDIDATE_TYPES);
+  }
+
+  @Test
+  void exemptedMembersAreNotVacuous() {
+    assertThat(StaticImportCheck.STATIC_IMPORT_EXEMPTED_MEMBERS.keySet())
+        .isSubsetOf(StaticImportCheck.STATIC_IMPORT_CANDIDATE_TYPES);
+  }
+
+  @Test
+  void exemptedMembersAreNotRedundant() {
+    assertThat(StaticImportCheck.STATIC_IMPORT_EXEMPTED_MEMBERS.values())
+        .doesNotContainAnyElementsOf(StaticImportCheck.STATIC_IMPORT_EXEMPTED_IDENTIFIERS);
  }

  @Test
@@ -27,6 +40,7 @@ public final class StaticImportCheckTest {
            "import static com.google.common.collect.ImmutableSet.toImmutableSet;",
            "import static java.nio.charset.StandardCharsets.UTF_8;",
            "import static java.util.function.Predicate.not;",
+            "import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT;",
            "",
            "import com.google.common.base.Predicates;",
            "import com.google.common.collect.ImmutableMap;",
@@ -35,6 +49,9 @@ public final class StaticImportCheckTest {
            "import java.nio.charset.StandardCharsets;",
            "import java.util.Optional;",
            "import java.util.function.Predicate;",
+            "import org.springframework.boot.test.context.SpringBootTest;",
+            "import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;",
+            "import org.springframework.http.MediaType;",
            "",
            "class A {",
            "  void m() {",
@@ -68,6 +85,15 @@ public final class StaticImportCheckTest {
            "    Object o1 = StandardCharsets.UTF_8;",
            "    Object o2 = UTF_8;",
            "",
+            "    // BUG: Diagnostic contains:",
+            "    Object e1 = WebEnvironment.RANDOM_PORT;",
+            "    Object e2 = RANDOM_PORT;",
+            "",
+            "    // Not flagged because `MediaType.ALL` is exempted.",
+            "    MediaType t1 = MediaType.ALL;",
+            "    // BUG: Diagnostic contains:",
+            "    MediaType t2 = MediaType.APPLICATION_JSON;",
+            "",
            "    Optional.empty();",
            "  }",
            "",
@@ -87,8 +113,13 @@ public final class StaticImportCheckTest {
            "import com.google.common.collect.ImmutableMap;",
            "import com.google.common.collect.ImmutableSet;",
            "import java.nio.charset.StandardCharsets;",
+            "import java.util.Objects;",
+            "import org.junit.jupiter.params.provider.Arguments;",
            "import org.springframework.format.annotation.DateTimeFormat;",
            "import org.springframework.format.annotation.DateTimeFormat.ISO;",
+            "import org.springframework.boot.test.context.SpringBootTest;",
+            "import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;",
+            "import org.springframework.http.MediaType;",
            "",
            "class A {",
            "  void m1() {",
@@ -101,7 +132,17 @@ public final class StaticImportCheckTest {
            "    Predicates.not(null);",
            "    not(null);",
            "",
+            "    Arguments.arguments(\"foo\");",
+            "",
+            "    Objects.requireNonNull(\"bar\");",
+            "",
            "    Object o = StandardCharsets.UTF_8;",
+            "",
+            "    ImmutableSet.of(",
+            "        MediaType.ALL,",
+            "        MediaType.APPLICATION_XHTML_XML,",
+            "        MediaType.TEXT_HTML,",
+            "        MediaType.valueOf(\"image/webp\"));",
            "  }",
            "",
            "  void m2(",
@@ -113,23 +154,36 @@ public final class StaticImportCheckTest {
            "      @DateTimeFormat(iso = ISO.DATE) String date,",
            "      @DateTimeFormat(iso = ISO.DATE_TIME) String dateTime,",
            "      @DateTimeFormat(iso = ISO.TIME) String time) {}",
+            "",
+            "   @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)",
+            "   final class Test {}",
            "}")
        .addOutputLines(
            "out/A.java",
            "import static com.google.common.collect.ImmutableMap.toImmutableMap;",
            "import static com.google.common.collect.ImmutableSet.toImmutableSet;",
            "import static java.nio.charset.StandardCharsets.UTF_8;",
+            "import static java.util.Objects.requireNonNull;",
            "import static java.util.function.Predicate.not;",
+            "import static org.junit.jupiter.params.provider.Arguments.arguments;",
+            "import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT;",
            "import static org.springframework.format.annotation.DateTimeFormat.ISO.DATE;",
            "import static org.springframework.format.annotation.DateTimeFormat.ISO.DATE_TIME;",
            "import static org.springframework.format.annotation.DateTimeFormat.ISO.TIME;",
+            "import static org.springframework.http.MediaType.APPLICATION_XHTML_XML;",
+            "import static org.springframework.http.MediaType.TEXT_HTML;",
            "",
            "import com.google.common.base.Predicates;",
            "import com.google.common.collect.ImmutableMap;",
            "import com.google.common.collect.ImmutableSet;",
            "import java.nio.charset.StandardCharsets;",
+            "import java.util.Objects;",
+            "import org.junit.jupiter.params.provider.Arguments;",
+            "import org.springframework.boot.test.context.SpringBootTest;",
+            "import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;",
            "import org.springframework.format.annotation.DateTimeFormat;",
            "import org.springframework.format.annotation.DateTimeFormat.ISO;",
+            "import org.springframework.http.MediaType;",
            "",
            "class A {",
            "  void m1() {",
@@ -142,7 +196,17 @@ public final class StaticImportCheckTest {
            "    Predicates.not(null);",
            "    not(null);",
            "",
+            "    arguments(\"foo\");",
+            "",
+            "    requireNonNull(\"bar\");",
+            "",
            "    Object o = UTF_8;",
+            "",
+            "    ImmutableSet.of(",
+            "        MediaType.ALL,",
+            "        APPLICATION_XHTML_XML,",
+            "        TEXT_HTML,",
+            "        MediaType.valueOf(\"image/webp\"));",
            "  }",
            "",
            "  void m2(",
@@ -154,7 +218,10 @@ public final class StaticImportCheckTest {
            "      @DateTimeFormat(iso = DATE) String date,",
            "      @DateTimeFormat(iso = DATE_TIME) String dateTime,",
            "      @DateTimeFormat(iso = TIME) String time) {}",
+            "",
+            "   @SpringBootTest(webEnvironment = RANDOM_PORT)",
+            "   final class Test {}",
            "}")
-        .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH);
+        .doTest(TestMode.TEXT_MATCH);
  }
 }
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestInput.java
@@ -7,6 +7,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
 import org.assertj.core.api.AbstractBigDecimalAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigDecimalTemplatesTestOutput.java
@@ -7,6 +7,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
 import org.assertj.core.api.AbstractBigDecimalAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBigDecimalTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigIntegerTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigIntegerTemplatesTestInput.java
@@ -7,6 +7,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 import com.google.common.collect.ImmutableSet;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigIntegerAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBigIntegerTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigIntegerTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBigIntegerTemplatesTestOutput.java
@@ -7,6 +7,7 @@ import static org.assertj.core.data.Percentage.withPercentage;
 import com.google.common.collect.ImmutableSet;
 import java.math.BigInteger;
 import org.assertj.core.api.AbstractBigIntegerAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBigIntegerTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBooleanTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBooleanTemplatesTestInput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractBooleanAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBooleanTemplatesTest implements RefasterTemplateTestCase {
  AbstractBooleanAssert<?> testAbstractBooleanAssertIsEqualTo() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBooleanTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJBooleanTemplatesTestOutput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractBooleanAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJBooleanTemplatesTest implements RefasterTemplateTestCase {
  AbstractBooleanAssert<?> testAbstractBooleanAssertIsEqualTo() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractByteAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJByteTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractByteAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJByteTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestInput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJCharSequenceTemplatesTest implements RefasterTemplateTestCase {
  void testAssertThatCharSequenceIsEmpty1() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJCharSequenceTemplatesTestOutput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJCharSequenceTemplatesTest implements RefasterTemplateTestCase {
  void testAssertThatCharSequenceIsEmpty1() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractDoubleAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJDoubleTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractDoubleAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJDoubleTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJEnumerableTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJEnumerableTemplatesTestInput.java
@@ -5,6 +5,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import org.assertj.core.api.EnumerableAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJEnumableTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJEnumerableTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJEnumerableTemplatesTestOutput.java
@@ -5,6 +5,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import org.assertj.core.api.EnumerableAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJEnumableTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractFloatAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJFloatTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractFloatAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJFloatTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractIntegerAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJIntegerTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractIntegerAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJIntegerTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractLongAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJLongTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractLongAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJLongTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestInput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.assertj.core.api.NumberAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJNumberTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<NumberAssert<?, ?>> testAbstractIntegerAssertIsPositive() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJNumberTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import org.assertj.core.api.NumberAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJNumberTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<NumberAssert<?, ?>> testAbstractIntegerAssertIsPositive() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectTemplatesTestInput.java
@@ -3,6 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import static org.assertj.core.api.Assertions.assertThat;

 import org.assertj.core.api.AbstractAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJObjectTemplatesTest implements RefasterTemplateTestCase {
  AbstractAssert<?, ?> testAssertThatIsInstanceOf() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJObjectTemplatesTestOutput.java
@@ -3,6 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import static org.assertj.core.api.Assertions.assertThat;

 import org.assertj.core.api.AbstractAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJObjectTemplatesTest implements RefasterTemplateTestCase {
  AbstractAssert<?, ?> testAssertThatIsInstanceOf() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJOptionalTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJOptionalTemplatesTestInput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.ImmutableSet;
 import java.util.Optional;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.OptionalAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJOptionalTemplatesTest implements RefasterTemplateTestCase {
  AbstractAssert<?, ?> testAssertThatOptional() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJOptionalTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJOptionalTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.ImmutableSet;
 import java.util.Optional;
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.OptionalAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJOptionalTemplatesTest implements RefasterTemplateTestCase {
  AbstractAssert<?, ?> testAssertThatOptional() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractShortAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJShortTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import static org.assertj.core.data.Percentage.withPercentage;

 import com.google.common.collect.ImmutableSet;
 import org.assertj.core.api.AbstractShortAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJShortTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestInput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractStringAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJStringTemplatesTest implements RefasterTemplateTestCase {
  void testAbstractStringAssertStringIsEmpty() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJStringTemplatesTestOutput.java
@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;

 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractStringAssert;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssertJStringTemplatesTest implements RefasterTemplateTestCase {
  void testAbstractStringAssertStringIsEmpty() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestInput.java
@@ -17,6 +17,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssortedTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssortedTemplatesTestOutput.java
@@ -21,6 +21,7 @@ import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class AssortedTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/BigDecimalTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/BigDecimalTemplatesTestInput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class BigDecimalTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<BigDecimal> testBigDecimalZero() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/BigDecimalTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/BigDecimalTemplatesTestOutput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import com.google.common.collect.ImmutableSet;
 import java.math.BigDecimal;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class BigDecimalTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<BigDecimal> testBigDecimalZero() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/CollectionTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/CollectionTemplatesTestInput.java
@@ -11,6 +11,7 @@ import java.util.LinkedList;
 import java.util.Optional;
 import java.util.TreeSet;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class CollectionTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/CollectionTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/CollectionTemplatesTestOutput.java
@@ -11,6 +11,7 @@ import java.util.LinkedList;
 import java.util.Optional;
 import java.util.TreeSet;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class CollectionTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ComparatorTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ComparatorTemplatesTestInput.java
@@ -8,6 +8,7 @@ import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ComparatorTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ComparatorTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ComparatorTemplatesTestOutput.java
@@ -10,6 +10,7 @@ import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ComparatorTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/DoubleStreamTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/DoubleStreamTemplatesTestInput.java
@@ -6,6 +6,7 @@ import java.util.OptionalDouble;
 import java.util.function.DoublePredicate;
 import java.util.stream.DoubleStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class DoubleStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/DoubleStreamTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/DoubleStreamTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import java.util.OptionalDouble;
 import java.util.function.DoublePredicate;
 import java.util.stream.DoubleStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class DoubleStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/EqualityTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/EqualityTemplatesTestInput.java
@@ -5,6 +5,7 @@ import com.google.common.collect.ImmutableSet;
 import java.math.RoundingMode;
 import java.util.Objects;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class EqualityTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/EqualityTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/EqualityTemplatesTestOutput.java
@@ -5,6 +5,7 @@ import com.google.common.collect.ImmutableSet;
 import java.math.RoundingMode;
 import java.util.Objects;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class EqualityTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java
@@ -16,6 +16,7 @@ import com.google.common.collect.Streams;
 import com.google.common.collect.TreeMultimap;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableListMultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java
@@ -16,6 +16,7 @@ import com.google.common.collect.Streams;
 import com.google.common.collect.TreeMultimap;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableListMultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestInput.java
@@ -13,6 +13,7 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableListTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListTemplatesTestOutput.java
@@ -14,6 +14,7 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableListTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Streams;
 import java.util.Collections;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableMapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Streams;
 import java.util.Collections;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableMapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java
@@ -10,6 +10,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableMultisetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java
@@ -10,6 +10,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableMultisetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java
@@ -13,6 +13,7 @@ import com.google.common.collect.Streams;
 import com.google.common.collect.TreeMultimap;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSetMultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java
@@ -13,6 +13,7 @@ import com.google.common.collect.Streams;
 import com.google.common.collect.TreeMultimap;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSetMultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
@@ -53,7 +54,7 @@ final class ImmutableSetMultimapTemplatesTest implements RefasterTemplateTestCas

  ImmutableSetMultimap<String, Integer> testTransformMultimapValuesToImmutableSetMultimap() {
    return ImmutableSetMultimap.copyOf(
-        Multimaps.transformValues(ImmutableSetMultimap.of("foo", 1L), v -> Math.toIntExact(v)));
+        Multimaps.transformValues(ImmutableSetMultimap.of("foo", 1L), e -> Math.toIntExact(e)));
  }

  ImmutableSet<ImmutableSetMultimap<String, Integer>>
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java
@@ -13,6 +13,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Set;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java
@@ -13,6 +13,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Set;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMapTemplatesTestInput.java
@@ -10,6 +10,7 @@ import com.google.common.collect.Streams;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedMapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMapTemplatesTestOutput.java
@@ -10,6 +10,7 @@ import com.google.common.collect.Streams;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedMapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMultisetTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMultisetTemplatesTestInput.java
@@ -13,6 +13,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedMultisetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMultisetTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedMultisetTemplatesTestOutput.java
@@ -13,6 +13,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedMultisetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedSetTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedSetTemplatesTestInput.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedSetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedSetTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSortedSetTemplatesTestOutput.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ImmutableSortedSetTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/IntStreamTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/IntStreamTemplatesTestInput.java
@@ -6,6 +6,7 @@ import java.util.OptionalInt;
 import java.util.function.IntPredicate;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class IntStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/IntStreamTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/IntStreamTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import java.util.OptionalInt;
 import java.util.function.IntPredicate;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class IntStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/JUnitTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/JUnitTemplatesTestInput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import com.google.common.collect.ImmutableSet;
 import org.junit.jupiter.params.provider.Arguments;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class JUnitTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Arguments> testArgumentsEnumeration() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/JUnitTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/JUnitTemplatesTestOutput.java
@@ -4,6 +4,7 @@ import static org.junit.jupiter.params.provider.Arguments.arguments;

 import com.google.common.collect.ImmutableSet;
 import org.junit.jupiter.params.provider.Arguments;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class JUnitTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Arguments> testArgumentsEnumeration() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/LongStreamTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/LongStreamTemplatesTestInput.java
@@ -6,6 +6,7 @@ import java.util.OptionalLong;
 import java.util.function.LongPredicate;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class LongStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/LongStreamTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/LongStreamTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import java.util.OptionalLong;
 import java.util.function.LongPredicate;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class LongStreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MapEntryTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MapEntryTemplatesTestInput.java
@@ -5,6 +5,7 @@ import com.google.common.collect.Maps;
 import java.util.AbstractMap;
 import java.util.Comparator;
 import java.util.Map;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MapEntryTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MapEntryTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MapEntryTemplatesTestOutput.java
@@ -8,6 +8,7 @@ import com.google.common.collect.Maps;
 import java.util.AbstractMap;
 import java.util.Comparator;
 import java.util.Map;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MapEntryTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MockitoTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MockitoTemplatesTestInput.java
@@ -6,6 +6,7 @@ import static org.mockito.Mockito.verify;

 import com.google.common.collect.ImmutableSet;
 import org.mockito.verification.VerificationMode;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MockitoTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MockitoTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MockitoTemplatesTestOutput.java
@@ -7,6 +7,7 @@ import static org.mockito.Mockito.verify;

 import com.google.common.collect.ImmutableSet;
 import org.mockito.verification.VerificationMode;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MockitoTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MultimapTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MultimapTemplatesTestInput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
 import java.util.Collection;
 import java.util.Set;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MultimapTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/MultimapTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
 import java.util.Collection;
 import java.util.Set;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class MultimapTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/NullTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/NullTemplatesTestInput.java
@@ -3,6 +3,7 @@ package tech.picnic.errorprone.bugpatterns;
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class NullTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/NullTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/NullTemplatesTestOutput.java
@@ -6,6 +6,7 @@ import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
 import java.util.Objects;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class NullTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/OptionalTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/OptionalTemplatesTestInput.java
@@ -5,6 +5,7 @@ import com.google.common.collect.Streams;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class OptionalTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/OptionalTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/OptionalTemplatesTestOutput.java
@@ -7,6 +7,7 @@ import com.google.common.collect.Streams;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class OptionalTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/PrimitiveTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/PrimitiveTemplatesTestInput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import com.google.common.collect.ImmutableSet;
 import com.google.common.primitives.Ints;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class PrimitiveTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/PrimitiveTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/PrimitiveTemplatesTestOutput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import com.google.common.collect.ImmutableSet;
 import com.google.common.primitives.Ints;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class PrimitiveTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java
@@ -1,5 +1,6 @@
 package tech.picnic.errorprone.bugpatterns;

+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.time.Duration;
 import java.util.Optional;
@@ -8,6 +9,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ReactorTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Mono<Integer>> testMonoFromOptional() {
@@ -45,10 +47,27 @@ final class ReactorTemplatesTest implements RefasterTemplateTestCase {
        Flux.just(1).switchIfEmpty(Mono.empty()), Flux.just(2).switchIfEmpty(Flux.empty()));
  }

+  ImmutableSet<Flux<Integer>> testFluxConcatMap() {
+    return ImmutableSet.of(
+        Flux.just(1).flatMap(Mono::just, 1), Flux.just(2).flatMapSequential(Mono::just, 1));
+  }
+
+  Flux<Integer> testFluxConcatMapIterable() {
+    return Flux.just(1, 2).flatMapIterable(ImmutableList::of);
+  }
+
  Flux<String> testMonoFlatMapToFlux() {
    return Mono.just("foo").flatMapMany(s -> Mono.just(s + s));
  }

+  Flux<String> testMonoFlux() {
+    return Flux.concat(Mono.just("foo"));
+  }
+
+  Flux<String> testFluxIdentity() {
+    return Flux.concat(Flux.just("foo"));
+  }
+
  ImmutableSet<Mono<Optional<String>>> testMonoCollectToOptional() {
    return ImmutableSet.of(
        Mono.just("foo").map(Optional::of).defaultIfEmpty(Optional.empty()),
@@ -59,6 +78,14 @@ final class ReactorTemplatesTest implements RefasterTemplateTestCase {
    return ImmutableSet.of(PublisherProbe.of(Mono.empty()), PublisherProbe.of(Flux.empty()));
  }

+  StepVerifier.FirstStep<Integer> testStepVerifierFromMono() {
+    return StepVerifier.create(Mono.just(1));
+  }
+
+  StepVerifier.FirstStep<Integer> testStepVerifierFromFlux() {
+    return StepVerifier.create(Flux.just(1));
+  }
+
  StepVerifier.Step<Integer> testStepVerifierStepExpectNextEmpty() {
    return StepVerifier.create(Mono.just(0)).expectNext();
  }
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java
@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns;

 import static com.google.common.collect.MoreCollectors.toOptional;

+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.time.Duration;
 import java.util.Optional;
@@ -10,6 +11,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 import reactor.test.publisher.PublisherProbe;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class ReactorTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Mono<Integer>> testMonoFromOptional() {
@@ -46,10 +48,26 @@ final class ReactorTemplatesTest implements RefasterTemplateTestCase {
    return ImmutableSet.of(Flux.just(1), Flux.just(2));
  }

+  ImmutableSet<Flux<Integer>> testFluxConcatMap() {
+    return ImmutableSet.of(Flux.just(1).concatMap(Mono::just), Flux.just(2).concatMap(Mono::just));
+  }
+
+  Flux<Integer> testFluxConcatMapIterable() {
+    return Flux.just(1, 2).concatMapIterable(ImmutableList::of);
+  }
+
  Flux<String> testMonoFlatMapToFlux() {
    return Mono.just("foo").flatMap(s -> Mono.just(s + s)).flux();
  }

+  Flux<String> testMonoFlux() {
+    return Mono.just("foo").flux();
+  }
+
+  Flux<String> testFluxIdentity() {
+    return Flux.just("foo");
+  }
+
  ImmutableSet<Mono<Optional<String>>> testMonoCollectToOptional() {
    return ImmutableSet.of(
        Mono.just("foo").flux().collect(toOptional()),
@@ -60,6 +78,14 @@ final class ReactorTemplatesTest implements RefasterTemplateTestCase {
    return ImmutableSet.of(PublisherProbe.empty(), PublisherProbe.empty());
  }

+  StepVerifier.FirstStep<Integer> testStepVerifierFromMono() {
+    return Mono.just(1).as(StepVerifier::create);
+  }
+
+  StepVerifier.FirstStep<Integer> testStepVerifierFromFlux() {
+    return Flux.just(1).as(StepVerifier::create);
+  }
+
  StepVerifier.Step<Integer> testStepVerifierStepExpectNextEmpty() {
    return StepVerifier.create(Mono.just(0));
  }
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java
@@ -12,6 +12,7 @@ import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Mono<Void>> testCompletableToMono() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java
@@ -12,6 +12,7 @@ import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
  ImmutableSet<Mono<Void>> testCompletableToMono() {
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StreamTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StreamTemplatesTestInput.java
@@ -10,6 +10,7 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class StreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StreamTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StreamTemplatesTestOutput.java
@@ -12,6 +12,7 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class StreamTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StringTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StringTemplatesTestInput.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class StringTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StringTemplatesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/StringTemplatesTestOutput.java
@@ -13,6 +13,7 @@ import com.google.common.collect.Streams;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.stream.Stream;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class StringTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/TestNGToAssertJTemplatesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/TestNGToAssertJTemplatesTestInput.java
@@ -17,6 +17,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
 import java.util.ArrayList;
 import java.util.Collections;
+import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;

 final class TestNGToAssertJTemplatesTest implements RefasterTemplateTestCase {
  @Override
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Pieter Dirk Soels	6943cbdc15	Apply suggestions	2022-03-23 16:17:26 +01:00
Rick Ossendrijver	d60598a5d2	Apply suggestions	2022-03-21 16:53:09 +01:00
Rick Ossendrijver	29f4a70f61	Remove validation in `error-prone-contrib`	2022-03-11 14:01:06 +01:00
Rick Ossendrijver	9430e0a1c0	Introduce validator for Refaster template collections and tests New method: `RefasterCollectionTestUtil#validateTemplateCollection`. This can verify that all Refaster templates from a given template collection are covered by at least one test and that the match rewrites code in the correct test method. Introduce the following modules: - `refaster-runner` - `refaster-test-support`	2022-03-11 14:01:00 +01:00
Rick Ossendrijver	793a70c29b	Configure static import policy for `AssertThatSetContainsExactlyOneElement` Refaster template (#32 )	2022-01-24 10:02:34 +01:00
Rick Ossendrijver	63b4fae185	Introduce `FluxFlatMapUsageCheck` (#26 ) And two (semi-)related Refaster templates.	2022-01-15 12:39:34 +01:00
Stephan Schroevers	73f8f056b4	Introduce `ScheduledTransactionTraceCheck` (#31 )	2022-01-10 10:21:20 +01:00
Rick Ossendrijver	c1638066cd	Define assorted `StaticImportCheck` exemptions While there, require that most `org.springframework.http.MediaType` members are statically imported.	2022-01-03 10:20:46 +01:00
Rick Ossendrijver	08e99fb54e	Use matching lambda parameter names in Refaster before- and after-templates (#24 )	2022-01-01 14:04:37 +01:00
Rick Ossendrijver	00012c6aa8	Extend `StaticImportCheck` test coverage (#21 )	2021-11-14 14:39:15 +01:00
Rick Ossendrijver	193589d193	Require static import of `SpringBootTest.WebEnvironment` constants (#19 )	2021-11-14 14:26:17 +01:00
Stephan Schroevers	1a1588d413	Upgrade Error Prone 2.9.0 -> 2.10.0	2021-11-14 13:50:26 +01:00
Stephan Schroevers	6656bd8186	Assorted upgrades	2021-11-14 13:50:26 +01:00
Rick Ossendrijver	26a9b46de7	Add Refaster rules for `StepVerifier` creation (#18 )	2021-11-14 13:48:39 +01:00
Phil Werli	17e74f778b	Add Refaster rules for redundant `Flux#concat` invocations (#20 )	2021-11-13 18:04:49 +01:00