test/jdk/java/util/Optional/Basic.java
changeset 48328 7acf5700d542
parent 47216 71c04702a3d5
child 49507 de0fd2c8a401
child 56357 2954c0c19403
equal deleted inserted replaced
48327:d2a837cf9ff1 48328:7acf5700d542
   130         Optional<Boolean> empty = Optional.empty();
   130         Optional<Boolean> empty = Optional.empty();
   131 
   131 
   132         Boolean got = empty.orElseThrow(ObscureException::new);
   132         Boolean got = empty.orElseThrow(ObscureException::new);
   133     }
   133     }
   134 
   134 
       
   135     @Test(expectedExceptions=NoSuchElementException.class)
       
   136     public void testEmptyOrElseThrowNoArg() throws Exception {
       
   137         Optional<Boolean> empty = Optional.empty();
       
   138 
       
   139         Boolean got = empty.orElseThrow();
       
   140     }
       
   141 
   135     @Test(groups = "unit")
   142     @Test(groups = "unit")
   136     public void testPresent() {
   143     public void testPresent() {
   137         Optional<Boolean> empty = Optional.empty();
   144         Optional<Boolean> empty = Optional.empty();
   138         Optional<String> presentEmptyString = Optional.of("");
   145         Optional<String> presentEmptyString = Optional.of("");
   139         Optional<Boolean> present = Optional.of(Boolean.TRUE);
   146         Optional<Boolean> present = Optional.of(Boolean.TRUE);
   145         assertTrue(Boolean.TRUE.hashCode() == present.hashCode());
   152         assertTrue(Boolean.TRUE.hashCode() == present.hashCode());
   146         assertTrue(!present.toString().isEmpty());
   153         assertTrue(!present.toString().isEmpty());
   147         assertTrue(!present.toString().equals(presentEmptyString.toString()));
   154         assertTrue(!present.toString().equals(presentEmptyString.toString()));
   148         assertTrue(-1 != present.toString().indexOf(Boolean.TRUE.toString()));
   155         assertTrue(-1 != present.toString().indexOf(Boolean.TRUE.toString()));
   149         assertSame(Boolean.TRUE, present.get());
   156         assertSame(Boolean.TRUE, present.get());
       
   157         assertSame(Boolean.TRUE, present.orElseThrow());
   150 
   158 
   151         AtomicBoolean presentCheck = new AtomicBoolean();
   159         AtomicBoolean presentCheck = new AtomicBoolean();
   152         present.ifPresent(v -> presentCheck.set(true));
   160         present.ifPresent(v -> presentCheck.set(true));
   153         assertTrue(presentCheck.get());
   161         assertTrue(presentCheck.get());
   154         presentCheck.set(false);
   162         presentCheck.set(false);
   189         assertFalse(instance.isPresent());
   197         assertFalse(instance.isPresent());
   190 
   198 
   191         instance = Optional.ofNullable("Duke");
   199         instance = Optional.ofNullable("Duke");
   192         assertTrue(instance.isPresent());
   200         assertTrue(instance.isPresent());
   193         assertEquals(instance.get(), "Duke");
   201         assertEquals(instance.get(), "Duke");
       
   202         assertEquals(instance.orElseThrow(), "Duke");
   194     }
   203     }
   195 
   204 
   196     @Test(groups = "unit")
   205     @Test(groups = "unit")
   197     public void testFilter() {
   206     public void testFilter() {
   198         // Null mapper function
   207         // Null mapper function
   212         result = duke.filter(String::isEmpty);
   221         result = duke.filter(String::isEmpty);
   213         assertFalse(result.isPresent());
   222         assertFalse(result.isPresent());
   214         result = duke.filter(s -> s.startsWith("D"));
   223         result = duke.filter(s -> s.startsWith("D"));
   215         assertTrue(result.isPresent());
   224         assertTrue(result.isPresent());
   216         assertEquals(result.get(), "Duke");
   225         assertEquals(result.get(), "Duke");
       
   226         assertEquals(result.orElseThrow(), "Duke");
   217 
   227 
   218         Optional<String> emptyString = Optional.of("");
   228         Optional<String> emptyString = Optional.of("");
   219         result = emptyString.filter(String::isEmpty);
   229         result = emptyString.filter(String::isEmpty);
   220         assertTrue(result.isPresent());
   230         assertTrue(result.isPresent());
   221         assertEquals(result.get(), "");
   231         assertEquals(result.get(), "");
       
   232         assertEquals(result.orElseThrow(), "");
   222     }
   233     }
   223 
   234 
   224     @Test(groups = "unit")
   235     @Test(groups = "unit")
   225     public void testMap() {
   236     public void testMap() {
   226         Optional<String> empty = Optional.empty();
   237         Optional<String> empty = Optional.empty();
   285         // Map to value
   296         // Map to value
   286         Optional<Integer> fixture = Optional.of(Integer.MAX_VALUE);
   297         Optional<Integer> fixture = Optional.of(Integer.MAX_VALUE);
   287         l = duke.flatMap(s -> Optional.of(s.length()));
   298         l = duke.flatMap(s -> Optional.of(s.length()));
   288         assertTrue(l.isPresent());
   299         assertTrue(l.isPresent());
   289         assertEquals(l.get().intValue(), 4);
   300         assertEquals(l.get().intValue(), 4);
       
   301         assertEquals(l.orElseThrow().intValue(), 4);
   290 
   302 
   291         // Verify same instance
   303         // Verify same instance
   292         l = duke.flatMap(s -> fixture);
   304         l = duke.flatMap(s -> fixture);
   293         assertSame(l, fixture);
   305         assertSame(l, fixture);
   294     }
   306     }