io.reactivex.observers.TestObserver#assertTerminated ( )源码实例Demo

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscriptionCombined_severalPermissions_oneRevoked() {
    TestObserver<Permission> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    when(mRxPermissions.isRevoked(Manifest.permission.CAMERA)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEachCombined(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(
            new String[]{Manifest.permission.READ_PHONE_STATE},
            new int[]{PackageManager.PERMISSION_GRANTED});

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValues(new Permission(permissions[0] + ", " + permissions[1], false));
}
 

@Test public void shouldAutoResubscribeAfterLockAndUnlock() {
  ObservableGroup group = observableManager.newGroup();
  TestObserver<String> testObserver = new TestObserver<>();
  PublishSubject<String> sourceObservable = PublishSubject.create();

  sourceObservable.compose(group.transform(testObserver)).subscribe(testObserver);
  group.lock();

  sourceObservable.onNext("Chespirito");
  sourceObservable.onComplete();

  group.unlock();

  testObserver.assertTerminated();
  testObserver.assertNoErrors();
  testObserver.assertValue("Chespirito");
  assertThat(group.hasObservables(fooObserver)).isEqualTo(false);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_severalPermissions_oneAlreadyGranted() {
    TestObserver<Permission> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    when(mRxPermissions.isGranted(Manifest.permission.CAMERA)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEach(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(
            new String[]{Manifest.permission.READ_PHONE_STATE},
            new int[]{PackageManager.PERMISSION_GRANTED});

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValues(new Permission(permissions[0], true), new Permission(permissions[1], true));
    ArgumentCaptor<String[]> requestedPermissions = ArgumentCaptor.forClass(String[].class);
    verify(mRxPermissions).requestPermissionsFromFragment(requestedPermissions.capture());
    assertEquals(1, requestedPermissions.getValue().length);
    assertEquals(Manifest.permission.READ_PHONE_STATE, requestedPermissions.getValue()[0]);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscriptionCombined_severalPermissions_oneAlreadyGranted() {
    TestObserver<Permission> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    when(mRxPermissions.isGranted(Manifest.permission.CAMERA)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEachCombined(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(
            new String[]{Manifest.permission.READ_PHONE_STATE},
            new int[]{PackageManager.PERMISSION_GRANTED});

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValues(new Permission(permissions[0] + ", " + permissions[1], true));
    ArgumentCaptor<String[]> requestedPermissions = ArgumentCaptor.forClass(String[].class);
    verify(mRxPermissions).requestPermissionsFromFragment(requestedPermissions.capture());
    assertEquals(1, requestedPermissions.getValue().length);
    assertEquals(Manifest.permission.READ_PHONE_STATE, requestedPermissions.getValue()[0]);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_severalPermissions_oneRevoked() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    when(mRxPermissions.isRevoked(Manifest.permission.CAMERA)).thenReturn(true);

    trigger().compose(mRxPermissions.ensure(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(
            new String[]{Manifest.permission.READ_PHONE_STATE},
            new int[]{PackageManager.PERMISSION_GRANTED});

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(false);
}
 

@Test
public void test_never() {
	Observable<String> observable = Observable.never();
	TestObserver<String> testObserver = new TestObserver<>();
	observable.subscribe(testObserver);

	testObserver.assertNoValues();
	testObserver.assertTerminated();
	// testObserver.assertComplete();
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_preM() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensure(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(true);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_granted() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_GRANTED};

    trigger().compose(mRxPermissions.ensure(permission)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(new String[]{permission}, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(true);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_granted() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_GRANTED};

    trigger().compose(mRxPermissions.ensureEach(permission)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(new String[]{permission}, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, true));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_severalPermissions_oneDenied() {
    TestObserver<Permission> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_GRANTED, PackageManager.PERMISSION_DENIED};

    trigger().compose(mRxPermissions.ensureEach(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(permissions, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValues(new Permission(permissions[0], true), new Permission(permissions[1], false));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_preM() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEach(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, true));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscriptionCombined_preM() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEachCombined(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, true));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_alreadyGranted() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensure(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(true);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_severalPermissions_oneDenied() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_GRANTED, PackageManager.PERMISSION_DENIED};

    trigger().compose(mRxPermissions.ensure(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(permissions, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(false);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_denied() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isGranted(permission)).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_DENIED};

    trigger().compose(mRxPermissions.ensureEach(permission)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(new String[]{permission}, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, false));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void subscription_revoked() {
    TestObserver<Boolean> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isRevoked(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensure(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(false);
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscription_revoked() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isRevoked(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEach(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, false));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscriptionCombined_revoked() {
    TestObserver<Permission> sub = new TestObserver<>();
    String permission = Manifest.permission.READ_PHONE_STATE;
    when(mRxPermissions.isRevoked(permission)).thenReturn(true);

    trigger().compose(mRxPermissions.ensureEachCombined(permission)).subscribe(sub);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValue(new Permission(permission, false));
}
 

@Test
@TargetApi(Build.VERSION_CODES.M)
public void eachSubscriptionCombined_severalPermissions_oneDenied() {
    TestObserver<Permission> sub = new TestObserver<>();
    String[] permissions = new String[]{Manifest.permission.READ_PHONE_STATE, Manifest.permission.CAMERA};
    when(mRxPermissions.isGranted(Matchers.<String>anyVararg())).thenReturn(false);
    int[] result = new int[]{PackageManager.PERMISSION_GRANTED, PackageManager.PERMISSION_DENIED};

    trigger().compose(mRxPermissions.ensureEachCombined(permissions)).subscribe(sub);
    mRxPermissions.onRequestPermissionsResult(permissions, result);

    sub.assertNoErrors();
    sub.assertTerminated();
    sub.assertValues(new Permission(permissions[0] + ", " + permissions[1], false));
}
 

@Test
public void serverCanCancelClientStreamImplicitly() {
    TestService svc = new TestService();
    serverRule.getServiceRegistry().addService(svc);

    RxNumbersGrpc.RxNumbersStub stub = RxNumbersGrpc.newRxStub(serverRule.getChannel());

    svc.setExplicitCancel(false);

    AtomicBoolean requestWasCanceled = new AtomicBoolean(false);
    AtomicBoolean requestDidProduce = new AtomicBoolean(false);

    Flowable<NumberProto.Number> request = Flowable
            .fromIterable(IntStream.range(0, NUMBER_OF_STREAM_ELEMENTS)::iterator)
            .delay(10, TimeUnit.MILLISECONDS)
            .map(CancellationPropagationIntegrationTest::protoNum)
            .doOnNext(x -> {
                requestDidProduce.set(true);
                System.out.println("Produced: " + x.getNumber(0));
            })
            .doOnCancel(() -> {
                requestWasCanceled.set(true);
                System.out.println("Client canceled");
            });

    TestObserver<NumberProto.Number> observer = request
            .as(stub::requestPressure)
            .doOnSuccess(number -> System.out.println(number.getNumber(0)))
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .test();

    observer.awaitTerminalEvent(3, TimeUnit.SECONDS);
    observer.assertComplete();
    observer.assertTerminated();

    await().atMost(Duration.FIVE_HUNDRED_MILLISECONDS).untilTrue(requestWasCanceled);

    assertThat(requestWasCanceled.get()).isTrue();
    assertThat(requestDidProduce.get()).isTrue();

    errorRule.verifyNoError();
}