More emulation

Author: zbynek

user/super/com/google/gwt/emul/java/lang/String.java

@@ -32,6 +32,7 @@
 import java.util.Spliterators;
 import java.util.StringJoiner;
 import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 import javaemul.internal.ArrayHelper;
@@ -815,6 +816,42 @@ private int getTrailingWhitespaceLength() {
     return length;
   }
 
+  public String indent(int spaces) {
+    if (spaces  == 0) {
+      return this;
+    }
+    int nPosition = -1;
+    int rPosition = -1;
+    int nextIndex = 0;
+    StringBuilder ret = new StringBuilder();
+    String spaceString = spaces > 0 ? " ".repeat(spaces) : "";
+    while (nextIndex < length()) {
+      if (rPosition < nextIndex) {
+        rPosition = cappedIndexOf('\r', nextIndex);
+      }
+      if (nPosition < nextIndex) {
+        nPosition = cappedIndexOf('\n', nextIndex);
+      }
+      int lineEnd = Math.min(nPosition, rPosition) + 1;
+      if (nPosition == rPosition + 1) {
+        lineEnd++;
+      }
+      String line = substring(nextIndex, Math.min(lineEnd, length()));
+      nextIndex = lineEnd;
+      if (spaces > 0) {
+        ret.append(spaceString).append(line);
+      } else {
+        int prefixLength = 0;
+        while (prefixLength < line.length() && line.charAt(prefixLength) == ' '
+            && prefixLength < -spaces) {
+          prefixLength++;
+        }
+        ret.append(line.substring(prefixLength));
+      }
+    }
+    return ret.toString();
+  }
+
   private class LinesSpliterator extends Spliterators.AbstractSpliterator<String> {
     private int nextIndex = 0;
     private int rPosition = -1;
@@ -830,10 +867,10 @@ public boolean tryAdvance(Consumer<? super String> action) {
         return false;
       }
       if (rPosition < nextIndex) {
-        rPosition = cappedIndexOf('\r');
+        rPosition = cappedIndexOf('\r', nextIndex);
       }
       if (nPosition < nextIndex) {
-        nPosition = cappedIndexOf('\n');
+        nPosition = cappedIndexOf('\n', nextIndex);
       }
       int lineEnd = Math.min(nPosition, rPosition);
       action.accept(substring(nextIndex, lineEnd));
@@ -843,11 +880,11 @@ public boolean tryAdvance(Consumer<? super String> action) {
       }
       return nextIndex < length();
     }
+  }
 
-    private int cappedIndexOf(char c) {
-      int index = indexOf(c, nextIndex);
-      return index == -1 ? length() : index;
-    }
+  private int cappedIndexOf(char c, int nextIndex) {
+    int index = indexOf(c, nextIndex);
+    return index == -1 ? length() : index;
   }
 
   @JsType(isNative = true, name = "String", namespace = "<window>")

user/super/com/google/gwt/emul/java/util/stream/DoubleStream.java

@@ -17,8 +17,10 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.DoubleSummaryStatistics;
+import java.util.List;
 import java.util.OptionalDouble;
 import java.util.PrimitiveIterator;
 import java.util.Spliterator;
@@ -58,6 +60,15 @@ default DoubleStream.Builder add(double t) {
     DoubleStream build();
   }
 
+  /**
+   * See <a
+   * href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/stream/DoubleStream.DoubleMapMultiConsumer.html">
+   * the official Java API doc</a> for details.
+   */
+  interface DoubleMapMultiConsumer {
+    void accept(double value, DoubleConsumer consumer);
+  }
+
   static Builder builder() {
     return new Builder() {
       private double[] items = new double[0];
@@ -317,5 +328,13 @@ public boolean tryAdvance(DoubleConsumer action) {
     return StreamSupport.doubleStream(spliterator, false);
   }
 
+  default DoubleStream mapMulti(DoubleStream.DoubleMapMultiConsumer mapper) {
+    return flatMap(element -> {
+      List<Double> buffer = new ArrayList<>();
+      mapper.accept(element, (DoubleConsumer) buffer::add);
+      return buffer.stream().mapToDouble(n -> n);
+    });
+  }
+
   double[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/IntStream.java

@@ -17,9 +17,11 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.IntSummaryStatistics;
+import java.util.List;
 import java.util.OptionalDouble;
 import java.util.OptionalInt;
 import java.util.PrimitiveIterator;
@@ -61,6 +63,15 @@ default IntStream.Builder add(int t) {
     IntStream build();
   }
 
+  /**
+   * See <a
+   * href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/stream/IntStream.IntMapMultiConsumer.html">
+   * the official Java API doc</a> for details.
+   */
+  interface IntMapMultiConsumer {
+    void accept(int value, IntConsumer consumer);
+  }
+
   static Builder builder() {
     return new Builder() {
       private int[] items = new int[0];
@@ -366,5 +377,13 @@ public boolean tryAdvance(IntConsumer action) {
     return StreamSupport.intStream(spliterator, false);
   }
 
+  default IntStream mapMulti(IntMapMultiConsumer mapper) {
+    return flatMap(element -> {
+      List<Integer> buffer = new ArrayList<>();
+      mapper.accept(element, (IntConsumer) buffer::add);
+      return buffer.stream().mapToInt(n -> n);
+    });
+  }
+
   int[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/LongStream.java

@@ -17,8 +17,10 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
 import java.util.LongSummaryStatistics;
 import java.util.OptionalDouble;
 import java.util.OptionalLong;
@@ -61,6 +63,15 @@ default LongStream.Builder add(long t) {
     LongStream build();
   }
 
+  /**
+   * See <a
+   * href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/stream/LongStream.LongMapMultiConsumer.html">
+   * the official Java API doc</a> for details.
+   */
+  interface LongMapMultiConsumer {
+    void accept(long value, LongConsumer consumer);
+  }
+
   static Builder builder() {
     return new Builder() {
       private long[] items = new long[0];
@@ -364,5 +375,13 @@ public boolean tryAdvance(LongConsumer action) {
     return StreamSupport.longStream(spliterator, false);
   }
 
+  default LongStream mapMulti(LongStream.LongMapMultiConsumer mapper) {
+    return flatMap(element -> {
+      List<Long> buffer = new ArrayList<>();
+      mapper.accept(element, (LongConsumer) buffer::add);
+      return buffer.stream().mapToLong(n -> n);
+    });
+  }
+
   long[] toArray();
 }

user/super/com/google/gwt/emul/java/util/stream/Stream.java

@@ -17,9 +17,11 @@
 
 import static javaemul.internal.InternalPreconditions.checkState;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.List;
 import java.util.Optional;
 import java.util.Spliterator;
 import java.util.Spliterators;
@@ -28,8 +30,11 @@
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
 import java.util.function.Function;
+import java.util.function.IntConsumer;
 import java.util.function.IntFunction;
+import java.util.function.LongConsumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.function.ToDoubleFunction;
@@ -327,6 +332,38 @@ public boolean tryAdvance(Consumer<? super T> action) {
     return StreamSupport.stream(spliterator, false);
   }
 
+  default <R> Stream<R> mapMulti(BiConsumer<T, ? super Consumer<R>> mapper) {
+    return flatMap(element -> {
+      List<R> buffer = new ArrayList<>();
+      mapper.accept(element, (Consumer<R>) buffer::add);
+      return buffer.stream();
+    });
+  }
+
+  default DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper) {
+    return flatMapToDouble(element -> {
+      List<Double> buffer = new ArrayList<>();
+      mapper.accept(element, (DoubleConsumer) buffer::add);
+      return buffer.stream().mapToDouble(n -> n);
+    });
+  }
+
+  default IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper) {
+    return flatMapToInt(element -> {
+      List<Integer> buffer = new ArrayList<>();
+      mapper.accept(element, (IntConsumer) buffer::add);
+      return buffer.stream().mapToInt(n -> n);
+    });
+  }
+
+  default LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper) {
+    return flatMapToLong(element -> {
+      List<Long> buffer = new ArrayList<>();
+      mapper.accept(element, (LongConsumer) buffer::add);
+      return buffer.stream().mapToLong(n -> n);
+    });
+  }
+
   Object[] toArray();
 
   <A> A[] toArray(IntFunction<A[]> generator);

user/test-super/com/google/gwt/dev/jjs/super/com/google/gwt/emultest/java12/lang/StringTest.java renamed to user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/lang/StringTest.java

@@ -13,20 +13,18 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.google.gwt.emultest.java11.lang;
+package com.google.gwt.emultest.java17.lang;
 
 import com.google.gwt.emultest.java.util.EmulTestBase;
 
-import java.util.Arrays;
-import java.util.stream.Collectors;
-
 /**
  * Tests for java.lang.String Java 12 API emulation.
  */
 public class StringTest extends EmulTestBase {
 
   public void testTransform() {
-    assertEquals(3, hideFromCompiler("foo").transform(String::length));
+    int stringLength = hideFromCompiler("foo").transform(String::length);
+    assertEquals(3, stringLength);
   }
 
   public void testIndent() {
@@ -39,12 +37,4 @@ public void testIndent() {
     assertEquals("x\r\ny", hideFromCompiler("  x\r\n  y").indent(-2));
     assertEquals("x\ry", hideFromCompiler("  x\r  y").indent(-2));
   }
-
-  private <T> T hideFromCompiler(T value) {
-    if (Math.random() < -1) {
-      // Can never happen, but fools the compiler enough not to optimize this call.
-      fail();
-    }
-    return value;
-  }
 }

user/test/com/google/gwt/emultest/java12/util/stream/CollectorsTest.java renamed to user/test-super/com/google/gwt/emultest/super/com/google/gwt/emultest/java17/util/stream/CollectorsTest.java

@@ -13,34 +13,25 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.google.gwt.emultest.java12.util.stream;
+package com.google.gwt.emultest.java17.util.stream;
 
-import com.google.gwt.dev.util.arg.SourceLevel;
 import com.google.gwt.emultest.java.util.EmulTestBase;
-import com.google.gwt.junit.JUnitShell;
 
-import java.util.Arrays;
+import java.util.stream.Collector;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Tests for java.lang.String Java 12 API emulation.
  */
 public class CollectorsTest extends EmulTestBase {
 
-  @Override
-  public void runTest() throws Throwable {
-    // Only run these tests if -sourceLevel 17 (or greater) is enabled.
-    if (isGwtSourceLevel17()) {
-      super.runTest();
-    }
-  }
-
   public void testTeeing() {
-    assertFalse(isGwtSourceLevel17());
-  }
-
-  private boolean isGwtSourceLevel17() {
-    return JUnitShell.getCompilerOptions().getSourceLevel().compareTo(SourceLevel.JAVA17) >= 0;
+    Collector<Double, ?, Double> teeing = Collectors.teeing(
+        Collectors.reducing(Double::sum),
+        Collectors.counting(),
+        (sum, count) -> sum.orElse(0.0) / count);
+    assertEquals(4.0, Stream.of(2.0, 4.0, 6.0).collect(teeing), 0.01);
   }
 
 }