/**

* Copyright 2016 Netflix, Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in

* compliance with the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software distributed under the License is

* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See

* the License for the specific language governing permissions and limitations under the License.

*/

package io.reactivex;

import java.lang.reflect.*;

import java.util.*;

import java.util.concurrent.*;

import org.junit.*;

import org.reactivestreams.*;

import io.reactivex.Observable.Operator;

import io.reactivex.exceptions.TestException;

import io.reactivex.functions.*;

import io.reactivex.internal.functions.Functions;

import io.reactivex.schedulers.Schedulers;

import io.reactivex.subjects.*;

import io.reactivex.subscribers.TestSubscriber;

/**

* Verifies the operators handle null values properly by emitting/throwing NullPointerExceptions

*/

public class ObservableNullTests {

Observable<Integer> just1 = Observable.just(1);

//***********************************************************

// Static methods

//***********************************************************

@Test(expected = NullPointerException.class)

public void ambVarargsNull() {

Observable.amb((Publisher<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void ambVarargsOneIsNull() {

Observable.amb(Observable.never(), null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void ambIterableNull() {

Observable.amb((Iterable<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void ambIterableIteratorNull() {

Observable.amb(new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void ambIterableOneIsNull() {

Observable.amb(Arrays.asList(Observable.never(), null)).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void combineLatestVarargsNull() {

Observable.combineLatest(new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128, (Publisher<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestVarargsOneIsNull() {

Observable.combineLatest(new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128, Observable.never(), null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void combineLatestIterableNull() {

Observable.combineLatest((Iterable<Publisher<Object>>)null, new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128);

}

@Test(expected = NullPointerException.class)

public void combineLatestIterableIteratorNull() {

Observable.combineLatest(new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}, new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestIterableOneIsNull() {

Observable.combineLatest(Arrays.asList(Observable.never(), null), new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestVarargsFunctionNull() {

Observable.combineLatest(null, true, 128, Observable.never());

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestVarargsFunctionReturnsNull() {

Observable.combineLatest(new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return null;

}

}, true, 128, just1).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestIterableFunctionNull() {

Observable.combineLatest(Arrays.asList(just1), null, true, 128);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestIterableFunctionReturnsNull() {

Observable.combineLatest(Arrays.asList(just1), new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return null;

}

}, true, 128).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void concatIterableNull() {

Observable.concat((Iterable<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void concatIterableIteratorNull() {

Observable.concat(new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void concatIterableOneIsNull() {

Observable.concat(Arrays.asList(just1, null)).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void concatPublisherNull() {

Observable.concat((Publisher<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void concatArrayNull() {

Observable.concatArray((Publisher<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void concatArrayOneIsNull() {

Observable.concatArray(just1, null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void createNull() {

Observable.create(null);

}

@Test(expected = NullPointerException.class)

public void deferFunctionNull() {

Observable.defer(null);

}

@Test(expected = NullPointerException.class)

public void deferFunctionReturnsNull() {

Observable.defer(new Supplier<Publisher<Object>>() {

@Override

public Publisher<Object> get() {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void errorFunctionNull() {

Observable.error((Supplier<Throwable>)null);

}

@Test(expected = NullPointerException.class)

public void errorFunctionReturnsNull() {

Observable.error(new Supplier<Throwable>() {

@Override

public Throwable get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void errorThrowableNull() {

Observable.error((Throwable)null);

}

@Test(expected = NullPointerException.class)

public void fromArrayNull() {

Observable.fromArray((Object[])null);

}

@Test(expected = NullPointerException.class)

public void fromArrayOneIsNull() {

Observable.fromArray(1, null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromCallableNull() {

Observable.fromCallable(null);

}

@Test(expected = NullPointerException.class)

public void fromCallableReturnsNull() {

Observable.fromCallable(new Callable<Object>() {

@Override

public Object call() throws Exception {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromFutureNull() {

Observable.fromFuture(null);

}

@Test

public void fromFutureReturnsNull() {

FutureTask<Object> f = new FutureTask<Object>(Functions.emptyRunnable(), null);

f.run();

TestSubscriber<Object> ts = new TestSubscriber<Object>();

Observable.fromFuture(f).subscribe(ts);

ts.assertNoValues();

ts.assertNotComplete();

ts.assertError(NullPointerException.class);

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedFutureNull() {

Observable.fromFuture(null, 1, TimeUnit.SECONDS);

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedUnitNull() {

Observable.fromFuture(new FutureTask<Object>(Functions.emptyRunnable(), null), 1, null);

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedSchedulerNull() {

Observable.fromFuture(new FutureTask<Object>(Functions.emptyRunnable(), null), 1, TimeUnit.SECONDS, null);

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedReturnsNull() {

FutureTask<Object> f = new FutureTask<Object>(Functions.emptyRunnable(), null);

f.run();

Observable.fromFuture(f, 1, TimeUnit.SECONDS).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromFutureSchedulerNull() {

Observable.fromFuture(new FutureTask<Object>(Functions.emptyRunnable(), null), null);

}

@Test(expected = NullPointerException.class)

public void fromIterableNull() {

Observable.fromIterable(null);

}

@Test(expected = NullPointerException.class)

public void fromIterableIteratorNull() {

Observable.fromIterable(new Iterable<Object>() {

@Override

public Iterator<Object> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromIterableValueNull() {

Observable.fromIterable(Arrays.asList(1, null)).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromPublisherNull() {

Observable.fromPublisher(null);

}

@Test(expected = NullPointerException.class)

public void generateConsumerNull() {

Observable.generate(null);

}

@Test(expected = NullPointerException.class)

public void generateConsumerEmitsNull() {

Observable.generate(new Consumer<Subscriber<Object>>() {

@Override

public void accept(Subscriber<Object> s) {

s.onNext(null);

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void generateStateConsumerInitialStateNull() {

BiConsumer<Integer, Subscriber<Integer>> generator = new BiConsumer<Integer, Subscriber<Integer>>() {

@Override

public void accept(Integer s, Subscriber<Integer> o) {

o.onNext(1);

}

};

Observable.generate(null, generator);

}

@Test(expected = NullPointerException.class)

public void generateStateFunctionInitialStateNull() {

Observable.generate(null, new BiFunction<Object, Subscriber<Object>, Object>() {

@Override

public Object apply(Object s, Subscriber<Object> o) { o.onNext(1); return s; }

});

}

@Test(expected = NullPointerException.class)

public void generateStateConsumerNull() {

Observable.generate(new Supplier<Integer>() {

@Override

public Integer get() {

return 1;

}

}, (BiConsumer<Integer, Subscriber<Object>>)null);

}

@Test

public void generateConsumerStateNullAllowed() {

BiConsumer<Integer, Subscriber<Integer>> generator = new BiConsumer<Integer, Subscriber<Integer>>() {

@Override

public void accept(Integer s, Subscriber<Integer> o) {

o.onComplete();

}

};

Observable.generate(new Supplier<Integer>() {

@Override

public Integer get() {

return null;

}

}, generator).toBlocking().lastOption();

}

@Test

public void generateFunctionStateNullAllowed() {

Observable.generate(new Supplier<Object>() {

@Override

public Object get() {

return null;

}

}, new BiFunction<Object, Subscriber<Object>, Object>() {

@Override

public Object apply(Object s, Subscriber<Object> o) { o.onComplete(); return s; }

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void generateConsumerDisposeNull() {

BiConsumer<Integer, Subscriber<Integer>> generator = new BiConsumer<Integer, Subscriber<Integer>>() {

@Override

public void accept(Integer s, Subscriber<Integer> o) {

o.onNext(1);

}

};

Observable.generate(new Supplier<Integer>() {

@Override

public Integer get() {

return 1;

}

}, generator, null);

}

@Test(expected = NullPointerException.class)

public void generateFunctionDisposeNull() {

Observable.generate(new Supplier<Object>() {

@Override

public Object get() {

return 1;

}

}, new BiFunction<Object, Subscriber<Object>, Object>() {

@Override

public Object apply(Object s, Subscriber<Object> o) { o.onNext(1); return s; }

}, null);

}

@Test(expected = NullPointerException.class)

public void intervalUnitNull() {

Observable.interval(1, null);

}

public void intervalSchedulerNull() {

Observable.interval(1, TimeUnit.SECONDS, null);

}

@Test(expected = NullPointerException.class)

public void intervalPeriodUnitNull() {

Observable.interval(1, 1, null);

}

@Test(expected = NullPointerException.class)

public void intervalPeriodSchedulerNull() {

Observable.interval(1, 1, TimeUnit.SECONDS, null);

}

@Test(expected = NullPointerException.class)

public void intervalRangeUnitNull() {

Observable.intervalRange(1,1, 1, 1, null);

}

@Test(expected = NullPointerException.class)

public void intervalRangeSchedulerNull() {

Observable.intervalRange(1, 1, 1, 1, TimeUnit.SECONDS, null);

}

@Test

public void justNull() throws Exception {

@SuppressWarnings("rawtypes")

Class<Observable> clazz = Observable.class;

for (int argCount = 1; argCount < 10; argCount++) {

for (int argNull = 1; argNull <= argCount; argNull++) {

Class<?>[] params = new Class[argCount];

Arrays.fill(params, Object.class);

Object[] values = new Object[argCount];

Arrays.fill(values, 1);

values[argNull - 1] = null;

Method m = clazz.getMethod("just", params);

try {

m.invoke(null, values);

Assert.fail("No exception for argCount " + argCount + " / argNull " + argNull);

} catch (InvocationTargetException ex) {

if (!(ex.getCause() instanceof NullPointerException)) {

Assert.fail("Unexpected exception for argCount " + argCount + " / argNull " + argNull + ": " + ex);

}

}

}

}

}

@Test(expected = NullPointerException.class)

public void mergeIterableNull() {

Observable.merge(128, 128, (Iterable<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void mergeIterableIteratorNull() {

Observable.merge(128, 128, new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeIterableOneIsNull() {

Observable.merge(128, 128, Arrays.asList(just1, null)).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void mergeArrayNull() {

Observable.merge(128, 128, (Publisher<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeArrayOneIsNull() {

Observable.merge(128, 128, just1, null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableNull() {

Observable.mergeDelayError(128, 128, (Iterable<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableIteratorNull() {

Observable.mergeDelayError(128, 128, new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableOneIsNull() {

Observable.mergeDelayError(128, 128, Arrays.asList(just1, null)).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorArrayNull() {

Observable.mergeDelayError(128, 128, (Publisher<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeDelayErrorArrayOneIsNull() {

Observable.mergeDelayError(128, 128, just1, null).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void sequenceEqualFirstNull() {

Observable.sequenceEqual(null, just1);

}

@Test(expected = NullPointerException.class)

public void sequenceEqualSecondNull() {

Observable.sequenceEqual(just1, null);

}

@Test(expected = NullPointerException.class)

public void sequenceEqualComparatorNull() {

Observable.sequenceEqual(just1, just1, null);

}

@Test(expected = NullPointerException.class)

public void switchOnNextNull() {

Observable.switchOnNext(null);

}

@Test(expected = NullPointerException.class)

public void timerUnitNull() {

Observable.timer(1, null);

}

@Test(expected = NullPointerException.class)

public void timerSchedulerNull() {

Observable.timer(1, TimeUnit.SECONDS, null);

}

@Test(expected = NullPointerException.class)

public void usingResourceSupplierNull() {

Observable.using(null, new Function<Object, Publisher<Integer>>() {

@Override

public Publisher<Integer> apply(Object d) {

return just1;

}

}, Functions.emptyConsumer());

}

@Test(expected = NullPointerException.class)

public void usingObservableSupplierNull() {

Observable.using(new Supplier<Object>() {

@Override

public Object get() {

return 1;

}

}, null, Functions.emptyConsumer());

}

@Test(expected = NullPointerException.class)

public void usingObservableSupplierReturnsNull() {

Observable.using(new Supplier<Object>() {

@Override

public Object get() {

return 1;

}

}, new Function<Object, Publisher<Object>>() {

@Override

public Publisher<Object> apply(Object d) {

return null;

}

}, Functions.emptyConsumer()).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void usingDisposeNull() {

Observable.using(new Supplier<Object>() {

@Override

public Object get() {

return 1;

}

}, new Function<Object, Publisher<Integer>>() {

@Override

public Publisher<Integer> apply(Object d) {

return just1;

}

}, null);

}

@Test(expected = NullPointerException.class)

public void zipIterableNull() {

Observable.zip((Iterable<Publisher<Object>>)null, new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

});

}

@Test(expected = NullPointerException.class)

public void zipIterableIteratorNull() {

Observable.zip(new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}, new Function<Object[], Object>() {

@Override

public Object apply(Object[] v) {

return 1;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterableFunctionNull() {

Observable.zip(Arrays.asList(just1, just1), null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterableFunctionReturnsNull() {

Observable.zip(Arrays.asList(just1, just1), new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void zipPublisherNull() {

Observable.zip((Publisher<Publisher<Object>>)null, new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return 1;

}

});

}

@Test(expected = NullPointerException.class)

public void zipPublisherFunctionNull() {

Observable.zip((Observable.just(just1)), null);

}

@Test(expected = NullPointerException.class)

public void zipPublisherFunctionReturnsNull() {

Observable.zip((Observable.just(just1)), new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void zipIterable2Null() {

Observable.zipIterable(new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return 1;

}

}, true, 128, (Iterable<Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void zipIterable2IteratorNull() {

Observable.zipIterable(new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return 1;

}

}, true, 128, new Iterable<Publisher<Object>>() {

@Override

public Iterator<Publisher<Object>> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterable2FunctionNull() {

Observable.zipIterable(null, true, 128, Arrays.asList(just1, just1));

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterable2FunctionReturnsNull() {

Observable.zipIterable(new Function<Object[], Object>() {

@Override

public Object apply(Object[] a) {

return null;

}

}, true, 128, Arrays.asList(just1, just1)).toBlocking().lastOption();

}

//*************************************************************

// Instance methods

//*************************************************************

@Test(expected = NullPointerException.class)

public void allPredicateNull() {

just1.all(null);

}

@Test(expected = NullPointerException.class)

public void ambWithNull() {

just1.ambWith(null);

}

@Test(expected = NullPointerException.class)

public void anyPredicateNull() {

just1.any(null);

}

@Test(expected = NullPointerException.class)

public void bufferSupplierNull() {

just1.buffer(1, 1, (Supplier<List<Integer>>)null);

}

@Test(expected = NullPointerException.class)

public void bufferSupplierReturnsNull() {

just1.buffer(1, 1, new Supplier<Collection<Integer>>() {

@Override

public Collection<Integer> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferTimedUnitNull() {

just1.buffer(1L, 1L, null);

}

@Test(expected = NullPointerException.class)

public void bufferTimedSchedulerNull() {

just1.buffer(1L, 1L, TimeUnit.SECONDS, null);

}

@Test(expected = NullPointerException.class)

public void bufferTimedSupplierNull() {

just1.buffer(1L, 1L, TimeUnit.SECONDS, Schedulers.single(), null);

}

@Test(expected = NullPointerException.class)

public void bufferTimedSupplierReturnsNull() {

just1.buffer(1L, 1L, TimeUnit.SECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {

@Override

public Collection<Integer> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferOpenCloseOpenNull() {

just1.buffer(null, new Function<Object, Publisher<Integer>>() {

@Override

public Publisher<Integer> apply(Object o) {

return just1;

}

});

}

@Test(expected = NullPointerException.class)

public void bufferOpenCloseCloseNull() {

just1.buffer(just1, (Function<Integer, Publisher<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void bufferOpenCloseCloseReturnsNull() {

just1.buffer(just1, new Function<Integer, Publisher<Object>>() {

@Override

public Publisher<Object> apply(Integer v) {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferBoundaryNull() {

just1.buffer((Publisher<Object>)null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplierNull() {

just1.buffer(just1, (Supplier<List<Integer>>)null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplierReturnsNull() {

just1.buffer(just1, new Supplier<Collection<Integer>>() {

@Override

public Collection<Integer> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2Null() {

just1.buffer((Supplier<Publisher<Integer>>)null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2ReturnsNull() {

just1.buffer(new Supplier<Publisher<Object>>() {

@Override

public Publisher<Object> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2SupplierNull() {

just1.buffer(new Supplier<Observable<Integer>>() {

@Override

public Observable<Integer> get() {

return just1;

}

}, null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2SupplierReturnsNull() {

just1.buffer(new Supplier<Observable<Integer>>() {

@Override

public Observable<Integer> get() {

return just1;

}

}, new Supplier<Collection<Integer>>() {

@Override

public Collection<Integer> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void castNull() {

just1.cast(null);

}

@Test(expected = NullPointerException.class)

public void collectInitialSupplierNull() {

just1.collect((Supplier<Integer>)null, new BiConsumer<Integer, Integer>() {

@Override

public void accept(Integer a, Integer b) { }

});

}

@Test(expected = NullPointerException.class)

public void collectInitialSupplierReturnsNull() {

just1.collect(new Supplier<Object>() {

@Override

public Object get() {

return null;

}

}, new BiConsumer<Object, Integer>() {

@Override

public void accept(Object a, Integer b) { }

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void collectInitialCollectorNull() {

just1.collect(new Supplier<Object>() {

@Override

public Object get() {

return 1;

}

}, null);

}

@Test(expected = NullPointerException.class)

public void collectIntoInitialNull() {

just1.collectInto(null, new BiConsumer<Object, Integer>() {

@Override

public void accept(Object a, Integer b) { }

});

}

@Test(expected = NullPointerException.class)

public void collectIntoCollectorNull() {

just1.collectInto(1, null);

}

@Test(expected = NullPointerException.class)

public void composeNull() {

just1.compose(null);

}

@Test(expected = NullPointerException.class)

public void concatMapNull() {

just1.concatMap(null);

}

@Test(expected = NullPointerException.class)

public void concatMapReturnsNull() {

just1.concatMap(new Function<Integer, Publisher<Object>>() {

@Override

public Publisher<Object> apply(Integer v) {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void concatMapIterableNull() {

just1.concatMapIterable(null);

}

@Test(expected = NullPointerException.class)

public void concatMapIterableReturnNull() {

just1.concatMapIterable(new Function<Integer, Iterable<Object>>() {

@Override

public Iterable<Object> apply(Integer v) {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void concatMapIterableIteratorNull() {

just1.concatMapIterable(new Function<Integer, Iterable<Object>>() {

@Override

public Iterable<Object> apply(Integer v) {

return new Iterable<Object>() {

@Override

public Iterator<Object> iterator() {

return null;

}

};

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void concatWithNull() {

just1.concatWith(null);

}

@Test(expected = NullPointerException.class)

public void containsNull() {

just1.contains(null);

}