/* * Copyright 2015 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.gwt.emultest.java8.util; import com.google.gwt.core.client.JavaScriptException; import com.google.gwt.junit.client.GWTTestCase; import java.util.NoSuchElementException; import java.util.Optional; /** * Tests for Optional JRE emulation. */ public class OptionalTest extends GWTTestCase { private static final Object REFERENCE = new Object(); private static final Object OTHER_REFERENCE = new Object(); private boolean[] mutableFlag; private Optional<Object> empty; private Optional<Object> present; @Override public String getModuleName() { return "com.google.gwt.emultest.EmulSuite"; } @Override protected void gwtSetUp() throws Exception { super.gwtSetUp(); mutableFlag = new boolean[1]; empty = Optional.empty(); present = Optional.of(REFERENCE); } public void testIsPresent() { // empty case assertFalse(empty.isPresent()); empty = Optional.ofNullable(null); assertFalse(empty.isPresent()); // non-empty case assertTrue(present.isPresent()); present = Optional.ofNullable(REFERENCE); assertTrue(present.isPresent()); } public void testGet() { // empty case try { empty.get(); fail("Empty Optional should throw NoSuchElementException"); } catch (NoSuchElementException e) { // expected } // non-empty case assertSame(REFERENCE, present.get()); } public void testIfPresent() { // empty case empty.ifPresent(null); // should not fail as per JavaDoc empty.ifPresent(wrapped -> fail("Empty Optional should not execute consumer")); // non-empty case try { present.ifPresent(null); fail("Non-Empty Optional must throw NullPointerException if consumer is null"); } catch (NullPointerException e) { // expected } catch (JavaScriptException e) { // expected } present.ifPresent((wrapped) -> { assertSame(REFERENCE, wrapped); mutableFlag[0] = true; }); assertTrue("Consumer not executed", mutableFlag[0]); } public void testFilter() { // empty case try { empty.filter(null); fail("Optional must throw NullPointerException if predicate is null"); } catch (NullPointerException e) { // expected } Optional<Object> filtered = empty.filter(wrapped -> true); assertFalse(filtered.isPresent()); filtered = empty.filter(wrapped -> false); assertFalse(filtered.isPresent()); // non-empty case try { present.filter(null); fail("Optional must throw NullPointerException if predicate is null"); } catch (NullPointerException e) { // expected } filtered = present.filter(wrapped -> true); assertSame(REFERENCE, filtered.get()); filtered = present.filter(wrapped -> false); assertFalse(filtered.isPresent()); } public void testMap() { // empty case try { empty.map(null); fail("Optional must throw NullPointerException if mapper is null"); } catch (NullPointerException e) { // expected } empty.map(wrapped -> { fail("Empty Optional must not execute mapper"); return "should not execute"; }); // non-empty case try { present.map(null); fail("Optional must throw NullPointerException if mapper is null"); } catch (NullPointerException e) { // expected } Optional<String> mapped = present.map(wrapped -> null); assertFalse(mapped.isPresent()); mapped = present.map(Object::toString); assertEquals(REFERENCE.toString(), mapped.get()); } public void testFlatMap() { // empty case try { empty.flatMap(null); fail("Optional must throw NullPointerException if mapper is null"); } catch (NullPointerException e) { // expected } empty.flatMap(wrapped -> { fail("Empty Optional must not execute mapper"); return Optional.of("should not execute"); }); // non-empty case try { present.flatMap(null); fail("Optional must throw NullPointerException if mapper is null"); } catch (NullPointerException e) { // expected } try { present.flatMap(wrapped -> null); fail("Optional must throw NullPointerException if mapper returns null"); } catch (NullPointerException e) { // expected } Optional<String> mapped = present.flatMap(wrapped -> Optional.empty()); assertFalse(mapped.isPresent()); mapped = present.flatMap(wrapped -> Optional.of(wrapped.toString())); assertEquals(REFERENCE.toString(), mapped.get()); } public void testOrElse() { // empty case assertSame(OTHER_REFERENCE, empty.orElse(OTHER_REFERENCE)); // non-empty case assertSame(REFERENCE, present.orElse(OTHER_REFERENCE)); } public void testOrElseGet() { // empty case try { empty.orElseGet(null); fail("Empty Optional must throw NullPointerException if supplier is null"); } catch (NullPointerException e) { // expected } catch (JavaScriptException e) { // expected } assertSame(OTHER_REFERENCE, empty.orElseGet(() -> OTHER_REFERENCE)); // non-empty case assertSame(REFERENCE, present.orElseGet(() -> { fail("Optional must not execute supplier"); return OTHER_REFERENCE; })); } public void testOrElseThrow() { // empty case try { empty.orElseThrow(null); fail("Empty Optional must throw NullPointerException if supplier is null"); } catch (NullPointerException e) { // expected } catch (JavaScriptException e) { // expected } try { empty.<RuntimeException>orElseThrow(() -> null); fail("Empty Optional must throw NullPointerException if supplier returns null"); } catch (NullPointerException e) { // expected } catch (JavaScriptException e) { // expected } try { empty.orElseThrow(IllegalStateException::new); fail("Empty Optional must throw supplied exception"); } catch (IllegalStateException e) { // expected } // non-empty case try { Object reference = present.orElseThrow(null); assertSame(REFERENCE, reference); } catch (NullPointerException e) { fail("Optional must not throw NullPointerException if supplier is null"); } assertSame(REFERENCE, present.orElseThrow(() -> { fail("Optional must not execute supplier"); return new RuntimeException("should not execute"); })); } public void testEquals() { // empty case assertFalse(empty.equals(null)); assertFalse(empty.equals("should not be equal")); assertFalse(empty.equals(present)); assertTrue(empty.equals(empty)); assertTrue(empty.equals(Optional.empty())); // non empty case assertFalse(present.equals(null)); assertFalse(present.equals("should not be equal")); assertFalse(present.equals(empty)); assertFalse(present.equals(Optional.of(OTHER_REFERENCE))); assertTrue(present.equals(present)); assertTrue(present.equals(Optional.of(REFERENCE))); } public void testHashcode() { // empty case assertEquals(0, empty.hashCode()); // non empty case assertEquals(REFERENCE.hashCode(), present.hashCode()); } }