## Uses of Interface
com.hazelcast.jet.pipeline.BatchStage

- Packages that use BatchStage
  Package | Description
  --- | ---
  com.hazelcast.jet.pipeline | The Pipeline API is Jet's high-level API to build and execute distributed computation jobs.
  com.hazelcast.jet.pipeline.test | This package contains various mock sources to help with pipeline testing and development.

- - ### Uses of BatchStage in com.hazelcast.jet.pipeline

    Methods in com.hazelcast.jet.pipeline that return BatchStage
    Modifier and Type | Method and Description
    --- | ---
    `<R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given group-and-aggregate operation.
    `<R> BatchStage<R>` | BatchStage.`aggregate(AggregateOperation1<? super T,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives.
    `default <T1,R0,R1> BatchStage<Tuple2<R0,R1>>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and emitting a `Tuple2` with their results.
    `default <T1,R0,R1> BatchStage<Map.Entry<K,Tuple2<R0,R1>>>` | BatchStageWithKey.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<? extends T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from both this stage and `stage1` you supply.
    `<T1,R> BatchStage<R>` | BatchStage.`aggregate2(BatchStage<T1> stage1, AggregateOperation2<? super T,? super T1,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives from both this stage and `stage1` you supply.
    `<T1,R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`aggregate2(BatchStageWithKey<T1,? extends K> stage1, AggregateOperation2<? super T,? super T1,?,R> aggrOp)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `default <T1,T2,R0,R1,R2> BatchStage<Map.Entry<K,Tuple3<R0,R1,R2>>>` | BatchStageWithKey.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStageWithKey<T1,? extends K> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that performs the given cogroup-and-aggregate transformation of the items from this stage as well as `stage1` and `stage2` you supply.
    `<T1,T2,R> BatchStage<R>` | BatchStage.`aggregate3(BatchStage<T1> stage1, BatchStage<T2> stage2, AggregateOperation3<? super T,? super T1,? super T2,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives from this stage as well as `stage1` and `stage2` you supply.
    `<T1,T2,R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`aggregate3(BatchStageWithKey<T1,? extends K> stage1, BatchStageWithKey<T2,? extends K> stage2, AggregateOperation3<? super T,? super T1,? super T2,?,? extends R> aggrOp)` Attaches a stage that performs the given cogroup-and-aggregate operation over the items from this stage as well as `stage1` and `stage2` you supply.
    `default <R> BatchStage<R>` | BatchStage.`apply(FunctionEx<? super BatchStage<T>,? extends BatchStage<R>> transformFn)` Transforms `this` stage using the provided `transformFn` and returns the transformed stage.
    `BatchStage<Map.Entry<K,ItemsByTag>>` | GroupAggregateBuilder.`build()` Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object and emits a `Map.Entry(key, resultsByTag)` for each distinct key.
    `BatchStage<ItemsByTag>` | AggregateBuilder.`build()` Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object.
    `<R> BatchStage<Map.Entry<K,R>>` | GroupAggregateBuilder1.`build(AggregateOperation<?,R> aggrOp)` Creates and returns a pipeline stage that performs the co-grouping and aggregation of pipeline stages registered with this builder object.
    `<R> BatchStage<R>` | AggregateBuilder1.`build(AggregateOperation<?,R> aggrOp)` Creates and returns a pipeline stage that performs the co-aggregation of pipeline stages registered with this builder object.
    `<R,OUT> BatchStage<OUT>` | GroupAggregateBuilder1.`build(AggregateOperation<?,R> aggrOp, BiFunctionEx<? super K,? super R,OUT> mapToOutputFn)` Deprecated. This is a leftover from an earlier development cycle of the Pipeline API. Use `GroupAggregateBuilder1.build(AggregateOperation)` instead and add a separate mapping stage with `mapToOutputFn`.
    `<R> BatchStage<R>` | HashJoinBuilder.`build(BiFunctionEx<T0,ItemsByTag,R> mapToOutputFn)` Builds a new pipeline stage that performs the hash-join operation.
    `<R> BatchStage<R>` | AggregateBuilder.`build(FunctionEx<? super ItemsByTag,? extends R> finishFn)` Creates and returns a pipeline stage that performs the co-aggregation of the stages registered with this builder object.
    `<R> BatchStage<R>` | BatchStageWithKey.`customTransform(String stageName, ProcessorMetaSupplier procSupplier)`
    `<R> BatchStage<R>` | BatchStage.`customTransform(String stageName, ProcessorMetaSupplier procSupplier)`
    `default <R> BatchStage<R>` | BatchStageWithKey.`customTransform(String stageName, ProcessorSupplier procSupplier)`
    `default <R> BatchStage<R>` | BatchStage.`customTransform(String stageName, ProcessorSupplier procSupplier)`
    `default <R> BatchStage<R>` | BatchStageWithKey.`customTransform(String stageName, SupplierEx<Processor> procSupplier)`
    `default <R> BatchStage<R>` | BatchStage.`customTransform(String stageName, SupplierEx<Processor> procSupplier)`
    `BatchStage<T>` | BatchStageWithKey.`distinct()` Attaches a stage that emits just the items that are distinct according to the grouping key (no two items which map to the same key will be on the output).
    `default BatchStage<T>` | BatchStage.`distinct()` Attaches a stage that emits just the items that are distinct according to their definition of equality (`equals` and `hashCode`).
    `<T> BatchStage<T>` | Pipeline.`drawFrom(BatchSource<? extends T> source)` Returns a pipeline stage that represents a bounded (batch) data source.
    `BatchStage<T>` | BatchStage.`filter(PredicateEx<T> filterFn)`
    `<S> BatchStage<T>` | BatchStageWithKey.`filterStateful(SupplierEx<? extends S> createFn, BiPredicateEx<? super S,? super T> filterFn)`
    `<S> BatchStage<T>` | BatchStage.`filterStateful(SupplierEx<? extends S> createFn, BiPredicateEx<? super S,? super T> filterFn)`
    `<C> BatchStage<T>` | BatchStage.`filterUsingContext(ContextFactory<C> contextFactory, BiPredicateEx<? super C,? super T> filterFn)`
    `<C> BatchStage<T>` | BatchStageWithKey.`filterUsingContext(ContextFactory<C> contextFactory, TriPredicate<? super C,? super K,? super T> filterFn)`
    `<C> BatchStage<T>` | BatchStage.`filterUsingContextAsync(ContextFactory<C> contextFactory, BiFunctionEx<? super C,? super T,? extends CompletableFuture<Boolean>> filterAsyncFn)`
    `<C> BatchStage<T>` | BatchStageWithKey.`filterUsingContextAsync(ContextFactory<C> contextFactory, TriFunction<? super C,? super K,? super T,CompletableFuture<Boolean>> filterAsyncFn)`
    `<R> BatchStage<R>` | BatchStage.`flatMap(FunctionEx<? super T,? extends Traverser<? extends R>> flatMapFn)`
    `<S,R> BatchStage<R>` | BatchStage.`flatMapStateful(SupplierEx<? extends S> createFn, BiFunctionEx<? super S,? super T,? extends Traverser<R>> flatMapFn)`
    `<S,R> BatchStage<R>` | BatchStageWithKey.`flatMapStateful(SupplierEx<? extends S> createFn, TriFunction<? super S,? super K,? super T,? extends Traverser<R>> flatMapFn)`
    `<C,R> BatchStage<R>` | BatchStage.`flatMapUsingContext(ContextFactory<C> contextFactory, BiFunctionEx<? super C,? super T,? extends Traverser<R>> flatMapFn)`
    `<C,R> BatchStage<R>` | BatchStageWithKey.`flatMapUsingContext(ContextFactory<C> contextFactory, TriFunction<? super C,? super K,? super T,? extends Traverser<? extends R>> flatMapFn)`
    `<C,R> BatchStage<R>` | BatchStage.`flatMapUsingContextAsync(ContextFactory<C> contextFactory, BiFunctionEx<? super C,? super T,? extends CompletableFuture<Traverser<R>>> flatMapAsyncFn)`
    `<C,R> BatchStage<R>` | BatchStageWithKey.`flatMapUsingContextAsync(ContextFactory<C> contextFactory, TriFunction<? super C,? super K,? super T,CompletableFuture<Traverser<R>>> flatMapAsyncFn)`
    `<K,T1_IN,T1,R> BatchStage<R>` | BatchStage.`hashJoin(BatchStage<T1_IN> stage1, JoinClause<K,? super T,? super T1_IN,? extends T1> joinClause1, BiFunctionEx<T,T1,R> mapToOutputFn)`
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> BatchStage<R>` | BatchStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)`
    `<R> BatchStage<R>` | BatchStage.`map(FunctionEx<? super T,? extends R> mapFn)`
    `<S,R> BatchStage<R>` | BatchStage.`mapStateful(SupplierEx<? extends S> createFn, BiFunctionEx<? super S,? super T,? extends R> mapFn)`
    `<S,R> BatchStage<R>` | BatchStageWithKey.`mapStateful(SupplierEx<? extends S> createFn, TriFunction<? super S,? super K,? super T,? extends R> mapFn)`
    `<C,R> BatchStage<R>` | BatchStage.`mapUsingContext(ContextFactory<C> contextFactory, BiFunctionEx<? super C,? super T,? extends R> mapFn)`
    `<C,R> BatchStage<R>` | BatchStageWithKey.`mapUsingContext(ContextFactory<C> contextFactory, TriFunction<? super C,? super K,? super T,? extends R> mapFn)`
    `<C,R> BatchStage<R>` | BatchStage.`mapUsingContextAsync(ContextFactory<C> contextFactory, BiFunctionEx<? super C,? super T,? extends CompletableFuture<R>> mapAsyncFn)`
    `<C,R> BatchStage<R>` | BatchStageWithKey.`mapUsingContextAsync(ContextFactory<C> contextFactory, TriFunction<? super C,? super K,? super T,CompletableFuture<R>> mapAsyncFn)`
    `default <V,R> BatchStage<R>` | BatchStageWithKey.`mapUsingIMap(IMap<K,V> iMap, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `default <K,V,R> BatchStage<R>` | BatchStage.`mapUsingIMap(IMap<K,V> iMap, FunctionEx<? super T,? extends K> lookupKeyFn, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `default <V,R> BatchStage<R>` | BatchStageWithKey.`mapUsingIMap(String mapName, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `default <K,V,R> BatchStage<R>` | BatchStage.`mapUsingIMap(String mapName, FunctionEx<? super T,? extends K> lookupKeyFn, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `default <K,V,R> BatchStage<R>` | BatchStage.`mapUsingReplicatedMap(ReplicatedMap<K,V> replicatedMap, FunctionEx<? super T,? extends K> lookupKeyFn, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `default <K,V,R> BatchStage<R>` | BatchStage.`mapUsingReplicatedMap(String mapName, FunctionEx<? super T,? extends K> lookupKeyFn, BiFunctionEx<? super T,? super V,? extends R> mapFn)`
    `BatchStage<T>` | BatchStage.`merge(BatchStage<? extends T> other)` Attaches a stage that emits all the items from this stage as well as all the items from the supplied stage.
    `default BatchStage<T>` | BatchStage.`peek()`
    `default BatchStage<T>` | BatchStage.`peek(FunctionEx<? super T,? extends CharSequence> toStringFn)`
    `BatchStage<T>` | BatchStage.`peek(PredicateEx<? super T> shouldLogFn, FunctionEx<? super T,? extends CharSequence> toStringFn)`
    `default <A,R> BatchStage<Map.Entry<K,R>>` | BatchStageWithKey.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `default <A,R> BatchStage<R>` | BatchStage.`rollingAggregate(AggregateOperation1<? super T,A,? extends R> aggrOp)`
    `BatchStage<T>` | BatchStage.`setLocalParallelism(int localParallelism)`
    `BatchStage<T>` | BatchStage.`setName(String name)`

    Methods in com.hazelcast.jet.pipeline with parameters of type BatchStage
    Modifier and Type | Method and Description
    --- | ---
    `<T> Tag<T>` | AggregateBuilder1.`add(BatchStage<T> stage)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `<T,R> Tag<R>` | AggregateBuilder.`add(BatchStage<T> stage, AggregateOperation1<? super T,?,? extends R> aggrOp)` Adds another stage that will contribute its data to the aggregate operation to be performed.
    `<K,T1_IN,T1> Tag<T1>` | GeneralHashJoinBuilder.`add(BatchStage<T1_IN> stage, JoinClause<K,T0,T1_IN,T1> joinClause)` Adds another contributing pipeline stage to the hash-join operation.
    `default <T1,R0,R1> BatchStage<Tuple2<R0,R1>>` | BatchStage.`aggregate2(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1)` Attaches a stage that co-aggregates the data from this and the supplied stage by performing a separate aggregate operation on each and emitting a `Tuple2` with their results.
    `<T1,R> BatchStage<R>` | BatchStage.`aggregate2(BatchStage<T1> stage1, AggregateOperation2<? super T,? super T1,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives from both this stage and `stage1` you supply.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `default <T1,T2,R0,R1,R2> BatchStage<Tuple3<R0,R1,R2>>` | BatchStage.`aggregate3(AggregateOperation1<? super T,?,? extends R0> aggrOp0, BatchStage<T1> stage1, AggregateOperation1<? super T1,?,? extends R1> aggrOp1, BatchStage<T2> stage2, AggregateOperation1<? super T2,?,? extends R2> aggrOp2)` Attaches a stage that co-aggregates the data from this and the two supplied stages by performing a separate aggregate operation on each and emitting a `Tuple3` with their results.
    `<T1,T2,R> BatchStage<R>` | BatchStage.`aggregate3(BatchStage<T1> stage1, BatchStage<T2> stage2, AggregateOperation3<? super T,? super T1,? super T2,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives from this stage as well as `stage1` and `stage2` you supply.
    `<T1,T2,R> BatchStage<R>` | BatchStage.`aggregate3(BatchStage<T1> stage1, BatchStage<T2> stage2, AggregateOperation3<? super T,? super T1,? super T2,?,? extends R> aggrOp)` Attaches a stage that performs the given aggregate operation over all the items it receives from this stage as well as `stage1` and `stage2` you supply.
    `<K,T1_IN,T1,R> StreamStage<R>` | StreamStage.`hashJoin(BatchStage<T1_IN> stage1, JoinClause<K,? super T,? super T1_IN,? extends T1> joinClause1, BiFunctionEx<T,T1,R> mapToOutputFn)`
    `<K,T1_IN,T1,R> GeneralStage<R>` | GeneralStage.`hashJoin(BatchStage<T1_IN> stage1, JoinClause<K,? super T,? super T1_IN,? extends T1> joinClause1, BiFunctionEx<T,T1,R> mapToOutputFn)` Attaches to both this and the supplied stage a hash-joining stage and returns it.
    `<K,T1_IN,T1,R> BatchStage<R>` | BatchStage.`hashJoin(BatchStage<T1_IN> stage1, JoinClause<K,? super T,? super T1_IN,? extends T1> joinClause1, BiFunctionEx<T,T1,R> mapToOutputFn)`
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> StreamStage<R>` | StreamStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)`
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> StreamStage<R>` | StreamStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)`
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> GeneralStage<R>` | GeneralStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)` Attaches to this and the two supplied stages a hash-joining stage and returns it.
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> GeneralStage<R>` | GeneralStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)` Attaches to this and the two supplied stages a hash-joining stage and returns it.
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> BatchStage<R>` | BatchStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)`
    `<K1,K2,T1_IN,T2_IN,T1,T2,R> BatchStage<R>` | BatchStage.`hashJoin2(BatchStage<T1_IN> stage1, JoinClause<K1,? super T,? super T1_IN,? extends T1> joinClause1, BatchStage<T2_IN> stage2, JoinClause<K2,? super T,? super T2_IN,? extends T2> joinClause2, TriFunction<T,T1,T2,R> mapToOutputFn)`
    `BatchStage<T>` | BatchStage.`merge(BatchStage<? extends T> other)` Attaches a stage that emits all the items from this stage as well as all the items from the supplied stage.

    Method parameters in com.hazelcast.jet.pipeline with type arguments of type BatchStage
    Modifier and Type | Method and Description
    --- | ---
    `default <R> BatchStage<R>` | BatchStage.`apply(FunctionEx<? super BatchStage<T>,? extends BatchStage<R>> transformFn)` Transforms `this` stage using the provided `transformFn` and returns the transformed stage.
    `default <R> BatchStage<R>` | BatchStage.`apply(FunctionEx<? super BatchStage<T>,? extends BatchStage<R>> transformFn)` Transforms `this` stage using the provided `transformFn` and returns the transformed stage.

  - ### Uses of BatchStage in com.hazelcast.jet.pipeline.test

    Methods in com.hazelcast.jet.pipeline.test that return types with arguments of type BatchStage
    Modifier and Type | Method and Description
    --- | ---
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertAnyOrder(Collection<? extends T> expected)` Asserts that the previous stage emitted the expected items in any order, but nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertAnyOrder(Collection<? extends T> expected)` Asserts that the previous stage emitted the expected items in any order, but nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertAnyOrder(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted the expected items in any order, but nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertAnyOrder(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted the expected items in any order, but nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertCollected(ConsumerEx<? super List<T>> assertFn)` Collects all the received items in a list and once the upstream stage is completed it executes the assertion supplied by `assertFn`.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertCollected(ConsumerEx<? super List<T>> assertFn)` Collects all the received items in a list and once the upstream stage is completed it executes the assertion supplied by `assertFn`.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertContains(Collection<? extends T> expected)` Asserts that the previous stage emitted all of the given items in any order.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertContains(Collection<? extends T> expected)` Asserts that the previous stage emitted all of the given items in any order.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertContains(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted all of the given items in any order.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertContains(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted all of the given items in any order.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertOrdered(Collection<? extends T> expected)` Asserts that the previous stage emitted the exact sequence of expected items and nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertOrdered(Collection<? extends T> expected)` Asserts that the previous stage emitted the exact sequence of expected items and nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertOrdered(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted the exact sequence of expected items and nothing else.
    `static <T> FunctionEx<BatchStage<T>,BatchStage<T>>` | Assertions.`assertOrdered(String message, Collection<? extends T> expected)` Asserts that the previous stage emitted the exact sequence of expected items and nothing else.

Copyright © 2020. All rights reserved.