/**

* 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 io.reactivex.NbpObservable.*;

import io.reactivex.disposables.Disposable;

import io.reactivex.exceptions.TestException;

import io.reactivex.functions.*;

import io.reactivex.internal.functions.Functions;

import io.reactivex.schedulers.Schedulers;

import io.reactivex.subscribers.nbp.NbpTestSubscriber;

/**

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

*/

public class NbpObservableNullTests {

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

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

// Static methods

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

@Test(expected = NullPointerException.class)

public void ambVarargsNull() {

NbpObservable.amb((NbpObservable<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void ambVarargsOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void ambIterableNull() {

NbpObservable.amb((Iterable<NbpObservable<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void ambIterableIteratorNull() {

NbpObservable.amb(new Iterable<NbpObservable<Object>>() {

@Override

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

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void ambIterableOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void combineLatestVarargsNull() {

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

@Override

public Object apply(Object[] v) {

return 1;

}

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestVarargsOneIsNull() {

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

@Override

public Object apply(Object[] v) {

return 1;

}

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

}

@Test(expected = NullPointerException.class)

public void combineLatestIterableNull() {

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

@Override

public Object apply(Object[] v) {

return 1;

}

}, true, 128);

}

@Test(expected = NullPointerException.class)

public void combineLatestIterableIteratorNull() {

NbpObservable.combineLatest(new Iterable<NbpObservable<Object>>() {

@Override

public Iterator<NbpObservable<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() {

NbpObservable.combineLatest(Arrays.asList(NbpObservable.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() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestVarargsFunctionReturnsNull() {

NbpObservable.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() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void combineLatestIterableFunctionReturnsNull() {

NbpObservable.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() {

NbpObservable.concat((Iterable<NbpObservable<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void concatIterableIteratorNull() {

NbpObservable.concat(new Iterable<NbpObservable<Object>>() {

@Override

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

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void concatIterableOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void concatNbpObservableNull() {

NbpObservable.concat((NbpObservable<NbpObservable<Object>>)null);

}

@Test(expected = NullPointerException.class)

public void concatArrayNull() {

NbpObservable.concatArray((NbpObservable<Object>[])null);

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void concatArrayOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void createNull() {

NbpObservable.create(null);

}

@Test(expected = NullPointerException.class)

public void deferFunctionNull() {

NbpObservable.defer(null);

}

@Test(expected = NullPointerException.class)

public void deferFunctionReturnsNull() {

NbpObservable.defer(new Supplier<NbpObservable<Object>>() {

@Override

public NbpObservable<Object> get() {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void errorFunctionNull() {

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

}

@Test(expected = NullPointerException.class)

public void errorFunctionReturnsNull() {

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

@Override

public Throwable get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void errorThrowableNull() {

NbpObservable.error((Throwable)null);

}

@Test(expected = NullPointerException.class)

public void fromArrayNull() {

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

}

@Test(expected = NullPointerException.class)

public void fromArrayOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void fromCallableNull() {

NbpObservable.fromCallable(null);

}

@Test(expected = NullPointerException.class)

public void fromCallableReturnsNull() {

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

@Override

public Object call() throws Exception {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromFutureNull() {

NbpObservable.fromFuture(null);

}

@Test

public void fromFutureReturnsNull() {

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

f.run();

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

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

ts.assertNoValues();

ts.assertNotComplete();

ts.assertError(NullPointerException.class);

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedFutureNull() {

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

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedUnitNull() {

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

}

@Test(expected = NullPointerException.class)

public void fromFutureTimedSchedulerNull() {

NbpObservable.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();

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

}

@Test(expected = NullPointerException.class)

public void fromFutureSchedulerNull() {

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

NbpObservable.fromFuture(f, null);

}

@Test(expected = NullPointerException.class)

public void fromIterableNull() {

NbpObservable.fromIterable(null);

}

@Test(expected = NullPointerException.class)

public void fromIterableIteratorNull() {

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

@Override

public Iterator<Object> iterator() {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void fromIterableValueNull() {

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

}

@Test(expected = NullPointerException.class)

public void generateConsumerNull() {

NbpObservable.generate(null);

}

@Test(expected = NullPointerException.class)

public void generateConsumerEmitsNull() {

NbpObservable.generate(new Consumer<NbpSubscriber<Object>>() {

@Override

public void accept(NbpSubscriber<Object> s) {

s.onNext(null);

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void generateStateConsumerInitialStateNull() {

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

@Override

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

o.onNext(1);

}

};

NbpObservable.generate(null, generator);

}

@Test(expected = NullPointerException.class)

public void generateStateFunctionInitialStateNull() {

NbpObservable.generate(null, new BiFunction<Object, NbpSubscriber<Object>, Object>() {

@Override

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

});

}

@Test(expected = NullPointerException.class)

public void generateStateConsumerNull() {

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

@Override

public Integer get() {

return 1;

}

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

}

@Test

public void generateConsumerStateNullAllowed() {

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

@Override

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

o.onComplete();

}

};

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

@Override

public Integer get() {

return null;

}

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

}

@Test

public void generateFunctionStateNullAllowed() {

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

@Override

public Object get() {

return null;

}

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

@Override

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

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void generateConsumerDisposeNull() {

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

@Override

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

o.onNext(1);

}

};

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

@Override

public Integer get() {

return 1;

}

}, generator, null);

}

@Test(expected = NullPointerException.class)

public void generateFunctionDisposeNull() {

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

@Override

public Object get() {

return 1;

}

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

@Override

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

}, null);

}

@Test(expected = NullPointerException.class)

public void intervalUnitNull() {

NbpObservable.interval(1, null);

}

public void intervalSchedulerNull() {

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

}

@Test(expected = NullPointerException.class)

public void intervalPeriodUnitNull() {

NbpObservable.interval(1, 1, null);

}

@Test(expected = NullPointerException.class)

public void intervalPeriodSchedulerNull() {

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

}

@Test(expected = NullPointerException.class)

public void intervalRangeUnitNull() {

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

}

@Test(expected = NullPointerException.class)

public void intervalRangeSchedulerNull() {

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

}

@Test

public void justNull() throws Exception {

@SuppressWarnings("rawtypes")

Class<NbpObservable> clazz = NbpObservable.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() {

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

}

@Test(expected = NullPointerException.class)

public void mergeIterableIteratorNull() {

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

@Override

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

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeIterableOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void mergeArrayNull() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeArrayOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableNull() {

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

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableIteratorNull() {

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

@Override

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

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeDelayErrorIterableOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void mergeDelayErrorArrayNull() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void mergeDelayErrorArrayOneIsNull() {

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

}

@Test(expected = NullPointerException.class)

public void sequenceEqualFirstNull() {

NbpObservable.sequenceEqual(null, just1);

}

@Test(expected = NullPointerException.class)

public void sequenceEqualSecondNull() {

NbpObservable.sequenceEqual(just1, null);

}

@Test(expected = NullPointerException.class)

public void sequenceEqualComparatorNull() {

NbpObservable.sequenceEqual(just1, just1, null);

}

@Test(expected = NullPointerException.class)

public void switchOnNextNull() {

NbpObservable.switchOnNext(null);

}

@Test(expected = NullPointerException.class)

public void timerUnitNull() {

NbpObservable.timer(1, null);

}

@Test(expected = NullPointerException.class)

public void timerSchedulerNull() {

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

}

@Test(expected = NullPointerException.class)

public void usingResourceSupplierNull() {

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

@Override

public NbpObservable<Integer> apply(Object d) {

return just1;

}

}, new Consumer<Object>() {

@Override

public void accept(Object d) { }

});

}

@Test(expected = NullPointerException.class)

public void usingNbpObservableSupplierNull() {

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

@Override

public Object get() {

return 1;

}

}, null, new Consumer<Object>() {

@Override

public void accept(Object d) { }

});

}

@Test(expected = NullPointerException.class)

public void usingNbpObservableSupplierReturnsNull() {

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

@Override

public Object get() {

return 1;

}

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

@Override

public NbpObservable<Object> apply(Object d) {

return null;

}

}, new Consumer<Object>() {

@Override

public void accept(Object d) { }

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void usingDisposeNull() {

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

@Override

public Object get() {

return 1;

}

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

@Override

public NbpObservable<Integer> apply(Object d) {

return just1;

}

}, null);

}

@Test(expected = NullPointerException.class)

public void zipIterableNull() {

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

@Override

public Object apply(Object[] v) {

return 1;

}

});

}

@Test(expected = NullPointerException.class)

public void zipIterableIteratorNull() {

NbpObservable.zip(new Iterable<NbpObservable<Object>>() {

@Override

public Iterator<NbpObservable<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() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterableFunctionReturnsNull() {

NbpObservable.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 zipNbpObservableNull() {

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

@Override

public Object apply(Object[] a) {

return 1;

}

});

}

@Test(expected = NullPointerException.class)

public void zipNbpObservableFunctionNull() {

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

}

@Test(expected = NullPointerException.class)

public void zipNbpObservableFunctionReturnsNull() {

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

@Override

public Object apply(Object[] a) {

return null;

}

}).toBlocking().lastOption();

}

@Test(expected = NullPointerException.class)

public void zipIterable2Null() {

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

@Override

public Object apply(Object[] a) {

return 1;

}

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

}

@Test(expected = NullPointerException.class)

public void zipIterable2IteratorNull() {

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

@Override

public Object apply(Object[] a) {

return 1;

}

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

@Override

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

return null;

}

}).toBlocking().lastOption();

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterable2FunctionNull() {

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

}

@SuppressWarnings("unchecked")

@Test(expected = NullPointerException.class)

public void zipIterable2FunctionReturnsNull() {

NbpObservable.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, NbpObservable<Integer>>() {

@Override

public NbpObservable<Integer> apply(Object o) {

return just1;

}

});

}

@Test(expected = NullPointerException.class)

public void bufferOpenCloseCloseNull() {

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

}

@Test(expected = NullPointerException.class)

public void bufferOpenCloseCloseReturnsNull() {

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

@Override

public NbpObservable<Object> apply(Integer v) {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferBoundaryNull() {

just1.buffer((NbpObservable<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<NbpObservable<Integer>>)null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2ReturnsNull() {

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

@Override

public NbpObservable<Object> get() {

return null;

}

}).toBlocking().run();

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2SupplierNull() {

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

@Override

public NbpObservable<Integer> get() {

return just1;

}

}, null);

}

@Test(expected = NullPointerException.class)

public void bufferBoundarySupplier2SupplierReturnsNull() {

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

@Override

public NbpObservable<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, NbpObservable<Object>>() {

@Override

public NbpObservable<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)