def test_concat_never_never(self):
scheduler = TestScheduler()
e1 = Observable.never()
e2 = Observable.never()
def create():
return e1.concat(e2)
results = scheduler.start(create)
results.messages.assert_equal()
def test_combine_latest_never_never(self):
scheduler = TestScheduler()
e1 = Observable.never()
e2 = Observable.never()
def create():
return e1.combine_latest(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_with_latest_from_never_never(self):
scheduler = TestScheduler()
e1 = Observable.never()
e2 = Observable.never()
def create():
return e1.with_latest_from(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_amb_never2(self):
scheduler = TestScheduler()
l = Observable.never()
r = Observable.never()
def create():
return l.amb(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_zip_never_never(self):
scheduler = TestScheduler()
o1 = Observable.never()
o2 = Observable.never()
def create():
return o1.zip(o2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_merge_never2(self):
scheduler = TestScheduler()
n1 = Observable.never()
n2 = Observable.never()
def create():
return Observable.merge(scheduler, n1, n2)
results = scheduler.start(create)
results.messages.assert_equal()
def test_merge_never2(self):
scheduler = TestScheduler()
n1 = Observable.never()
n2 = Observable.never()
def create():
return Observable.merge(scheduler, n1, n2)
results = scheduler.start(create)
results.messages.assert_equal()
def test_take_until_nopreempt_never_never(self):
scheduler = TestScheduler()
l = Observable.never()
r = Observable.never()
def create():
return l.take_until(r)
results = scheduler.start(create)
assert results.messages == []
def test_skip_until_never_never(self):
scheduler = TestScheduler()
l = Observable.never()
r = Observable.never()
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_zip_never_never(self):
scheduler = TestScheduler()
o1 = Observable.never()
o2 = Observable.never()
def create():
return o1.zip(o2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_concat_never_never(self):
scheduler = TestScheduler()
e1 = Observable.never()
e2 = Observable.never()
def create():
return e1.concat(e2)
results = scheduler.start(create)
assert results.messages == []
def test_amb_never2(self):
scheduler = TestScheduler()
l = Observable.never()
r = Observable.never()
def create():
return l.amb(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_skip_until_never_never(self):
scheduler = TestScheduler()
l = Observable.never()
r = Observable.never()
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_combine_latest_never_never(self):
scheduler = TestScheduler()
e1 = Observable.never()
e2 = Observable.never()
def create():
return e1.combine_latest(e2, lambda x, y: x + y)
results = scheduler.start(create)
assert results.messages == []
def test_amb_never3(self):
scheduler = TestScheduler()
n1 = Observable.never()
n2 = Observable.never()
n3 = Observable.never()
def create():
return Observable.amb(n1, n2, n3)
results = scheduler.start(create)
results.messages.assert_equal()
def test_merge_never3(self):
scheduler = TestScheduler()
n1 = Observable.never()
n2 = Observable.never()
n3 = Observable.never()
def create():
return Observable.merge(n1, n2, n3)
results = scheduler.start(create)
assert results.messages == []
def test_amb_never3(self):
scheduler = TestScheduler()
n1 = Observable.never()
n2 = Observable.never()
n3 = Observable.never()
def create():
return Observable.amb(n1, n2, n3)
results = scheduler.start(create)
results.messages.assert_equal()
def test_never_basic(self):
scheduler = TestScheduler()
xs = Observable.never()
results = scheduler.create_observer()
xs.subscribe(results)
scheduler.start()
results.messages.assert_equal()
def test_never_basic(self):
scheduler = TestScheduler()
xs = Observable.never()
results = scheduler.create_observer()
xs.subscribe(results)
scheduler.start()
assert results.messages == []
def test_zip_non_empty_never(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_next(215, 2), on_completed(220)]
e1 = scheduler.create_hot_observable(msgs)
e2 = Observable.never()
def create():
return e1.zip(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_concat_never_empty(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_completed(230)]
e1 = scheduler.create_hot_observable(msgs1)
e2 = Observable.never()
def create():
return e2.concat(e1)
results = scheduler.start(create)
results.messages.assert_equal()
def test_with_latest_from_return_never(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_next(215, 2), on_completed(210)]
e1 = scheduler.create_hot_observable(msgs)
e2 = Observable.never()
def create():
return e2.with_latest_from(e1, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_amb_empty_never(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_completed(225)]
n = Observable.never()
e = scheduler.create_hot_observable(r_msgs)
def create():
return e.amb(n)
results = scheduler.start(create)
results.messages.assert_equal(on_completed(225))
def test_merge_never_return(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_completed(245)]
r1 = scheduler.create_hot_observable(msgs1)
n1 = Observable.never()
def create():
return Observable.merge(scheduler, n1, r1)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2))
def test_skip_until_never_next(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_next(225, 2), on_completed(250)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_take_until_nopreempt_somedata_never(self):
scheduler = TestScheduler()
l_msgs = [on_next(150, 1), on_next(210, 2), on_next(220, 3), on_next(230, 4), on_next(240, 5), on_completed(250)]
l = scheduler.create_hot_observable(l_msgs)
r = Observable.never()
def create():
return l.take_until(r)
results = scheduler.start(create)
assert results.messages == [on_next(210, 2), on_next(220, 3), on_next(230, 4), on_next(240, 5), on_completed(250)]
def test_publish_multipleconnections(self):
xs = Observable.never()
ys = xs.publish()
connection1 = ys.connect()
connection2 = ys.connect()
assert(connection1 == connection2)
connection1.dispose()
connection2.dispose()
connection3 = ys.connect()
assert(connection1 != connection3)
connection3.dispose()
def test_take_until_preempt_never_next(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_next(225, 2), on_completed(250)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.take_until(r)
results = scheduler.start(create)
results.messages.assert_equal(on_completed(225))
def test_take_until_preempt_never_next(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_next(225, 2), on_completed(250)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.take_until(r)
results = scheduler.start(create)
assert results.messages == [on_completed(225)]
def test_amb_empty_never(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_completed(225)]
n = Observable.never()
e = scheduler.create_hot_observable(r_msgs)
def create():
return e.amb(n)
results = scheduler.start(create)
results.messages.assert_equal(on_completed(225))
def test_skip_until_somedata_never(self):
scheduler = TestScheduler()
l_msgs = [on_next(150, 1), on_next(210, 2), on_next(220, 3), on_next(230, 4), on_next(240, 5), on_completed(250)]
l = scheduler.create_hot_observable(l_msgs)
r = Observable.never()
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_skip_until_never_empty(self):
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_completed(225)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal()
def test_zip_never_empty(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_completed(210)]
o1 = Observable.never()
o2 = scheduler.create_hot_observable(msgs)
def create():
return o1.zip(o2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_zip_never_empty(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_completed(210)]
o1 = Observable.never()
o2 = scheduler.create_hot_observable(msgs)
def create():
return o1.zip(o2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_zip_never_non_empty(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_next(215, 2), on_completed(220)]
e1 = scheduler.create_hot_observable(msgs)
e2 = Observable.never()
def create():
return e2.zip(e1, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_combine_latest_empty_never(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_completed(210)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs)
def create():
return e2.combine_latest(e1, lambda x, y: x + y)
results = scheduler.start(create)
assert results.messages == []
def test_combine_latest_never_feturn(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_next(215, 2), on_completed(220)]
e1 = scheduler.create_hot_observable(msgs)
e2 = Observable.never()
def create():
return e1.combine_latest(e2, lambda x, y: x + y)
results = scheduler.start(create)
assert results.messages == []
def test_on_error_resume_next_end_with_never(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_completed(220)]
o1 = scheduler.create_hot_observable(msgs1)
o2 = Observable.never()
def create():
return Observable.on_error_resume_next(o1, o2)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2))
def test_merge_never_empty(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_completed(245)]
e1 = scheduler.create_hot_observable(msgs1)
n1 = Observable.never()
def create():
return Observable.merge(n1, e1)
results = scheduler.start(create)
assert results.messages == []
def test_with_latest_from_never_return(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_next(215, 2), on_completed(220)]
e1 = scheduler.create_hot_observable(msgs)
e2 = Observable.never()
def create():
return e1.with_latest_from(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_completed(220))
def test_combine_latest_empty_never(self):
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_completed(210)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs)
def create():
return e2.combine_latest(e1, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal()
def test_publish_multipleconnections(self):
xs = Observable.never()
ys = xs.publish()
connection1 = ys.connect()
connection2 = ys.connect()
assert (connection1 == connection2)
connection1.dispose()
connection2.dispose()
connection3 = ys.connect()
assert (connection1 != connection3)
connection3.dispose()
def test_catch_never(self):
scheduler = TestScheduler()
msgs2 = [on_next(240, 5), on_completed(250)]
o1 = Observable.never()
o2 = scheduler.create_hot_observable(msgs2)
def create():
return o1.catch_exception(o2)
results = scheduler.start(create)
results.messages.assert_equal()
def test_catch_error_never(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_next(220, 3), on_error(230, ex)]
o1 = scheduler.create_hot_observable(msgs1)
o2 = Observable.never()
def create():
return o1.catch_exception(o2)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2), on_next(220, 3))
def test_concat_never_empty(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_completed(230)]
e1 = scheduler.create_hot_observable(msgs1)
e2 = Observable.never()
def create():
return e2.concat(e1)
results = scheduler.start(create)
assert results.messages == []
def test_merge_never_return(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_completed(245)]
r1 = scheduler.create_hot_observable(msgs1)
n1 = Observable.never()
def create():
return Observable.merge(scheduler, n1, r1)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2))
def test_concat_return_never(self):
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_completed(230)]
e1 = scheduler.create_hot_observable(msgs1)
e2 = Observable.never()
def create():
return e1.concat(e2)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2))
def test_skip_until_never_error(self):
ex = 'ex'
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_error(225, ex)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal(on_error(225, ex))
def test_catch_never(self):
scheduler = TestScheduler()
msgs2 = [on_next(240, 5), on_completed(250)]
o1 = Observable.never()
o2 = scheduler.create_hot_observable(msgs2)
def create():
return o1.catch_exception(o2)
results = scheduler.start(create)
results.messages.assert_equal()
def test_merge_never_error(self):
ex = 'ex'
scheduler = TestScheduler()
msgs1 = [on_next(150, 1), on_next(210, 2), on_error(245, ex)]
e1 = scheduler.create_hot_observable(msgs1)
n1 = Observable.never()
def create():
return Observable.merge(scheduler, n1, e1)
results = scheduler.start(create)
results.messages.assert_equal(on_next(210, 2), on_error(245, ex))
def test_combine_latest_throw_never(self):
ex = 'ex'
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_error(220, ex)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs)
def create():
return e2.combine_latest(e1, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_error(220, ex))
def test_zip_never_error(self):
ex = 'ex'
scheduler = TestScheduler()
msgs2 = [on_next(150, 1), on_error(220, ex)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs2)
def create():
return e1.zip(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_error(220, ex))
def test_skip_until_never_error(self):
ex = 'ex'
scheduler = TestScheduler()
r_msgs = [on_next(150, 1), on_error(225, ex)]
l = Observable.never()
r = scheduler.create_hot_observable(r_msgs)
def create():
return l.skip_until(r)
results = scheduler.start(create)
results.messages.assert_equal(on_error(225, ex))
def test_with_latest_from_throw_never(self):
ex = 'ex'
scheduler = TestScheduler()
msgs = [on_next(150, 1), on_error(220, ex)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs)
def create():
return e2.with_latest_from(e1, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_error(220, ex))
def test_zip_never_error(self):
ex = 'ex'
scheduler = TestScheduler()
msgs2 = [on_next(150, 1), on_error(220, ex)]
e1 = Observable.never()
e2 = scheduler.create_hot_observable(msgs2)
def create():
return e1.zip(e2, lambda x, y: x + y)
results = scheduler.start(create)
results.messages.assert_equal(on_error(220, ex))
def amb(cls, *args):
"""Propagates the observable sequence that reacts first.
E.g. winner = Rx.Observable.amb(xs, ys, zs)
Returns an observable sequence that surfaces any of the given sequences, whichever reacted first.
"""
acc = Observable.never()
if isinstance(args[0], list):
items = args[0]
else:
items = list(args)
def func(previous, current):
return previous.amb(current)
for item in items:
acc = func(acc, item)
return acc
def create():
return Observable.never().sample(0, scheduler=scheduler)
def create():
return Observable.never().distinct_until_changed()
def duration_selector(x):
return Observable.never()
