java.util.stream.TestData#OfInt ( )源码实例Demo

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testIntStream(String name, TestData.OfInt data) {
    for (IntPredicate p : INT_PREDICATES) {
        setContext("p", p);
        for (Kind kind : Kind.values()) {
            setContext("kind", kind);
            exerciseTerminalOps(data, intKinds.get(kind).apply(p));
            exerciseTerminalOps(data, s -> s.filter(ipFalse), intKinds.get(kind).apply(p));
            exerciseTerminalOps(data, s -> s.filter(ipEven), intKinds.get(kind).apply(p));
        }
    }
}
 

@Test(dataProvider = "IntStream.limit")
public void testIntUnorderedGenerator(String description, UnaryOperator<IntStream> fs) {
    // Source is spliterator of infinite size
    TestData.OfInt generator = TestData.Factory.ofIntSupplier(
            "[1, 1, ...]", () -> IntStream.generate(() -> 1));

    withData(generator).
            stream(s -> fs.apply(s.filter(i -> true).unordered())).
            exercise();
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testOps(String name, TestData.OfInt data) {
    assertEquals(0, (int) exerciseTerminalOps(data, s -> s.filter(ipFalse), s -> s.reduce(0, irPlus)));

    OptionalInt seedless = exerciseTerminalOps(data, s -> s.reduce(irPlus));
    int folded = exerciseTerminalOps(data, s -> s.reduce(0, irPlus));
    assertEquals(folded, seedless.orElse(0));

    seedless = exerciseTerminalOps(data, s -> s.reduce(irMin));
    folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MAX_VALUE, irMin));
    assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));

    seedless = exerciseTerminalOps(data, s -> s.reduce(irMax));
    folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MIN_VALUE, irMax));
    assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));

    seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irPlus));
    folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(0, irPlus));
    assertEquals(folded, seedless.orElse(0));

    seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irMin));
    folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(Integer.MAX_VALUE, irMin));
    assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));

    seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irMax));
    folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(Integer.MIN_VALUE, irMax));
    assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));
}
 

@Test
public void testIntSingleton() {
    TestData.OfInt data = TestData.Factory.ofIntSupplier("[0, 1)",
                                                         () -> IntStream.of(1));

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

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

@Test(dataProvider = "ints")
public void testInts(TestData.OfInt data, ResultAsserter<Iterable<Integer>> ra) {
    withData(data).
            stream(s -> s).
            without(IntStreamTestScenario.CLEAR_SIZED_SCENARIOS).
            resultAsserter(ra).
            exercise();
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testOps(String name, TestData.OfInt data) {
    AtomicLong expectedCount = new AtomicLong();
    data.stream().forEach(e -> expectedCount.incrementAndGet());

    withData(data).
            terminal(IntStream::count).
            expectedResult(expectedCount.get()).
            exercise();
}
 

@Test(dataProvider = "ints")
public void testInts(TestData.OfInt data, ResultAsserter<Iterable<Integer>> ra) {
    withData(data).
            stream(s -> s).
            without(IntStreamTestScenario.CLEAR_SIZED_SCENARIOS).
            resultAsserter(ra).
            exercise();
}
 

private void testIntStreamBuilder(int size, Function<Integer, IntStream> supplier) {
    TestData.OfInt data = TestData.Factory.ofIntSupplier(String.format("[0, %d)", size),
                                                         () -> supplier.apply(size));

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

    withData(data).
            stream(s -> s.map(i -> i)).
            expectedResult(IntStream.range(0, size).toArray()).
            exercise();
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testOps(String name, TestData.OfInt data) {
    AtomicLong expectedCount = new AtomicLong();
    data.stream().forEach(e -> expectedCount.incrementAndGet());

    withData(data).
            terminal(IntStream::count).
            expectedResult(expectedCount.get()).
            exercise();
}
 

@Test(dataProvider = "IntStream.limit")
public void testIntUnorderedGenerator(String description, UnaryOperator<IntStream> fs) {
    // Source is spliterator of infinite size
    TestData.OfInt generator = TestData.Factory.ofIntSupplier(
            "[1, 1, ...]", () -> IntStream.generate(() -> 1));

    withData(generator).
            stream(s -> fs.apply(s.filter(i -> true).unordered())).
            exercise();
}
 

@Test(dataProvider = "IntStream.limit")
public void testIntUnorderedIteration(String description, UnaryOperator<IntStream> fs) {
    // Source is a right-balanced tree of infinite size
    TestData.OfInt iterator = TestData.Factory.ofIntSupplier(
            "[1, 2, 3, ...]", () -> IntStream.iterate(1, i -> i + 1));

    // Ref
    withData(iterator).
            stream(s -> fs.apply(s.unordered())).
            resultAsserter(unorderedAsserter()).
            exercise();
}
 

@Test
public void testIntSingleton() {
    TestData.OfInt data = TestData.Factory.ofIntSupplier("[0, 1)",
                                                         () -> IntStream.of(1));

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

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

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testIntParSpliterators(String name, TestData.OfInt data) {
    for (Function<IntStream, IntStream> f : intStreamFunctions()) {
        SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
    }
}
 

private TestData.OfInt intRange(int l, int u) {
    return TestData.Factory.ofIntSupplier(
            String.format("[%d, %d)", l, u),
            () -> IntStream.range(l, u));
}
 

TestData.OfInt intRangeData(int start, int end) {
    return TestData.Factory.ofIntSupplier("int range", () -> IntStream.range(start, end));
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testIntSpliterators(String name, TestData.OfInt data) {
    for (Function<IntStream, IntStream> f : intStreamFunctions()) {
        SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
    }
}
 

TestData.OfInt intRangeClosedData(int start, int end) {
    return TestData.Factory.ofIntSupplier("int rangeClosed", () -> IntStream.rangeClosed(start, end));
}
 

@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
public void testIntSpliterators(String name, TestData.OfInt data) {
    for (Function<IntStream, IntStream> f : intStreamFunctions()) {
        SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
    }
}
 

TestData.OfInt intRangeClosedData(int start, int end) {
    return TestData.Factory.ofIntSupplier("int rangeClosed", () -> IntStream.rangeClosed(start, end));
}
 

private TestData.OfInt intRange(int l, int u) {
    return TestData.Factory.ofIntSupplier(
            String.format("[%d, %d)", l, u),
            () -> IntStream.range(l, u));
}