public void OAPHShouldFireChangeNotifications() { var input = new[] {1, 2, 3, 3, 4}.ToObservable(); var output = new List<int>(); (new TestScheduler()).With(sched => { var fixture = new ObservableAsPropertyHelper<int>(input, x => output.Add(x), -5); sched.Start(); // Note: Why doesn't the list match the above one? We're supposed // to suppress duplicate notifications, of course :) (new[] { -5, 1, 2, 3, 4 }).AssertAreEqual(output); }); }
public void AsyncGetTest() { var input = new[] { 1, 1, 1, 1, 1 }; var sched = new TestScheduler(); var delay = TimeSpan.FromSeconds(1.0); var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched); int result = 0; input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500))); Assert.Equal(0, result); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1200))); Assert.Equal(25, result); sched.Start(); Assert.Equal(25, result); }
public void MessageBusSmokeTest() { var input = new[] {1, 2, 3, 4}; var result = (new TestScheduler()).With(sched => { var source = new Subject<int>(); var fixture = new MessageBus(); fixture.RegisterMessageSource(source, "Test"); Assert.False(fixture.IsRegistered(typeof (int))); Assert.False(fixture.IsRegistered(typeof (int), "Foo")); var output = fixture.Listen<int>("Test").CreateCollection(); input.Run(source.OnNext); sched.Start(); return output; }); input.AssertAreEqual(result); }
public void CacheShouldQueueOnceWeHitOurConcurrentLimit() { var input = new[] { 1, 2, 3, 4, 1 }; var sched = new TestScheduler(); var delay = TimeSpan.FromSeconds(1.0); var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched); int result = 0; input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500))); Assert.Equal(0, result); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500))); Assert.Equal(1*5 + 2*5 + 1*5, result); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(2500))); Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(5000))); Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result); }
public void GetTest() { (new TestScheduler()).With(sched => { var input = new[] {1, 1, 1, 1, 1}; var delay = TimeSpan.FromSeconds(1.0); var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2); int result = 0; var t = new Thread(() => { // We use this side thread because there's no way to tell // the cache to Run the Test Scheduler. So the side thread // will do the waiting while the main thread advances the // Scheduler foreach (int x in input.Select(x => fixture.Get(x))) { result += x; } }); t.Start(); sched.Start(); sched.AdvanceToMs(500); // NB: The Thread.Sleep is to let our other thread catch up Thread.Sleep(100); Assert.Equal(0, result); sched.AdvanceToMs(1200); Thread.Sleep(100); Assert.Equal(25, result); sched.Start(); t.Join(); Assert.Equal(25, result); }); }
public void ObservableCanExecuteShouldShowUpInCommand() { var input = new[] {true, false, false, true, false, true}; var result = (new TestScheduler()).With(sched => { var can_execute = new Subject<bool>(); var fixture = createCommand(can_execute, sched); var changes_as_observable = fixture.CanExecuteObservable.CreateCollection(); int change_event_count = 0; fixture.CanExecuteChanged += (o, e) => { change_event_count++; }; input.Run(x => { can_execute.OnNext(x); sched.Start(); Assert.Equal(x, fixture.CanExecute(null)); }); // N.B. We check against '5' instead of 6 because we're supposed to // suppress changes that aren't actually changes i.e. false => false sched.AdvanceToMs(10 * 1000); return changes_as_observable; }); input.DistinctUntilChanged().AssertAreEqual(result.ToList()); }
public void MultipleSubscribesShouldntResultInMultipleNotifications() { var input = new[] { 1, 2, 1, 2 }; var sched = new TestScheduler(); var fixture = createCommand(null, sched); var odd_list = new List<int>(); var even_list = new List<int>(); fixture.Where(x => ((int)x) % 2 != 0).Subscribe(x => odd_list.Add((int)x)); fixture.Where(x => ((int)x) % 2 == 0).Subscribe(x => even_list.Add((int)x)); input.Run(x => fixture.Execute(x)); sched.AdvanceToMs(1000); new[]{1,1}.AssertAreEqual(odd_list); new[]{2,2}.AssertAreEqual(even_list); }
public void RegisterMemoizedFunctionSmokeTest() { var input = new[] { 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 }; var output = new[] { 5, 5, 5, 5, 5, 10, 10, 10, 10, 10 }; var sched = new EventLoopScheduler(); var results = new List<Timestamped<int>>(); var start = sched.Now; sched.With(_ => { var fixture = new ReactiveAsyncCommand(null, 5, sched); fixture.RegisterMemoizedFunction(x => { Thread.Sleep(1000); return ((int) x) * 5; }, 50, null, sched) .Timestamp() .Subscribe(x => results.Add(x)); Assert.True(fixture.CanExecute(1)); foreach (var i in input) { Assert.True(fixture.CanExecute(i)); fixture.Execute(i); } Thread.Sleep(2500); }); Assert.Equal(10, results.Count); results.Select(x => x.Timestamp - start) .Run(x => { }); output.AssertAreEqual(results.Select(x => x.Value)); Assert.False(results.Any(x => x.Timestamp - start > new TimeSpan(0, 0, 3))); }
public void MultipleSubscribersShouldntDecrementRefcountBelowZero() { (new TestScheduler()).With(sched => { var fixture = new ReactiveAsyncCommand(); var results = new List<int>(); bool[] subscribers = new[] { false, false, false, false, false }; var output = fixture.RegisterAsyncObservable(_ => Observable.Return(5).Delay(TimeSpan.FromMilliseconds(5000), sched)); output.Subscribe(x => results.Add(x)); Enumerable.Range(0, 5).Run(x => output.Subscribe(_ => subscribers[x] = true)); Assert.True(fixture.CanExecute(null)); fixture.Execute(null); sched.AdvanceToMs(2000); Assert.False(fixture.CanExecute(null)); sched.AdvanceToMs(6000); Assert.True(fixture.CanExecute(null)); Assert.True(results.Count == 1); Assert.True(results[0] == 5); Assert.True(subscribers.All(x => x == true)); }); }
public void GetValueShouldActuallyReturnTheValue() { var input = new[] {"Foo", "Bar", "Baz"}; var output = new List<string>(); var output2 = new List<string>(); (new TestScheduler()).With(sched => { var fixture = new TestFixture(); // Two cases: Changed is guaranteed to *not* set ObservedChange.Value fixture.Changed.Subscribe(x => { output.Add((string) x.GetValue()); }); // ...whereas ObservableForProperty *is* guaranteed to. fixture.ObservableForProperty(x => x.IsOnlyOneWord).Subscribe(x => { output2.Add(x.GetValue()); }); foreach (var v in input) { fixture.IsOnlyOneWord = v; } sched.AdvanceToMs(1000); input.AssertAreEqual(output); input.AssertAreEqual(output2); }); }
public void ValueTest() { var input = new[] {"Foo", "Bar", "Baz"}; IEnumerable<string> output = null; IEnumerable<string> output2 = null; (new TestScheduler()).With(sched => { var fixture = new TestFixture(); // Same deal as above output = fixture.Changed.Value<object, object, string>().CreateCollection(); output2 = fixture.ObservableForProperty(x => x.IsOnlyOneWord).Value().CreateCollection(); foreach (var v in input) { fixture.IsOnlyOneWord = v; } sched.AdvanceToMs(1000); input.AssertAreEqual(output); input.AssertAreEqual(output2); }); }
public void CacheShouldEatExceptionsAndMarshalThemToObservable() { /* This is a bit tricky: * * 5,2 complete at t=1000 simultaneously * 10,0 get queued up, 0 fails immediately (delay() doesn't delay the OnError), * so 10 completes at t=2000 * The 7 completes at t=3000 */ var input = new[] { 5, 2, 10, 0/*boom!*/, 7 }; var sched = new TestScheduler(); Observable.Throw<int>(new Exception("Foo")).Subscribe(x => { Console.WriteLine(x); }, ex => { Console.WriteLine(ex); }, () => { Console.WriteLine("Completed"); }); var delay = TimeSpan.FromSeconds(1.0); var fixture = new ObservableAsyncMRUCache<int, int>(x => (x == 0 ? Observable.Throw<int>(new Exception("Boom!")) : Observable.Return(10 * x)).Delay(delay, sched), 5, 2, null, sched); Exception exception = null; int completed = 0; input.ToObservable() .SelectMany(x => fixture.AsyncGet(x)) .Subscribe(x => { this.Log().InfoFormat("Result = {0}", x); completed++; }, ex => exception = exception ?? ex); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500))); Assert.Null(exception); Assert.Equal(0, completed); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500))); Assert.NotNull(exception); Assert.Equal(2, completed); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(7500))); Assert.NotNull(exception); Assert.Equal(4, completed); this.Log().Info(exception); }
public void CachedValuesTest() { var input = new[] { 1, 2, 1, 3, 1 }; var sched = new TestScheduler(); var delay = TimeSpan.FromSeconds(1.0); var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 2, 2); var results = input.ToObservable().SelectMany(fixture.AsyncGet).CreateCollection(); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500))); Assert.Equal(0, fixture.CachedValues().Count()); sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500))); var output = fixture.CachedValues().ToArray(); Assert.IsTrue(output.Length == 2); Assert.Equal(input.Length, results.Count); }