def test_new_thread_schedule_action(self): scheduler = NewThreadScheduler() ran = False def action(scheduler, state): nonlocal ran ran = True scheduler.schedule(action) sleep(0.1) assert ran is True
def test_new_thread_schedule_action_cancel(self): ran = False scheduler = NewThreadScheduler() def action(scheduler, state): nonlocal ran ran = True d = scheduler.schedule_relative(timedelta(milliseconds=1), action) d.dispose() sleep(0.2) assert ran is False
def test_new_thread_schedule_periodic_cancel(self): scheduler = NewThreadScheduler() period = 0.1 counter = 4 def action(state: int): nonlocal counter if state: counter -= 1 return state - 1 disp = scheduler.schedule_periodic(period, action, counter) sleep(0.4) disp.dispose() assert 0 <= counter < 4
def test_new_thread_schedule_action_due(self): scheduler = NewThreadScheduler() starttime = default_now() endtime = None def action(scheduler, state): nonlocal endtime endtime = default_now() scheduler.schedule_relative(timedelta(milliseconds=200), action) sleep(0.4) assert endtime is not None diff = endtime - starttime assert diff > timedelta(milliseconds=180)
def test_new_thread_now_units(self): scheduler = NewThreadScheduler() diff = scheduler.now sleep(1.1) diff = scheduler.now - diff assert timedelta(milliseconds=1000) < diff < timedelta( milliseconds=1300)
def test_new_thread_schedule_periodic(self): scheduler = NewThreadScheduler() gate = threading.Semaphore(0) period = 0.05 counter = 3 def action(state: int): nonlocal counter if state: counter -= 1 return state - 1 if counter == 0: gate.release() scheduler.schedule_periodic(period, action, counter) gate.acquire() assert counter == 0
from contextlib import contextmanager from typing import Any, Dict, Generator, List, NamedTuple, Optional, Tuple, Union from warnings import warn import reactivex from reactivex import Observable, typing from reactivex.notification import Notification, OnError, OnNext from reactivex.observable.marbles import parse from reactivex.scheduler import NewThreadScheduler from reactivex.typing import Callable, RelativeTime from .reactivetest import ReactiveTest from .recorded import Recorded from .testscheduler import TestScheduler new_thread_scheduler = NewThreadScheduler() class MarblesContext(NamedTuple): start: Callable[[Union[Observable[Any], Callable[[], Observable[Any]]]], List[Recorded[Any]]] cold: Callable[ [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]], Observable[Any], ] hot: Callable[ [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]], Observable[Any], ] exp: Callable[ [str, Optional[Dict[Union[str, float], Any]], Optional[Exception]], List[Recorded[Any]], ]
def test_new_thread_now(self): scheduler = NewThreadScheduler() diff = scheduler.now - default_now() assert abs(diff) < timedelta(milliseconds=5)
import threading from typing import Optional, TypeVar, cast from reactivex.internal.exceptions import SequenceContainsNoElementsError from reactivex.scheduler import NewThreadScheduler from .observable import Observable scheduler = NewThreadScheduler() _T = TypeVar("_T") def run(source: Observable[_T]) -> _T: """Run source synchronously. Subscribes to the observable source. Then blocks and waits for the observable source to either complete or error. Returns the last value emitted, or throws exception if any error occured. Examples: >>> result = run(source) Args: source: Observable source to run. Raises: SequenceContainsNoElementsError: if observable completes (on_completed) without any values being emitted. Exception: raises exception if any error (on_error) occured.