How to use com.oath.cyclops.internal.stream.spliterators.push

@Override
public void forEachAsync(final Consumer<? super T> action) {
  if (async == Type.NO_BACKPRESSURE)
    source.subscribeAll(action, this.defaultErrorHandler, () -> {
    });
  else
    source.subscribe(action, this.defaultErrorHandler, () -> {
    }).request(Long.MAX_VALUE);
}

@Override
public <X extends Throwable> Subscription forEach(final long numberOfElements, final Consumer<? super T> consumer) {
  StreamSubscription sub = source.subscribe(consumer, this.defaultErrorHandler, () -> {
  });
  if(numberOfElements>0)
   sub.request(numberOfElements);
  return sub;
}

  @Override
  public void cancel() {
    ref[0].cancel();
    super.cancel();
  }
};

public Operator<Integer> createTwoAndError(){
  return new ArrayConcatonatingOperator<>(new ArrayOfValuesOperator<>(),
      new SpliteratorToOperator<>(Stream.of(1).spliterator()),
      Fixtures.oneAndErrorSource);
}
public Operator<Integer> createThreeErrors(){

public Operator<Integer> createEmpty(){
  return new FilterOperator<>(new ArrayOfValuesOperator<>(), i->true);
}
public Operator<Integer> createOne(){

public Operator<Integer> createThree(){
  return  new MapOperator<Integer,Integer>(new ArrayOfValuesOperator<>(1,2,3),i->i*2);
}
public Operator<Integer> createTwoAndError(){

public Operator<Integer> createThree(){
  return new ZippingOperator<Integer,Integer,Integer>(new ArrayOfValuesOperator<>(1,2,3),new ArrayOfValuesOperator<>(10,11,12),(a,b)->a+b);
}
public Operator<Integer> createTwoAndError(){

public Operator<Integer> createThree(){
  return  new SkipOperator<>(new ArrayOfValuesOperator<>(1,2,3,4,5,6),3);
}
public Operator<Integer> createTwoAndError(){

@Override
public void subscribeAll(Consumer<? super R> onNext, Consumer<? super Throwable> onError, Runnable onComplete) {
    subscribe(onNext,onError,onComplete).request(Long.MAX_VALUE);
}

  @Override
  public void cancel() {
    ref[0].cancel();
    super.cancel();
  }
};

@Override
public void subscribeAll(Consumer<? super IN> onNext, Consumer<? super Throwable> onError, Runnable onCompleteDs) {
  subscribe(onNext,onError,onCompleteDs).request(Long.MAX_VALUE);
}

@Override
public Subscriber<Long> createSubscriber() {
  SubscriberSource<Long> sub = new SubscriberSource<Long>();
  new MapOperator<Long,Long>(sub, i->i*2).subscribe(System.out::println,System.err::println,()->{});
  return sub;
}

@Override
public Subscriber<Long> createSubscriber() {
  SubscriberSource<Long> sub = new SubscriberSource<Long>();
  new FilterOperator<Long>(sub, i->true).subscribe(System.out::println,System.err::println,()->{});
  return sub;
}

@Override
public <X extends Throwable> void forEach(final Consumer<? super T> consumerElement, final Consumer<? super Throwable> consumerError,
                     final Runnable onComplete) {
  if (async != Type.NO_BACKPRESSURE) {
    this.source.subscribe(consumerElement, consumerError, onComplete).request(Long.MAX_VALUE);
  } else {
    source.subscribeAll(consumerElement, consumerError, onComplete);
  }
}

@Override
public <X extends Throwable> Subscription forEach(final long numberOfElements, final Consumer<? super T> consumer,
                         final Consumer<? super Throwable> consumerError) {
  StreamSubscription sub = source.subscribe(consumer, consumerError, () -> {
  });
  if(numberOfElements>0)
   sub.request(numberOfElements);
  return sub;
}

public Operator<Integer> createThree(){
  return  new FilterOperator<>(new ArrayOfValuesOperator<>(1,2,3),i->true);
}
public Operator<Integer> createTwoAndError(){

public Operator<Integer> createEmpty(){
  return new MapOperator<Integer,Integer>(new ArrayOfValuesOperator<>(), i->i*2);
}
public Operator<Integer> createOne(){

public Operator<Integer> createTwoAndError(){
  return new ZippingOperator<Integer,Integer,Integer>(Fixtures.twoAndErrorSource,new ArrayOfValuesOperator<>(10,11,12),(a, b)->a+b);
}
public Operator<Integer> createThreeErrors(){

@Override
public <X extends Throwable> void forEach(final Consumer<? super T> consumerElement, final Consumer<? super Throwable> consumerError) {
  if (async != Type.NO_BACKPRESSURE) {
    this.source.subscribe(consumerElement, consumerError, () -> {
    }).request(Long.MAX_VALUE);
  } else {
    source.subscribeAll(consumerElement, consumerError, () -> {
    });
  }
}

@Override
public <X extends Throwable> Subscription forEach(final long numberOfElements, final Consumer<? super T> consumer,
                         final Consumer<? super Throwable> consumerError, final Runnable onComplete) {
  StreamSubscription sub = source.subscribe(consumer, consumerError, onComplete);
  if(numberOfElements>0)
    sub.request(numberOfElements);
  return sub;
}