1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
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 * @summary Basic functional test of OptionalLong
26 * @author Mike Duigou
27 * @run testng BasicLong
28 */
29
30 import java.util.NoSuchElementException;
31 import java.util.OptionalLong;
32 import java.util.concurrent.atomic.AtomicBoolean;
33 import java.util.stream.LongStream;
34
35 import static org.testng.Assert.*;
36 import org.testng.annotations.Test;
37
38
39 public class BasicLong {
40
41 @Test(groups = "unit")
42 public void testEmpty() {
43 OptionalLong empty = OptionalLong.empty();
44 OptionalLong present = OptionalLong.of(1);
45
46 // empty
47 assertTrue(empty.equals(empty));
48 assertTrue(empty.equals(OptionalLong.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, empty.orElse(2));
71 assertEquals(2, empty.orElseGet(()-> 2));
72 }
73
74 @Test(groups = "unit")
75 public void testIfPresentAndOrElseAndNull() {
76 OptionalLong empty = OptionalLong.empty();
77 OptionalLong present = OptionalLong.of(1);
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 OptionalLong empty = OptionalLong.empty();
102
103 long got = empty.getAsLong();
104 }
105
106 @Test(expectedExceptions=NullPointerException.class)
107 public void testEmptyOrElseGetNull() {
108 OptionalLong empty = OptionalLong.empty();
109
110 long got = empty.orElseGet(null);
111 }
112
113 @Test(expectedExceptions=NullPointerException.class)
114 public void testEmptyOrElseThrowNull() throws Throwable {
115 OptionalLong empty = OptionalLong.empty();
116
117 long got = empty.orElseThrow(null);
118 }
119
120 @Test(expectedExceptions=ObscureException.class)
121 public void testEmptyOrElseThrow() throws Exception {
122 OptionalLong empty = OptionalLong.empty();
123
124 long got = empty.orElseThrow(ObscureException::new);
125 }
126
127 @Test(expectedExceptions=NoSuchElementException.class)
128 public void testEmptyOrElseThrowNoArg() throws Exception {
129 OptionalLong empty = OptionalLong.empty();
130
131 long got = empty.orElseThrow();
132 }
133
134 @Test(groups = "unit")
135 public void testPresent() {
136 OptionalLong empty = OptionalLong.empty();
137 OptionalLong present = OptionalLong.of(1L);
138
139 // present
140 assertTrue(present.equals(present));
141 assertFalse(present.equals(OptionalLong.of(0L)));
142 assertTrue(present.equals(OptionalLong.of(1L)));
143 assertFalse(present.equals(empty));
144 assertTrue(Long.hashCode(1) == present.hashCode());
145 assertFalse(present.toString().isEmpty());
146 assertTrue(-1 != present.toString().indexOf(Long.toString(present.getAsLong()).toString()));
147 assertTrue(-1 != present.toString().indexOf(Long.toString(present.orElseThrow()).toString()));
148 assertEquals(1L, present.getAsLong());
149 assertEquals(1L, 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 -> {
169 throw new ObscureException();
170 }, () -> fail());
171 fail();
172 } catch (ObscureException expected) {
173 } catch (AssertionError e) {
174 throw e;
175 } catch (Throwable t) {
176 fail();
177 }
178
179 assertEquals(1, present.orElse(2));
180 assertEquals(1, present.orElseGet(null));
181 assertEquals(1, present.orElseGet(()-> 2));
182 assertEquals(1, present.orElseGet(()-> 3));
183 assertEquals(1, present.<RuntimeException>orElseThrow(null));
184 assertEquals(1, present.<RuntimeException>orElseThrow(ObscureException::new));
185 }
186
187 @Test(groups = "unit")
188 public void testStream() {
189 {
190 LongStream s = OptionalLong.empty().stream();
191
192 long[] es = s.toArray();
193 assertEquals(es.length, 0);
194 }
195
196 {
197 LongStream s = OptionalLong.of(42L).stream();
198
199 long[] es = s.toArray();
200 assertEquals(es.length, 1);
201 assertEquals(es[0], 42L);
202 }
203 }
204
205 private static class ObscureException extends RuntimeException {
206
207 }
208 }
|
1 /*
2 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
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 }
74
75 /**
76 * Checks a block of assertions over an OptionalLong that is expected to
77 * have a particular value present.
78 */
79 void checkPresent(OptionalLong opt, long expected) {
80 assertFalse(opt.equals(OptionalLong.empty()));
81 assertFalse(OptionalLong.empty().equals(opt));
82 assertTrue(opt.equals(OptionalLong.of(expected)));
83 assertTrue(OptionalLong.of(expected).equals(opt));
84 assertFalse(opt.equals(OptionalLong.of(UNEXPECTED)));
85 assertFalse(OptionalLong.of(UNEXPECTED).equals(opt));
86 assertFalse(opt.equals("unexpected"));
87
88 assertTrue(opt.isPresent());
89 assertEquals(opt.hashCode(), Long.hashCode(expected));
90 assertEquals(opt.orElse(UNEXPECTED), expected);
91 assertEquals(opt.orElseGet(() -> UNEXPECTED), expected);
92
93 assertEquals(opt.getAsLong(), expected);
94 assertEquals(opt.orElseThrow(), expected);
95 assertEquals(opt.orElseThrow(ObscureException::new), expected);
96
97 var b = new AtomicBoolean(false);
98 opt.ifPresent(s -> b.set(true));
99 assertTrue(b.get());
100
101 var b1 = new AtomicBoolean(false);
102 var b2 = new AtomicBoolean(false);
103 opt.ifPresentOrElse(s -> b1.set(true), () -> b2.set(true));
104 assertTrue(b1.get());
105 assertFalse(b2.get());
106
107 assertEquals(opt.toString(), "OptionalLong[" + expected + "]");
108 }
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 }
|