public void concatMapValueErrorThrown() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override public SingleSource<Integer> apply(final Integer integer) throws Exception {
                throw new RuntimeException("something went terribly wrong!");
            }
        })
            .to(TestHelper.<Integer>testConsumer())
            .assertNoValues()
            .assertError(RuntimeException.class)

            

Reported by PMD.

              public class SingleConcatMapTest extends RxJavaTest {

    @Test
    public void concatMapValue() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override public SingleSource<Integer> apply(final Integer integer) throws Exception {
                if (integer == 1) {
                    return Single.just(2);
                }

            

Reported by PMD.

                  public void concatMapValue() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override public SingleSource<Integer> apply(final Integer integer) throws Exception {
                if (integer == 1) {
                    return Single.just(2);
                }

                return Single.just(1);
            }

            

Reported by PMD.

                  }

    @Test
    public void concatMapValueDifferentType() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<String>>() {
            @Override public SingleSource<String> apply(final Integer integer) throws Exception {
                if (integer == 1) {
                    return Single.just("2");
                }

            

Reported by PMD.

                  public void concatMapValueDifferentType() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<String>>() {
            @Override public SingleSource<String> apply(final Integer integer) throws Exception {
                if (integer == 1) {
                    return Single.just("2");
                }

                return Single.just("1");
            }

            

Reported by PMD.

                  }

    @Test
    public void concatMapValueNull() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override public SingleSource<Integer> apply(final Integer integer) throws Exception {
                return null;
            }
        })

            

Reported by PMD.

                  }

    @Test
    public void concatMapValueErrorThrown() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override public SingleSource<Integer> apply(final Integer integer) throws Exception {
                throw new RuntimeException("something went terribly wrong!");
            }
        })

            

Reported by PMD.

                  }

    @Test
    public void concatMapError() {
        RuntimeException exception = new RuntimeException("test");

        Single.error(exception).concatMap(new Function<Object, SingleSource<Object>>() {
            @Override public SingleSource<Object> apply(final Object integer) throws Exception {
                return Single.just(new Object());

            

Reported by PMD.

                  }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override
            public SingleSource<Integer> apply(Integer v) throws Exception {
                return Single.just(2);
            }

            

Reported by PMD.

                  }

    @Test
    public void mappedSingleOnError() {
        Single.just(1).concatMap(new Function<Integer, SingleSource<Integer>>() {
            @Override
            public SingleSource<Integer> apply(Integer v) throws Exception {
                return Single.error(new TestException());
            }

            

Reported by PMD.

               */
public final class MaybeDelay<T> extends AbstractMaybeWithUpstream<T, T> {

    final long delay;

    final TimeUnit unit;

    final Scheduler scheduler;


            

Reported by PMD.

              
    final long delay;

    final TimeUnit unit;

    final Scheduler scheduler;

    final boolean delayError;


            

Reported by PMD.

              
    final TimeUnit unit;

    final Scheduler scheduler;

    final boolean delayError;

    public MaybeDelay(MaybeSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
        super(source);

            

Reported by PMD.

              
    final Scheduler scheduler;

    final boolean delayError;

    public MaybeDelay(MaybeSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
        super(source);
        this.delay = delay;
        this.unit = unit;

            

Reported by PMD.

              
        private static final long serialVersionUID = 5566860102500855068L;

        final MaybeObserver<? super T> downstream;

        final long delay;

        final TimeUnit unit;


            

Reported by PMD.

              
        final MaybeObserver<? super T> downstream;

        final long delay;

        final TimeUnit unit;

        final Scheduler scheduler;


            

Reported by PMD.

              
        final long delay;

        final TimeUnit unit;

        final Scheduler scheduler;

        final boolean delayError;


            

Reported by PMD.

              
        final TimeUnit unit;

        final Scheduler scheduler;

        final boolean delayError;

        T value;


            

Reported by PMD.

              
        final Scheduler scheduler;

        final boolean delayError;

        T value;

        Throwable error;


            

Reported by PMD.

              
        final boolean delayError;

        T value;

        Throwable error;

        DelayMaybeObserver(MaybeObserver<? super T> actual, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
            this.downstream = actual;

            

Reported by PMD.

              import io.reactivex.rxjava3.internal.util.*;

public final class FlowableSkipUntil<T, U> extends AbstractFlowableWithUpstream<T, T> {
    final Publisher<U> other;
    public FlowableSkipUntil(Flowable<T> source, Publisher<U> other) {
        super(source);
        this.other = other;
    }


            

Reported by PMD.

                  implements ConditionalSubscriber<T>, Subscription {
        private static final long serialVersionUID = -6270983465606289181L;

        final Subscriber<? super T> downstream;

        final AtomicReference<Subscription> upstream;

        final AtomicLong requested;


            

Reported by PMD.

              
        final Subscriber<? super T> downstream;

        final AtomicReference<Subscription> upstream;

        final AtomicLong requested;

        final OtherSubscriber other;


            

Reported by PMD.

              
        final AtomicReference<Subscription> upstream;

        final AtomicLong requested;

        final OtherSubscriber other;

        final AtomicThrowable error;


            

Reported by PMD.

              
        final AtomicLong requested;

        final OtherSubscriber other;

        final AtomicThrowable error;

        volatile boolean gate;


            

Reported by PMD.

              
        final OtherSubscriber other;

        final AtomicThrowable error;

        volatile boolean gate;

        SkipUntilMainSubscriber(Subscriber<? super T> downstream) {
            this.downstream = downstream;

            

Reported by PMD.

              
        final AtomicThrowable error;

        volatile boolean gate;

        SkipUntilMainSubscriber(Subscriber<? super T> downstream) {
            this.downstream = downstream;
            this.upstream = new AtomicReference<>();
            this.requested = new AtomicLong();

            

Reported by PMD.

                      @Override
        public void onNext(T t) {
            if (!tryOnNext(t)) {
                upstream.get().request(1);
            }
        }

        @Override
        public boolean tryOnNext(T t) {

            

Reported by PMD.

                          @Override
            public void onNext(Object t) {
                gate = true;
                get().cancel();
            }

            @Override
            public void onError(Throwable t) {
                SubscriptionHelper.cancel(upstream);

            

Reported by PMD.

              
import java.util.concurrent.atomic.*;

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.fuseable.ConditionalSubscriber;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
import io.reactivex.rxjava3.internal.util.*;

            

Reported by PMD.

              import java.util.Objects;

public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }

    @Override

            

Reported by PMD.

              
public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }

    @Override
    public void subscribeActual(Observer<? super T> observer) {

            

Reported by PMD.

              
    static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {

        final Observer<? super T> downstream;

        final T[] array;

        int index;


            

Reported by PMD.

              
        final Observer<? super T> downstream;

        final T[] array;

        int index;

        boolean fusionMode;


            

Reported by PMD.

              
        final T[] array;

        int index;

        boolean fusionMode;

        volatile boolean disposed;


            

Reported by PMD.

              
        int index;

        boolean fusionMode;

        volatile boolean disposed;

        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.downstream = actual;

            

Reported by PMD.

              
        boolean fusionMode;

        volatile boolean disposed;

        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.downstream = actual;
            this.array = array;
        }

            

Reported by PMD.

              
        volatile boolean disposed;

        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.downstream = actual;
            this.array = array;
        }

        @Override

            

Reported by PMD.

                          for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                if (value == null) {
                    downstream.onError(new NullPointerException("The element at index " + i + " is null"));
                    return;
                }
                downstream.onNext(value);
            }
            if (!isDisposed()) {

            

Reported by PMD.

              package io.reactivex.rxjava3.internal.operators.observable;

import io.reactivex.rxjava3.annotations.Nullable;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.observers.BasicQueueDisposable;

import java.util.Objects;

public final class ObservableFromArray<T> extends Observable<T> {

            

Reported by PMD.

               */
public final class ListCompositeDisposable implements Disposable, DisposableContainer {

    List<Disposable> resources;

    volatile boolean disposed;

    public ListCompositeDisposable() {
    }

            

Reported by PMD.

              
    List<Disposable> resources;

    volatile boolean disposed;

    public ListCompositeDisposable() {
    }

    public ListCompositeDisposable(Disposable... resources) {

            

Reported by PMD.

                          }
            disposed = true;
            set = resources;
            resources = null;
        }

        dispose(set);
    }


            

Reported by PMD.

                          synchronized (this) {
                if (!disposed) {
                    List<Disposable> set = resources;
                    if (set == null) {
                        set = new LinkedList<>();
                        resources = set;
                    }
                    set.add(d);
                    return true;

            

Reported by PMD.

                          synchronized (this) {
                if (!disposed) {
                    List<Disposable> set = resources;
                    if (set == null) {
                        set = new LinkedList<>();
                        resources = set;
                    }
                    for (Disposable d : ds) {
                        Objects.requireNonNull(d, "d is null");

            

Reported by PMD.

                          }

            List<Disposable> set = resources;
            if (set == null || !set.remove(d)) {
                return false;
            }
        }
        return true;
    }

            

Reported by PMD.

                          }

            set = resources;
            resources = null;
        }

        dispose(set);
    }


            

Reported by PMD.

                      for (Disposable o : set) {
            try {
                o.dispose();
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (errors == null) {
                    errors = new ArrayList<>();
                }
                errors.add(ex);

            

Reported by PMD.

                          } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (errors == null) {
                    errors = new ArrayList<>();
                }
                errors.add(ex);
            }
        }
        if (errors != null) {

            

Reported by PMD.

                          }
        }
        if (errors != null) {
            if (errors.size() == 1) {
                throw ExceptionHelper.wrapOrThrow(errors.get(0));
            }
            throw new CompositeException(errors);
        }
    }

            

Reported by PMD.

              import io.reactivex.rxjava3.observers.SerializedObserver;

public final class ObservableSkipUntil<T, U> extends AbstractObservableWithUpstream<T, T> {
    final ObservableSource<U> other;
    public ObservableSkipUntil(ObservableSource<T> source, ObservableSource<U> other) {
        super(source);
        this.other = other;
    }


            

Reported by PMD.

              
    static final class SkipUntilObserver<T> implements Observer<T> {

        final Observer<? super T> downstream;
        final ArrayCompositeDisposable frc;

        Disposable upstream;

        volatile boolean notSkipping;

            

Reported by PMD.

                  static final class SkipUntilObserver<T> implements Observer<T> {

        final Observer<? super T> downstream;
        final ArrayCompositeDisposable frc;

        Disposable upstream;

        volatile boolean notSkipping;
        boolean notSkippingLocal;

            

Reported by PMD.

                      final Observer<? super T> downstream;
        final ArrayCompositeDisposable frc;

        Disposable upstream;

        volatile boolean notSkipping;
        boolean notSkippingLocal;

        SkipUntilObserver(Observer<? super T> actual, ArrayCompositeDisposable frc) {

            

Reported by PMD.

              
        Disposable upstream;

        volatile boolean notSkipping;
        boolean notSkippingLocal;

        SkipUntilObserver(Observer<? super T> actual, ArrayCompositeDisposable frc) {
            this.downstream = actual;
            this.frc = frc;

            

Reported by PMD.

                      Disposable upstream;

        volatile boolean notSkipping;
        boolean notSkippingLocal;

        SkipUntilObserver(Observer<? super T> actual, ArrayCompositeDisposable frc) {
            this.downstream = actual;
            this.frc = frc;
        }

            

Reported by PMD.

                  }

    final class SkipUntil implements Observer<U> {
        final ArrayCompositeDisposable frc;
        final SkipUntilObserver<T> sus;
        final SerializedObserver<T> serial;
        Disposable upstream;

        SkipUntil(ArrayCompositeDisposable frc, SkipUntilObserver<T> sus, SerializedObserver<T> serial) {

            

Reported by PMD.

              
    final class SkipUntil implements Observer<U> {
        final ArrayCompositeDisposable frc;
        final SkipUntilObserver<T> sus;
        final SerializedObserver<T> serial;
        Disposable upstream;

        SkipUntil(ArrayCompositeDisposable frc, SkipUntilObserver<T> sus, SerializedObserver<T> serial) {
            this.frc = frc;

            

Reported by PMD.

                  final class SkipUntil implements Observer<U> {
        final ArrayCompositeDisposable frc;
        final SkipUntilObserver<T> sus;
        final SerializedObserver<T> serial;
        Disposable upstream;

        SkipUntil(ArrayCompositeDisposable frc, SkipUntilObserver<T> sus, SerializedObserver<T> serial) {
            this.frc = frc;
            this.sus = sus;

            

Reported by PMD.

                      final ArrayCompositeDisposable frc;
        final SkipUntilObserver<T> sus;
        final SerializedObserver<T> serial;
        Disposable upstream;

        SkipUntil(ArrayCompositeDisposable frc, SkipUntilObserver<T> sus, SerializedObserver<T> serial) {
            this.frc = frc;
            this.sus = sus;
            this.serial = serial;

            

Reported by PMD.

              import io.reactivex.rxjava3.internal.disposables.SequentialDisposable;

public final class ObservableRetryPredicate<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super Throwable> predicate;
    final long count;
    public ObservableRetryPredicate(Observable<T> source,
            long count,
            Predicate<? super Throwable> predicate) {
        super(source);

            

Reported by PMD.

              
public final class ObservableRetryPredicate<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super Throwable> predicate;
    final long count;
    public ObservableRetryPredicate(Observable<T> source,
            long count,
            Predicate<? super Throwable> predicate) {
        super(source);
        this.predicate = predicate;

            

Reported by PMD.

              
        private static final long serialVersionUID = -7098360935104053232L;

        final Observer<? super T> downstream;
        final SequentialDisposable upstream;
        final ObservableSource<? extends T> source;
        final Predicate<? super Throwable> predicate;
        long remaining;
        RepeatObserver(Observer<? super T> actual, long count,

            

Reported by PMD.

                      private static final long serialVersionUID = -7098360935104053232L;

        final Observer<? super T> downstream;
        final SequentialDisposable upstream;
        final ObservableSource<? extends T> source;
        final Predicate<? super Throwable> predicate;
        long remaining;
        RepeatObserver(Observer<? super T> actual, long count,
                Predicate<? super Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source) {

            

Reported by PMD.

              
        final Observer<? super T> downstream;
        final SequentialDisposable upstream;
        final ObservableSource<? extends T> source;
        final Predicate<? super Throwable> predicate;
        long remaining;
        RepeatObserver(Observer<? super T> actual, long count,
                Predicate<? super Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source) {
            this.downstream = actual;

            

Reported by PMD.

                      final Observer<? super T> downstream;
        final SequentialDisposable upstream;
        final ObservableSource<? extends T> source;
        final Predicate<? super Throwable> predicate;
        long remaining;
        RepeatObserver(Observer<? super T> actual, long count,
                Predicate<? super Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source) {
            this.downstream = actual;
            this.upstream = sa;

            

Reported by PMD.

                      final SequentialDisposable upstream;
        final ObservableSource<? extends T> source;
        final Predicate<? super Throwable> predicate;
        long remaining;
        RepeatObserver(Observer<? super T> actual, long count,
                Predicate<? super Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source) {
            this.downstream = actual;
            this.upstream = sa;
            this.source = source;

            

Reported by PMD.

                              boolean b;
                try {
                    b = predicate.test(t);
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    downstream.onError(new CompositeException(t, e));
                    return;
                }
                if (!b) {

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicInteger;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Predicate;
import io.reactivex.rxjava3.internal.disposables.SequentialDisposable;


            

Reported by PMD.

              
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Predicate;
import io.reactivex.rxjava3.internal.disposables.SequentialDisposable;

public final class ObservableRetryPredicate<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super Throwable> predicate;

            

Reported by PMD.

               */
public final class FlowableMergeWithCompletable<T> extends AbstractFlowableWithUpstream<T, T> {

    final CompletableSource other;

    public FlowableMergeWithCompletable(Flowable<T> source, CompletableSource other) {
        super(source);
        this.other = other;
    }

            

Reported by PMD.

              
        private static final long serialVersionUID = -4592979584110982903L;

        final Subscriber<? super T> downstream;

        final AtomicReference<Subscription> mainSubscription;

        final OtherObserver otherObserver;


            

Reported by PMD.

              
        final Subscriber<? super T> downstream;

        final AtomicReference<Subscription> mainSubscription;

        final OtherObserver otherObserver;

        final AtomicThrowable errors;


            

Reported by PMD.

              
        final AtomicReference<Subscription> mainSubscription;

        final OtherObserver otherObserver;

        final AtomicThrowable errors;

        final AtomicLong requested;


            

Reported by PMD.

              
        final OtherObserver otherObserver;

        final AtomicThrowable errors;

        final AtomicLong requested;

        volatile boolean mainDone;


            

Reported by PMD.

              
        final AtomicThrowable errors;

        final AtomicLong requested;

        volatile boolean mainDone;

        volatile boolean otherDone;


            

Reported by PMD.

              
        final AtomicLong requested;

        volatile boolean mainDone;

        volatile boolean otherDone;

        MergeWithSubscriber(Subscriber<? super T> downstream) {
            this.downstream = downstream;

            

Reported by PMD.

              
        volatile boolean mainDone;

        volatile boolean otherDone;

        MergeWithSubscriber(Subscriber<? super T> downstream) {
            this.downstream = downstream;
            this.mainSubscription = new AtomicReference<>();
            this.otherObserver = new OtherObserver(this);

            

Reported by PMD.

              
            private static final long serialVersionUID = -2935427570954647017L;

            final MergeWithSubscriber<?> parent;

            OtherObserver(MergeWithSubscriber<?> parent) {
                this.parent = parent;
            }


            

Reported by PMD.

              
import java.util.concurrent.atomic.*;

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;

            

Reported by PMD.

              
    private static final long serialVersionUID = 22876611072430776L;

    final InnerQueuedSubscriberSupport<T> parent;

    final int prefetch;

    final int limit;


            

Reported by PMD.

              
    final InnerQueuedSubscriberSupport<T> parent;

    final int prefetch;

    final int limit;

    volatile SimpleQueue<T> queue;


            

Reported by PMD.

              
    final int prefetch;

    final int limit;

    volatile SimpleQueue<T> queue;

    volatile boolean done;


            

Reported by PMD.

              
    final int limit;

    volatile SimpleQueue<T> queue;

    volatile boolean done;

    long produced;


            

Reported by PMD.

              
    final int limit;

    volatile SimpleQueue<T> queue;

    volatile boolean done;

    long produced;


            

Reported by PMD.

              
    volatile boolean done;

    long produced;

    int fusionMode;

    public InnerQueuedSubscriber(InnerQueuedSubscriberSupport<T> parent, int prefetch) {
        this.parent = parent;

            

Reported by PMD.

              
    long produced;

    int fusionMode;

    public InnerQueuedSubscriber(InnerQueuedSubscriberSupport<T> parent, int prefetch) {
        this.parent = parent;
        this.prefetch = prefetch;
        this.limit = prefetch - (prefetch >> 2);

            

Reported by PMD.

                              @SuppressWarnings("unchecked")
                QueueSubscription<T> qs = (QueueSubscription<T>) s;

                int m = qs.requestFusion(QueueSubscription.ANY);
                if (m == QueueSubscription.SYNC) {
                    fusionMode = m;
                    queue = qs;
                    done = true;
                    parent.innerComplete(this);

            

Reported by PMD.

                              QueueSubscription<T> qs = (QueueSubscription<T>) s;

                int m = qs.requestFusion(QueueSubscription.ANY);
                if (m == QueueSubscription.SYNC) {
                    fusionMode = m;
                    queue = qs;
                    done = true;
                    parent.innerComplete(this);
                    return;

            

Reported by PMD.

                                  parent.innerComplete(this);
                    return;
                }
                if (m == QueueSubscription.ASYNC) {
                    fusionMode = m;
                    queue = qs;
                    QueueDrainHelper.request(s, prefetch);
                    return;
                }

            

Reported by PMD.

              import io.reactivex.rxjava3.plugins.RxJavaPlugins;

public final class FlowableElementAt<T> extends AbstractFlowableWithUpstream<T, T> {
    final long index;
    final T defaultValue;
    final boolean errorOnFewer;

    public FlowableElementAt(Flowable<T> source, long index, T defaultValue, boolean errorOnFewer) {
        super(source);

            

Reported by PMD.

              
public final class FlowableElementAt<T> extends AbstractFlowableWithUpstream<T, T> {
    final long index;
    final T defaultValue;
    final boolean errorOnFewer;

    public FlowableElementAt(Flowable<T> source, long index, T defaultValue, boolean errorOnFewer) {
        super(source);
        this.index = index;

            

Reported by PMD.

              public final class FlowableElementAt<T> extends AbstractFlowableWithUpstream<T, T> {
    final long index;
    final T defaultValue;
    final boolean errorOnFewer;

    public FlowableElementAt(Flowable<T> source, long index, T defaultValue, boolean errorOnFewer) {
        super(source);
        this.index = index;
        this.defaultValue = defaultValue;

            

Reported by PMD.

              
        private static final long serialVersionUID = 4066607327284737757L;

        final long index;
        final T defaultValue;
        final boolean errorOnFewer;

        Subscription upstream;


            

Reported by PMD.

                      private static final long serialVersionUID = 4066607327284737757L;

        final long index;
        final T defaultValue;
        final boolean errorOnFewer;

        Subscription upstream;

        long count;

            

Reported by PMD.

              
        final long index;
        final T defaultValue;
        final boolean errorOnFewer;

        Subscription upstream;

        long count;


            

Reported by PMD.

                      final T defaultValue;
        final boolean errorOnFewer;

        Subscription upstream;

        long count;

        boolean done;


            

Reported by PMD.

              
        Subscription upstream;

        long count;

        boolean done;

        ElementAtSubscriber(Subscriber<? super T> actual, long index, T defaultValue, boolean errorOnFewer) {
            super(actual);

            

Reported by PMD.

              
        long count;

        boolean done;

        ElementAtSubscriber(Subscriber<? super T> actual, long index, T defaultValue, boolean errorOnFewer) {
            super(actual);
            this.index = index;
            this.defaultValue = defaultValue;

            

Reported by PMD.

              
import java.util.NoSuchElementException;

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;


            

Reported by PMD.