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

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

*** 130,139 ****
--- 130,146 ----
          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,154 ****
--- 152,162 ----
          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,198 ****
--- 197,207 ----
          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,226 ****
--- 221,237 ----
          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,294 ****
--- 296,306 ----
          // 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);
      }