def create(): def subscribe(o, observer=None): d = BooleanDisposable() o.on_next(1) o.on_next(2) def action1(scheduler, state): if not d.is_disposed: o.on_next(3) scheduler.schedule_relative(600, action1) def action2(scheduler, state): if not d.is_disposed: o.on_next(4) scheduler.schedule_relative(700, action2) def action3(scheduler, state): if not d.is_disposed: o.on_next(5) scheduler.schedule_relative(900, action3) def action4(scheduler, state): if not d.is_disposed: o.on_next(6) scheduler.schedule_relative(1100, action4) return d return Observable.create(subscribe)
def create(): def subscribe(o, observer=None): o.on_next(1) o.on_next(2) return Disposable.empty() return Observable.create(subscribe)
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 create(): def subscribe(o, observer=None): o.on_next(1) o.on_next(2) return lambda: None return Observable.create(subscribe)
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_retry_observable_retry_count_throws(self): scheduler1 = TestScheduler() xs = Observable.return_value(1).retry(3) xs.subscribe_(lambda x: _raise('ex'), scheduler=scheduler1) self.assertRaises(RxException, scheduler1.start) scheduler2 = TestScheduler() ys = Observable.throw('ex').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 = Observable.return_value(1).retry(100) zs.subscribe_(on_completed=lambda: _raise('ex'), scheduler=scheduler3) with pytest.raises(RxException): scheduler3.start() xss = Observable.create(lambda o: _raise('ex')).retry(100) with pytest.raises(Exception): xss.subscribe()
def create(): def subscribe(o): is_stopped = [False] o.on_next(1) o.on_next(2) def action1(scheduler, state): if not is_stopped[0]: return o.on_next(3) scheduler.schedule_relative(600, action1) def action2(scheduler, state): if not is_stopped[0]: return o.on_next(4) scheduler.schedule_relative(700, action2) def action3(scheduler, state): if not is_stopped[0]: return o.on_next(5) scheduler.schedule_relative(900, action3) def action4(scheduler, state): if not is_stopped[0]: return o.on_next(6) scheduler.schedule_relative(1100, action4) def dispose(): is_stopped[0] = True return dispose return Observable.create(subscribe)
def create(): def subscribe(o): o.on_next(1) o.on_next(2) return lambda: None return Observable.create(subscribe)
def create(): def subscribe(o): o.on_error(ex) o.on_next(100) o.on_error('foo') o.on_completed() return lambda: None return Observable.create(subscribe)
def create(): def subscribe(o, observer=None): o.on_error(ex) o.on_next(100) o.on_error('foo') o.on_completed() return Disposable.empty() return Observable.create(subscribe)
def factory(): count[0] += 1 def create(obs): def func(): disconnected[0] = True return func return Observable.create(create)
def create(): def subscribe(o, observer=None): o.on_completed() o.on_next(100) o.on_error('ex') o.on_completed() return lambda: None return Observable.create(subscribe)
def create(): def subscribe(o): o.on_error(ex) o.on_next(100) o.on_error("foo") o.on_completed() return lambda: None return Observable.create(subscribe)
def create(): def predicate(x): n[0] += 1 return n[0] < 100 def subscribe(o, scheduler=None): o.on_next(1) o.on_completed() return lambda: None return Observable.while_do(predicate, Observable.create(subscribe))
def create(): import sys sys.setrecursionlimit(1000) def predicate(x): n[0] += 1 return n[0] < 1000 def subscribe(o): o.on_next(1) o.on_completed() return lambda: None return Observable.while_do(predicate, Observable.create(subscribe))
def test_create_observer_throws(self): def subscribe1(o): o.on_next(1) return Disposable.empty() def on_next(x): _raise('ex') with self.assertRaises(RxException): Observable.create(subscribe1).subscribe_(on_next) def subscribe2(o): o.on_error('exception') return Disposable.empty() with self.assertRaises(RxException): Observable.create(subscribe2).subscribe_( on_error=lambda ex: _raise('ex')) def subscribe3(o): o.on_completed() return Disposable.empty() with self.assertRaises(RxException): Observable.create(subscribe3).subscribe_(on_completed=_raise('ex'))
def test_select_throws(self): with self.assertRaises(RxException): Observable.return_value(1) \ .map(lambda x, y: x) \ .subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): Observable.throw_exception('ex') \ .map(lambda x, y: x) \ .subscribe(on_error=lambda ex: _raise(ex)) with self.assertRaises(RxException): Observable.empty() \ .map(lambda x, y: x) \ .subscribe(lambda x: x, lambda ex: ex, lambda: _raise('ex')) def subscribe(observer): _raise('ex') with self.assertRaises(RxException): Observable.create(subscribe) \ .map(lambda x: x) \ .subscribe()
def create(): import sys sys.setrecursionlimit(1000) def predicate(x): n[0] += 1 return n[0] < 1000 def subscribe(o): o.on_next(1) o.on_completed() return lambda: None return Observable.while_do(predicate, Observable.create(subscribe))
def test_select_throws(self): with self.assertRaises(RxException): Observable.return_value(1) \ .map(lambda x, y: x) \ .subscribe(lambda x: _raise("ex")) with self.assertRaises(RxException): Observable.throw_exception('ex') \ .map(lambda x, y: x) \ .subscribe(on_error=lambda ex: _raise(ex)) with self.assertRaises(RxException): Observable.empty() \ .map(lambda x, y: x) \ .subscribe(lambda x: x, lambda ex: ex, lambda: _raise('ex')) def subscribe(observer): _raise('ex') with self.assertRaises(RxException): Observable.create(subscribe) \ .map(lambda x: x) \ .subscribe()
def test_map_throws(self): with self.assertRaises(RxException): Observable.return_value(1) \ .map(mapper_indexed=lambda x, y: x) \ .subscribe_(lambda x: _raise("ex")) with self.assertRaises(RxException): Observable.throw('ex') \ .map(mapper_indexed=lambda x, y: x) \ .subscribe_(on_error=lambda ex: _raise(ex)) with self.assertRaises(RxException): Observable.empty() \ .map(mapper_indexed=lambda x, y: x) \ .subscribe_(lambda x: x, lambda ex: ex, lambda: _raise('ex')) def subscribe(observer, scheduler=None): _raise('ex') with self.assertRaises(RxException): Observable.create(subscribe) \ .map(lambda x: x) \ .subscribe()
def test_select_with_index_throws(self): with self.assertRaises(RxException): return Observable.return_value(1) \ .map(lambda x, index: x) \ .subscribe(lambda x: _raise('ex')) with self.assertRaises(RxException): return Observable.throw_exception('ex') \ .map(lambda x, index: x) \ .subscribe(lambda x: x, lambda ex: _raise(ex)) with self.assertRaises(RxException): return Observable.empty() \ .map(lambda x, index: x) \ .subscribe(lambda x: x, lambda ex: _, lambda : _raise('ex')) with self.assertRaises(RxException): return Observable.create(lambda o: _raise('ex')) \ .map(lambda x, index: x) \ .subscribe()
def test_map_with_index_throws(self): with self.assertRaises(RxException): return Observable.return_value(1) \ .map(mapper_indexed=lambda x, index: x) \ .subscribe_(lambda x: _raise('ex')) with self.assertRaises(RxException): return Observable.throw('ex') \ .map(mapper_indexed=lambda x, index: x) \ .subscribe_(lambda x: x, lambda ex: _raise(ex)) with self.assertRaises(RxException): return Observable.empty() \ .map(lambda x, index: x) \ .subscribe_(lambda x: x, lambda ex: _, lambda : _raise('ex')) with self.assertRaises(RxException): return Observable.create(lambda o: _raise('ex')) \ .map(mapper_indexed=lambda x, index: x) \ .subscribe()
def test_as_observable_isnoteager(self): scheduler = TestScheduler() subscribed = [False] def subscribe(obs): subscribed[0] = True disp = scheduler.create_hot_observable(on_next(150, 1), on_next(220, 2), on_completed(250)).subscribe(obs) def func(): return disp.dispose() return func xs = Observable.create(subscribe) xs.as_observable() assert(not subscribed[0]) def create(): return xs.as_observable() scheduler.start(create) assert(subscribed[0])
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) xss = Observable.create(lambda o: _raise('ex')).retry() self.assertRaises(Exception, xss.subscribe)
def test_as_observable_isnoteager(self): scheduler = TestScheduler() subscribed = [False] def subscribe(obs): subscribed[0] = True disp = scheduler.create_hot_observable(on_next( 150, 1), on_next(220, 2), on_completed(250)).subscribe(obs) def func(): return disp.dispose() return func xs = Observable.create(subscribe) xs.as_observable() assert (not subscribed[0]) def create(): return xs.as_observable() scheduler.start(create) assert (subscribed[0])
def create(): def subscribe(o): is_stopped = [False] o.on_next(1) o.on_next(2) def action1(scheduler, state): if not is_stopped[0]: return o.on_next(3) scheduler.schedule_relative(600, action1) def action2(scheduler, state): if not is_stopped[0]: return o.on_next(4) scheduler.schedule_relative(700, action2) def action3(scheduler, state): if not is_stopped[0]: return o.on_next(5) scheduler.schedule_relative(900, action3) def action4(scheduler, state): if not is_stopped[0]: return o.on_next(6) scheduler.schedule_relative(1100, action4) def dispose(): is_stopped[0] = True return dispose return Observable.create(subscribe)
def test_create_observer_throws(self): def subscribe(o): o.on_next(1) return lambda: None with self.assertRaises(RxException): Observable.create(subscribe).subscribe(lambda x: _raise('ex')) def subscribe2(o): o.on_error('exception') return lambda: None with self.assertRaises(RxException): Observable.create(subscribe2).subscribe(on_error=lambda ex: _raise('ex')) def subscribe3(o): o.on_completed() return lambda: None with self.assertRaises(RxException): Observable.create(subscribe3).subscribe(on_completed=lambda: _raise('ex'))
def test_create_observer_throws(self): def subscribe(o): o.on_next(1) return lambda: None with self.assertRaises(RxException): Observable.create(subscribe).subscribe(lambda x: _raise("ex")) def subscribe2(o): o.on_error("exception") return lambda: None with self.assertRaises(RxException): Observable.create(subscribe2).subscribe(on_error=lambda ex: _raise("ex")) def subscribe3(o): o.on_completed() return lambda: None with self.assertRaises(RxException): Observable.create(subscribe3).subscribe(on_completed=lambda: _raise("ex"))
def test_create_exception(self): with self.assertRaises(RxException): Observable.create(lambda o: _raise('ex')).subscribe()
def test_create_exception(self): with self.assertRaises(RxException): Observable.create(lambda o: _raise("ex")).subscribe()