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 bool Remove(T item)
{
var result = original.Remove(item);
ReactiveManager.WasChanged(this);
return(result);
}
public void CollectionModifiedRegression()
{
var source = new object();
var dependent = new LambdaListener();
var secondDependent = new LambdaListener();
dependent.OnNotify = () =>
{
ReactiveManager.Evaluate(secondDependent, () =>
{
ReactiveManager.WasRead(dependent);
return(true);
});
dependent.OnNotify = null;
ReactiveManager.WasChanged(dependent);
};
ReactiveManager.Evaluate(dependent, () =>
{
ReactiveManager.WasRead(source);
return(true);
});
ReactiveManager.WasChanged(source);
}
public void TestDisenabler()
{
var source = new object();
var expression = new ReactiveExpression <bool>(() =>
{
ReactiveManager.WasRead(source);
return(true);
});
int notifications = 0;
int expectation = 1;
using (new ReactiveDisenabler())
{
expression.Subscribe(getValue => Const(getValue, () => notifications++));
}
expression.Evaluate();
ReactiveManager.WasChanged(source);
Assert.AreEqual(++expectation, notifications);
using (new ReactiveDisenabler())
{
ReactiveManager.WasChanged(source);
Assert.AreEqual(expectation, notifications);
using (new ReactiveDisenabler(true))
{
ReactiveManager.WasChanged(source);
Assert.AreEqual(++expectation, notifications);
}
ReactiveManager.WasChanged(source);
Assert.AreEqual(expectation, notifications);
}
ReactiveManager.WasChanged(source);
Assert.AreEqual(++expectation, notifications);
}
void UpdateFrom(int start, int exclusiveTo)
{
for (int changedIndex = start; changedIndex < exclusiveTo; changedIndex++)
{
ReactiveManager.WasChanged(new CompositeReactiveObject(this, changedIndex));
}
ReactiveManager.WasChanged(CountReactiveObject);
}
public override bool Remove(TKey key)
{
var result = original.Remove(key);
ReactiveManager.WasChanged(GetKeyReactive(key));
ReactiveManager.WasChanged(CountAndKeySetReactiveObject);
return(result);
}
public override void Clear()
{
var keys = Keys;
original.Clear();
foreach (var key in keys)
{
ReactiveManager.WasChanged(GetKeyReactive(key));
}
ReactiveManager.WasChanged(CountAndKeySetReactiveObject);
}
/// <inheritdoc />
public sealed override void OnSetValue(LocationInterceptionArgs args)
{
var newValue = args.Value;
var oldValue = args.GetCurrentValue();
if (Equals(newValue, oldValue))
{
return;
}
args.SetNewValue(newValue);
ReactiveManager.WasChanged(new CompositeReactiveObject(args.Instance, property));
}
/// <inheritdoc/>
public sealed override void OnSetValue(LocationInterceptionArgs args)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (this == null) //This is because of the case in TestPropertyAccessDuringConstructionReflection
{
args.ProceedSetValue();
return;
}
args.ProceedSetValue();
ReactiveManager.WasChanged(this);
}
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 TValue this[TKey key]
{
get
{
ReactiveManager.WasRead(GetKeyReactive(key));
return(original[key]);
}
set
{
original[key] = value;
ReactiveManager.WasChanged(GetKeyReactive(key));
}
}
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 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 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);
}
/// <summary>
/// Invalidate the cache manually. Usefull for cases not covered by the Reactive framework.
/// </summary>
public void Invalidate()
{
IsSet = false;
ReactiveManager.WasChanged(this);
}
static void OnResultOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
{
ReactiveManager.WasChanged(sender);
}
public override void Clear()
{
original.Clear();
ReactiveManager.WasChanged(this);
}
private static void CollectionChangedHandler(EventPattern <NotifyCollectionChangedEventArgs> eventPattern)
{
ReactiveManager.WasChanged(eventPattern.Sender);
}
/// <inheritdoc />
public sealed override void OnSetValue(LocationInterceptionArgs args)
{
args.ProceedSetValue();
ReactiveManager.WasChanged(new CompositeReactiveObject(args.Instance, property));
}
public override void Add(TKey key, TValue value)
{
original.Add(key, value);
ReactiveManager.WasChanged(CountAndKeySetReactiveObject);
}