| /* |
| * 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 java.util.stream; |
| |
| import org.testng.annotations.Test; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.EnumSet; |
| import java.util.List; |
| import java.util.Spliterator; |
| import java.util.function.Consumer; |
| import java.util.function.Function; |
| import java.util.function.ToDoubleFunction; |
| import java.util.function.ToIntFunction; |
| import java.util.function.ToLongFunction; |
| |
| import static java.util.stream.Collectors.toList; |
| import static java.util.stream.StreamOpFlag.*; |
| import static org.testng.Assert.*; |
| import static org.testng.Assert.assertEquals; |
| |
| @Test |
| public class StreamOpFlagsTest { |
| |
| public void testNullCombine() { |
| int sourceFlags = StreamOpFlag.IS_SIZED; |
| |
| assertEquals(sourceFlags, toStreamFlags(combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE))); |
| } |
| |
| public void testInitialOpFlagsFromSourceFlags() { |
| List<StreamOpFlag> flags = new ArrayList<>(StreamOpFlagTestHelper.allStreamFlags()); |
| for (int i = 0; i < (1 << flags.size()); i++) { |
| int sourceFlags = 0; |
| for (int f = 0; f < flags.size(); f++) { |
| if ((i & (1 << f)) != 0) { |
| sourceFlags |= flags.get(f).set(); |
| } |
| } |
| |
| int opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| assertEquals(opsFlags, (~(sourceFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE); |
| } |
| } |
| |
| public void testSameCombine() { |
| for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) { |
| int sourceFlags = f.set(); |
| int opsFlags; |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f.set(), opsFlags); |
| assertEquals(sourceFlags, toStreamFlags(opsFlags)); |
| } |
| } |
| |
| public void testOpClear() { |
| for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) { |
| // Clear when source not set |
| int sourceFlags = 0; |
| int opsFlags; |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f.clear(), opsFlags); |
| assertEquals(sourceFlags, toStreamFlags(opsFlags)); |
| |
| // Clear when source set |
| sourceFlags = f.set(); |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f.clear(), opsFlags); |
| assertEquals(0, toStreamFlags(opsFlags)); |
| } |
| } |
| |
| public void testOpInject() { |
| for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) { |
| // Set when source not set |
| int sourceFlags = 0; |
| int opsFlags; |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f.set(), opsFlags); |
| assertEquals(f.set(), toStreamFlags(opsFlags)); |
| |
| // Set when source set |
| sourceFlags = f.set(); |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f.set(), opsFlags); |
| assertEquals(sourceFlags, toStreamFlags(opsFlags)); |
| } |
| } |
| |
| public void testPairSet() { |
| List<Integer> sourceFlagsList |
| = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList()); |
| sourceFlagsList.add(0, 0); |
| |
| for (int sourceFlags : sourceFlagsList) { |
| for (StreamOpFlag f1 : StreamOpFlagTestHelper.allStreamFlags()) { |
| for (StreamOpFlag f2 : StreamOpFlagTestHelper.allStreamFlags()) { |
| int opsFlags; |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f1.set(), opsFlags); |
| opsFlags = combineOpFlags(f2.set(), opsFlags); |
| assertEquals(sourceFlags | f1.set() | f2.set(), toStreamFlags(opsFlags)); |
| } |
| } |
| } |
| } |
| |
| public void testPairSetAndClear() { |
| List<Integer> sourceFlagsList |
| = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList()); |
| sourceFlagsList.add(0, 0); |
| |
| for (int sourceFlags : sourceFlagsList) { |
| for (StreamOpFlag f1 : StreamOpFlagTestHelper.allStreamFlags()) { |
| for (StreamOpFlag f2 : StreamOpFlagTestHelper.allStreamFlags()) { |
| int opsFlags; |
| |
| opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| opsFlags = combineOpFlags(f1.set(), opsFlags); |
| opsFlags = combineOpFlags(f2.clear(), opsFlags); |
| if (f1 == f2) |
| assertEquals((f2.set() == sourceFlags) ? 0 : sourceFlags, toStreamFlags(opsFlags)); |
| else |
| assertEquals((f2.set() == sourceFlags) ? f1.set() : sourceFlags | f1.set(), toStreamFlags(opsFlags)); |
| } |
| } |
| } |
| } |
| |
| public void testShortCircuit() { |
| int opsFlags = combineOpFlags(0, StreamOpFlag.INITIAL_OPS_VALUE); |
| assertFalse(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags)); |
| |
| opsFlags = combineOpFlags(StreamOpFlag.IS_SHORT_CIRCUIT, opsFlags); |
| assertTrue(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags)); |
| |
| opsFlags = combineOpFlags(0, opsFlags); |
| assertTrue(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags)); |
| } |
| |
| public void testApplySourceFlags() { |
| int sourceFlags = StreamOpFlag.IS_SIZED | StreamOpFlag.IS_DISTINCT; |
| |
| List<Integer> ops = Arrays.asList(StreamOpFlag.NOT_SIZED, StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SORTED); |
| |
| int opsFlags = StreamOpFlag.combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE); |
| for (int opFlags : ops) { |
| opsFlags = combineOpFlags(opFlags, opsFlags); |
| } |
| assertFalse(StreamOpFlag.SIZED.isKnown(opsFlags)); |
| assertTrue(StreamOpFlag.SIZED.isCleared(opsFlags)); |
| assertFalse(StreamOpFlag.SIZED.isPreserved(opsFlags)); |
| assertTrue(StreamOpFlag.DISTINCT.isKnown(opsFlags)); |
| assertFalse(StreamOpFlag.DISTINCT.isCleared(opsFlags)); |
| assertFalse(StreamOpFlag.DISTINCT.isPreserved(opsFlags)); |
| assertTrue(StreamOpFlag.SORTED.isKnown(opsFlags)); |
| assertFalse(StreamOpFlag.SORTED.isCleared(opsFlags)); |
| assertFalse(StreamOpFlag.SORTED.isPreserved(opsFlags)); |
| assertTrue(StreamOpFlag.ORDERED.isKnown(opsFlags)); |
| assertFalse(StreamOpFlag.ORDERED.isCleared(opsFlags)); |
| assertFalse(StreamOpFlag.ORDERED.isPreserved(opsFlags)); |
| |
| int streamFlags = toStreamFlags(opsFlags); |
| assertFalse(StreamOpFlag.SIZED.isKnown(streamFlags)); |
| assertTrue(StreamOpFlag.DISTINCT.isKnown(streamFlags)); |
| assertTrue(StreamOpFlag.SORTED.isKnown(streamFlags)); |
| assertTrue(StreamOpFlag.ORDERED.isKnown(streamFlags)); |
| } |
| |
| public void testSpliteratorMask() { |
| assertSpliteratorMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT); |
| assertSpliteratorMask(StreamOpFlag.DISTINCT.clear(), 0); |
| |
| assertSpliteratorMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED); |
| assertSpliteratorMask(StreamOpFlag.SORTED.clear(), 0); |
| |
| assertSpliteratorMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED); |
| assertSpliteratorMask(StreamOpFlag.ORDERED.clear(), 0); |
| |
| assertSpliteratorMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED); |
| assertSpliteratorMask(StreamOpFlag.SIZED.clear(), 0); |
| |
| assertSpliteratorMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0); |
| assertSpliteratorMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertSpliteratorMask(int actual, int expected) { |
| assertEquals(actual & StreamOpFlag.SPLITERATOR_CHARACTERISTICS_MASK, expected); |
| } |
| |
| public void testStreamMask() { |
| assertStreamMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT); |
| assertStreamMask(StreamOpFlag.DISTINCT.clear(), 0); |
| |
| assertStreamMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED); |
| assertStreamMask(StreamOpFlag.SORTED.clear(), 0); |
| |
| assertStreamMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED); |
| assertStreamMask(StreamOpFlag.ORDERED.clear(), 0); |
| |
| assertStreamMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED); |
| assertStreamMask(StreamOpFlag.SIZED.clear(), 0); |
| |
| assertStreamMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0); |
| assertStreamMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertStreamMask(int actual, int expected) { |
| assertEquals(actual & StreamOpFlag.STREAM_MASK, expected); |
| } |
| |
| public void testOpMask() { |
| assertOpMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT); |
| assertOpMask(StreamOpFlag.DISTINCT.clear(), StreamOpFlag.NOT_DISTINCT); |
| |
| assertOpMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED); |
| assertOpMask(StreamOpFlag.SORTED.clear(), StreamOpFlag.NOT_SORTED); |
| |
| assertOpMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED); |
| assertOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED); |
| |
| assertOpMask(StreamOpFlag.SIZED.set(), 0); |
| assertOpMask(StreamOpFlag.SIZED.clear(), StreamOpFlag.NOT_SIZED); |
| |
| assertOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), StreamOpFlag.IS_SHORT_CIRCUIT); |
| assertOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertOpMask(int actual, int expected) { |
| assertEquals(actual & StreamOpFlag.OP_MASK, expected); |
| } |
| |
| public void testTerminalOpMask() { |
| assertTerminalOpMask(StreamOpFlag.DISTINCT.set(), 0); |
| assertTerminalOpMask(StreamOpFlag.DISTINCT.clear(), 0); |
| |
| assertTerminalOpMask(StreamOpFlag.SORTED.set(), 0); |
| assertTerminalOpMask(StreamOpFlag.SORTED.clear(), 0); |
| |
| assertTerminalOpMask(StreamOpFlag.ORDERED.set(), 0); |
| assertTerminalOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED); |
| |
| assertTerminalOpMask(StreamOpFlag.SIZED.set(), 0); |
| assertTerminalOpMask(StreamOpFlag.SIZED.clear(), 0); |
| |
| assertTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), StreamOpFlag.IS_SHORT_CIRCUIT); |
| assertTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertTerminalOpMask(int actual, int expected) { |
| assertEquals(actual & StreamOpFlag.TERMINAL_OP_MASK, expected); |
| } |
| |
| public void testUpstreamTerminalOpMask() { |
| assertUpstreamTerminalOpMask(StreamOpFlag.DISTINCT.set(), 0); |
| assertUpstreamTerminalOpMask(StreamOpFlag.DISTINCT.clear(), 0); |
| |
| assertUpstreamTerminalOpMask(StreamOpFlag.SORTED.set(), 0); |
| assertUpstreamTerminalOpMask(StreamOpFlag.SORTED.clear(), 0); |
| |
| assertUpstreamTerminalOpMask(StreamOpFlag.ORDERED.set(), 0); |
| assertUpstreamTerminalOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED); |
| |
| assertUpstreamTerminalOpMask(StreamOpFlag.SIZED.set(), 0); |
| assertUpstreamTerminalOpMask(StreamOpFlag.SIZED.clear(), 0); |
| |
| assertUpstreamTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0); |
| assertUpstreamTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertUpstreamTerminalOpMask(int actual, int expected) { |
| assertEquals(actual & StreamOpFlag.UPSTREAM_TERMINAL_OP_MASK, expected); |
| } |
| |
| public void testSpliteratorCharacteristics() { |
| assertEquals(Spliterator.DISTINCT, StreamOpFlag.IS_DISTINCT); |
| assertEquals(Spliterator.SORTED, StreamOpFlag.IS_SORTED); |
| assertEquals(Spliterator.ORDERED, StreamOpFlag.IS_ORDERED); |
| assertEquals(Spliterator.SIZED, StreamOpFlag.IS_SIZED); |
| |
| List<Integer> others = Arrays.asList(Spliterator.NONNULL, Spliterator.IMMUTABLE, |
| Spliterator.CONCURRENT, Spliterator.SUBSIZED); |
| for (int c : others) { |
| assertNotEquals(c, StreamOpFlag.IS_SHORT_CIRCUIT); |
| } |
| } |
| |
| public void testSpliteratorCharacteristicsMask() { |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT); |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.DISTINCT.clear(), 0); |
| |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED); |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SORTED.clear(), 0); |
| |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED); |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.ORDERED.clear(), 0); |
| |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED); |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SIZED.clear(), 0); |
| |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0); |
| assertSpliteratorCharacteristicsMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0); |
| } |
| |
| private void assertSpliteratorCharacteristicsMask(int actual, int expected) { |
| assertEquals(StreamOpFlag.fromCharacteristics(actual), expected); |
| } |
| |
| public void testSpliteratorSorted() { |
| class SortedEmptySpliterator implements Spliterator<Object> { |
| final Comparator<Object> c; |
| |
| SortedEmptySpliterator(Comparator<Object> c) { |
| this.c = c; |
| } |
| |
| @Override |
| public Spliterator<Object> trySplit() { |
| return null; |
| } |
| |
| @Override |
| public boolean tryAdvance(Consumer<? super Object> action) { |
| return false; |
| } |
| |
| @Override |
| public long estimateSize() { |
| return Long.MAX_VALUE; |
| } |
| |
| @Override |
| public int characteristics() { |
| return Spliterator.SORTED; |
| } |
| |
| @Override |
| public Comparator<? super Object> getComparator() { |
| return c; |
| } |
| }; |
| |
| { |
| int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator(null)); |
| assertEquals(flags, StreamOpFlag.IS_SORTED); |
| } |
| |
| { |
| int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator((a, b) -> 0)); |
| assertEquals(flags, 0); |
| } |
| } |
| } |