* Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.

 * @bug 8195649

 * @build ObscureException

    static final int INTVAL = 33_550_336;

    static final int UNEXPECTED = 0xCAFEBABE;

    /**

     * Checks a block of assertions over an empty OptionalInt.

     */

    void checkEmpty(OptionalInt empty) {

        assertTrue(empty.equals(OptionalInt.empty()));

        assertTrue(OptionalInt.empty().equals(empty));

        assertFalse(empty.equals(OptionalInt.of(UNEXPECTED)));

        assertFalse(OptionalInt.of(UNEXPECTED).equals(empty));

        assertFalse(empty.equals("unexpected"));

        assertFalse(empty.isPresent());

        assertEquals(empty.hashCode(), 0);

        assertEquals(empty.orElse(UNEXPECTED), UNEXPECTED);

        assertEquals(empty.orElseGet(() -> UNEXPECTED), UNEXPECTED);

        assertThrows(NoSuchElementException.class, () -> empty.getAsInt());

        assertThrows(NoSuchElementException.class, () -> empty.orElseThrow());

        assertThrows(ObscureException.class,       () -> empty.orElseThrow(ObscureException::new));

        var b = new AtomicBoolean();

        empty.ifPresent(s -> b.set(true));

        assertFalse(b.get());

        var b1 = new AtomicBoolean(false);

        var b2 = new AtomicBoolean(false);

        empty.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));

        assertFalse(b1.get());

        assertTrue(b2.get());

        assertEquals(empty.toString(), "OptionalInt.empty");

    }

    /**

     * Checks a block of assertions over an OptionalInt that is expected to

     * have a particular value present.

     */

    void checkPresent(OptionalInt opt, int expected) {

        assertFalse(opt.equals(OptionalInt.empty()));

        assertFalse(OptionalInt.empty().equals(opt));

        assertTrue(opt.equals(OptionalInt.of(expected)));

        assertTrue(OptionalInt.of(expected).equals(opt));

        assertFalse(opt.equals(OptionalInt.of(UNEXPECTED)));

        assertFalse(OptionalInt.of(UNEXPECTED).equals(opt));

        assertFalse(opt.equals("unexpected"));

        assertTrue(opt.isPresent());

        assertEquals(opt.hashCode(), Integer.hashCode(expected));

        assertEquals(opt.orElse(UNEXPECTED), expected);

        assertEquals(opt.orElseGet(() -> UNEXPECTED), expected);

        assertEquals(opt.getAsInt(), expected);

        assertEquals(opt.orElseThrow(), expected);

        assertEquals(opt.orElseThrow(ObscureException::new), expected);

        var b = new AtomicBoolean(false);

        opt.ifPresent(s -> b.set(true));

        assertTrue(b.get());

        var b1 = new AtomicBoolean(false);

        var b2 = new AtomicBoolean(false);

        opt.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));

        assertTrue(b1.get());

        assertFalse(b2.get());

        assertEquals(opt.toString(), "OptionalInt[" + expected + "]");

    public void testEmpty() {

        checkEmpty(OptionalInt.empty());

        checkPresent(OptionalInt.of(INTVAL), INTVAL);

    public void testStreamEmpty() {

        assertEquals(OptionalInt.empty().stream().toArray(), new int[] { });

    @Test(groups = "unit")

    public void testStreamPresent() {

        assertEquals(OptionalInt.of(INTVAL).stream().toArray(), new int[] { INTVAL });