def test_retry_observable_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1, scheduler1).retry()
xs.subscribe(lambda x: _raise('ex'))
try:
return scheduler1.start()
except RxException:
pass
scheduler2 = TestScheduler()
ys = Observable.throw_exception('ex', scheduler2).retry()
d = ys.subscribe(on_error=lambda ex: _raise('ex'))
scheduler2.schedule_absolute(210, lambda: d.dispose())
scheduler2.start()
scheduler3 = TestScheduler()
zs = Observable.return_value(1, scheduler3).retry()
zs.subscribe(on_completed=lambda: _raise('ex'))
try:
return scheduler3.start()
except RxException:
pass
xss = Observable.create(lambda o: _raise('ex')).retry()
try:
return xss.subscribe()
except RxException:
pass
def test_multicast_hot_3(self):
c = [None]
d1 = [None]
d2 = [None]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_completed(390))
s = Subject()
o = scheduler.create_observer()
def action0(scheduler, state):
c[0] = xs.pipe(ops.multicast(s))
scheduler.schedule_absolute(50, action0)
def action1(scheduler, state):
d2[0] = c[0].connect(scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state):
d1[0] = c[0].subscribe(o)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state):
d2[0].dispose()
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
d2[0] = c[0].connect(scheduler)
scheduler.schedule_absolute(335, action4)
scheduler.start()
assert o.messages == [on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(340, 7), on_completed(390)]
assert xs.subscriptions == [subscribe(100, 300), subscribe(335, 390)]
def test_paused_with_immediate_unpause(self):
subscription = [None]
scheduler = TestScheduler()
results = scheduler.create_observer()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_completed(500)
)
controller = Observable.just(True)
pausable_buffered = xs.pausable_buffered(controller)
def action1(scheduler, state):
subscription[0] = pausable_buffered.subscribe(results)
scheduler.schedule_absolute(200, action1)
scheduler.start()
results.messages.assert_equal(
on_next(210, 2),
on_completed(500)
)
def test_group_by_with_merge(self):
scheduler = TestScheduler()
xs = [None]
results = [None]
def action1(scheduler, state):
xs[0] = rx.from_iterable(["alpha", "apple", "beta", "bat", "gamma"]) \
.pipe(ops.group_by(lambda s: s[0]),
ops.map(lambda xs: xs.pipe(ops.to_iterable(), ops.map(list))),
ops.merge_all(),
)
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
results[0] = scheduler.create_observer()
xs[0].subscribe(results[0], scheduler)
scheduler.schedule_absolute(subscribed, action2)
scheduler.start()
assert results[0].messages == [
on_next(200, ["alpha", "apple"]),
on_next(200, ["beta", "bat"]),
on_next(200, ["gamma"]),
on_completed(200)]
def test_retry_observable_retry_count_throws(self):
scheduler1 = TestScheduler()
xs = rx.return_value(1).pipe(ops.retry(3))
xs.subscribe(lambda x: _raise('ex'), scheduler=scheduler1)
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = rx.throw('ex').pipe(ops.retry(100))
d = ys.subscribe(on_error=lambda ex: _raise('ex'), scheduler=scheduler2)
def dispose(_, __):
d.dispose()
scheduler2.schedule_absolute(0, dispose)
scheduler2.start()
scheduler3 = TestScheduler()
zs = rx.return_value(1).pipe(ops.retry(100))
zs.subscribe(on_completed=lambda: _raise('ex'), scheduler=scheduler3)
with pytest.raises(RxException):
scheduler3.start()
xss = rx.create(lambda o: _raise('ex')).pipe(ops.retry(100))
with pytest.raises(Exception):
xss.subscribe()
def test_paused_with_state_change_in_subscriber(self):
scheduler = TestScheduler()
results = scheduler.create_observer()
xs = scheduler.create_hot_observable(
on_next(150, 1), on_next(210, 2), on_next(250, 3), on_next(270, 4), on_next(330, 5), on_completed(500)
)
controller = Subject()
pausable_buffered = xs.pausable_buffered(controller)
def action1(scheduler, state):
def on_next(value):
results.on_next(value)
controller.on_next(False)
def action2(scheduler, state):
controller.on_next(True)
scheduler.schedule_relative(100, action2)
subscription = pausable_buffered.subscribe(on_next, results.on_error, results.on_completed)
controller.on_next(True)
scheduler.schedule_absolute(200, action1)
scheduler.start()
results.messages.assert_equal(
on_next(210, 2), on_next(310, 3), on_next(310, 4), on_next(410, 5), on_completed(500)
)
def test_repeat_observable_repeat_count_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1, scheduler1).repeat(3)
xs.subscribe(lambda x: _raise('ex'))
with self.assertRaises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = Observable.throw_exception('ex1', scheduler2).repeat(3)
ys.subscribe(on_error=lambda ex: _raise('ex2'))
with self.assertRaises(RxException):
scheduler2.start()
scheduler3 = TestScheduler()
zs = Observable.return_value(1, scheduler3).repeat(100)
d = zs.subscribe(on_completed=lambda: _raise('ex3'))
scheduler3.schedule_absolute(10, lambda sc, st: d.dispose())
scheduler3.start()
xss = Observable.create(lambda o: _raise('ex4')).repeat(3)
with self.assertRaises(RxException):
xss.subscribe()
def test_group_by_with_merge(self):
scheduler = TestScheduler()
xs = [None]
results = [None]
def action1(scheduler, state):
xs[0] = Observable.from_(["alpha", "apple", "beta", "bat", "gamma"]) \
.group_by(lambda s: s[0]) \
.map(lambda group: group.to_list()) \
.merge_all()
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
results[0] = scheduler.create_observer()
xs[0].subscribe(results[0])
scheduler.schedule_absolute(subscribed, action2)
scheduler.start()
results[0].messages.assert_equal(
on_next(200, ["alpha", "apple"]),
on_next(200, ["beta", "bat"]),
on_next(200, ["gamma"]),
on_completed(200))
def test_select_disposeinsideselector(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4))
results = scheduler.create_observer()
d = SerialDisposable()
invoked = [0]
def projection(x, *args, **kw):
invoked[0] += 1
if scheduler.clock > 400:
#print("*** Dispose ****")
d.dispose()
return x
d.disposable = xs.select(projection).subscribe(results)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(ReactiveTest.disposed, action)
scheduler.start()
results.messages.assert_equal(on_next(100, 1), on_next(200, 2))
xs.subscriptions.assert_equal(ReactiveTest.subscribe(0, 500))
assert invoked[0] == 3
def test_repeat_observable_repeat_count_throws():
scheduler1 = TestScheduler()
xs = Observable.return_value(1, scheduler1).repeat(3)
xs.subscribe(lambda x: _raise('ex'))
try:
return scheduler1.start()
except RxException:
pass
scheduler2 = TestScheduler()
ys = Observable.throwException('ex1', scheduler2).repeat(3)
ys.subscribe(lambda ex: _raise('ex2'))
try:
return scheduler2.start()
except RxException:
pass
scheduler3 = TestScheduler()
zs = Observable.return_value(1, scheduler3).repeat(100)
d = zs.subscribe(on_complete=lambda: _raise('ex3'))
scheduler3.schedule_absolute(10, lambda: d.dispose())
scheduler3.start()
xss = Observable.create(lambda o: _raise('ex4')).repeat(3)
try:
return xss.subscribe()
except RxException:
pass
def test_select_with_index_dispose_inside_selector():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1))
invoked = 0
results = scheduler.create_observer()
d = SerialDisposable()
def projection(x, index):
nonlocal invoked
invoked += 1
if scheduler.clock > 400:
d.dispose()
return x + index * 10
d.disposable = xs.select(projection).subscribe(results)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(disposed, action)
scheduler.start()
results.messages.assert_equal(on_next(100, 4), on_next(200, 13))
xs.subscriptions.assert_equal(subscribe(0, 500))
assert invoked == 3
def test_multicast_hot_4(self):
c = [None]
d1 = [None]
d2 = [None]
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_error(390, ex))
s = Subject()
o = scheduler.create_observer()
def action0(scheduler, state):
c[0] = xs.multicast(s)
scheduler.schedule_absolute(50, action0)
def action1(scheduler, state):
d2[0] = c[0].connect()
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state):
d1[0] = c[0].subscribe(o)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state):
d2[0].dispose()
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
d2[0] = c[0].connect()
scheduler.schedule_absolute(335, action4)
scheduler.start()
o.messages.assert_equal(on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(340, 7), on_error(390, ex))
xs.subscriptions.assert_equal(subscribe(100, 300), subscribe(335, 390))
def test_map_disposeinsidemapper(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 1), on_next(200, 2), on_next(500, 3), on_next(600, 4))
results = scheduler.create_observer()
d = SerialDisposable()
invoked = [0]
def projection(x, *args, **kw):
invoked[0] += 1
if scheduler.clock > 400:
d.dispose()
return x
d.disposable = xs.pipe(
map(projection)
).subscribe(results, scheduler)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(ReactiveTest.disposed, action)
scheduler.start()
assert results.messages == [on_next(100, 1), on_next(200, 2)]
assert xs.subscriptions == [ReactiveTest.subscribe(0, 500)]
assert invoked[0] == 3
def test_if_default_completed(self):
b = [False]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 1), on_next(220, 2), on_next(330, 3), on_completed(440))
def action(scheduler, state):
b[0] = True
scheduler.schedule_absolute(150, action)
def create():
def condition():
return b[0]
return rx.if_then(condition, xs)
results = scheduler.start(create)
assert results.messages == [on_next(220, 2), on_next(330, 3), on_completed(440)]
assert xs.subscriptions == [subscribe(200, 440)]
def test_if_default_other(self):
b = [True]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 1), on_next(220, 2), on_next(330, 3), on_error(440, 'ex'))
def action(scheduler, state):
b[0] = False
scheduler.schedule_absolute(150, action)
def create():
def condition():
return b[0]
return Observable.if_then(condition, xs)
results = scheduler.start(create)
results.messages.assert_equal(on_completed(200))
xs.subscriptions.assert_equal()
def test_paused_with_observable_controller_and_pause_and_unpause(self):
subscription = [None]
scheduler = TestScheduler()
results = scheduler.create_observer()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(230, 3),
on_next(301, 4),
on_next(350, 5),
on_next(399, 6),
on_next(450, 7),
on_next(470, 8),
on_completed(500),
)
controller = scheduler.create_hot_observable(on_next(201, True), on_next(300, False), on_next(400, True))
pausable_buffered = xs.pausable_buffered(controller)
def action1(scheduler, state):
subscription[0] = pausable_buffered.subscribe(results)
scheduler.schedule_absolute(200, action1)
def action2(scheduler, state):
pausable_buffered.pause()
scheduler.schedule_absolute(460, action2)
def action3(scheduler, state):
pausable_buffered.resume()
scheduler.schedule_absolute(480, action3)
def action4(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action4)
scheduler.start()
results.messages.assert_equal(
on_next(210, 2),
on_next(230, 3),
on_next(400, 4),
on_next(400, 5),
on_next(400, 6),
on_next(450, 7),
on_next(480, 8),
on_completed(500),
)
def test_retry_observable_throws(self):
scheduler1 = TestScheduler()
xs = Observable.return_value(1, scheduler1).retry()
xs.subscribe(lambda x: _raise('ex'))
self.assertRaises(RxException, scheduler1.start)
scheduler2 = TestScheduler()
ys = Observable.throw_exception('ex', scheduler2).retry()
d = ys.subscribe(on_error=lambda ex: _raise('ex'))
scheduler2.schedule_absolute(210, lambda sc, st: d.dispose())
scheduler2.start()
scheduler3 = TestScheduler()
zs = Observable.return_value(1, scheduler3).retry()
zs.subscribe(on_completed=lambda: _raise('ex'))
self.assertRaises(RxException, scheduler3.start)
def test_repeat_observable_throws(self):
scheduler1 = TestScheduler()
xs = rx.return_value(11).pipe(ops.repeat())
xs.subscribe(lambda x: _raise('ex'), scheduler=scheduler1)
with self.assertRaises(RxException):
scheduler1.start()
scheduler2 = TestScheduler()
ys = rx.throw('ex').pipe(ops.repeat())
ys.subscribe(lambda ex: _raise('ex'), scheduler=scheduler2)
with self.assertRaises(Exception):
scheduler2.start()
scheduler3 = TestScheduler()
zs = rx.return_value(1).pipe(ops.repeat())
d = zs.subscribe(on_completed=lambda: _raise('ex'), scheduler=scheduler3)
scheduler3.schedule_absolute(210, lambda sc, st: d.dispose())
scheduler3.start()
def test_return_disposed_after_next(self):
scheduler = TestScheduler()
d = SerialDisposable()
xs = Observable.return_value(42, scheduler)
results = scheduler.create_observer()
def action(scheduler, state):
def on_next(x):
d.dispose()
results.on_next(x)
def on_error(e):
results.on_error(e)
def on_completed():
results.on_completed()
d.disposable = xs.subscribe(on_next, on_error, on_completed)
return d.disposable
scheduler.schedule_absolute(100, action)
scheduler.start()
results.messages.assert_equal(on_next(101, 42))
def test_multicast_hot_5(self):
c = [None]
d1 = [None]
d2 = [None]
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(40, 0), on_next(90, 1), on_next(150, 2), on_next(210, 3), on_next(240, 4), on_next(270, 5), on_next(330, 6), on_next(340, 7), on_error(390, ex))
s = Subject()
o = scheduler.create_observer()
def action0(scheduler, state):
c[0] = xs.pipe(ops.multicast(s))
scheduler.schedule_absolute(50, action0)
def action1(scheduler, state):
d2[0] = c[0].connect(scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state):
d1[0] = c[0].subscribe(o, scheduler)
scheduler.schedule_absolute(400, action2)
scheduler.start()
assert o.messages == [on_error(400, ex)]
assert xs.subscriptions == [subscribe(100, 390)]
def test_where_index_dispose_in_predicate(self):
scheduler = TestScheduler()
ys = [None]
invoked = [0]
xs = scheduler.create_hot_observable(on_next(110, 1), on_next(180, 2), on_next(230, 3), on_next(270, 4), on_next(340, 5), on_next(380, 6), on_next(390, 7), on_next(450, 8), on_next(470, 9), on_next(560, 10), on_next(580, 11), on_completed(600), on_next(610, 12), on_error(620, 'ex'), on_completed(630))
results = scheduler.create_observer()
d = SerialDisposable()
def action1(scheduler, state):
def predicate(x, index):
invoked[0] += 1
if x == 8:
d.dispose()
return is_prime(x + index * 10)
ys[0] = xs.filter(predicate)
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
d.disposable = ys[0].subscribe(results)
scheduler.schedule_absolute(subscribed, action2)
def action3(scheduler, state):
d.dispose()
scheduler.schedule_absolute(disposed, action3)
scheduler.start()
results.messages.assert_equal(on_next(230, 3), on_next(390, 7))
xs.subscriptions.assert_equal(subscribe(200, 450))
assert(invoked[0] == 6)
def test_paused_skip_initial_elements(self):
subscription = [None]
scheduler = TestScheduler()
controller = Subject()
results = scheduler.create_observer()
xs = scheduler.create_hot_observable(on_next(150, 1), on_next(230, 2), on_next(270, 3), on_completed(400))
def action1(scheduler, state):
subscription[0] = xs.pausable_buffered(controller).subscribe(results)
controller.on_next(False)
scheduler.schedule_absolute(200, action1)
def action2(scheduler, state):
controller.on_next(True)
scheduler.schedule_absolute(280, action2)
def action3(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
scheduler.start()
results.messages.assert_equal(on_next(280, 2), on_next(280, 3), on_completed(400))
def test_windowedobservalbe_simple(self):
scheduler = TestScheduler()
windowed = [None]
subject = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(230, 3),
on_next(301, 4),
on_next(350, 5),
on_next(399, 6),
on_completed(500)
)
def action1(scheduler, state=None):
subject[0] = ControlledSubject(enable_queue=False, scheduler=scheduler)
xs.subscribe(subject[0])
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
windowed[0] = WindowedObservable(subject[0], 2, scheduler=scheduler)
scheduler.schedule_absolute(120, action2)
def action3(scheduler, state=None):
windowed[0].subscribe(results1)
scheduler.schedule_absolute(220, action3)
def action4(scheduler, state=None):
windowed[0].subscribe(results2)
scheduler.schedule_absolute(355, action4)
scheduler.start()
results1.messages.assert_equal(
on_next(230, 3),
on_next(301, 4),
on_next(350, 5),
on_next(399, 6),
on_completed(500)
)
results2.messages.assert_equal(
on_next(399, 6),
on_completed(500)
)
def test_map_with_index_dispose_inside_mapper(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(100, 4), on_next(200, 3), on_next(500, 2), on_next(600, 1))
invoked = [0]
results = scheduler.create_observer()
d = SerialDisposable()
def projection(x, index):
invoked[0] += 1
if scheduler.clock > 400:
d.dispose()
return x + index * 10
d.disposable = xs.pipe(map_indexed(projection)).subscribe(results)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(disposed, action)
scheduler.start()
assert results.messages == [on_next(100, 4), on_next(200, 13)]
assert xs.subscriptions == [subscribe(0, 500)]
assert invoked[0] == 3
def test_starmap_dispose_inside_mapper(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
# 100 create
on_next(110, (1, 10)),
# 200 subscribe
on_next(210, (2, 20)),
on_next(310, (3, 30)),
on_next(410, (4, 40)))
results = scheduler.create_observer()
d = SerialDisposable()
invoked = [0]
def mapper(x, y):
invoked[0] += 1
if scheduler._clock > 250:
d.dispose()
return x + y
d.disposable = xs.pipe(
ops.starmap(mapper)
).subscribe(results, scheduler)
def action(scheduler, state):
return d.dispose()
scheduler.schedule_absolute(ReactiveTest.disposed, action)
scheduler.start()
assert results.messages == [
on_next(110, 11),
on_next(210, 22)]
assert xs.subscriptions == [ReactiveTest.subscribe(0, 310)]
assert invoked[0] == 3
def test_paused_no_skip(self):
subscription = [None]
scheduler = TestScheduler()
controller = Subject()
results = scheduler.create_observer()
xs = scheduler.create_hot_observable(
on_next(150, 1),
on_next(210, 2),
on_next(230, 3),
on_next(301, 4),
on_next(350, 5),
on_next(399, 6),
on_completed(500),
)
def action0(scheduler, state):
subscription[0] = xs.pausable_buffered(controller).subscribe(results)
controller.on_next(True)
scheduler.schedule_absolute(200, action0)
def action1(scheduler, state):
controller.on_next(False)
scheduler.schedule_absolute(205, action1)
def action2(scheduler, state):
controller.on_next(True)
scheduler.schedule_absolute(209, action2)
def action3(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
scheduler.start()
results.messages.assert_equal(
on_next(210, 2), on_next(230, 3), on_next(301, 4), on_next(350, 5), on_next(399, 6), on_completed(500)
)
def test_group_by_inner_error():
ex = 'ex1'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, "error"), on_next(110, "error"), on_next(130, "error"), on_next(220, " foo"), on_next(240, " FoO "), on_next(270, "baR "), on_next(310, "foO "), on_next(350, " Baz "), on_next(360, " qux "), on_next(390, " bar"), on_next(420, " BAR "), on_next(470, "FOO "), on_next(480, "baz "), on_next(510, " bAZ "), on_next(530, " fOo "), on_error(570, ex), on_next(580, "error"), on_completed(600), on_error(650, 'ex'))
outer_subscription = None
inner_subscriptions = {}
inners = {}
outer = None
results = {}
result = None
def action1(scheduler, state):
nonlocal outer
outer = xs.group_by(
lambda x: x.lower().strip(),
lambda x: x[::-1]
)
return outer
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
nonlocal outer_subscription
def on_next(group):
nonlocal result, inners, results
result = scheduler.create_observer()
inners[group.key] = group
results[group.key] = result
def action3(scheduler, state):
nonlocal inner_subscriptions
inner_subscriptions[group.key] = group.subscribe(result)
scheduler.schedule_relative(100, action3)
outer_subscription = outer.subscribe(on_next, lambda e: None)
return outer_subscription
scheduler.schedule_absolute(subscribed, action2)
def action4(scheduler, state):
outer_subscription.dispose();
for sub in inner_subscriptions.values():
sub.dispose()
scheduler.schedule_absolute(disposed, action4)
scheduler.start()
assert(len(inners) == 4)
#results['foo'].messages.assert_equal(on_next(470, " OOF"), on_next(530, " oOf "), on_error(570, ex))
#results['bar'].messages.assert_equal(on_next(390, "rab "), on_next(420, " RAB "), on_error(570, ex))
#results['baz'].messages.assert_equal(on_next(480, " zab"), on_next(510, " ZAb "), on_error(570, ex))
#results['qux'].messages.assert_equal(on_error(570, ex))
xs.subscriptions.assert_equal(subscribe(200, 570))
def test_partition_completed(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(180, 5),
on_next(210, 4),
on_next(240, 3),
on_next(290, 2),
on_next(350, 1),
on_completed(360)
)
observables = []
subscription1 = [None]
subscription2 = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
def action0(scheduler, state):
observables.extend(xs.partition(is_even))
scheduler.schedule_absolute(ReactiveTest.created, action0)
def action1(scheduler, state):
subscription1[0] = observables[0].subscribe(results1)
subscription2[0] = observables[1].subscribe(results2)
scheduler.schedule_absolute(ReactiveTest.subscribed, action1)
def action2(scheduler, state):
subscription1[0].dispose()
subscription2[0].dispose()
scheduler.schedule_absolute(ReactiveTest.disposed, action2)
scheduler.start()
results1.messages.assert_equal(
on_next(210, 4),
on_next(290, 2),
on_completed(360)
)
results2.messages.assert_equal(
on_next(240, 3),
on_next(350, 1),
on_completed(360)
)
xs.subscriptions.assert_equal(
subscribe(200, 360)
)
def test_multicast_hot_6(self):
c = [None]
d1 = [None]
d2 = [None]
ex = "ex"
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(40, 0),
on_next(90, 1),
on_next(150, 2),
on_next(210, 3),
on_next(240, 4),
on_next(270, 5),
on_next(330, 6),
on_next(340, 7),
on_completed(390),
)
s = Subject()
o = scheduler.create_observer()
def action0(scheduler, state):
c[0] = xs.multicast(s)
scheduler.schedule_absolute(50, action0)
def action1(scheduler, state):
d2[0] = c[0].connect()
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state):
d1[0] = c[0].subscribe(o)
scheduler.schedule_absolute(400, action2)
scheduler.start()
o.messages.assert_equal(on_completed(400))
xs.subscriptions.assert_equal(subscribe(100, 390))
def test_filter_dispose_in_predicate(self):
scheduler = TestScheduler()
invoked = [0]
ys = [None]
xs = scheduler.create_hot_observable(on_next(110, 1), on_next(180, 2), on_next(230, 3), on_next(270, 4), on_next(340, 5), on_next(380, 6), on_next(
390, 7), on_next(450, 8), on_next(470, 9), on_next(560, 10), on_next(580, 11), on_completed(600), on_next(610, 12), on_error(620, 'ex'), on_completed(630))
results = scheduler.create_observer()
d = SerialDisposable()
def action(scheduler, state):
def predicate(x):
invoked[0] += 1
if x == 8:
d.dispose()
return is_prime(x)
ys[0] = xs.pipe(filter(predicate))
return ys[0]
scheduler.schedule_absolute(created, action)
def action1(scheduler, state):
d.disposable = ys[0].subscribe(results)
scheduler.schedule_absolute(subscribed, action1)
def action2(scheduler, state):
d.dispose()
scheduler.schedule_absolute(disposed, action2)
scheduler.start()
assert results.messages == [
on_next(230, 3), on_next(340, 5), on_next(390, 7)]
assert xs.subscriptions == [subscribe(200, 450)]
assert(invoked[0] == 6)
def test_publish_with_initial_value_error(self):
connection = [None]
subscription = [None]
ys = [None]
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3),
on_next(280, 4), on_next(290, 1),
on_next(340, 8), on_next(360, 5),
on_next(370, 6), on_next(390, 7),
on_next(410, 13), on_next(430, 2),
on_next(450, 9), on_next(520, 11),
on_next(560, 20),
on_error(600, ex))
results = scheduler.create_observer()
def action0(scheduler, state):
ys[0] = xs.publish_value(1979)
scheduler.schedule_absolute(created, action0)
def action1(scheduler, state):
subscription[0] = ys[0].subscribe(results)
scheduler.schedule_absolute(subscribed, action1)
def action2(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(disposed, action2)
def action3(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(800, action6)
scheduler.start()
results.messages.assert_equal(on_next(200, 1979), on_next(340, 8),
on_next(360, 5), on_next(370, 6),
on_next(390, 7), on_next(520, 11),
on_next(560, 20), on_error(600, ex))
xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 600))
def test_group_by_inner_complete(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(90, "error"),
on_next(110, "error"),
on_next(130, "error"),
on_next(220, " foo"),
on_next(240, " FoO "),
on_next(270, "baR "),
on_next(310, "foO "),
on_next(350, " Baz "),
on_next(360, " qux "),
on_next(390, " bar"),
on_next(420, " BAR "),
on_next(470, "FOO "),
on_next(480, "baz "),
on_next(510, " bAZ "),
on_next(530, " fOo "),
on_completed(570),
on_next(580, "error"),
on_completed(600),
on_error(650, 'ex'))
c = {
"outer_subscription": None,
"inner_subscriptions": {},
"inners": {},
"results": {},
"outer": None
}
def action1(scheduler, state):
c["outer"] = xs.group_by(lambda x: x.lower().strip(), lambda x: x[::-1])
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
def next(group):
result = scheduler.create_observer()
c["inners"][group.key] = group
c["results"][group.key] = result
def action21(scheduler, state):
c["inner_subscriptions"][group.key] = group.subscribe(result)
scheduler.schedule_relative(100, action21)
c["outer_subscription"] = c["outer"].subscribe(next)
scheduler.schedule_absolute(subscribed, action2)
def action3(scheduler, state):
c["outer_subscription"].dispose()
for sub in c["inner_subscriptions"].values():
sub.dispose()
scheduler.schedule_absolute(disposed, action3)
scheduler.start()
assert(len(c["inners"]) == 4)
c["results"]['foo'].messages.assert_equal(
on_next(470, " OOF"),
on_next(530, " oOf "),
on_completed(570))
c["results"]['bar'].messages.assert_equal(
on_next(390, "rab "),
on_next(420, " RAB "),
on_completed(570))
c["results"]['baz'].messages.assert_equal(
on_next(480, " zab"),
on_next(510, " ZAb "),
on_completed(570))
c["results"]['qux'].messages.assert_equal(
on_completed(570))
xs.subscriptions.assert_equal(
subscribe(200, 570))
def test_replay_time_dispose(self):
subscription = [None]
connection = [None]
ys = [None]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3),
on_next(280, 4), on_next(290, 1),
on_next(340, 8), on_next(360, 5),
on_next(370, 6), on_next(390, 7),
on_next(410, 13), on_next(430, 2),
on_next(450, 9), on_next(520, 11),
on_next(560, 20),
on_completed(600))
results = scheduler.create_observer()
def action0(scheduler, state):
ys[0] = xs.replay(window=100, scheduler=scheduler)
scheduler.schedule_absolute(created, action0)
def action1(scheduler, state):
subscription[0] = ys[0].subscribe(results, scheduler)
scheduler.schedule_absolute(450, action1)
def action2(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(475, action2)
def action3(scheduler, state):
connection[0] = ys[0].connect(scheduler)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state):
connection[0] = ys[0].connect(scheduler)
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(550, action6)
def action7(scheduler, state):
connection[0] = ys[0].connect(scheduler)
scheduler.schedule_absolute(650, action7)
def action8(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(800, action8)
scheduler.start()
assert results.messages == [
on_next(450, 5), on_next(450, 6),
on_next(450, 7)
]
assert xs.subscriptions == [
subscribe(300, 400),
subscribe(500, 550),
subscribe(650, 800)
]
def test_replay_count_error(self):
connection = [None]
subscription = [None]
ys = [None]
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3),
on_next(280, 4), on_next(290, 1),
on_next(340, 8), on_next(360, 5),
on_next(370, 6), on_next(390, 7),
on_next(410, 13), on_next(430, 2),
on_next(450, 9), on_next(520, 11),
on_next(560, 20),
on_error(600, ex))
results = scheduler.create_observer()
def action0(scheduler, state):
ys[0] = xs.replay(buffer_size=3, scheduler=scheduler)
scheduler.schedule_absolute(created, action0)
def action1(scheduler, state):
subscription[0] = ys[0].subscribe(results)
scheduler.schedule_absolute(450, action1)
def action2(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(disposed, action2)
def action3(scheduler, state):
connection[0] = ys[0].connect(scheduler)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state):
connection[0] = ys[0].connect(scheduler)
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(800, action6)
scheduler.start()
assert results.messages == [
on_next(450, 5),
on_next(450, 6),
on_next(450, 7),
on_next(520, 11),
on_next(560, 20),
on_error(600, ex)
]
assert xs.subscriptions == [subscribe(300, 400), subscribe(500, 600)]
def test_group_by_inner_error(self):
ex = 'ex1'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, "error"),
on_next(110, "error"),
on_next(130, "error"),
on_next(220, " foo"),
on_next(240, " FoO "),
on_next(270, "baR "),
on_next(310, "foO "),
on_next(350, " Baz "),
on_next(360, " qux "),
on_next(390, " bar"),
on_next(420, " BAR "),
on_next(470, "FOO "),
on_next(480, "baz "),
on_next(510, " bAZ "),
on_next(530, " fOo "),
on_error(570, ex),
on_next(580, "error"),
on_completed(600),
on_error(650, 'ex'))
inner_subscriptions = {}
inners = {}
results = {}
c = {"outer_subscription": None, "outer": None}
def action1(scheduler, state):
c["outer"] = xs.pipe(
ops.group_by(
lambda x: x.lower().strip(),
lambda x: x[::-1],
))
return c["outer"]
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
def on_next(group):
result = scheduler.create_observer()
inners[group.key] = group
results[group.key] = result
def action3(scheduler, state):
inner_subscriptions[group.key] = group.subscribe(
result, scheduler)
scheduler.schedule_relative(100, action3)
c["outer_subscription"] = c["outer"].subscribe(on_next,
lambda e: None,
scheduler=scheduler)
return c["outer_subscription"]
scheduler.schedule_absolute(subscribed, action2)
def action4(scheduler, state):
c["outer_subscription"].dispose()
for sub in inner_subscriptions.values():
sub.dispose()
scheduler.schedule_absolute(disposed, action4)
scheduler.start()
assert len(inners) == 4
assert results['foo'].messages == [
on_next(470, " OOF"),
on_next(530, " oOf "),
on_error(570, ex)
]
assert results['bar'].messages == [
on_next(390, "rab "),
on_next(420, " RAB "),
on_error(570, ex)
]
assert results['baz'].messages == [
on_next(480, " zab"),
on_next(510, " ZAb "),
on_error(570, ex)
]
assert results['qux'].messages == [on_error(570, ex)]
assert xs.subscriptions == [subscribe(200, 570)]
def test_group_by_inner_complete_all(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(90, "error"),
on_next(110, "error"),
on_next(130, "error"),
on_next(220, " foo"),
on_next(240, " FoO "),
on_next(270, "baR "),
on_next(310, "foO "),
on_next(350, " Baz "),
on_next(360, " qux "),
on_next(390, " bar"),
on_next(420, " BAR "),
on_next(470, "FOO "),
on_next(480, "baz "),
on_next(510, " bAZ "),
on_next(530, " fOo "),
on_completed(570),
on_next(580, "error"),
on_completed(600),
on_error(650, 'ex'))
inners = {}
inner_subscriptions = {}
results = {}
c = {
"outer": None,
"outer_subscription": None,
"result": None
}
def action1(scheduler, state):
c["outer"] = xs.group_by(
lambda x: x.lower().strip(),
lambda x: x[::-1]
)
return c["outer"]
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
def on_next(group):
c["result"] = scheduler.create_observer()
inners[group.key] = group
results[group.key] = c["result"]
inner_subscriptions[group.key] = group.subscribe(c["result"])
c["outer_subscription"] = c["outer"].subscribe(on_next)
return c["outer_subscription"]
scheduler.schedule_absolute(subscribed, action2)
def action3(scheduler, state):
c["outer_subscription"].dispose()
for sub in inner_subscriptions.values():
sub.dispose()
scheduler.schedule_absolute(disposed, action3)
scheduler.start()
assert(len(inners) == 4)
results['foo'].messages.assert_equal(
on_next(220, "oof "),
on_next(240, " OoF "),
on_next(310, " Oof"),
on_next(470, " OOF"),
on_next(530, " oOf "),
on_completed(570))
results['bar'].messages.assert_equal(
on_next(270, " Rab"),
on_next(390, "rab "),
on_next(420, " RAB "),
on_completed(570))
results['baz'].messages.assert_equal(
on_next(350, " zaB "),
on_next(480, " zab"),
on_next(510, " ZAb "),
on_completed(570))
results['qux'].messages.assert_equal(
on_next(360, " xuq "),
on_completed(570))
xs.subscriptions.assert_equal(
subscribe(200, 570))
def test_infinite():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(70, 1),
on_next(110, 2),
on_next(220, 3),
on_next(270, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7),
on_next(630, 8),
on_next(710, 9),
on_next(870, 10),
on_next(940, 11),
on_next(1020, 12)
)
subject = [None]
subscription = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
subject[0] = ReplaySubject(3, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
subscription[0] = xs.subscribe(subject[0])
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
subscription1[0] = subject[0].subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
subscription2[0] = subject[0].subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
subscription3[0] = subject[0].subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
assert results1.messages == [
on_next(300, 3),
on_next(300, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7)]
assert results2.messages == [
on_next(400, 5),
on_next(410, 6),
on_next(520, 7),
on_next(630, 8)]
assert results3.messages == [
on_next(900, 10),
on_next(940, 11)]
def test_error():
subject = [None]
subscription = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(70, 1),
on_next(110, 2),
on_next(220, 3),
on_next(270, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7),
on_error(630, ex),
on_next(640, 9),
on_completed(650),
on_error(660, 'ex2')
)
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action(scheduler, state=None):
subject[0] = AsyncSubject()
scheduler.schedule_absolute(100, action)
def action1(scheduler, state=None):
subscription[0] = xs.subscribe(subject[0])
scheduler.schedule_absolute(200, action1)
def action2(scheduler, state=None):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action2)
def action3(scheduler, state=None):
subscription1[0] = subject[0].subscribe(results1)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
subscription2[0] = subject[0].subscribe(results2)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
subscription3[0] = subject[0].subscribe(results3)
scheduler.schedule_absolute(900, action5)
def action6(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(600, action6)
def action7(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action7)
def action8(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(800, action8)
def action9(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(950, action9)
scheduler.start()
assert results1.messages == []
assert results2.messages == [on_error(630, ex)]
assert results3.messages == [on_error(900, ex)]
def test_subject_disposed():
scheduler = TestScheduler()
subject = None
subscription1 = None
subscription2 = None
subscription3 = None
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
nonlocal subject
subject = ReplaySubject(scheduler=scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
nonlocal subscription1
subscription1 = subject.subscribe(results1)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
nonlocal subscription2
subscription2 = subject.subscribe(results2)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
nonlocal subscription3
subscription3 = subject.subscribe(results3)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state=None):
subject.dispose()
scheduler.schedule_absolute(600, action6)
def action7(scheduler, state=None):
subscription2.dispose()
scheduler.schedule_absolute(700, action7)
def action8(scheduler, state=None):
subscription3.dispose()
scheduler.schedule_absolute(800, action8)
def action9(scheduler, state=None):
subject.on_next(1)
scheduler.schedule_absolute(150, action9)
def action10(scheduler, state=None):
subject.on_next(2)
scheduler.schedule_absolute(250, action10)
def action11(scheduler, state=None):
subject.on_next(3)
scheduler.schedule_absolute(350, action11)
def action12(scheduler, state=None):
subject.on_next(4)
scheduler.schedule_absolute(450, action12)
def action13(scheduler, state=None):
subject.on_next(5)
scheduler.schedule_absolute(550, action13)
@raises(DisposedException)
def action14(scheduler, state=None):
subject.on_next(6)
scheduler.schedule_absolute(650, action14)
@raises(DisposedException)
def action15(scheduler, state=None):
subject.on_completed()
scheduler.schedule_absolute(750, action15)
@raises(DisposedException)
def action16(scheduler, state=None):
subject.on_error(Exception())
scheduler.schedule_absolute(850, action16)
@raises(DisposedException)
def action17(scheduler, state=None):
subject.subscribe(None)
scheduler.schedule_absolute(950, action17)
scheduler.start()
results1.messages.assert_equal(on_next(201, 1), on_next(251, 2),
on_next(351, 3), on_next(451, 4))
results2.messages.assert_equal(on_next(301, 1), on_next(302, 2),
on_next(351, 3), on_next(451, 4),
on_next(551, 5))
results3.messages.assert_equal(on_next(401, 1), on_next(402, 2),
on_next(403, 3), on_next(451, 4),
on_next(551, 5))
def test_replay_subject_dies_out():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2),
on_next(220, 3), on_next(270, 4),
on_next(340, 5), on_next(410, 6),
on_next(520, 7), on_completed(580))
subject = None
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
results4 = scheduler.create_observer()
def action1(scheduler, state=None):
nonlocal subject
subject = ReplaySubject(sys.maxsize, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
xs.subscribe(subject)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subject.subscribe(results1)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
subject.subscribe(results2)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
subject.subscribe(results3)
scheduler.schedule_absolute(600, action5)
def action6(scheduler, state=None):
subject.subscribe(results4)
scheduler.schedule_absolute(900, action6)
scheduler.start()
results1.messages.assert_equal(on_next(301, 3), on_next(302, 4),
on_next(341, 5), on_next(411, 6),
on_next(521, 7), on_completed(581))
results2.messages.assert_equal(on_next(401, 5), on_next(411, 6),
on_next(521, 7), on_completed(581))
results3.messages.assert_equal(on_next(601, 7), on_completed(602))
results4.messages.assert_equal(on_completed(901))
def test_canceled():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_completed(630), on_next(640, 9),
on_completed(650),
on_error(660, RxException()))
subject = None
subscription = None
subscription1 = None
subscription2 = None
subscription3 = None
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
nonlocal subject
subject = ReplaySubject(3, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
nonlocal subscription
subscription = xs.subscribe(subject)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription.dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
nonlocal subscription1
subscription1 = subject.subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
nonlocal subscription2
subscription2 = subject.subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
nonlocal subscription3
subscription3 = subject.subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2.dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3.dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
results1.messages.assert_equal()
results2.messages.assert_equal(on_completed(631))
results3.messages.assert_equal(on_completed(901))
def test_finite():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2),
on_next(220, 3), on_next(270, 4),
on_next(340, 5), on_next(410, 6),
on_next(520, 7), on_completed(630),
on_next(640, 9), on_completed(650),
on_error(660, 'ex'))
subject = None
subscription = None
subscription1 = None
subscription2 = None
subscription3 = None
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
nonlocal subject
subject = ReplaySubject(3, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action3(scheduler, state=None):
nonlocal subscription
subscription = xs.subscribe(subject)
scheduler.schedule_absolute(200, action3)
def action4(scheduler, state=None):
subscription.dispose()
scheduler.schedule_absolute(1000, action4)
def action5(scheduler, state=None):
nonlocal subscription1
subscription1 = subject.subscribe(results1)
scheduler.schedule_absolute(300, action5)
def action6(scheduler, state=None):
nonlocal subscription2
subscription2 = subject.subscribe(results2)
scheduler.schedule_absolute(400, action6)
def action7(scheduler, state=None):
nonlocal subscription3
subscription3 = subject.subscribe(results3)
scheduler.schedule_absolute(900, action7)
def action8(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(600, action8)
def action9(scheduler, state=None):
subscription2.dispose()
scheduler.schedule_absolute(700, action9)
def action10(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(800, action10)
def action11(scheduler, state=None):
subscription3.dispose()
scheduler.schedule_absolute(950, action11)
scheduler.start()
results1.messages.assert_equal(on_next(301, 3), on_next(302, 4),
on_next(341, 5), on_next(411, 6),
on_next(521, 7))
results2.messages.assert_equal(on_next(401, 5), on_next(411, 6),
on_next(521, 7), on_completed(631))
results3.messages.assert_equal(on_completed(901))
def test_publish_dispose(self):
connection = [None]
subscription = [None]
ys = [None]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3),
on_next(280, 4), on_next(290, 1),
on_next(340, 8), on_next(360, 5),
on_next(370, 6), on_next(390, 7),
on_next(410, 13), on_next(430, 2),
on_next(450, 9), on_next(520, 11),
on_next(560, 20),
on_completed(600))
results = scheduler.create_observer()
def action0(scheduler, state):
ys[0] = xs.publish()
scheduler.schedule_absolute(created, action0)
def action1(scheduler, state):
subscription[0] = ys[0].subscribe(results)
scheduler.schedule_absolute(subscribed, action1)
def action2(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(350, action2)
def action3(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(550, action6)
def action7(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(650, action7)
def action8(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(800, action8)
scheduler.start()
results.messages.assert_equal(on_next(340, 8))
xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 550),
subscribe(650, 800))
def test_error():
scheduler = TestScheduler()
ex = RxException('ex')
xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2),
on_next(220, 3), on_next(270, 4),
on_next(340, 5), on_next(410, 6),
on_next(520, 7), on_error(630, ex),
on_next(640, 9), on_completed(650),
on_error(660, RxException('ex')))
subject = [None]
subscription = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
subject[0] = ReplaySubject(3, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
subscription[0] = xs.subscribe(subject[0])
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
subscription1[0] = subject[0].subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
subscription2[0] = subject[0].subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
subscription3[0] = subject[0].subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
results1.messages.assert_equal(on_next(301, 3), on_next(302, 4),
on_next(341, 5), on_next(411, 6),
on_next(521, 7))
results2.messages.assert_equal(on_next(401, 5), on_next(411, 6),
on_next(521, 7), on_error(631, ex))
results3.messages.assert_equal(on_error(901, ex))
def test_subject_disposed():
scheduler = TestScheduler()
subject = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
subject[0] = ReplaySubject(scheduler=scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
subscription1[0] = subject[0].subscribe(results1)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription2[0] = subject[0].subscribe(results2)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
subscription3[0] = subject[0].subscribe(results3)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(500, action5)
def action6(scheduler, state=None):
subject[0].dispose()
scheduler.schedule_absolute(600, action6)
def action7(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action7)
def action8(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(800, action8)
def action9(scheduler, state=None):
subject[0].on_next(1)
scheduler.schedule_absolute(150, action9)
def action10(scheduler, state=None):
subject[0].on_next(2)
scheduler.schedule_absolute(250, action10)
def action11(scheduler, state=None):
subject[0].on_next(3)
scheduler.schedule_absolute(350, action11)
def action12(scheduler, state=None):
subject[0].on_next(4)
scheduler.schedule_absolute(450, action12)
def action13(scheduler, state=None):
subject[0].on_next(5)
scheduler.schedule_absolute(550, action13)
@raises(DisposedException)
def action14(scheduler, state=None):
subject[0].on_next(6)
scheduler.schedule_absolute(650, action14)
@raises(DisposedException)
def action15(scheduler, state=None):
subject[0].on_completed()
scheduler.schedule_absolute(750, action15)
@raises(DisposedException)
def action16(scheduler, state=None):
subject[0].on_error(Exception())
scheduler.schedule_absolute(850, action16)
@raises(DisposedException)
def action17(scheduler, state=None):
subject[0].subscribe(None)
scheduler.schedule_absolute(950, action17)
scheduler.start()
assert results1.messages == [
on_next(200, 1),
on_next(250, 2),
on_next(350, 3),
on_next(450, 4)]
assert results2.messages == [
on_next(300, 1),
on_next(300, 2),
on_next(350, 3),
on_next(450, 4),
on_next(550, 5)]
assert results3.messages == [
on_next(400, 1),
on_next(400, 2),
on_next(400, 3),
on_next(450, 4),
on_next(550, 5)]
def test_group_by_inner_error():
ex = 'ex1'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(90, "error"),
on_next(110, "error"),
on_next(130, "error"),
on_next(220, " foo"),
on_next(240, " FoO "),
on_next(270, "baR "),
on_next(310, "foO "),
on_next(350, " Baz "),
on_next(360, " qux "),
on_next(390, " bar"),
on_next(420, " BAR "),
on_next(470, "FOO "),
on_next(480, "baz "),
on_next(510, " bAZ "),
on_next(530, " fOo "),
on_error(570, ex),
on_next(580, "error"),
on_completed(600),
on_error(650, 'ex'))
outer_subscription = None
inner_subscriptions = {}
inners = {}
outer = None
results = {}
result = None
def action1(scheduler, state):
nonlocal outer
outer = xs.group_by(lambda x: x.lower().strip(), lambda x: x[::-1])
return outer
scheduler.schedule_absolute(created, action1)
def action2(scheduler, state):
nonlocal outer_subscription
def on_next(group):
nonlocal result, inners, results
result = scheduler.create_observer()
inners[group.key] = group
results[group.key] = result
def action3(scheduler, state):
nonlocal inner_subscriptions
inner_subscriptions[group.key] = group.subscribe(result)
scheduler.schedule_relative(100, action3)
outer_subscription = outer.subscribe(on_next, lambda e: None)
return outer_subscription
scheduler.schedule_absolute(subscribed, action2)
def action4(scheduler, state):
outer_subscription.dispose()
for sub in inner_subscriptions.values():
sub.dispose()
scheduler.schedule_absolute(disposed, action4)
scheduler.start()
assert (len(inners) == 4)
#results['foo'].messages.assert_equal(on_next(470, " OOF"), on_next(530, " oOf "), on_error(570, ex))
#results['bar'].messages.assert_equal(on_next(390, "rab "), on_next(420, " RAB "), on_error(570, ex))
#results['baz'].messages.assert_equal(on_next(480, " zab"), on_next(510, " ZAb "), on_error(570, ex))
#results['qux'].messages.assert_equal(on_error(570, ex))
xs.subscriptions.assert_equal(subscribe(200, 570))
def test_error():
s = None
subscription = None
subscription1 = None
subscription2 = None
subscription3 = None
ex = 'ex'
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2),
on_next(220, 3), on_next(270, 4),
on_next(340, 5), on_next(410, 6),
on_next(520, 7), on_error(630, ex),
on_next(640, 9), on_completed(650),
on_error(660, 'foo'))
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action(scheduler, state=None):
nonlocal s
s = Subject()
scheduler.schedule_absolute(100, action)
def action1(scheduler, state=None):
nonlocal subscription
subscription = xs.subscribe(s)
scheduler.schedule_absolute(200, action1)
def action2(scheduler, state=None):
subscription.dispose()
scheduler.schedule_absolute(1000, action2)
def action3(scheduler, state=None):
nonlocal subscription1
subscription1 = s.subscribe(results1)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
nonlocal subscription2
subscription2 = s.subscribe(results2)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
nonlocal subscription3
subscription3 = s.subscribe(results3)
scheduler.schedule_absolute(900, action5)
def action6(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(600, action6)
def action7(scheduler, state=None):
subscription2.dispose()
scheduler.schedule_absolute(700, action7)
def action8(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(800, action8)
def action9(scheduler, state=None):
subscription3.dispose()
scheduler.schedule_absolute(950, action9)
scheduler.start()
results1.messages.assert_equal(on_next(340, 5), on_next(410, 6),
on_next(520, 7))
results2.messages.assert_equal(on_next(410, 6), on_next(520, 7),
on_error(630, ex))
results3.messages.assert_equal(on_error(900, ex))
def test_canceled():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_completed(630),
on_next(640, 9),
on_completed(650),
on_error(660, RxException())
)
subject = [None]
subscription = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
subject[0] = ReplaySubject(3, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
subscription[0] = xs.subscribe(subject[0])
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
subscription1[0] = subject[0].subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
subscription2[0] = subject[0].subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
subscription3[0] = subject[0].subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
assert results1.messages == []
assert results2.messages == [
on_completed(630)]
assert results3.messages == [
on_completed(900)]
def test_connectable_observable_multiple_non_overlapped_connections(self):
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(210, 1),
on_next(220, 2),
on_next(230, 3),
on_next(240, 4),
on_next(250, 5),
on_next(260, 6),
on_next(270, 7),
on_next(280, 8),
on_next(290, 9),
on_completed(300)
)
subject = Subject()
conn = xs.pipe(ops.multicast(subject))
c1 = [None]
def action10(scheduler, state):
c1[0] = conn.connect(scheduler)
scheduler.schedule_absolute(225, action10)
def action11(scheduler, state):
c1[0].dispose()
scheduler.schedule_absolute(241, action11)
def action12(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(245, action12)
def action13(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(251, action13)
def action14(scheduler, state):
c1[0].dispose() # idempotency test
scheduler.schedule_absolute(260, action14)
c2 = [None]
def action20(scheduler, state):
c2[0] = conn.connect(scheduler)
scheduler.schedule_absolute(249, action20)
def action21(scheduler, state):
c2[0].dispose()
scheduler.schedule_absolute(255, action21)
def action22(scheduler, state):
c2[0].dispose() # idempotency test
scheduler.schedule_absolute(265, action22)
def action23(scheduler, state):
c2[0].dispose() # idempotency test
scheduler.schedule_absolute(280, action23)
c3 = [None]
def action30(scheduler, state):
c3[0] = conn.connect(scheduler)
scheduler.schedule_absolute(275, action30)
def action31(scheduler, state):
c3[0].dispose()
scheduler.schedule_absolute(295, action31)
res = scheduler.start(lambda: conn)
assert res.messages == [
on_next(230, 3),
on_next(240, 4),
on_next(250, 5),
on_next(280, 8),
on_next(290, 9)]
assert xs.subscriptions == [
subscribe(225, 241),
subscribe(249, 255),
subscribe(275, 295)]
def test_replay_subject_dies_out():
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(
on_next(70, 1),
on_next(110, 2),
on_next(220, 3),
on_next(270, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7),
on_completed(580)
)
subject = [None]
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
results4 = scheduler.create_observer()
def action1(scheduler, state=None):
subject[0] = ReplaySubject(sys.maxsize, 100, scheduler)
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
xs.subscribe(subject[0])
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subject[0].subscribe(results1)
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state=None):
subject[0].subscribe(results2)
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state=None):
subject[0].subscribe(results3)
scheduler.schedule_absolute(600, action5)
def action6(scheduler, state=None):
subject[0].subscribe(results4)
scheduler.schedule_absolute(900, action6)
scheduler.start()
assert results1.messages == [
on_next(300, 3),
on_next(300, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7),
on_completed(580)]
assert results2.messages == [
on_next(400, 5),
on_next(410, 6),
on_next(520, 7),
on_completed(580)]
assert results3.messages == [
on_next(600, 7),
on_completed(600)]
assert results4.messages == [
on_completed(900)]
def test_replay_count_complete(self):
connection = [None]
subscription = [None]
ys = [None]
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(110, 7), on_next(220, 3), on_next(280, 4), on_next(290, 1), on_next(340, 8), on_next(360, 5), on_next(370, 6), on_next(390, 7), on_next(410, 13), on_next(430, 2), on_next(450, 9), on_next(520, 11), on_next(560, 20), on_completed(600))
results = scheduler.create_observer()
def action0(scheduler, state):
ys[0] = xs.replay(None, 3, None, scheduler)
scheduler.schedule_absolute(created, action0)
def action1(scehduler, state):
subscription[0] = ys[0].subscribe(results)
scheduler.schedule_absolute(450, action1)
def action2(scheduler, state):
subscription[0].dispose()
scheduler.schedule_absolute(disposed, action2)
def action3(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(300, action3)
def action4(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(400, action4)
def action5(scheduler, state):
connection[0] = ys[0].connect()
scheduler.schedule_absolute(500, action5)
def action(scheduler, state):
connection[0].dispose()
scheduler.schedule_absolute(800, action)
scheduler.start()
results.messages.assert_equal(on_next(451, 5), on_next(452, 6), on_next(453, 7), on_next(521, 11), on_next(561, 20), on_completed(601))
xs.subscriptions.assert_equal(subscribe(300, 400), subscribe(500, 600))
def test_infinite():
subject = None
subscription = None
subscription1 = None
subscription2 = None
subscription3 = None
scheduler = TestScheduler()
xs = scheduler.create_hot_observable(on_next(70, 1), on_next(110, 2),
on_next(220, 3), on_next(270, 4),
on_next(340, 5), on_next(410, 6),
on_next(520, 7), on_next(630, 8),
on_next(710, 9), on_next(870, 10),
on_next(940, 11), on_next(1020, 12))
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
nonlocal subject
subject = AsyncSubject()
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
nonlocal subscription
subscription = xs.subscribe(subject)
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription.dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
nonlocal subscription1
subscription1 = subject.subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
nonlocal subscription2
subscription2 = subject.subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
nonlocal subscription3
subscription3 = subject.subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2.dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1.dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3.dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
results1.messages.assert_equal()
results2.messages.assert_equal()
results3.messages.assert_equal()
def test_finite():
scheduler = TestScheduler()
subscription = [None]
subscription1 = [None]
subscription2 = [None]
subscription3 = [None]
s = [None]
xs = scheduler.create_hot_observable(
on_next(70, 1),
on_next(110, 2),
on_next(220, 3),
on_next(270, 4),
on_next(340, 5),
on_next(410, 6),
on_next(520, 7),
on_completed(630),
on_next(640, 9),
on_completed(650),
on_error(660, 'error')
)
results1 = scheduler.create_observer()
results2 = scheduler.create_observer()
results3 = scheduler.create_observer()
def action1(scheduler, state=None):
s[0] = Subject()
scheduler.schedule_absolute(100, action1)
def action2(scheduler, state=None):
subscription[0] = xs.subscribe(s[0])
scheduler.schedule_absolute(200, action2)
def action3(scheduler, state=None):
subscription[0].dispose()
scheduler.schedule_absolute(1000, action3)
def action4(scheduler, state=None):
subscription1[0] = s[0].subscribe(results1)
scheduler.schedule_absolute(300, action4)
def action5(scheduler, state=None):
subscription2[0] = s[0].subscribe(results2)
scheduler.schedule_absolute(400, action5)
def action6(scheduler, state=None):
subscription3[0] = s[0].subscribe(results3)
scheduler.schedule_absolute(900, action6)
def action7(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(600, action7)
def action8(scheduler, state=None):
subscription2[0].dispose()
scheduler.schedule_absolute(700, action8)
def action9(scheduler, state=None):
subscription1[0].dispose()
scheduler.schedule_absolute(800, action9)
def action10(scheduler, state=None):
subscription3[0].dispose()
scheduler.schedule_absolute(950, action10)
scheduler.start()
results1.messages.assert_equal(
on_next(340, 5),
on_next(410, 6),
on_next(520, 7)
)
results2.messages.assert_equal(
on_next(410, 6),
on_next(520, 7),
on_completed(630)
)
results3.messages.assert_equal(
on_completed(900)
)
