Add Java 9 Optional APIs

Closes #224

PiperOrigin-RevId: 606390605

Author: treblereel

jre/java/java/util/Optional.java

@@ -23,6 +23,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 
 /**
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html">
@@ -130,6 +131,14 @@ public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSuppli
     throw exceptionSupplier.get();
   }
 
+  public Stream<T> stream() {
+    if (isPresent()) {
+      return Stream.of(ref);
+    } else {
+      return Stream.empty();
+    }
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (obj == this) {

jre/java/java/util/OptionalDouble.java

@@ -15,11 +15,12 @@
  */
 package java.util;
 
+import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+
 import java.util.function.DoubleConsumer;
 import java.util.function.DoubleSupplier;
 import java.util.function.Supplier;
-
-import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+import java.util.stream.DoubleStream;
 
 /**
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/OptionalDouble.html">
@@ -65,6 +66,14 @@ public void ifPresent(DoubleConsumer consumer) {
     }
   }
 
+  public void ifPresentOrElse(DoubleConsumer action, Runnable emptyAction) {
+    if (isPresent()) {
+      action.accept(ref);
+    } else {
+      emptyAction.run();
+    }
+  }
+
   public double orElse(double other) {
     return present ? ref : other;
   }
@@ -80,6 +89,14 @@ public <X extends Throwable> double orElseThrow(Supplier<X> exceptionSupplier) t
     throw exceptionSupplier.get();
   }
 
+  public DoubleStream stream() {
+    if (isPresent()) {
+      return DoubleStream.of(ref);
+    } else {
+      return DoubleStream.empty();
+    }
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (obj == this) {

jre/java/java/util/OptionalInt.java

@@ -15,11 +15,12 @@
  */
 package java.util;
 
+import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+
 import java.util.function.IntConsumer;
 import java.util.function.IntSupplier;
 import java.util.function.Supplier;
-
-import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+import java.util.stream.IntStream;
 
 /**
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/OptionalInt.html">
@@ -65,6 +66,14 @@ public void ifPresent(IntConsumer consumer) {
     }
   }
 
+  public void ifPresentOrElse(IntConsumer action, Runnable emptyAction) {
+    if (present) {
+      action.accept(ref);
+    } else {
+      emptyAction.run();
+    }
+  }
+
   public int orElse(int other) {
     return present ? ref : other;
   }
@@ -80,6 +89,14 @@ public <X extends Throwable> int orElseThrow(Supplier<X> exceptionSupplier) thro
     throw exceptionSupplier.get();
   }
 
+  public IntStream stream() {
+    if (present) {
+      return IntStream.of(ref);
+    } else {
+      return IntStream.empty();
+    }
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (obj == this) {

jre/java/java/util/OptionalLong.java

@@ -15,11 +15,12 @@
  */
 package java.util;
 
+import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+
 import java.util.function.LongConsumer;
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
-
-import static javaemul.internal.InternalPreconditions.checkCriticalElement;
+import java.util.stream.LongStream;
 
 /**
  * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/OptionalLong.html">
@@ -65,6 +66,14 @@ public void ifPresent(LongConsumer consumer) {
     }
   }
 
+  public void ifPresentOrElse(LongConsumer action, Runnable emptyAction) {
+    if (present) {
+      action.accept(ref);
+    } else {
+      emptyAction.run();
+    }
+  }
+
   public long orElse(long other) {
     return present ? ref : other;
   }
@@ -80,6 +89,14 @@ public <X extends Throwable> long orElseThrow(Supplier<X> exceptionSupplier) thr
     throw exceptionSupplier.get();
   }
 
+  public LongStream stream() {
+    if (present) {
+      return LongStream.of(ref);
+    } else {
+      return LongStream.empty();
+    }
+  }
+
   @Override
   public boolean equals(Object obj) {
     if (obj == this) {

jre/javatests/com/google/j2cl/jre/EmulJava9Suite.java

@@ -17,12 +17,24 @@
 
 import com.google.j2cl.jre.java9.util.ListTest;
 import com.google.j2cl.jre.java9.util.MapTest;
+import com.google.j2cl.jre.java9.util.OptionalDoubleTest;
+import com.google.j2cl.jre.java9.util.OptionalIntTest;
+import com.google.j2cl.jre.java9.util.OptionalLongTest;
+import com.google.j2cl.jre.java9.util.OptionalTest;
 import com.google.j2cl.jre.java9.util.SetTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
 
 /** Test JRE emulations. */
 @RunWith(Suite.class)
-@SuiteClasses({ListTest.class, SetTest.class, MapTest.class})
+@SuiteClasses({
+  ListTest.class,
+  MapTest.class,
+  OptionalDoubleTest.class,
+  OptionalIntTest.class,
+  OptionalLongTest.class,
+  OptionalTest.class,
+  SetTest.class
+})
 public class EmulJava9Suite {}

jre/javatests/com/google/j2cl/jre/java8/util/OptionalDoubleTest.java

@@ -108,6 +108,24 @@ public void testIfPresent() {
     assertTrue("Consumer not executed", mutableFlag[0]);
   }
 
+  public void testIfPresentOrElse() {
+    // empty case
+    empty.ifPresentOrElse(
+        (wrapped) -> fail("Empty Optional should not call non-empty consumer"),
+        () -> mutableFlag[0] = true);
+    assertTrue("Consumer not executed", mutableFlag[0]);
+
+    // non-empty case
+    mutableFlag[0] = false;
+    present.ifPresentOrElse(
+        (wrapped) -> {
+          assertEquals(REFERENCE, wrapped);
+          mutableFlag[0] = true;
+        },
+        () -> fail("Non-Empty Optional should not call empty consumer"));
+    assertTrue("Consumer not executed", mutableFlag[0]);
+  }
+
   public void testOrElse() {
     // empty case
     assertEquals(OTHER_REFERENCE, empty.orElse(OTHER_REFERENCE));

jre/javatests/com/google/j2cl/jre/java8/util/OptionalIntTest.java

@@ -107,6 +107,24 @@ public void testIfPresent() {
     assertTrue("Consumer not executed", mutableFlag[0]);
   }
 
+  public void testIfPresentOrElse() {
+    // empty case
+    empty.ifPresentOrElse(
+        (wrapped) -> fail("Empty Optional should not call non-empty consumer"),
+        () -> mutableFlag[0] = true);
+    assertTrue("Consumer not executed", mutableFlag[0]);
+
+    // non-empty case
+    mutableFlag[0] = false;
+    present.ifPresentOrElse(
+        (wrapped) -> {
+          assertEquals(REFERENCE, wrapped);
+          mutableFlag[0] = true;
+        },
+        () -> fail("Non-Empty Optional should not call empty consumer"));
+    assertTrue("Consumer not executed", mutableFlag[0]);
+  }
+
   public void testOrElse() {
     // empty case
     assertEquals(OTHER_REFERENCE, empty.orElse(OTHER_REFERENCE));

jre/javatests/com/google/j2cl/jre/java8/util/OptionalLongTest.java

@@ -107,6 +107,24 @@ public void testIfPresent() {
     assertTrue("Consumer not executed", mutableFlag[0]);
   }
 
+  public void testIfPresentOrElse() {
+    // empty case
+    empty.ifPresentOrElse(
+        (wrapped) -> fail("Empty Optional should not call non-empty consumer"),
+        () -> mutableFlag[0] = true);
+    assertTrue("Consumer not executed", mutableFlag[0]);
+
+    // non-empty case
+    mutableFlag[0] = false;
+    present.ifPresentOrElse(
+        (wrapped) -> {
+          assertEquals(REFERENCE, wrapped);
+          mutableFlag[0] = true;
+        },
+        () -> fail("Non-Empty Optional should not call empty consumer"));
+    assertTrue("Consumer not executed", mutableFlag[0]);
+  }
+
   public void testOrElse() {
     // empty case
     assertEquals(OTHER_REFERENCE, empty.orElse(OTHER_REFERENCE));

jre/javatests/com/google/j2cl/jre/java8/util/OptionalTest.java

@@ -141,21 +141,20 @@ public void testIfPresent() {
 
   public void testIfPresentOrElse() {
     // empty case
-    empty.ifPresentOrElse(wrapped -> fail("Empty Optional should not execute consumer"), () -> {});
+    empty.ifPresentOrElse(
+        (wrapped) -> fail("Empty Optional should not call non-empty consumer"),
+        () -> mutableFlag[0] = true);
+    assertTrue("Consumer not executed", mutableFlag[0]);
 
     // non-empty case
+    mutableFlag[0] = false;
     present.ifPresentOrElse(
         (wrapped) -> {
           assertSame(REFERENCE, wrapped);
           mutableFlag[0] = true;
         },
         () -> fail("Non-Empty Optional should not call empty consumer"));
     assertTrue("Consumer not executed", mutableFlag[0]);
-    mutableFlag[0] = false;
-    empty.ifPresentOrElse(
-        (wrapped) -> fail("Empty Optional should not call non-empty consumer"),
-        () -> mutableFlag[0] = true);
-    assertTrue("Consumer not executed", mutableFlag[0]);
   }
 
   public void testFilter() {

jre/javatests/com/google/j2cl/jre/java9/util/OptionalDoubleTest.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.j2cl.jre.java9.util;
+
+import com.google.j2cl.jre.java.util.EmulTestBase;
+import java.util.OptionalDouble;
+import java.util.stream.Stream;
+
+/** Tests for java.util.OptionalDouble Java 9 API emulation. */
+public class OptionalDoubleTest extends EmulTestBase {
+
+  public void testStream() {
+    assertEquals(0, OptionalDouble.empty().stream().count());
+    assertEquals(1, OptionalDouble.of(10.0).stream().count());
+
+    assertEquals(
+        new double[] {10.0, 100.0, 1000.0},
+        Stream.of(
+                OptionalDouble.of(10.0),
+                OptionalDouble.empty(),
+                OptionalDouble.of(100.0),
+                OptionalDouble.of(1000.0))
+            .flatMapToDouble(OptionalDouble::stream)
+            .toArray());
+  }
+}

jre/javatests/com/google/j2cl/jre/java9/util/OptionalIntTest.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.j2cl.jre.java9.util;
+
+import com.google.j2cl.jre.java.util.EmulTestBase;
+import java.util.OptionalInt;
+import java.util.stream.Stream;
+
+/** Tests for java.util.OptionalInt Java 9 API emulation. */
+public class OptionalIntTest extends EmulTestBase {
+
+  public void testStream() {
+    assertEquals(0, OptionalInt.empty().stream().count());
+    assertEquals(1, OptionalInt.of(10).stream().count());
+
+    assertEquals(
+        new int[] {10, 100, 1000},
+        Stream.of(
+                OptionalInt.of(10), OptionalInt.empty(), OptionalInt.of(100), OptionalInt.of(1000))
+            .flatMapToInt(OptionalInt::stream)
+            .toArray());
+  }
+}