diff --git a/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java b/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java
index 3d08e80..66a5a7c 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/BaseStream.java
@@ -26,7 +26,7 @@
  * @param <T> the contents of the stream
  * @param <S> the type of stream implementing this interface
  */
-public interface BaseStream<T,S extends BaseStream<T,S>> extends AutoCloseable {
+public interface BaseStream<T, S extends BaseStream<T, S>> extends AutoCloseable {
   Iterator<T> iterator();
 
   Spliterator<T> spliterator();
diff --git a/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
index 492f621..2198f00 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java
@@ -47,7 +47,7 @@
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/DoubleStream.html">
  * the official Java API doc</a> for details.
  */
-public interface DoubleStream extends BaseStream<Double,DoubleStream> {
+public interface DoubleStream extends BaseStream<Double, DoubleStream> {
 
   /**
    * Value holder for various stream operations.
@@ -89,45 +89,45 @@
 
     // TODO replace this flatMap-ish spliterator with one that directly combines the two root
     // streams
-    Spliterator<? extends DoubleStream> spliteratorOfStreams =
-        Arrays.asList(a, b).spliterator();
-    DoubleStream result = new DoubleStreamSource(null, new Spliterators.AbstractDoubleSpliterator(
-        Long.MAX_VALUE,
-        0
-    ) {
-      DoubleStream nextStream;
-      Spliterator.OfDouble next;
+    Spliterator<? extends DoubleStream> spliteratorOfStreams = Arrays.asList(a, b).spliterator();
+    DoubleStream result =
+        new DoubleStreamSource(
+            null,
+            new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
+              DoubleStream nextStream;
+              Spliterator.OfDouble next;
 
-      @Override
-      public boolean tryAdvance(DoubleConsumer action) {
-        // look for a new spliterator
-        while (advanceToNextSpliterator()) {
-          // if we have one, try to read and use it
-          if (next.tryAdvance(action)) {
-            return true;
-          } else {
-            nextStream = null;
-            // failed, null it out so we can find another
-            next = null;
-          }
-        }
-        return false;
-      }
+              @Override
+              public boolean tryAdvance(DoubleConsumer action) {
+                // look for a new spliterator
+                while (advanceToNextSpliterator()) {
+                  // if we have one, try to read and use it
+                  if (next.tryAdvance(action)) {
+                    return true;
+                  } else {
+                    nextStream = null;
+                    // failed, null it out so we can find another
+                    next = null;
+                  }
+                }
+                return false;
+              }
 
-      private boolean advanceToNextSpliterator() {
-        while (next == null) {
-          if (!spliteratorOfStreams.tryAdvance(n -> {
-            if (n != null) {
-              nextStream = n;
-              next = n.spliterator();
-            }
-          })) {
-            return false;
-          }
-        }
-        return true;
-      }
-    });
+              private boolean advanceToNextSpliterator() {
+                while (next == null) {
+                  if (!spliteratorOfStreams.tryAdvance(
+                      n -> {
+                        if (n != null) {
+                          nextStream = n;
+                          next = n.spliterator();
+                        }
+                      })) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            });
 
     result.onClose(a::close);
     result.onClose(b::close);
@@ -140,32 +140,32 @@
   }
 
   static DoubleStream generate(DoubleSupplier s) {
-    return StreamSupport.doubleStream(new Spliterators.AbstractDoubleSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      @Override
-      public boolean tryAdvance(DoubleConsumer action) {
-        action.accept(s.getAsDouble());
-        return true;
-      }
-    }, false);
+    return StreamSupport.doubleStream(
+        new Spliterators.AbstractDoubleSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          @Override
+          public boolean tryAdvance(DoubleConsumer action) {
+            action.accept(s.getAsDouble());
+            return true;
+          }
+        },
+        false);
   }
 
   static DoubleStream iterate(double seed, DoubleUnaryOperator f) {
-    return StreamSupport.doubleStream(new Spliterators.AbstractDoubleSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      private double next = seed;
+    return StreamSupport.doubleStream(
+        new Spliterators.AbstractDoubleSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private double next = seed;
 
-      @Override
-      public boolean tryAdvance(DoubleConsumer action) {
-        action.accept(next);
-        next = f.applyAsDouble(next);
-        return true;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(DoubleConsumer action) {
+            action.accept(next);
+            next = f.applyAsDouble(next);
+            return true;
+          }
+        },
+        false);
   }
 
   static DoubleStream of(double... values) {
@@ -174,7 +174,7 @@
 
   static DoubleStream of(double t) {
     // TODO consider a splittable that returns only a single value
-    return of(new double[]{t});
+    return of(new double[] {t});
   }
 
   /**
@@ -202,7 +202,7 @@
 
   Stream<Double> boxed();
 
-  <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R,R> combiner);
+  <R> R collect(Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner);
 
   long count();
 
@@ -368,9 +368,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         ObjDoubleConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       return supplier.get();
     }
@@ -493,8 +492,7 @@
     public MapToIntSpliterator(DoubleToIntFunction map, Spliterator.OfDouble original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -517,8 +515,7 @@
     public MapToObjSpliterator(DoubleFunction<? extends T> map, Spliterator.OfDouble original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -540,8 +537,7 @@
     public MapToLongSpliterator(DoubleToLongFunction map, Spliterator.OfDouble original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -563,8 +559,7 @@
     public MapToDoubleSpliterator(DoubleUnaryOperator map, Spliterator.OfDouble original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -600,12 +595,14 @@
     @Override
     public boolean tryAdvance(final DoubleConsumer action) {
       found = false;
-      while (!found && original.tryAdvance((double item) -> {
-        if (filter.test(item)) {
-          found = true;
-          action.accept(item);
-        }
-      })) {
+      while (!found
+          && original.tryAdvance(
+              (double item) -> {
+                if (filter.test(item)) {
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
         // do nothing, work is done in tryAdvance
       }
 
@@ -625,8 +622,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.max(0, original.estimateSize() - skip)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.skip = skip;
       this.original = original;
     }
@@ -639,7 +635,7 @@
     @Override
     public boolean tryAdvance(DoubleConsumer action) {
       while (skip > 0) {
-        if (!original.tryAdvance((double ignore) -> { })) {
+        if (!original.tryAdvance((double ignore) -> {})) {
           return false;
         }
         skip--;
@@ -661,8 +657,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.min(original.estimateSize(), limit)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.limit = limit;
       this.original = original;
     }
@@ -724,9 +719,10 @@
       terminate();
       ValueConsumer holder = new ValueConsumer();
       holder.value = identity;
-      spliterator.forEachRemaining((double value) -> {
-        holder.accept(op.applyAsDouble(holder.value, value));
-      });
+      spliterator.forEachRemaining(
+          (double value) -> {
+            holder.accept(op.applyAsDouble(holder.value, value));
+          });
       return holder.value;
     }
 
@@ -741,9 +737,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         ObjDoubleConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, ObjDoubleConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       final R acc = supplier.get();
       spliterator.forEachRemaining((double value) -> accumulator.accept(acc, value));
@@ -760,9 +755,10 @@
       terminate();
       final ValueConsumer holder = new ValueConsumer();
       if (spliterator.tryAdvance((double value) -> holder.value = value)) {
-        spliterator.forEachRemaining((double value) -> {
-          holder.value = Math.min(holder.value, value);
-        });
+        spliterator.forEachRemaining(
+            (double value) -> {
+              holder.value = Math.min(holder.value, value);
+            });
         return OptionalDouble.of(holder.value);
       }
       return OptionalDouble.empty();
@@ -773,9 +769,10 @@
       terminate();
       final ValueConsumer holder = new ValueConsumer();
       if (spliterator.tryAdvance((double value) -> holder.value = value)) {
-        spliterator.forEachRemaining((double value) -> {
-          holder.value = Math.max(holder.value, value);
-        });
+        spliterator.forEachRemaining(
+            (double value) -> {
+              holder.value = Math.max(holder.value, value);
+            });
         return OptionalDouble.of(holder.value);
       }
       return OptionalDouble.empty();
@@ -785,7 +782,7 @@
     public long count() {
       terminate();
       long count = 0;
-      while (spliterator.tryAdvance((double value) -> { })) {
+      while (spliterator.tryAdvance((double value) -> {})) {
         count++;
       }
       return count;
@@ -806,8 +803,7 @@
           DoubleSummaryStatistics::new,
           // TODO switch to a lambda reference once #9340 is fixed
           (doubleSummaryStatistics, value) -> doubleSummaryStatistics.accept(value),
-          DoubleSummaryStatistics::combine
-      );
+          DoubleSummaryStatistics::combine);
     }
 
     @Override
@@ -890,44 +886,44 @@
       throwIfTerminated();
       final Spliterator<? extends DoubleStream> spliteratorOfStreams =
           new MapToObjSpliterator<DoubleStream>(mapper, spliterator);
-      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
-          Long.MAX_VALUE,
-          0
-      ) {
-        DoubleStream nextStream;
-        Spliterator.OfDouble next;
+      return new DoubleStreamSource(
+          this,
+          new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE, 0) {
+            DoubleStream nextStream;
+            Spliterator.OfDouble next;
 
-        @Override
-        public boolean tryAdvance(DoubleConsumer action) {
-          // look for a new spliterator
-          while (advanceToNextSpliterator()) {
-            // if we have one, try to read and use it
-            if (next.tryAdvance(action)) {
-              return true;
-            } else {
-              nextStream.close();
-              nextStream = null;
-              // failed, null it out so we can find another
-              next = null;
-            }
-          }
-          return false;
-        }
-
-        private boolean advanceToNextSpliterator() {
-          while (next == null) {
-            if (!spliteratorOfStreams.tryAdvance(n -> {
-              if (n != null) {
-                nextStream = n;
-                next = n.spliterator();
+            @Override
+            public boolean tryAdvance(DoubleConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
               }
-            })) {
               return false;
             }
-          }
-          return true;
-        }
-      });
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          });
     }
 
     @Override
@@ -940,43 +936,43 @@
     @Override
     public DoubleStream sorted() {
       throwIfTerminated();
-      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics() | Spliterator.SORTED
-      ) {
-        Spliterator.OfDouble ordered = null;
+      return new DoubleStreamSource(
+          this,
+          new Spliterators.AbstractDoubleSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+            Spliterator.OfDouble ordered = null;
 
-        @Override
-        public Comparator<? super Double> getComparator() {
-          return null;
-        }
+            @Override
+            public Comparator<? super Double> getComparator() {
+              return null;
+            }
 
-        @Override
-        public boolean tryAdvance(DoubleConsumer action) {
-          if (ordered == null) {
-            double[] list = new double[0];
-            spliterator.forEachRemaining((double item) -> list[list.length] = item);
-            Arrays.sort(list);
-            ordered = Spliterators.spliterator(list, characteristics());
-          }
-          return ordered.tryAdvance(action);
-        }
-      });
+            @Override
+            public boolean tryAdvance(DoubleConsumer action) {
+              if (ordered == null) {
+                double[] list = new double[0];
+                spliterator.forEachRemaining((double item) -> list[list.length] = item);
+                Arrays.sort(list);
+                ordered = Spliterators.spliterator(list, characteristics());
+              }
+              return ordered.tryAdvance(action);
+            }
+          });
     }
 
     @Override
     public DoubleStream peek(DoubleConsumer action) {
       checkNotNull(action);
       throwIfTerminated();
-      return new DoubleStreamSource(this, new Spliterators.AbstractDoubleSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics()
-      ) {
-        @Override
-        public boolean tryAdvance(final DoubleConsumer innerAction) {
-          return spliterator.tryAdvance(action.andThen(innerAction));
-        }
-      });
+      return new DoubleStreamSource(
+          this,
+          new Spliterators.AbstractDoubleSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics()) {
+            @Override
+            public boolean tryAdvance(final DoubleConsumer innerAction) {
+              return spliterator.tryAdvance(action.andThen(innerAction));
+            }
+          });
     }
 
     @Override
diff --git a/user/super/com/google/gwt/emul/java/util/stream/IntStream.java b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
index 8a0816e..d6de0d9 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/IntStream.java
@@ -48,7 +48,7 @@
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html">
  * the official Java API doc</a> for details.
  */
-public interface IntStream extends BaseStream<Integer,IntStream> {
+public interface IntStream extends BaseStream<Integer, IntStream> {
 
   /**
    * Value holder for various stream operations.
@@ -90,43 +90,45 @@
 
     // TODO replace this flatMap-ish spliterator with one that directly combines the two root
     // streams
-    Spliterator<? extends IntStream> spliteratorOfStreams =
-        Arrays.asList(a, b).spliterator();
-    IntStream result = new IntStreamSource(null, new Spliterators.AbstractIntSpliterator(Long
-        .MAX_VALUE, 0) {
-      IntStream nextStream;
-      Spliterator.OfInt next;
+    Spliterator<? extends IntStream> spliteratorOfStreams = Arrays.asList(a, b).spliterator();
+    IntStream result =
+        new IntStreamSource(
+            null,
+            new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+              IntStream nextStream;
+              Spliterator.OfInt next;
 
-      @Override
-      public boolean tryAdvance(IntConsumer action) {
-        // look for a new spliterator
-        while (advanceToNextSpliterator()) {
-          // if we have one, try to read and use it
-          if (next.tryAdvance(action)) {
-            return true;
-          } else {
-            nextStream = null;
-            // failed, null it out so we can find another
-            next = null;
-          }
-        }
-        return false;
-      }
+              @Override
+              public boolean tryAdvance(IntConsumer action) {
+                // look for a new spliterator
+                while (advanceToNextSpliterator()) {
+                  // if we have one, try to read and use it
+                  if (next.tryAdvance(action)) {
+                    return true;
+                  } else {
+                    nextStream = null;
+                    // failed, null it out so we can find another
+                    next = null;
+                  }
+                }
+                return false;
+              }
 
-      private boolean advanceToNextSpliterator() {
-        while (next == null) {
-          if (!spliteratorOfStreams.tryAdvance(n -> {
-            if (n != null) {
-              nextStream = n;
-              next = n.spliterator();
-            }
-          })) {
-            return false;
-          }
-        }
-        return true;
-      }
-    });
+              private boolean advanceToNextSpliterator() {
+                while (next == null) {
+                  if (!spliteratorOfStreams.tryAdvance(
+                      n -> {
+                        if (n != null) {
+                          nextStream = n;
+                          next = n.spliterator();
+                        }
+                      })) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            });
 
     result.onClose(a::close);
     result.onClose(b::close);
@@ -139,32 +141,32 @@
   }
 
   static IntStream generate(final IntSupplier s) {
-    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      @Override
-      public boolean tryAdvance(IntConsumer action) {
-        action.accept(s.getAsInt());
-        return true;
-      }
-    }, false);
+    return StreamSupport.intStream(
+        new Spliterators.AbstractIntSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          @Override
+          public boolean tryAdvance(IntConsumer action) {
+            action.accept(s.getAsInt());
+            return true;
+          }
+        },
+        false);
   }
 
   static IntStream iterate(int seed, IntUnaryOperator f) {
-    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      private int next = seed;
+    return StreamSupport.intStream(
+        new Spliterators.AbstractIntSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private int next = seed;
 
-      @Override
-      public boolean tryAdvance(IntConsumer action) {
-        action.accept(next);
-        next = f.applyAsInt(next);
-        return true;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(IntConsumer action) {
+            action.accept(next);
+            next = f.applyAsInt(next);
+            return true;
+          }
+        },
+        false);
   }
 
   static IntStream of(int... values) {
@@ -173,7 +175,7 @@
 
   static IntStream of(int t) {
     // TODO consider a splittable that returns only a single value
-    return of(new int[]{t});
+    return of(new int[] {t});
   }
 
   static IntStream range(int startInclusive, int endExclusive) {
@@ -189,27 +191,32 @@
     }
     int count = endInclusive - startInclusive + 1;
 
-    return StreamSupport.intStream(new Spliterators.AbstractIntSpliterator(
-        count,
-        Spliterator.IMMUTABLE | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED
-            | Spliterator.SORTED | Spliterator.DISTINCT
-    ) {
-      private int next = startInclusive;
+    return StreamSupport.intStream(
+        new Spliterators.AbstractIntSpliterator(
+            count,
+            Spliterator.IMMUTABLE
+                | Spliterator.SIZED
+                | Spliterator.SUBSIZED
+                | Spliterator.ORDERED
+                | Spliterator.SORTED
+                | Spliterator.DISTINCT) {
+          private int next = startInclusive;
 
-      @Override
-      public Comparator<? super Integer> getComparator() {
-        return null;
-      }
+          @Override
+          public Comparator<? super Integer> getComparator() {
+            return null;
+          }
 
-      @Override
-      public boolean tryAdvance(IntConsumer action) {
-        if (next <= endInclusive) {
-          action.accept(next++);
-          return true;
-        }
-        return false;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(IntConsumer action) {
+            if (next <= endInclusive) {
+              action.accept(next++);
+              return true;
+            }
+            return false;
+          }
+        },
+        false);
   }
 
   /**
@@ -241,7 +248,7 @@
 
   Stream<Integer> boxed();
 
-  <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner);
+  <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner);
 
   long count();
 
@@ -407,9 +414,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         ObjIntConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       return supplier.get();
     }
@@ -544,8 +550,7 @@
     public MapToIntSpliterator(IntUnaryOperator map, Spliterator.OfInt original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -568,8 +573,7 @@
     public MapToObjSpliterator(IntFunction<? extends T> map, Spliterator.OfInt original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -591,8 +595,7 @@
     public MapToLongSpliterator(IntToLongFunction map, Spliterator.OfInt original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -614,8 +617,7 @@
     public MapToDoubleSpliterator(IntToDoubleFunction map, Spliterator.OfInt original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -651,12 +653,14 @@
     @Override
     public boolean tryAdvance(final IntConsumer action) {
       found = false;
-      while (!found && original.tryAdvance((int item) -> {
-        if (filter.test(item)) {
-          found = true;
-          action.accept(item);
-        }
-      })) {
+      while (!found
+          && original.tryAdvance(
+              (int item) -> {
+                if (filter.test(item)) {
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
         // do nothing, work is done in tryAdvance
       }
 
@@ -676,8 +680,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.max(0, original.estimateSize() - skip)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.skip = skip;
       this.original = original;
     }
@@ -690,7 +693,7 @@
     @Override
     public boolean tryAdvance(IntConsumer action) {
       while (skip > 0) {
-        if (!original.tryAdvance((int ignore) -> { })) {
+        if (!original.tryAdvance((int ignore) -> {})) {
           return false;
         }
         skip--;
@@ -712,8 +715,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.min(original.estimateSize(), limit)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.limit = limit;
       this.original = original;
     }
@@ -793,8 +795,7 @@
           IntSummaryStatistics::new,
           // TODO switch to a lambda reference once #9340 is fixed
           (intSummaryStatistics, value) -> intSummaryStatistics.accept(value),
-          IntSummaryStatistics::combine
-      );
+          IntSummaryStatistics::combine);
     }
 
     @Override
@@ -810,7 +811,7 @@
     public long count() {
       terminate();
       long count = 0;
-      while (spliterator.tryAdvance((int value) -> { })) {
+      while (spliterator.tryAdvance((int value) -> {})) {
         count++;
       }
       return count;
@@ -844,9 +845,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         final ObjIntConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, final ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       final R acc = supplier.get();
       spliterator.forEachRemaining((int value) -> accumulator.accept(acc, value));
@@ -868,9 +868,10 @@
       terminate();
       ValueConsumer holder = new ValueConsumer();
       holder.value = identity;
-      spliterator.forEachRemaining((int value) -> {
-        holder.accept(op.applyAsInt(holder.value, value));
-      });
+      spliterator.forEachRemaining(
+          (int value) -> {
+            holder.accept(op.applyAsInt(holder.value, value));
+          });
       return holder.value;
     }
 
@@ -926,9 +927,7 @@
     public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
       throwIfTerminated();
       return new DoubleStream.DoubleStreamSource(
-          this,
-          new MapToDoubleSpliterator(mapper, spliterator)
-      );
+          this, new MapToDoubleSpliterator(mapper, spliterator));
     }
 
     @Override
@@ -936,41 +935,44 @@
       throwIfTerminated();
       final Spliterator<? extends IntStream> spliteratorOfStreams =
           new MapToObjSpliterator<>(mapper, spliterator);
-      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
-        IntStream nextStream;
-        Spliterator.OfInt next;
+      return new IntStreamSource(
+          this,
+          new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE, 0) {
+            IntStream nextStream;
+            Spliterator.OfInt next;
 
-        @Override
-        public boolean tryAdvance(IntConsumer action) {
-          // look for a new spliterator
-          while (advanceToNextSpliterator()) {
-            // if we have one, try to read and use it
-            if (next.tryAdvance(action)) {
-              return true;
-            } else {
-              nextStream.close();
-              nextStream = null;
-              // failed, null it out so we can find another
-              next = null;
-            }
-          }
-          return false;
-        }
-
-        private boolean advanceToNextSpliterator() {
-          while (next == null) {
-            if (!spliteratorOfStreams.tryAdvance(n -> {
-              if (n != null) {
-                nextStream = n;
-                next = n.spliterator();
+            @Override
+            public boolean tryAdvance(IntConsumer action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
               }
-            })) {
               return false;
             }
-          }
-          return true;
-        }
-      });
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          });
     }
 
     @Override
@@ -983,43 +985,43 @@
     @Override
     public IntStream sorted() {
       throwIfTerminated();
-      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics() | Spliterator.SORTED
-      ) {
-        Spliterator.OfInt ordered = null;
+      return new IntStreamSource(
+          this,
+          new Spliterators.AbstractIntSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+            Spliterator.OfInt ordered = null;
 
-        @Override
-        public Comparator<? super Integer> getComparator() {
-          return null;
-        }
+            @Override
+            public Comparator<? super Integer> getComparator() {
+              return null;
+            }
 
-        @Override
-        public boolean tryAdvance(IntConsumer action) {
-          if (ordered == null) {
-            int[] list = new int[0];
-            spliterator.forEachRemaining((int item) -> list[list.length] = item);
-            Arrays.sort(list);
-            ordered = Spliterators.spliterator(list, characteristics());
-          }
-          return ordered.tryAdvance(action);
-        }
-      });
+            @Override
+            public boolean tryAdvance(IntConsumer action) {
+              if (ordered == null) {
+                int[] list = new int[0];
+                spliterator.forEachRemaining((int item) -> list[list.length] = item);
+                Arrays.sort(list);
+                ordered = Spliterators.spliterator(list, characteristics());
+              }
+              return ordered.tryAdvance(action);
+            }
+          });
     }
 
     @Override
     public IntStream peek(IntConsumer action) {
       checkNotNull(action);
       throwIfTerminated();
-      return new IntStreamSource(this, new Spliterators.AbstractIntSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics()
-      ) {
-        @Override
-        public boolean tryAdvance(final IntConsumer innerAction) {
-          return spliterator.tryAdvance(action.andThen(innerAction));
-        }
-      });
+      return new IntStreamSource(
+          this,
+          new Spliterators.AbstractIntSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics()) {
+            @Override
+            public boolean tryAdvance(final IntConsumer innerAction) {
+              return spliterator.tryAdvance(action.andThen(innerAction));
+            }
+          });
     }
 
     @Override
diff --git a/user/super/com/google/gwt/emul/java/util/stream/LongStream.java b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
index f2b6ba1..f012aea 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/LongStream.java
@@ -48,7 +48,7 @@
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/LongStream.html">
  * the official Java API doc</a> for details.
  */
-public interface LongStream extends BaseStream<Long,LongStream> {
+public interface LongStream extends BaseStream<Long, LongStream> {
 
   /**
    * Value holder for various stream operations.
@@ -90,43 +90,45 @@
 
     // TODO replace this flatMap-ish spliterator with one that directly combines the two root
     // streams
-    Spliterator<? extends LongStream> spliteratorOfStreams =
-        Arrays.asList(a, b).spliterator();
-    LongStream result = new LongStreamSource(null, new Spliterators.AbstractLongSpliterator(Long
-        .MAX_VALUE, 0) {
-      LongStream nextStream;
-      Spliterator.OfLong next;
+    Spliterator<? extends LongStream> spliteratorOfStreams = Arrays.asList(a, b).spliterator();
+    LongStream result =
+        new LongStreamSource(
+            null,
+            new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
+              LongStream nextStream;
+              Spliterator.OfLong next;
 
-      @Override
-      public boolean tryAdvance(LongConsumer action) {
-        // look for a new spliterator
-        while (advanceToNextSpliterator()) {
-          // if we have one, try to read and use it
-          if (next.tryAdvance(action)) {
-            return true;
-          } else {
-            nextStream = null;
-            // failed, null it out so we can find another
-            next = null;
-          }
-        }
-        return false;
-      }
+              @Override
+              public boolean tryAdvance(LongConsumer action) {
+                // look for a new spliterator
+                while (advanceToNextSpliterator()) {
+                  // if we have one, try to read and use it
+                  if (next.tryAdvance(action)) {
+                    return true;
+                  } else {
+                    nextStream = null;
+                    // failed, null it out so we can find another
+                    next = null;
+                  }
+                }
+                return false;
+              }
 
-      private boolean advanceToNextSpliterator() {
-        while (next == null) {
-          if (!spliteratorOfStreams.tryAdvance(n -> {
-            if (n != null) {
-              nextStream = n;
-              next = n.spliterator();
-            }
-          })) {
-            return false;
-          }
-        }
-        return true;
-      }
-    });
+              private boolean advanceToNextSpliterator() {
+                while (next == null) {
+                  if (!spliteratorOfStreams.tryAdvance(
+                      n -> {
+                        if (n != null) {
+                          nextStream = n;
+                          next = n.spliterator();
+                        }
+                      })) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            });
 
     result.onClose(a::close);
     result.onClose(b::close);
@@ -139,32 +141,32 @@
   }
 
   static LongStream generate(LongSupplier s) {
-    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      @Override
-      public boolean tryAdvance(LongConsumer action) {
-        action.accept(s.getAsLong());
-        return true;
-      }
-    }, false);
+    return StreamSupport.longStream(
+        new Spliterators.AbstractLongSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          @Override
+          public boolean tryAdvance(LongConsumer action) {
+            action.accept(s.getAsLong());
+            return true;
+          }
+        },
+        false);
   }
 
   static LongStream iterate(long seed, LongUnaryOperator f) {
-    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
-        Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED
-    ) {
-      private long next = seed;
+    return StreamSupport.longStream(
+        new Spliterators.AbstractLongSpliterator(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private long next = seed;
 
-      @Override
-      public boolean tryAdvance(LongConsumer action) {
-        action.accept(next);
-        next = f.applyAsLong(next);
-        return true;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(LongConsumer action) {
+            action.accept(next);
+            next = f.applyAsLong(next);
+            return true;
+          }
+        },
+        false);
   }
 
   static LongStream of(long... values) {
@@ -173,7 +175,7 @@
 
   static LongStream of(long t) {
     // TODO consider a splittable that returns only a single value
-    return of(new long[]{t});
+    return of(new long[] {t});
   }
 
   static LongStream range(long startInclusive, long endExclusive) {
@@ -189,27 +191,32 @@
     }
     long count = endInclusive - startInclusive + 1;
 
-    return StreamSupport.longStream(new Spliterators.AbstractLongSpliterator(
-        count,
-        Spliterator.IMMUTABLE | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED
-            | Spliterator.SORTED | Spliterator.DISTINCT
-    ) {
-      private long next = startInclusive;
+    return StreamSupport.longStream(
+        new Spliterators.AbstractLongSpliterator(
+            count,
+            Spliterator.IMMUTABLE
+                | Spliterator.SIZED
+                | Spliterator.SUBSIZED
+                | Spliterator.ORDERED
+                | Spliterator.SORTED
+                | Spliterator.DISTINCT) {
+          private long next = startInclusive;
 
-      @Override
-      public Comparator<? super Long> getComparator() {
-        return null;
-      }
+          @Override
+          public Comparator<? super Long> getComparator() {
+            return null;
+          }
 
-      @Override
-      public boolean tryAdvance(LongConsumer action) {
-        if (next <= endInclusive) {
-          action.accept(next++);
-          return true;
-        }
-        return false;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(LongConsumer action) {
+            if (next <= endInclusive) {
+              action.accept(next++);
+              return true;
+            }
+            return false;
+          }
+        },
+        false);
   }
 
   /**
@@ -403,9 +410,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         ObjLongConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       return supplier.get();
     }
@@ -534,8 +540,7 @@
     public MapToIntSpliterator(LongToIntFunction map, Spliterator.OfLong original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -558,8 +563,7 @@
     public MapToObjSpliterator(LongFunction<? extends T> map, Spliterator.OfLong original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -581,8 +585,7 @@
     public MapToLongSpliterator(LongUnaryOperator map, Spliterator.OfLong original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -604,8 +607,7 @@
     public MapToDoubleSpliterator(LongToDoubleFunction map, Spliterator.OfLong original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -641,12 +643,14 @@
     @Override
     public boolean tryAdvance(final LongConsumer action) {
       found = false;
-      while (!found && original.tryAdvance((long item) -> {
-        if (filter.test(item)) {
-          found = true;
-          action.accept(item);
-        }
-      })) {
+      while (!found
+          && original.tryAdvance(
+              (long item) -> {
+                if (filter.test(item)) {
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
         // do nothing, work is done in tryAdvance
       }
 
@@ -666,8 +670,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.max(0, original.estimateSize() - skip)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.skip = skip;
       this.original = original;
     }
@@ -680,7 +683,7 @@
     @Override
     public boolean tryAdvance(LongConsumer action) {
       while (skip > 0) {
-        if (!original.tryAdvance((long ignore) -> { })) {
+        if (!original.tryAdvance((long ignore) -> {})) {
           return false;
         }
         skip--;
@@ -702,8 +705,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.min(original.estimateSize(), limit)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.limit = limit;
       this.original = original;
     }
@@ -764,9 +766,10 @@
       terminate();
       ValueConsumer holder = new ValueConsumer();
       holder.value = identity;
-      spliterator.forEachRemaining((long value) -> {
-        holder.accept(op.applyAsLong(holder.value, value));
-      });
+      spliterator.forEachRemaining(
+          (long value) -> {
+            holder.accept(op.applyAsLong(holder.value, value));
+          });
       return holder.value;
     }
 
@@ -781,9 +784,8 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         ObjLongConsumer<R> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       final R acc = supplier.get();
       spliterator.forEachRemaining((long value) -> accumulator.accept(acc, value));
@@ -821,7 +823,7 @@
     public long count() {
       terminate();
       long count = 0;
-      while (spliterator.tryAdvance((long value) -> { })) {
+      while (spliterator.tryAdvance((long value) -> {})) {
         count++;
       }
       return count;
@@ -842,8 +844,7 @@
           LongSummaryStatistics::new,
           // TODO switch to a lambda reference once #9340 is fixed
           (longSummaryStatistics, value) -> longSummaryStatistics.accept(value),
-          LongSummaryStatistics::combine
-      );
+          LongSummaryStatistics::combine);
     }
 
     @Override
@@ -916,23 +917,18 @@
     @Override
     public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
       throwIfTerminated();
-      return new DoubleStream.DoubleStreamSource(this, new MapToDoubleSpliterator(
-          mapper,
-          spliterator)
-      );
+      return new DoubleStream.DoubleStreamSource(
+          this, new MapToDoubleSpliterator(mapper, spliterator));
     }
 
     @Override
     public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
       throwIfTerminated();
-      final Spliterator<? extends LongStream> spliteratorOfStreams = new MapToObjSpliterator<>(
-          mapper,
-          spliterator
-      );
+      final Spliterator<? extends LongStream> spliteratorOfStreams =
+          new MapToObjSpliterator<>(mapper, spliterator);
       return new LongStreamSource(
           this,
-          new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0
-          ) {
+          new Spliterators.AbstractLongSpliterator(Long.MAX_VALUE, 0) {
             LongStream nextStream;
             Spliterator.OfLong next;
 
@@ -955,12 +951,13 @@
 
             private boolean advanceToNextSpliterator() {
               while (next == null) {
-                if (!spliteratorOfStreams.tryAdvance(n -> {
-                  if (n != null) {
-                    nextStream = n;
-                    next = n.spliterator();
-                  }
-                })) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
                   return false;
                 }
               }
@@ -979,43 +976,43 @@
     @Override
     public LongStream sorted() {
       throwIfTerminated();
-      return new LongStreamSource(this, new Spliterators.AbstractLongSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics() | Spliterator.SORTED
-      ) {
-        Spliterator.OfLong ordered = null;
+      return new LongStreamSource(
+          this,
+          new Spliterators.AbstractLongSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
+            Spliterator.OfLong ordered = null;
 
-        @Override
-        public Comparator<? super Long> getComparator() {
-          return null;
-        }
+            @Override
+            public Comparator<? super Long> getComparator() {
+              return null;
+            }
 
-        @Override
-        public boolean tryAdvance(LongConsumer action) {
-          if (ordered == null) {
-            long[] list = new long[0];
-            spliterator.forEachRemaining((long item) -> list[list.length] = item);
-            Arrays.sort(list);
-            ordered = Spliterators.spliterator(list, characteristics());
-          }
-          return ordered.tryAdvance(action);
-        }
-      });
+            @Override
+            public boolean tryAdvance(LongConsumer action) {
+              if (ordered == null) {
+                long[] list = new long[0];
+                spliterator.forEachRemaining((long item) -> list[list.length] = item);
+                Arrays.sort(list);
+                ordered = Spliterators.spliterator(list, characteristics());
+              }
+              return ordered.tryAdvance(action);
+            }
+          });
     }
 
     @Override
     public LongStream peek(LongConsumer action) {
       checkNotNull(action);
       throwIfTerminated();
-      return new LongStreamSource(this, new Spliterators.AbstractLongSpliterator(
-          spliterator.estimateSize(),
-          spliterator.characteristics()
-      ) {
-        @Override
-        public boolean tryAdvance(final LongConsumer innerAction) {
-          return spliterator.tryAdvance(action.andThen(innerAction));
-        }
-      });
+      return new LongStreamSource(
+          this,
+          new Spliterators.AbstractLongSpliterator(
+              spliterator.estimateSize(), spliterator.characteristics()) {
+            @Override
+            public boolean tryAdvance(final LongConsumer innerAction) {
+              return spliterator.tryAdvance(action.andThen(innerAction));
+            }
+          });
     }
 
     @Override
diff --git a/user/super/com/google/gwt/emul/java/util/stream/Stream.java b/user/super/com/google/gwt/emul/java/util/stream/Stream.java
index b61486d..d4b8dca 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/Stream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/Stream.java
@@ -96,41 +96,44 @@
     // streams
     Spliterator<? extends Stream<? extends T>> spliteratorOfStreams =
         Arrays.asList(a, b).spliterator();
-    Stream<T> result = new StreamSource<T>(null, new Spliterators.AbstractSpliterator<T>(Long
-        .MAX_VALUE, 0) {
-      Stream<? extends T> nextStream;
-      Spliterator<? extends T> next;
+    Stream<T> result =
+        new StreamSource<T>(
+            null,
+            new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE, 0) {
+              Stream<? extends T> nextStream;
+              Spliterator<? extends T> next;
 
-      @Override
-      public boolean tryAdvance(Consumer<? super T> action) {
-        // look for a new spliterator
-        while (advanceToNextSpliterator()) {
-          // if we have one, try to read and use it
-          if (next.tryAdvance(action)) {
-            return true;
-          } else {
-            nextStream = null;
-            // failed, null it out so we can find another
-            next = null;
-          }
-        }
-        return false;
-      }
+              @Override
+              public boolean tryAdvance(Consumer<? super T> action) {
+                // look for a new spliterator
+                while (advanceToNextSpliterator()) {
+                  // if we have one, try to read and use it
+                  if (next.tryAdvance(action)) {
+                    return true;
+                  } else {
+                    nextStream = null;
+                    // failed, null it out so we can find another
+                    next = null;
+                  }
+                }
+                return false;
+              }
 
-      private boolean advanceToNextSpliterator() {
-        while (next == null) {
-          if (!spliteratorOfStreams.tryAdvance(n -> {
-            if (n != null) {
-              nextStream = n;
-              next = n.spliterator();
-            }
-          })) {
-            return false;
-          }
-        }
-        return true;
-      }
-    });
+              private boolean advanceToNextSpliterator() {
+                while (next == null) {
+                  if (!spliteratorOfStreams.tryAdvance(
+                      n -> {
+                        if (n != null) {
+                          nextStream = n;
+                          next = n.spliterator();
+                        }
+                      })) {
+                    return false;
+                  }
+                }
+                return true;
+              }
+            });
 
     result.onClose(a::close);
     result.onClose(b::close);
@@ -143,28 +146,32 @@
   }
 
   static <T> Stream<T> generate(Supplier<T> s) {
-    return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED) {
-      @Override
-      public boolean tryAdvance(Consumer<? super T> action) {
-        action.accept(s.get());
-        return true;
-      }
-    }, false);
+    return StreamSupport.stream(
+        new Spliterators.AbstractSpliterator<T>(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          @Override
+          public boolean tryAdvance(Consumer<? super T> action) {
+            action.accept(s.get());
+            return true;
+          }
+        },
+        false);
   }
 
   static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {
-    return StreamSupport.stream(new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
-        Spliterator.IMMUTABLE | Spliterator.ORDERED) {
-      private T next = seed;
+    return StreamSupport.stream(
+        new Spliterators.AbstractSpliterator<T>(
+            Long.MAX_VALUE, Spliterator.IMMUTABLE | Spliterator.ORDERED) {
+          private T next = seed;
 
-      @Override
-      public boolean tryAdvance(Consumer<? super T> action) {
-        action.accept(next);
-        next = f.apply(next);
-        return true;
-      }
-    }, false);
+          @Override
+          public boolean tryAdvance(Consumer<? super T> action) {
+            action.accept(next);
+            next = f.apply(next);
+            return true;
+          }
+        },
+        false);
   }
 
   static <T> Stream<T> of(T t) {
@@ -197,11 +204,10 @@
 
   boolean anyMatch(Predicate<? super T> predicate);
 
-  <R,A> R collect(Collector<? super T,A,R> collector);
+  <R, A> R collect(Collector<? super T, A, R> collector);
 
-  <R> R collect(Supplier<R> supplier,
-                BiConsumer<R,? super T> accumulator,
-                BiConsumer<R,R> combiner);
+  <R> R collect(
+      Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
 
   long count();
 
@@ -213,13 +219,13 @@
 
   Optional<T> findFirst();
 
-  <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper);
+  <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
 
-  DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper);
+  DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
 
-  IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper);
+  IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
 
-  LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper);
+  LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
 
   void forEach(Consumer<? super T> action);
 
@@ -227,7 +233,7 @@
 
   Stream<T> limit(long maxSize);
 
-  <R> Stream<R> map(Function<? super T,? extends R> mapper);
+  <R> Stream<R> map(Function<? super T, ? extends R> mapper);
 
   DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
 
@@ -247,7 +253,7 @@
 
   T reduce(T identity, BinaryOperator<T> accumulator);
 
-  <U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner);
+  <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
 
   Stream<T> skip(long n);
 
@@ -270,13 +276,13 @@
     }
 
     @Override
-    public  Stream<T> filter(Predicate<? super T> predicate) {
+    public Stream<T> filter(Predicate<? super T> predicate) {
       throwIfTerminated();
       return this;
     }
 
     @Override
-    public <R>  Stream<R> map(Function<? super T, ? extends R> mapper) {
+    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
       throwIfTerminated();
       return (Stream) this;
     }
@@ -300,7 +306,7 @@
     }
 
     @Override
-    public <R> Stream<R> flatMap(Function<? super T, ? extends  Stream<? extends R>> mapper) {
+    public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
       throwIfTerminated();
       return (Stream) this;
     }
@@ -398,17 +404,15 @@
     }
 
     @Override
-    public <U> U reduce(U identity,
-                        BiFunction<U, ? super T, U> accumulator,
-                        BinaryOperator<U> combiner) {
+    public <U> U reduce(
+        U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
       terminate();
       return identity;
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         BiConsumer<R, ? super T> accumulator,
-                         BiConsumer<R, R> combiner) {
+    public <R> R collect(
+        Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
       terminate();
       return supplier.get();
     }
@@ -516,8 +520,7 @@
     public MapToObjSpliterator(Function<? super U, ? extends T> map, Spliterator<U> original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -540,8 +543,7 @@
     public MapToIntSpliterator(ToIntFunction<? super T> map, Spliterator<T> original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -564,8 +566,7 @@
     public MapToLongSpliterator(ToLongFunction<? super T> map, Spliterator<T> original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -588,8 +589,7 @@
     public MapToDoubleSpliterator(ToDoubleFunction<? super T> map, Spliterator<T> original) {
       super(
           original.estimateSize(),
-          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT)
-      );
+          original.characteristics() & ~(Spliterator.SORTED | Spliterator.DISTINCT));
       checkNotNull(map);
       this.map = map;
       this.original = original;
@@ -626,12 +626,14 @@
     @Override
     public boolean tryAdvance(final Consumer<? super T> action) {
       found = false;
-      while (!found && original.tryAdvance(item -> {
-        if (filter.test(item)) {
-          found = true;
-          action.accept(item);
-        }
-      })) {
+      while (!found
+          && original.tryAdvance(
+              item -> {
+                if (filter.test(item)) {
+                  found = true;
+                  action.accept(item);
+                }
+              })) {
         // do nothing, work is done in tryAdvance
       }
 
@@ -652,8 +654,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.max(0, original.estimateSize() - skip)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.skip = skip;
       this.original = original;
     }
@@ -666,7 +667,7 @@
     @Override
     public boolean tryAdvance(Consumer<? super T> action) {
       while (skip > 0) {
-        if (!original.tryAdvance(ignore -> { })) {
+        if (!original.tryAdvance(ignore -> {})) {
           return false;
         }
         skip--;
@@ -689,8 +690,7 @@
           original.hasCharacteristics(Spliterator.SIZED)
               ? Math.min(original.estimateSize(), limit)
               : Long.MAX_VALUE,
-          original.characteristics()
-      );
+          original.characteristics());
       this.limit = limit;
       this.original = original;
     }
@@ -739,7 +739,7 @@
     public long count() {
       terminate();
       long count = 0;
-      while (spliterator.tryAdvance(a -> { })) {
+      while (spliterator.tryAdvance(a -> {})) {
         count++;
       }
       return count;
@@ -768,25 +768,30 @@
     }
 
     @Override
-    public <R> R collect(Supplier<R> supplier,
-                         BiConsumer<R, ? super T> accumulator,
-                         BiConsumer<R, R> combiner) {
-      return collect(Collector.of(supplier, accumulator, (a, b) -> {
-        combiner.accept(a, b);
-        return a;
-      }));
+    public <R> R collect(
+        Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+      return collect(
+          Collector.of(
+              supplier,
+              accumulator,
+              (a, b) -> {
+                combiner.accept(a, b);
+                return a;
+              }));
     }
 
     @Override
     public <R, A> R collect(final Collector<? super T, A, R> collector) {
-      return collector.finisher().apply(reduce(
-          collector.supplier().get(),
-          (a, t) -> {
-            collector.accumulator().accept(a, t);
-            return a;
-          },
-          collector.combiner()
-      ));
+      return collector
+          .finisher()
+          .apply(
+              reduce(
+                  collector.supplier().get(),
+                  (a, t) -> {
+                    collector.accumulator().accept(a, t);
+                    return a;
+                  },
+                  collector.combiner()));
     }
 
     @Override
@@ -846,15 +851,15 @@
 
     // combiner is ignored, since we don't parallelize
     @Override
-    public <U> U reduce(U identity,
-                        BiFunction<U, ? super T, U> accumulator,
-                        BinaryOperator<U> combiner) {
+    public <U> U reduce(
+        U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
       terminate();
       final ValueConsumer<U> consumer = new ValueConsumer<U>();
       consumer.value = identity;
-      spliterator.forEachRemaining(item -> {
-        consumer.accept(accumulator.apply(consumer.value, item));
-      });
+      spliterator.forEachRemaining(
+          item -> {
+            consumer.accept(accumulator.apply(consumer.value, item));
+          });
       return consumer.value;
     }
     // end terminal
@@ -888,9 +893,7 @@
     public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
       throwIfTerminated();
       return new DoubleStream.DoubleStreamSource(
-          this,
-          new MapToDoubleSpliterator<>(mapper, spliterator)
-      );
+          this, new MapToDoubleSpliterator<>(mapper, spliterator));
     }
 
     @Override
@@ -898,41 +901,44 @@
       throwIfTerminated();
       final Spliterator<? extends Stream<? extends R>> spliteratorOfStreams =
           new MapToObjSpliterator<>(mapper, spliterator);
-      return new StreamSource<R>(this, new Spliterators.AbstractSpliterator<R>(Long.MAX_VALUE, 0) {
-        Stream<? extends R> nextStream;
-        Spliterator<? extends R> next;
+      return new StreamSource<R>(
+          this,
+          new Spliterators.AbstractSpliterator<R>(Long.MAX_VALUE, 0) {
+            Stream<? extends R> nextStream;
+            Spliterator<? extends R> next;
 
-        @Override
-        public boolean tryAdvance(Consumer<? super R> action) {
-          // look for a new spliterator
-          while (advanceToNextSpliterator()) {
-            // if we have one, try to read and use it
-            if (next.tryAdvance(action)) {
-              return true;
-            } else {
-              nextStream.close();
-              nextStream = null;
-              // failed, null it out so we can find another
-              next = null;
-            }
-          }
-          return false;
-        }
-
-        private boolean advanceToNextSpliterator() {
-          while (next == null) {
-            if (!spliteratorOfStreams.tryAdvance(n -> {
-              if (n != null) {
-                nextStream = n;
-                next = n.spliterator();
+            @Override
+            public boolean tryAdvance(Consumer<? super R> action) {
+              // look for a new spliterator
+              while (advanceToNextSpliterator()) {
+                // if we have one, try to read and use it
+                if (next.tryAdvance(action)) {
+                  return true;
+                } else {
+                  nextStream.close();
+                  nextStream = null;
+                  // failed, null it out so we can find another
+                  next = null;
+                }
               }
-            })) {
               return false;
             }
-          }
-          return true;
-        }
-      });
+
+            private boolean advanceToNextSpliterator() {
+              while (next == null) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          });
     }
 
     @Override
@@ -965,19 +971,19 @@
 
             private boolean advanceToNextSpliterator() {
               while (next == null) {
-                if (!spliteratorOfStreams.tryAdvance(n -> {
-                  if (n != null) {
-                    nextStream = n;
-                    next = n.spliterator();
-                  }
-                })) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
                   return false;
                 }
               }
               return true;
             }
-          }
-      );
+          });
     }
 
     @Override
@@ -1010,19 +1016,19 @@
 
             private boolean advanceToNextSpliterator() {
               while (next == null) {
-                if (!spliteratorOfStreams.tryAdvance(n -> {
-                  if (n != null) {
-                    nextStream = n;
-                    next = n.spliterator();
-                  }
-                })) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
                   return false;
                 }
               }
               return true;
             }
-          }
-      );
+          });
     }
 
     @Override
@@ -1055,19 +1061,19 @@
 
             private boolean advanceToNextSpliterator() {
               while (next == null) {
-                if (!spliteratorOfStreams.tryAdvance(n -> {
-                  if (n != null) {
-                    nextStream = n;
-                    next = n.spliterator();
-                  }
-                })) {
+                if (!spliteratorOfStreams.tryAdvance(
+                    n -> {
+                      if (n != null) {
+                        nextStream = n;
+                        next = n.spliterator();
+                      }
+                    })) {
                   return false;
                 }
               }
               return true;
             }
-          }
-      );
+          });
     }
 
     @Override
@@ -1090,9 +1096,7 @@
       return new StreamSource<>(
           this,
           new Spliterators.AbstractSpliterator<T>(
-              spliterator.estimateSize(),
-              spliterator.characteristics() | Spliterator.SORTED
-          ) {
+              spliterator.estimateSize(), spliterator.characteristics() | Spliterator.SORTED) {
             Spliterator<T> ordered = null;
 
             @Override
@@ -1110,8 +1114,7 @@
               }
               return ordered.tryAdvance(action);
             }
-          }
-      );
+          });
     }
 
     @Override
@@ -1121,18 +1124,16 @@
       return new StreamSource<>(
           this,
           new Spliterators.AbstractSpliterator<T>(
-              spliterator.estimateSize(),
-              spliterator.characteristics()
-          ) {
+              spliterator.estimateSize(), spliterator.characteristics()) {
             @Override
             public boolean tryAdvance(final Consumer<? super T> innerAction) {
-              return spliterator.tryAdvance(item -> {
-                action.accept(item);
-                innerAction.accept(item);
-              });
+              return spliterator.tryAdvance(
+                  item -> {
+                    action.accept(item);
+                    innerAction.accept(item);
+                  });
             }
-          }
-      );
+          });
     }
 
     @Override
diff --git a/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
index 12b34e3..0c64d9e 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/StreamSupport.java
@@ -29,56 +29,65 @@
     return new DoubleStream.DoubleStreamSource(null, spliterator);
   }
 
-  public static DoubleStream doubleStream(Supplier<? extends Spliterator.OfDouble> supplier,
-                                          int characteristics,
-                                          boolean parallel) {
+  public static DoubleStream doubleStream(
+      Supplier<? extends Spliterator.OfDouble> supplier, int characteristics, boolean parallel) {
     // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
-    return Stream.of(supplier).map(Supplier::get).flatMapToDouble(doubleSpliterator -> {
-      return doubleStream(doubleSpliterator, parallel);
-    });
+    return Stream.of(supplier)
+        .map(Supplier::get)
+        .flatMapToDouble(
+            doubleSpliterator -> {
+              return doubleStream(doubleSpliterator, parallel);
+            });
   }
 
   public static IntStream intStream(Spliterator.OfInt spliterator, boolean parallel) {
     return new IntStream.IntStreamSource(null, spliterator);
   }
 
-  public static IntStream intStream(Supplier<? extends Spliterator.OfInt> supplier,
-                                    int characteristics,
-                                    boolean parallel) {
+  public static IntStream intStream(
+      Supplier<? extends Spliterator.OfInt> supplier, int characteristics, boolean parallel) {
     // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
-    return Stream.of(supplier).map(Supplier::get).flatMapToInt(intSpliterator -> {
-      return intStream(intSpliterator, parallel);
-    });
+    return Stream.of(supplier)
+        .map(Supplier::get)
+        .flatMapToInt(
+            intSpliterator -> {
+              return intStream(intSpliterator, parallel);
+            });
   }
 
   public static LongStream longStream(Spliterator.OfLong spliterator, boolean parallel) {
     return new LongStream.LongStreamSource(null, spliterator);
   }
 
-  public static LongStream longStream(Supplier<? extends Spliterator.OfLong> supplier,
-                                      int characteristics,
-                                      final boolean parallel) {
+  public static LongStream longStream(
+      Supplier<? extends Spliterator.OfLong> supplier,
+      int characteristics,
+      final boolean parallel) {
     // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
-    return Stream.of(supplier).map(Supplier::get).flatMapToLong(longSpliterator -> {
-      return longStream(longSpliterator, parallel);
-    });
+    return Stream.of(supplier)
+        .map(Supplier::get)
+        .flatMapToLong(
+            longSpliterator -> {
+              return longStream(longSpliterator, parallel);
+            });
   }
 
   public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
     return new Stream.StreamSource<T>(null, spliterator);
   }
 
-  public static <T> Stream<T> stream(Supplier<? extends Spliterator<T>> supplier,
-                                     int characteristics,
-                                     final boolean parallel) {
+  public static <T> Stream<T> stream(
+      Supplier<? extends Spliterator<T>> supplier, int characteristics, final boolean parallel) {
     // TODO this is somewhat convoluted, and would be better served by a lazy singleton spliterator
-    return Stream.of(supplier).map(Supplier::get).flatMap(spliterator -> {
-      return stream(spliterator, parallel);
-    });
+    return Stream.of(supplier)
+        .map(Supplier::get)
+        .flatMap(
+            spliterator -> {
+              return stream(spliterator, parallel);
+            });
   }
 
   private StreamSupport() {
     // prevent instantiation
   }
-
 }
diff --git a/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java b/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java
index b78b41f..8901f1c 100644
--- a/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java
+++ b/user/super/com/google/gwt/emul/java/util/stream/TerminatableStream.java
@@ -76,13 +76,14 @@
 
   private void runClosers() {
     ArrayList<Throwable> throwables = new ArrayList<>();
-    onClose.forEach(runnable -> {
-      try {
-        runnable.run();
-      } catch (Throwable e) {
-        throwables.add(e);
-      }
-    });
+    onClose.forEach(
+        runnable -> {
+          try {
+            runnable.run();
+          } catch (Throwable e) {
+            throwables.add(e);
+          }
+        });
     onClose.clear();
 
     if (!throwables.isEmpty()) {
@@ -103,4 +104,4 @@
       assert false : "Couldn't have caught this exception from a Runnable! " + e;
     }
   }
-}
\ No newline at end of file
+}
diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java
index fb0cc17..f8f6715 100644
--- a/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/DoubleStreamTest.java
@@ -61,23 +61,16 @@
 
   public void testStreamOfOne() {
     Supplier<DoubleStream> one = () -> DoubleStream.of(1);
-    assertEquals(new double[]{1d}, one.get().toArray());
+    assertEquals(new double[] {1d}, one.get().toArray());
     assertEquals(1L, one.get().count());
     assertEquals(1d, one.get().findFirst().getAsDouble(), 0d);
     assertEquals(1d, one.get().findAny().getAsDouble(), 0d);
   }
 
   public void testBuilder() {
-    DoubleStream s = DoubleStream.builder()
-        .add(1d)
-        .add(3d)
-        .add(2d)
-        .build();
+    DoubleStream s = DoubleStream.builder().add(1d).add(3d).add(2d).build();
 
-    assertEquals(
-        new double[] {1d, 3d, 2d},
-        s.toArray()
-    );
+    assertEquals(new double[] {1d, 3d, 2d}, s.toArray());
 
     DoubleStream.Builder builder = DoubleStream.builder();
     DoubleStream built = builder.build();
@@ -97,12 +90,13 @@
   }
 
   public void testConcat() {
-    Supplier<DoubleStream> adbc = () -> {
-      return DoubleStream.concat(DoubleStream.of(1, 4), DoubleStream.of(2, 3));
-    };
+    Supplier<DoubleStream> adbc =
+        () -> {
+          return DoubleStream.concat(DoubleStream.of(1, 4), DoubleStream.of(2, 3));
+        };
 
-    assertEquals(new double[]{1d, 4d, 2d, 3d}, adbc.get().toArray());
-    assertEquals(new double[]{1d, 2d, 3d, 4d}, adbc.get().sorted().toArray());
+    assertEquals(new double[] {1d, 4d, 2d, 3d}, adbc.get().toArray());
+    assertEquals(new double[] {1d, 2d, 3d, 4d}, adbc.get().sorted().toArray());
 
     List<String> closed = new ArrayList<>();
     DoubleStream first = DoubleStream.of(1d).onClose(() -> closed.add("first"));
@@ -121,12 +115,8 @@
 
   public void testIterate() {
     assertEquals(
-        new double[]{10d, 11d, 12d, 13d, 14d},
-        DoubleStream.iterate(0d, l -> l + 1d)
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        new double[] {10d, 11d, 12d, 13d, 14d},
+        DoubleStream.iterate(0d, l -> l + 1d).skip(10).limit(5).toArray());
   }
 
   public void testGenerate() {
@@ -134,12 +124,8 @@
     assertEquals(new double[0], DoubleStream.generate(makeGenerator()).limit(4).skip(5).toArray());
 
     assertEquals(
-        new double[]{10d, 11d, 12d, 13d, 14d},
-        DoubleStream.generate(makeGenerator())
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        new double[] {10d, 11d, 12d, 13d, 14d},
+        DoubleStream.generate(makeGenerator()).skip(10).limit(5).toArray());
   }
 
   private DoubleSupplier makeGenerator() {
@@ -181,24 +167,17 @@
 
     // one result
     assertEquals(
-        new double[]{1d},
-        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a == 1).toArray()
-    );
+        new double[] {1d}, DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a == 1).toArray());
     // zero results
-    assertEquals(
-        new double[0],
-        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> false).toArray()
-    );
+    assertEquals(new double[0], DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> false).toArray());
     // two results
     assertEquals(
         new double[] {2d, 4d},
-        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a % 2 == 0).toArray()
-    );
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> a % 2 == 0).toArray());
     // all
     assertEquals(
         new double[] {1d, 2d, 3d, 4d, 3d},
-        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> true).toArray()
-    );
+        DoubleStream.of(1d, 2d, 3d, 4d, 3d).filter(a -> true).toArray());
   }
 
   public void testMap() {
@@ -207,10 +186,7 @@
     DoubleStream.of(1d, 2d, 3d).map(i -> data[0]++);
     assertEquals(0, data[0]);
 
-    assertEquals(
-        new double[] {2d, 4d, 6d},
-        DoubleStream.of(1d, 2d, 3d).map(i -> i * 2).toArray()
-    );
+    assertEquals(new double[] {2d, 4d, 6d}, DoubleStream.of(1d, 2d, 3d).map(i -> i * 2).toArray());
   }
 
   public void testPeek() {
@@ -222,9 +198,12 @@
     // make sure we saw it all in order
     double[] items = new double[] {1d, 2d, 3d};
     List<Double> peeked = new ArrayList<>();
-    DoubleStream.of(items).peek(peeked::add).forEach(item -> {
-      // do nothing, just run
-    });
+    DoubleStream.of(items)
+        .peek(peeked::add)
+        .forEach(
+            item -> {
+              // do nothing, just run
+            });
     assertEquals(items.length, peeked.size());
     for (int i = 0; i < items.length; i++) {
       assertEquals(items[i], peeked.get(i), 0d);
@@ -282,27 +261,19 @@
 
     assertEquals(
         new double[] {1d, 2d, 2d, 4d, 3d, 6d},
-        values.flatMap(i -> DoubleStream.of(i, i * 2d)).toArray()
-    );
+        values.flatMap(i -> DoubleStream.of(i, i * 2d)).toArray());
   }
 
   public void testMapToOthers() {
     Supplier<DoubleStream> s = () -> DoubleStream.of(1d, 2d, 10d);
 
     assertEquals(
-        new String[]{"1", "2", "10"},
-        s.get().mapToObj(DoubleStreamTest::toIntegralString).toArray(String[]::new)
-    );
+        new String[] {"1", "2", "10"},
+        s.get().mapToObj(DoubleStreamTest::toIntegralString).toArray(String[]::new));
 
-    assertEquals(
-        new long[]{1L, 2L, 10L},
-        s.get().mapToLong(i -> (long) i).toArray()
-    );
+    assertEquals(new long[] {1L, 2L, 10L}, s.get().mapToLong(i -> (long) i).toArray());
 
-    assertEquals(
-        new int[] {1, 2, 10},
-        s.get().mapToInt(i -> (int) i).toArray()
-    );
+    assertEquals(new int[] {1, 2, 10}, s.get().mapToInt(i -> (int) i).toArray());
   }
 
   public void testDistinct() {
@@ -398,9 +369,13 @@
 
   public void testCollect() {
     // noinspection StringConcatenationInsideStringBufferAppend
-    String val = DoubleStream.of(1d, 2d, 3d, 4d, 5d).collect(StringBuilder::new,
-        (stringBuilder, d) -> stringBuilder.append(toIntegralString(d)),
-        StringBuilder::append).toString();
+    String val =
+        DoubleStream.of(1d, 2d, 3d, 4d, 5d)
+            .collect(
+                StringBuilder::new,
+                (stringBuilder, d) -> stringBuilder.append(toIntegralString(d)),
+                StringBuilder::append)
+            .toString();
 
     assertEquals("12345", val);
   }
diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java
index 232aebe..8b72465 100644
--- a/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/IntStreamTest.java
@@ -63,23 +63,16 @@
 
   public void testStreamOfOne() {
     Supplier<IntStream> one = () -> IntStream.of(1);
-    assertEquals(new int[]{1}, one.get().toArray());
+    assertEquals(new int[] {1}, one.get().toArray());
     assertEquals(1L, one.get().count());
     assertEquals(1, one.get().findFirst().getAsInt());
     assertEquals(1, one.get().findAny().getAsInt());
   }
 
   public void testBuilder() {
-    IntStream s = IntStream.builder()
-        .add(1)
-        .add(3)
-        .add(2)
-        .build();
+    IntStream s = IntStream.builder().add(1).add(3).add(2).build();
 
-    assertEquals(
-        new int[] {1, 3, 2},
-        s.toArray()
-    );
+    assertEquals(new int[] {1, 3, 2}, s.toArray());
 
     IntStream.Builder builder = IntStream.builder();
     IntStream built = builder.build();
@@ -101,8 +94,8 @@
   public void testConcat() {
     Supplier<IntStream> adbc = () -> IntStream.concat(IntStream.of(1, 4), IntStream.of(2, 3));
 
-    assertEquals(new int[]{1, 4, 2, 3}, adbc.get().toArray());
-    assertEquals(new int[]{1, 2, 3, 4}, adbc.get().sorted().toArray());
+    assertEquals(new int[] {1, 4, 2, 3}, adbc.get().toArray());
+    assertEquals(new int[] {1, 2, 3, 4}, adbc.get().sorted().toArray());
 
     List<String> closed = new ArrayList<>();
     IntStream first = IntStream.of(1).onClose(() -> closed.add("first"));
@@ -121,12 +114,8 @@
 
   public void testIterate() {
     assertEquals(
-        new int[]{10, 11, 12, 13, 14},
-        IntStream.iterate(0, i -> i + 1)
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        new int[] {10, 11, 12, 13, 14},
+        IntStream.iterate(0, i -> i + 1).skip(10).limit(5).toArray());
   }
 
   public void testGenerate() {
@@ -135,11 +124,7 @@
 
     assertEquals(
         new int[] {10, 11, 12, 13, 14},
-        IntStream.generate(makeGenerator())
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        IntStream.generate(makeGenerator()).skip(10).limit(5).toArray());
   }
 
   private IntSupplier makeGenerator() {
@@ -170,7 +155,7 @@
   public void testToArray() {
     assertEquals(new int[0], IntStream.of().toArray());
     assertEquals(new int[] {1}, IntStream.of(1).toArray());
-    assertEquals(new int[] {3,2,0}, IntStream.of(3,2,0).toArray());
+    assertEquals(new int[] {3, 2, 0}, IntStream.of(3, 2, 0).toArray());
   }
 
   public void testReduce() {
@@ -194,25 +179,14 @@
     assertFalse(data[0]);
 
     // one result
-    assertEquals(
-        new int[] {1},
-        IntStream.of(1, 2, 3, 4, 3).filter(a -> a == 1).toArray()
-    );
+    assertEquals(new int[] {1}, IntStream.of(1, 2, 3, 4, 3).filter(a -> a == 1).toArray());
     // zero results
-    assertEquals(
-        new int[0],
-        IntStream.of(1, 2, 3, 4, 3).filter(a -> false).toArray()
-    );
+    assertEquals(new int[0], IntStream.of(1, 2, 3, 4, 3).filter(a -> false).toArray());
     // two results
-    assertEquals(
-        new int[] {2, 4},
-        IntStream.of(1, 2, 3, 4, 3).filter(a -> a % 2 == 0).toArray()
-    );
+    assertEquals(new int[] {2, 4}, IntStream.of(1, 2, 3, 4, 3).filter(a -> a % 2 == 0).toArray());
     // all
     assertEquals(
-        new int[] {1, 2, 3, 4, 3},
-        IntStream.of(1, 2, 3, 4, 3).filter(a -> true).toArray()
-    );
+        new int[] {1, 2, 3, 4, 3}, IntStream.of(1, 2, 3, 4, 3).filter(a -> true).toArray());
   }
 
   public void testMap() {
@@ -221,10 +195,7 @@
     IntStream.of(1, 2, 3).map(i -> data[0]++);
     assertEquals(0, data[0]);
 
-    assertEquals(
-        new int[] {2, 4, 6},
-        IntStream.of(1, 2, 3).map(i -> i * 2).toArray()
-    );
+    assertEquals(new int[] {2, 4, 6}, IntStream.of(1, 2, 3).map(i -> i * 2).toArray());
   }
 
   public void testPeek() {
@@ -236,9 +207,12 @@
     // make sure we saw it all in order
     int[] items = new int[] {1, 2, 3};
     List<Integer> peeked = new ArrayList<>();
-    IntStream.of(items).peek(peeked::add).forEach(item -> {
-      // do nothing, just run
-    });
+    IntStream.of(items)
+        .peek(peeked::add)
+        .forEach(
+            item -> {
+              // do nothing, just run
+            });
     assertEquals(items.length, peeked.size());
     for (int i = 0; i < items.length; i++) {
       assertEquals(items[i], (int) peeked.get(i));
@@ -295,28 +269,18 @@
     IntStream values = IntStream.of(1, 2, 3);
 
     assertEquals(
-        new int[] {1, 2, 2, 4, 3, 6},
-        values.flatMap(i -> IntStream.of(i, i * 2)).toArray()
-    );
+        new int[] {1, 2, 2, 4, 3, 6}, values.flatMap(i -> IntStream.of(i, i * 2)).toArray());
   }
 
   public void testMapToOthers() {
     Supplier<IntStream> s = () -> IntStream.of(1, 2, 10);
 
     assertEquals(
-        new String[] {"1", "2", "10"},
-        s.get().mapToObj(String::valueOf).toArray(String[]::new)
-    );
+        new String[] {"1", "2", "10"}, s.get().mapToObj(String::valueOf).toArray(String[]::new));
 
-    assertEquals(
-        new long[] {1, 2, 10},
-        s.get().mapToLong(i -> (long) i).toArray()
-    );
+    assertEquals(new long[] {1, 2, 10}, s.get().mapToLong(i -> (long) i).toArray());
 
-    assertEquals(
-        new double[] {1, 2, 10},
-        s.get().mapToDouble(i -> (double) i).toArray()
-    );
+    assertEquals(new double[] {1, 2, 10}, s.get().mapToDouble(i -> (double) i).toArray());
   }
 
   public void testDistinct() {
@@ -376,7 +340,7 @@
     Supplier<IntStream> stream = () -> IntStream.of(1, 2);
 
     DoubleStream actualDoubleStream = stream.get().asDoubleStream();
-    assertEquals(new double[]{1, 2}, actualDoubleStream.toArray());
+    assertEquals(new double[] {1, 2}, actualDoubleStream.toArray());
 
     LongStream actualLongStream = stream.get().asLongStream();
     assertEquals(new long[] {1, 2}, actualLongStream.toArray());
@@ -421,10 +385,14 @@
   }
 
   public void testCollect() {
-    String val = IntStream.of(1, 2, 3, 4, 5).collect(StringBuilder::new,
-        // TODO switch to a lambda reference once #9340 is fixed
-        (stringBuilder, i) -> stringBuilder.append(i),
-        StringBuilder::append).toString();
+    String val =
+        IntStream.of(1, 2, 3, 4, 5)
+            .collect(
+                StringBuilder::new,
+                // TODO switch to a lambda reference once #9340 is fixed
+                (stringBuilder, i) -> stringBuilder.append(i),
+                StringBuilder::append)
+            .toString();
 
     assertEquals("12345", val);
   }
diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java
index 407f4bf..0efee03 100644
--- a/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/LongStreamTest.java
@@ -62,23 +62,16 @@
 
   public void testStreamOfOne() {
     Supplier<LongStream> one = () -> LongStream.of(1);
-    assertEquals(new long[]{1L}, one.get().toArray());
+    assertEquals(new long[] {1L}, one.get().toArray());
     assertEquals(1L, one.get().count());
     assertEquals(1, one.get().findFirst().getAsLong());
     assertEquals(1, one.get().findAny().getAsLong());
   }
 
   public void testBuilder() {
-    LongStream s = LongStream.builder()
-        .add(1L)
-        .add(3L)
-        .add(2L)
-        .build();
+    LongStream s = LongStream.builder().add(1L).add(3L).add(2L).build();
 
-    assertEquals(
-        new long[] {1L, 3L, 2L},
-        s.toArray()
-    );
+    assertEquals(new long[] {1L, 3L, 2L}, s.toArray());
 
     LongStream.Builder builder = LongStream.builder();
     LongStream built = builder.build();
@@ -100,8 +93,8 @@
   public void testConcat() {
     Supplier<LongStream> adbc = () -> LongStream.concat(LongStream.of(1, 4), LongStream.of(2, 3));
 
-    assertEquals(new long[]{1L, 4L, 2L, 3L}, adbc.get().toArray());
-    assertEquals(new long[]{1L, 2L, 3L, 4L}, adbc.get().sorted().toArray());
+    assertEquals(new long[] {1L, 4L, 2L, 3L}, adbc.get().toArray());
+    assertEquals(new long[] {1L, 2L, 3L, 4L}, adbc.get().sorted().toArray());
 
     List<String> closed = new ArrayList<>();
     LongStream first = LongStream.of(1L).onClose(() -> closed.add("first"));
@@ -120,12 +113,8 @@
 
   public void testIterate() {
     assertEquals(
-        new long[]{10L, 11L, 12L, 13L, 14L},
-        LongStream.iterate(0L, l -> l + 1L)
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        new long[] {10L, 11L, 12L, 13L, 14L},
+        LongStream.iterate(0L, l -> l + 1L).skip(10).limit(5).toArray());
   }
 
   public void testGenerate() {
@@ -133,12 +122,8 @@
     assertEquals(new long[0], LongStream.generate(makeGenerator()).limit(4).skip(5).toArray());
 
     assertEquals(
-        new long[]{10L, 11L, 12L, 13L, 14L},
-        LongStream.generate(makeGenerator())
-            .skip(10)
-            .limit(5)
-            .toArray()
-    );
+        new long[] {10L, 11L, 12L, 13L, 14L},
+        LongStream.generate(makeGenerator()).skip(10).limit(5).toArray());
   }
 
   private LongSupplier makeGenerator() {
@@ -169,7 +154,7 @@
   public void testToArray() {
     assertEquals(new long[0], LongStream.of().toArray());
     assertEquals(new long[] {1L}, LongStream.of(1L).toArray());
-    assertEquals(new long[] {3L, 2L, 0L}, LongStream.of(3L,2L,0L).toArray());
+    assertEquals(new long[] {3L, 2L, 0L}, LongStream.of(3L, 2L, 0L).toArray());
   }
 
   public void testReduce() {
@@ -193,25 +178,16 @@
     assertFalse(data[0]);
 
     // one result
-    assertEquals(
-        new long[] {1L},
-        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a == 1).toArray()
-    );
+    assertEquals(new long[] {1L}, LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a == 1).toArray());
     // zero results
-    assertEquals(
-        new long[0],
-        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> false).toArray()
-    );
+    assertEquals(new long[0], LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> false).toArray());
     // two results
     assertEquals(
-        new long[] {2L, 4L},
-        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a % 2 == 0).toArray()
-    );
+        new long[] {2L, 4L}, LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> a % 2 == 0).toArray());
     // all
     assertEquals(
         new long[] {1L, 2L, 3L, 4L, 3L},
-        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> true).toArray()
-    );
+        LongStream.of(1L, 2L, 3L, 4L, 3L).filter(a -> true).toArray());
   }
 
   public void testMap() {
@@ -220,10 +196,7 @@
     LongStream.of(1L, 2L, 3L).map(i -> data[0]++);
     assertEquals(0, data[0]);
 
-    assertEquals(
-        new long[] {2L, 4L, 6L},
-        LongStream.of(1L, 2L, 3L).map(i -> i * 2).toArray()
-    );
+    assertEquals(new long[] {2L, 4L, 6L}, LongStream.of(1L, 2L, 3L).map(i -> i * 2).toArray());
   }
 
   public void testPeek() {
@@ -235,9 +208,12 @@
     // make sure we saw it all in order
     long[] items = new long[] {1L, 2L, 3L};
     List<Long> peeked = new ArrayList<>();
-    LongStream.of(items).peek(peeked::add).forEach(item -> {
-      // do nothing, just run
-    });
+    LongStream.of(items)
+        .peek(peeked::add)
+        .forEach(
+            item -> {
+              // do nothing, just run
+            });
     assertEquals(items.length, peeked.size());
     for (int i = 0; i < items.length; i++) {
       assertEquals(items[i], (long) peeked.get(i));
@@ -295,27 +271,18 @@
 
     assertEquals(
         new long[] {1L, 2L, 2L, 4L, 3L, 6L},
-        values.flatMap(i -> LongStream.of(i, i * 2)).toArray()
-    );
+        values.flatMap(i -> LongStream.of(i, i * 2)).toArray());
   }
 
   public void testMapToOthers() {
     Supplier<LongStream> s = () -> LongStream.of(1, 2, 10);
 
     assertEquals(
-        new String[] {"1", "2", "10"},
-        s.get().mapToObj(String::valueOf).toArray(String[]::new)
-    );
+        new String[] {"1", "2", "10"}, s.get().mapToObj(String::valueOf).toArray(String[]::new));
 
-    assertEquals(
-        new int[] {1, 2, 10},
-        s.get().mapToInt(i -> (int) i).toArray()
-    );
+    assertEquals(new int[] {1, 2, 10}, s.get().mapToInt(i -> (int) i).toArray());
 
-    assertEquals(
-        new double[] {1d, 2d, 10d},
-        s.get().mapToDouble(i -> (double) i).toArray()
-    );
+    assertEquals(new double[] {1d, 2d, 10d}, s.get().mapToDouble(i -> (double) i).toArray());
   }
 
   public void testDistinct() {
@@ -374,7 +341,7 @@
   public void testAsOtherPrimitive() {
     Supplier<LongStream> stream = () -> LongStream.of(1L, 2L);
     DoubleStream actualDoubleStream = stream.get().asDoubleStream();
-    assertEquals(new double[]{1, 2}, actualDoubleStream.toArray());
+    assertEquals(new double[] {1, 2}, actualDoubleStream.toArray());
   }
 
   public void testSummaryStats() {
@@ -416,10 +383,14 @@
   }
 
   public void testCollect() {
-    String val = LongStream.of(1L, 2L, 3L, 4L, 5L).collect(StringBuilder::new,
-        // TODO switch to a lambda reference once #9340 is fixed
-        (stringBuilder, lng) -> stringBuilder.append(lng),
-        StringBuilder::append).toString();
+    String val =
+        LongStream.of(1L, 2L, 3L, 4L, 5L)
+            .collect(
+                StringBuilder::new,
+                // TODO switch to a lambda reference once #9340 is fixed
+                (stringBuilder, lng) -> stringBuilder.append(lng),
+                StringBuilder::append)
+            .toString();
 
     assertEquals("12345", val);
   }
diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java
index 0ff6331..3a811f3 100644
--- a/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/StreamSupportTest.java
@@ -35,29 +35,21 @@
 public class StreamSupportTest extends EmulTestBase {
 
   public void testDoubleStream() {
-    DoubleStream doubles = doubleStream(
-        Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0),
-        false
-    );
+    DoubleStream doubles =
+        doubleStream(Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0), false);
 
     assertNotNull(doubles);
-    assertEquals(new double[]{1d, 2d, 3d}, doubles.limit(3).toArray());
+    assertEquals(new double[] {1d, 2d, 3d}, doubles.limit(3).toArray());
 
-    doubles = doubleStream(() -> Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0), 0,
-        false);
+    doubles =
+        doubleStream(() -> Spliterators.spliterator(new double[] {1d, 2d, 3d, 4d}, 0), 0, false);
 
     assertNotNull(doubles);
-    assertEquals(
-        new double[] {2d, 3d},
-        doubles.skip(1).limit(2).toArray()
-    );
+    assertEquals(new double[] {2d, 3d}, doubles.skip(1).limit(2).toArray());
   }
 
   public void testIntStream() {
-    IntStream ints = intStream(
-        Spliterators.spliterator(new int[] {1, 2, 3, 4}, 0),
-        false
-    );
+    IntStream ints = intStream(Spliterators.spliterator(new int[] {1, 2, 3, 4}, 0), false);
 
     assertNotNull(ints);
     assertEquals(new int[] {1, 2, 3}, ints.limit(3).toArray());
@@ -65,17 +57,11 @@
     ints = intStream(() -> Spliterators.spliterator(new int[] {1, 2, 3, 4}, 0), 0, false);
 
     assertNotNull(ints);
-    assertEquals(
-        new int[] {2, 3},
-        ints.skip(1).limit(2).toArray()
-    );
+    assertEquals(new int[] {2, 3}, ints.skip(1).limit(2).toArray());
   }
 
   public void testLongStream() {
-    LongStream longs = longStream(
-        Spliterators.spliterator(new long[] {1L, 2L, 3L, 4L}, 0),
-        false
-    );
+    LongStream longs = longStream(Spliterators.spliterator(new long[] {1L, 2L, 3L, 4L}, 0), false);
 
     assertNotNull(longs);
     assertEquals(new long[] {1L, 2L, 3L}, longs.limit(3).toArray());
@@ -83,27 +69,20 @@
     longs = longStream(() -> Spliterators.spliterator(new long[] {1L, 2L, 3L, 4L}, 0), 0, false);
 
     assertNotNull(longs);
-    assertEquals(
-        new long[] {2L, 3L},
-        longs.skip(1).limit(2).toArray()
-    );
+    assertEquals(new long[] {2L, 3L}, longs.skip(1).limit(2).toArray());
   }
 
   public void testStream() {
-    Stream<String> strings = stream(
-        Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0),
-        false
-    );
+    Stream<String> strings =
+        stream(Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0), false);
 
     assertNotNull(strings);
     assertEquals(new String[] {"a", "b", "c"}, strings.limit(3).toArray());
 
-    strings = stream(() -> Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0), 0, false);
+    strings =
+        stream(() -> Spliterators.spliterator(new String[] {"a", "b", "c", "d"}, 0), 0, false);
 
     assertNotNull(strings);
-    assertEquals(
-        new String[] {"b", "c"},
-        strings.skip(1).limit(2).toArray()
-    );
+    assertEquals(new String[] {"b", "c"}, strings.skip(1).limit(2).toArray());
   }
 }
diff --git a/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java b/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java
index 7835e05..e8b405c 100644
--- a/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java
+++ b/user/test/com/google/gwt/emultest/java8/util/stream/StreamTest.java
@@ -78,11 +78,7 @@
   }
 
   public void testBuilder() {
-    Supplier<Stream<String>> s = () -> Stream.<String>builder()
-        .add("1")
-        .add("3")
-        .add("2")
-        .build();
+    Supplier<Stream<String>> s = () -> Stream.<String>builder().add("1").add("3").add("2").build();
 
     Optional<String> max = s.get().filter(str -> !str.equals("3")).max(Comparator.naturalOrder());
     assertTrue(max.isPresent());
@@ -112,8 +108,8 @@
   public void testConcat() {
     Supplier<Stream<String>> adbc = () -> Stream.concat(Stream.of("a", "d"), Stream.of("b", "c"));
 
-    assertEquals(new String[]{"a", "d", "b", "c"}, adbc.get().toArray(String[]::new));
-    assertEquals(new String[]{"a", "b", "c", "d"}, adbc.get().sorted().toArray(String[]::new));
+    assertEquals(new String[] {"a", "d", "b", "c"}, adbc.get().toArray(String[]::new));
+    assertEquals(new String[] {"a", "b", "c", "d"}, adbc.get().sorted().toArray(String[]::new));
 
     List<String> closed = new ArrayList<>();
     Stream<String> first = Stream.of("first").onClose(() -> closed.add("first"));
@@ -132,25 +128,19 @@
 
   public void testIterate() {
     assertEquals(
-        new Integer[]{10, 11, 12, 13, 14},
-        Stream.iterate(0, i -> i + 1)
-            .skip(10)
-            .limit(5)
-            .toArray(Integer[]::new)
-    );
+        new Integer[] {10, 11, 12, 13, 14},
+        Stream.iterate(0, i -> i + 1).skip(10).limit(5).toArray(Integer[]::new));
   }
 
   public void testGenerate() {
     // infinite, but if you limit it is already too short to skip much
-    assertEquals(new Integer[]{}, Stream.generate(makeGenerator())
-        .limit(4)
-        .skip(5)
-        .toArray(Integer[]::new));
+    assertEquals(
+        new Integer[] {},
+        Stream.generate(makeGenerator()).limit(4).skip(5).toArray(Integer[]::new));
 
-    assertEquals(new Integer[]{10, 11, 12, 13, 14}, Stream.generate(makeGenerator())
-        .skip(10)
-        .limit(5)
-        .toArray(Integer[]::new));
+    assertEquals(
+        new Integer[] {10, 11, 12, 13, 14},
+        Stream.generate(makeGenerator()).skip(10).limit(5).toArray(Integer[]::new));
   }
 
   private Supplier<Integer> makeGenerator() {
@@ -200,14 +190,8 @@
 
   // toArray
   public void testToArray() {
-    assertEquals(
-        new Object[]{"a", "b"},
-        asList("a", "b").stream().toArray()
-    );
-    assertEquals(
-        new String[]{"a", "b"},
-        asList("a", "b").stream().toArray(String[]::new)
-    );
+    assertEquals(new Object[] {"a", "b"}, asList("a", "b").stream().toArray());
+    assertEquals(new String[] {"a", "b"}, asList("a", "b").stream().toArray(String[]::new));
   }
 
   // reduce
@@ -231,9 +215,10 @@
   public void testCollect() {
     final String[] values = new String[] {"a", "b", "c"};
 
-    String collectedString = Stream.of(values).collect(StringBuilder::new,
-        StringBuilder::append,
-        StringBuilder::append).toString();
+    String collectedString =
+        Stream.of(values)
+            .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
+            .toString();
     assertEquals("abc", collectedString);
 
     List<String> collectedList = Stream.of(values).collect(Collectors.toList());
@@ -249,25 +234,21 @@
     // one result
     assertEquals(
         Collections.singletonList("a"),
-        Stream.of("a", "b", "c", "d", "c").filter(a -> a.equals("a")).collect(Collectors.toList())
-    );
+        Stream.of("a", "b", "c", "d", "c").filter(a -> a.equals("a")).collect(Collectors.toList()));
     // zero results
     assertEquals(
         Collections.emptyList(),
-        Stream.of("a", "b", "c", "d", "c").filter(a -> false).collect(Collectors.toList())
-    );
+        Stream.of("a", "b", "c", "d", "c").filter(a -> false).collect(Collectors.toList()));
     // two results
     assertEquals(
         asList("c3", "c5"),
         Stream.of("a1", "b2", "c3", "d4", "c5")
             .filter(a -> a.startsWith("c"))
-            .collect(Collectors.toList())
-    );
+            .collect(Collectors.toList()));
     // all
     assertEquals(
         asList("a", "b", "c", "d", "c"),
-        Stream.of("a", "b", "c", "d", "c").filter(a -> true).collect(Collectors.toList())
-    );
+        Stream.of("a", "b", "c", "d", "c").filter(a -> true).collect(Collectors.toList()));
   }
 
   public void testMap() {
@@ -278,8 +259,7 @@
 
     assertEquals(
         asList("#1", "#2", "#3"),
-        Stream.of(1, 2, 3).map(i -> "#" + i).collect(Collectors.toList())
-    );
+        Stream.of(1, 2, 3).map(i -> "#" + i).collect(Collectors.toList()));
   }
 
   public void testPeek() {
@@ -291,9 +271,13 @@
     // make sure we saw it all in order
     List<String> items = asList("a", "b", "c");
     List<String> peeked = new ArrayList<>();
-    items.stream().peek(peeked::add).forEach(item -> {
-      // deliberately do nothing, just run
-    });
+    items
+        .stream()
+        .peek(peeked::add)
+        .forEach(
+            item -> {
+              // deliberately do nothing, just run
+            });
     assertEquals(items, peeked);
   }
 
@@ -346,27 +330,17 @@
     Stream<Stream<String>> strings = Stream.of(Stream.of("a", "b"), Stream.empty(), Stream.of("c"));
 
     assertEquals(
-        asList("a", "b", "c"),
-        strings.flatMap(Function.identity()).collect(Collectors.toList())
-    );
+        asList("a", "b", "c"), strings.flatMap(Function.identity()).collect(Collectors.toList()));
   }
+
   public void testMapToPrimitives() {
     Supplier<Stream<String>> s = () -> Stream.of("1", "2", "10");
 
-    assertEquals(
-        new int[]{1, 2, 10},
-        s.get().mapToInt(Integer::parseInt).toArray()
-    );
+    assertEquals(new int[] {1, 2, 10}, s.get().mapToInt(Integer::parseInt).toArray());
 
-    assertEquals(
-        new long[]{1, 2, 10},
-        s.get().mapToLong(Long::parseLong).toArray()
-    );
+    assertEquals(new long[] {1, 2, 10}, s.get().mapToLong(Long::parseLong).toArray());
 
-    assertEquals(
-        new double[]{1, 2, 10},
-        s.get().mapToDouble(Double::parseDouble).toArray()
-    );
+    assertEquals(new double[] {1, 2, 10}, s.get().mapToDouble(Double::parseDouble).toArray());
   }
 
   public void testFlatMapToPrimitives() {
@@ -375,41 +349,23 @@
     assertEquals(0, Stream.of(IntStream.of()).flatMapToInt(Function.identity()).count());
     assertEquals(1, Stream.of(IntStream.of(0)).flatMapToInt(Function.identity()).count());
 
-    Stream<IntStream> intStreams = Stream.of(
-        IntStream.of(1, 2),
-        IntStream.empty(),
-        IntStream.of(5)
-    );
-    assertEquals(
-        new int[]{1, 2, 5},
-        intStreams.flatMapToInt(Function.identity()).toArray()
-    );
+    Stream<IntStream> intStreams =
+        Stream.of(IntStream.of(1, 2), IntStream.empty(), IntStream.of(5));
+    assertEquals(new int[] {1, 2, 5}, intStreams.flatMapToInt(Function.identity()).toArray());
 
-    Stream<LongStream> longStreams = Stream.of(
-        LongStream.of(1, 2),
-        LongStream.empty(),
-        LongStream.of(5)
-    );
-    assertEquals(
-        new long[]{1, 2, 5},
-        longStreams.flatMapToLong(Function.identity()).toArray()
-    );
+    Stream<LongStream> longStreams =
+        Stream.of(LongStream.of(1, 2), LongStream.empty(), LongStream.of(5));
+    assertEquals(new long[] {1, 2, 5}, longStreams.flatMapToLong(Function.identity()).toArray());
 
-    Stream<DoubleStream> doubleStreams = Stream.of(
-        DoubleStream.of(1, 2),
-        DoubleStream.empty(),
-        DoubleStream.of(5)
-    );
+    Stream<DoubleStream> doubleStreams =
+        Stream.of(DoubleStream.of(1, 2), DoubleStream.empty(), DoubleStream.of(5));
     assertEquals(
-        new double[]{1, 2, 5},
-        doubleStreams.flatMapToDouble(Function.identity()).toArray()
-    );
+        new double[] {1, 2, 5}, doubleStreams.flatMapToDouble(Function.identity()).toArray());
   }
 
   public void testDistinct() {
-    List<String> distinct = asList("a", "b", "c", "b").stream()
-        .distinct()
-        .collect(Collectors.toList());
+    List<String> distinct =
+        asList("a", "b", "c", "b").stream().distinct().collect(Collectors.toList());
     assertEquals(3, distinct.size());
     assertTrue(distinct.contains("a"));
     assertTrue(distinct.contains("b"));
@@ -418,9 +374,11 @@
 
   public void testSorted() {
     List<String> sorted = asList("c", "a", "b").stream().sorted().collect(Collectors.toList());
-    List<String> reversed = asList("c", "a", "b").stream()
-        .sorted(Comparator.reverseOrder())
-        .collect(Collectors.toList());
+    List<String> reversed =
+        asList("c", "a", "b")
+            .stream()
+            .sorted(Comparator.reverseOrder())
+            .collect(Collectors.toList());
 
     assertEquals(asList("a", "b", "c"), sorted);
     assertEquals(asList("c", "b", "a"), reversed);
@@ -454,26 +412,16 @@
     assertEquals(1, stream.get().skip(3).count());
 
     assertEquals(asList("c", "d"), stream.get().skip(2).limit(3).collect(Collectors.toList()));
-    assertEquals(Collections.singletonList("c"), stream.get()
-        .skip(2)
-        .limit(1)
-        .collect(Collectors.toList()));
+    assertEquals(
+        Collections.singletonList("c"), stream.get().skip(2).limit(1).collect(Collectors.toList()));
 
-    assertEquals(Collections.singletonList("d"), stream.get()
-        .skip(3)
-        .collect(Collectors.toList()));
-    assertEquals(Collections.emptyList(), stream.get()
-        .skip(5)
-        .collect(Collectors.toList()));
+    assertEquals(Collections.singletonList("d"), stream.get().skip(3).collect(Collectors.toList()));
+    assertEquals(Collections.emptyList(), stream.get().skip(5).collect(Collectors.toList()));
 
-    assertEquals(asList("a", "b"), stream.get()
-        .limit(2)
-        .collect(Collectors.toList()));
+    assertEquals(asList("a", "b"), stream.get().limit(2).collect(Collectors.toList()));
 
-    assertEquals(Collections.singletonList("b"), stream.get()
-        .limit(2)
-        .skip(1)
-        .collect(Collectors.toList()));
+    assertEquals(
+        Collections.singletonList("b"), stream.get().limit(2).skip(1).collect(Collectors.toList()));
   }
 
   // This frustrating test was written first on the JVM stream to discover the basic behavior before
@@ -566,9 +514,10 @@
     Stream<Object> s = Stream.of(1, 2, 3);
 
     RuntimeException a = new RuntimeException("a");
-    s.onClose(() -> {
-      throw a;
-    });
+    s.onClose(
+        () -> {
+          throw a;
+        });
     try {
       s.close();
       fail("RuntimeException expected");
@@ -584,19 +533,22 @@
     RuntimeException a2 = new RuntimeException("a");
     IllegalStateException b = new IllegalStateException("b");
     int[] calledCount = {0};
-    s
-        .onClose(() -> {
-          throw a2;
-        })
-        .onClose(() -> {
-          throw b;
-        })
-        .onClose(() -> {
-          throw a2;
-        })
-        .onClose(() -> {
-          throw b;
-        })
+    s.onClose(
+            () -> {
+              throw a2;
+            })
+        .onClose(
+            () -> {
+              throw b;
+            })
+        .onClose(
+            () -> {
+              throw a2;
+            })
+        .onClose(
+            () -> {
+              throw b;
+            })
         .onClose(() -> calledCount[0]++);
 
     try {
@@ -612,13 +564,14 @@
     s = Stream.of(1, 2, 3);
 
     RuntimeException t = new RuntimeException("a");
-    s
-        .onClose(() -> {
-          throw t;
-        })
-        .onClose(() -> {
-          throw t;
-        });
+    s.onClose(
+            () -> {
+              throw t;
+            })
+        .onClose(
+            () -> {
+              throw t;
+            });
 
     try {
       s.close();
@@ -628,4 +581,4 @@
       assertEquals(0, expected.getSuppressed().length);
     }
   }
-}
\ No newline at end of file
+}