/// <summary> /// Starts the test scheduler and uses the specified virtual time to create, subscribe and dispose the subscription to the sequence /// obtained through the factory function. Scheduler is passed to the subscription using the provided operator context. /// Default virtual times are used for <see cref="ReactiveTest.Created">factory invocation</see> and <see cref="ReactiveTest.Subscribed">sequence subscription</see>. /// </summary> /// <typeparam name="T">The element type of the observable sequence being tested.</typeparam> /// <param name="scheduler">The scheduler.</param> /// <param name="context">The context.</param> /// <param name="create">Factory method to create an observable sequence.</param> /// <param name="created">The created time.</param> /// <param name="subscribed">The subscribed time.</param> /// <param name="disposed">Virtual time at which to dispose the subscription.</param> /// <param name="recovery">Optional state container to reload state from at subscription time.</param> /// <returns> /// Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active. /// </returns> public static ITestableObserver <T> Start <T>( this TestScheduler scheduler, IOperatorContext context, Func <ISubscribable <T> > create, long created, long subscribed, long disposed, IOperatorStateContainer recovery = null) { if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (create == null) { throw new ArgumentNullException(nameof(create)); } if (created > subscribed) { throw new ArgumentOutOfRangeException(nameof(created)); } if (subscribed > disposed) { throw new ArgumentOutOfRangeException(nameof(subscribed)); } var source = default(ISubscribable <T>); var subscription = default(ISubscription); var observer = scheduler.CreateObserver <T>(); scheduler.ScheduleAbsolute(default(object), created, (s, state) => source = create()); scheduler.ScheduleAbsolute( default(object), subscribed, (s, state) => { subscription = source.Subscribe(observer); var reader = default(IOperatorStateReaderFactory); if (recovery != null) { reader = recovery.CreateReader(); } new SubscriptionInitializeVisitor(subscription).Initialize(context, reader); }); scheduler.ScheduleAbsolute(default(object), disposed, (s, state) => subscription.Dispose()); scheduler.Start(); return(observer); }
/// <summary> /// Starts the test scheduler and uses the specified virtual time to create, subscribe and dispose the subscription to the sequence /// obtained through the factory function. Scheduler is passed to the subscription using the provided operator context. /// Default virtual times are used for <see cref="ReactiveTest.Created">factory invocation</see> and <see cref="ReactiveTest.Subscribed">sequence subscription</see>. /// </summary> /// <typeparam name="T">The element type of the observable sequence being tested.</typeparam> /// <param name="scheduler">The scheduler.</param> /// <param name="create">Factory method to create an observable sequence.</param> /// <param name="created">The created time.</param> /// <param name="subscribed">The subscribed time.</param> /// <param name="disposed">Virtual time at which to dispose the subscription.</param> /// <param name="recovery">Optional state container to reload state from at subscription time.</param> /// <returns> /// Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active. /// </returns> public static ITestableObserver <T> Start <T>( this TestScheduler scheduler, Func <ISubscribable <T> > create, long created, long subscribed, long disposed, IOperatorStateContainer recovery = null) { if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } return(scheduler.Start(scheduler.CreateContext(), create, created, subscribed, disposed, recovery)); }
protected static Recorded <SubscriptionAction> OnSave(long time, IOperatorStateContainer state) { return(new Recorded <SubscriptionAction>(time, new SaveState(state))); }
/// <summary> /// Subscribes the specified source. /// </summary> /// <typeparam name="T">Type of events.</typeparam> /// <param name="source">The source.</param> /// <param name="res">The result observer.</param> /// <param name="context">The context.</param> /// <param name="container">The container.</param> /// <returns>Subscription.</returns> public static ISubscription Subscribe <T>(this ISubscribable <T> source, IObserver <T> res, IOperatorContext context, IOperatorStateContainer container) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (container == null) { throw new ArgumentNullException(nameof(container)); } ISubscription sub = source.Subscribe(res); new SubscriptionInitializeVisitor(sub).Initialize(context, container.CreateReader()); return(sub); }
public SaveState(IOperatorStateContainer state) { Type = SubscriptionActionKind.SaveState; _state = state; }