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 Optional
26 * @author Mike Duigou
27 * @run testng Basic
28 */
29
30 import java.lang.AssertionError;
31 import java.lang.NullPointerException;
32 import java.lang.Throwable;
33 import java.util.NoSuchElementException;
34 import java.util.Optional;
35 import java.util.concurrent.atomic.AtomicBoolean;
36 import java.util.stream.Stream;
37
38 import static org.testng.Assert.*;
39 import org.testng.annotations.Test;
40
41
42 public class Basic {
43
44 @Test(groups = "unit")
45 public void testEmpty() {
46 Optional<Boolean> empty = Optional.empty();
47 Optional<String> presentEmptyString = Optional.of("");
48 Optional<Boolean> present = Optional.of(Boolean.TRUE);
49
50 // empty
51 assertTrue(empty.equals(empty));
52 assertTrue(empty.equals(Optional.empty()));
53 assertTrue(!empty.equals(present));
54 assertTrue(0 == empty.hashCode());
55 assertTrue(!empty.toString().isEmpty());
56 assertTrue(!empty.toString().equals(presentEmptyString.toString()));
57 assertTrue(!empty.isPresent());
58
59 empty.ifPresent(v -> fail());
60
61 AtomicBoolean emptyCheck = new AtomicBoolean();
62 empty.ifPresentOrElse(v -> fail(), () -> emptyCheck.set(true));
63 assertTrue(emptyCheck.get());
64
65 try {
66 empty.ifPresentOrElse(v -> fail(), () -> { throw new ObscureException(); });
67 fail();
68 } catch (ObscureException expected) {
69 } catch (AssertionError e) {
70 throw e;
71 } catch (Throwable t) {
72 fail();
73 }
74
75 assertSame(null, empty.orElse(null));
76 RuntimeException orElse = new RuntimeException() { };
77 assertSame(Boolean.FALSE, empty.orElse(Boolean.FALSE));
78 assertSame(null, empty.orElseGet(() -> null));
79 assertSame(Boolean.FALSE, empty.orElseGet(() -> Boolean.FALSE));
80 }
81
82 @Test(groups = "unit")
83 public void testIfPresentAndOrElseAndNull() {
84 Optional<Boolean> empty = Optional.empty();
85 Optional<Boolean> present = Optional.of(Boolean.TRUE);
86
87 // No NPE
88 present.ifPresentOrElse(v -> {}, null);
89 empty.ifPresent(null);
90 empty.ifPresentOrElse(null, () -> {});
91
92 // NPE
93 try {
94 present.ifPresent(null);
95 fail();
96 } catch (NullPointerException ex) {}
97 try {
98 present.ifPresentOrElse(null, () -> {});
99 fail();
100 } catch (NullPointerException ex) {}
101 try {
102 empty.ifPresentOrElse(v -> {}, null);
103 fail();
104 } catch (NullPointerException ex) {}
105 }
106
107 @Test(expectedExceptions=NoSuchElementException.class)
108 public void testEmptyGet() {
109 Optional<Boolean> empty = Optional.empty();
110
111 Boolean got = empty.get();
112 }
113
114 @Test(expectedExceptions=NullPointerException.class)
115 public void testEmptyOrElseGetNull() {
116 Optional<Boolean> empty = Optional.empty();
117
118 Boolean got = empty.orElseGet(null);
119 }
120
121 @Test(expectedExceptions=NullPointerException.class)
122 public void testEmptyOrElseThrowNull() throws Throwable {
123 Optional<Boolean> empty = Optional.empty();
124
125 Boolean got = empty.orElseThrow(null);
126 }
127
128 @Test(expectedExceptions=ObscureException.class)
129 public void testEmptyOrElseThrow() throws Exception {
130 Optional<Boolean> empty = Optional.empty();
131
132 Boolean got = empty.orElseThrow(ObscureException::new);
133 }
134
135 @Test(groups = "unit")
136 public void testPresent() {
137 Optional<Boolean> empty = Optional.empty();
138 Optional<String> presentEmptyString = Optional.of("");
139 Optional<Boolean> present = Optional.of(Boolean.TRUE);
140
141 // present
142 assertTrue(present.equals(present));
143 assertTrue(present.equals(Optional.of(Boolean.TRUE)));
144 assertTrue(!present.equals(empty));
145 assertTrue(Boolean.TRUE.hashCode() == present.hashCode());
146 assertTrue(!present.toString().isEmpty());
147 assertTrue(!present.toString().equals(presentEmptyString.toString()));
148 assertTrue(-1 != present.toString().indexOf(Boolean.TRUE.toString()));
149 assertSame(Boolean.TRUE, present.get());
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 assertSame(Boolean.TRUE, present.orElse(null));
178 assertSame(Boolean.TRUE, present.orElse(Boolean.FALSE));
179 assertSame(Boolean.TRUE, present.orElseGet(null));
180 assertSame(Boolean.TRUE, present.orElseGet(() -> null));
181 assertSame(Boolean.TRUE, present.orElseGet(() -> Boolean.FALSE));
182 assertSame(Boolean.TRUE, present.<RuntimeException>orElseThrow(null));
183 assertSame(Boolean.TRUE, present.<RuntimeException>orElseThrow(ObscureException::new));
184 }
185
186 @Test(groups = "unit")
187 public void testOfNullable() {
188 Optional<String> instance = Optional.ofNullable(null);
189 assertFalse(instance.isPresent());
190
191 instance = Optional.ofNullable("Duke");
192 assertTrue(instance.isPresent());
193 assertEquals(instance.get(), "Duke");
194 }
195
196 @Test(groups = "unit")
197 public void testFilter() {
198 // Null mapper function
199 Optional<String> empty = Optional.empty();
200 Optional<String> duke = Optional.of("Duke");
201
202 try {
203 Optional<String> result = empty.filter(null);
204 fail("Should throw NPE on null mapping function");
205 } catch (NullPointerException npe) {
206 // expected
207 }
208
209 Optional<String> result = empty.filter(String::isEmpty);
210 assertFalse(result.isPresent());
211
212 result = duke.filter(String::isEmpty);
213 assertFalse(result.isPresent());
214 result = duke.filter(s -> s.startsWith("D"));
215 assertTrue(result.isPresent());
216 assertEquals(result.get(), "Duke");
217
218 Optional<String> emptyString = Optional.of("");
219 result = emptyString.filter(String::isEmpty);
220 assertTrue(result.isPresent());
221 assertEquals(result.get(), "");
222 }
223
224 @Test(groups = "unit")
225 public void testMap() {
226 Optional<String> empty = Optional.empty();
227 Optional<String> duke = Optional.of("Duke");
228
229 // Null mapper function
230 try {
231 Optional<Boolean> b = empty.map(null);
232 fail("Should throw NPE on null mapping function");
233 } catch (NullPointerException npe) {
234 // expected
235 }
236
237 // Map an empty value
238 Optional<Boolean> b = empty.map(String::isEmpty);
239 assertFalse(b.isPresent());
240
241 // Map into null
242 b = empty.map(n -> null);
243 assertFalse(b.isPresent());
244 b = duke.map(s -> null);
245 assertFalse(b.isPresent());
246
247 // Map to value
248 Optional<Integer> l = duke.map(String::length);
249 assertEquals(l.get().intValue(), 4);
250 }
251
252 @Test(groups = "unit")
253 public void testFlatMap() {
254 Optional<String> empty = Optional.empty();
255 Optional<String> duke = Optional.of("Duke");
256
257 // Null mapper function
258 try {
259 Optional<Boolean> b = empty.flatMap(null);
260 fail("Should throw NPE on null mapping function");
261 } catch (NullPointerException npe) {
262 // expected
263 }
264
265 // Map into null
266 try {
267 Optional<Boolean> b = duke.flatMap(s -> null);
268 fail("Should throw NPE when mapper return null");
269 } catch (NullPointerException npe) {
270 // expected
271 }
272
273 // Empty won't invoke mapper function
274 try {
275 Optional<Boolean> b = empty.flatMap(s -> null);
276 assertFalse(b.isPresent());
277 } catch (NullPointerException npe) {
278 fail("Mapper function should not be invoked");
279 }
280
281 // Map an empty value
282 Optional<Integer> l = empty.flatMap(s -> Optional.of(s.length()));
283 assertFalse(l.isPresent());
284
285 // Map to value
286 Optional<Integer> fixture = Optional.of(Integer.MAX_VALUE);
287 l = duke.flatMap(s -> Optional.of(s.length()));
288 assertTrue(l.isPresent());
289 assertEquals(l.get().intValue(), 4);
290
291 // Verify same instance
292 l = duke.flatMap(s -> fixture);
293 assertSame(l, fixture);
294 }
295
296 @Test(groups = "unit")
297 public void testOr() {
298 Optional<String> empty = Optional.empty();
299 Optional<String> duke = Optional.of("Duke");
300
301 // Null supplier
302 try {
303 Optional<String> b = empty.or(null);
304 fail("Should throw NPE on null supplier");
305 } catch (NullPointerException npe) {
306 // expected
307 }
308
309 // Supply null
310 try {
311 Optional<String> b = empty.or(() -> null);
312 fail("Should throw NPE when supplier returns null");
313 } catch (NullPointerException npe) {
314 // expected
315 }
316
317 // Non-empty won't invoke supplier
318 try {
319 Optional<String> b = duke.or(() -> null);
320 assertTrue(b.isPresent());
321 } catch (NullPointerException npe) {
322 fail("Supplier should not be invoked");
323 }
324
325 // Supply for empty
326 Optional<String> suppliedDuke = empty.or(() -> duke);
327 assertTrue(suppliedDuke.isPresent());
328 assertSame(suppliedDuke, duke);
329
330 // Supply for non-empty
331 Optional<String> actualDuke = duke.or(() -> Optional.of("Other Duke"));
332 assertTrue(actualDuke.isPresent());
333 assertSame(actualDuke, duke);
334 }
335
336 @Test(groups = "unit")
337 public void testStream() {
338 {
339 Stream<String> s = Optional.<String>empty().stream();
340 assertFalse(s.isParallel());
341
342 Object[] es = s.toArray();
343 assertEquals(es.length, 0);
344 }
345
346 {
347 Stream<String> s = Optional.of("Duke").stream();
348 assertFalse(s.isParallel());
349
350 String[] es = s.toArray(String[]::new);
351 assertEquals(es.length, 1);
352 assertEquals(es[0], "Duke");
353 }
354 }
355
356 private static class ObscureException extends RuntimeException {
357
358 }
359 }