--- a/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java Fri Nov 20 15:40:23 2015 -0800
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,381 +0,0 @@
-/*
- * 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);
- }
- }
-}