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);
}
