Java 类java.util.stream.LambdaTestHelpers 实例源码

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartitioningBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapCollection(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitioningByAssertion<>(classifier,
                                                        new PartitioningByAssertion(classifier2, new ToListAssertion<>())));

    // Two level partition with reduce
    exerciseMapCollection(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitioningByAssertion<>(classifier,
                                                        new ReducingAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

public void findAllFileTest() {
    // derive expected result by using conventional loop
    Pattern pat = Pattern.compile("[A-Z]{7,}");
    List<String> expected = new ArrayList<>();

    try (Scanner sc = makeFileScanner(inputFile)) {
        String match;
        while ((match = sc.findWithinHorizon(pat, 0)) != null) {
            expected.add(match);
        }
    }

    Supplier<Stream<String>> ss =
        () -> makeFileScanner(inputFile).findAll(pat).map(MatchResult::group);

    withData(TestData.Factory.ofSupplier("findAllFileTest", ss))
            .stream(LambdaTestHelpers.identity())
            .expectedResult(expected)
            .exercise();
}

@Test(dataProvider = "FindAllZero")
public void findAllZeroTest(String input, String patternString) {
    Pattern pattern = Pattern.compile(patternString);

    // generate expected result using Matcher.find()
    Matcher m = pattern.matcher(input);
    List<String> expected = new ArrayList<>();
    while (m.find()) {
        expected.add(m.group());
    }

    Supplier<Stream<String>> ss = () -> new Scanner(input).findAll(pattern)
                                                          .limit(100)
                                                          .map(MatchResult::group);

    withData(TestData.Factory.ofSupplier("findAllZeroTest", ss))
            .stream(LambdaTestHelpers.identity())
            .expectedResult(expected)
            .exercise();
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartitioningBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapCollection(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitioningByAssertion<>(classifier,
                                                        new PartitioningByAssertion(classifier2, new ToListAssertion<>())));

    // Two level partition with reduce
    exerciseMapCollection(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitioningByAssertion<>(classifier,
                                                        new ReducingAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

public void findAllTest() {
    // derive expected result by using conventional loop
    Pattern pat = Pattern.compile("[A-Z]{7,}");
    List<String> expected = new ArrayList<>();

    try (Scanner sc = makeFileScanner(inputFile)) {
        String match;
        while ((match = sc.findWithinHorizon(pat, 0)) != null) {
            expected.add(match);
        }
    }

    Supplier<Stream<String>> ss =
        () -> makeFileScanner(inputFile).findAll(pat).map(MatchResult::group);

    withData(TestData.Factory.ofSupplier("findAllTest", ss))
            .stream(LambdaTestHelpers.identity())
            .expectedResult(expected)
            .exercise();
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            // Can only assert that all elements of the actual result
            // are distinct and that the count is the limit size
            // any element within the range [0, Long.MAX_VALUE) may be
            // present
            assertUnique(act);
            long count = 0;
            for (T l : act) {
                count++;
            }
            assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
    Predicate<Integer> classifier = i -> i % 3 == 0;
    Predicate<Integer> classifier2 = i -> i % 7 == 0;

    // Two level partition
    exerciseMapTabulation(data,
                          partitioningBy(classifier, partitioningBy(classifier2)),
                          new PartitionAssertion<>(classifier,
                                                   new PartitionAssertion(classifier2, new ListAssertion<>())));

    // Two level partition with reduce
    exerciseMapTabulation(data,
                          partitioningBy(classifier, reducing(0, Integer::sum)),
                          new PartitionAssertion<>(classifier,
                                                   new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
}

List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
    int uniqueSize = data.into(new HashSet<>()).size();

    return Arrays.asList(
        new MapperData<>(mId, uniqueSize),
        new MapperData<>(mZero, Math.min(1, data.size())),
        new MapperData<>(mDoubler, uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
        new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),

        new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
        new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
    );
}

private ResultAsserter<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
                                                              int expectedSize) {
    return (act, exp, ord, par) -> {
        if (par & !ord) {
            List<Integer> expected = new ArrayList<>();
            data.forEach(expected::add);

            List<Integer> actual = new ArrayList<>();
            act.forEach(actual::add);

            assertEquals(actual.size(), expectedSize);
            assertTrue(expected.containsAll(actual));
        }
        else {
            LambdaTestHelpers.assertContents(act, exp);
        }
    };
}

@SuppressWarnings({"rawtypes", "unchecked"})
@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testMixedSeqPar(String name, TestData.OfRef<Integer> data) {
    Function<Integer, Integer> id = LambdaTestHelpers.identity();
    UnaryOperator<Stream<Integer>>[] changers
            = new UnaryOperator[] {
            (UnaryOperator<Stream<Integer>>) s -> s,
            (UnaryOperator<Stream<Integer>>) s -> s.sequential(),
            (UnaryOperator<Stream<Integer>>) s -> s.parallel(),
            (UnaryOperator<Stream<Integer>>) s -> s.unordered()
    };
    UnaryOperator<Stream<Integer>>[] stuff
            = new UnaryOperator[] {
            (UnaryOperator<Stream<Integer>>) s -> s,
            (UnaryOperator<Stream<Integer>>) s -> s.map(id),
            (UnaryOperator<Stream<Integer>>) s -> s.sorted(Comparator.naturalOrder()),
            (UnaryOperator<Stream<Integer>>) s -> s.map(id).sorted(Comparator.naturalOrder()).map(id),
            (UnaryOperator<Stream<Integer>>) s -> s.filter(LambdaTestHelpers.pEven).sorted(Comparator.naturalOrder()).map(id),
    };

    for (int c1Index = 0; c1Index < changers.length; c1Index++) {
        setContext("c1Index", c1Index);
        UnaryOperator<Stream<Integer>> c1 = changers[c1Index];
        for (int s1Index = 0; s1Index < stuff.length; s1Index++) {
            setContext("s1Index", s1Index);
            UnaryOperator<Stream<Integer>> s1 = stuff[s1Index];
            for (int c2Index = 0; c2Index < changers.length; c2Index++) {
                setContext("c2Index", c2Index);
                UnaryOperator<Stream<Integer>> c2 = changers[c2Index];
                for (int s2Index = 0; s2Index < stuff.length; s2Index++) {
                    setContext("s2Index", s2Index);
                    UnaryOperator<Stream<Integer>> s2 = stuff[s2Index];
                    UnaryOperator<Stream<Integer>> composed = s -> s2.apply(c2.apply(s1.apply(c1.apply(s))));
                    exerciseOps(data, composed);
                }
            }
        }
    }
}

private <T> ResultAsserter<T> mapTabulationAsserter(boolean ordered) {
    return (act, exp, ord, par) -> {
        if (par && (!ordered || !ord)) {
            TabulatorsTest.nestedMapEqualityAssertion(act, exp);
        }
        else {
            LambdaTestHelpers.assertContentsEqual(act, exp);
        }
    };
}

@Test
public void testSingleton() {
    TestData.OfRef<Integer> data = TestData.Factory.ofSupplier("[0, 1)",
                                                               () -> Stream.of(1));

    withData(data).
            stream(s -> s).
            expectedResult(Collections.singletonList(1)).
            exercise();

    withData(data).
            stream(s -> s.map(LambdaTestHelpers.identity())).
            expectedResult(Collections.singletonList(1)).
            exercise();
}

private void testStreamBuilder(int size, Function<Integer, Stream<Integer>> supplier) {
    TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(String.format("[0, %d)", size),
                                                               () -> supplier.apply(size));

    withData(data).
            stream(s -> s).
            expectedResult(IntStream.range(0, size).boxed().collect(toList())).
            exercise();

    withData(data).
            stream(s -> s.map(LambdaTestHelpers.identity())).
            expectedResult(IntStream.range(0, size).boxed().collect(toList())).
            exercise();
}

@Test(dataProvider = "Stream<String>")
public void testStrings(String description, String input, Pattern pattern, List<String> expected) {
    Supplier<Stream<String>> ss =  () -> pattern.splitAsStream(input);
    withData(TestData.Factory.ofSupplier(description, ss))
            .stream(LambdaTestHelpers.identity())
            .expectedResult(expected)
            .exercise();
}