*/
public final class FlowableCollectWithCollectorSingle<T, A, R> extends Single<R> implements FuseToFlowable<R> {

    final Flowable<T> source;

    final Collector<? super T, A, R> collector;

    public FlowableCollectWithCollectorSingle(Flowable<T> source, Collector<? super T, A, R> collector) {
        this.source = source;

            

Reported by PMD.

              
    final Flowable<T> source;

    final Collector<? super T, A, R> collector;

    public FlowableCollectWithCollectorSingle(Flowable<T> source, Collector<? super T, A, R> collector) {
        this.source = source;
        this.collector = collector;
    }

            

Reported by PMD.

                      Function<A, R> finisher;

        try {
            container = collector.supplier().get();
            accumulator = collector.accumulator();
            finisher = collector.finisher();
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);

            

Reported by PMD.

                          container = collector.supplier().get();
            accumulator = collector.accumulator();
            finisher = collector.finisher();
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);
            return;
        }


            

Reported by PMD.

              
    static final class CollectorSingleObserver<T, A, R> implements FlowableSubscriber<T>, Disposable {

        final SingleObserver<? super R> downstream;

        final BiConsumer<A, T> accumulator;

        final Function<A, R> finisher;


            

Reported by PMD.

              
        final SingleObserver<? super R> downstream;

        final BiConsumer<A, T> accumulator;

        final Function<A, R> finisher;

        Subscription upstream;


            

Reported by PMD.

              
        final BiConsumer<A, T> accumulator;

        final Function<A, R> finisher;

        Subscription upstream;

        boolean done;


            

Reported by PMD.

              
        final Function<A, R> finisher;

        Subscription upstream;

        boolean done;

        A container;


            

Reported by PMD.

              
        Subscription upstream;

        boolean done;

        A container;

        CollectorSingleObserver(SingleObserver<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
            this.downstream = downstream;

            

Reported by PMD.

              
        boolean done;

        A container;

        CollectorSingleObserver(SingleObserver<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
            this.downstream = downstream;
            this.container = container;
            this.accumulator = accumulator;

            

Reported by PMD.

               */
public final class SingleScheduler extends Scheduler {

    final ThreadFactory threadFactory;
    final AtomicReference<ScheduledExecutorService> executor = new AtomicReference<>();

    /** The name of the system property for setting the thread priority for this Scheduler. */
    private static final String KEY_SINGLE_PRIORITY = "rx3.single-priority";


            

Reported by PMD.

              public final class SingleScheduler extends Scheduler {

    final ThreadFactory threadFactory;
    final AtomicReference<ScheduledExecutorService> executor = new AtomicReference<>();

    /** The name of the system property for setting the thread priority for this Scheduler. */
    private static final String KEY_SINGLE_PRIORITY = "rx3.single-priority";

    private static final String THREAD_NAME_PREFIX = "RxSingleScheduler";

            

Reported by PMD.

              
    static final RxThreadFactory SINGLE_THREAD_FACTORY;

    static final ScheduledExecutorService SHUTDOWN;
    static {
        SHUTDOWN = Executors.newScheduledThreadPool(0);
        SHUTDOWN.shutdown();

        int priority = Math.max(Thread.MIN_PRIORITY, Math.min(Thread.MAX_PRIORITY,

            

Reported by PMD.

                      ScheduledExecutorService next = null;
        for (;;) {
            ScheduledExecutorService current = executor.get();
            if (current != SHUTDOWN) {
                if (next != null) {
                    next.shutdown();
                }
                return;
            }

            

Reported by PMD.

                  @Override
    public void shutdown() {
        ScheduledExecutorService current =  executor.getAndSet(SHUTDOWN);
        if (current != SHUTDOWN) {
            current.shutdownNow();
        }
    }

    @NonNull

            

Reported by PMD.

                      ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run), true);
        try {
            Future<?> f;
            if (delay <= 0L) {
                f = executor.get().submit(task);
            } else {
                f = executor.get().schedule(task, delay, unit);
            }
            task.setFuture(f);

            

Reported by PMD.

                      try {
            Future<?> f;
            if (delay <= 0L) {
                f = executor.get().submit(task);
            } else {
                f = executor.get().schedule(task, delay, unit);
            }
            task.setFuture(f);
            return task;

            

Reported by PMD.

                          if (delay <= 0L) {
                f = executor.get().submit(task);
            } else {
                f = executor.get().schedule(task, delay, unit);
            }
            task.setFuture(f);
            return task;
        } catch (RejectedExecutionException ex) {
            RxJavaPlugins.onError(ex);

            

Reported by PMD.

                  @Override
    public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) {
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        if (period <= 0L) {

            ScheduledExecutorService exec = executor.get();

            InstantPeriodicTask periodicWrapper = new InstantPeriodicTask(decoratedRun, exec);
            Future<?> f;

            

Reported by PMD.

                          InstantPeriodicTask periodicWrapper = new InstantPeriodicTask(decoratedRun, exec);
            Future<?> f;
            try {
                if (initialDelay <= 0L) {
                    f = exec.submit(periodicWrapper);
                } else {
                    f = exec.schedule(periodicWrapper, initialDelay, unit);
                }
                periodicWrapper.setFirst(f);

            

Reported by PMD.

              @OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@State(Scope.Thread)
public class EachTypeFlatMapPerf {
    @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;

            

Reported by PMD.

              @State(Scope.Thread)
public class EachTypeFlatMapPerf {
    @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;


            

Reported by PMD.

                  @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;

            

Reported by PMD.

                  @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;

            

Reported by PMD.

                  public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;

            

Reported by PMD.

                  public int times;

    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;

            

Reported by PMD.

              
    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;


            

Reported by PMD.

              
    Flowable<Integer> bpRange;
    Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;


            

Reported by PMD.

                  Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;

    Flowable<Integer> bpRangeMapRange;
    Observable<Integer> nbpRangeMapRange;

            

Reported by PMD.

                  Observable<Integer> nbpRange;
    Single<Integer> singleJust;

    Flowable<Integer> bpRangeMapJust;
    Observable<Integer> nbpRangeMapJust;
    Single<Integer> singleJustMapJust;

    Flowable<Integer> bpRangeMapRange;
    Observable<Integer> nbpRangeMapRange;

            

Reported by PMD.

               */
public final class ObservableCollectWithCollector<T, A, R> extends Observable<R> {

    final Observable<T> source;

    final Collector<? super T, A, R> collector;

    public ObservableCollectWithCollector(Observable<T> source, Collector<? super T, A, R> collector) {
        this.source = source;

            

Reported by PMD.

              
    final Observable<T> source;

    final Collector<? super T, A, R> collector;

    public ObservableCollectWithCollector(Observable<T> source, Collector<? super T, A, R> collector) {
        this.source = source;
        this.collector = collector;
    }

            

Reported by PMD.

                      Function<A, R> finisher;

        try {
            container = collector.supplier().get();
            accumulator = collector.accumulator();
            finisher = collector.finisher();
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);

            

Reported by PMD.

                          container = collector.supplier().get();
            accumulator = collector.accumulator();
            finisher = collector.finisher();
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);
            return;
        }


            

Reported by PMD.

              
        private static final long serialVersionUID = -229544830565448758L;

        final BiConsumer<A, T> accumulator;

        final Function<A, R> finisher;

        Disposable upstream;


            

Reported by PMD.

              
        final BiConsumer<A, T> accumulator;

        final Function<A, R> finisher;

        Disposable upstream;

        boolean done;


            

Reported by PMD.

              
        final Function<A, R> finisher;

        Disposable upstream;

        boolean done;

        A container;


            

Reported by PMD.

              
        Disposable upstream;

        boolean done;

        A container;

        CollectorObserver(Observer<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
            super(downstream);

            

Reported by PMD.

              
        boolean done;

        A container;

        CollectorObserver(Observer<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
            super(downstream);
            this.container = container;
            this.accumulator = accumulator;

            

Reported by PMD.

                          }
            try {
                accumulator.accept(container, t);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                upstream.dispose();
                onError(ex);
            }
        }

            

Reported by PMD.

                  }

    @Override
    public void onError(@NonNull Throwable t) {
        if (done) {
            RxJavaPlugins.onError(t);
            return;
        }
        done = true;

            

Reported by PMD.

               */
public final class SafeObserver<T> implements Observer<T>, Disposable {
    /** The actual Subscriber. */
    final Observer<? super T> downstream;
    /** The subscription. */
    Disposable upstream;
    /** Indicates a terminal state. */
    boolean done;


            

Reported by PMD.

                  /** The actual Subscriber. */
    final Observer<? super T> downstream;
    /** The subscription. */
    Disposable upstream;
    /** Indicates a terminal state. */
    boolean done;

    /**
     * Constructs a {@code SafeObserver} by wrapping the given actual {@link Observer}.

            

Reported by PMD.

                  /** The subscription. */
    Disposable upstream;
    /** Indicates a terminal state. */
    boolean done;

    /**
     * Constructs a {@code SafeObserver} by wrapping the given actual {@link Observer}.
     * @param downstream the actual {@code Observer} to wrap, not {@code null} (not validated)
     */

            

Reported by PMD.

                          this.upstream = d;
            try {
                downstream.onSubscribe(this);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                done = true;
                // can't call onError because the actual's state may be corrupt at this point
                try {
                    d.dispose();

            

Reported by PMD.

                              // can't call onError because the actual's state may be corrupt at this point
                try {
                    d.dispose();
                } catch (Throwable e1) {
                    Exceptions.throwIfFatal(e1);
                    RxJavaPlugins.onError(new CompositeException(e, e1));
                    return;
                }
                RxJavaPlugins.onError(e);

            

Reported by PMD.

                          Throwable ex = ExceptionHelper.createNullPointerException("onNext called with a null value.");
            try {
                upstream.dispose();
            } catch (Throwable e1) {
                Exceptions.throwIfFatal(e1);
                onError(new CompositeException(ex, e1));
                return;
            }
            onError(ex);

            

Reported by PMD.

              
        try {
            downstream.onNext(t);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            try {
                upstream.dispose();
            } catch (Throwable e1) {
                Exceptions.throwIfFatal(e1);

            

Reported by PMD.

                          Exceptions.throwIfFatal(e);
            try {
                upstream.dispose();
            } catch (Throwable e1) {
                Exceptions.throwIfFatal(e1);
                onError(new CompositeException(e, e1));
                return;
            }
            onError(e);

            

Reported by PMD.

              
        try {
            downstream.onSubscribe(EmptyDisposable.INSTANCE);
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because the actual's state may be corrupt at this point
            RxJavaPlugins.onError(new CompositeException(ex, e));
            return;
        }

            

Reported by PMD.

                  Consumer<Result> action = new Consumer<Result>() {
        @Override
        public void accept(Result t1) {
            System.out.println("Result: " + t1);
        }
    };

    Consumer<ExtendedResult> extendedAction = new Consumer<ExtendedResult>() {
        @Override

            

Reported by PMD.

                  Consumer<ExtendedResult> extendedAction = new Consumer<ExtendedResult>() {
        @Override
        public void accept(ExtendedResult t1) {
            System.out.println("Result: " + t1);
        }
    };
}

            

Reported by PMD.

                   * This won't compile if super/extends isn't done correctly on generics.
     */
    @Test
    public void covarianceOfCombineLatest() {
        Observable<HorrorMovie> horrors = Observable.just(new HorrorMovie());
        Observable<CoolRating> ratings = Observable.just(new CoolRating());

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);

            

Reported by PMD.

                      Observable<HorrorMovie> horrors = Observable.just(new HorrorMovie());
        Observable<CoolRating> ratings = Observable.just(new CoolRating());

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);


            

Reported by PMD.

                      Observable<HorrorMovie> horrors = Observable.just(new HorrorMovie());
        Observable<CoolRating> ratings = Observable.just(new CoolRating());

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);


            

Reported by PMD.

                      Observable<CoolRating> ratings = Observable.just(new CoolRating());

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);

            

Reported by PMD.

                      Observable<CoolRating> ratings = Observable.just(new CoolRating());

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);

            

Reported by PMD.

              
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);
    }

            

Reported by PMD.

              
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);
    }

            

Reported by PMD.

                      Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(extendedAction);
        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).blockingForEach(action);
        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).blockingForEach(action);

        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);
    }


            

Reported by PMD.

              public class SinglePostCompleteSubscriberTest extends RxJavaTest {

    @Test
    public void requestCompleteRace() {
        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
            final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

            

Reported by PMD.

                  @Test
    public void requestCompleteRace() {
        for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
            final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override

            

Reported by PMD.

                      for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
            final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override
                public void onNext(Integer t) {
                }

            

Reported by PMD.

                              }
            };

            spc.onSubscribe(new BooleanSubscription());

            Runnable r1 = new Runnable() {
                @Override
                public void run() {
                    spc.onComplete();

            

Reported by PMD.

              
            spc.onSubscribe(new BooleanSubscription());

            Runnable r1 = new Runnable() {
                @Override
                public void run() {
                    spc.onComplete();
                }
            };

            

Reported by PMD.

                              }
            };

            Runnable r2 = new Runnable() {
                @Override
                public void run() {
                    ts.request(1);
                }
            };

            

Reported by PMD.

                          final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override
                public void onNext(Integer t) {
                }


            

Reported by PMD.

                          final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override
                public void onNext(Integer t) {
                }


            

Reported by PMD.

                          final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override
                public void onNext(Integer t) {
                }


            

Reported by PMD.

                          final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);

            final SinglePostCompleteSubscriber<Integer, Integer> spc = new SinglePostCompleteSubscriber<Integer, Integer>(ts) {
                private static final long serialVersionUID = -2848918821531562637L;

                @Override
                public void onNext(Integer t) {
                }


            

Reported by PMD.

                                  }

                    if (!found) {
                        System.out.printf(" at %s.%s.method(%s.java:%s)%n%n", packageName, clazzName, clazzName, i + 1);
                    }
                }
            }
        }
    }

            

Reported by PMD.

                      throw new IllegalArgumentException("No instances!");
    }

    public static void main(String[] args) throws Exception {
        for (Class<?> clazz : CLASSES) {
            String clazzName = clazz.getSimpleName();
            String packageName = clazz.getPackage().getName();
            File f = TestHelper.findSource(clazzName, packageName);


            

Reported by PMD.

                  public static void main(String[] args) throws Exception {
        for (Class<?> clazz : CLASSES) {
            String clazzName = clazz.getSimpleName();
            String packageName = clazz.getPackage().getName();
            File f = TestHelper.findSource(clazzName, packageName);

            List<String> lines = Files.readAllLines(f.toPath());

            for (int i = 1; i < lines.size(); i++) {

            

Reported by PMD.

                          String packageName = clazz.getPackage().getName();
            File f = TestHelper.findSource(clazzName, packageName);

            List<String> lines = Files.readAllLines(f.toPath());

            for (int i = 1; i < lines.size(); i++) {
                String line = lines.get(i).trim();

                if (line.startsWith("/**")) {

            

Reported by PMD.

              
            List<String> lines = Files.readAllLines(f.toPath());

            for (int i = 1; i < lines.size(); i++) {
                String line = lines.get(i).trim();

                if (line.startsWith("/**")) {
                    boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {

            

Reported by PMD.

                          List<String> lines = Files.readAllLines(f.toPath());

            for (int i = 1; i < lines.size(); i++) {
                String line = lines.get(i).trim();

                if (line.startsWith("/**")) {
                    boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {


            

Reported by PMD.

                          List<String> lines = Files.readAllLines(f.toPath());

            for (int i = 1; i < lines.size(); i++) {
                String line = lines.get(i).trim();

                if (line.startsWith("/**")) {
                    boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {


            

Reported by PMD.

                          for (int i = 1; i < lines.size(); i++) {
                String line = lines.get(i).trim();

                if (line.startsWith("/**")) {
                    boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {

                        String line2 = lines.get(j).trim();
                        if (line2.startsWith("public")) {

            

Reported by PMD.

              
                if (line.startsWith("/**")) {
                    boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {

                        String line2 = lines.get(j).trim();
                        if (line2.startsWith("public")) {
                            if (line2.endsWith("() {")) {
                                found = true;

            

Reported by PMD.

                                  boolean found = false;
                    for (int j = i + 1; j < lines.size(); j++) {

                        String line2 = lines.get(j).trim();
                        if (line2.startsWith("public")) {
                            if (line2.endsWith("() {")) {
                                found = true;
                            }
                            break;

            

Reported by PMD.

              
@RunWith(MockitoJUnitRunner.class)
public class SequentialDisposableTest extends RxJavaTest {
    private SequentialDisposable serialDisposable;

    @Before
    public void setUp() {
        serialDisposable = new SequentialDisposable();
    }

            

Reported by PMD.

                  }

    @Test
    public void getDisposableShouldReturnset() {
        final Disposable underlying = mock(Disposable.class);
        serialDisposable.update(underlying);
        assertSame(underlying, serialDisposable.get());

        final Disposable another = mock(Disposable.class);

            

Reported by PMD.

                      serialDisposable.replace(Disposable.empty());
        serialDisposable.dispose();

        verify(underlying, never()).dispose();
    }

    @Test
    public void unsubscribingTwiceDoesUnsubscribeOnce() {
        Disposable underlying = mock(Disposable.class);

            

Reported by PMD.

                      serialDisposable.update(underlying);

        serialDisposable.dispose();
        verify(underlying).dispose();

        serialDisposable.dispose();
        verifyNoMoreInteractions(underlying);
    }


            

Reported by PMD.

                      serialDisposable.update(underlying);
        verifyNoInteractions(underlying);
        serialDisposable.update(underlying);
        verify(underlying).dispose();
    }

    @Test
    public void unsubscribingWithSingleUnderlyingUnsubscribes() {
        Disposable underlying = mock(Disposable.class);

            

Reported by PMD.

                  public void unsubscribingWithSingleUnderlyingUnsubscribes() {
        Disposable underlying = mock(Disposable.class);
        serialDisposable.update(underlying);
        underlying.dispose();
        verify(underlying).dispose();
    }

    @Test
    public void replacingFirstUnderlyingCausesUnsubscription() {

            

Reported by PMD.

                      Disposable underlying = mock(Disposable.class);
        serialDisposable.update(underlying);
        underlying.dispose();
        verify(underlying).dispose();
    }

    @Test
    public void replacingFirstUnderlyingCausesUnsubscription() {
        Disposable first = mock(Disposable.class);

            

Reported by PMD.

                      serialDisposable.update(first);
        Disposable second = mock(Disposable.class);
        serialDisposable.update(second);
        verify(first).dispose();
    }

    @Test
    public void whenUnsubscribingSecondUnderlyingUnsubscribed() {
        Disposable first = mock(Disposable.class);

            

Reported by PMD.

                      Disposable second = mock(Disposable.class);
        serialDisposable.update(second);
        serialDisposable.dispose();
        verify(second).dispose();
    }

    @Test
    public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscription() {
        serialDisposable.dispose();

            

Reported by PMD.

                      serialDisposable.dispose();
        Disposable underlying = mock(Disposable.class);
        serialDisposable.update(underlying);
        verify(underlying).dispose();
    }

    @Test
    public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscriptionConcurrently()
            throws InterruptedException {

            

Reported by PMD.

              public class SingleOnErrorXTest extends RxJavaTest {

    @Test
    public void returnSuccess() {
        Single.just(1)
        .onErrorReturnItem(2)
        .test()
        .assertResult(1);
    }

            

Reported by PMD.

              
    @Test
    public void returnSuccess() {
        Single.just(1)
        .onErrorReturnItem(2)
        .test()
        .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void returnSuccess() {
        Single.just(1)
        .onErrorReturnItem(2)
        .test()
        .assertResult(1);
    }


            

Reported by PMD.

              
    @Test
    public void returnSuccess() {
        Single.just(1)
        .onErrorReturnItem(2)
        .test()
        .assertResult(1);
    }


            

Reported by PMD.

                  }

    @Test
    public void resumeThrows() {
        TestObserverEx<Integer> to = Single.<Integer>error(new TestException("Outer"))
        .onErrorReturn(new Function<Throwable, Integer>() {
            @Override
            public Integer apply(Throwable e) throws Exception {
                throw new TestException("Inner");

            

Reported by PMD.

                      .to(TestHelper.<Integer>testConsumer())
        .assertFailure(CompositeException.class);

        List<Throwable> errors = TestHelper.compositeList(to.errors().get(0));

        TestHelper.assertError(errors, 0, TestException.class, "Outer");
        TestHelper.assertError(errors, 1, TestException.class, "Inner");
    }


            

Reported by PMD.

                  }

    @Test
    public void resumeErrors() {
        Single.error(new TestException("Main"))
        .onErrorResumeWith(Single.error(new TestException("Resume")))
        .to(TestHelper.<Object>testConsumer())
        .assertFailureAndMessage(TestException.class, "Resume");
    }

            

Reported by PMD.

                  }

    @Test
    public void resumeDispose() {
        TestHelper.checkDisposed(Single.error(new TestException("Main"))
        .onErrorResumeWith(Single.just(1)));
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void resumeDoubleOnSubscribe() {
        TestHelper.checkDoubleOnSubscribeSingle(new Function<Single<Object>, SingleSource<Object>>() {
            @Override
            public SingleSource<Object> apply(Single<Object> s) throws Exception {
                return s.onErrorResumeWith(Single.just(1));
            }

            

Reported by PMD.

                  }

    @Test
    public void resumeSuccess() {
        Single.just(1)
        .onErrorResumeWith(Single.just(2))
        .test()
        .assertResult(1);
    }

            

Reported by PMD.