diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
index c92668319f..ac9808f2c5 100644
--- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
+++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java
@@ -247,11 +247,43 @@ Flux<R> after(Flux<T> flux, Publisher<S> other, BiFunction<T, S, R> combinator)
     }
   }
 
+  /** Prefer {@link Flux#zipWithIterable(Iterable)} over more contrived alternatives. */
+  static final class FluxZipWithIterable<T, S> {
+    @BeforeTemplate
+    Flux<Tuple2<T, S>> before(Flux<T> flux, Iterable<S> iterable) {
+      return Flux.zip(flux, Flux.fromIterable(iterable));
+    }
+
+    @AfterTemplate
+    Flux<Tuple2<T, S>> after(Flux<T> flux, Iterable<S> iterable) {
+      return flux.zipWithIterable(iterable);
+    }
+  }
+
+  /** Prefer {@link Flux#zipWithIterable(Iterable, BiFunction)} over more contrived alternatives. */
+  static final class FluxZipWithIterableBiFunction<T, S, R> {
+    @BeforeTemplate
+    Flux<R> before(
+        Flux<T> flux,
+        Iterable<S> iterable,
+        BiFunction<? super T, ? super S, ? extends R> function) {
+      return flux.zipWith(Flux.fromIterable(iterable), function);
+    }
+
+    @AfterTemplate
+    Flux<R> after(
+        Flux<T> flux,
+        Iterable<S> iterable,
+        BiFunction<? super T, ? super S, ? extends R> function) {
+      return flux.zipWithIterable(iterable, function);
+    }
+  }
+
   /**
    * Prefer {@link Flux#zipWithIterable(Iterable)} with a chained combinator over {@link
    * Flux#zipWithIterable(Iterable, BiFunction)}, as the former generally yields more readable code.
    */
-  static final class FluxZipWithIterable<T, S, R> {
+  static final class FluxZipWithIterableMapFunction<T, S, R> {
     @BeforeTemplate
     Flux<R> before(Flux<T> flux, Iterable<S> iterable, BiFunction<T, S, R> combinator) {
       return flux.zipWithIterable(iterable, combinator);
@@ -328,7 +360,10 @@ Flux<T> after(Supplier<E> supplier) {
   static final class MonoThenReturn<T, S> {
     @BeforeTemplate
     Mono<S> before(Mono<T> mono, S object) {
-      return mono.then(Mono.just(object));
+      return Refaster.anyOf(
+          mono.ignoreElement().thenReturn(object),
+          mono.then().thenReturn(object),
+          mono.then(Mono.just(object)));
     }
 
     @AfterTemplate
@@ -401,7 +436,7 @@ Mono<T> before(Mono<T> mono) {
 
     @BeforeTemplate
     Mono<@Nullable Void> before2(Mono<@Nullable Void> mono) {
-      return mono.then();
+      return Refaster.anyOf(mono.ignoreElement(), mono.then());
     }
 
     // XXX: Replace this rule with an extension of the `IdentityConversion` rule, supporting
@@ -485,14 +520,46 @@ Flux<S> after(
     }
   }
 
+  /** Avoid contrived alternatives to {@link Mono#flatMapIterable(Function)}. */
+  static final class MonoFlatMapIterable<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Mono<T> mono, Function<? super T, ? extends Iterable<? extends S>> function) {
+      return Refaster.anyOf(
+          mono.map(function).flatMapIterable(identity()), mono.flux().concatMapIterable(function));
+    }
+
+    @AfterTemplate
+    Flux<S> after(Mono<T> mono, Function<? super T, ? extends Iterable<? extends S>> function) {
+      return mono.flatMapIterable(function);
+    }
+  }
+
+  /**
+   * Prefer {@link Mono#flatMapIterable(Function)} to flatten a {@link Mono} of some {@link
+   * Iterable} over less efficient alternatives.
+   */
+  static final class MonoFlatMapIterableIdentity<T, S extends Iterable<T>> {
+    @BeforeTemplate
+    Flux<T> before(Mono<S> mono) {
+      return mono.flatMapMany(Flux::fromIterable);
+    }
+
+    @AfterTemplate
+    @UseImportPolicy(STATIC_IMPORT_ALWAYS)
+    Flux<T> after(Mono<S> mono) {
+      return mono.flatMapIterable(identity());
+    }
+  }
+
   /**
-   * Prefer {@link Flux#concatMapIterable(Function)} over {@link Flux#flatMapIterable(Function)}, as
-   * the former has equivalent semantics but a clearer name.
+   * Prefer {@link Flux#concatMapIterable(Function)} over alternatives with less clear syntax or
+   * semantics.
    */
   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);
+      return Refaster.anyOf(
+          flux.flatMapIterable(function), flux.map(function).concatMapIterable(identity()));
     }
 
     @AfterTemplate
@@ -502,14 +569,16 @@ Flux<S> after(Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>>
   }
 
   /**
-   * Prefer {@link Flux#concatMapIterable(Function, int)} over {@link Flux#flatMapIterable(Function,
-   * int)}, as the former has equivalent semantics but a clearer name.
+   * Prefer {@link Flux#concatMapIterable(Function, int)} over alternatives with less clear syntax
+   * or semantics.
    */
   static final class FluxConcatMapIterableWithPrefetch<T, S> {
     @BeforeTemplate
     Flux<S> before(
         Flux<T> flux, Function<? super T, ? extends Iterable<? extends S>> function, int prefetch) {
-      return flux.flatMapIterable(function, prefetch);
+      return Refaster.anyOf(
+          flux.flatMapIterable(function, prefetch),
+          flux.map(function).concatMapIterable(identity(), prefetch));
     }
 
     @AfterTemplate
@@ -741,7 +810,7 @@ Flux<T> after(Mono<T> mono) {
   static final class MonoThen<T> {
     @BeforeTemplate
     Mono<@Nullable Void> before(Mono<T> mono) {
-      return mono.flux().then();
+      return Refaster.anyOf(mono.ignoreElement().then(), mono.flux().then());
     }
 
     @AfterTemplate
@@ -750,6 +819,128 @@ static final class MonoThen<T> {
     }
   }
 
+  /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
+  static final class FluxThen<T> {
+    @BeforeTemplate
+    Mono<@Nullable Void> before(Flux<T> flux) {
+      return flux.ignoreElements().then();
+    }
+
+    @BeforeTemplate
+    Mono<@Nullable Void> before2(Flux<@Nullable Void> flux) {
+      return flux.ignoreElements();
+    }
+
+    @AfterTemplate
+    Mono<@Nullable Void> after(Flux<T> flux) {
+      return flux.then();
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Mono#ignoreElement()}. */
+  static final class MonoThenEmpty<T> {
+    @BeforeTemplate
+    Mono<@Nullable Void> before(Mono<T> mono, Publisher<@Nullable Void> publisher) {
+      return mono.ignoreElement().thenEmpty(publisher);
+    }
+
+    @AfterTemplate
+    Mono<@Nullable Void> after(Mono<T> mono, Publisher<@Nullable Void> publisher) {
+      return mono.thenEmpty(publisher);
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
+  static final class FluxThenEmpty<T> {
+    @BeforeTemplate
+    Mono<@Nullable Void> before(Flux<T> flux, Publisher<@Nullable Void> publisher) {
+      return flux.ignoreElements().thenEmpty(publisher);
+    }
+
+    @AfterTemplate
+    Mono<@Nullable Void> after(Flux<T> flux, Publisher<@Nullable Void> publisher) {
+      return flux.thenEmpty(publisher);
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Mono#ignoreElement()}. */
+  static final class MonoThenMany<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Mono<T> mono, Publisher<S> publisher) {
+      return mono.ignoreElement().thenMany(publisher);
+    }
+
+    @AfterTemplate
+    Flux<S> after(Mono<T> mono, Publisher<S> publisher) {
+      return mono.thenMany(publisher);
+    }
+  }
+
+  /**
+   * Prefer explicit invocation of {@link Mono#flux()} over implicit conversions from {@link Mono}
+   * to {@link Flux}.
+   */
+  static final class MonoThenMonoFlux<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Mono<T> mono1, Mono<S> mono2) {
+      return mono1.thenMany(mono2);
+    }
+
+    @AfterTemplate
+    Flux<S> after(Mono<T> mono1, Mono<S> mono2) {
+      return mono1.then(mono2).flux();
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
+  static final class FluxThenMany<T, S> {
+    @BeforeTemplate
+    Flux<S> before(Flux<T> flux, Publisher<S> publisher) {
+      return flux.ignoreElements().thenMany(publisher);
+    }
+
+    @AfterTemplate
+    Flux<S> after(Flux<T> flux, Publisher<S> publisher) {
+      return flux.thenMany(publisher);
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Mono#ignoreElement()}. */
+  static final class MonoThenMono<T, S> {
+    @BeforeTemplate
+    Mono<S> before(Mono<T> mono1, Mono<S> mono2) {
+      return mono1.ignoreElement().then(mono2);
+    }
+
+    @BeforeTemplate
+    Mono<@Nullable Void> before2(Mono<T> mono1, Mono<@Nullable Void> mono2) {
+      return mono1.thenEmpty(mono2);
+    }
+
+    @AfterTemplate
+    Mono<S> after(Mono<T> mono1, Mono<S> mono2) {
+      return mono1.then(mono2);
+    }
+  }
+
+  /** Avoid vacuous invocations of {@link Flux#ignoreElements()}. */
+  static final class FluxThenMono<T, S> {
+    @BeforeTemplate
+    Mono<S> before(Flux<T> flux, Mono<S> mono) {
+      return flux.ignoreElements().then(mono);
+    }
+
+    @BeforeTemplate
+    Mono<@Nullable Void> before2(Flux<T> flux, Mono<@Nullable Void> mono) {
+      return flux.thenEmpty(mono);
+    }
+
+    @AfterTemplate
+    Mono<S> after(Flux<T> flux, Mono<S> mono) {
+      return flux.then(mono);
+    }
+  }
+
   /** Prefer {@link Mono#singleOptional()} over more contrived alternatives. */
   // XXX: Consider creating a plugin that flags/discourages `Mono<Optional<T>>` method return
   // types, just as we discourage nullable `Boolean`s and `Optional`s.
@@ -812,8 +1003,30 @@ Mono<T> after(Mono<S> mono, Function<? super S, ? extends Mono<? extends T>> fun
   static final class MonoFlatMapMany<S, T> {
     @BeforeTemplate
     @SuppressWarnings("NestedPublishers")
-    Flux<T> before(Mono<S> mono, Function<? super S, ? extends Publisher<? extends T>> function) {
-      return mono.map(function).flatMapMany(identity());
+    Flux<T> before(
+        Mono<S> mono,
+        Function<? super S, ? extends Publisher<? extends T>> function,
+        boolean delayUntilEnd,
+        int maxConcurrency,
+        int prefetch) {
+      return Refaster.anyOf(
+          mono.map(function).flatMapMany(identity()),
+          mono.flux().concatMap(function),
+          mono.flux().concatMap(function, prefetch),
+          mono.flux().concatMapDelayError(function),
+          mono.flux().concatMapDelayError(function, prefetch),
+          mono.flux().concatMapDelayError(function, delayUntilEnd, prefetch),
+          mono.flux().flatMap(function, maxConcurrency),
+          mono.flux().flatMap(function, maxConcurrency, prefetch),
+          mono.flux().flatMapDelayError(function, maxConcurrency, prefetch),
+          mono.flux().flatMapSequential(function, maxConcurrency),
+          mono.flux().flatMapSequential(function, maxConcurrency, prefetch),
+          mono.flux().flatMapSequentialDelayError(function, maxConcurrency, prefetch));
+    }
+
+    @BeforeTemplate
+    Flux<T> before(Mono<S> mono, Function<? super S, Publisher<? extends T>> function) {
+      return mono.flux().switchMap(function);
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
index 7f8021f70c..002df87ca7 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestInput.java
@@ -98,7 +98,16 @@ Flux<String> testFluxZipWithCombinator() {
     return Flux.just("foo", "bar").zipWith(Flux.just(1, 2), String::repeat);
   }
 
-  Flux<String> testFluxZipWithIterable() {
+  Flux<Tuple2<String, Integer>> testFluxZipWithIterable() {
+    return Flux.zip(Flux.just("foo", "bar"), Flux.fromIterable(ImmutableSet.of(1, 2)));
+  }
+
+  Flux<String> testFluxZipWithIterableBiFunction() {
+    return Flux.just("foo", "bar")
+        .zipWith(Flux.fromIterable(ImmutableSet.of(1, 2)), String::repeat);
+  }
+
+  Flux<String> testFluxZipWithIterableMapFunction() {
     return Flux.just("foo", "bar").zipWithIterable(ImmutableSet.of(1, 2), String::repeat);
   }
 
@@ -118,8 +127,11 @@ Flux<Void> testFluxErrorSupplier() {
     return Flux.error(() -> ((Supplier<RuntimeException>) null).get());
   }
 
-  Mono<String> testMonoThenReturn() {
-    return Mono.empty().then(Mono.just("foo"));
+  ImmutableSet<Mono<String>> testMonoThenReturn() {
+    return ImmutableSet.of(
+        Mono.just(1).ignoreElement().thenReturn("foo"),
+        Mono.just(2).then().thenReturn("bar"),
+        Mono.just(3).then(Mono.just("baz")));
   }
 
   Flux<Integer> testFluxTake() {
@@ -141,6 +153,7 @@ ImmutableSet<Mono<?>> testMonoIdentity() {
         Mono.just(1).switchIfEmpty(Mono.empty()),
         Mono.just(2).flux().next(),
         Mono.just(3).flux().singleOrEmpty(),
+        Mono.<Void>empty().ignoreElement(),
         Mono.<Void>empty().then(),
         Mono.<ImmutableList<String>>empty().map(ImmutableList::copyOf));
   }
@@ -168,12 +181,26 @@ ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
         Flux.just(3).map(Mono::just).concatMap(identity(), 5));
   }
 
-  Flux<Integer> testFluxConcatMapIterable() {
-    return Flux.just(1, 2).flatMapIterable(ImmutableList::of);
+  ImmutableSet<Flux<Integer>> testMonoFlatMapIterable() {
+    return ImmutableSet.of(
+        Mono.just(1).map(ImmutableSet::of).flatMapIterable(identity()),
+        Mono.just(2).flux().concatMapIterable(ImmutableSet::of));
+  }
+
+  Flux<Integer> testMonoFlatMapIterableIdentity() {
+    return Mono.just(ImmutableSet.of(1)).flatMapMany(Flux::fromIterable);
   }
 
-  Flux<Integer> testFluxConcatMapIterableWithPrefetch() {
-    return Flux.just(1, 2).flatMapIterable(ImmutableList::of, 3);
+  ImmutableSet<Flux<Integer>> testFluxConcatMapIterable() {
+    return ImmutableSet.of(
+        Flux.just(1).flatMapIterable(ImmutableList::of),
+        Flux.just(2).map(ImmutableList::of).concatMapIterable(identity()));
+  }
+
+  ImmutableSet<Flux<Integer>> testFluxConcatMapIterableWithPrefetch() {
+    return ImmutableSet.of(
+        Flux.just(1).flatMapIterable(ImmutableList::of, 3),
+        Flux.just(2).map(ImmutableList::of).concatMapIterable(identity(), 3));
   }
 
   Flux<String> testMonoFlatMapToFlux() {
@@ -251,8 +278,45 @@ ImmutableSet<Flux<String>> testMonoFlux() {
         Flux.concat(Mono.just("baz")));
   }
 
-  Mono<Void> testMonoThen() {
-    return Mono.just("foo").flux().then();
+  ImmutableSet<Mono<Void>> testMonoThen() {
+    return ImmutableSet.of(Mono.just("foo").ignoreElement().then(), Mono.just("bar").flux().then());
+  }
+
+  ImmutableSet<Mono<Void>> testFluxThen() {
+    return ImmutableSet.of(
+        Flux.just("foo").ignoreElements().then(), Flux.<Void>empty().ignoreElements());
+  }
+
+  Mono<Void> testMonoThenEmpty() {
+    return Mono.just("foo").ignoreElement().thenEmpty(Mono.empty());
+  }
+
+  Mono<Void> testFluxThenEmpty() {
+    return Flux.just("foo").ignoreElements().thenEmpty(Mono.empty());
+  }
+
+  Flux<String> testMonoThenMany() {
+    return Mono.just("foo").ignoreElement().thenMany(Flux.just("bar"));
+  }
+
+  Flux<String> testMonoThenMonoFlux() {
+    return Mono.just("foo").thenMany(Mono.just("bar"));
+  }
+
+  Flux<String> testFluxThenMany() {
+    return Flux.just("foo").ignoreElements().thenMany(Flux.just("bar"));
+  }
+
+  ImmutableSet<Mono<?>> testMonoThenMono() {
+    return ImmutableSet.of(
+        Mono.just("foo").ignoreElement().then(Mono.just("bar")),
+        Mono.just("baz").thenEmpty(Mono.<Void>empty()));
+  }
+
+  ImmutableSet<Mono<?>> testFluxThenMono() {
+    return ImmutableSet.of(
+        Flux.just("foo").ignoreElements().then(Mono.just("bar")),
+        Flux.just("baz").thenEmpty(Mono.<Void>empty()));
   }
 
   ImmutableSet<Mono<Optional<String>>> testMonoSingleOptional() {
@@ -273,8 +337,21 @@ Mono<String> testMonoFlatMap() {
     return Mono.just("foo").map(Mono::just).flatMap(identity());
   }
 
-  Flux<String> testMonoFlatMapMany() {
-    return Mono.just("foo").map(Mono::just).flatMapMany(identity());
+  ImmutableSet<Flux<Integer>> testMonoFlatMapMany() {
+    return ImmutableSet.of(
+        Mono.just(1).map(Mono::just).flatMapMany(identity()),
+        Mono.just(2).flux().concatMap(Mono::just),
+        Mono.just(3).flux().concatMap(Mono::just, 2),
+        Mono.just(4).flux().concatMapDelayError(Mono::just),
+        Mono.just(5).flux().concatMapDelayError(Mono::just, 2),
+        Mono.just(6).flux().concatMapDelayError(Mono::just, false, 2),
+        Mono.just(7).flux().flatMap(Mono::just, 2),
+        Mono.just(8).flux().flatMap(Mono::just, 2, 3),
+        Mono.just(9).flux().flatMapDelayError(Mono::just, 2, 3),
+        Mono.just(10).flux().flatMapSequential(Mono::just, 2),
+        Mono.just(11).flux().flatMapSequential(Mono::just, 2, 3),
+        Mono.just(12).flux().flatMapSequentialDelayError(Mono::just, 2, 3),
+        Mono.just(13).flux().switchMap(Mono::just));
   }
 
   ImmutableSet<Flux<String>> testConcatMapIterableIdentity() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
index b12af508c4..9b24aa3b24 100644
--- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
+++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ReactorRulesTestOutput.java
@@ -102,7 +102,15 @@ Flux<String> testFluxZipWithCombinator() {
         .map(TupleUtils.function(String::repeat));
   }
 
-  Flux<String> testFluxZipWithIterable() {
+  Flux<Tuple2<String, Integer>> testFluxZipWithIterable() {
+    return Flux.just("foo", "bar").zipWithIterable(ImmutableSet.of(1, 2));
+  }
+
+  Flux<String> testFluxZipWithIterableBiFunction() {
+    return Flux.just("foo", "bar").zipWithIterable(ImmutableSet.of(1, 2), String::repeat);
+  }
+
+  Flux<String> testFluxZipWithIterableMapFunction() {
     return Flux.just("foo", "bar")
         .zipWithIterable(ImmutableSet.of(1, 2))
         .map(function(String::repeat));
@@ -124,8 +132,11 @@ Flux<Void> testFluxErrorSupplier() {
     return Flux.error(((Supplier<RuntimeException>) null));
   }
 
-  Mono<String> testMonoThenReturn() {
-    return Mono.empty().thenReturn("foo");
+  ImmutableSet<Mono<String>> testMonoThenReturn() {
+    return ImmutableSet.of(
+        Mono.just(1).thenReturn("foo"),
+        Mono.just(2).thenReturn("bar"),
+        Mono.just(3).thenReturn("baz"));
   }
 
   Flux<Integer> testFluxTake() {
@@ -147,6 +158,7 @@ ImmutableSet<Mono<?>> testMonoIdentity() {
         Mono.just(2),
         Mono.just(3),
         Mono.<Void>empty(),
+        Mono.<Void>empty(),
         Mono.<ImmutableList<String>>empty());
   }
 
@@ -172,12 +184,26 @@ ImmutableSet<Flux<Integer>> testFluxConcatMapWithPrefetch() {
         Flux.just(3).concatMap(Mono::just, 5));
   }
 
-  Flux<Integer> testFluxConcatMapIterable() {
-    return Flux.just(1, 2).concatMapIterable(ImmutableList::of);
+  ImmutableSet<Flux<Integer>> testMonoFlatMapIterable() {
+    return ImmutableSet.of(
+        Mono.just(1).flatMapIterable(ImmutableSet::of),
+        Mono.just(2).flatMapIterable(ImmutableSet::of));
+  }
+
+  Flux<Integer> testMonoFlatMapIterableIdentity() {
+    return Mono.just(ImmutableSet.of(1)).flatMapIterable(identity());
+  }
+
+  ImmutableSet<Flux<Integer>> testFluxConcatMapIterable() {
+    return ImmutableSet.of(
+        Flux.just(1).concatMapIterable(ImmutableList::of),
+        Flux.just(2).concatMapIterable(ImmutableList::of));
   }
 
-  Flux<Integer> testFluxConcatMapIterableWithPrefetch() {
-    return Flux.just(1, 2).concatMapIterable(ImmutableList::of, 3);
+  ImmutableSet<Flux<Integer>> testFluxConcatMapIterableWithPrefetch() {
+    return ImmutableSet.of(
+        Flux.just(1).concatMapIterable(ImmutableList::of, 3),
+        Flux.just(2).concatMapIterable(ImmutableList::of, 3));
   }
 
   Flux<String> testMonoFlatMapToFlux() {
@@ -250,8 +276,42 @@ ImmutableSet<Flux<String>> testMonoFlux() {
         Mono.just("foo").flux(), Mono.just("bar").flux(), Mono.just("baz").flux());
   }
 
-  Mono<Void> testMonoThen() {
-    return Mono.just("foo").then();
+  ImmutableSet<Mono<Void>> testMonoThen() {
+    return ImmutableSet.of(Mono.just("foo").then(), Mono.just("bar").then());
+  }
+
+  ImmutableSet<Mono<Void>> testFluxThen() {
+    return ImmutableSet.of(Flux.just("foo").then(), Flux.<Void>empty().then());
+  }
+
+  Mono<Void> testMonoThenEmpty() {
+    return Mono.just("foo").thenEmpty(Mono.empty());
+  }
+
+  Mono<Void> testFluxThenEmpty() {
+    return Flux.just("foo").thenEmpty(Mono.empty());
+  }
+
+  Flux<String> testMonoThenMany() {
+    return Mono.just("foo").thenMany(Flux.just("bar"));
+  }
+
+  Flux<String> testMonoThenMonoFlux() {
+    return Mono.just("foo").then(Mono.just("bar")).flux();
+  }
+
+  Flux<String> testFluxThenMany() {
+    return Flux.just("foo").thenMany(Flux.just("bar"));
+  }
+
+  ImmutableSet<Mono<?>> testMonoThenMono() {
+    return ImmutableSet.of(
+        Mono.just("foo").then(Mono.just("bar")), Mono.just("baz").then(Mono.<Void>empty()));
+  }
+
+  ImmutableSet<Mono<?>> testFluxThenMono() {
+    return ImmutableSet.of(
+        Flux.just("foo").then(Mono.just("bar")), Flux.just("baz").then(Mono.<Void>empty()));
   }
 
   ImmutableSet<Mono<Optional<String>>> testMonoSingleOptional() {
@@ -270,8 +330,21 @@ Mono<String> testMonoFlatMap() {
     return Mono.just("foo").flatMap(Mono::just);
   }
 
-  Flux<String> testMonoFlatMapMany() {
-    return Mono.just("foo").flatMapMany(Mono::just);
+  ImmutableSet<Flux<Integer>> testMonoFlatMapMany() {
+    return ImmutableSet.of(
+        Mono.just(1).flatMapMany(Mono::just),
+        Mono.just(2).flatMapMany(Mono::just),
+        Mono.just(3).flatMapMany(Mono::just),
+        Mono.just(4).flatMapMany(Mono::just),
+        Mono.just(5).flatMapMany(Mono::just),
+        Mono.just(6).flatMapMany(Mono::just),
+        Mono.just(7).flatMapMany(Mono::just),
+        Mono.just(8).flatMapMany(Mono::just),
+        Mono.just(9).flatMapMany(Mono::just),
+        Mono.just(10).flatMapMany(Mono::just),
+        Mono.just(11).flatMapMany(Mono::just),
+        Mono.just(12).flatMapMany(Mono::just),
+        Mono.just(13).flatMapMany(Mono::just));
   }
 
   ImmutableSet<Flux<String>> testConcatMapIterableIdentity() {