public void TestComplexSink() { var first = new Source(); var second = new Source(); var sink = new ComplexSink(first, second); var counter = 0; var expectation = 1; Assert.AreEqual("zoo", sink.Complex); new ReactiveExpression <string>(() => sink.Complex).Subscribe(value => ReactiveManagerTest.Const(value, () => counter++)); Assert.AreEqual(expectation, counter); second.Woop = true; Assert.AreEqual(++expectation, counter); Assert.AreEqual("bar", sink.Complex); first.Woop = true; Assert.AreEqual("foo", sink.Complex); Assert.AreEqual(++expectation, counter); second.Woop = false; Assert.AreEqual("foo", sink.Complex); Assert.AreEqual(expectation, counter); second.Woop = true; Assert.AreEqual("foo", sink.Complex); Assert.AreEqual(expectation, counter); first.Woop = false; Assert.AreEqual("bar", sink.Complex); Assert.AreEqual(++expectation, counter); second.Woop = false; Assert.AreEqual("zoo", sink.Complex); Assert.AreEqual(++expectation, counter); sink.Source2 = new Source(); Assert.AreEqual("zoo", sink.Complex); Assert.AreEqual(expectation += NotificationWhenDependentChangesToSameValue, counter); }
public void TestIndex() { var reactiveList = new List <int>() { 1, 2, 3, 4 }.ToReactive(); var elementAtIndex2 = Reactive.Expression(() => reactiveList[2]); var counter = 0; elementAtIndex2.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveList[2] = 5; Assert.AreEqual(++expectation, counter); reactiveList[1] = 6; Assert.AreEqual(expectation, counter); reactiveList[3] = 7; Assert.AreEqual(expectation, counter); reactiveList.Add(8); Assert.AreEqual(expectation, counter); reactiveList.RemoveAt(reactiveList.Count - 1); Assert.AreEqual(expectation, counter); reactiveList.RemoveAt(0); Assert.AreEqual(++expectation, counter); }
public void Reactive() { var source1 = new Source(); var source2 = new Source(); var user = new SimpleSink(source1); var counter = 0; var expectation = 1; user.BoopReactive.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); Assert.AreEqual(expectation, counter); Assert.AreEqual(false, user.Boop); source1.Woop = true; Assert.AreEqual(++expectation, counter); Assert.AreEqual(true, user.Boop); source2.Woop = true; Assert.AreEqual(expectation, counter); Assert.AreEqual(true, user.Boop); source1.Woop = false; Assert.AreEqual(++expectation, counter); Assert.AreEqual(false, user.Boop); user.Source = source2; Assert.AreEqual(++expectation, counter); Assert.AreEqual(true, user.Boop); source2.Woop = false; Assert.AreEqual(++expectation, counter); Assert.AreEqual(false, user.Boop); }
public void TestWeakStrongVariable() { var listener = new Listener(); var source = new CompositeReactiveObject(listener, "first"); var sameSource = new CompositeReactiveObject(listener, "first"); var otherSource = new CompositeReactiveObject(listener, "second"); var expression = Reactive.Expression(() => { ReactiveManager.WasRead(source); return(1); }); var listenerValue = expression.Evaluate(); Assert.AreEqual(1, listenerValue); var counter = 0; var expectation = 0; expression.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); Assert.AreEqual(++expectation, counter); ReactiveManager.WasChanged(sameSource); Assert.AreEqual(++expectation, counter); ReactiveManager.WasChanged(otherSource); Assert.AreEqual(expectation, counter); }
public void TestList2() { var sourcesList = new ClassWithList(); var property = new ReactiveExpression <int>(() => sourcesList.Sources.Count); property.Evaluate(); int counter = 0; int expectation = 1; property.Subscribe(s => ReactiveManagerTest.Const(s, () => counter++)); Assert.AreEqual(expectation, counter); var source1 = new Source(); sourcesList.Sources.Add(source1); Assert.AreEqual(++expectation, counter); Assert.AreEqual(1, property.Evaluate()); var source2 = new Source(); sourcesList.Sources.Add(source2); Assert.AreEqual(++expectation, counter); source1.Woop = true; Assert.AreEqual(expectation, counter); }
public void MultipleDependence() { var source = new Source(); var sink = new ReactiveExpression <bool>(() => source.Woop && source.Woop); var counter = 0; var expectation = 1; sink.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); Assert.AreEqual(source.Woop, sink.Evaluate()); Assert.AreEqual(expectation, counter); source.FlipWoop(); Assert.AreEqual(++expectation, counter); }
public void ReactiveVariable() { var test = new Source(); var rx = new ReactiveExpression <string>(() => test.Woop ? "foo" : "bar"); var counter = 0; var expectation = 1; rx.Subscribe(s => ReactiveManagerTest.Const(s, () => counter++)); test.Woop = true; Assert.AreEqual(++expectation, counter); test.Woop = true; Assert.AreEqual(expectation += NotificationWhenSourceChangesToSameValue, counter); test.Woop = false; Assert.AreEqual(++expectation, counter); }
public void TestSinkChain() { var sink = new SinkChain(); var outerCounter = 0; Assert.AreEqual(false, sink.OuterSink); Assert.AreEqual(true, sink.InnerSink); sink.OuterSinkReactive.Skip(1).Subscribe(value => ReactiveManagerTest.Const(value, () => outerCounter++)); Assert.AreEqual(0, outerCounter); sink.Source = true; Assert.AreEqual(true, sink.OuterSink); Assert.AreEqual(false, sink.InnerSink); Assert.AreEqual(1, outerCounter); }
public void TestEnumerator() { var reactiveList = new HashSet <int> { 1, 2, 3, 4 }.ToReactive(); var sumFirstTwo = Reactive.Expression(() => reactiveList.Take(2).Sum()); var counter = 0; sumFirstTwo.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveList.Remove(2); Assert.AreEqual(++expectation, counter); reactiveList.Add(6); Assert.AreEqual(++expectation, counter); reactiveList.Clear(); Assert.AreEqual(++expectation, counter); }
public void TestContains() { var set = new HashSet <int> { 1, 2, 3, 4 }.ToReactive(); var containsTwo = Reactive.Expression(() => set.Contains(2)); var counter = 0; containsTwo.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; set.Remove(2); Assert.AreEqual(++expectation, counter); set.Add(2); Assert.AreEqual(++expectation, counter); set.Clear(); Assert.AreEqual(++expectation, counter); }
public void TestBasics() { var collection = new ObservableCollection <int>(); collection.Add(1); collection.Add(2); collection.Add(3); Func <ObservableCollection <int> > getCollection = () => ReactiveManagerWithList.Evaluate(() => collection); var secondElement = new ReactiveExpression <int>(() => getCollection()[1]); var counter = 0; var expectation = 0; secondElement.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); Assert.AreEqual(++expectation, counter); collection.RemoveAt(2); Assert.AreEqual(++expectation, counter); collection.Add(0); Assert.AreEqual(++expectation, counter); }
public void TestCount() { var reactiveList = new HashSet <int>().ToReactive(); var countExpression = Reactive.Expression(() => reactiveList.Count); var counter = 0; countExpression.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveList.Add(1); Assert.AreEqual(++expectation, counter); reactiveList.Add(2); Assert.AreEqual(++expectation, counter); Assert.AreEqual(expectation, counter); reactiveList.Remove(1); Assert.AreEqual(++expectation, counter); reactiveList.Clear(); Assert.AreEqual(++expectation, counter); }
public void TestEnumerator() { var reactiveList = new Dictionary <int, string> { { 1, "first" }, { 2, "second" }, { 3, "third" }, { 4, "fourth" } }.ToReactive(); var sumFirstTwo = Reactive.Expression(() => reactiveList.Take(2).Sum(kv => kv.Key)); var counter = 0; sumFirstTwo.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveList[3] = "fifth"; Assert.AreEqual(expectation, counter); reactiveList.Add(6, "sixth"); Assert.AreEqual(expectation, counter); reactiveList[1] = "seventh"; Assert.AreEqual(++expectation, counter); reactiveList.Clear(); Assert.AreEqual(++expectation, counter); }
public void TestCount() { var reactiveDictionary = new Dictionary <int, string>().ToReactive(); var countExpression = Reactive.Expression(() => reactiveDictionary.Count); var counter = 0; countExpression.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveDictionary.Add(1, "first"); Assert.AreEqual(++expectation, counter); reactiveDictionary.Add(2, "second"); Assert.AreEqual(++expectation, counter); reactiveDictionary[0] = "third"; Assert.AreEqual(expectation, counter); reactiveDictionary.Remove(2); Assert.AreEqual(++expectation, counter); reactiveDictionary.Clear(); Assert.AreEqual(++expectation, counter); }
public void TestTree() { var bottom1 = new Tree(); var bottom2 = new Tree(); var bottoms1 = new List <Tree> { bottom1, bottom2 }; var mid1 = new Tree(bottoms1); var mid2 = new Tree(); var mids = new List <Tree> { mid1, mid2 }; var top = new Tree(mids); var counter = 0; top.HasSuccessfulBloodReactive.Subscribe(value => ReactiveManagerTest.Const(value, () => counter++)); var expectation = 1; mid2.Successful = true; Assert.AreEqual(++expectation, counter); mid1.Successful = true; Assert.AreEqual(++expectation, counter); mid2.Successful = false; Assert.AreEqual(expectation, counter); Assert.AreEqual(true, top.HasSuccessfulBlood); mid1.Successful = false; Assert.AreEqual(++expectation, counter); Assert.AreEqual(false, top.HasSuccessfulBlood); bottom1.Successful = true; Assert.AreEqual(++expectation, counter); Assert.AreEqual(true, top.HasSuccessfulBlood); bottom2.Successful = true; Assert.AreEqual(expectation, counter); }
public void NestedMultipleDependence() { var source1 = new Source(); var source2 = new Source(); var mid = new ReactiveExpression <bool>(() => source1.Woop ^ source2.Woop, "mid"); var top = new ReactiveExpression <bool>(() => mid.Evaluate() & source1.Woop, "top"); var topCounter = 0; var midCounter = 0; var topExpectation = 1; var midExpectation = 1; top.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => topCounter++)); mid.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => midCounter++)); Assert.AreEqual(topExpectation, topCounter); Assert.AreEqual(midExpectation, midCounter); source1.FlipWoop(); Assert.AreEqual(++topExpectation, topCounter); Assert.AreEqual(++midExpectation, midCounter); source2.FlipWoop(); Assert.AreEqual(++topExpectation, topCounter); Assert.AreEqual(++midExpectation, midCounter); }
public void TestList() { var source1 = new Source(); var source2 = new Source(); var source3 = new Source(); var sourcesList = new ClassWithList(); sourcesList.Sources.Add(source1); sourcesList.Sources.Add(source2); int counter = 0; int expectation = 1; var property = new ReactiveExpression <bool>(() => sourcesList.Sources[1].Woop); property.Evaluate(); property.Subscribe(s => ReactiveManagerTest.Const(s, () => counter++)); source1.Woop = true; Assert.AreEqual(expectation, counter); source2.Woop = true; Assert.AreEqual(true, property.Evaluate()); Assert.AreEqual(++expectation, counter); source1.Woop = false; sourcesList.Sources.Insert(0, source3); Assert.AreEqual(false, property.Evaluate()); Assert.AreEqual(++expectation, counter); source2.Woop = false; source3.Woop = true; Assert.AreEqual(expectation, counter); source1.Woop = true; Assert.AreEqual(true, property.Evaluate()); Assert.AreEqual(++expectation, counter); }
public void TestKey() { var reactiveList = new Dictionary <int, string> { { 1, "first" }, { 2, "second" }, { 3, "third" }, { 4, "fourth" } }.ToReactive(); var countExpression = Reactive.Expression(() => reactiveList[2]); var counter = 0; countExpression.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++)); var expectation = 1; reactiveList[2] = "fifth"; Assert.AreEqual(++expectation, counter); reactiveList[1] = "sixth"; Assert.AreEqual(expectation, counter); reactiveList[3] = "seventh"; Assert.AreEqual(expectation, counter); reactiveList.Add(8, "eight"); Assert.AreEqual(expectation, counter); reactiveList.Remove(8); Assert.AreEqual(expectation, counter); reactiveList.Remove(1); Assert.AreEqual(expectation, counter); }