1 /*

     2  * Copyright (c) 2012, 2015, 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 java.util.stream;

    24 

    25 import org.testng.Assert;

    26 import org.testng.annotations.Test;

    27 

    28 import java.util.ArrayList;

    29 import java.util.EnumSet;

    30 import java.util.List;

    31 import java.util.function.Supplier;

    32 

    33 import static java.util.stream.LambdaTestHelpers.countTo;

    34 

    35 @Test

    36 public class FlagOpTest extends OpTestCase {

    37 

    38     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)

    39     public void testFlagsPassThrough(String name, TestData<Integer, Stream<Integer>> data) {

    40 

    41         @SuppressWarnings({"unchecked", "rawtypes"})

    42         TestFlagPassThroughOp<Integer>[] ops = new TestFlagPassThroughOp[3];

    43         ops[0] = new TestFlagPassThroughOp<>();

    44         ops[1] = new TestFlagPassThroughOp<>();

    45         ops[2] = new TestFlagPassThroughOp<>();

    46 

    47         ops[0].set(null, ops[1]);

    48         ops[1].set(ops[0], ops[2]);

    49         ops[2].set(ops[1], null);

    50 

    51         withData(data).ops(ops).exercise();

    52     }

    53 

    54     static class TestFlagPassThroughOp<T> extends FlagDeclaringOp<T> {

    55         TestFlagPassThroughOp<T> upstream;

    56         TestFlagPassThroughOp<T> downstream;

    57 

    58         TestFlagPassThroughOp() {

    59             super(0);

    60         }

    61 

    62         void set(TestFlagPassThroughOp<T> upstream, TestFlagPassThroughOp<T> downstream)  {

    63             this.upstream = upstream;

    64             this.downstream = downstream;

    65         }

    66 

    67         int wrapFlags;

    68 

    69         @Override

    70         @SuppressWarnings({"unchecked", "rawtypes"})

    71         public Sink<T> opWrapSink(int flags, boolean parallel, Sink sink) {

    72             this.wrapFlags = flags;

    73 

    74             if (downstream != null) {

    75                 assertTrue(flags == downstream.wrapFlags);

    76             }

    77 

    78             return sink;

    79         }

    80     }

    81 

    82     public void testFlagsClearAllSet() {

    83         int clearAllFlags = 0;

    84         for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class)) {

    85             if (f.isStreamFlag()) {

    86                 clearAllFlags |= f.clear();

    87             }

    88         }

    89 

    90         EnumSet<StreamOpFlag> known = EnumSet.noneOf(StreamOpFlag.class);

    91         EnumSet<StreamOpFlag> notKnown = StreamOpFlagTestHelper.allStreamFlags();

    92 

    93         List<FlagDeclaringOp<Integer>> ops = new ArrayList<>();

    94         ops.add(new FlagDeclaringOp<>(clearAllFlags));

    95         for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {

    96             if (f.canSet(StreamOpFlag.Type.OP)) {

    97                 ops.add(new TestFlagExpectedOp<>(f.set(),

    98                                              known.clone(),

    99                                              EnumSet.noneOf(StreamOpFlag.class),

   100                                              notKnown.clone()));

   101                 known.add(f);

   102                 notKnown.remove(f);

   103             }

   104         }

   105         ops.add(new TestFlagExpectedOp<>(0,

   106                                          known.clone(),

   107                                          EnumSet.noneOf(StreamOpFlag.class),

   108                                          notKnown.clone()));

   109 

   110         TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));

   111         @SuppressWarnings("rawtypes")

   112         FlagDeclaringOp[] opsArray = ops.toArray(new FlagDeclaringOp[ops.size()]);

   113 

   114         withData(data).ops(opsArray).

   115                 without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).

   116                 exercise();

   117     }

   118 

   119     public void testFlagsSetAllClear() {

   120         EnumSet<StreamOpFlag> known = StreamOpFlagTestHelper.allStreamFlags();

   121         int setAllFlags = 0;

   122         for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class)) {

   123             if (f.isStreamFlag()) {

   124                 if (f.canSet(StreamOpFlag.Type.OP)) {

   125                     setAllFlags |= f.set();

   126                 } else {

   127                     known.remove(f);

   128                 }

   129             }

   130         }

   131 

   132         EnumSet<StreamOpFlag> notKnown = EnumSet.noneOf(StreamOpFlag.class);

   133 

   134         List<FlagDeclaringOp<Integer>> ops = new ArrayList<>();

   135         ops.add(new FlagDeclaringOp<>(setAllFlags));

   136         for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {

   137             ops.add(new TestFlagExpectedOp<>(f.clear(),

   138                                              known.clone(),

   139                                              EnumSet.noneOf(StreamOpFlag.class),

   140                                              notKnown.clone()));

   141             known.remove(f);

   142             notKnown.add(f);

   143         }

   144         ops.add(new TestFlagExpectedOp<>(0,

   145                                          known.clone(),

   146                                          EnumSet.noneOf(StreamOpFlag.class),

   147                                          notKnown.clone()));

   148 

   149         TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));

   150         @SuppressWarnings("rawtypes")

   151         FlagDeclaringOp[] opsArray = ops.toArray(new FlagDeclaringOp[ops.size()]);

   152 

   153 

   154         withData(data).ops(opsArray).

   155                 without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).

   156                 exercise();

   157     }

   158 

   159     public void testFlagsParallelCollect() {

   160         testFlagsSetSequence(CollectorOps::collector);

   161     }

   162 

   163     private void testFlagsSetSequence(Supplier<StatefulTestOp<Integer>> cf) {

   164         EnumSet<StreamOpFlag> known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED);

   165         EnumSet<StreamOpFlag> preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED);

   166 

   167         List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();

   168         for (StreamOpFlag f : EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED)) {

   169             ops.add(cf.get());

   170             ops.add(new TestFlagExpectedOp<>(f.set(),

   171                                              known.clone(),

   172                                              preserve.clone(),

   173                                              EnumSet.noneOf(StreamOpFlag.class)));

   174             known.add(f);

   175             preserve.remove(f);

   176         }

   177         ops.add(cf.get());

   178         ops.add(new TestFlagExpectedOp<>(0,

   179                                          known.clone(),

   180                                          preserve.clone(),

   181                                          EnumSet.noneOf(StreamOpFlag.class)));

   182 

   183         TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));

   184         @SuppressWarnings("rawtypes")

   185         IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);

   186 

   187         withData(data).ops(opsArray).

   188                 without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).

   189                 exercise();

   190     }

   191 

   192 

   193     public void testFlagsClearParallelCollect() {

   194         testFlagsClearSequence(CollectorOps::collector);

   195     }

   196 

   197     protected void testFlagsClearSequence(Supplier<StatefulTestOp<Integer>> cf) {

   198         EnumSet<StreamOpFlag> known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED);

   199         EnumSet<StreamOpFlag> preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED);

   200         EnumSet<StreamOpFlag> notKnown = EnumSet.noneOf(StreamOpFlag.class);

   201 

   202         List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();

   203         for (StreamOpFlag f : EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.DISTINCT, StreamOpFlag.SORTED)) {

   204             ops.add(cf.get());

   205             ops.add(new TestFlagExpectedOp<>(f.clear(),

   206                                              known.clone(),

   207                                              preserve.clone(),

   208                                              notKnown.clone()));

   209             known.remove(f);

   210             preserve.remove(f);

   211             notKnown.add(f);

   212         }

   213         ops.add(cf.get());

   214         ops.add(new TestFlagExpectedOp<>(0,

   215                                          known.clone(),

   216                                          preserve.clone(),

   217                                          notKnown.clone()));

   218 

   219         TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));

   220         @SuppressWarnings("rawtypes")

   221         IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);

   222 

   223         withData(data).ops(opsArray).

   224                 without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).

   225                 exercise();

   226     }

   227 

   228     public void testFlagsSizedOrderedParallelCollect() {

   229         EnumSet<StreamOpFlag> parKnown = EnumSet.of(StreamOpFlag.SIZED);

   230         EnumSet<StreamOpFlag> serKnown = parKnown.clone();

   231 

   232         List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();

   233         for (StreamOpFlag f : parKnown) {

   234             ops.add(CollectorOps.collector());

   235             ops.add(new ParSerTestFlagExpectedOp<>(f.clear(),

   236                                              parKnown,

   237                                              serKnown));

   238             serKnown.remove(f);

   239         }

   240         ops.add(CollectorOps.collector());

   241         ops.add(new ParSerTestFlagExpectedOp<>(0,

   242                                          parKnown,

   243                                          EnumSet.noneOf(StreamOpFlag.class)));

   244 

   245         TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));

   246         @SuppressWarnings("rawtypes")

   247         IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);

   248 

   249         withData(data).ops(opsArray).exercise();

   250     }

   251 

   252     static class ParSerTestFlagExpectedOp<T> extends FlagDeclaringOp<T> {

   253         final EnumSet<StreamOpFlag> parKnown;

   254         final EnumSet<StreamOpFlag> serKnown;

   255 

   256         ParSerTestFlagExpectedOp(int flags, EnumSet<StreamOpFlag> known, EnumSet<StreamOpFlag> serKnown) {

   257             super(flags);

   258             this.parKnown = known;

   259             this.serKnown = serKnown;

   260         }

   261 

   262         @Override

   263         @SuppressWarnings({"unchecked", "rawtypes"})

   264         public Sink<T> opWrapSink(int flags, boolean parallel, Sink upstream) {

   265             assertFlags(flags, parallel);

   266             return upstream;

   267         }

   268 

   269         protected void assertFlags(int flags, boolean parallel) {

   270             if (parallel) {

   271                 for (StreamOpFlag f : parKnown) {

   272                     Assert.assertTrue(f.isKnown(flags), String.format("Flag %s is not known, but should be known.", f.toString()));

   273                 }

   274 

   275             } else {

   276                 for (StreamOpFlag f : serKnown) {

   277                     Assert.assertTrue(f.isKnown(flags), String.format("Flag %s is not known, but should be known.", f.toString()));

   278                 }

   279 

   280             }

   281         }

   282     }

   283 }