Returns a non-terminating observable sequence, which can be used to denote an infinite duration.
| public static never ( ) : Rx\Observable\NeverObservable | ||
| return | Rx\Observable\NeverObservable | An observable sequence whose observers will never get called. |
/**
* @test
*/
public function never_basic()
{
$xs = Observable::never();
$results = new MockObserver($this->scheduler);
$xs->subscribe($results);
$this->assertMessages([], $results->getMessages());
}
public function testAsObservableNever()
{
$results = $this->scheduler->startWithCreate(function () {
return Observable::never()->asObservable();
});
$this->assertMessages([], $results->getMessages());
}
/**
* @test
*/
public function distinct_until_changed_never()
{
$results = $this->scheduler->startWithCreate(function () {
$o = new EmptyObservable();
return Observable::never()->distinctUntilChanged();
});
$this->assertMessages([], $results->getMessages());
}
public function testSkipUntilNeverNever()
{
$l = Observable::never();
$r = Observable::never();
$results = $this->scheduler->startWithCreate(function () use($l, $r) {
return $l->skipUntil($r);
});
$this->assertMessages([], $results->getMessages());
}
/**
* @test
*/
public function race_empty_never()
{
$n1 = Observable::never();
$e = $this->createHotObservable([onNext(150, 1), onCompleted(225)]);
$results = $this->scheduler->startWithCreate(function () use($n1, $e) {
return Observable::race([$e, $n1]);
});
$this->assertMessages([onCompleted(225)], $results->getMessages());
}
public function testScanNoSeedNever()
{
$results = $this->scheduler->startWithCreate(function () {
return Observable::never()->scan(function ($acc, $x) {
return $acc + $x;
});
});
$this->assertMessages([], $results->getMessages());
}
/**
* @test
*/
public function await_default_timeout()
{
$start = microtime(true);
$observable = Observable::never()->takeUntil(Observable::timer(2000));
$generator = \Rx\await($observable);
foreach ($generator as $item) {
}
$totalTime = microtime(true) - $start;
$this->assertEquals('2', round($totalTime));
}
/**
* @test
*/
function cut_never()
{
$xs = Observable::never();
$results = $this->scheduler->startWithCreate(function () use($xs) {
return $xs->lift(function () {
return new CutOperator();
});
});
$this->assertMessages([], $results->getMessages());
}
/**
* @test
*/
public function takeUntil_preempt_never_never()
{
$l = Observable::never();
$r = Observable::never();
$result = $this->scheduler->startWithCreate(function () use($l, $r) {
return $l->takeUntil($r);
});
$this->assertMessages([], $result->getMessages());
}
/**
* does not lose subscription to underlying observable
* @test
*/
public function catchError_does_not_lose_subscription()
{
$subscribes = 0;
$unsubscribes = 0;
$tracer = Observable::create(function () use(&$subscribes, &$unsubscribes) {
++$subscribes;
return new CallbackDisposable(function () use(&$unsubscribes) {
++$unsubscribes;
});
});
// Try it without catchError()
$s = $tracer->subscribe(new CallbackObserver());
$this->assertEquals($subscribes, 1, '1 subscribes');
$this->assertEquals($unsubscribes, 0, '0 unsubscribes');
$s->dispose();
$this->assertEquals($subscribes, 1, 'After dispose: 1 subscribes');
$this->assertEquals($unsubscribes, 1, 'After dispose: 1 unsubscribes');
// And now try again with catchError(function()):
$subscribes = 0;
$unsubscribes = 0;
$s = $tracer->catchError(function () {
return Observable::never();
})->subscribe(new CallbackObserver());
$this->assertEquals($subscribes, 1, 'catchError(Observable): 1 subscribes');
$this->assertEquals($unsubscribes, 0, 'catchError(Observable): 0 unsubscribes');
$s->dispose();
$this->assertEquals($subscribes, 1, 'catchError(Observable): After dispose: 1 subscribes');
$this->assertEquals($unsubscribes, 1, 'catchError(Observable): After dispose: 1 unsubscribes');
}
/**
* @test
* @requires function Rx\Observable::dematerialize
*/
public function materialize_dematerialize_never()
{
$results = $this->scheduler->startWithCreate(function () {
return Observable::never()->materialize()->dematerialize();
});
$this->assertMessages([], $results->getMessages());
}
public function testConcatNeverReturn()
{
$e1 = $this->createHotObservable([onNext(150, 1), onNext(210, 2), onCompleted(230)]);
$e2 = Observable::never();
$results = $this->scheduler->startWithCreate(function () use($e1, $e2) {
return $e2->concat($e1);
});
$this->assertMessages([], $results->getMessages());
}
public function testRetryWhenDisposeBetweenSourceSubscriptions()
{
$xs = $this->createColdObservable([onNext(10, 1), onNext(20, 2), onNext(30, 3), onNext(40, 4), onCompleted(50)]);
$results = $this->scheduler->startWithDispose(function () use($xs) {
return $xs->map(function ($x) {
if ($x > 2) {
throw new \Exception();
}
return $x;
})->retryWhen(function ($attempts) {
return Observable::never();
});
}, 285);
$this->assertMessages([onNext(210, 1), onNext(220, 2)], $results->getMessages());
$this->assertSubscriptions([subscribe(200, 230)], $xs->getSubscriptions());
}
<?php require_once __DIR__ . '/../bootstrap.php'; $observable = \Rx\Observable::never(); $observable->subscribe($stdoutObserver);
/**
* @test
*/
public function repeatWhen_Observable_dispose_between()
{
$xs = $this->createColdObservable([onNext(10, 1), onNext(20, 2), onNext(30, 3), onNext(40, 4), onNext(50, 5), onCompleted(60)]);
$results = $this->scheduler->startWithDispose(function () use($xs) {
return $xs->repeatWhen(function () {
return Observable::never();
});
}, 275);
$this->assertMessages([onNext(210, 1), onNext(220, 2), onNext(230, 3), onNext(240, 4), onNext(250, 5)], $results->getMessages());
$this->assertSubscriptions([subscribe(200, 260)], $xs->getSubscriptions());
}
