Java TestSubject类代码示例

import rx.subjects.TestSubject; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void multipleLeftTerminalRightOtherThread() {
    TestScheduler otherScheduler = Schedulers.test();
    TestSubject<EventB> eventBSubject = TestSubject.create(otherScheduler);
    Observable<Either<EventA, EventB>> either = RxEither.from(eventASubject, eventBSubject);
    either.subscribe(subscriber);

    eventASubject.onNext(eventA);
    eventBSubject.onNext(eventB);
    eventBSubject.onCompleted();
    eventASubject.onNext(eventA);

    testScheduler.triggerActions();
    subscriber.assertNotCompleted();
    otherScheduler.triggerActions();

    subscriber.assertNoErrors();
    subscriber.assertCompleted();
    subscriber.assertUnsubscribed();
    subscriber.assertValues(Either.<EventA, EventB>left(eventA),
                            Either.<EventA, EventB>left(eventA),
                            Either.<EventA, EventB>right(eventB));
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Test
public void onErrorCallsCallback() {
    TestSubject<String> subject = TestSubject.create(scheduler);
    Loader.Callbacks<Result<String>> callbacks = mock(Loader.Callbacks.class);
    Exception error = new Exception();
    RxLoader<String> loader = new RxLoader<>(subject);
    loader.setCallbacks(callbacks);
    loader.start();
    subject.onError(error);

    scheduler.triggerActions();

    verify(callbacks).onLoaderStart();
    verify(callbacks).onLoaderResult(Result.<String>error(error));
    verify(callbacks).onLoaderComplete();
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartRemoveFragment() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().removeFragment();
        }
    });
    Thread.sleep(500); // Need to wait for onDestroy() to be called.
    subject.onNext("test");
    subject.onCompleted();
    testScheduler.triggerActions();
    getInstrumentation().waitForIdleSync();

    assertThat(getActivity().<String>getNext()).isNull();
    assertThat(getActivity().isCompleted()).isFalse().as("onCompleted() is not called if the activity is destroyed");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartDetachFragment() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().detachFragment();
        }
    });
    Thread.sleep(500); // Need to wait for onDestroy() to be called.
    subject.onNext("test");
    subject.onCompleted();
    testScheduler.triggerActions();
    getInstrumentation().waitForIdleSync();

    assertThat(getActivity().<String>getNext()).isNull();
    assertThat(getActivity().isCompleted()).isFalse().as("onCompleted() is not called if the fragment is detached");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartRotation() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().recreate();
        }
    });
    createLoader(getActivity(), subject);
    getActivity().waitForStarted();

    assertThat(getActivity().isStarted()).isTrue().as("onStarted() called again after a configuration change");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartRotationNext() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    subject.onNext("test");
    subject.onCompleted();
    testScheduler.triggerActions();
    getActivity().waitForNext();
    getActivity().waitForCompleted();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().recreate();
        }
    });
    createLoader(getActivity(), subject);
    getActivity().waitForNext();
    getActivity().waitForCompleted();

    assertThat(getActivity().<String>getNext()).isEqualTo("test").as("result is delivered again after a configuration change");
    assertThat(getActivity().isCompleted()).isTrue().as("onCompleted() is called again after a configuration change");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartRotationError() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    subject.onError(new Exception("test"));
    testScheduler.triggerActions();
    getActivity().waitForError();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().recreate();
        }
    });
    createLoader(getActivity(), subject);
    getActivity().waitForError();

    assertThat(getActivity().<String>getError()).hasMessage("test").as("onError() is called again after a configuration change");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartNextAfterDestroyed() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    getInstrumentation().runOnMainSync(new Runnable() {
        @Override
        public void run() {
            getActivity().finish();
        }
    });
    Thread.sleep(500); // Need to wait for onDestroy() to be called.
    subject.onNext("test");
    subject.onCompleted();
    testScheduler.triggerActions();
    getInstrumentation().waitForIdleSync();

    assertThat(getActivity().<String>getNext()).isNull();
    assertThat(getActivity().isCompleted()).isFalse().as("onCompleted() is not called if the activity is destroyed");

    // Needed to recreate the activity since the test runner expects it to exist. 
    getActivity();
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@SmallTest
public void testLoaderStartNextRotationClear() throws InterruptedException {
    TestSubject<String> subject = TestSubject.create(testScheduler);
    RxLoader<String> loader = createLoader(getActivity(), subject).start();
    getActivity().waitForStarted();
    subject.onNext("test");
    subject.onCompleted();
    testScheduler.triggerActions();
    getActivity().waitForNext();
    getActivity().waitForCompleted();
    loader.clear();
    T newActivity = recreateActivity();
    createLoader(newActivity, subject);
    getInstrumentation().waitForIdleSync();
    Thread.sleep(500); // Give loader a chance to deliver the result.

    assertThat(newActivity.<String>getNext()).isNull();
    assertThat(newActivity.isCompleted()).isFalse().as("onCompleted() is not called if the result was cleared");
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    testScheduler = new TestScheduler();
    statusSubject = TestSubject.create(testScheduler);
    jobSubject = TestSubject.create(testScheduler);

    when(uploadInteractor.getAll()).thenReturn(Observable.empty());

    uploadManager =
            new UploadManager(uploadInteractor, uploadErrorAdapter, jobSubject, statusSubject,
                    false);
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Test
public void testDanglingUpload() {
    final String jobId1 = "job-id-1";
    final String jobId2 = "job-id-2";

    final Job job1 = Job.builder()
            .setId(jobId1)
            .setFilepath("filepath")
            .setMetadata(Collections.emptyMap())
            .setStatus(createQueued(jobId1))
            .setMimeType("text/plain")
            .build();

    final Job job2 = Job.builder()
            .setId(jobId2)
            .setFilepath("filepath")
            .setMetadata(Collections.emptyMap())
            .setStatus(createSending(jobId2, 0))
            .setMimeType("text/plain")
            .build();

    when(uploadInteractor.getAll())
            .thenReturn(Observable.from(Arrays.asList(job1, job2)));

    final TestScheduler testScheduler = new TestScheduler();
    final TestSubject<Status> statusSubject = TestSubject.create(testScheduler);
    final TestSubject<Job> jobSubject = TestSubject.create(testScheduler);

    new UploadManager(uploadInteractor, uploadErrorAdapter, jobSubject, statusSubject, false);

    verify(uploadInteractor, times(1)).update(any(Status.class));

    final Status expectedStatus = Status.createFailed(job2.id(), ErrorType.TERMINATED);
    verify(uploadInteractor).update(expectedStatus);
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Before
public void setUpServer() {
    tradeEventStreamClient = mock(EventStreamClient.class);
    scheduler = Schedulers.test();
    vwapServer = new VwapServer(42, tradeEventStreamClient, scheduler);
    tradeSourceSubject = TestSubject.create(scheduler);
    when(tradeEventStreamClient.readServerSideEvents()).thenReturn(tradeSourceSubject);
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Test
public void newlyCreatedIsNotSubscribed() {
    TestSubject<String> subject = TestSubject.create(scheduler);
    RxLoader<String> loader = new RxLoader<>(subject);

    assertFalse(subject.hasObservers());
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Test
public void startedSubscribes() {
    TestSubject<String> subject = TestSubject.create(scheduler);
    RxLoader<String> loader = new RxLoader<>(subject);
    loader.start();

    assertTrue(subject.hasObservers());
}
 

import rx.subjects.TestSubject; //导入依赖的package包/类
@Test
public void canceledUnsubscribes() {
    TestSubject<String> subject = TestSubject.create(scheduler);
    RxLoader<String> loader = new RxLoader<>(subject);
    loader.start();
    loader.cancel();

    assertFalse(subject.hasObservers());
}