< prev index next >

test/jdk/java/util/Optional/BasicInt.java

Print this page




  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 OptionalInt
  27  * @author Mike Duigou
  28  * @build ObscureException
  29  * @run testng BasicInt
  30  */
  31 
  32 import java.util.NoSuchElementException;
  33 import java.util.OptionalInt;
  34 import java.util.concurrent.atomic.AtomicBoolean;


  35 
  36 import static org.testng.Assert.*;
  37 import org.testng.annotations.Test;
  38 
  39 public class BasicInt {
  40 
  41     static final int INTVAL = 33_550_336;
  42     static final int UNEXPECTED = 0xCAFEBABE;
  43 
  44     /**
  45      * Checks a block of assertions over an empty OptionalInt.
  46      */
  47     void checkEmpty(OptionalInt empty) {
  48         assertTrue(empty.equals(OptionalInt.empty()));
  49         assertTrue(OptionalInt.empty().equals(empty));
  50         assertFalse(empty.equals(OptionalInt.of(UNEXPECTED)));
  51         assertFalse(OptionalInt.of(UNEXPECTED).equals(empty));
  52         assertFalse(empty.equals("unexpected"));
  53 
  54         assertFalse(empty.isPresent());


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


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
















 130 }


  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 OptionalInt
  27  * @author Mike Duigou
  28  * @build ObscureException
  29  * @run testng BasicInt
  30  */
  31 
  32 import java.util.NoSuchElementException;
  33 import java.util.OptionalInt;
  34 import java.util.concurrent.atomic.AtomicBoolean;
  35 import java.util.function.IntPredicate;
  36 import java.util.List;
  37 
  38 import static org.testng.Assert.*;
  39 import org.testng.annotations.Test;
  40 
  41 public class BasicInt {
  42 
  43     static final int INTVAL = 33_550_336;
  44     static final int UNEXPECTED = 0xCAFEBABE;
  45 
  46     /**
  47      * Checks a block of assertions over an empty OptionalInt.
  48      */
  49     void checkEmpty(OptionalInt empty) {
  50         assertTrue(empty.equals(OptionalInt.empty()));
  51         assertTrue(OptionalInt.empty().equals(empty));
  52         assertFalse(empty.equals(OptionalInt.of(UNEXPECTED)));
  53         assertFalse(OptionalInt.of(UNEXPECTED).equals(empty));
  54         assertFalse(empty.equals("unexpected"));
  55 
  56         assertFalse(empty.isPresent());
  57         assertTrue(empty.isEmpty());
  58 
  59         assertEquals(empty.hashCode(), 0);
  60         assertEquals(empty.orElse(UNEXPECTED), UNEXPECTED);
  61         assertEquals(empty.orElseGet(() -> UNEXPECTED), UNEXPECTED);
  62 
  63         assertThrows(NoSuchElementException.class, () -> empty.getAsInt());
  64         assertThrows(NoSuchElementException.class, () -> empty.orElseThrow());
  65         assertThrows(ObscureException.class,       () -> empty.orElseThrow(ObscureException::new));
  66 
  67         var b = new AtomicBoolean();
  68         empty.ifPresent(s -> b.set(true));
  69         assertFalse(b.get());
  70 
  71         var b1 = new AtomicBoolean(false);
  72         var b2 = new AtomicBoolean(false);
  73         empty.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));
  74         assertFalse(b1.get());
  75         assertTrue(b2.get());
  76 
  77         assertEquals(empty.toString(), "OptionalInt.empty");
  78     }


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