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

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

    39 public class BasicDouble {

    41     /**

    42      * Checks a block of assertions over an empty OptionalDouble.

    43      */

    44     void checkEmpty(OptionalDouble empty) {

    45         assertTrue(empty.equals(OptionalDouble.empty()));

    46         assertTrue(OptionalDouble.empty().equals(empty));

    47         assertFalse(empty.equals(OptionalDouble.of(UNEXPECTED)));

    48         assertFalse(OptionalDouble.of(UNEXPECTED).equals(empty));

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

    50 

    51         assertFalse(empty.isPresent());

    52         assertEquals(empty.hashCode(), 0);

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

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

    55 

    56         assertThrows(NoSuchElementException.class, () -> empty.getAsDouble());

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

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

    59 

    60         var b = new AtomicBoolean();

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

    62         assertFalse(b.get());

    63 

    64         var b1 = new AtomicBoolean(false);

    65         var b2 = new AtomicBoolean(false);

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

    67         assertFalse(b1.get());

    68         assertTrue(b2.get());

    69 

    70         assertEquals(empty.toString(), "OptionalDouble.empty");

    71     }

    72 

    73     /**

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

    75      * have a particular value present.

    76      */

    77     void checkPresent(OptionalDouble opt, double expected) {

    78         assertFalse(opt.equals(OptionalDouble.empty()));

    79         assertFalse(OptionalDouble.empty().equals(opt));

    80         assertTrue(opt.equals(OptionalDouble.of(expected)));

    81         assertTrue(OptionalDouble.of(expected).equals(opt));

    82         assertFalse(opt.equals(OptionalDouble.of(UNEXPECTED)));

    83         assertFalse(OptionalDouble.of(UNEXPECTED).equals(opt));

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

    85 

    86         assertTrue(opt.isPresent());

    87         assertEquals(opt.hashCode(), Double.hashCode(expected));

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

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

    90 

    91         assertEquals(opt.getAsDouble(), expected);

    92         assertEquals(opt.orElseThrow(), expected);

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

    94 

    95         var b = new AtomicBoolean(false);

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

    97         assertTrue(b.get());

    98 

    99         var b1 = new AtomicBoolean(false);

   100         var b2 = new AtomicBoolean(false);

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

   102         assertTrue(b1.get());

   103         assertFalse(b2.get());

   104 

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

   106     }

    43         OptionalDouble empty = OptionalDouble.empty();

   110         checkEmpty(OptionalDouble.empty());

    44         OptionalDouble present = OptionalDouble.of(1.0);

    45 

    46         // empty

    47         assertTrue(empty.equals(empty));

    48         assertTrue(empty.equals(OptionalDouble.empty()));

    49         assertTrue(!empty.equals(present));

    50         assertTrue(0 == empty.hashCode());

    51         assertTrue(!empty.toString().isEmpty());

    52         assertTrue(!empty.isPresent());

    53 

    54         empty.ifPresent(v -> { fail(); });

    55 

    56         AtomicBoolean emptyCheck = new AtomicBoolean();

    57         empty.ifPresentOrElse(v -> fail(), () -> emptyCheck.set(true));

    58         assertTrue(emptyCheck.get());

    59 

    60         try {

    61             empty.ifPresentOrElse(v -> fail(), () -> { throw new ObscureException(); });

    62             fail();

    63         } catch (ObscureException expected) {

    64         } catch (AssertionError e) {

    65             throw e;

    66         } catch (Throwable t) {

    67             fail();

    68         }

    69 

    70         assertEquals(2.0, empty.orElse(2.0));

    71         assertEquals(2.0, empty.orElseGet(()-> 2.0));

    75     public void testIfPresentAndOrElseAndNull() {

   114     public void testOf() {

    76         OptionalDouble empty = OptionalDouble.empty();

   115         checkPresent(OptionalDouble.of(Math.PI), Math.PI);

    77         OptionalDouble present = OptionalDouble.of(1.0);

    78 

    79         // No NPE

    80         present.ifPresentOrElse(v -> {}, null);

    81         empty.ifPresent(null);

    82         empty.ifPresentOrElse(null, () -> {});

    83 

    84         // NPE

    85         try {

    86             present.ifPresent(null);

    87             fail();

    88         } catch (NullPointerException ex) {}

    89         try {

    90             present.ifPresentOrElse(null, () -> {});

    91             fail();

    92         } catch (NullPointerException ex) {}

    93         try {

    94             empty.ifPresentOrElse(v -> {}, null);

    95             fail();

    96         } catch (NullPointerException ex) {}

    97     }

    98 

    99     @Test(expectedExceptions=NoSuchElementException.class)

   100     public void testEmptyGet() {

   101         OptionalDouble empty = OptionalDouble.empty();

   102 

   103         double got = empty.getAsDouble();

   104     }

   105 

   106     @Test(expectedExceptions=NullPointerException.class)

   107     public void testEmptyOrElseGetNull() {

   108         OptionalDouble empty = OptionalDouble.empty();

   109 

   110         double got = empty.orElseGet(null);

   111     }

   112 

   113     @Test(expectedExceptions=NullPointerException.class)

   114     public void testEmptyOrElseThrowNull() throws Throwable {

   115         OptionalDouble empty = OptionalDouble.empty();

   116 

   117         double got = empty.orElseThrow(null);

   118     }

   119 

   120     @Test(expectedExceptions=ObscureException.class)

   121     public void testEmptyOrElseThrow() throws Exception {

   122         OptionalDouble empty = OptionalDouble.empty();

   123 

   124         double got = empty.orElseThrow(ObscureException::new);

   125     }

   126 

   127     @Test(expectedExceptions=NoSuchElementException.class)

   128     public void testEmptyOrElseThrowNoArg() throws Exception {

   129         OptionalDouble empty = OptionalDouble.empty();

   130 

   131         double got = empty.orElseThrow();

   135     public void testPresent() {

   119     public void testStreamEmpty() {

   136         OptionalDouble empty = OptionalDouble.empty();

   120         assertEquals(OptionalDouble.empty().stream().toArray().length, 0);

   137         OptionalDouble present = OptionalDouble.of(1.0);

   138 

   139         // present

   140         assertTrue(present.equals(present));

   141         assertFalse(present.equals(OptionalDouble.of(0.0)));

   142         assertTrue(present.equals(OptionalDouble.of(1.0)));

   143         assertTrue(!present.equals(empty));

   144         assertTrue(Double.hashCode(1.0) == present.hashCode());

   145         assertFalse(present.toString().isEmpty());

   146         assertTrue(-1 != present.toString().indexOf(Double.toString(present.getAsDouble()).toString()));

   147         assertTrue(-1 != present.toString().indexOf(Double.toString(present.orElseThrow()).toString()));

   148         assertEquals(1.0, present.getAsDouble());

   149         assertEquals(1.0, present.orElseThrow());

   150 

   151         AtomicBoolean presentCheck = new AtomicBoolean();

   152         present.ifPresent(v -> presentCheck.set(true));

   153         assertTrue(presentCheck.get());

   154         presentCheck.set(false);

   155         present.ifPresentOrElse(v -> presentCheck.set(true), () -> fail());

   156         assertTrue(presentCheck.get());

   157 

   158         try {

   159             present.ifPresent(v -> { throw new ObscureException(); });

   160             fail();

   161         } catch (ObscureException expected) {

   162         } catch (AssertionError e) {

   163             throw e;

   164         } catch (Throwable t) {

   165             fail();

   166         }

   167         try {

   168             present.ifPresentOrElse(v -> { throw new ObscureException(); }, () -> fail());

   169             fail();

   170         } catch (ObscureException expected) {

   171         } catch (AssertionError e) {

   172             throw e;

   173         } catch (Throwable t) {

   174             fail();

   175         }

   176 

   177         assertEquals(1.0, present.orElse(2.0));

   178         assertEquals(1.0, present.orElseGet(null));

   179         assertEquals(1.0, present.orElseGet(()-> 2.0));

   180         assertEquals(1.0, present.orElseGet(()-> 3.0));

   181         assertEquals(1.0, present.<RuntimeException>orElseThrow(null));

   182         assertEquals(1.0, present.<RuntimeException>orElseThrow(ObscureException::new));

   186     public void testStream() {

   124     public void testStreamPresent() {

   187         {

   125         assertEquals(OptionalDouble.of(Math.PI).stream().toArray(), new double[] { Math.PI });

   188             DoubleStream s = OptionalDouble.empty().stream();

   189             assertFalse(s.isParallel());

   190 

   191             double[] es = s.toArray();

   192             assertEquals(es.length, 0);

   193         }

   194 

   195         {

   196             DoubleStream s = OptionalDouble.of(42.0).stream();

   197             assertFalse(s.isParallel());

   198 

   199             double[] es = s.toArray();

   200             assertEquals(es.length, 1);

   201             assertEquals(es[0], 42.0);

   202         }

   203     }

   204 

   205     private static class ObscureException extends RuntimeException {

   206