/* * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* @test * @summary Basic functional test of Optional * @author Mike Duigou * @run testng Basic */ import java.lang.AssertionError; import java.lang.NullPointerException; import java.lang.Throwable; import java.util.NoSuchElementException; import java.util.Optional; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Stream; import static org.testng.Assert.*; import org.testng.annotations.Test; public class Basic { @Test(groups = "unit") public void testEmpty() { Optional<Boolean> empty = Optional.empty(); Optional<String> presentEmptyString = Optional.of(""); Optional<Boolean> present = Optional.of(Boolean.TRUE); // empty assertTrue(empty.equals(empty)); assertTrue(empty.equals(Optional.empty())); assertTrue(!empty.equals(present)); assertTrue(0 == empty.hashCode()); assertTrue(!empty.toString().isEmpty()); assertTrue(!empty.toString().equals(presentEmptyString.toString())); assertTrue(!empty.isPresent()); empty.ifPresent(v -> fail()); AtomicBoolean emptyCheck = new AtomicBoolean(); empty.ifPresentOrElse(v -> fail(), () -> emptyCheck.set(true)); assertTrue(emptyCheck.get()); try { empty.ifPresentOrElse(v -> fail(), () -> { throw new ObscureException(); }); fail(); } catch (ObscureException expected) { } catch (AssertionError e) { throw e; } catch (Throwable t) { fail(); } assertSame(null, empty.orElse(null)); RuntimeException orElse = new RuntimeException() { }; assertSame(Boolean.FALSE, empty.orElse(Boolean.FALSE)); assertSame(null, empty.orElseGet(() -> null)); assertSame(Boolean.FALSE, empty.orElseGet(() -> Boolean.FALSE)); } @Test(groups = "unit") public void testIfPresentAndOrElseAndNull() { Optional<Boolean> empty = Optional.empty(); Optional<Boolean> present = Optional.of(Boolean.TRUE); // No NPE present.ifPresentOrElse(v -> {}, null); empty.ifPresent(null); empty.ifPresentOrElse(null, () -> {}); // NPE try { present.ifPresent(null); fail(); } catch (NullPointerException ex) {} try { present.ifPresentOrElse(null, () -> {}); fail(); } catch (NullPointerException ex) {} try { empty.ifPresentOrElse(v -> {}, null); fail(); } catch (NullPointerException ex) {} } @Test(expectedExceptions=NoSuchElementException.class) public void testEmptyGet() { Optional<Boolean> empty = Optional.empty(); Boolean got = empty.get(); } @Test(expectedExceptions=NullPointerException.class) public void testEmptyOrElseGetNull() { Optional<Boolean> empty = Optional.empty(); Boolean got = empty.orElseGet(null); } @Test(expectedExceptions=NullPointerException.class) public void testEmptyOrElseThrowNull() throws Throwable { Optional<Boolean> empty = Optional.empty(); Boolean got = empty.orElseThrow(null); } @Test(expectedExceptions=ObscureException.class) public void testEmptyOrElseThrow() throws Exception { Optional<Boolean> empty = Optional.empty(); Boolean got = empty.orElseThrow(ObscureException::new); } @Test(groups = "unit") public void testPresent() { Optional<Boolean> empty = Optional.empty(); Optional<String> presentEmptyString = Optional.of(""); Optional<Boolean> present = Optional.of(Boolean.TRUE); // present assertTrue(present.equals(present)); assertTrue(present.equals(Optional.of(Boolean.TRUE))); assertTrue(!present.equals(empty)); 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()); AtomicBoolean presentCheck = new AtomicBoolean(); present.ifPresent(v -> presentCheck.set(true)); assertTrue(presentCheck.get()); presentCheck.set(false); present.ifPresentOrElse(v -> presentCheck.set(true), () -> fail()); assertTrue(presentCheck.get()); try { present.ifPresent(v -> { throw new ObscureException(); }); fail(); } catch (ObscureException expected) { } catch (AssertionError e) { throw e; } catch (Throwable t) { fail(); } try { present.ifPresentOrElse(v -> { throw new ObscureException(); }, () -> fail()); fail(); } catch (ObscureException expected) { } catch (AssertionError e) { throw e; } catch (Throwable t) { fail(); } assertSame(Boolean.TRUE, present.orElse(null)); assertSame(Boolean.TRUE, present.orElse(Boolean.FALSE)); assertSame(Boolean.TRUE, present.orElseGet(null)); assertSame(Boolean.TRUE, present.orElseGet(() -> null)); assertSame(Boolean.TRUE, present.orElseGet(() -> Boolean.FALSE)); assertSame(Boolean.TRUE, present.<RuntimeException>orElseThrow(null)); assertSame(Boolean.TRUE, present.<RuntimeException>orElseThrow(ObscureException::new)); } @Test(groups = "unit") public void testOfNullable() { Optional<String> instance = Optional.ofNullable(null); assertFalse(instance.isPresent()); instance = Optional.ofNullable("Duke"); assertTrue(instance.isPresent()); assertEquals(instance.get(), "Duke"); } @Test(groups = "unit") public void testFilter() { // Null mapper function Optional<String> empty = Optional.empty(); Optional<String> duke = Optional.of("Duke"); try { Optional<String> result = empty.filter(null); fail("Should throw NPE on null mapping function"); } catch (NullPointerException npe) { // expected } Optional<String> result = empty.filter(String::isEmpty); assertFalse(result.isPresent()); result = duke.filter(String::isEmpty); assertFalse(result.isPresent()); result = duke.filter(s -> s.startsWith("D")); assertTrue(result.isPresent()); assertEquals(result.get(), "Duke"); Optional<String> emptyString = Optional.of(""); result = emptyString.filter(String::isEmpty); assertTrue(result.isPresent()); assertEquals(result.get(), ""); } @Test(groups = "unit") public void testMap() { Optional<String> empty = Optional.empty(); Optional<String> duke = Optional.of("Duke"); // Null mapper function try { Optional<Boolean> b = empty.map(null); fail("Should throw NPE on null mapping function"); } catch (NullPointerException npe) { // expected } // Map an empty value Optional<Boolean> b = empty.map(String::isEmpty); assertFalse(b.isPresent()); // Map into null b = empty.map(n -> null); assertFalse(b.isPresent()); b = duke.map(s -> null); assertFalse(b.isPresent()); // Map to value Optional<Integer> l = duke.map(String::length); assertEquals(l.get().intValue(), 4); } @Test(groups = "unit") public void testFlatMap() { Optional<String> empty = Optional.empty(); Optional<String> duke = Optional.of("Duke"); // Null mapper function try { Optional<Boolean> b = empty.flatMap(null); fail("Should throw NPE on null mapping function"); } catch (NullPointerException npe) { // expected } // Map into null try { Optional<Boolean> b = duke.flatMap(s -> null); fail("Should throw NPE when mapper return null"); } catch (NullPointerException npe) { // expected } // Empty won't invoke mapper function try { Optional<Boolean> b = empty.flatMap(s -> null); assertFalse(b.isPresent()); } catch (NullPointerException npe) { fail("Mapper function should not be invoked"); } // Map an empty value Optional<Integer> l = empty.flatMap(s -> Optional.of(s.length())); assertFalse(l.isPresent()); // 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); // Verify same instance l = duke.flatMap(s -> fixture); assertSame(l, fixture); } @Test(groups = "unit") public void testOr() { Optional<String> empty = Optional.empty(); Optional<String> duke = Optional.of("Duke"); // Null supplier try { Optional<String> b = empty.or(null); fail("Should throw NPE on null supplier"); } catch (NullPointerException npe) { // expected } // Supply null try { Optional<String> b = empty.or(() -> null); fail("Should throw NPE when supplier returns null"); } catch (NullPointerException npe) { // expected } // Non-empty won't invoke supplier try { Optional<String> b = duke.or(() -> null); assertTrue(b.isPresent()); } catch (NullPointerException npe) { fail("Supplier should not be invoked"); } // Supply for empty Optional<String> suppliedDuke = empty.or(() -> duke); assertTrue(suppliedDuke.isPresent()); assertSame(suppliedDuke, duke); // Supply for non-empty Optional<String> actualDuke = duke.or(() -> Optional.of("Other Duke")); assertTrue(actualDuke.isPresent()); assertSame(actualDuke, duke); } @Test(groups = "unit") public void testStream() { { Stream<String> s = Optional.<String>empty().stream(); assertFalse(s.isParallel()); Object[] es = s.toArray(); assertEquals(es.length, 0); } { Stream<String> s = Optional.of("Duke").stream(); assertFalse(s.isParallel()); String[] es = s.toArray(String[]::new); assertEquals(es.length, 1); assertEquals(es[0], "Duke"); } } private static class ObscureException extends RuntimeException { } }