test/jdk/java/util/Optional/Basic.java

rev 48216 : 8140281: add no-arg Optional.orElseThrow() as preferred alternative to get()
Reviewed-by: XXX

@@ -130,10 +130,17 @@
         Optional<Boolean> empty = Optional.empty();
 
         Boolean got = empty.orElseThrow(ObscureException::new);
     }
 
+    @Test(expectedExceptions=NoSuchElementException.class)
+    public void testEmptyOrElseThrowNoArg() throws Exception {
+        Optional<Boolean> empty = Optional.empty();
+
+        Boolean got = empty.orElseThrow();
+    }
+
     @Test(groups = "unit")
     public void testPresent() {
         Optional<Boolean> empty = Optional.empty();
         Optional<String> presentEmptyString = Optional.of("");
         Optional<Boolean> present = Optional.of(Boolean.TRUE);

@@ -145,10 +152,11 @@
         assertTrue(Boolean.TRUE.hashCode() == present.hashCode());
         assertTrue(!present.toString().isEmpty());
         assertTrue(!present.toString().equals(presentEmptyString.toString()));
         assertTrue(-1 != present.toString().indexOf(Boolean.TRUE.toString()));
         assertSame(Boolean.TRUE, present.get());
+        assertSame(Boolean.TRUE, present.orElseThrow());
 
         AtomicBoolean presentCheck = new AtomicBoolean();
         present.ifPresent(v -> presentCheck.set(true));
         assertTrue(presentCheck.get());
         presentCheck.set(false);

@@ -189,10 +197,11 @@
         assertFalse(instance.isPresent());
 
         instance = Optional.ofNullable("Duke");
         assertTrue(instance.isPresent());
         assertEquals(instance.get(), "Duke");
+        assertEquals(instance.orElseThrow(), "Duke");
     }
 
     @Test(groups = "unit")
     public void testFilter() {
         // Null mapper function

@@ -212,15 +221,17 @@
         result = duke.filter(String::isEmpty);
         assertFalse(result.isPresent());
         result = duke.filter(s -> s.startsWith("D"));
         assertTrue(result.isPresent());
         assertEquals(result.get(), "Duke");
+        assertEquals(result.orElseThrow(), "Duke");
 
         Optional<String> emptyString = Optional.of("");
         result = emptyString.filter(String::isEmpty);
         assertTrue(result.isPresent());
         assertEquals(result.get(), "");
+        assertEquals(result.orElseThrow(), "");
     }
 
     @Test(groups = "unit")
     public void testMap() {
         Optional<String> empty = Optional.empty();

@@ -285,10 +296,11 @@
         // Map to value
         Optional<Integer> fixture = Optional.of(Integer.MAX_VALUE);
         l = duke.flatMap(s -> Optional.of(s.length()));
         assertTrue(l.isPresent());
         assertEquals(l.get().intValue(), 4);
+        assertEquals(l.orElseThrow().intValue(), 4);
 
         // Verify same instance
         l = duke.flatMap(s -> fixture);
         assertSame(l, fixture);
     }