public void RepeatingTimer_Overflow2()
{
ISubscription sub = null;
IOperatorContext context = Scheduler.CreateContext();
var state = Scheduler.CreateStateContainer();
var checkpoints = new[]
{
OnSave(152, state)
};
// Create new subscription allow the timer to fire twice.
var res1 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(100, () => { sub = Subscribable.Timer(TimeSpan.MinValue).Apply(Scheduler, checkpoints).Subscribe(res1, context); });
Scheduler.ScheduleAbsolute(155, () => sub.Dispose());
// Create new subscription and load the state.
var res2 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(200, () => sub = Subscribable.Timer(TimeSpan.MinValue).Subscribe(res2, context, state));
Scheduler.ScheduleAbsolute(255, () => sub.Dispose());
Scheduler.Start();
res1.Messages.AssertEqual(
new[]
{
OnNext(100, 0L),
OnCompleted(100, 0L),
});
res2.Messages.AssertEqual(Array.Empty <Recorded <Notification <long> > >());
}
public void RepeatingTimer_RestoreOlderCheckpoint()
{
var oldState = Scheduler.CreateStateContainer();
var newState = Scheduler.CreateStateContainer();
var checkpoints = new[]
{
OnSave(255, oldState),
OnSave(305, newState),
OnSave(405, newState),
OnLoad(406, oldState)
};
var result = Scheduler.Start(
() => Subscribable.Timer(TimeSpan.Zero, TimeSpan.FromTicks(50)).Apply(Scheduler, checkpoints),
disposed: 460);
result.Messages.AssertEqual(new[]
{
OnNext(Subscribed, 0L),
OnNext(250, 1L),
// Saved old state here
OnNext(300, 2L),
OnNext(350, 3L),
OnNext(400, 4L),
// Loaded old state here
OnNext(450, 2L),
OnNext(450, 3L),
OnNext(450, 4L),
OnNext(450, 5L)
});
}
public void SelectMany_QueryOperator_ThrowResult()
{
Run(client =>
{
var xs = client.CreateHotObservable(
OnNext(220, 4),
OnNext(221, 3),
OnNext(222, 2),
OnNext(223, 5),
OnCompleted <int>(224)
);
var ex = new Exception();
var res = client.Start(() =>
from x in xs
from y in Subscribable.Timer(TimeSpan.FromTicks(1), TimeSpan.FromTicks(1)).Take(x)
select Throw <int>(ex)
);
res.Messages.AssertEqual(
OnError <int>(221, ex)
);
xs.Subscriptions.AssertEqual(
Subscribe(200, 221)
);
});
}
public void OneShotTimer_TimeSpan_OnCompletedObserverThrows()
{
var xs = Subscribable.Timer(TimeSpan.FromTicks(1));
var observer = new OnCompletedThrowsObserver <long>();
var sub = xs.Subscribe(observer, Scheduler.CreateContext());
ReactiveAssert.Throws <InvalidOperationException>(() => Scheduler.Start());
}
public void RepeatingTimer_SimpleSaveAndLoad()
{
ISubscription sub = null;
IOperatorContext context = Scheduler.CreateContext();
var state = Scheduler.CreateStateContainer();
var checkpoints = new[]
{
OnSave(152, state)
};
// Create new subscription allow the timer to fire twice.
var res1 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(100, () => sub = Subscribable.Timer(TimeSpan.Zero, TimeSpan.FromTicks(50)).Apply(Scheduler, checkpoints).Subscribe(res1, context));
Scheduler.ScheduleAbsolute(155, () => sub.Dispose());
// Create new subscription and load the state.
var res2 = Scheduler.CreateObserver <long>();
Scheduler.ScheduleAbsolute(200, () => sub = Subscribable.Timer(TimeSpan.Zero, TimeSpan.FromTicks(50)).Subscribe(res2, context, state));
Scheduler.ScheduleAbsolute(255, () => sub.Dispose());
Scheduler.Start();
res1.Messages.AssertEqual(
new[]
{
OnNext(100, 0L),
OnNext(150, 1L)
});
res2.Messages.AssertEqual(new[]
{
OnNext(200, 2L),
OnNext(250, 3L)
});
}
public static ISubscribable <long> Timer(this TestScheduler scheduler, DateTimeOffset dueTime, TimeSpan period)
{
return(Subscribable.Timer(dueTime, period));
}
public static ISubscribable <long> Timer(this TestScheduler scheduler, TimeSpan dueTime)
{
return(Subscribable.Timer(dueTime));
}
public void OneShotTimer_TimeSpan_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Timer(TimeSpan.Zero, TimeSpan.FromSeconds(-1)));
ReactiveAssert.Throws <ArgumentOutOfRangeException>(() => Subscribable.Timer(DateTimeOffset.Now, TimeSpan.FromSeconds(-1)));
}