diff --git a/mug/src/main/java/com/google/mu/util/stream/BiStream.java b/mug/src/main/java/com/google/mu/util/stream/BiStream.java
index 4a86867429..13b7b2da3e 100644
--- a/mug/src/main/java/com/google/mu/util/stream/BiStream.java
+++ b/mug/src/main/java/com/google/mu/util/stream/BiStream.java
@@ -144,7 +144,7 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.3
    */
   public static <K, V> Collector<V, ?, BiStream<K, V>> groupingBy(
-      Function<? super V, ? extends K> classifier, BinaryOperator<V> reducer) {
+          Function<? super V, ? extends K> classifier, BinaryOperator<V> reducer) {
     return groupingBy(classifier, reducingGroupMembers(reducer));
   }
 
@@ -163,9 +163,9 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.3
    */
   public static <T, K, V> Collector<T, ?, BiStream<K, V>> groupingBy(
-      Function<? super T, ? extends K> classifier,
-      Function<? super T, ? extends V> mapper,
-      BinaryOperator<V> reducer) {
+          Function<? super T, ? extends K> classifier,
+          Function<? super T, ? extends V> mapper,
+          BinaryOperator<V> reducer) {
     return groupingBy(classifier, Collectors.mapping(mapper, reducingGroupMembers(reducer)));
   }
 
@@ -191,7 +191,7 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.0
    */
   public static <T, K> Collector<T, ?, BiStream<K, List<T>>> groupingBy(
-      Function<? super T, ? extends K> classifier) {
+          Function<? super T, ? extends K> classifier) {
     return groupingBy(classifier, toList());
   }
 
@@ -220,10 +220,10 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.0
    */
   public static <T, K, V> Collector<T, ?, BiStream<K, V>> groupingBy(
-      Function<? super T, ? extends K> classifier, Collector<? super T, ?, V> valueCollector) {
+          Function<? super T, ? extends K> classifier, Collector<? super T, ?, V> valueCollector) {
     requireNonNull(classifier);
     Collector<T, ?, Map<K, V>> grouping =
-        Collectors.groupingBy(classifier, LinkedHashMap::new, valueCollector);
+            Collectors.groupingBy(classifier, LinkedHashMap::new, valueCollector);
     return collectingAndThen(grouping, BiStream::from);
   }
 
@@ -245,12 +245,12 @@ public static <K, V> Builder<K, V> builder() {
    * @since 6.5
    */
   public static <T, K, V> Collector<T, ?, BiStream<K, V>> groupingByEach(
-      Function<? super T, ? extends Stream<? extends K>> keysFunction,
-      Collector<T, ?, V> groupCollector) {
+          Function<? super T, ? extends Stream<? extends K>> keysFunction,
+          Collector<T, ?, V> groupCollector) {
     requireNonNull(keysFunction);
     return Java9Collectors.flatMapping(
-        (T e) -> keysFunction.apply(e).map(k -> kv(k, e)),
-        groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, groupCollector)));
+            (T e) -> keysFunction.apply(e).map(k -> kv(k, e)),
+            groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, groupCollector)));
   }
 
   /**
@@ -275,18 +275,18 @@ public static <K, V> Builder<K, V> builder() {
    * @since 6.5
    */
   public static <T, K, V, G> Collector<T, ?, BiStream<K, G>> groupingByEach(
-      Function<? super T, ? extends Stream<? extends K>> keysFunction,
-      Function<? super T, ? extends V> valueFunction,
-      Collector<V, ?, G> groupCollector) {
+          Function<? super T, ? extends Stream<? extends K>> keysFunction,
+          Function<? super T, ? extends V> valueFunction,
+          Collector<V, ?, G> groupCollector) {
     requireNonNull(keysFunction);
     requireNonNull(valueFunction);
     requireNonNull(groupCollector);
     return Java9Collectors.flatMapping(
-        (T e) -> {
-          V v = valueFunction.apply(e);
-          return keysFunction.apply(e).map(k -> kv(k, v));
-        },
-        groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, groupCollector)));
+            (T e) -> {
+              V v = valueFunction.apply(e);
+              return keysFunction.apply(e).map(k -> kv(k, v));
+            },
+            groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, groupCollector)));
   }
 
   /**
@@ -310,9 +310,9 @@ public static <K, V> Builder<K, V> builder() {
    * @since 6.5
    */
   public static <T, K, V> Collector<T, ?, BiStream<K, V>> groupingByEach(
-      Function<? super T, ? extends Stream<? extends K>> keysFunction,
-      Function<? super T, ? extends V> valueFunction,
-      BinaryOperator<V> groupReducer) {
+          Function<? super T, ? extends Stream<? extends K>> keysFunction,
+          Function<? super T, ? extends V> valueFunction,
+          BinaryOperator<V> groupReducer) {
     return groupingByEach(keysFunction, valueFunction, reducingGroupMembers(groupReducer));
   }
 
@@ -332,7 +332,7 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.0
    */
   public static <T, K, V> Collector<T, ?, BiStream<K, V>> concatenating(
-      Function<? super T, ? extends BiStream<? extends K, ? extends V>> toBiStream) {
+          Function<? super T, ? extends BiStream<? extends K, ? extends V>> toBiStream) {
     return collectingAndThen(stream -> concat(stream.map(toBiStream)));
   }
 
@@ -360,10 +360,10 @@ public static <K, V> Builder<K, V> builder() {
   public static <L, R> Collector<L, ?, BiStream<L, R>> crossJoining(Stream<R> right) {
     requireNonNull(right);
     return collectingAndThen(
-        toList(),
-        (List<L> left) ->
-            // If `right` is infinite, even limit(1) will result in infinite loop otherwise.
-            left.isEmpty() ? empty() : concat(right.map(r -> from(left, identity(), l -> r))));
+            toList(),
+            (List<L> left) ->
+                    // If `right` is infinite, even limit(1) will result in infinite loop otherwise.
+                    left.isEmpty() ? empty() : concat(right.map(r -> from(left, identity(), l -> r))));
   }
 
   /**
@@ -391,7 +391,7 @@ public static <K, V> Builder<K, V> builder() {
    * @since 3.2
    */
   public static <E, K, V> Collector<E, ?, BiStream<K, V>> toBiStream(
-      Function<? super E, ? extends K> toKey, Function<? super E, ? extends V> toValue) {
+          Function<? super E, ? extends K> toKey, Function<? super E, ? extends V> toValue) {
     requireNonNull(toKey);
     requireNonNull(toValue);
     return collectingAndThen(stream -> from(stream, toKey, toValue));
@@ -408,7 +408,7 @@ public static <K, V> Builder<K, V> builder() {
    * @since 5.1
    */
   public static <E, K, V> Collector<E, ?, BiStream<K, V>> toBiStream(
-      Function<? super E, ? extends Both<? extends K, ? extends V>> toPair) {
+          Function<? super E, ? extends Both<? extends K, ? extends V>> toPair) {
     requireNonNull(toPair);;
     return collectingAndThen(stream -> from(stream.map(toPair)));
   }
@@ -439,18 +439,18 @@ public static <K, V> BiStream<K, V> of(K key, V value) {
 
   /** Returns a {@code BiStream} of two pairs, containing the supplied keys and values. */
   public static <K, V> BiStream<K, V> of(
-      K key1, V value1, K key2, V value2) {
+          K key1, V value1, K key2, V value2) {
     return fromEntries(Stream.of(kv(key1, value1), kv(key2, value2)));
   }
 
   /** Returns a {@code BiStream} of three pairs, containing the supplied keys and values. */
   public static <K, V> BiStream<K, V> of(
-      K key1,
-      V value1,
-      K key2,
-      V value2,
-      K key3,
-      V value3) {
+          K key1,
+          V value1,
+          K key2,
+          V value2,
+          K key3,
+          V value3) {
     return fromEntries(Stream.of(kv(key1, value1), kv(key2, value2), kv(key3, value3)));
   }
 
@@ -460,14 +460,14 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4) {
     return fromEntries(Stream.of(kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4)));
   }
 
@@ -477,16 +477,16 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5) {
     return fromEntries(Stream.of(kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4), kv(k5, v5)));
   }
 
@@ -496,20 +496,20 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5,
-      K k6,
-      V v6) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5,
+          K k6,
+          V v6) {
     return fromEntries(
-        Stream.of(kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4), kv(k5, v5), kv(k6, v6)));
+            Stream.of(kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4), kv(k5, v5), kv(k6, v6)));
   }
 
   /**
@@ -518,23 +518,23 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5,
-      K k6,
-      V v6,
-      K k7,
-      V v7) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5,
+          K k6,
+          V v6,
+          K k7,
+          V v7) {
     return fromEntries(
-        Stream.of(
-            kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4), kv(k5, v5), kv(k6, v6), kv(k7, v7)));
+            Stream.of(
+                    kv(k1, v1), kv(k2, v2), kv(k3, v3), kv(k4, v4), kv(k5, v5), kv(k6, v6), kv(k7, v7)));
   }
 
   /**
@@ -543,32 +543,32 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5,
-      K k6,
-      V v6,
-      K k7,
-      V v7,
-      K k8,
-      V v8) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5,
+          K k6,
+          V v6,
+          K k7,
+          V v7,
+          K k8,
+          V v8) {
     return fromEntries(
-        Stream.of(
-            kv(k1, v1),
-            kv(k2, v2),
-            kv(k3, v3),
-            kv(k4, v4),
-            kv(k5, v5),
-            kv(k6, v6),
-            kv(k7, v7),
-            kv(k8, v8)));
+            Stream.of(
+                    kv(k1, v1),
+                    kv(k2, v2),
+                    kv(k3, v3),
+                    kv(k4, v4),
+                    kv(k5, v5),
+                    kv(k6, v6),
+                    kv(k7, v7),
+                    kv(k8, v8)));
   }
 
   /**
@@ -577,35 +577,35 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5,
-      K k6,
-      V v6,
-      K k7,
-      V v7,
-      K k8,
-      V v8,
-      K k9,
-      V v9) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5,
+          K k6,
+          V v6,
+          K k7,
+          V v7,
+          K k8,
+          V v8,
+          K k9,
+          V v9) {
     return fromEntries(
-        Stream.of(
-            kv(k1, v1),
-            kv(k2, v2),
-            kv(k3, v3),
-            kv(k4, v4),
-            kv(k5, v5),
-            kv(k6, v6),
-            kv(k7, v7),
-            kv(k8, v8),
-            kv(k9, v9)));
+            Stream.of(
+                    kv(k1, v1),
+                    kv(k2, v2),
+                    kv(k3, v3),
+                    kv(k4, v4),
+                    kv(k5, v5),
+                    kv(k6, v6),
+                    kv(k7, v7),
+                    kv(k8, v8),
+                    kv(k9, v9)));
   }
 
   /**
@@ -614,38 +614,38 @@ public static <K, V> BiStream<K, V> of(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> of(
-      K k1,
-      V v1,
-      K k2,
-      V v2,
-      K k3,
-      V v3,
-      K k4,
-      V v4,
-      K k5,
-      V v5,
-      K k6,
-      V v6,
-      K k7,
-      V v7,
-      K k8,
-      V v8,
-      K k9,
-      V v9,
-      K k10,
-      V v10) {
+          K k1,
+          V v1,
+          K k2,
+          V v2,
+          K k3,
+          V v3,
+          K k4,
+          V v4,
+          K k5,
+          V v5,
+          K k6,
+          V v6,
+          K k7,
+          V v7,
+          K k8,
+          V v8,
+          K k9,
+          V v9,
+          K k10,
+          V v10) {
     return fromEntries(
-        Stream.of(
-            kv(k1, v1),
-            kv(k2, v2),
-            kv(k3, v3),
-            kv(k4, v4),
-            kv(k5, v5),
-            kv(k6, v6),
-            kv(k7, v7),
-            kv(k8, v8),
-            kv(k9, v9),
-            kv(k10, v10)));
+            Stream.of(
+                    kv(k1, v1),
+                    kv(k2, v2),
+                    kv(k3, v3),
+                    kv(k4, v4),
+                    kv(k5, v5),
+                    kv(k6, v6),
+                    kv(k7, v7),
+                    kv(k8, v8),
+                    kv(k9, v9),
+                    kv(k10, v10)));
   }
 
   /**
@@ -660,9 +660,9 @@ public static <K, V> BiStream<K, V> of(
    */
   @SafeVarargs
   public static <K, V> BiStream<K, V> concat(
-      Map<? extends K, ? extends V> m1,
-      Map<? extends K, ? extends V> m2,
-      Map<? extends K, ? extends V>... rest) {
+          Map<? extends K, ? extends V> m1,
+          Map<? extends K, ? extends V> m2,
+          Map<? extends K, ? extends V>... rest) {
     Stream.Builder<Map<? extends K, ? extends V>> builder = Stream.builder();
     builder.add(requireNonNull(m1)).add(requireNonNull(m2));
     for (Map<? extends K, ? extends V> m : rest) {
@@ -683,9 +683,9 @@ public static <K, V> BiStream<K, V> concat(
    */
   @SafeVarargs
   public static <K, V> BiStream<K, V> concat(
-      BiStream<? extends K, ? extends V> s1,
-      BiStream<? extends K, ? extends V> s2,
-      BiStream<? extends K, ? extends V>... rest) {
+          BiStream<? extends K, ? extends V> s1,
+          BiStream<? extends K, ? extends V> s2,
+          BiStream<? extends K, ? extends V>... rest) {
     Stream.Builder<BiStream<? extends K, ? extends V>> builder = Stream.builder();
     builder.add(requireNonNull(s1)).add(requireNonNull(s2));
     for (BiStream<? extends K, ? extends V> s : rest) {
@@ -700,7 +700,7 @@ public static <K, V> BiStream<K, V> concat(
    * @since 3.0
    */
   public static <K, V> BiStream<K, V> concat(
-      Stream<? extends BiStream<? extends K, ? extends V>> biStreams) {
+          Stream<? extends BiStream<? extends K, ? extends V>> biStreams) {
     return fromEntries(biStreams.flatMap(BiStream::mapToEntry));
   }
 
@@ -785,7 +785,7 @@ public static <T> BiStream<T, T> biStream(Stream<T> elements) {
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> biStream(
-      Collection<K> keys, Function<? super K, ? extends V> toValue) {
+          Collection<K> keys, Function<? super K, ? extends V> toValue) {
     return new GenericEntryStream<>(keys.stream(), identity(), toValue);
   }
 
@@ -801,7 +801,7 @@ public static <K, V> BiStream<K, V> biStream(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> biStream(
-      Stream<K> keys, Function<? super K, ? extends V> toValue) {
+          Stream<K> keys, Function<? super K, ? extends V> toValue) {
     return new GenericEntryStream<>(keys, identity(), toValue);
   }
 
@@ -819,7 +819,7 @@ public static <K, V> BiStream<K, V> biStream(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> biStream(
-      Function<? super V, ? extends K> toKey, Collection<V> values) {
+          Function<? super V, ? extends K> toKey, Collection<V> values) {
     return new GenericEntryStream<>(values.stream(), toKey, identity());
   }
 
@@ -837,7 +837,7 @@ public static <K, V> BiStream<K, V> biStream(
    * @since 5.6
    */
   public static <K, V> BiStream<K, V> biStream(
-      Function<? super V, ? extends K> toKey, Stream<V> values) {
+          Function<? super V, ? extends K> toKey, Stream<V> values) {
     return new GenericEntryStream<>(values, toKey, identity());
   }
 
@@ -866,9 +866,9 @@ public static <K, V> BiStream<K, V> from(Collection<? extends Map.Entry<? extend
    */
   @Deprecated
   public static <T, K, V> BiStream<K, V> from(
-      Collection<T> elements,
-      Function<? super T, ? extends K> toKey,
-      Function<? super T, ? extends V> toValue) {
+          Collection<T> elements,
+          Function<? super T, ? extends K> toKey,
+          Function<? super T, ? extends V> toValue) {
     return from(elements.stream(), toKey, toValue);
   }
 
@@ -882,9 +882,9 @@ public static <T, K, V> BiStream<K, V> from(
    */
   @Deprecated
   public static <T, K, V> BiStream<K, V> from(
-      Stream<T> stream,
-      Function<? super T, ? extends K> toKey,
-      Function<? super T, ? extends V> toValue) {
+          Stream<T> stream,
+          Function<? super T, ? extends K> toKey,
+          Function<? super T, ? extends V> toValue) {
     return new GenericEntryStream<>(stream, toKey, toValue);
   }
 
@@ -894,7 +894,7 @@ public static <T, K, V> BiStream<K, V> from(
    * @since 5.1
    */
   public static <K, V> BiStream<K, V> from(
-      Stream<? extends Both<? extends K, ? extends V>> pairs) {
+          Stream<? extends Both<? extends K, ? extends V>> pairs) {
     return from(pairs, BiStream::left, BiStream::right);
   }
 
@@ -946,25 +946,25 @@ public static <K, V> BiStream<K, V> from(
    * @since 5.5
    */
   public static <I, O> BiStream<I, O> repeat(
-      Function<? super I, ? extends O> work,
-      I initial,
-      BiFunction<? super I, ? super O, ? extends Optional<? extends I>> increment) {
+          Function<? super I, ? extends O> work,
+          I initial,
+          BiFunction<? super I, ? super O, ? extends Optional<? extends I>> increment) {
     requireNonNull(work);
     requireNonNull(increment);
     return fromEntries(
-        MoreStreams.whileNotNull(
-            new Supplier<Map.Entry<I, O>>() {
-              I nextInput = requireNonNull(initial);
-              @Override public Map.Entry<I, O> get() {
-                I in = nextInput;
-                if (in == null) {
-                  return null;
-                }
-                O out = work.apply(in);
-                nextInput = increment.apply(in, out).orElse(null);
-                return kv(in, out);
-              }
-            }));
+            MoreStreams.whileNotNull(
+                    new Supplier<Map.Entry<I, O>>() {
+                      I nextInput = requireNonNull(initial);
+                      @Override public Map.Entry<I, O> get() {
+                        I in = nextInput;
+                        if (in == null) {
+                          return null;
+                        }
+                        O out = work.apply(in);
+                        nextInput = increment.apply(in, out).orElse(null);
+                        return kv(in, out);
+                      }
+                    }));
   }
 
   /**
@@ -987,21 +987,21 @@ public interface Partitioner<A, B> {
 
   /** @since 7.1 */
   public static <K, V, E extends Map.Entry<? extends K, ? extends V>> BiStream<K, V> fromEntries(
-      Stream<E> entryStream) {
+          Stream<E> entryStream) {
     return new GenericEntryStream<E, K, V>(entryStream, Map.Entry::getKey, Map.Entry::getValue) {
       @Override public <K2, V2> BiStream<K2, V2> map(
-          BiFunction<? super K, ? super V, ? extends K2> keyMapper,
-          BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
+              BiFunction<? super K, ? super V, ? extends K2> keyMapper,
+              BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
         return from(entryStream, forEntry(keyMapper), forEntry(valueMapper));
       }
 
       @Override public <K2> BiStream<K2, V> mapKeys(
-          BiFunction<? super K, ? super V, ? extends K2> keyMapper) {
+              BiFunction<? super K, ? super V, ? extends K2> keyMapper) {
         return from(entryStream, forEntry(keyMapper), Map.Entry::getValue);
       }
 
       @Override public <V2> BiStream<K, V2> mapValues(
-          BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
+              BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
         return from(entryStream, Map.Entry::getKey, forEntry(valueMapper));
       }
 
@@ -1036,7 +1036,7 @@ public interface Partitioner<A, B> {
    * @since 4.7
    */
   public final <T> Stream<T> mapToObjIfPresent(
-      BiFunction<? super K, ? super V, ? extends Optional<? extends T>> mapper) {
+          BiFunction<? super K, ? super V, ? extends Optional<? extends T>> mapper) {
     return mapToObj(mapper).<T>map(BiStream::orElseNull).filter(Objects::nonNull);
   }
 
@@ -1045,8 +1045,8 @@ public final <T> Stream<T> mapToObjIfPresent(
    * valueMapper} to the pairs in this {@code BiStream}.
    */
   public <K2, V2> BiStream<K2, V2> map(
-      BiFunction<? super K, ? super V, ? extends K2> keyMapper,
-      BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
+          BiFunction<? super K, ? super V, ? extends K2> keyMapper,
+          BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
     requireNonNull(keyMapper);
     requireNonNull(valueMapper);
     return fromEntries(mapToObj((k, v) -> kv(keyMapper.apply(k, v), valueMapper.apply(k, v))));
@@ -1073,7 +1073,7 @@ public <K2, V2> BiStream<K2, V2> map(
    * @since 5.2
    */
   public final <K2, V2> BiStream<K2, V2> map(
-      BiFunction<? super K, ? super V, ? extends Both<? extends K2, ? extends V2>> mapper) {
+          BiFunction<? super K, ? super V, ? extends Both<? extends K2, ? extends V2>> mapper) {
     return from(mapToObj(mapper));
   }
 
@@ -1084,11 +1084,11 @@ public final <K2, V2> BiStream<K2, V2> map(
    * @since 5.0
    */
   public final <K2, V2> BiStream<K2, V2> mapIfPresent(
-      BiFunction<? super K, ? super V, ? extends BiOptional<? extends K2, ? extends V2>> mapper) {
+          BiFunction<? super K, ? super V, ? extends BiOptional<? extends K2, ? extends V2>> mapper) {
     return fromEntries(
-        mapToObj(mapper)
-            .filter(BiOptional::isPresent)
-            .map(optional -> optional.map(BiStream::kv).get()));
+            mapToObj(mapper)
+                    .filter(BiOptional::isPresent)
+                    .map(optional -> optional.map(BiStream::kv).get()));
   }
 
   /**
@@ -1122,7 +1122,7 @@ public <K2> BiStream<K2, V> mapKeys(BiFunction<? super K, ? super V, ? extends K
 
   /** Maps each value to another value of type {@code V2}. */
   public <V2> BiStream<K, V2> mapValues(
-      BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
+          BiFunction<? super K, ? super V, ? extends V2> valueMapper) {
     return map((k, v) -> k, valueMapper);
   }
 
@@ -1135,7 +1135,7 @@ public <V2> BiStream<K, V2> mapValues(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <T> Stream<T> flatMapToObj(
-      BiFunction<? super K, ? super V, ? extends Stream<? extends T>> mapper) {
+          BiFunction<? super K, ? super V, ? extends Stream<? extends T>> mapper) {
     return mapToObj(mapper).flatMap(identity());
   }
 
@@ -1145,7 +1145,7 @@ public final <T> Stream<T> flatMapToObj(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final DoubleStream flatMapToDouble(
-      BiFunction<? super K, ? super V, ? extends DoubleStream> mapper) {
+          BiFunction<? super K, ? super V, ? extends DoubleStream> mapper) {
     return mapToObj(mapper).flatMapToDouble(identity());
   }
 
@@ -1155,7 +1155,7 @@ public final DoubleStream flatMapToDouble(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final IntStream flatMapToInt(
-      BiFunction<? super K, ? super V, ? extends IntStream> mapper) {
+          BiFunction<? super K, ? super V, ? extends IntStream> mapper) {
     return mapToObj(mapper).flatMapToInt(identity());
   }
 
@@ -1165,7 +1165,7 @@ public final IntStream flatMapToInt(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final LongStream flatMapToLong(
-      BiFunction<? super K, ? super V, ? extends LongStream> mapper) {
+          BiFunction<? super K, ? super V, ? extends LongStream> mapper) {
     return mapToObj(mapper).flatMapToLong(identity());
   }
 
@@ -1180,7 +1180,7 @@ public final LongStream flatMapToLong(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <K2, V2> BiStream<K2, V2> flatMap(
-      BiFunction<? super K, ? super V, ? extends BiStream<? extends K2, ? extends V2>> mapper) {
+          BiFunction<? super K, ? super V, ? extends BiStream<? extends K2, ? extends V2>> mapper) {
     return fromEntries(mapToObj(mapper).filter(Objects::nonNull).flatMap(BiStream::mapToEntry));
   }
 
@@ -1190,11 +1190,11 @@ public final <K2, V2> BiStream<K2, V2> flatMap(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <K2> BiStream<K2, V> flatMapKeys(
-      BiFunction<? super K, ? super V, ? extends Stream<? extends K2>> keyMapper) {
+          BiFunction<? super K, ? super V, ? extends Stream<? extends K2>> keyMapper) {
     requireNonNull(keyMapper);
     return fromEntries(
-        this.<Map.Entry<K2, V>>flatMapToObj( // j2cl compiler needs help with type inference
-            (k, v) -> nullToEmpty(keyMapper.apply(k, v)).map(k2 -> kv(k2, v))));
+            this.<Map.Entry<K2, V>>flatMapToObj( // j2cl compiler needs help with type inference
+                    (k, v) -> nullToEmpty(keyMapper.apply(k, v)).map(k2 -> kv(k2, v))));
   }
 
   /**
@@ -1203,7 +1203,7 @@ public final <K2> BiStream<K2, V> flatMapKeys(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <K2> BiStream<K2, V> flatMapKeys(
-      Function<? super K, ? extends Stream<? extends K2>> keyMapper) {
+          Function<? super K, ? extends Stream<? extends K2>> keyMapper) {
     requireNonNull(keyMapper);
     return flatMapKeys((k, v) -> keyMapper.apply(k));
   }
@@ -1272,7 +1272,7 @@ public final <K2> BiStream<K2, V> mapKeysIfPresent(Map<? super K, ? extends K2>
    * @since 4.7
    */
   public final <K2> BiStream<K2, V> mapKeysIfPresent(
-      Function<? super K, ? extends Optional<? extends K2>> keyMapper) {
+          Function<? super K, ? extends Optional<? extends K2>> keyMapper) {
     return mapKeys(keyMapper).<K2>mapKeys(BiStream::orElseNull).filterKeys(Objects::nonNull);
   }
 
@@ -1284,7 +1284,7 @@ public final <K2> BiStream<K2, V> mapKeysIfPresent(
    * @since 4.7
    */
   public final <K2> BiStream<K2, V> mapKeysIfPresent(
-      BiFunction<? super K, ? super V, ? extends Optional<? extends K2>> keyMapper) {
+          BiFunction<? super K, ? super V, ? extends Optional<? extends K2>> keyMapper) {
     return mapKeys(keyMapper).<K2>mapKeys(BiStream::orElseNull).filterKeys(Objects::nonNull);
   }
 
@@ -1294,11 +1294,11 @@ public final <K2> BiStream<K2, V> mapKeysIfPresent(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <V2> BiStream<K, V2> flatMapValues(
-      BiFunction<? super K, ? super V, ? extends Stream<? extends V2>> valueMapper) {
+          BiFunction<? super K, ? super V, ? extends Stream<? extends V2>> valueMapper) {
     requireNonNull(valueMapper);
     return fromEntries(
-        this.<Map.Entry<K, V2>>flatMapToObj( // j2cl compiler needs help with type inference
-            (k, v) -> nullToEmpty(valueMapper.apply(k, v)).map(v2 -> kv(k, v2))));
+            this.<Map.Entry<K, V2>>flatMapToObj( // j2cl compiler needs help with type inference
+                    (k, v) -> nullToEmpty(valueMapper.apply(k, v)).map(v2 -> kv(k, v2))));
   }
 
   /**
@@ -1307,7 +1307,7 @@ public final <V2> BiStream<K, V2> flatMapValues(
    * <p>If a mapped stream is null, an empty stream is used instead.
    */
   public final <V2> BiStream<K, V2> flatMapValues(
-      Function<? super V, ? extends Stream<? extends V2>> valueMapper) {
+          Function<? super V, ? extends Stream<? extends V2>> valueMapper) {
     requireNonNull(valueMapper);
     return flatMapValues((k, v) -> valueMapper.apply(v));
   }
@@ -1374,7 +1374,7 @@ public final <V2> BiStream<K, V2> mapValuesIfPresent(Map<? super V, ? extends V2
    * @since 4.7
    */
   public final <V2> BiStream<K, V2> mapValuesIfPresent(
-      Function<? super V, ? extends Optional<? extends V2>> valueMapper) {
+          Function<? super V, ? extends Optional<? extends V2>> valueMapper) {
     return mapValues(valueMapper).<V2>mapValues(BiStream::orElseNull).filterValues(Objects::nonNull);
   }
 
@@ -1386,7 +1386,7 @@ public final <V2> BiStream<K, V2> mapValuesIfPresent(
    * @since 4.7
    */
   public final <V2> BiStream<K, V2> mapValuesIfPresent(
-      BiFunction<? super K, ? super V, ? extends Optional<? extends V2>> valueMapper) {
+          BiFunction<? super K, ? super V, ? extends Optional<? extends V2>> valueMapper) {
     return mapValues(valueMapper).<V2>mapValues(BiStream::orElseNull).filterValues(Objects::nonNull);
   }
 
@@ -1403,13 +1403,24 @@ public final BiStream<K, V> peek(BiConsumer<? super K, ? super V> action) {
    * Filter this stream to only pairs matching {@code predicate}.
    *
    * <p>Note that if you are passing in a lambda with the {@code !} operator, consider using {@link
-   * #skipIf} instead that might even allow you to use method reference.
+   * #skipIf(BiPredicate)} instead that might even allow you to use method reference.
    */
   public final BiStream<K, V> filter(BiPredicate<? super K, ? super V> predicate) {
     requireNonNull(predicate);
     return fromEntries(mapToEntry().filter(kv -> predicate.test(kv.getKey(), kv.getValue())));
   }
 
+  /**
+   * Filter this stream to only entries matching {@code predicate}.
+   *
+   * <p>Note that if you are passing in a lambda with the {@code !} operator, consider using {@link
+   * #skipIf(Predicate)} instead that might even allow you to use method reference.
+   */
+  public final BiStream<K, V> filter(Predicate<? super Map.Entry<? extends K, ? extends V>> predicate) {
+    requireNonNull(predicate);
+    return fromEntries(mapToEntry().filter(predicate));
+  }
+
   /**
    * Filter this stream to only pairs whose key matches {@code predicate}.
    *
@@ -1450,6 +1461,24 @@ public final BiStream<K, V> skipIf(BiPredicate<? super K, ? super V> predicate)
     return filter(predicate.negate());
   }
 
+  /**
+   * Filter this stream to exclude entries matching {@code predicate}.
+   *
+   * <p>Useful especially when it allows you to use method reference. For example:
+   *
+   * <pre>{@code
+   * tasks.stream()
+   *      .collect(crossJoining(Arrays.stream(MachineType.values()))
+   *      .skipIf(Worker::blacklistsMachine)
+   *      ...
+   * }</pre>
+   *
+   * @since 5.1
+   */
+  public final BiStream<K, V> skipIf(Predicate<? super Map.Entry<? extends K, ? extends V>> predicate) {
+    return filter(predicate.negate());
+  }
+
   /**
    * Filter this stream to exclude pairs whose key matches {@code predicate}.
    *
@@ -1604,7 +1633,7 @@ public final BiStream<K, V> sortedByValues(Comparator<? super V> comparator) {
    * @since 6.6
    */
   public final <T> BiStream<K, V> sortedBy(
-      BiFunction<? super K, ? super V, T> sortKeyFunction, Comparator<? super T> comparator) {
+          BiFunction<? super K, ? super V, T> sortKeyFunction, Comparator<? super T> comparator) {
     requireNonNull(sortKeyFunction);
     return sorted(Comparator.comparing((Map.Entry<K, V> e) -> sortKeyFunction.apply(e.getKey(), e.getValue()), comparator));
   }
@@ -1618,8 +1647,8 @@ public final <T> BiStream<K, V> sortedBy(
    */
   public final BiStream<K, V> sorted(Comparator<? super K> byKey, Comparator<? super V> byValue) {
     return sorted(
-        Comparator.<Map.Entry<? extends K, ? extends V>, K>comparing(Map.Entry::getKey, byKey)
-            .thenComparing(Map.Entry::getValue, byValue));
+            Comparator.<Map.Entry<? extends K, ? extends V>, K>comparing(Map.Entry::getKey, byKey)
+                    .thenComparing(Map.Entry::getValue, byValue));
   }
 
   /**
@@ -1698,7 +1727,7 @@ public final Map<K, V> toMap() {
    * @since 5.6
    */
   public final <T, R> R collect(
-      BiCollector<? super K, ? super V, T> collector, Function<? super T, R> finisher) {
+          BiCollector<? super K, ? super V, T> collector, Function<? super T, R> finisher) {
     return finisher.apply(collect(collector));
   }
 
@@ -1726,7 +1755,7 @@ public final <T, R> R collect(
    * @since 5.0
    */
   public abstract <A> A collect(
-      A container, BiAccumulator<? super A, ? super K, ? super V> accumulator);
+          A container, BiAccumulator<? super A, ? super K, ? super V> accumulator);
 
   /**
    * Closes any resources associated with this stream, typically used in a try-with-resources
@@ -1768,12 +1797,12 @@ public abstract <A> A collect(
    * @since 5.4
    */
   public final <G, A, R> BiStream<G, R> groupConsecutiveBy(
-      Function<? super K, ? extends G> classifier,
-      Collector<? super V, A, ? extends R> groupCollector) {
+          Function<? super K, ? extends G> classifier,
+          Collector<? super V, A, ? extends R> groupCollector) {
     return this
-        .<G>mapKeys(classifier)
-        .groupConsecutiveByKeys(groupCollector.supplier(), groupCollector.accumulator())
-        .mapValues(groupCollector.finisher());
+            .<G>mapKeys(classifier)
+            .groupConsecutiveByKeys(groupCollector.supplier(), groupCollector.accumulator())
+            .mapValues(groupCollector.finisher());
   }
 
   /**
@@ -1807,7 +1836,7 @@ public final <G, A, R> BiStream<G, R> groupConsecutiveBy(
    * @since 5.4
    */
   public final <G> BiStream<G, V> groupConsecutiveBy(
-      Function<? super K, ? extends G> classifier, BinaryOperator<V> groupReducer) {
+          Function<? super K, ? extends G> classifier, BinaryOperator<V> groupReducer) {
     return groupConsecutiveBy(classifier, reducingGroupMembers(groupReducer));
   }
 
@@ -1853,11 +1882,11 @@ public final <G> BiStream<G, V> groupConsecutiveBy(
    * @since 5.5
    */
   public final <G, A, R> BiStream<G, R> groupConsecutiveBy(
-      BiFunction<? super K, ? super V, ? extends G> classifier,
-      BiCollector<? super K, ? super V, R> groupCollector) {
+          BiFunction<? super K, ? super V, ? extends G> classifier,
+          BiCollector<? super K, ? super V, R> groupCollector) {
     return this
-        .<G, Map.Entry<K, V>>map(classifier, BiStream::kv)
-        .groupConsecutiveByKeys(groupCollector.collectorOf(Map.Entry::getKey, Map.Entry::getValue));
+            .<G, Map.Entry<K, V>>map(classifier, BiStream::kv)
+            .groupConsecutiveByKeys(groupCollector.collectorOf(Map.Entry::getKey, Map.Entry::getValue));
   }
 
   /**
@@ -1891,12 +1920,12 @@ public final <G, A, R> BiStream<G, R> groupConsecutiveBy(
    * @since 5.6
    */
   public final <R> Stream<R> groupConsecutiveIf(
-      Partitioner<? super K, ? super V> sameGroup, BiCollector<? super K, ? super V, R> groupCollector) {
+          Partitioner<? super K, ? super V> sameGroup, BiCollector<? super K, ? super V, R> groupCollector) {
     requireNonNull(sameGroup);
     return biStream(mapToEntry())
-        .groupConsecutiveIf(
-            (p1, p2) -> sameGroup.belong(p1.getKey(), p1.getValue(), p2.getKey(), p2.getValue()),
-            groupCollector.collectorOf(Map.Entry::getKey, Map.Entry::getValue));
+            .groupConsecutiveIf(
+                    (p1, p2) -> sameGroup.belong(p1.getKey(), p1.getValue(), p2.getKey(), p2.getValue()),
+                    groupCollector.collectorOf(Map.Entry::getKey, Map.Entry::getValue));
   }
 
   /**
@@ -1927,13 +1956,13 @@ public final <R> Stream<R> groupConsecutiveIf(
    * @since 5.4
    */
   public final <A, R> Stream<R> groupConsecutiveIf(
-      BiPredicate<? super K, ? super K> sameGroup, Collector<? super V, A, R> groupCollector) {
+          BiPredicate<? super K, ? super K> sameGroup, Collector<? super V, A, R> groupCollector) {
     BiConsumer<A, ? super V> groupAccumulator = groupCollector.accumulator();
     return groupConsecutiveIf(
-        sameGroup,
-        groupCollector.supplier(),
-        (a, k, v) -> groupAccumulator.accept(a, v),
-        groupCollector.finisher());
+            sameGroup,
+            groupCollector.supplier(),
+            (a, k, v) -> groupAccumulator.accept(a, v),
+            groupCollector.finisher());
   }
 
   /**
@@ -1955,37 +1984,37 @@ public final <A, R> Stream<R> groupConsecutiveIf(
    * @since 5.4
    */
   public final Stream<V> groupConsecutiveIf(
-      BiPredicate<? super K, ? super K> sameGroup, BinaryOperator<V> groupReducer) {
+          BiPredicate<? super K, ? super K> sameGroup, BinaryOperator<V> groupReducer) {
     return groupConsecutiveIf(sameGroup, reducingGroupMembers(groupReducer));
   }
 
   private <A, R> BiStream<K, R> groupConsecutiveByKeys(
-      Collector<? super V, A, R> groupCollector) {
+          Collector<? super V, A, R> groupCollector) {
     return groupConsecutiveByKeys(groupCollector.supplier(), groupCollector.accumulator())
-        .mapValues(groupCollector.finisher());
+            .mapValues(groupCollector.finisher());
   }
 
   private <A> BiStream<K, A> groupConsecutiveByKeys(
-      Supplier<A> newGroup, BiConsumer<? super A, ? super V> groupAccumulator) {
+          Supplier<A> newGroup, BiConsumer<? super A, ? super V> groupAccumulator) {
     requireNonNull(newGroup);
     requireNonNull(groupAccumulator);
     Temp<K> currentGroup = new Temp<>();
     return fromEntries(
-        groupConsecutiveIf(
-            Objects::equals,
-            newGroup,
-            (a, k, v) -> {
-              currentGroup.value = k;
-              groupAccumulator.accept(a, v);
-            },
-            a -> kv(currentGroup.value, a)));
+            groupConsecutiveIf(
+                    Objects::equals,
+                    newGroup,
+                    (a, k, v) -> {
+                      currentGroup.value = k;
+                      groupAccumulator.accept(a, v);
+                    },
+                    a -> kv(currentGroup.value, a)));
   }
 
   private <A, R> Stream<R> groupConsecutiveIf(
-      BiPredicate<? super K, ? super K> sameGroup,
-      Supplier<? extends A> newRun,
-      BiAccumulator<? super A, ? super K, ? super V> groupAccumulator,
-      Function<? super A, ? extends R> groupFinisher) {
+          BiPredicate<? super K, ? super K> sameGroup,
+          Supplier<? extends A> newRun,
+          BiAccumulator<? super A, ? super K, ? super V> groupAccumulator,
+          Function<? super A, ? extends R> groupFinisher) {
     requireNonNull(sameGroup);
     requireNonNull(newRun);
     requireNonNull(groupAccumulator);
@@ -2076,7 +2105,7 @@ private static <T> T orElseNull(Optional<T> optional) {
    * instances by either invoking {@code toKey} and {@code toValue} then using the results directly,
    * or composing the functions to be invoked later.
    *
-   * <p>Doing so isn't always feasible. For example {@link #filter} and {@link #peek} both need to
+   * <p>Doing so isn't always feasible. For example {@link #filter(BiPredicate)} and {@link #peek} both need to
    * evaluate the entry by invoking {@code toKey} and {@code toValue} and the return values need to
    * be stored to avoid invoking the functions again. For these cases, the stream will be
    * degeneralized into {@code Stream<Map.Entry<K, V>>} so as to guarantee the "at-most-once"
@@ -2088,9 +2117,9 @@ private static class GenericEntryStream<E, K, V> extends BiStream<K, V> {
     private final Function<? super E, ? extends V> toValue;
 
     GenericEntryStream(
-        Stream<E> underlying,
-        Function<? super E, ? extends K> toKey,
-        Function<? super E, ? extends V> toValue) {
+            Stream<E> underlying,
+            Function<? super E, ? extends K> toKey,
+            Function<? super E, ? extends V> toValue) {
       this.underlying = requireNonNull(underlying);
       this.toKey = requireNonNull(toKey);
       this.toValue = requireNonNull(toValue);
@@ -2162,8 +2191,8 @@ private static class GenericEntryStream<E, K, V> extends BiStream<K, V> {
     @Override public final <A> A collect(A container, BiAccumulator<? super A, ? super K, ? super V> accumulator) {
       requireNonNull(accumulator);
       underlying
-          .sequential()
-          .forEachOrdered(e -> accumulator.accumulate(container, toKey.apply(e), toValue.apply(e)));
+              .sequential()
+              .forEachOrdered(e -> accumulator.accumulate(container, toKey.apply(e), toValue.apply(e)));
       return container;
     }
 
@@ -2202,29 +2231,29 @@ private static final class ZippingStream<K, V> extends BiStream<K, V> {
     @Override public <T> Stream<T> mapToObj(BiFunction<? super K, ? super V, ? extends T> mapper) {
       requireNonNull(mapper);
       return stream(() -> new Spliteration().<T>ofObj(mapper), ORDERED, NOT_PARALLEL)
-          .onClose(left::close)
-          .onClose(right::close);
+              .onClose(left::close)
+              .onClose(right::close);
     }
 
     @Override public DoubleStream mapToDouble(ToDoubleBiFunction<? super K, ? super V> mapper) {
       requireNonNull(mapper);
       return doubleStream(() -> new Spliteration().ofDouble(mapper), ORDERED, NOT_PARALLEL)
-          .onClose(left::close)
-          .onClose(right::close);
+              .onClose(left::close)
+              .onClose(right::close);
     }
 
     @Override public IntStream mapToInt(ToIntBiFunction<? super K, ? super V> mapper) {
       requireNonNull(mapper);
       return intStream(() -> new Spliteration().ofInt(mapper), ORDERED, NOT_PARALLEL)
-          .onClose(left::close)
-          .onClose(right::close);
+              .onClose(left::close)
+              .onClose(right::close);
     }
 
     @Override public LongStream mapToLong(ToLongBiFunction<? super K, ? super V> mapper) {
       requireNonNull(mapper);
       return longStream(() -> new Spliteration().ofLong(mapper), ORDERED, NOT_PARALLEL)
-          .onClose(left::close)
-          .onClose(right::close);
+              .onClose(left::close)
+              .onClose(right::close);
     }
 
     @Override public <K2> BiStream<K2, V> mapKeys(Function<? super K, ? extends K2> keyMapper) {
@@ -2333,7 +2362,7 @@ Spliterator.OfInt ofInt(ToIntBiFunction<? super K, ? super V> mapper) {
         return new AbstractIntSpliterator(estimateSize(), ORDERED) {
           @Override public boolean tryAdvance(IntConsumer consumer) {
             return advance()
-                && emit(mapper.applyAsInt(currentLeft.value, currentRight.value), consumer);
+                    && emit(mapper.applyAsInt(currentLeft.value, currentRight.value), consumer);
           }
         };
       }
@@ -2342,7 +2371,7 @@ Spliterator.OfLong ofLong(ToLongBiFunction<? super K, ? super V> mapper) {
         return new AbstractLongSpliterator(estimateSize(), ORDERED) {
           @Override public boolean tryAdvance(LongConsumer consumer) {
             return advance()
-                && emit(mapper.applyAsLong(currentLeft.value, currentRight.value), consumer);
+                    && emit(mapper.applyAsLong(currentLeft.value, currentRight.value), consumer);
           }
         };
       }
@@ -2351,7 +2380,7 @@ Spliterator.OfDouble ofDouble(ToDoubleBiFunction<? super K, ? super V> mapper) {
         return new AbstractDoubleSpliterator(estimateSize(), ORDERED) {
           @Override public boolean tryAdvance(DoubleConsumer consumer) {
             return advance()
-                && emit(mapper.applyAsDouble(currentLeft.value, currentRight.value), consumer);
+                    && emit(mapper.applyAsDouble(currentLeft.value, currentRight.value), consumer);
           }
         };
       }
@@ -2417,10 +2446,10 @@ static <T> T right(Both<?, T> both) {
   }
 
   private static <K, V> BiOptional<K, V> fromOptionalEntry(
-      Optional<? extends Map.Entry<? extends K, ? extends V>> optional) {
+          Optional<? extends Map.Entry<? extends K, ? extends V>> optional) {
     return optional.isPresent()
-        ? BiOptional.of(optional.get().getKey(), optional.get().getValue())
-        : BiOptional.empty();
+            ? BiOptional.of(optional.get().getKey(), optional.get().getValue())
+            : BiOptional.empty();
   }
 
   private BiStream() {}
diff --git a/mug/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java b/mug/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java
index a028fdf1a5..fb87e2eefd 100644
--- a/mug/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java
+++ b/mug/src/test/java/com/google/mu/util/stream/BiStreamFunctionEvaluationTest.java
@@ -48,23 +48,31 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
 
   @Test public void testKeys_toKeyFunctionCalledOnce() {
     assertThat(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 2).keys())
-        .containsExactly("1", "2", "3")
-        .inOrder();
+            .containsExactly("1", "2", "3")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testValues_toValueFunctionCalledOnce() {
     assertThat(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 2).values())
-        .containsExactly(2, 4, 6)
-        .inOrder();
+            .containsExactly(2, 4, 6)
+            .inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testFilter_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).filter((k, v) -> v > 10))
-        .containsExactly("2", 20, "3", 30)
-        .inOrder();
+            .containsExactly("2", 20, "3", 30)
+            .inOrder();
+    assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
+    assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
+  }
+
+  @Test public void testFilterEntries_bothFunctionsCalledOnce() {
+    assertKeyValues(
+            biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).filter(entry -> entry.getKey().isEmpty() && entry.getValue() < 10))
+            .isEmpty();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -72,7 +80,7 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFilterKeys_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).filterKeys(String::isEmpty))
-        .isEmpty();
+            .isEmpty();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -80,23 +88,23 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFilterValues_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).filterValues(v -> v < 0))
-        .isEmpty();
+            .isEmpty();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testPeek_bothFunctionsCalledOnce() {
     assertKeyValues(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).peek((k, v) -> {}))
-        .containsExactly("1", 10, "2", 20, "3", 30)
-        .inOrder();
+            .containsExactly("1", 10, "2", 20, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testDistinct_bothFunctionsCalledOnce() {
     assertKeyValues(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).distinct())
-        .containsExactly("1", 10, "2", 20, "3", 30)
-        .inOrder();
+            .containsExactly("1", 10, "2", 20, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -104,9 +112,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testSortedByKeys_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .sortedByKeys(Comparator.naturalOrder()))
-        .containsExactly("1", 10, "2", 20, "3", 30)
-        .inOrder();
+                    .sortedByKeys(Comparator.naturalOrder()))
+            .containsExactly("1", 10, "2", 20, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -114,9 +122,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testSortedByValues_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .sortedByValues(Comparator.naturalOrder()))
-        .containsExactly("1", 10, "2", 20, "3", 30)
-        .inOrder();
+                    .sortedByValues(Comparator.naturalOrder()))
+            .containsExactly("1", 10, "2", 20, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -124,29 +132,29 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapKeys_toKeyFunctionCalledOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapKeys(k -> k + "." + k)
-                .keys())
-        .containsExactly("1.1", "2.2", "3.3")
-        .inOrder();
+                    .mapKeys(k -> k + "." + k)
+                    .keys())
+            .containsExactly("1.1", "2.2", "3.3")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testMapValues_toValueFunctionCalledOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapValues(v -> v + 1)
-                .values())
-        .containsExactly(11, 21, 31)
-        .inOrder();
+                    .mapValues(v -> v + 1)
+                    .values())
+            .containsExactly(11, 21, 31)
+            .inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testMapKeysWithBiFunction_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapKeys((k, v) -> Joiner.on('.').join(k, v)))
-        .containsExactly("1.10", 10, "2.20", 20, "3.30", 30)
-        .inOrder();
+                    .mapKeys((k, v) -> Joiner.on('.').join(k, v)))
+            .containsExactly("1.10", 10, "2.20", 20, "3.30", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -154,9 +162,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapValuesWithBiFunction_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapValues((k, v) -> Joiner.on('.').join(k, v)))
-        .containsExactly("1", "1.10", "2", "2.20", "3", "3.30")
-        .inOrder();
+                    .mapValues((k, v) -> Joiner.on('.').join(k, v)))
+            .containsExactly("1", "1.10", "2", "2.20", "3", "3.30")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -164,9 +172,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapWithBiFunctions_bothFunctionsCalledOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .map(Joiner.on('.')::join, (k, v) -> v + "<-" + k))
-        .containsExactly("1.10", "10<-1", "2.20", "20<-2", "3.30", "30<-3")
-        .inOrder();
+                    .map(Joiner.on('.')::join, (k, v) -> v + "<-" + k))
+            .containsExactly("1.10", "10<-1", "2.20", "20<-2", "3.30", "30<-3")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -174,17 +182,17 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapToObj_bothFunctionsCalledOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapToObj(Joiner.on("->")::join))
-        .containsExactly("1->10", "2->20", "3->30")
-        .inOrder();
+                    .mapToObj(Joiner.on("->")::join))
+            .containsExactly("1->10", "2->20", "3->30")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testMapToInt_bothFunctionsCalledOnce() {
     assertThat(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).mapToInt((k, v) -> v))
-        .containsExactly(10, 20, 30)
-        .inOrder();
+            .containsExactly(10, 20, 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -192,9 +200,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapToLong_bothFunctionsCalledOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapToLong((k, v) -> Long.valueOf(k)))
-        .containsExactly(1L, 2L, 3L)
-        .inOrder();
+                    .mapToLong((k, v) -> Long.valueOf(k)))
+            .containsExactly(1L, 2L, 3L)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -202,10 +210,10 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testMapToDouble_bothFunctionsCalledOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .mapToDouble((k, v) -> Double.valueOf(k))
-                .boxed())
-        .containsExactly(1D, 2D, 3D)
-        .inOrder();
+                    .mapToDouble((k, v) -> Double.valueOf(k))
+                    .boxed())
+            .containsExactly(1D, 2D, 3D)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -213,9 +221,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapKeys_bothFunctionsCalledOnlyOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapKeys(k -> Stream.of(k, k)))
-        .containsExactly("1", 10, "1", 10, "2", 20, "2", 20, "3", 30, "3", 30)
-        .inOrder();
+                    .flatMapKeys(k -> Stream.of(k, k)))
+            .containsExactly("1", 10, "1", 10, "2", 20, "2", 20, "3", 30, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -223,9 +231,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapKeysWithBiFunction_bothFunctionsCalledOnlyOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapKeys((k, v) -> Stream.of(k, v)))
-        .containsExactly("1", 10, 10, 10, "2", 20, 20, 20, "3", 30, 30, 30)
-        .inOrder();
+                    .flatMapKeys((k, v) -> Stream.of(k, v)))
+            .containsExactly("1", 10, 10, 10, "2", 20, 20, 20, "3", 30, 30, 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -233,9 +241,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapValues_bothFunctionsCalledOnlyOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapValues(v -> Stream.of(v, v)))
-        .containsExactly("1", 10, "1", 10, "2", 20, "2", 20, "3", 30, "3", 30)
-        .inOrder();
+                    .flatMapValues(v -> Stream.of(v, v)))
+            .containsExactly("1", 10, "1", 10, "2", 20, "2", 20, "3", 30, "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -243,9 +251,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapValuesWithBiFunction_bothFunctionsCalledOnlyOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapValues((k, v) -> Stream.of(k, v)))
-        .containsExactly("1", "1", "1", 10, "2", "2", "2", 20, "3", "3", "3", 30)
-        .inOrder();
+                    .flatMapValues((k, v) -> Stream.of(k, v)))
+            .containsExactly("1", "1", "1", 10, "2", "2", "2", 20, "3", "3", "3", 30)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -253,9 +261,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMap_bothFunctionsCalledOnlyOnce() {
     assertKeyValues(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMap((k, v) -> BiStream.of(k, v, v, k)))
-        .containsExactly("1", 10, 10, "1", "2", 20, 20, "2", "3", 30, 30, "3")
-        .inOrder();
+                    .flatMap((k, v) -> BiStream.of(k, v, v, k)))
+            .containsExactly("1", 10, 10, "1", "2", 20, 20, "2", "3", 30, 30, "3")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -263,9 +271,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapToObj_bothFunctionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapToObj((k, v) -> Stream.of(v, k)))
-        .containsExactly(10, "1", 20, "2", 30, "3")
-        .inOrder();
+                    .flatMapToObj((k, v) -> Stream.of(v, k)))
+            .containsExactly(10, "1", 20, "2", 30, "3")
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -273,9 +281,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapToInt_bothFunctionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapToInt((k, v) -> IntStream.of(v, Integer.parseInt(k))))
-        .containsExactly(10, 1, 20, 2, 30, 3)
-        .inOrder();
+                    .flatMapToInt((k, v) -> IntStream.of(v, Integer.parseInt(k))))
+            .containsExactly(10, 1, 20, 2, 30, 3)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -283,9 +291,9 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapToLong_bothFunctionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapToLong((k, v) -> LongStream.of(Long.valueOf(v), Long.parseLong(k))))
-        .containsExactly(10L, 1L, 20L, 2L, 30L, 3L)
-        .inOrder();
+                    .flatMapToLong((k, v) -> LongStream.of(Long.valueOf(v), Long.parseLong(k))))
+            .containsExactly(10L, 1L, 20L, 2L, 30L, 3L)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -293,36 +301,36 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testFlatMapToDouble_bothFunctionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10)
-                .flatMapToDouble((k, v) -> DoubleStream.of(v, Double.parseDouble(k)))
-                .boxed())
-        .containsExactly(10D, 1D, 20D, 2D, 30D, 3D)
-        .inOrder();
+                    .flatMapToDouble((k, v) -> DoubleStream.of(v, Double.parseDouble(k)))
+                    .boxed())
+            .containsExactly(10D, 1D, 20D, 2D, 30D, 3D)
+            .inOrder();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testInverseThenKeys_toValueFunctionCalledOnce() {
     assertThat(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 2).inverse().keys())
-        .containsExactly(2, 4, 6);
+            .containsExactly(2, 4, 6);
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testInverseThenValues_toKeyFunctionCalledOnce() {
     assertThat(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 2).inverse().values())
-        .containsExactly("1", "2", "3");
+            .containsExactly("1", "2", "3");
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
   }
 
   @Test public void testSkip_skippedEntriesNotEvaluated() {
     assertKeyValues(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 2).skip(2))
-        .containsExactly("3", 6);
+            .containsExactly("3", 6);
     assertThat(evaluatedKeys).containsExactly(3).inOrder();
     assertThat(evaluatedValues).containsExactly(3).inOrder();
   }
 
   @Test public void testLimit_limitedEntriesNotEvaluated() {
     assertKeyValues(biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).limit(2))
-        .containsExactly("1", 10, "2", 20);
+            .containsExactly("1", 10, "2", 20);
     assertThat(evaluatedKeys).containsExactly(1, 2).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2).inOrder();
   }
@@ -330,7 +338,7 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testAnyMatch_functionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).anyMatch((k, v) -> v < 0))
-        .isFalse();
+            .isFalse();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -338,7 +346,7 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testAllMatch_functionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).allMatch((k, v) -> v > 0))
-        .isTrue();
+            .isTrue();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
@@ -346,22 +354,22 @@ public final class BiStreamFunctionEvaluationTest extends TestCase {
   @Test public void testNoneMatch_functionsCalledOnlyOnce() {
     assertThat(
             biStream(Stream.of(1, 2, 3), Object::toString, i -> i * 10).noneMatch((k, v) -> v < 0))
-        .isTrue();
+            .isTrue();
     assertThat(evaluatedKeys).containsExactly(1, 2, 3).inOrder();
     assertThat(evaluatedValues).containsExactly(1, 2, 3).inOrder();
   }
 
   private <K, V, T> BiStream<K, V> biStream(
-      Stream<T> stream,
-      Function<? super T, ? extends K> toKey,
-      Function<? super T, ? extends V> toValue) {
+          Stream<T> stream,
+          Function<? super T, ? extends K> toKey,
+          Function<? super T, ? extends V> toValue) {
     return BiStream.from(
-        stream, trackCallHistory(toKey, evaluatedKeys), trackCallHistory(toValue, evaluatedValues));
+            stream, trackCallHistory(toKey, evaluatedKeys), trackCallHistory(toValue, evaluatedValues));
   }
 
   // Poor man's mock
   private static <F, T> Function<F, T> trackCallHistory(
-      Function<? super F, ? extends T> function, List<Object> history) {
+          Function<? super F, ? extends T> function, List<Object> history) {
     return arg -> {
       history.add(arg);
       return function.apply(arg);
@@ -379,13 +387,13 @@ private static<K,V> MultimapSubject assertKeyValues(BiStream<K, V> stream) {
   }
 
   public static <T, K, V> Collector<T, ?, Multimap<K, V>> toLinkedListMultimap(
-      Function<? super T, ? extends K> toKey, Function<? super T, ? extends V> toValue) {
+          Function<? super T, ? extends K> toKey, Function<? super T, ? extends V> toValue) {
     return Collector.of(
-        LinkedListMultimap::create,
-        (m, e) -> m.put(toKey.apply(e), toValue.apply(e)),
-        (m1, m2) -> {
-          m1.putAll(m2);
-          return m1;
-        });
+            LinkedListMultimap::create,
+            (m, e) -> m.put(toKey.apply(e), toValue.apply(e)),
+            (m1, m2) -> {
+              m1.putAll(m2);
+              return m1;
+            });
   }
 }
diff --git a/mug/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java b/mug/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java
index 7897fbfed5..fea62a319c 100644
--- a/mug/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java
+++ b/mug/src/test/java/com/google/mu/util/stream/BiStreamInvariantsTest.java
@@ -78,10 +78,10 @@ public class BiStreamInvariantsTest {
   @Parameters(name = "{index}: {0}/{1}")
   public static ImmutableList<Object[]> factories() {
     return Sets.cartesianProduct(
-            ImmutableSet.copyOf(BiStreamFactory.values()), ImmutableSet.copyOf(Variant.values()))
-        .stream()
-        .map(Collection::toArray)
-        .collect(toImmutableList());
+                    ImmutableSet.copyOf(BiStreamFactory.values()), ImmutableSet.copyOf(Variant.values()))
+            .stream()
+            .map(Collection::toArray)
+            .collect(toImmutableList());
   }
 
   @Test public void empty() {
@@ -90,59 +90,59 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void nonEmpty() {
     assertKeyValues(of("one", 1))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1))
+            .inOrder();
     assertKeyValues(of("one", 1, "two", 2))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2))
+            .inOrder();
     assertKeyValues(of("one", 1, "two", 2, "three", 3))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
+            .inOrder();
   }
 
   @Test public void mapKeys() {
     assertKeyValues(of("one", 1).mapKeys((k, v) -> k + v))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one1", 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one1", 1))
+            .inOrder();
     assertKeyValues(of("one", 1).mapKeys(k -> k + k))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("oneone", 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("oneone", 1))
+            .inOrder();
     assertKeyValues(of("one", 1).mapKeys(k -> null))
-        .containsExactlyEntriesIn(keyValues(null, 1))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, 1))
+            .inOrder();
   }
 
   @Test public void mapValues() {
     assertKeyValues(of("one", 1).mapValues((k, v) -> k + v))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", "one1"))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", "one1"))
+            .inOrder();
     assertKeyValues(of("one", 1).mapValues(v -> v * 10))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 10))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 10))
+            .inOrder();
     assertKeyValues(of("one", 1).mapValues(v -> null))
-        .containsExactlyEntriesIn(keyValues("one", null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues("one", null))
+            .inOrder();
   }
 
   @Test public void distinct_byKey() {
     BiStream<Integer, ?> distinct =
-        biStream(Stream.of(1, 1, 2, 2, 3), x -> null).distinct();
+            biStream(Stream.of(1, 1, 2, 2, 3), x -> null).distinct();
     assertKeyValues(distinct).containsExactlyEntriesIn(keyValues(1, null, 2, null, 3, null));
   }
 
   @Test public void distinct_byValue() {
     BiStream<?, Integer> distinct =
-        biStream(k -> null, Stream.of(1, 1, 2, 2, 3)).distinct();
+            biStream(k -> null, Stream.of(1, 1, 2, 2, 3)).distinct();
     assertKeyValues(distinct).containsExactlyEntriesIn(keyValues(null, 1, null, 2, null, 3));
   }
 
   @Test public void flatMap() {
     assertKeyValues(of("one", 1).flatMap((k, v) -> of(k, v * 10, k, v * 11)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 10, "one", 11))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 10, "one", 11))
+            .inOrder();
     assertKeyValues(of("one", 1).flatMap((k, v) -> of(null, null)))
-        .containsExactlyEntriesIn(keyValues(null, null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, null))
+            .inOrder();
   }
 
   @Test public void flatMap_mapperReturnsNull() {
@@ -151,14 +151,14 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void flatMapKeys() {
     assertKeyValues(of("one", 1).flatMapKeys((k, v) -> Stream.of(k, v)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, 1, 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, 1, 1))
+            .inOrder();
     assertKeyValues(of("one", 1).flatMapKeys(k -> Stream.of(k, k + k)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "oneone", 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "oneone", 1))
+            .inOrder();
     assertKeyValues(of("one", 1).flatMapKeys(k -> Stream.of(null, null)))
-        .containsExactlyEntriesIn(keyValues(null, 1, null, 1))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, 1, null, 1))
+            .inOrder();
   }
 
   @Test public void flatMapKeys_mapperReturnsNull() {
@@ -167,8 +167,8 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void mapKeysIfPresent_found() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapKeysIfPresent(ImmutableMap.of("uno", "one")))
-        .containsExactly("one", 1)
-        .inOrder();
+            .containsExactly("one", 1)
+            .inOrder();
   }
 
   @Test public void mapKeysIfPresent_notFound() {
@@ -177,36 +177,36 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void mapKeysIfPresent_present() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapKeysIfPresent(k -> Optional.of("found:" + k)))
-        .containsExactly("found:uno", 1, "found:dos", 2)
-        .inOrder();
+            .containsExactly("found:uno", 1, "found:dos", 2)
+            .inOrder();
   }
 
   @Test public void mapKeysIfPresent_absent() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapKeysIfPresent(k -> Optional.empty()))
-        .isEmpty();
+            .isEmpty();
   }
 
   @Test public void mapKeysIfPresent_biFunction_present() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapKeysIfPresent((k, v) -> Optional.of(k + "->" + v)))
-        .containsExactly("uno->1", 1, "dos->2", 2)
-        .inOrder();
+            .containsExactly("uno->1", 1, "dos->2", 2)
+            .inOrder();
   }
 
   @Test public void mapKeysIfPresent_biFunction_absent() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapKeysIfPresent((k, v) -> Optional.empty()))
-        .isEmpty();
+            .isEmpty();
   }
 
   @Test public void flatMapValues() {
     assertKeyValues(of("one", 1).flatMapValues((k, v) -> Stream.of(k, v)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", "one", "one", 1))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", "one", "one", 1))
+            .inOrder();
     assertKeyValues(of("one", 1).flatMapValues(v -> Stream.of(v, v * 10)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "one", 10))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "one", 10))
+            .inOrder();
     assertKeyValues(of("one", 1).flatMapValues(v -> Stream.of(null, null)))
-        .containsExactlyEntriesIn(keyValues("one", null, "one", null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues("one", null, "one", null))
+            .inOrder();
   }
 
   @Test public void flatMapValues_mapperReturnsNull() {
@@ -215,8 +215,8 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void mapValuesIfPresent_found() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapValuesIfPresent(ImmutableMap.of(1, "one")))
-        .containsExactly("uno", "one")
-        .inOrder();
+            .containsExactly("uno", "one")
+            .inOrder();
   }
 
   @Test public void mapValuesIfPresent_notFound() {
@@ -225,73 +225,83 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void mapValuesIfPresent_present() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapValuesIfPresent(v -> Optional.of("found:" + v)))
-        .containsExactly("uno", "found:1", "dos", "found:2")
-        .inOrder();
+            .containsExactly("uno", "found:1", "dos", "found:2")
+            .inOrder();
   }
 
   @Test public void mapValuesIfPresent_absent() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapValuesIfPresent(v -> Optional.empty()))
-        .isEmpty();
+            .isEmpty();
   }
 
   @Test public void mapValuesIfPresent_biFunction_present() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapValuesIfPresent((k, v) -> Optional.of(k + "->" + v)))
-        .containsExactly("uno", "uno->1", "dos", "dos->2")
-        .inOrder();
+            .containsExactly("uno", "uno->1", "dos", "dos->2")
+            .inOrder();
   }
 
   @Test public void mapValuesIfPresent_biFunction_absent() {
     assertKeyValues(BiStream.of("uno", 1, "dos", 2).mapValuesIfPresent((k, v) -> Optional.empty()))
-        .isEmpty();
+            .isEmpty();
   }
 
   @Test public void filter() {
     assertKeyValues(of("one", 1, "two", "two").filter((k, v) -> k.equals(v)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("two", "two"));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("two", "two"));
+  }
+
+  @Test public void filterEntries() {
+    assertKeyValues(of("one", 1, "two", "two").filter(entry -> entry.getKey().equals(entry.getValue())))
+            .containsExactlyEntriesIn(ImmutableMultimap.of("two", "two"));
   }
 
   @Test public void filterKeys() {
     assertKeyValues(of("one", 1, "two", 2).filterKeys("one"::equals))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
   }
 
   @Test public void filterValues() {
     assertKeyValues(of("one", 1, "two", 2).filterValues(v -> v == 2))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2));
+  }
+
+  @Test public void skipEntriesIf() {
+    assertKeyValues(of("one", 1, "two", "two").skipIf(entry -> entry.getKey().equals(entry.getValue())))
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
   }
 
   @Test public void skipIf() {
     assertKeyValues(of("one", 1, "two", "two").skipIf((k, v) -> k.equals(v)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
   }
 
   @Test public void skipKeysIf() {
     assertKeyValues(of("one", 1, "two", 2).skipKeysIf("one"::equals))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2));
   }
 
   @Test public void skipValuesIf() {
     assertKeyValues(of("one", 1, "two", 2).skipValuesIf(v -> v == 2))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1));
   }
 
   @Test public void append() {
     assertKeyValues(of("one", 1).append(of("two", 2, "three", 3)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
+            .inOrder();
     assertKeyValues(of("one", 1).append("two", 2).append("three", 3))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
+            .inOrder();
     assertKeyValues(of("one", 1).append("two", null).append(null, 3))
-        .containsExactlyEntriesIn(keyValues("one", 1, "two", null, null, 3))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues("one", 1, "two", null, null, 3))
+            .inOrder();
   }
 
   @Test public void peek() {
     AtomicInteger sum = new AtomicInteger();
     assertKeyValues(of(1, 2, 3, 4).peek((k, v) -> sum.addAndGet(k + v)))
-        .containsExactlyEntriesIn(ImmutableMultimap.of(1, 2, 3, 4))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of(1, 2, 3, 4))
+            .inOrder();
     assertThat(sum.get()).isEqualTo(10);
   }
 
@@ -323,17 +333,17 @@ public static ImmutableList<Object[]> factories() {
   @Test public void findFirst_nullValueThrowx() {
     assertThrows(NullPointerException.class, of("one", null, "two", 2)::findFirst);
     assertThrows(
-        NullPointerException.class, of("one", 1, "two", 2).mapValues(v -> null)::findFirst);
+            NullPointerException.class, of("one", 1, "two", 2).mapValues(v -> null)::findFirst);
   }
 
   @Test public void findFirst_nullKeyMapsToNonNull() {
     assertThat(of(null, 1, "two", 2).mapKeys(k -> Objects.toString(k)).findFirst())
-        .isEqualTo(BiOptional.of("null", 1));
+            .isEqualTo(BiOptional.of("null", 1));
   }
 
   @Test public void findFirst_nullValueMapsToNonNull() {
     assertThat(of("one", null, "two", 2).mapValues(v -> Objects.toString(v)).findFirst())
-        .isEqualTo(BiOptional.of("one", "null"));
+            .isEqualTo(BiOptional.of("one", "null"));
   }
 
   @Test public void findAny() {
@@ -353,12 +363,12 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void findAny_nullKeyMapsToNonNull() {
     assertThat(of(null, 1).mapKeys(k -> Objects.toString(k)).findAny())
-        .isEqualTo(BiOptional.of("null", 1));
+            .isEqualTo(BiOptional.of("null", 1));
   }
 
   @Test public void findAny_nullValueMapsToNonNull() {
     assertThat(of("one", null).mapValues(v -> Objects.toString(v)).findAny())
-        .isEqualTo(BiOptional.of("one", "null"));
+            .isEqualTo(BiOptional.of("one", "null"));
   }
 
   @Test public void keys() {
@@ -369,14 +379,14 @@ public static ImmutableList<Object[]> factories() {
     List<Object> mappedValues = new ArrayList<>();
     assertThat(
             of("one", 1, "two", 2)
-                .mapValues(
-                    v -> {
-                      mappedValues.add(v);
-                      return v;
-                    })
-                .keys())
-        .containsExactly("one", "two")
-        .inOrder();
+                    .mapValues(
+                            v -> {
+                              mappedValues.add(v);
+                              return v;
+                            })
+                    .keys())
+            .containsExactly("one", "two")
+            .inOrder();
     assertThat(mappedValues).containsExactly(1, 2).inOrder();
   }
 
@@ -388,30 +398,30 @@ public static ImmutableList<Object[]> factories() {
     List<Object> mappedKeys = new ArrayList<>();
     assertThat(
             of("one", 1, "two", 2)
-                .mapKeys(
-                    k -> {
-                      mappedKeys.add(k);
-                      return k;
-                    })
-                .values())
-        .containsExactly(1, 2)
-        .inOrder();
+                    .mapKeys(
+                            k -> {
+                              mappedKeys.add(k);
+                              return k;
+                            })
+                    .values())
+            .containsExactly(1, 2)
+            .inOrder();
     assertThat(mappedKeys).containsExactly("one", "two").inOrder();
   }
 
   @Test public void testMapToObj() {
     assertThat(of("one", 1, "two", 2).mapToObj(Joiner.on(':')::join))
-        .containsExactly("one:1", "two:2");
+            .containsExactly("one:1", "two:2");
   }
 
   @Test public void testMapToObjIfPresent_present() {
     assertThat(of("one", 1, "two", 2).mapToObjIfPresent((k, v) -> Optional.of(k + ":" + v)))
-        .containsExactly("one:1", "two:2");
+            .containsExactly("one:1", "two:2");
   }
 
   @Test public void testMapToObjIfPresent_absent() {
     assertThat(of("one", 1, "two", 2).mapToObjIfPresent((k, v) -> Optional.empty()))
-        .isEmpty();
+            .isEmpty();
   }
 
   @Test public void collectToMap() {
@@ -420,7 +430,7 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void toCollect_toMapMergingValues() {
     assertThat(of("k", 1, "k", 2).collect(toMap((v1, v2) -> v1 * 10 + v2)))
-        .containsExactly("k", 12);
+            .containsExactly("k", 12);
   }
 
   @Test public void collect() {
@@ -430,14 +440,14 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void collect_toImmutableListMultimapWithInflexibleMapperTypes() {
     ImmutableListMultimap<String, Integer> multimap =
-        of("one", 1, "one", 10, "two", 2).collect(new BiCollector<String, Integer, ImmutableListMultimap<String, Integer>>() {
-          @Override
-          public <E> Collector<E, ?, ImmutableListMultimap<String, Integer>> collectorOf(Function<E, String> toKey, Function<E, Integer> toValue) {
-            return BiStreamInvariantsTest.toImmutableMultimap(toKey,toValue);
-          }
-        });
+            of("one", 1, "one", 10, "two", 2).collect(new BiCollector<String, Integer, ImmutableListMultimap<String, Integer>>() {
+              @Override
+              public <E> Collector<E, ?, ImmutableListMultimap<String, Integer>> collectorOf(Function<E, String> toKey, Function<E, Integer> toValue) {
+                return BiStreamInvariantsTest.toImmutableMultimap(toKey,toValue);
+              }
+            });
     assertThat(multimap)
-        .containsExactlyEntriesIn(ImmutableListMultimap.of("one", 1, "one", 10, "two", 2));
+            .containsExactlyEntriesIn(ImmutableListMultimap.of("one", 1, "one", 10, "two", 2));
   }
 
   @Test public void forEach() {
@@ -449,11 +459,11 @@ public static ImmutableList<Object[]> factories() {
   @Test public void forEachOrdered() {
     List<Integer> list = new ArrayList<>();
     of(1, 2, 3, 4)
-        .forEachOrdered(
-            (k, v) -> {
-              list.add(k);
-              list.add(v);
-            });
+            .forEachOrdered(
+                    (k, v) -> {
+                      list.add(k);
+                      list.add(v);
+                    });
     assertThat(list).containsExactly(1, 2, 3, 4).inOrder();
   }
 
@@ -463,20 +473,20 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void map() {
     assertKeyValues(of(1, "one", 2, "two").map(Joiner.on(':')::join, (k, v) -> v + ":" + k))
-        .containsExactly("1:one", "one:1", "2:two", "two:2")
-        .inOrder();
+            .containsExactly("1:one", "one:1", "2:two", "two:2")
+            .inOrder();
   }
 
   @Test public void map_toPair() {
     assertKeyValues(of(1, "a:foo", 2, "b:bar").map((l, t) -> first(':').split(t).orElseThrow()))
-        .containsExactly("a", "foo", "b", "bar")
-        .inOrder();
+            .containsExactly("a", "foo", "b", "bar")
+            .inOrder();
   }
 
   @Test public void mapIfPresent_mapToPresent() {
     assertKeyValues(of(1, "one", 2, "two").mapIfPresent((k, v) -> BiOptional.of(k + ":" + v, v + ":" + k)))
-        .containsExactly("1:one", "one:1", "2:two", "two:2")
-        .inOrder();
+            .containsExactly("1:one", "one:1", "2:two", "two:2")
+            .inOrder();
   }
 
   @Test public void mapIfPresent_mapToEnty() {
@@ -489,26 +499,26 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void mapToInt() {
     assertThat(of(1, 2, 3, 4).mapToInt((k, v) -> k * 10 + v).boxed())
-        .containsExactly(12, 34)
-        .inOrder();
+            .containsExactly(12, 34)
+            .inOrder();
   }
 
   @Test public void mapToLong() {
     assertThat(of(1, 2, 3, 4).mapToLong((k, v) -> k * 10 + v).boxed())
-        .containsExactly(12L, 34L)
-        .inOrder();
+            .containsExactly(12L, 34L)
+            .inOrder();
   }
 
   @Test public void mapToDouble() {
     assertThat(of(1, 2, 3, 4).mapToDouble((k, v) -> k * 10 + v).boxed())
-        .containsExactly(12D, 34D)
-        .inOrder();
+            .containsExactly(12D, 34D)
+            .inOrder();
   }
 
   @Test public void flatMapToObj() {
     assertThat(of(1, 2, 3, 4).flatMapToObj((k, n) -> Collections.nCopies(n, k).stream()))
-        .containsExactly(1, 1, 3, 3, 3, 3)
-        .inOrder();
+            .containsExactly(1, 1, 3, 3, 3, 3)
+            .inOrder();
   }
 
   @Test public void flatMapToObj_mapperReturnsNull() {
@@ -518,10 +528,10 @@ public static ImmutableList<Object[]> factories() {
   @Test public void flatMapToInt() {
     assertThat(
             of(1, 2, 3, 4)
-                .flatMapToInt((k, n) -> Collections.nCopies(n, k).stream().mapToInt(i -> i))
-                .boxed())
-        .containsExactly(1, 1, 3, 3, 3, 3)
-        .inOrder();
+                    .flatMapToInt((k, n) -> Collections.nCopies(n, k).stream().mapToInt(i -> i))
+                    .boxed())
+            .containsExactly(1, 1, 3, 3, 3, 3)
+            .inOrder();
   }
 
   @Test public void flatMapToInt_mapperReturnsNull() {
@@ -531,10 +541,10 @@ public static ImmutableList<Object[]> factories() {
   @Test public void flatMapToLong() {
     assertThat(
             of(1, 2, 3, 4)
-                .flatMapToLong((k, n) -> Collections.nCopies(n, k).stream().mapToLong(i -> i))
-                .boxed())
-        .containsExactly(1L, 1L, 3L, 3L, 3L, 3L)
-        .inOrder();
+                    .flatMapToLong((k, n) -> Collections.nCopies(n, k).stream().mapToLong(i -> i))
+                    .boxed())
+            .containsExactly(1L, 1L, 3L, 3L, 3L, 3L)
+            .inOrder();
   }
 
   @Test public void flatMapToLong_mapperReturnsNull() {
@@ -544,10 +554,10 @@ public static ImmutableList<Object[]> factories() {
   @Test public void flatMapToDouble() {
     assertThat(
             of(1, 2, 3, 4)
-                .flatMapToDouble((k, n) -> Collections.nCopies(n, k).stream().mapToDouble(i -> i))
-                .boxed())
-        .containsExactly(1D, 1D, 3D, 3D, 3D, 3D)
-        .inOrder();
+                    .flatMapToDouble((k, n) -> Collections.nCopies(n, k).stream().mapToDouble(i -> i))
+                    .boxed())
+            .containsExactly(1D, 1D, 3D, 3D, 3D, 3D)
+            .inOrder();
   }
 
   @Test public void flatMapToDouble_mapperReturnsNull() {
@@ -556,152 +566,152 @@ public static ImmutableList<Object[]> factories() {
 
   @Test public void limit() {
     assertKeyValues(of("one", 1, "two", 2, "three", 3).limit(2))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2))
+            .inOrder();
   }
 
   @Test public void skip() {
     assertKeyValues(of("one", 1, "two", 2, "three", 3).skip(1))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2, "three", 3))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("two", 2, "three", 3))
+            .inOrder();
   }
 
   @Test public void sortedByKeys() {
     assertKeyValues(of("a", 1, "c", 2, "b", 3).sortedByKeys(naturalOrder()))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("a", 1, "b", 3, "c", 2));
+            .containsExactlyEntriesIn(ImmutableMultimap.of("a", 1, "b", 3, "c", 2));
   }
 
   @Test public void sortedByValues() {
     assertKeyValues(of("a", 3, "b", 1, "c", 2).sortedByValues(naturalOrder()))
-        .containsExactlyEntriesIn(ImmutableMultimap.of("b", 1, "c", 2, "a", 3))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("b", 1, "c", 2, "a", 3))
+            .inOrder();
   }
 
   @Test public void testMaxByKey_found() {
     assertThat(of(1, "y", 2, "x").collect(maxByKey(naturalOrder())))
-        .isEqualTo(BiOptional.of(2, "x"));
+            .isEqualTo(BiOptional.of(2, "x"));
   }
 
- @Test public void testMaxByKey_multipleMax_firstWins() {
+  @Test public void testMaxByKey_multipleMax_firstWins() {
     assertThat(of(1, "y", 2, "x", 2, "a").collect(maxByKey(naturalOrder())))
-        .isEqualTo(BiOptional.of(2, "x"));
+            .isEqualTo(BiOptional.of(2, "x"));
   }
 
- @Test public void testMaxByKey_notFound() {
+  @Test public void testMaxByKey_notFound() {
     assertThat(this.<String, Integer>of().collect(maxByKey(naturalOrder())))
-        .isEqualTo(BiOptional.empty());
+            .isEqualTo(BiOptional.empty());
   }
 
- @Test public void testMinByKey_found() {
+  @Test public void testMinByKey_found() {
     assertThat(of(1, "y", 2, "x").collect(minByKey(naturalOrder())))
-        .isEqualTo(BiOptional.of(1, "y"));
+            .isEqualTo(BiOptional.of(1, "y"));
   }
 
- @Test public void testMinByKey_multipleMin_firstWins() {
+  @Test public void testMinByKey_multipleMin_firstWins() {
     assertThat(of(1, "y", 2, "x", 1, "a").collect(minByKey(naturalOrder())))
-        .isEqualTo(BiOptional.of(1, "y"));
+            .isEqualTo(BiOptional.of(1, "y"));
   }
 
- @Test public void testMinByKey_notFound() {
+  @Test public void testMinByKey_notFound() {
     assertThat(this.<String, Integer>of().collect(minByKey(naturalOrder())))
-        .isEqualTo(BiOptional.empty());
-  }
-
- @Test public void testMaxByValue_found() {
-   assertThat(of(1, "y", 2, "x").collect(maxByValue(naturalOrder())))
-       .isEqualTo(BiOptional.of(1, "y"));
- }
-
-@Test public void testMaxByValue_multipleMax_firstWins() {
-   assertThat(of(1, "x", 2, "y", 3, "y").collect(maxByValue(naturalOrder())))
-       .isEqualTo(BiOptional.of(2, "y"));
- }
-
-@Test public void testMaxByValue_notFound() {
-   assertThat(this.<String, Integer>of().collect(maxByValue(naturalOrder())))
-       .isEqualTo(BiOptional.empty());
- }
-
-@Test public void testMinByValue_found() {
-   assertThat(of(1, "y", 2, "x").collect(minByValue(naturalOrder())))
-       .isEqualTo(BiOptional.of(2, "x"));
- }
-
-@Test public void testMinByValue_multipleMin_firstWins() {
-   assertThat(of(1, "y", 3, "x", 2, "x").collect(minByValue(naturalOrder())))
-       .isEqualTo(BiOptional.of(3, "x"));
- }
-
-@Test public void testMinByValue_notFound() {
-   assertThat(this.<String, Integer>of().collect(minByValue(naturalOrder())))
-       .isEqualTo(BiOptional.empty());
- }
-
-@Test
-public void testMinBy_found() {
-  assertThat(of(1, "y", 2, "x").collect(minBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(1, "y"));
-  assertThat(of(1, "y", 1, "x").collect(minBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(1, "x"));
-}
+            .isEqualTo(BiOptional.empty());
+  }
 
-@Test
-public void testMinBy_breakTieByValue() {
-  assertThat(of(1, "y", 2, "x", 1, "a").collect(minBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(1, "a"));
-}
+  @Test public void testMaxByValue_found() {
+    assertThat(of(1, "y", 2, "x").collect(maxByValue(naturalOrder())))
+            .isEqualTo(BiOptional.of(1, "y"));
+  }
 
-@Test
-public void testMinBy_notFound() {
-  assertThat(this.<String, Integer>of().collect(minBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.empty());
-}
+  @Test public void testMaxByValue_multipleMax_firstWins() {
+    assertThat(of(1, "x", 2, "y", 3, "y").collect(maxByValue(naturalOrder())))
+            .isEqualTo(BiOptional.of(2, "y"));
+  }
 
-@Test
-public void testMaxBy_found() {
-  assertThat(of(1, "y", 2, "x").collect(maxBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(2, "x"));
-  assertThat(of(1, "y", 1, "x").collect(maxBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(1, "y"));
-}
+  @Test public void testMaxByValue_notFound() {
+    assertThat(this.<String, Integer>of().collect(maxByValue(naturalOrder())))
+            .isEqualTo(BiOptional.empty());
+  }
 
-@Test
-public void testMaxBy_breakTieByValue() {
-  assertThat(of(3, "x", 2, "y", 3, "y").collect(maxBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.of(3, "y"));
-}
+  @Test public void testMinByValue_found() {
+    assertThat(of(1, "y", 2, "x").collect(minByValue(naturalOrder())))
+            .isEqualTo(BiOptional.of(2, "x"));
+  }
 
-@Test
-public void testMaxBy_notFound() {
-  assertThat(this.<String, Integer>of().collect(maxBy(naturalOrder(), naturalOrder())))
-      .isEqualTo(BiOptional.empty());
-}
+  @Test public void testMinByValue_multipleMin_firstWins() {
+    assertThat(of(1, "y", 3, "x", 2, "x").collect(minByValue(naturalOrder())))
+            .isEqualTo(BiOptional.of(3, "x"));
+  }
+
+  @Test public void testMinByValue_notFound() {
+    assertThat(this.<String, Integer>of().collect(minByValue(naturalOrder())))
+            .isEqualTo(BiOptional.empty());
+  }
+
+  @Test
+  public void testMinBy_found() {
+    assertThat(of(1, "y", 2, "x").collect(minBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(1, "y"));
+    assertThat(of(1, "y", 1, "x").collect(minBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(1, "x"));
+  }
+
+  @Test
+  public void testMinBy_breakTieByValue() {
+    assertThat(of(1, "y", 2, "x", 1, "a").collect(minBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(1, "a"));
+  }
+
+  @Test
+  public void testMinBy_notFound() {
+    assertThat(this.<String, Integer>of().collect(minBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.empty());
+  }
+
+  @Test
+  public void testMaxBy_found() {
+    assertThat(of(1, "y", 2, "x").collect(maxBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(2, "x"));
+    assertThat(of(1, "y", 1, "x").collect(maxBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(1, "y"));
+  }
+
+  @Test
+  public void testMaxBy_breakTieByValue() {
+    assertThat(of(3, "x", 2, "y", 3, "y").collect(maxBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.of(3, "y"));
+  }
+
+  @Test
+  public void testMaxBy_notFound() {
+    assertThat(this.<String, Integer>of().collect(maxBy(naturalOrder(), naturalOrder())))
+            .isEqualTo(BiOptional.empty());
+  }
 
   @Test public void distinct() {
     assertKeyValues(of("a", 1, "b", 2, "a", 1).distinct())
-        .containsExactlyEntriesIn(ImmutableMultimap.of("a", 1, "b", 2))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of("a", 1, "b", 2))
+            .inOrder();
     assertKeyValues(of("a", null, "a", null).distinct())
-        .containsExactlyEntriesIn(keyValues("a", null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues("a", null))
+            .inOrder();
     assertKeyValues(of("a", null, "b", null).distinct())
-        .containsExactlyEntriesIn(keyValues("a", null, "b", null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues("a", null, "b", null))
+            .inOrder();
     assertKeyValues(of(null, 1, null, 1).distinct())
-        .containsExactlyEntriesIn(keyValues(null, 1))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, 1))
+            .inOrder();
     assertKeyValues(of(null, 1, null, 2).distinct())
-        .containsExactlyEntriesIn(keyValues(null, 1, null, 2))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, 1, null, 2))
+            .inOrder();
     assertKeyValues(of(null, null, null, null).distinct())
-        .containsExactlyEntriesIn(keyValues(null, null))
-        .inOrder();
+            .containsExactlyEntriesIn(keyValues(null, null))
+            .inOrder();
   }
 
   @Test public void inverse() {
     assertKeyValues(of("a", 1).inverse())
-        .containsExactlyEntriesIn(ImmutableMultimap.of(1, "a"))
-        .inOrder();
+            .containsExactlyEntriesIn(ImmutableMultimap.of(1, "a"))
+            .inOrder();
   }
 
   @Test public void testGroupConsecutiveBy_emptyStream() {
@@ -710,18 +720,18 @@ public void testMaxBy_notFound() {
 
   @Test public void testGroupConsecutiveBy_singleElement() {
     assertKeyValues(of("1", 1).groupConsecutiveBy(identity(), toList()))
-        .containsExactly("1", asList(1));
+            .containsExactly("1", asList(1));
   }
 
   @Test public void testGroupConsecutiveBy_twoElementsSameRun() {
     assertKeyValues(of("k", "a", "k", "b").groupConsecutiveBy(identity(), toList()))
-        .containsExactly("k", asList("a", "b"));
+            .containsExactly("k", asList("a", "b"));
   }
 
   @Test public void testGroupConsecutiveBy_twoElementsDifferentRuns() {
     assertKeyValues(of("k1", 1, "k2", 2).groupConsecutiveBy(identity(), toList()))
-        .containsExactly("k1", asList(1), "k2", asList(2))
-        .inOrder();
+            .containsExactly("k1", asList(1), "k2", asList(2))
+            .inOrder();
   }
 
   @Test public void testGroupConsecutiveIf_emptyStream() {
@@ -730,18 +740,18 @@ public void testMaxBy_notFound() {
 
   @Test public void testGroupConsecutiveIf_singleElement() {
     assertThat(of("1", 1).groupConsecutiveIf(Object::equals, toList()))
-        .containsExactly(asList(1));
+            .containsExactly(asList(1));
   }
 
   @Test public void testGroupConsecutiveIf_twoElementsSameRun() {
     assertThat(of("k", "a", "k", "b").groupConsecutiveIf(Object::equals, toList()))
-        .containsExactly(asList("a", "b"));
+            .containsExactly(asList("a", "b"));
   }
 
   @Test public void testGroupConsecutiveIf_twoElementsDifferentRuns() {
     assertThat(of("k1", 1, "k2", 2).groupConsecutiveIf(Object::equals, Integer::sum))
-        .containsExactly(1, 2)
-        .inOrder();
+            .containsExactly(1, 2)
+            .inOrder();
   }
 
   @Test public void testGroupConsecutiveBy_withGroupReducer_emptyStream() {
@@ -750,18 +760,18 @@ public void testMaxBy_notFound() {
 
   @Test public void testGroupConsecutiveBy_withGroupReducer_singleElement() {
     assertKeyValues(of("1", 1).groupConsecutiveBy(identity(), Integer::sum))
-        .containsExactly("1", 1);
+            .containsExactly("1", 1);
   }
 
   @Test public void testGroupConsecutiveBy_withGroupReducer_twoElementsSameRun() {
     assertKeyValues(of("k", "a", "k", "b").groupConsecutiveBy(identity(), String::concat))
-        .containsExactly("k", "ab");
+            .containsExactly("k", "ab");
   }
 
   @Test public void testGroupConsecutiveBy_withGroupReducer_twoElementsDifferentRuns() {
     assertKeyValues(of("k1", 1, "k2", 2).groupConsecutiveBy(identity(), Integer::sum))
-        .containsExactly("k1", 1, "k2", 2)
-        .inOrder();
+            .containsExactly("k1", 1, "k2", 2)
+            .inOrder();
   }
 
   @Test public void testGroupConsecutiveBy_groupWithBiCollector_emptyStream() {
@@ -771,19 +781,19 @@ public void testMaxBy_notFound() {
   @Test public void testGroupConsecutiveBy_groupWithBiCollector_singleElement() {
     assertKeyValues(
             of("1", 1).groupConsecutiveBy((k, v) -> Integer.parseInt(k), toMap()))
-        .containsExactly(1, ImmutableMap.of("1", 1));
+            .containsExactly(1, ImmutableMap.of("1", 1));
   }
 
   @Test public void testGroupConsecutiveBy_groupWithBiCollector_twoElementsSameRun() {
     assertKeyValues(
             of("k", "a", "k", "b").groupConsecutiveBy((k, v) -> k, ImmutableListMultimap::toImmutableListMultimap))
-        .containsExactly("k", ImmutableListMultimap.of("k", "a", "k", "b"));
+            .containsExactly("k", ImmutableListMultimap.of("k", "a", "k", "b"));
   }
 
   @Test public void testGroupConsecutiveBy_groupWithBiCollector_twoElementsDifferentRuns() {
     assertKeyValues(of("k1", 1, "k2", 2).groupConsecutiveBy((k, v) -> k, toMap()))
-        .containsExactly("k1", ImmutableMap.of("k1", 1), "k2", ImmutableMap.of("k2", 2))
-        .inOrder();
+            .containsExactly("k1", ImmutableMap.of("k1", 1), "k2", ImmutableMap.of("k2", 2))
+            .inOrder();
   }
 
   private <K, V> BiStream<K, V> of() {
@@ -815,19 +825,19 @@ static<K, V> MultimapSubject assertKeyValues(BiStream<K, V> stream) {
   // Intentionally declare the parameter types without wildcards, to make sure
   // BiCollector can still work with such naive method references.
   public static <T, K, V> Collector<T, ?, ImmutableListMultimap<K, V>> toImmutableMultimap(
-      Function<T, K> keyMapper, Function<T, V> valueMapper) {
+          Function<T, K> keyMapper, Function<T, V> valueMapper) {
     return ImmutableListMultimap.toImmutableListMultimap(keyMapper, valueMapper);
   }
 
   private static <T, K, V> Collector<T, ?, Multimap<K, V>> toLinkedListMultimap(
-      Function<? super T, ? extends K> toKey, Function<? super T, ? extends V> toValue) {
+          Function<? super T, ? extends K> toKey, Function<? super T, ? extends V> toValue) {
     return Collector.of(
-        LinkedListMultimap::create,
-        (m, e) -> m.put(toKey.apply(e), toValue.apply(e)),
-        (m1, m2) -> {
-          m1.putAll(m2);
-          return m1;
-        });
+            LinkedListMultimap::create,
+            (m, e) -> m.put(toKey.apply(e), toValue.apply(e)),
+            (m1, m2) -> {
+              m1.putAll(m2);
+              return m1;
+            });
   }
 
   private static <K, V> ListMultimap<K, V> keyValues(K key, V value) {
@@ -899,54 +909,54 @@ <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
       @Override
       <K, V> BiStream<K, V> newBiStream() {
         return BiStream.from(
-            ImmutableListMultimap.<K, V>of().entries().stream(),
-            Map.Entry::getKey,
-            Map.Entry::getValue);
+                ImmutableListMultimap.<K, V>of().entries().stream(),
+                Map.Entry::getKey,
+                Map.Entry::getValue);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K key, V value) {
         return BiStream.from(
-            keyValues(value, key).entries().stream(), Map.Entry::getValue, Map.Entry::getKey);
+                keyValues(value, key).entries().stream(), Map.Entry::getValue, Map.Entry::getKey);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2) {
         return BiStream.from(
-            keyValues(k1, v1, k2, v2).entries().stream(), Map.Entry::getKey, Map.Entry::getValue);
+                keyValues(k1, v1, k2, v2).entries().stream(), Map.Entry::getKey, Map.Entry::getValue);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
         return BiStream.from(
-            keyValues(k1, v1, k2, v2, k3, v3).entries().stream(),
-            Map.Entry::getKey,
-            Map.Entry::getValue);
+                keyValues(k1, v1, k2, v2, k3, v3).entries().stream(),
+                Map.Entry::getKey,
+                Map.Entry::getValue);
       }
     },
     COLLECTED_FROM_GENERIC_ENTRY_STREAM {
       @Override
       <K, V> BiStream<K, V> newBiStream() {
         return ImmutableListMultimap.<K, V>of().entries().stream()
-            .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
+                .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K key, V value) {
         return keyValues(value, key).entries().stream()
-            .collect(toBiStream(Map.Entry::getValue, Map.Entry::getKey));
+                .collect(toBiStream(Map.Entry::getValue, Map.Entry::getKey));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2) {
         return keyValues(k1, v1, k2, v2).entries().stream()
-            .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
+                .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
         return keyValues(k1, v1, k2, v2, k3, v3).entries().stream()
-            .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
+                .collect(toBiStream(Map.Entry::getKey, Map.Entry::getValue));
       }
     },
     FROM_PAIRS {
@@ -974,25 +984,25 @@ <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
       @Override
       <K, V> BiStream<K, V> newBiStream() {
         return ImmutableListMultimap.<K, V>of().entries().stream()
-            .collect(toBiStream(this::fromEntry));
+                .collect(toBiStream(this::fromEntry));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K key, V value) {
         return keyValues(key, value).entries().stream()
-            .collect(toBiStream(this::fromEntry));
+                .collect(toBiStream(this::fromEntry));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2) {
         return keyValues(k1, v1, k2, v2).entries().stream()
-            .collect(toBiStream(this::fromEntry));
+                .collect(toBiStream(this::fromEntry));
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
         return keyValues(k1, v1, k2, v2, k3, v3).entries().stream()
-            .collect(toBiStream(this::fromEntry));
+                .collect(toBiStream(this::fromEntry));
       }
 
       private <K, V> Both<K, V> fromEntry(Map.Entry<K, V> entry) {
@@ -1003,25 +1013,25 @@ private <K, V> Both<K, V> fromEntry(Map.Entry<K, V> entry) {
       @Override
       <K, V> BiStream<K, V> newBiStream() {
         return BiStream.from(
-            ImmutableListMultimap.<K, V>of().entries(), Map.Entry::getKey, Map.Entry::getValue);
+                ImmutableListMultimap.<K, V>of().entries(), Map.Entry::getKey, Map.Entry::getValue);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K key, V value) {
         return BiStream.from(
-            keyValues(value, key).entries(), Map.Entry::getValue, Map.Entry::getKey);
+                keyValues(value, key).entries(), Map.Entry::getValue, Map.Entry::getKey);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2) {
         return BiStream.from(
-            keyValues(k1, v1, k2, v2).entries(), Map.Entry::getKey, Map.Entry::getValue);
+                keyValues(k1, v1, k2, v2).entries(), Map.Entry::getKey, Map.Entry::getValue);
       }
 
       @Override
       <K, V> BiStream<K, V> newBiStream(K k1, V v1, K k2, V v2, K k3, V v3) {
         return BiStream.from(
-            keyValues(k1, v1, k2, v2, k3, v3).entries(), Map.Entry::getKey, Map.Entry::getValue);
+                keyValues(k1, v1, k2, v2, k3, v3).entries(), Map.Entry::getKey, Map.Entry::getValue);
       }
     },
     FROM_ZIP {
@@ -1112,6 +1122,12 @@ <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {
         return stream.filter((k, v) -> true);
       }
     },
+    TRIVIAL_FILTER_ENTRY {
+      @Override
+      <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {
+        return stream.filter(entry -> true);
+      }
+    },
     TRIVIAL_FILTER_KEY {
       @Override
       <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {
@@ -1130,6 +1146,12 @@ <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {
         return stream.skipIf((k, v) -> false);
       }
     },
+    TRIVIAL_SKIP_ENTRIES_IF {
+      @Override
+      <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {
+        return stream.skipIf(entry -> false);
+      }
+    },
     TRIVIAL_SKIP_KEYS_IF {
       @Override
       <K, V> BiStream<K, V> wrap(BiStream<K, V> stream) {