.test()
        .assertResult(1);

        assertTrue(atomicBoolean.get());
    }

    @Test
    public void doOnTerminateError() {
        final AtomicBoolean atomicBoolean = new AtomicBoolean();

            

Reported by PMD.

                      .test()
        .assertFailure(TestException.class);

        assertTrue(atomicBoolean.get());
    }

    @Test
    public void doOnTerminateComplete() {
        final AtomicBoolean atomicBoolean = new AtomicBoolean();

            

Reported by PMD.

                      .test()
        .assertResult();

        assertTrue(atomicBoolean.get());
    }

    @Test
    public void doOnTerminateSuccessCrash() {
        Maybe.just(1).doOnTerminate(new Action() {

            

Reported by PMD.

                  }

    @Test
    public void doOnTerminateSuccessCrash() {
        Maybe.just(1).doOnTerminate(new Action() {
            @Override
            public void run() {
                throw new TestException();
            }

            

Reported by PMD.

                  }

    @Test
    public void doOnTerminateErrorCrash() {
        TestObserverEx<Object> to = Maybe.error(new TestException("Outer"))
        .doOnTerminate(new Action() {
            @Override
            public void run() {
                throw new TestException("Inner");

            

Reported by PMD.

                      .to(TestHelper.<Object>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");
    }

    @Test

            

Reported by PMD.

                  }

    @Test
    public void doOnTerminateCompleteCrash() {
        Maybe.empty()
        .doOnTerminate(new Action() {
            @Override
            public void run() {
                throw new TestException();

            

Reported by PMD.

              
import org.junit.Test;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Action;
import io.reactivex.rxjava3.testsupport.*;

public class MaybeDoOnTerminateTest extends RxJavaTest {

            

Reported by PMD.

              import org.junit.Test;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Action;
import io.reactivex.rxjava3.testsupport.*;

public class MaybeDoOnTerminateTest extends RxJavaTest {


            

Reported by PMD.

              import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Action;
import io.reactivex.rxjava3.testsupport.*;

public class MaybeDoOnTerminateTest extends RxJavaTest {

    @Test
    public void doOnTerminateSuccess() {

            

Reported by PMD.

                  @Test
    public void awaitInterrupted() {

        Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait();
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {

            

Reported by PMD.

                      Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait();
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }

            

Reported by PMD.

                      Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait();
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }

            

Reported by PMD.

                      try {
            PublishProcessor.create().ignoreElements().blockingAwait();
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }
        }


            

Reported by PMD.

                  @Test
    public void awaitTimeoutInterrupted() {

        Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait(1, TimeUnit.SECONDS);
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {

            

Reported by PMD.

                      Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait(1, TimeUnit.SECONDS);
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }

            

Reported by PMD.

                      Thread.currentThread().interrupt();

        try {
            PublishProcessor.create().ignoreElements().blockingAwait(1, TimeUnit.SECONDS);
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }

            

Reported by PMD.

                      try {
            PublishProcessor.create().ignoreElements().blockingAwait(1, TimeUnit.SECONDS);
            fail("Should have thrown RuntimeException");
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("Wrong cause: " + ex.getCause());
            }
        }


            

Reported by PMD.

              
    @Test
    public void awaitTimeout() {
        assertFalse(PublishProcessor.create().ignoreElements().blockingAwait(100, TimeUnit.MILLISECONDS));
    }
}

            

Reported by PMD.

              
    @Test
    public void awaitTimeout() {
        assertFalse(PublishProcessor.create().ignoreElements().blockingAwait(100, TimeUnit.MILLISECONDS));
    }
}

            

Reported by PMD.

              
    private static final TimeUnit TIME_UNIT = TimeUnit.MILLISECONDS;

    private Observer<Timed<Integer>> observer;

    private TestScheduler testScheduler;
    private PublishSubject<Integer> subject;
    private Observable<Timed<Integer>> observable;


            

Reported by PMD.

              
    private Observer<Timed<Integer>> observer;

    private TestScheduler testScheduler;
    private PublishSubject<Integer> subject;
    private Observable<Timed<Integer>> observable;

    @Before
    public void setUp() {

            

Reported by PMD.

                  private Observer<Timed<Integer>> observer;

    private TestScheduler testScheduler;
    private PublishSubject<Integer> subject;
    private Observable<Timed<Integer>> observable;

    @Before
    public void setUp() {
        observer = TestHelper.mockObserver();

            

Reported by PMD.

              
    private TestScheduler testScheduler;
    private PublishSubject<Integer> subject;
    private Observable<Timed<Integer>> observable;

    @Before
    public void setUp() {
        observer = TestHelper.mockObserver();
        testScheduler = new TestScheduler();

            

Reported by PMD.

                              new Timed<>(2, 2000, TIME_UNIT));
        inOrder.verify(observer, times(1)).onNext(
                new Timed<>(3, 3000, TIME_UNIT));
        inOrder.verify(observer, times(1)).onComplete();
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void timeIntervalDefault() {

            

Reported by PMD.

                              new Timed<>(2, 2000, TIME_UNIT));
        inOrder.verify(observer, times(1)).onNext(
                new Timed<>(3, 3000, TIME_UNIT));
        inOrder.verify(observer, times(1)).onComplete();
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void timeIntervalDefault() {

            

Reported by PMD.

                      inOrder.verify(observer, times(1)).onNext(
                new Timed<>(3, 3000, TIME_UNIT));
        inOrder.verify(observer, times(1)).onComplete();
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void timeIntervalDefault() {
        final TestScheduler scheduler = new TestScheduler();

            

Reported by PMD.

              
    @Test
    public void dispose() {
        TestHelper.checkDisposed(Observable.just(1).timeInterval());
    }

    @Test
    public void error() {
        Observable.error(new TestException())

            

Reported by PMD.

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

import static org.mockito.Mockito.*;

import java.util.concurrent.TimeUnit;

import org.junit.*;
import org.mockito.InOrder;

            

Reported by PMD.

              
import java.util.concurrent.TimeUnit;

import org.junit.*;
import org.mockito.InOrder;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.TestException;
import io.reactivex.rxjava3.functions.Function;

            

Reported by PMD.

              public class CompletableResumeNextTest extends RxJavaTest {

    @Test
    public void resumeNextError() {
        Completable.error(new TestException())
        .onErrorResumeNext(Functions.justFunction(Completable.error(new TestException("second"))))
        .to(TestHelper.<Object>testConsumer())
        .assertFailureAndMessage(TestException.class, "second");
    }

            

Reported by PMD.

                  }

    @Test
    public void disposeInMain() {
        TestHelper.checkDisposedCompletable(new Function<Completable, CompletableSource>() {
            @Override
            public CompletableSource apply(Completable c) throws Exception {
                return c.onErrorResumeNext(Functions.justFunction(Completable.complete()));
            }

            

Reported by PMD.

                  }

    @Test
    public void disposeInResume() {
        TestHelper.checkDisposedCompletable(new Function<Completable, CompletableSource>() {
            @Override
            public CompletableSource apply(Completable c) throws Exception {
                return Completable.error(new TestException()).onErrorResumeNext(Functions.justFunction(c));
            }

            

Reported by PMD.

                  }

    @Test
    public void disposed() {
        TestHelper.checkDisposed(
                Completable.error(new TestException())
                .onErrorResumeNext(Functions.justFunction(Completable.never()))
        );
    }

            

Reported by PMD.

                  public void resumeWithNoError() throws Throwable {
        Action action = mock(Action.class);

        Completable.complete()
        .onErrorResumeWith(Completable.fromAction(action))
        .test()
        .assertResult();

        verify(action, never()).run();

            

Reported by PMD.

                  public void resumeWithNoError() throws Throwable {
        Action action = mock(Action.class);

        Completable.complete()
        .onErrorResumeWith(Completable.fromAction(action))
        .test()
        .assertResult();

        verify(action, never()).run();

            

Reported by PMD.

                  public void resumeWithNoError() throws Throwable {
        Action action = mock(Action.class);

        Completable.complete()
        .onErrorResumeWith(Completable.fromAction(action))
        .test()
        .assertResult();

        verify(action, never()).run();

            

Reported by PMD.

                      .test()
        .assertResult();

        verify(action, never()).run();
    }

    @Test
    public void resumeWithError() throws Throwable {
        Action action = mock(Action.class);

            

Reported by PMD.

                      .test()
        .assertResult();

        verify(action).run();
    }
}

            

Reported by PMD.

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

import static org.mockito.Mockito.*;
import org.junit.Test;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.TestException;
import io.reactivex.rxjava3.functions.*;

            

Reported by PMD.

              public class EmptyDisposableTest extends RxJavaTest {

    @Test
    public void noOffer() {
        TestHelper.assertNoOffer(EmptyDisposable.INSTANCE);
    }

    @Test
    public void asyncFusion() {

            

Reported by PMD.

                  }

    @Test
    public void asyncFusion() {
        assertEquals(QueueFuseable.NONE, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.SYNC));
        assertEquals(QueueFuseable.ASYNC, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.ASYNC));
    }

    @Test

            

Reported by PMD.

              
    @Test
    public void asyncFusion() {
        assertEquals(QueueFuseable.NONE, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.SYNC));
        assertEquals(QueueFuseable.ASYNC, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.ASYNC));
    }

    @Test
    public void checkEnum() {

            

Reported by PMD.

              
    @Test
    public void asyncFusion() {
        assertEquals(QueueFuseable.NONE, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.SYNC));
        assertEquals(QueueFuseable.ASYNC, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.ASYNC));
    }

    @Test
    public void checkEnum() {

            

Reported by PMD.

                  @Test
    public void asyncFusion() {
        assertEquals(QueueFuseable.NONE, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.SYNC));
        assertEquals(QueueFuseable.ASYNC, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.ASYNC));
    }

    @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);

            

Reported by PMD.

                  @Test
    public void asyncFusion() {
        assertEquals(QueueFuseable.NONE, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.SYNC));
        assertEquals(QueueFuseable.ASYNC, EmptyDisposable.INSTANCE.requestFusion(QueueFuseable.ASYNC));
    }

    @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);

            

Reported by PMD.

                  }

    @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);
        assertNotNull(EmptyDisposable.valueOf("INSTANCE"));
        assertNotNull(EmptyDisposable.valueOf("NEVER"));
    }
}

            

Reported by PMD.

              
    @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);
        assertNotNull(EmptyDisposable.valueOf("INSTANCE"));
        assertNotNull(EmptyDisposable.valueOf("NEVER"));
    }
}

            

Reported by PMD.

              
    @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);
        assertNotNull(EmptyDisposable.valueOf("INSTANCE"));
        assertNotNull(EmptyDisposable.valueOf("NEVER"));
    }
}

            

Reported by PMD.

                  @Test
    public void checkEnum() {
        assertEquals(2, EmptyDisposable.values().length);
        assertNotNull(EmptyDisposable.valueOf("INSTANCE"));
        assertNotNull(EmptyDisposable.valueOf("NEVER"));
    }
}

            

Reported by PMD.

              public class SingleSafeSubscribeTest {

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

            Single.just(1)

            

Reported by PMD.

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

            Single.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")
            SingleObserver<Integer> consumer = mock(SingleObserver.class);

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

            

Reported by PMD.

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

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

    @Test
    public void onSubscribeCrash() throws Throwable {

            

Reported by PMD.

                  }

    @Test
    public void onSubscribeCrash() throws Throwable {
        TestHelper.withErrorTracking(errors -> {
            @SuppressWarnings("unchecked")
            SingleObserver<Integer> consumer = mock(SingleObserver.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")
            SingleObserver<Integer> consumer = mock(SingleObserver.class);
            doThrow(new TestException()).when(consumer).onSuccess(any());


            

Reported by PMD.

                  }

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


            

Reported by PMD.

              
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

import java.io.IOException;

import org.junit.Test;
import org.mockito.InOrder;

            

Reported by PMD.

                  public void source() {
        Maybe<Integer> source = Maybe.just(1);

        assertSame(source, ((HasUpstreamMaybeSource<Integer>)source.ignoreElement().toMaybe()).source());
    }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());

            

Reported by PMD.

                  public void source() {
        Maybe<Integer> source = Maybe.just(1);

        assertSame(source, ((HasUpstreamMaybeSource<Integer>)source.ignoreElement().toMaybe()).source());
    }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());

            

Reported by PMD.

                  public void source() {
        Maybe<Integer> source = Maybe.just(1);

        assertSame(source, ((HasUpstreamMaybeSource<Integer>)source.ignoreElement().toMaybe()).source());
    }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());

            

Reported by PMD.

                  }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());
    }

    @Test
    public void successToComplete() {

            

Reported by PMD.

              
    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());
    }

    @Test
    public void successToComplete() {
        Maybe.just(1)

            

Reported by PMD.

              
    @Test
    public void dispose() {
        TestHelper.checkDisposed(Maybe.never().ignoreElement().toMaybe());
    }

    @Test
    public void successToComplete() {
        Maybe.just(1)

            

Reported by PMD.

                  }

    @Test
    public void successToComplete() {
        Maybe.just(1)
        .ignoreElement()
        .test()
        .assertResult();
    }

            

Reported by PMD.

              
    @Test
    public void successToComplete() {
        Maybe.just(1)
        .ignoreElement()
        .test()
        .assertResult();
    }


            

Reported by PMD.

              
    @Test
    public void successToComplete() {
        Maybe.just(1)
        .ignoreElement()
        .test()
        .assertResult();
    }


            

Reported by PMD.

              
    @Test
    public void successToComplete() {
        Maybe.just(1)
        .ignoreElement()
        .test()
        .assertResult();
    }


            

Reported by PMD.

              public class SingleMaterializeTest extends RxJavaTest {

    @Test
    public void success() {
        Single.just(1)
        .materialize()
        .test()
        .assertResult(Notification.createOnNext(1));
    }

            

Reported by PMD.

              
    @Test
    public void success() {
        Single.just(1)
        .materialize()
        .test()
        .assertResult(Notification.createOnNext(1));
    }


            

Reported by PMD.

              
    @Test
    public void success() {
        Single.just(1)
        .materialize()
        .test()
        .assertResult(Notification.createOnNext(1));
    }


            

Reported by PMD.

              
    @Test
    public void success() {
        Single.just(1)
        .materialize()
        .test()
        .assertResult(Notification.createOnNext(1));
    }


            

Reported by PMD.

                  }

    @Test
    public void error() {
        TestException ex = new TestException();
        Maybe.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));

            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Maybe.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Maybe.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Maybe.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  }

    @Test
    public void doubleOnSubscribe() {
        TestHelper.checkDoubleOnSubscribeSingle(new Function<Single<Object>, SingleSource<Notification<Object>>>() {
            @Override
            public SingleSource<Notification<Object>> apply(Single<Object> v) throws Exception {
                return v.materialize();
            }

            

Reported by PMD.

                  }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(SingleSubject.create().materialize());
    }
}

            

Reported by PMD.

              public class CompletableMaterializeTest extends RxJavaTest {

    @Test
    public void error() {
        TestException ex = new TestException();
        Completable.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));

            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Completable.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Completable.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  @Test
    public void error() {
        TestException ex = new TestException();
        Completable.error(ex)
        .materialize()
        .test()
        .assertResult(Notification.createOnError(ex));
    }


            

Reported by PMD.

                  }

    @Test
    public void empty() {
        Completable.complete()
        .materialize()
        .test()
        .assertResult(Notification.createOnComplete());
    }

            

Reported by PMD.

              
    @Test
    public void empty() {
        Completable.complete()
        .materialize()
        .test()
        .assertResult(Notification.createOnComplete());
    }


            

Reported by PMD.

              
    @Test
    public void empty() {
        Completable.complete()
        .materialize()
        .test()
        .assertResult(Notification.createOnComplete());
    }


            

Reported by PMD.

              
    @Test
    public void empty() {
        Completable.complete()
        .materialize()
        .test()
        .assertResult(Notification.createOnComplete());
    }


            

Reported by PMD.

                  }

    @Test
    public void doubleOnSubscribe() {
        TestHelper.checkDoubleOnSubscribeCompletableToSingle(new Function<Completable, SingleSource<Notification<Object>>>() {
            @Override
            public SingleSource<Notification<Object>> apply(Completable v) throws Exception {
                return v.materialize();
            }

            

Reported by PMD.

                  }

    @Test
    public void dispose() {
        TestHelper.checkDisposed(CompletableSubject.create().materialize());
    }
}

            

Reported by PMD.

               * @param <T>
 *          the type of items observed and emitted by the Subject
 */
public final class PublishSubject<T> extends Subject<T> {
    /** The terminated indicator for the subscribers array. */
    @SuppressWarnings("rawtypes")
    static final PublishDisposable[] TERMINATED = new PublishDisposable[0];
    /** An empty subscribers array to avoid allocating it all the time. */
    @SuppressWarnings("rawtypes")

            

Reported by PMD.

                  static final PublishDisposable[] EMPTY = new PublishDisposable[0];

    /** The array of currently subscribed subscribers. */
    final AtomicReference<PublishDisposable<T>[]> subscribers;

    /** The error, write before terminating and read after checking subscribers. */
    Throwable error;

    /**

            

Reported by PMD.

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

    /** The error, write before terminating and read after checking subscribers. */
    Throwable error;

    /**
     * Constructs a PublishSubject.
     * @param <T> the value type
     * @return the new PublishSubject

            

Reported by PMD.

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

    @Override

            

Reported by PMD.

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

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

            

Reported by PMD.

              
            PublishDisposable<T>[] b;

            if (n == 1) {
                b = EMPTY;
            } else {
                b = new PublishDisposable[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 PublishDisposable[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.

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

    @Override
    @Nullable
    @CheckReturnValue

            

Reported by PMD.

              
        private static final long serialVersionUID = 3562861878281475070L;
        /** The actual subscriber. */
        final Observer<? super T> downstream;
        /** The subject state. */
        final PublishSubject<T> parent;

        /**
         * Constructs a PublishSubscriber, wraps the actual subscriber and the state.

            

Reported by PMD.

                      /** The actual subscriber. */
        final Observer<? super T> downstream;
        /** The subject state. */
        final PublishSubject<T> parent;

        /**
         * Constructs a PublishSubscriber, wraps the actual subscriber and the state.
         * @param actual the actual subscriber
         * @param parent the parent PublishProcessor

            

Reported by PMD.