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 override IEnumerator <T> GetEnumerator()
{
return(original.Select((element, index) =>
{
ReactiveManager.WasRead(new CompositeReactiveObject(this, index));
return element;
}).GetEnumerator());
}
public override IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator()
{
return(original.Select(kv =>
{
ReactiveManager.WasRead(GetKeyReactive(kv.Key));
return kv;
}).GetEnumerator());
}
/// <inheritdoc/>
public sealed override void OnGetValue(LocationInterceptionArgs args)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (this != null) //This is because of the case in TestPropertyAccessDuringConstructionReflection
{
ReactiveManager.WasRead(this);
}
args.ProceedGetValue();
}
public void TestNullCannotBeASource()
{
Assert.Throws <ArgumentNullException>(() =>
{
ReactiveManager.Evaluate(new Dependent("TestNullCannotBeASource"), () =>
{
ReactiveManager.WasRead(null);
return(true);
});
});
}
/// <summary>
/// Get a value from the cache.
/// </summary>
public T Get()
{
if (IsSet)
{
ReactiveManager.WasRead(this);
}
else
{
lastValue = ReactiveManager.Evaluate(this, get);
IsSet = true;
}
return(lastValue);
}
public override TValue this[TKey key]
{
get
{
ReactiveManager.WasRead(GetKeyReactive(key));
return(original[key]);
}
set
{
original[key] = value;
ReactiveManager.WasChanged(GetKeyReactive(key));
}
}
public override T this[int index]
{
get
{
ReactiveManager.WasRead(new CompositeReactiveObject(this, index));
return(original[index]);
}
set
{
original[index] = value;
ReactiveManager.WasChanged(new CompositeReactiveObject(this, index));
}
}
public override bool TryGetValue(TKey key, out TValue value)
{
var result = original.TryGetValue(key, out value);
if (result)
{
ReactiveManager.WasRead(GetKeyReactive(key));
}
else
{
ReactiveManager.WasRead(CountAndKeySetReactiveObject);
}
return(result);
}
static void TestManyToOneDependency()
{
var dependency = new CompositeReactiveObject(new object(), 0);
var dependent = new object();
foreach (var i in Enumerable.Range(0, 100000))
{
ReactiveManager.Evaluate(new CompositeReactiveObject(dependent, i), () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
}
}
public void InfiniteRecursionRegression()
{
var source = new object();
var dependent = new LambdaListener();
dependent.OnNotify = () => ReactiveManager.WasChanged(source);
ReactiveManager.Evaluate(dependent, () =>
{
ReactiveManager.WasRead(source);
return(true);
});
ReactiveManager.WasChanged(source);
}
public void TestExceptionInNotify()
{
var dependent = new ExceptionInNotify();
var dependency = new object();
ReactiveManager.Evaluate(dependent, () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
Assert.Throws <NotSupportedException>(() =>
{
ReactiveManager.WasChanged(dependency);
});
}
public void TestDependentWeakness()
{
var dependency = new object();
foreach (var obj in Enumerable.Range(0, 10000))
{
ReactiveManager.Evaluate(new Dependent(), () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
}
GC.Collect();
Assert.AreEqual(0, ReactiveManager.GetDependents(dependency).Count());
}
public void DependenciesClearedAfterNotify()
{
var notifyCounter = new NotifyCounter();
var source = new object();
ReactiveManager.Evaluate(notifyCounter, () =>
{
ReactiveManager.WasRead(source);
return(true);
});
Assert.AreEqual(0, notifyCounter.Counter);
ReactiveManager.WasChanged(source);
Assert.AreEqual(1, notifyCounter.Counter);
ReactiveManager.WasChanged(source);
Assert.AreEqual(1, notifyCounter.Counter);
}
public void TestExceptionInEvaluate()
{
var dependent = new Dependent("TestExceptionInEvaluate");
Assert.Throws <NotSupportedException>(() =>
{
ReactiveManager.Evaluate <bool>(dependent, () =>
{
throw new NotSupportedException("woeps");
});
});
var dependency = new object();
ReactiveManager.WasRead(dependency);
Assert.AreEqual(0, ReactiveManager.GetDependents(dependency).Count());
}
public sealed override void OnGetValue(LocationInterceptionArgs args)
{
if (IsSet)
{
ReactiveManager.WasRead(this);
args.Value = Value;
}
else
{
Value = ReactiveManager.Evaluate(this, () =>
{
args.ProceedGetValue();
return(args.Value);
});
IsSet = true;
}
}
public void TestRobustAgainstGarbageCollection()
{
var dependency = new CompositeReactiveObject(new object(), 0);
var dependent = new object();
foreach (var i in Enumerable.Range(0, 1000))
{
ReactiveManager.Evaluate(new CompositeReactiveObject(dependent, i.ToString()), () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
}
GC.Collect();
Assert.AreEqual(1000, ReactiveManager.GetDependents(dependency).Count());
}
public void ReactiveManagerForwardThreadSafety()
{
var weak = new object();
var weak2 = new object();
var dependency = new CompositeReactiveObject(weak, 0);
var firsts = Enumerable.Range(0, 1000).Select(i => new CompositeReactiveObject(weak2, i)).ToList();
var first = new Thread(() =>
{
foreach (var obj in firsts)
{
ReactiveManager.Evaluate(obj, () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
}
});
var weak3 = new object();
var seconds = Enumerable.Range(0, 1000).Select(i => new CompositeReactiveObject(weak3, i)).ToList();
var second = new Thread(() =>
{
foreach (var obj in seconds)
{
ReactiveManager.Evaluate(obj, () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
}
});
first.Start();
second.Start();
first.Join();
second.Join();
var dependencyCount = ReactiveManager.GetDependents(dependency).Count();
Assert.AreEqual(2000, dependencyCount);
}
public void TestExceptionInNotifyMultiple()
{
var dependency = new object();
var dependent1 = new ExceptionInNotify();
ReactiveManager.Evaluate(dependent1, () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
var dependent2 = new ExceptionInNotify();
ReactiveManager.Evaluate(dependent2, () =>
{
ReactiveManager.WasRead(dependency);
return(true);
});
Assert.Throws <AggregateException>(() =>
{
ReactiveManager.WasChanged(dependency);
});
}
public void TestSourceEquality()
{
var source1 = new EqualityBasedOnId(1);
var source2 = new EqualityBasedOnId(2);
var source3 = new EqualityBasedOnId(1);
var function = new ReactiveExpression <bool>(() =>
{
ReactiveManager.WasRead(source1);
return(true);
});
var counter = 0;
var expectation = 1;
function.Subscribe(getValue => Const(getValue, () => counter++));
ReactiveManager.WasChanged(source1);
Assert.AreEqual(++expectation, counter);
ReactiveManager.WasChanged(source2);
Assert.AreEqual(expectation, counter);
ReactiveManager.WasChanged(source3);
Assert.AreEqual(expectation, counter);
}
/// <inheritdoc />
public sealed override void OnGetValue(LocationInterceptionArgs args)
{
ReactiveManager.WasRead(new CompositeReactiveObject(args.Instance, property));
args.ProceedGetValue();
}
public override bool ContainsKey(TKey key)
{
ReactiveManager.WasRead(CountAndKeySetReactiveObject);
return(original.ContainsKey(key));
}
public override IEnumerator <T> GetEnumerator()
{
ReactiveManager.WasRead(this);
return(original.GetEnumerator()); //TODO lazyness bug?
}
public override bool Contains(T item)
{
ReactiveManager.WasRead(this);
return(original.Contains(item));
}