public void GetValueShouldActuallyReturnTheValue() { var input = new[] {"Foo", "Bar", "Baz"}; var output = new List<string>(); (new TestScheduler()).With(sched => { var fixture = new TestFixture(); // ...whereas ObservableForProperty *is* guaranteed to. fixture.ObservableForProperty(x => x.IsOnlyOneWord).Subscribe(x => { output.Add(x.GetValue()); }); foreach (var v in input) { fixture.IsOnlyOneWord = v; } sched.AdvanceToMs(1000); input.AssertAreEqual(output); }); }
public void ObservableFromDPSmokeTest() { (new TestScheduler()).With(sched => { var input = new[] {"Foo", "Bar", "Baz"}; var fixture = new DepObjFixture(); var output = fixture.ObservableFromDP(x => x.TestString).CreateCollection(); foreach (var v in input) { fixture.TestString = v; } sched.Run(); input.AssertAreEqual(output.Select(x => x.Value)); foreach (var v in output) { Assert.AreEqual(fixture, v.Sender); Assert.AreEqual("TestString", v.PropertyName); } return new Unit(); }); }
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.IsFalse(fixture.IsRegistered(typeof (int))); Assert.IsFalse(fixture.IsRegistered(typeof (int), "Foo")); var output = fixture.Listen<int>("Test").CreateCollection(); input.Run(source.OnNext); sched.Run(); return output; }); input.AssertAreEqual(result); }
public void MakeSureMemoizedReleaseFuncGetsCalled() { var input = new[] { 1, 1, 2, 2, 1, 1, 3, 3 }; var output = new[] { 5, 5, 10, 10, 5, 5, 15, 15 }; var fixture = new ReactiveAsyncCommand(null, 0); var results = new List<Timestamped<int>>(); var released = new List<int>(); fixture.RegisterMemoizedFunction<int>(x => { Thread.Sleep(250); return ((int)x) * 5; }, 2, x => released.Add(x)) .Timestamp() .DebugObservable() .Subscribe(x => results.Add(x)); Assert.IsTrue(fixture.CanExecute(1)); var start = DateTimeOffset.Now; foreach(var i in input) { Assert.IsTrue(fixture.CanExecute(i)); fixture.Execute(i); } Thread.Sleep(1000); this.Log().Info("Timestamp Deltas"); results.Select(x => x.Timestamp - start) .Run(x => this.Log().Info(x)); this.Log().Info("Release list"); released.Run(x => this.Log().Info(x)); output.AssertAreEqual(results.Select(x => x.Value)); Assert.IsTrue(results.Count == 8); Assert.IsTrue(released.Count == 1); Assert.IsTrue(released[0] == 2*5); }
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 = new ReactiveCommand(can_execute, null); var changes_as_observable = new ListObservable<bool>(fixture.CanExecuteObservable); int change_event_count = 0; fixture.CanExecuteChanged += (o, e) => { change_event_count++; }; input.Run(x => { can_execute.OnNext(x); sched.Run(); Assert.AreEqual(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 can_execute.OnCompleted(); sched.Run(); Assert.AreEqual(5, change_event_count); return changes_as_observable; }); input.AssertAreEqual(result.ToList()); }
public void ActionExceptionShouldntPermabreakCommands() { var input = new[] {1,2,3,4}; var fixture = ReactiveCommand.Create(null, x => { if (((int)x) == 2) throw new Exception("Die!"); }); var exception_list = new List<Exception>(); var out_list = new List<int>(); fixture.Subscribe(x => out_list.Add((int)x), ex => exception_list.Add(ex)); bool we_threw = false; foreach (int i in input) { try { fixture.Execute(i); } catch { we_threw = true; if (i != 2) throw; } } Assert.IsTrue(we_threw); input.AssertAreEqual(out_list); // Now, make sure that the command isn't broken fixture.Execute(5); Console.WriteLine(String.Join(",", out_list.Select(x => x.ToString()).ToArray())); Assert.AreEqual(5, out_list.Count); }
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 fixture = new ReactiveAsyncCommand(null, 0); var results = new List<Timestamped<int>>(); fixture.RegisterMemoizedFunction<int>(x => { Thread.Sleep(1000); return ((int)x) * 5; }) .Timestamp() .DebugObservable() .Subscribe(x => results.Add(x)); Assert.IsTrue(fixture.CanExecute(1)); var start = DateTimeOffset.Now; foreach(var i in input) { Assert.IsTrue(fixture.CanExecute(i)); fixture.Execute(i); } Thread.Sleep(2500); Assert.IsTrue(results.Count == 10); this.Log().Info("Timestamp Deltas"); results.Select(x => x.Timestamp - start) .Run(x => this.Log().Info(x)); output.AssertAreEqual(results.Select(x => x.Value)); Assert.IsFalse(results.Any(x => x.Timestamp - start > new TimeSpan(0, 0, 3))); }
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 ReactiveObjectSmokeTest() { #if IOS Assert.Fail("This crashes Mono in a quite spectacular way"); #endif var output_changing = new List<string>(); var output = new List<string>(); var fixture = new TestFixture(); fixture.Changing.Subscribe(x => output_changing.Add(x.PropertyName)); fixture.Changed.Subscribe(x => output.Add(x.PropertyName)); fixture.IsNotNullString = "Foo Bar Baz"; fixture.IsOnlyOneWord = "Foo"; fixture.IsOnlyOneWord = "Bar"; fixture.IsNotNullString = null; // Sorry. fixture.IsNotNullString = null; var results = new[] { "IsNotNullString", "IsOnlyOneWord", "IsOnlyOneWord", "IsNotNullString" }; Assert.AreEqual(results.Length, output.Count); output.AssertAreEqual(output_changing); results.AssertAreEqual(output); }
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.RunToMilliseconds(1000); input.AssertAreEqual(output); input.AssertAreEqual(output2); }); }
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 DerivedCollectionsShouldRaiseListChangedEvents() { var input = new[] { "Foo", "Bar", "Baz", "Bamf" }; var fixture = new ReactiveList<TestFixture>( input.Select(x => new TestFixture() { IsOnlyOneWord = x })); IBindingList output = fixture.CreateDerivedBindingList(new Func<TestFixture, string>(x => x.IsOnlyOneWord)); var capturedEvents = new List<ListChangedEventArgs>(); output.ListChanged += (o, e) => capturedEvents.Add(e); input.AssertAreEqual((IEnumerable<string>)output); fixture.Add(new TestFixture() { IsOnlyOneWord = "Hello" }); Assert.Equal(capturedEvents.Last().ListChangedType,ListChangedType.ItemAdded); Assert.Equal(5, output.Count); Assert.Equal("Hello", output[4]); fixture.RemoveAt(4); Assert.Equal(capturedEvents.Last().ListChangedType, ListChangedType.ItemDeleted); Assert.Equal(4, output.Count); //replacing results in //1 itemdeleted //2 itemadded fixture[1] = new TestFixture() { IsOnlyOneWord = "Goodbye" }; Assert.Equal(4, output.Count); Assert.Equal("Goodbye", output[1]); Assert.Equal(capturedEvents[capturedEvents.Count - 2].ListChangedType, ListChangedType.ItemDeleted); Assert.Equal(capturedEvents[capturedEvents.Count - 1].ListChangedType, ListChangedType.ItemAdded); fixture.Clear(); Assert.Equal(0, output.Count); Assert.Equal(capturedEvents.Last().ListChangedType, ListChangedType.Reset); }
public void DerivedCollectionsShouldFollowBaseCollection() { var input = new[] {"Foo", "Bar", "Baz", "Bamf"}; var fixture = new ReactiveCollection<TestFixture>( input.Select(x => new TestFixture() { IsOnlyOneWord = x })); var output = fixture.CreateDerivedCollection(new Func<TestFixture, string>(x => x.IsOnlyOneWord)); input.AssertAreEqual(output); fixture.Add(new TestFixture() { IsOnlyOneWord = "Hello" }); Assert.Equal(5, output.Count); Assert.Equal(output[4], "Hello"); fixture.RemoveAt(4); Assert.Equal(4, output.Count); fixture[1] = new TestFixture() { IsOnlyOneWord = "Goodbye" }; Assert.Equal(4, output.Count); Assert.Equal(output[1], "Goodbye"); fixture.Clear(); Assert.Equal(0, output.Count); }
public void CreateCollectionWithoutTimer() { var input = new[] {"Foo", "Bar", "Baz", "Bamf"}; var fixture = (new TestScheduler()).With(sched => { var f = input.ToObservable(sched).CreateCollection(); sched.Start(); return f; }); input.AssertAreEqual(fixture); }