public void time_offset_excludes_values_of_exact_offset()
{
var stats = new StatsObserver<IList<int>>();
var valueScheduler = new ManualScheduler();
var bufferScheduler = new ManualScheduler();
DateTimeOffset startTime = DateTimeOffset.UtcNow;
Observable.Range(0, 5, valueScheduler)
.BufferWithTime(TimeSpan.FromMilliseconds(30), TimeSpan.FromMilliseconds(20), bufferScheduler)
.Subscribe(stats);
Assert.IsFalse(stats.NextCalled);
bufferScheduler.Now = startTime.AddMilliseconds(10);
valueScheduler.RunNext();
bufferScheduler.Now = startTime.AddMilliseconds(20); // exact offset value
valueScheduler.RunNext();
bufferScheduler.Now = startTime.AddMilliseconds(30);
valueScheduler.RunNext();
bufferScheduler.RunNext();
bufferScheduler.RunNext();
Assert.AreEqual(2, stats.NextCount);
Assert.AreEqual(1, stats.NextValues[1].Count);
}
public void scheduler_is_used_for_completion_when_take_is_zero()
{
var scheduler = new ManualScheduler();
var stats = new StatsObserver<int>();
new Subject<int>().Take(0, scheduler).Subscribe(stats);
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.IsTrue(stats.CompletedCalled);
}
public void scheduler_is_not_used_when_count_great_than_zero()
{
var scheduler = new ManualScheduler();
var subject = new StatsSubject<int>();
var stats = new StatsObserver<int>();
subject.Take(3, scheduler).Subscribe(stats);
subject.OnNext(0);
subject.OnNext(1);
subject.OnNext(2);
Assert.AreEqual(0, scheduler.QueueSize);
}
public void empty_buffer_is_flushed_on_error()
{
var stats = new StatsObserver<IList<int>>();
var bufferScheduler = new ManualScheduler();
DateTimeOffset startTime = DateTimeOffset.UtcNow;
Observable.Empty<int>().Concat(Observable.Throw<int>(new Exception()))
.BufferWithTime(TimeSpan.FromMilliseconds(30), bufferScheduler)
.Subscribe(stats);
Assert.IsTrue(stats.ErrorCalled);
Assert.AreEqual(1, stats.NextCount);
Assert.AreEqual(0, stats.NextValues[0].Count);
}
public void publishing_is_run_through_publishing_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
obs = Observable.Empty<int>(scheduler);
bool completed = false;
var subs = obs.Subscribe(x => { }, () => completed = true);
Assert.IsFalse(completed);
scheduler.RunAll();
Assert.IsTrue(completed);
}
public void errors_are_sent_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject = new ReplaySubject<int>(scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnError(new Exception());
subject.Subscribe(stats);
Assert.IsFalse(stats.ErrorCalled);
scheduler.RunNext();
Assert.IsTrue(stats.ErrorCalled);
}
public void scheduler_is_used_for_first_subscription()
{
var sourceA = new StatsSubject<int>();
var sourceB = Observable.Empty<int>();
var scheduler = new ManualScheduler();
var stats = new StatsObserver<int>();
sourceA.Concat(sourceB, scheduler).Subscribe(stats);
Assert.AreEqual(0, sourceA.SubscriptionCount);
Assert.AreEqual(1, scheduler.QueueSize);
scheduler.RunNext();
Assert.AreEqual(1, sourceA.SubscriptionCount);
Assert.AreEqual(0, scheduler.QueueSize);
}
public void honours_window_for_replays_with_priority_to_most_recent()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject =
new ReplaySubject<int>(TimeSpan.FromMilliseconds(10), scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
DateTime start = DateTime.UtcNow;
scheduler.Now = start;
subject.OnNext(1);
scheduler.Now = start.AddMilliseconds(5);
subject.OnNext(2);
scheduler.Now = start.AddMilliseconds(10);
subject.OnNext(3);
scheduler.Now = start.AddMilliseconds(11);
subject.Subscribe(stats);
scheduler.RunAll();
Assert.AreEqual(2, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2, 3 }));
Assert.IsFalse(stats.CompletedCalled);
}
public void with_both_window_and_buffer_size_values_can_be_ignored_by_window()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject =
new ReplaySubject<int>(3, TimeSpan.FromMilliseconds(10), scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
DateTime start = DateTime.UtcNow;
scheduler.Now = start; // ignored by window
subject.OnNext(1);
scheduler.Now = start.AddMilliseconds(5);
subject.OnNext(2);
scheduler.Now = start.AddMilliseconds(8);
subject.OnCompleted();
scheduler.Now = start.AddMilliseconds(11);
subject.Subscribe(stats);
scheduler.RunAll();
Assert.AreEqual(1, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2 }));
Assert.IsTrue(stats.CompletedCalled);
}
public void window_includes_onerror()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject =
new ReplaySubject<int>(TimeSpan.FromMilliseconds(10), scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
DateTime start = DateTime.UtcNow;
scheduler.Now = start;
subject.OnNext(1);
scheduler.Now = start.AddMilliseconds(5);
subject.OnNext(2);
scheduler.Now = start.AddMilliseconds(10);
subject.OnError(new Exception());
scheduler.Now = start.AddMilliseconds(11);
subject.Subscribe(stats);
scheduler.RunAll();
Assert.AreEqual(1, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2 }));
Assert.IsTrue(stats.ErrorCalled);
}
public void catch_with_observer_subscribes_to_next_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver<IEvent<EventArgs>> observer = new StatsObserver<IEvent<EventArgs>>();
EventOwner owner = new EventOwner();
var eventObs = Observable.FromEvent<EventArgs>(x => owner.Event += x, x => owner.Event -= x);
Observable.Throw<IEvent<EventArgs>>(new ApplicationException())
.Catch(eventObs, scheduler)
.Subscribe(observer);
scheduler.RunNext();
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunNext();
Assert.IsTrue(owner.HasSubscriptions);
}
public void window_can_pass_complete()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject =
new ReplaySubject<int>(TimeSpan.FromMilliseconds(10), scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
DateTime start = DateTime.UtcNow;
scheduler.Now = start;
subject.OnCompleted();
scheduler.Now = start.AddMilliseconds(11);
subject.Subscribe(stats);
scheduler.RunAll();
Assert.AreEqual(0, stats.NextCount);
Assert.IsFalse(stats.CompletedCalled);
}
public void values_cannot_be_replayed_out_of_order()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject = new ReplaySubject<int>(scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnNext(1);
subject.OnNext(2);
subject.Subscribe(stats);
Assert.IsFalse(stats.NextCalled);
scheduler.RunNext();
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1 }));
subject.OnNext(3);
scheduler.RunNext();
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1, 2 }));
scheduler.RunNext();
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1, 2, 3 }));
subject.OnCompleted();
scheduler.RunNext();
Assert.IsTrue(stats.CompletedCalled);
}
public void replayed_values_are_sent_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject = new ReplaySubject<int>(scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
subject.OnNext(1);
subject.OnNext(2);
subject.OnCompleted();
subject.Subscribe(stats);
Assert.IsFalse(stats.NextCalled);
scheduler.RunNext();
Assert.AreEqual(1, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.AreEqual(2, stats.NextCount);
Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1, 2 }));
Assert.IsFalse(stats.CompletedCalled);
scheduler.RunNext();
Assert.IsTrue(stats.CompletedCalled);
}
public void zero_length_list_is_emitted_when_no_values_are_available()
{
var stats = new StatsObserver<IList<int>>();
var scheduler = new ManualScheduler();
var manObs = Observable.Never<int>()
.BufferWithTime(TimeSpan.FromMilliseconds(1), scheduler)
.Take(1)
.Subscribe(stats);
scheduler.RunNext();
Assert.AreEqual(1, stats.NextCount);
Assert.AreEqual(0, stats.NextValues[0].Count);
}
public void window_can_pass_error()
{
ManualScheduler scheduler = new ManualScheduler();
ReplaySubject<int> subject =
new ReplaySubject<int>(TimeSpan.FromMilliseconds(10), scheduler);
StatsObserver<int> stats = new StatsObserver<int>();
DateTime start = DateTime.UtcNow;
scheduler.Now = start;
subject.OnError(new Exception());
scheduler.Now = start.AddMilliseconds(11);
subject.Subscribe(stats);
scheduler.RunAll();
Assert.IsFalse(stats.ErrorCalled);
}
public void catch_with_observer_subscribes_to_first_through_scheduler()
{
ManualScheduler scheduler = new ManualScheduler();
StatsObserver<IEvent<EventArgs>> observer = new StatsObserver<IEvent<EventArgs>>();
EventOwner owner = new EventOwner();
Observable.FromEvent<EventArgs>(x => owner.Event += x, x => owner.Event -= x)
.Catch(Observable.Empty<IEvent<EventArgs>>(), scheduler)
.Subscribe(observer);
Assert.IsFalse(owner.HasSubscriptions);
scheduler.RunAll();
Assert.IsTrue(owner.HasSubscriptions);
}
