}
    }

    boolean removeEntry(int pos, T[] a, int m) {
        size--;

        int last;
        int slot;
        T curr;

            

Reported by PMD.

                      }
    }

    boolean removeEntry(int pos, T[] a, int m) {
        size--;

        int last;
        int slot;
        T curr;

            

Reported by PMD.

              public final class OpenHashSet<T> {
    private static final int INT_PHI = 0x9E3779B9;

    final float loadFactor;
    int mask;
    int size;
    int maxSize;
    T[] keys;


            

Reported by PMD.

                  private static final int INT_PHI = 0x9E3779B9;

    final float loadFactor;
    int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {

            

Reported by PMD.

              
    final float loadFactor;
    int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {
        this(16, 0.75f);

            

Reported by PMD.

              
    final float loadFactor;
    int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {
        this(16, 0.75f);

            

Reported by PMD.

                  final float loadFactor;
    int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {
        this(16, 0.75f);
    }

            

Reported by PMD.

                  int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {
        this(16, 0.75f);
    }


            

Reported by PMD.

                  int mask;
    int size;
    int maxSize;
    T[] keys;

    public OpenHashSet() {
        this(16, 0.75f);
    }


            

Reported by PMD.

                          }
        }
        a[pos] = value;
        if (++size >= maxSize) {
            rehash();
        }
        return true;
    }
    public boolean remove(T value) {

            

Reported by PMD.

               * </code></pre>
 * @param <T> the value type
 */
public final class AsyncProcessor<@NonNull T> extends FlowableProcessor<T> {

    @SuppressWarnings("rawtypes")
    static final AsyncSubscription[] EMPTY = new AsyncSubscription[0];

    @SuppressWarnings("rawtypes")

            

Reported by PMD.

                  @SuppressWarnings("rawtypes")
    static final AsyncSubscription[] TERMINATED = new AsyncSubscription[0];

    final AtomicReference<AsyncSubscription<T>[]> subscribers;

    /** Write before updating subscribers, read after reading subscribers as TERMINATED. */
    Throwable error;

    /** Write before updating subscribers, read after reading subscribers as TERMINATED. */

            

Reported by PMD.

                  final AtomicReference<AsyncSubscription<T>[]> subscribers;

    /** Write before updating subscribers, read after reading subscribers as TERMINATED. */
    Throwable error;

    /** Write before updating subscribers, read after reading subscribers as TERMINATED. */
    T value;

    /**

            

Reported by PMD.

                  Throwable error;

    /** Write before updating subscribers, read after reading subscribers as TERMINATED. */
    T value;

    /**
     * Creates a new AsyncProcessor.
     * @param <T> the value type to be received and emitted
     * @return the new AsyncProcessor instance

            

Reported by PMD.

                   * Constructs an AsyncProcessor.
     * @since 2.0
     */
    @SuppressWarnings("unchecked")
    AsyncProcessor() {
        this.subscribers = new AtomicReference<>(EMPTY);
    }

    @Override

            

Reported by PMD.

                          RxJavaPlugins.onError(t);
            return;
        }
        value = null;
        error = t;
        for (AsyncSubscription<T> as : subscribers.getAndSet(TERMINATED)) {
            as.onError(t);
        }
    }

            

Reported by PMD.

                  @Override
    @CheckReturnValue
    public boolean hasSubscribers() {
        return subscribers.get().length != 0;
    }

    @Override
    @CheckReturnValue
    public boolean hasThrowable() {

            

Reported by PMD.

              
            int n = a.length;
            @SuppressWarnings("unchecked")
            AsyncSubscription<T>[] b = new AsyncSubscription[n + 1];
            System.arraycopy(a, 0, b, 0, n);
            b[n] = ps;

            if (subscribers.compareAndSet(a, b)) {
                return true;

            

Reported by PMD.

              
            AsyncSubscription<T>[] b;

            if (n == 1) {
                b = EMPTY;
            } else {
                b = new AsyncSubscription[n - 1];
                System.arraycopy(a, 0, b, 0, j);
                System.arraycopy(a, j + 1, b, j, n - j - 1);

            

Reported by PMD.

                          if (n == 1) {
                b = EMPTY;
            } else {
                b = new AsyncSubscription[n - 1];
                System.arraycopy(a, 0, b, 0, j);
                System.arraycopy(a, j + 1, b, j, n - j - 1);
            }
            if (subscribers.compareAndSet(a, b)) {
                return;

            

Reported by PMD.

               * @param <T> the upstream and downstream value type
 * @since 2.1.8
 */
/* public */final class RefCountProcessor<T> extends FlowableProcessor<T> implements Subscription {

    final FlowableProcessor<T> actual;

    final AtomicReference<Subscription> upstream;


            

Reported by PMD.

               */
/* public */final class RefCountProcessor<T> extends FlowableProcessor<T> implements Subscription {

    final FlowableProcessor<T> actual;

    final AtomicReference<Subscription> upstream;

    final AtomicReference<RefCountSubscriber<T>[]> subscribers;


            

Reported by PMD.

              
    final FlowableProcessor<T> actual;

    final AtomicReference<Subscription> upstream;

    final AtomicReference<RefCountSubscriber<T>[]> subscribers;

    @SuppressWarnings("rawtypes")
    static final RefCountSubscriber[] EMPTY = new RefCountSubscriber[0];

            

Reported by PMD.

              
    final AtomicReference<Subscription> upstream;

    final AtomicReference<RefCountSubscriber<T>[]> subscribers;

    @SuppressWarnings("rawtypes")
    static final RefCountSubscriber[] EMPTY = new RefCountSubscriber[0];

    @SuppressWarnings("rawtypes")

            

Reported by PMD.

              
    @Override
    public void request(long n) {
        upstream.get().request(n);
    }

    boolean add(RefCountSubscriber<T> rcs) {
        for (;;) {
            RefCountSubscriber<T>[] a = subscribers.get();

            

Reported by PMD.

                          }
            int n = a.length;
            @SuppressWarnings("unchecked")
            RefCountSubscriber<T>[] b = new RefCountSubscriber[n + 1];
            System.arraycopy(a, 0, b, 0, n);
            b[n] = rcs;
            if (subscribers.compareAndSet(a, b)) {
                return true;
            }

            

Reported by PMD.

                          }

            RefCountSubscriber<T>[] b;
            if (n == 1) {
                b = TERMINATED;
            } else {
                b = new RefCountSubscriber[n - 1];
                System.arraycopy(a, 0, b, 0, j);
                System.arraycopy(a, j + 1, b, j, n - j - 1);

            

Reported by PMD.

                          if (n == 1) {
                b = TERMINATED;
            } else {
                b = new RefCountSubscriber[n - 1];
                System.arraycopy(a, 0, b, 0, j);
                System.arraycopy(a, j + 1, b, j, n - j - 1);
            }
            if (subscribers.compareAndSet(a, b)) {
                if (b == TERMINATED) {

            

Reported by PMD.

              
        private static final long serialVersionUID = -4317488092687530631L;

        final Subscriber<? super T> downstream;

        final RefCountProcessor<T> parent;

        Subscription upstream;


            

Reported by PMD.

              
        final Subscriber<? super T> downstream;

        final RefCountProcessor<T> parent;

        Subscription upstream;

        RefCountSubscriber(Subscriber<? super T> actual, RefCountProcessor<T> parent) {
            this.downstream = actual;

            

Reported by PMD.

                  }

    @Override
    public void onNext(T t) {
        if (!checkSubscriptionOnce) {
            checkSubscriptionOnce = true;
            if (upstream.get() == null) {
                errors.add(new IllegalStateException("onSubscribe not called in proper order"));
            }

            

Reported by PMD.

               */
public class TestObserverEx<T>
extends BaseTestConsumerEx<T, TestObserverEx<T>>
implements Observer<T>, Disposable, MaybeObserver<T>, SingleObserver<T>, CompletableObserver {
    /** The actual observer to forward events to. */
    private final Observer<? super T> downstream;

    /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

            

Reported by PMD.

              extends BaseTestConsumerEx<T, TestObserverEx<T>>
implements Observer<T>, Disposable, MaybeObserver<T>, SingleObserver<T>, CompletableObserver {
    /** The actual observer to forward events to. */
    private final Observer<? super T> downstream;

    /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    private QueueDisposable<T> qd;

            

Reported by PMD.

                  private final Observer<? super T> downstream;

    /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    private QueueDisposable<T> qd;

    /**
     * Constructs a non-forwarding TestObserver.

            

Reported by PMD.

                  /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    private QueueDisposable<T> qd;

    /**
     * Constructs a non-forwarding TestObserver.
     */
    public TestObserverEx() {

            

Reported by PMD.

                      }

        if (initialFusionMode != 0) {
            if (d instanceof QueueDisposable) {
                qd = (QueueDisposable<T>)d;

                int m = qd.requestFusion(initialFusionMode);
                establishedFusionMode = m;


            

Reported by PMD.

                              int m = qd.requestFusion(initialFusionMode);
                establishedFusionMode = m;

                if (m == QueueFuseable.SYNC) {
                    checkSubscriptionOnce = true;
                    lastThread = Thread.currentThread();
                    try {
                        T t;
                        while ((t = qd.poll()) != null) {

            

Reported by PMD.

                                  lastThread = Thread.currentThread();
                    try {
                        T t;
                        while ((t = qd.poll()) != null) {
                            values.add(t);
                        }
                        completions++;

                        upstream.lazySet(DisposableHelper.DISPOSED);

            

Reported by PMD.

                                      completions++;

                        upstream.lazySet(DisposableHelper.DISPOSED);
                    } catch (Throwable ex) {
                        errors.add(ex);
                    }
                    return;
                }
            }

            

Reported by PMD.

              
        if (establishedFusionMode == QueueFuseable.ASYNC) {
            try {
                while ((t = qd.poll()) != null) {
                    values.add(t);
                }
            } catch (Throwable ex) {
                errors.add(ex);
                qd.dispose();

            

Reported by PMD.

                      .blockingForEach(new Consumer<GroupedFlowable<Object, Event>>() {
            @Override
            public void accept(GroupedFlowable<Object, Event> v) {
                System.out.println(v);
                v.take(1).subscribe();  // FIXME groups need consumption to a certain degree to cancel upstream
            }
        });

        System.out.println("**** finished");

            

Reported by PMD.

                          }
        });

        System.out.println("**** finished");
    }

    @Test
    public void takeUnsubscribesOnFlatMapOfGroupBy() {
        Flowable.merge(

            

Reported by PMD.

                      .blockingForEach(new Consumer<Object>() {
            @Override
            public void accept(Object v) {
                System.out.println(v);
            }
        });

        System.out.println("**** finished");
    }

            

Reported by PMD.

                          }
        });

        System.out.println("**** finished");
    }

    @Test
    public void groupsCompleteAsSoonAsMainCompletes() {
        TestSubscriber<Integer> ts = TestSubscriber.create();

            

Reported by PMD.

              public class FlowableGroupByTests extends RxJavaTest {

    @Test
    public void takeUnsubscribesOnGroupBy() {
        Flowable.merge(
            FlowableEventStream.getEventStream("HTTP-ClusterA", 50),
            FlowableEventStream.getEventStream("HTTP-ClusterB", 20)
        )
        // group by type (2 clusters)

            

Reported by PMD.

                          @Override
            public void accept(GroupedFlowable<Object, Event> v) {
                System.out.println(v);
                v.take(1).subscribe();  // FIXME groups need consumption to a certain degree to cancel upstream
            }
        });

        System.out.println("**** finished");
    }

            

Reported by PMD.

                  }

    @Test
    public void takeUnsubscribesOnFlatMapOfGroupBy() {
        Flowable.merge(
            FlowableEventStream.getEventStream("HTTP-ClusterA", 50),
            FlowableEventStream.getEventStream("HTTP-ClusterB", 20)
        )
        // group by type (2 clusters)

            

Reported by PMD.

                              return g.map(new Function<Event, Object>() {
                    @Override
                    public Object apply(Event event) {
                        return event.instanceId + " - " + event.values.get("count200");
                    }
                });
            }
        })
        .take(20)

            

Reported by PMD.

                  }

    @Test
    public void groupsCompleteAsSoonAsMainCompletes() {
        TestSubscriber<Integer> ts = TestSubscriber.create();

        Flowable.range(0, 20)
        .groupBy(new Function<Integer, Integer>() {
            @Override

            

Reported by PMD.

              
        // Behavior change: this now counts as group abandonment because concatMap
        // doesn't subscribe to the 2nd+ emitted groups immediately
        ts.assertValues(
                0, 5, 10, 15, // First group is okay
                // any other group gets abandoned so we get 16 one-element group
                1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19
                );
        ts.assertComplete();

            

Reported by PMD.

               */
public final class Burst<T> extends Flowable<T> {

    final List<T> items;
    final Throwable error;

    Burst(Throwable error, List<T> items) {
        if (items.isEmpty()) {
            throw new IllegalArgumentException("items cannot be empty");

            

Reported by PMD.

               */
public final class Burst<T> extends Flowable<T> {

    final List<T> items;
    final Throwable error;

    Burst(Throwable error, List<T> items) {
        if (items.isEmpty()) {
            throw new IllegalArgumentException("items cannot be empty");

            

Reported by PMD.

              public final class Burst<T> extends Flowable<T> {

    final List<T> items;
    final Throwable error;

    Burst(Throwable error, List<T> items) {
        if (items.isEmpty()) {
            throw new IllegalArgumentException("items cannot be empty");
        }

            

Reported by PMD.

                  }

    final class BurstSubscription implements Subscription {
        private final Subscriber<? super T> subscriber;
        final Queue<T> q = new ConcurrentLinkedQueue<>(items);
        final AtomicLong requested = new AtomicLong();
        volatile boolean cancelled;

        BurstSubscription(Subscriber<? super T> subscriber) {

            

Reported by PMD.

              
    final class BurstSubscription implements Subscription {
        private final Subscriber<? super T> subscriber;
        final Queue<T> q = new ConcurrentLinkedQueue<>(items);
        final AtomicLong requested = new AtomicLong();
        volatile boolean cancelled;

        BurstSubscription(Subscriber<? super T> subscriber) {
            this.subscriber = subscriber;

            

Reported by PMD.

                  final class BurstSubscription implements Subscription {
        private final Subscriber<? super T> subscriber;
        final Queue<T> q = new ConcurrentLinkedQueue<>(items);
        final AtomicLong requested = new AtomicLong();
        volatile boolean cancelled;

        BurstSubscription(Subscriber<? super T> subscriber) {
            this.subscriber = subscriber;
        }

            

Reported by PMD.

                      private final Subscriber<? super T> subscriber;
        final Queue<T> q = new ConcurrentLinkedQueue<>(items);
        final AtomicLong requested = new AtomicLong();
        volatile boolean cancelled;

        BurstSubscription(Subscriber<? super T> subscriber) {
            this.subscriber = subscriber;
        }


            

Reported by PMD.

                          if (SubscriptionHelper.validate(n)) {
                // just for testing, don't care about perf
                // so no attempt made to reduce volatile reads
                if (BackpressureHelper.add(requested, n) == 0) {
                    if (q.isEmpty()) {
                        return;
                    }
                    while (!q.isEmpty() && requested.get() > 0) {
                        T item = q.poll();

            

Reported by PMD.

                              // just for testing, don't care about perf
                // so no attempt made to reduce volatile reads
                if (BackpressureHelper.add(requested, n) == 0) {
                    if (q.isEmpty()) {
                        return;
                    }
                    while (!q.isEmpty() && requested.get() > 0) {
                        T item = q.poll();
                        requested.decrementAndGet();

            

Reported by PMD.

                                      subscriber.onNext(item);
                    }
                    if (q.isEmpty()) {
                        if (error != null) {
                            subscriber.onError(error);
                        } else {
                            subscriber.onComplete();
                        }
                    }

            

Reported by PMD.

              public class MaybeFromPubisherTest extends RxJavaTest {

    @Test
    public void empty() {
        Maybe.fromPublisher(Flowable.empty().hide())
            .test()
            .assertResult();
    }


            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromPublisher(Flowable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromPublisher(Flowable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromPublisher(Flowable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void just() {
        Maybe.fromPublisher(Flowable.just(1).hide())
            .test()
            .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromPublisher(Flowable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromPublisher(Flowable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromPublisher(Flowable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void range() {
        Maybe.fromPublisher(Flowable.range(1, 5).hide())
            .test()
            .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void range() {
        Maybe.fromPublisher(Flowable.range(1, 5).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              public class MaybeFromObservableTest extends RxJavaTest {

    @Test
    public void empty() {
        Maybe.fromObservable(Observable.empty().hide())
            .test()
            .assertResult();
    }


            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromObservable(Observable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromObservable(Observable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void empty() {
        Maybe.fromObservable(Observable.empty().hide())
            .test()
            .assertResult();
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void just() {
        Maybe.fromObservable(Observable.just(1).hide())
            .test()
            .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromObservable(Observable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromObservable(Observable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void just() {
        Maybe.fromObservable(Observable.just(1).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void range() {
        Maybe.fromObservable(Observable.range(1, 5).hide())
            .test()
            .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void range() {
        Maybe.fromObservable(Observable.range(1, 5).hide())
            .test()
            .assertResult(1);
    }

    @Test

            

Reported by PMD.

              public class MaybeSafeSubscribeTest {

    @Test
    public void normalSuccess() throws Throwable {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);

            Maybe.just(1)

            

Reported by PMD.

                  @Test
    public void normalSuccess() throws Throwable {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);

            Maybe.just(1)
            .safeSubscribe(consumer);


            

Reported by PMD.

                          order.verify(consumer).onSuccess(1);
            order.verifyNoMoreInteractions();

            assertTrue("" + errors, errors.isEmpty());
        });
    }

    @Test
    public void normalError() throws Throwable  {

            

Reported by PMD.

                  }

    @Test
    public void normalError() throws Throwable  {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);

            Maybe.<Integer>error(new TestException())

            

Reported by PMD.

                          order.verify(consumer).onError(any(TestException.class));
            order.verifyNoMoreInteractions();

            assertTrue("" + errors, errors.isEmpty());
        });
    }

    @Test
    public void normalEmpty() throws Throwable  {

            

Reported by PMD.

                  }

    @Test
    public void normalEmpty() throws Throwable  {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);

            Maybe.<Integer>empty()

            

Reported by PMD.

                  }

    @Test
    public void onSubscribeCrash() throws Throwable {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);
            doThrow(new TestException()).when(consumer).onSubscribe(any());


            

Reported by PMD.

                          order.verify(consumer).onSubscribe(any(Disposable.class));
            order.verifyNoMoreInteractions();

            assertTrue(d.isDisposed());

            TestHelper.assertUndeliverable(errors, 0, TestException.class);
            TestHelper.assertUndeliverable(errors, 1, IOException.class);
        });
    }

            

Reported by PMD.

                  }

    @Test
    public void onSuccessCrash() throws Throwable {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);
            doThrow(new TestException()).when(consumer).onSuccess(any());


            

Reported by PMD.

                  }

    @Test
    public void onErrorCrash() throws Throwable  {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            MaybeObserver<Integer> consumer = mock(MaybeObserver.class);
            doThrow(new TestException()).when(consumer).onError(any());


            

Reported by PMD.

              public class CompletableMergeIterableTest extends RxJavaTest {

    @Test
    public void errorRace() {
        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
            List<Throwable> errors = TestHelper.trackPluginErrors();
            try {
                final PublishSubject<Integer> ps1 = PublishSubject.create();
                final PublishSubject<Integer> ps2 = PublishSubject.create();

            

Reported by PMD.

                              final PublishSubject<Integer> ps1 = PublishSubject.create();
                final PublishSubject<Integer> ps2 = PublishSubject.create();

                TestObserver<Void> to = Completable.merge(
                        Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test();

                final TestException ex = new TestException();

                Runnable r1 = new Runnable() {

            

Reported by PMD.

                              final PublishSubject<Integer> ps2 = PublishSubject.create();

                TestObserver<Void> to = Completable.merge(
                        Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test();

                final TestException ex = new TestException();

                Runnable r1 = new Runnable() {
                    @Override

            

Reported by PMD.

                              final PublishSubject<Integer> ps2 = PublishSubject.create();

                TestObserver<Void> to = Completable.merge(
                        Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test();

                final TestException ex = new TestException();

                Runnable r1 = new Runnable() {
                    @Override

            

Reported by PMD.

                              TestObserver<Void> to = Completable.merge(
                        Arrays.asList(ps1.ignoreElements(), ps2.ignoreElements())).test();

                final TestException ex = new TestException();

                Runnable r1 = new Runnable() {
                    @Override
                    public void run() {
                        ps1.onError(ex);

            

Reported by PMD.

              
                final TestException ex = new TestException();

                Runnable r1 = new Runnable() {
                    @Override
                    public void run() {
                        ps1.onError(ex);
                    }
                };

            

Reported by PMD.

                                      ps1.onError(ex);
                    }
                };
                Runnable r2 = new Runnable() {
                    @Override
                    public void run() {
                        ps2.onError(ex);
                    }
                };

            

Reported by PMD.

              
                TestHelper.race(r1, r2);

                to.assertFailure(TestException.class);

                if (!errors.isEmpty()) {
                    TestHelper.assertUndeliverable(errors, 0, TestException.class);
                }
            } finally {

            

Reported by PMD.

              
                to.assertFailure(TestException.class);

                if (!errors.isEmpty()) {
                    TestHelper.assertUndeliverable(errors, 0, TestException.class);
                }
            } finally {
                RxJavaPlugins.reset();
            }

            

Reported by PMD.

                  }

    @Test
    public void cancelAfterHasNext() {
        final TestObserver<Void> to = new TestObserver<>();

        Completable.merge(new Iterable<Completable>() {
            @Override
            public Iterator<Completable> iterator() {

            

Reported by PMD.