1 /*
2 * Copyright (c) 2012, 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 package org.openjdk.tests.java.util.stream;
24
25 import java.util.*;
26 import java.util.function.BiConsumer;
27 import java.util.stream.*;
28
29 import org.testng.annotations.Test;
30
31 import java.util.function.Function;
32
33 import static java.util.stream.LambdaTestHelpers.*;
34
35
36 /**
37 * FindAnyOpTest
38 */
39 @Test
40 public class FindAnyOpTest extends OpTestCase {
41
42 public void testFindAny() {
43 assertFalse(Collections.emptySet().stream().findAny().isPresent(), "no result");
44 assertFalse(countTo(10).stream().filter(x -> x > 10).findAny().isPresent(), "no result");
45 assertTrue(countTo(10).stream().filter(pEven).findAny().isPresent(), "with result");
46 }
47
48 public void testFindAnyParallel() {
49 assertFalse(Collections.emptySet().parallelStream().findAny().isPresent(), "no result");
50 assertFalse(countTo(1000).parallelStream().filter(x -> x > 1000).findAny().isPresent(), "no result");
51 assertTrue(countTo(1000).parallelStream().filter(pEven).findAny().isPresent(), "with result");
52 }
53
54 @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
55 public void testStream(String name, TestData.OfRef<Integer> data) {
56 exerciseStream(data, s -> s);
57 exerciseStream(data, s -> s.filter(pTrue));
58 exerciseStream(data, s -> s.filter(pFalse));
59 exerciseStream(data, s -> s.filter(pEven));
60 }
61
62 void exerciseStream(TestData.OfRef<Integer> data, Function<Stream<Integer>, Stream<Integer>> fs) {
63 Optional<Integer> or = withData(data).terminal(fs, s -> s.findAny()).equalator(VALID_ANSWER).exercise();
64 assertContains(or, fs.apply(data.stream()).iterator());
65 }
66
67 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
68 public void testIntStream(String name, TestData.OfInt data) {
69 exerciseIntStream(data, s -> s);
70 exerciseIntStream(data, s -> s.filter(ipTrue));
71 exerciseIntStream(data, s -> s.filter(ipFalse));
72 exerciseIntStream(data, s -> s.filter(ipEven));
73 }
74
75 void exerciseIntStream(TestData.OfInt data, Function<IntStream, IntStream> fs) {
76 OptionalInt or = withData(data).terminal(fs, s -> s.findAny()).equalator(INT_VALID_ANSWER).exercise();
77 if (or.isPresent()) {
78 int r = or.getAsInt();
79 PrimitiveIterator.OfInt it = fs.apply(data.stream()).iterator();
80 boolean contained = false;
81 while (!contained && it.hasNext()) {
82 contained = r == it.nextInt();
83 }
84 assertTrue(contained);
85 }
86 else {
87 assertFalse(fs.apply(data.stream()).iterator().hasNext());
88 }
89 }
90
91 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
92 public void testLongStream(String name, TestData.OfLong data) {
93 exerciseLongStream(data, s -> s);
94 exerciseLongStream(data, s -> s.filter(lpTrue));
95 exerciseLongStream(data, s -> s.filter(lpFalse));
96 exerciseLongStream(data, s -> s.filter(lpEven));
97 }
98
99 void exerciseLongStream(TestData.OfLong data, Function<LongStream, LongStream> fs) {
100 OptionalLong or = withData(data).terminal(fs, s -> s.findAny()).equalator(LONG_VALID_ANSWER).exercise();
101 if (or.isPresent()) {
102 long r = or.getAsLong();
103 PrimitiveIterator.OfLong it = fs.apply(data.stream()).iterator();
104 boolean contained = false;
105 while (!contained && it.hasNext()) {
106 contained = r == it.nextLong();
107 }
108 assertTrue(contained);
109 }
110 else {
111 assertFalse(fs.apply(data.stream()).iterator().hasNext());
112 }
113 }
114
115 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
116 public void testDoubleStream(String name, TestData.OfDouble data) {
117 exerciseDoubleStream(data, s -> s);
118 exerciseDoubleStream(data, s -> s.filter(dpTrue));
119 exerciseDoubleStream(data, s -> s.filter(dpEven));
120 exerciseDoubleStream(data, s -> s.filter(dpFalse));
121 }
122
123 void exerciseDoubleStream(TestData.OfDouble data, Function<DoubleStream, DoubleStream> fs) {
124 OptionalDouble or = withData(data).terminal(fs, s -> s.findAny()).equalator(DOUBLE_VALID_ANSWER).exercise();
125 if (or.isPresent()) {
126 double r = or.getAsDouble();
127 PrimitiveIterator.OfDouble it = fs.apply(data.stream()).iterator();
128 boolean contained = false;
129 while (!contained && it.hasNext()) {
130 contained = r == it.nextDouble();
131 }
132 assertTrue(contained);
133 }
134 else {
135 assertFalse(fs.apply(data.stream()).iterator().hasNext());
136 }
137 }
138
139 static final BiConsumer<Optional<Integer>, Optional<Integer>> VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
140
141 static final BiConsumer<OptionalInt, OptionalInt> INT_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
142
143 static final BiConsumer<OptionalLong, OptionalLong> LONG_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
144
145 static final BiConsumer<OptionalDouble, OptionalDouble> DOUBLE_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
146 }