< prev index next >

test/jdk/java/util/Optional/BasicLong.java

Print this page




  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 8195649
  26  * @summary Basic functional test of OptionalLong
  27  * @author Mike Duigou
  28  * @build ObscureException
  29  * @run testng BasicLong
  30  */
  31 
  32 import java.util.NoSuchElementException;
  33 import java.util.OptionalLong;

  34 import java.util.concurrent.atomic.AtomicBoolean;

  35 
  36 import static org.testng.Assert.*;
  37 import org.testng.annotations.Test;
  38 
  39 public class BasicLong {
  40     static final long LONGVAL = 2_305_843_008_139_952_128L;
  41     static final long UNEXPECTED = 0xFEEDBEEFCAFEBABEL;
  42 
  43     /**
  44      * Checks a block of assertions over an empty OptionalLong.
  45      */
  46     void checkEmpty(OptionalLong empty) {
  47         assertTrue(empty.equals(OptionalLong.empty()));
  48         assertTrue(OptionalLong.empty().equals(empty));
  49         assertFalse(empty.equals(OptionalLong.of(UNEXPECTED)));
  50         assertFalse(OptionalLong.of(UNEXPECTED).equals(empty));
  51         assertFalse(empty.equals("unexpected"));
  52 
  53         assertFalse(empty.isPresent());

  54         assertEquals(empty.hashCode(), 0);
  55         assertEquals(empty.orElse(UNEXPECTED), UNEXPECTED);
  56         assertEquals(empty.orElseGet(() -> UNEXPECTED), UNEXPECTED);
  57 
  58         assertThrows(NoSuchElementException.class, () -> empty.getAsLong());
  59         assertThrows(NoSuchElementException.class, () -> empty.orElseThrow());
  60         assertThrows(ObscureException.class,       () -> empty.orElseThrow(ObscureException::new));
  61 
  62         var b = new AtomicBoolean();
  63         empty.ifPresent(s -> b.set(true));
  64         assertFalse(b.get());
  65 
  66         var b1 = new AtomicBoolean(false);
  67         var b2 = new AtomicBoolean(false);
  68         empty.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));
  69         assertFalse(b1.get());
  70         assertTrue(b2.get());
  71 
  72         assertEquals(empty.toString(), "OptionalLong.empty");
  73     }


 109 
 110     @Test(groups = "unit")
 111     public void testEmpty() {
 112         checkEmpty(OptionalLong.empty());
 113     }
 114 
 115     @Test(groups = "unit")
 116     public void testPresent() {
 117         checkPresent(OptionalLong.of(LONGVAL), LONGVAL);
 118     }
 119 
 120     @Test(groups = "unit")
 121     public void testStreamEmpty() {
 122         assertEquals(OptionalLong.empty().stream().toArray(), new long[] { });
 123     }
 124 
 125     @Test(groups = "unit")
 126     public void testStreamPresent() {
 127         assertEquals(OptionalLong.of(LONGVAL).stream().toArray(), new long[] { LONGVAL });
 128     }
















 129 }


  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 8195649
  26  * @summary Basic functional test of OptionalLong
  27  * @author Mike Duigou
  28  * @build ObscureException
  29  * @run testng BasicLong
  30  */
  31 
  32 import java.util.NoSuchElementException;
  33 import java.util.OptionalLong;
  34 import java.util.function.LongPredicate;
  35 import java.util.concurrent.atomic.AtomicBoolean;
  36 import java.util.List;
  37 
  38 import static org.testng.Assert.*;
  39 import org.testng.annotations.Test;
  40 
  41 public class BasicLong {
  42     static final long LONGVAL = 2_305_843_008_139_952_128L;
  43     static final long UNEXPECTED = 0xFEEDBEEFCAFEBABEL;
  44 
  45     /**
  46      * Checks a block of assertions over an empty OptionalLong.
  47      */
  48     void checkEmpty(OptionalLong empty) {
  49         assertTrue(empty.equals(OptionalLong.empty()));
  50         assertTrue(OptionalLong.empty().equals(empty));
  51         assertFalse(empty.equals(OptionalLong.of(UNEXPECTED)));
  52         assertFalse(OptionalLong.of(UNEXPECTED).equals(empty));
  53         assertFalse(empty.equals("unexpected"));
  54 
  55         assertFalse(empty.isPresent());
  56         assertTrue(empty.isEmpty());
  57         assertEquals(empty.hashCode(), 0);
  58         assertEquals(empty.orElse(UNEXPECTED), UNEXPECTED);
  59         assertEquals(empty.orElseGet(() -> UNEXPECTED), UNEXPECTED);
  60 
  61         assertThrows(NoSuchElementException.class, () -> empty.getAsLong());
  62         assertThrows(NoSuchElementException.class, () -> empty.orElseThrow());
  63         assertThrows(ObscureException.class,       () -> empty.orElseThrow(ObscureException::new));
  64 
  65         var b = new AtomicBoolean();
  66         empty.ifPresent(s -> b.set(true));
  67         assertFalse(b.get());
  68 
  69         var b1 = new AtomicBoolean(false);
  70         var b2 = new AtomicBoolean(false);
  71         empty.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));
  72         assertFalse(b1.get());
  73         assertTrue(b2.get());
  74 
  75         assertEquals(empty.toString(), "OptionalLong.empty");
  76     }


 112 
 113     @Test(groups = "unit")
 114     public void testEmpty() {
 115         checkEmpty(OptionalLong.empty());
 116     }
 117 
 118     @Test(groups = "unit")
 119     public void testPresent() {
 120         checkPresent(OptionalLong.of(LONGVAL), LONGVAL);
 121     }
 122 
 123     @Test(groups = "unit")
 124     public void testStreamEmpty() {
 125         assertEquals(OptionalLong.empty().stream().toArray(), new long[] { });
 126     }
 127 
 128     @Test(groups = "unit")
 129     public void testStreamPresent() {
 130         assertEquals(OptionalLong.of(LONGVAL).stream().toArray(), new long[] { LONGVAL });
 131     }
 132 
 133     @Test(groups = "unit")
 134     public void testIsEmpty() {
 135         OptionalLong empty = OptionalLong.empty();
 136         assertTrue(empty.isEmpty());
 137         OptionalLong present = OptionalLong.of(LONGVAL);
 138         assertFalse(present.isEmpty());
 139         var longList = List.of(1L,2L,3L,4L,5L);
 140         LongPredicate isPositiveNumber = x -> x > 0;
 141         LongPredicate isNegativeNumber = x -> x < 0;
 142         OptionalLong positiveNumber = longList.stream().mapToLong(Long::longValue).filter(isPositiveNumber).findAny();
 143         OptionalLong negativeNumber = longList.stream().mapToLong(Long::longValue).filter(isNegativeNumber).findAny();
 144         assertFalse(positiveNumber.isEmpty());
 145         assertTrue(negativeNumber.isEmpty());
 146     }
 147 
 148 }
< prev index next >