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 java.util.stream;

    24 

    25 import org.testng.Assert;

    26 

    27 import java.util.EnumSet;

    28 

    29 class TestFlagExpectedOp<T> extends FlagDeclaringOp<T> {

    30 

    31     static class Builder<T> {

    32         final int flags;

    33         StreamShape shape = StreamShape.REFERENCE;

    34 

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

    36         EnumSet<StreamOpFlag> preserve = EnumSet.noneOf(StreamOpFlag.class);

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

    38 

    39         Builder(int flags) {

    40             this.flags = flags;

    41         }

    42 

    43         Builder<T> known(EnumSet<StreamOpFlag> known) {

    44             this.known = known;

    45             return this;

    46         }

    47 

    48         Builder<T> preserve(EnumSet<StreamOpFlag> preserve) {

    49             this.preserve = preserve;

    50             return this;

    51         }

    52 

    53         Builder<T> notKnown(EnumSet<StreamOpFlag> notKnown) {

    54             this.notKnown = notKnown;

    55             return this;

    56         }

    57 

    58         Builder<T> shape(StreamShape shape) {

    59             this.shape = shape;

    60             return this;

    61         }

    62 

    63         TestFlagExpectedOp<T> build() {

    64             return new TestFlagExpectedOp<>(flags, known, preserve, notKnown, shape);

    65         }

    66     }

    67 

    68     final EnumSet<StreamOpFlag> known;

    69     final EnumSet<StreamOpFlag> preserve;

    70     final EnumSet<StreamOpFlag> notKnown;

    71     final StreamShape shape;

    72 

    73     TestFlagExpectedOp(int flags,

    74                        EnumSet<StreamOpFlag> known,

    75                        EnumSet<StreamOpFlag> preserve,

    76                        EnumSet<StreamOpFlag> notKnown) {

    77         this(flags, known, preserve, notKnown, StreamShape.REFERENCE);

    78     }

    79 

    80     TestFlagExpectedOp(int flags,

    81                        EnumSet<StreamOpFlag> known,

    82                        EnumSet<StreamOpFlag> preserve,

    83                        EnumSet<StreamOpFlag> notKnown,

    84                        StreamShape shape) {

    85         super(flags);

    86         this.known = known;

    87         this.preserve = preserve;

    88         this.notKnown = notKnown;

    89         this.shape = shape;

    90     }

    91 

    92     @Override

    93     public StreamShape outputShape() {

    94         return shape;

    95     }

    96 

    97     @Override

    98     public StreamShape inputShape() {

    99         return shape;

   100     }

   101 

   102     @Override

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

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

   105         assertFlags(flags);

   106         return upstream;

   107     }

   108 

   109     private void assertFlags(int flags) {

   110         for (StreamOpFlag f : known) {

   111             Assert.assertTrue(f.isKnown(flags),

   112                               String.format("Flag %s is not known, but should be known.", f.toString()));

   113         }

   114 

   115         for (StreamOpFlag f : preserve) {

   116             Assert.assertTrue(f.isPreserved(flags),

   117                               String.format("Flag %s is not preserved, but should be preserved.", f.toString()));

   118         }

   119 

   120         for (StreamOpFlag f : notKnown) {

   121             Assert.assertFalse(f.isKnown(flags),

   122                                String.format("Flag %s is known, but should be not known.", f.toString()));

   123         }

   124     }

   125 }