| /* |
| * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package org.openjdk.tests.java.util.stream; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.PrimitiveIterator; |
| import java.util.Spliterators; |
| import java.util.function.DoublePredicate; |
| import java.util.function.Function; |
| import java.util.function.IntPredicate; |
| import java.util.function.LongPredicate; |
| import java.util.function.Predicate; |
| import java.util.function.Supplier; |
| import java.util.stream.DoubleStream; |
| import java.util.stream.DoubleStreamTestDataProvider; |
| import java.util.stream.IntStream; |
| import java.util.stream.IntStreamTestDataProvider; |
| import java.util.stream.LongStream; |
| import java.util.stream.LongStreamTestDataProvider; |
| import java.util.stream.OpTestCase; |
| import java.util.stream.Stream; |
| import java.util.stream.StreamSupport; |
| import java.util.stream.StreamTestDataProvider; |
| import java.util.stream.TestData; |
| |
| import org.testng.annotations.Test; |
| |
| import static java.util.stream.LambdaTestHelpers.countTo; |
| import static java.util.stream.LambdaTestHelpers.dpEven; |
| import static java.util.stream.LambdaTestHelpers.dpFalse; |
| import static java.util.stream.LambdaTestHelpers.dpOdd; |
| import static java.util.stream.LambdaTestHelpers.dpTrue; |
| import static java.util.stream.LambdaTestHelpers.ipEven; |
| import static java.util.stream.LambdaTestHelpers.ipFalse; |
| import static java.util.stream.LambdaTestHelpers.ipOdd; |
| import static java.util.stream.LambdaTestHelpers.ipTrue; |
| import static java.util.stream.LambdaTestHelpers.lpEven; |
| import static java.util.stream.LambdaTestHelpers.lpFalse; |
| import static java.util.stream.LambdaTestHelpers.lpOdd; |
| import static java.util.stream.LambdaTestHelpers.lpTrue; |
| import static java.util.stream.LambdaTestHelpers.pEven; |
| import static java.util.stream.LambdaTestHelpers.pFalse; |
| import static java.util.stream.LambdaTestHelpers.pOdd; |
| import static java.util.stream.LambdaTestHelpers.pTrue; |
| |
| /** |
| * MatchOpTest |
| * |
| * @author Brian Goetz |
| */ |
| @Test |
| public class MatchOpTest extends OpTestCase { |
| private enum Kind { ANY, ALL, NONE } |
| |
| @SuppressWarnings("unchecked") |
| private static final Predicate<Integer>[] INTEGER_PREDICATES |
| = (Predicate<Integer>[]) new Predicate<?>[]{pTrue, pFalse, pEven, pOdd}; |
| |
| @SuppressWarnings({"serial", "rawtypes"}) |
| private final Map kinds |
| = new HashMap<Kind, Function<Predicate<Integer>, Function<Stream<Integer>, Boolean>>>() {{ |
| put(Kind.ANY, p -> s -> s.anyMatch(p)); |
| put(Kind.ALL, p -> s -> s.allMatch(p)); |
| put(Kind.NONE, p -> s -> s.noneMatch(p)); |
| }}; |
| |
| @SuppressWarnings("unchecked") |
| private <T> Map<Kind, Function<Predicate<T>, Function<Stream<T>, Boolean>>> kinds() { |
| return (Map<Kind, Function<Predicate<T>, Function<Stream<T>, Boolean>>>) kinds; |
| } |
| |
| private <T> void assertPredicates(List<T> source, Kind kind, Predicate<T>[] predicates, boolean... answers) { |
| for (int i = 0; i < predicates.length; i++) { |
| setContext("i", i); |
| boolean match = this.<T>kinds().get(kind).apply(predicates[i]).apply(source.stream()); |
| assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); |
| } |
| } |
| |
| public void testStreamMatches() { |
| assertPredicates(countTo(0), Kind.ANY, INTEGER_PREDICATES, false, false, false, false); |
| assertPredicates(countTo(0), Kind.ALL, INTEGER_PREDICATES, true, true, true, true); |
| assertPredicates(countTo(0), Kind.NONE, INTEGER_PREDICATES, true, true, true, true); |
| |
| assertPredicates(countTo(1), Kind.ANY, INTEGER_PREDICATES, true, false, false, true); |
| assertPredicates(countTo(1), Kind.ALL, INTEGER_PREDICATES, true, false, false, true); |
| assertPredicates(countTo(1), Kind.NONE, INTEGER_PREDICATES, false, true, true, false); |
| |
| assertPredicates(countTo(5), Kind.ANY, INTEGER_PREDICATES, true, false, true, true); |
| assertPredicates(countTo(5), Kind.ALL, INTEGER_PREDICATES, true, false, false, false); |
| assertPredicates(countTo(5), Kind.NONE, INTEGER_PREDICATES, false, true, false, false); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testStream(String name, TestData.OfRef<Integer> data) { |
| for (Predicate<Integer> p : INTEGER_PREDICATES) { |
| setContext("p", p); |
| for (Kind kind : Kind.values()) { |
| setContext("kind", kind); |
| exerciseTerminalOps(data, this.<Integer>kinds().get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(pFalse), this.<Integer>kinds().get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(pEven), this.<Integer>kinds().get(kind).apply(p)); |
| } |
| } |
| } |
| |
| public void testInfinite() { |
| class CycleIterator implements Iterator<Integer> { |
| final Supplier<Iterator<Integer>> source; |
| Iterator<Integer> i = null; |
| |
| CycleIterator(Supplier<Iterator<Integer>> source) { |
| this.source = source; |
| } |
| |
| @Override |
| public Integer next() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.next(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.hasNext(); |
| } |
| } |
| |
| Supplier<Iterator<Integer>> source = () -> Arrays.asList(1, 2, 3, 4).iterator(); |
| Supplier<Stream<Integer>> s = () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false); |
| |
| assertFalse(s.get().allMatch(i -> i > 3)); |
| assertTrue(s.get().anyMatch(i -> i > 3)); |
| assertFalse(s.get().noneMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().allMatch(i -> i > 3)); |
| assertTrue(s.get().parallel().anyMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().noneMatch(i -> i > 3)); |
| } |
| |
| // |
| |
| private static final IntPredicate[] INT_PREDICATES |
| = new IntPredicate[]{ipTrue, ipFalse, ipEven, ipOdd}; |
| |
| @SuppressWarnings("serial") |
| private final Map<Kind, Function<IntPredicate, Function<IntStream, Boolean>>> intKinds |
| = new HashMap<Kind, Function<IntPredicate, Function<IntStream, Boolean>>>() {{ |
| put(Kind.ANY, p -> s -> s.anyMatch(p)); |
| put(Kind.ALL, p -> s -> s.allMatch(p)); |
| put(Kind.NONE, p -> s -> s.noneMatch(p)); |
| }}; |
| |
| private void assertIntPredicates(Supplier<IntStream> source, Kind kind, IntPredicate[] predicates, boolean... answers) { |
| for (int i = 0; i < predicates.length; i++) { |
| setContext("i", i); |
| boolean match = intKinds.get(kind).apply(predicates[i]).apply(source.get()); |
| assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); |
| } |
| } |
| |
| public void testIntStreamMatches() { |
| assertIntPredicates(() -> IntStream.range(0, 0), Kind.ANY, INT_PREDICATES, false, false, false, false); |
| assertIntPredicates(() -> IntStream.range(0, 0), Kind.ALL, INT_PREDICATES, true, true, true, true); |
| assertIntPredicates(() -> IntStream.range(0, 0), Kind.NONE, INT_PREDICATES, true, true, true, true); |
| |
| assertIntPredicates(() -> IntStream.range(1, 2), Kind.ANY, INT_PREDICATES, true, false, false, true); |
| assertIntPredicates(() -> IntStream.range(1, 2), Kind.ALL, INT_PREDICATES, true, false, false, true); |
| assertIntPredicates(() -> IntStream.range(1, 2), Kind.NONE, INT_PREDICATES, false, true, true, false); |
| |
| assertIntPredicates(() -> IntStream.range(1, 6), Kind.ANY, INT_PREDICATES, true, false, true, true); |
| assertIntPredicates(() -> IntStream.range(1, 6), Kind.ALL, INT_PREDICATES, true, false, false, false); |
| assertIntPredicates(() -> IntStream.range(1, 6), Kind.NONE, INT_PREDICATES, false, true, false, false); |
| } |
| |
| @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) |
| public void testIntStream(String name, TestData.OfInt data) { |
| for (IntPredicate p : INT_PREDICATES) { |
| setContext("p", p); |
| for (Kind kind : Kind.values()) { |
| setContext("kind", kind); |
| exerciseTerminalOps(data, intKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(ipFalse), intKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(ipEven), intKinds.get(kind).apply(p)); |
| } |
| } |
| } |
| |
| public void testIntInfinite() { |
| class CycleIterator implements PrimitiveIterator.OfInt { |
| final Supplier<PrimitiveIterator.OfInt> source; |
| PrimitiveIterator.OfInt i = null; |
| |
| CycleIterator(Supplier<PrimitiveIterator.OfInt> source) { |
| this.source = source; |
| } |
| |
| @Override |
| public int nextInt() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.nextInt(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.hasNext(); |
| } |
| } |
| |
| Supplier<PrimitiveIterator.OfInt> source = () -> Arrays.stream(new int[]{1, 2, 3, 4}).iterator(); |
| Supplier<IntStream> s = () -> StreamSupport.intStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false); |
| |
| assertFalse(s.get().allMatch(i -> i > 3)); |
| assertTrue(s.get().anyMatch(i -> i > 3)); |
| assertFalse(s.get().noneMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().allMatch(i -> i > 3)); |
| assertTrue(s.get().parallel().anyMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().noneMatch(i -> i > 3)); |
| } |
| |
| // |
| |
| private static final LongPredicate[] LONG_PREDICATES |
| = new LongPredicate[]{lpTrue, lpFalse, lpEven, lpOdd}; |
| |
| @SuppressWarnings("serial") |
| private final Map<Kind, Function<LongPredicate, Function<LongStream, Boolean>>> longKinds |
| = new HashMap<Kind, Function<LongPredicate, Function<LongStream, Boolean>>>() {{ |
| put(Kind.ANY, p -> s -> s.anyMatch(p)); |
| put(Kind.ALL, p -> s -> s.allMatch(p)); |
| put(Kind.NONE, p -> s -> s.noneMatch(p)); |
| }}; |
| |
| private void assertLongPredicates(Supplier<LongStream> source, Kind kind, LongPredicate[] predicates, boolean... answers) { |
| for (int i = 0; i < predicates.length; i++) { |
| setContext("i", i); |
| boolean match = longKinds.get(kind).apply(predicates[i]).apply(source.get()); |
| assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); |
| } |
| } |
| |
| public void testLongStreamMatches() { |
| assertLongPredicates(() -> LongStream.range(0, 0), Kind.ANY, LONG_PREDICATES, false, false, false, false); |
| assertLongPredicates(() -> LongStream.range(0, 0), Kind.ALL, LONG_PREDICATES, true, true, true, true); |
| assertLongPredicates(() -> LongStream.range(0, 0), Kind.NONE, LONG_PREDICATES, true, true, true, true); |
| |
| assertLongPredicates(() -> LongStream.range(1, 2), Kind.ANY, LONG_PREDICATES, true, false, false, true); |
| assertLongPredicates(() -> LongStream.range(1, 2), Kind.ALL, LONG_PREDICATES, true, false, false, true); |
| assertLongPredicates(() -> LongStream.range(1, 2), Kind.NONE, LONG_PREDICATES, false, true, true, false); |
| |
| assertLongPredicates(() -> LongStream.range(1, 6), Kind.ANY, LONG_PREDICATES, true, false, true, true); |
| assertLongPredicates(() -> LongStream.range(1, 6), Kind.ALL, LONG_PREDICATES, true, false, false, false); |
| assertLongPredicates(() -> LongStream.range(1, 6), Kind.NONE, LONG_PREDICATES, false, true, false, false); |
| } |
| |
| @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) |
| public void testLongStream(String name, TestData.OfLong data) { |
| for (LongPredicate p : LONG_PREDICATES) { |
| setContext("p", p); |
| for (Kind kind : Kind.values()) { |
| setContext("kind", kind); |
| exerciseTerminalOps(data, longKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(lpFalse), longKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(lpEven), longKinds.get(kind).apply(p)); |
| } |
| } |
| } |
| |
| public void testLongInfinite() { |
| class CycleIterator implements PrimitiveIterator.OfLong { |
| final Supplier<PrimitiveIterator.OfLong> source; |
| PrimitiveIterator.OfLong i = null; |
| |
| CycleIterator(Supplier<PrimitiveIterator.OfLong> source) { |
| this.source = source; |
| } |
| |
| @Override |
| public long nextLong() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.nextLong(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.hasNext(); |
| } |
| } |
| |
| Supplier<PrimitiveIterator.OfLong> source = () -> Arrays.stream(new long[]{1, 2, 3, 4}).iterator(); |
| Supplier<LongStream> s = () -> StreamSupport.longStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false); |
| |
| assertFalse(s.get().allMatch(i -> i > 3)); |
| assertTrue(s.get().anyMatch(i -> i > 3)); |
| assertFalse(s.get().noneMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().allMatch(i -> i > 3)); |
| assertTrue(s.get().parallel().anyMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().noneMatch(i -> i > 3)); |
| } |
| |
| // |
| |
| private static final DoublePredicate[] DOUBLE_PREDICATES |
| = new DoublePredicate[]{dpTrue, dpFalse, dpEven, dpOdd}; |
| |
| @SuppressWarnings("serial") |
| private final Map<Kind, Function<DoublePredicate, Function<DoubleStream, Boolean>>> doubleKinds |
| = new HashMap<Kind, Function<DoublePredicate, Function<DoubleStream, Boolean>>>() {{ |
| put(Kind.ANY, p -> s -> s.anyMatch(p)); |
| put(Kind.ALL, p -> s -> s.allMatch(p)); |
| put(Kind.NONE, p -> s -> s.noneMatch(p)); |
| }}; |
| |
| private void assertDoublePredicates(Supplier<DoubleStream> source, Kind kind, DoublePredicate[] predicates, boolean... answers) { |
| for (int i = 0; i < predicates.length; i++) { |
| setContext("i", i); |
| boolean match = doubleKinds.get(kind).apply(predicates[i]).apply(source.get()); |
| assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); |
| } |
| } |
| |
| public void testDoubleStreamMatches() { |
| assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, false, false, false, false); |
| assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, true, true, true); |
| assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, true, true, true, true); |
| |
| assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, true, false, false, true); |
| assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, false, false, true); |
| assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, false, true, true, false); |
| |
| assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, true, false, true, true); |
| assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, false, false, false); |
| assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, false, true, false, false); |
| } |
| |
| @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) |
| public void testDoubleStream(String name, TestData.OfDouble data) { |
| for (DoublePredicate p : DOUBLE_PREDICATES) { |
| setContext("p", p); |
| for (Kind kind : Kind.values()) { |
| setContext("kind", kind); |
| exerciseTerminalOps(data, doubleKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(dpFalse), doubleKinds.get(kind).apply(p)); |
| exerciseTerminalOps(data, s -> s.filter(dpEven), doubleKinds.get(kind).apply(p)); |
| } |
| } |
| } |
| |
| public void testDoubleInfinite() { |
| class CycleIterator implements PrimitiveIterator.OfDouble { |
| final Supplier<PrimitiveIterator.OfDouble> source; |
| PrimitiveIterator.OfDouble i = null; |
| |
| CycleIterator(Supplier<PrimitiveIterator.OfDouble> source) { |
| this.source = source; |
| } |
| |
| @Override |
| public double nextDouble() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.nextDouble(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| if (i == null || !i.hasNext()) { |
| i = source.get(); |
| } |
| return i.hasNext(); |
| } |
| } |
| |
| Supplier<PrimitiveIterator.OfDouble> source = () -> Arrays.stream(new double[]{1, 2, 3, 4}).iterator(); |
| Supplier<DoubleStream> s = () -> StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false); |
| |
| assertFalse(s.get().allMatch(i -> i > 3)); |
| assertTrue(s.get().anyMatch(i -> i > 3)); |
| assertFalse(s.get().noneMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().allMatch(i -> i > 3)); |
| assertTrue(s.get().parallel().anyMatch(i -> i > 3)); |
| assertFalse(s.get().parallel().noneMatch(i -> i > 3)); |
| } |
| } |