public void ConditionalExpression_ObservableTest_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy <bool>()
{
Item = false
};
var test = new ObservingFunc <Dummy <bool>, string>(d => d.Item ? "42" : "23");
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => update = true;
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
result.Detach();
dummy.Item = true;
Assert.IsFalse(update);
result.Attach();
Assert.IsTrue(update);
Assert.AreEqual("42", result.Value);
update = false;
dummy.Item = false;
Assert.IsTrue(update);
}
public void NotifySystem_CheckEntrySemaphore()
{
ObservingFunc <IRoute, bool> func = new ObservingFunc <IRoute, bool>(r => r.Entry != null && r.Entry.Signal == Signal.GO);
var route = RailwayContainer.Routes[0];
var test = func.Observe(route);
test.Successors.SetDummy();
var resultChanged = false;
test.ValueChanged += (o, e) =>
{
resultChanged = true;
Assert.AreEqual(true, e.OldValue);
Assert.AreEqual(false, e.NewValue);
};
Assert.IsTrue(test.Value);
Assert.IsFalse(resultChanged);
route.Entry.Signal = Signal.STOP;
Assert.IsTrue(resultChanged);
Assert.IsFalse(test.Value);
}
public void ConditionalExpression_ObservableFalsePart_Updates()
{
var update = false;
var dummy = new ObservableDummy <bool>()
{
Item = false
};
var dummy2 = new ObservableDummy <string>()
{
Item = "23"
};
var test = new ObservingFunc <Dummy <bool>, string>(d => d.Item ? "23" : dummy2.Item);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldValue);
Assert.AreEqual("42", e.NewValue);
};
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
dummy2.Item = "42";
Assert.IsTrue(update);
Assert.AreEqual("42", result.Value);
}
public void Subtract_ULong_Observable_Update()
{
unchecked
{
var updated = false;
var dummy = new ObservableDummy <ulong>()
{
Item = 5
};
var test = new ObservingFunc <Dummy <ulong>, ulong>(d => d.Item - 3);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(2ul, e.OldValue);
updated = true;
};
Assert.AreEqual(2ul, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.IsTrue(updated);
Assert.AreEqual(42ul, result.Value);
}
}
public void NotifySystem_SemaphoreNeighbor()
{
var connectedRoute = ObservingFunc <IRoute, IRoute> .FromExpression(route =>
(from sensor1 in route.DefinedBy
from te1 in sensor1.Elements
from te2 in te1.ConnectsTo
where te2.Sensor != null && te2.Sensor.Parent != route
select te2.Sensor.Parent as IRoute).Where(r => r != null).FirstOrDefault());
var func = CreateExpression(from route1 in RailwayContainer.Invalids.OfType <Route>().Concat(RailwayContainer.Routes)
let route2 = connectedRoute.Evaluate(route1)
where route2 != null && route2.Entry != route1.Exit
select new { Route1 = route1, Route2 = route2 });
var first = func.FirstOrDefault();
var incremental = func.AsNotifiable();
var changed = false;
incremental.CollectionChanged += (o, e) =>
{
changed = true;
Assert.AreEqual(NotifyCollectionChangedAction.Remove, e.Action);
Assert.AreEqual(1, e.OldItems.Count);
Assert.AreEqual(first, e.OldItems[0]);
};
Assert.IsFalse(changed);
Assert.AreEqual(func.Count(), incremental.Count());
first.Route2.Entry = first.Route1.Exit;
Assert.IsTrue(changed);
Assert.AreEqual(func.Count(), incremental.Count());
}
public void NotifySystem_PosLength()
{
ObservingFunc <RailwayContainer, IEnumerableExpression <ISegment> > func = new ObservingFunc <RailwayContainer, IEnumerableExpression <ISegment> >(
rc =>
from seg in rc.Descendants().OfType <Segment>()
where seg.Length <= 0
select seg);
var test = func.Observe(RailwayContainer);
var resultChanged = false;
test.ValueChanged += (o, e) =>
{
resultChanged = true;
};
var testCollection = test.Value.AsNotifiable();
testCollection.CollectionChanged += (o, e) =>
{
resultChanged = true;
};
Assert.AreEqual(43, testCollection.Count());
Assert.IsFalse(resultChanged);
var first = test.Value.FirstOrDefault();
first.Length = -first.Length + 1;
Assert.AreEqual(42, testCollection.Count());
Assert.IsTrue(resultChanged);
}
public void Subtract_Decimal_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy <decimal>()
{
Item = 5
};
var test = new ObservingFunc <Dummy <decimal>, decimal>(d => d.Item - 3);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(2m, e.OldValue);
updated = true;
};
Assert.AreEqual(2, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.IsTrue(updated);
Assert.AreEqual(42, result.Value);
}
public void MultiplyChecked_Int_NoObservable_NoUpdate()
{
checked
{
var updated = false;
var dummy = new Dummy <int>()
{
Item = 3
};
var test = new ObservingFunc <Dummy <int>, int>(d => d.Item * 7);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
}
}
public void Multiply_Decimal_Observable_Update()
{
unchecked
{
var updated = false;
var dummy = new ObservableDummy <decimal>()
{
Item = 3
};
var test = new ObservingFunc <Dummy <decimal>, decimal>(d => d.Item * 7);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(21m, e.OldValue);
updated = true;
};
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.IsTrue(updated);
Assert.AreEqual(42, result.Value);
}
}
public void MultiplyChecked_Long_Observable_Update()
{
checked
{
var updated = false;
var dummy = new ObservableDummy <long>()
{
Item = 3
};
var test = new ObservingFunc <Dummy <long>, long>(d => d.Item * 7L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(21L, e.OldValue);
updated = true;
};
Assert.AreEqual(21L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.IsTrue(updated);
Assert.AreEqual(42L, result.Value);
}
}
public void ObservableFuncT2_ImplicitOperatorFromNull_ArgumentNullException()
{
Expression <Func <object, object, string> > expression = null;
ObservingFunc <object, object, string> func = expression;
Assert.IsNull(func);
}
public ObservableGroupJoin(INotifyEnumerable <TOuter> outerSource, IEnumerable <TInner> innerSource, ObservingFunc <TOuter, TKey> outerKeySelector, ObservingFunc <TInner, TKey> innerKeySelector, ObservingFunc <TOuter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
{
if (outerSource == null)
{
throw new ArgumentNullException("outerSource");
}
if (innerSource == null)
{
throw new ArgumentNullException("innerSource");
}
if (outerKeySelector == null)
{
throw new ArgumentNullException("outerKeySelector");
}
if (innerKeySelector == null)
{
throw new ArgumentNullException("innerKeySelector");
}
if (resultSelector == null)
{
throw new ArgumentNullException("resultSelector");
}
this.outerSource = outerSource;
this.innerSource = innerSource;
this.outerKeySelector = outerKeySelector;
this.innerKeySelector = innerKeySelector;
this.resultSelector = resultSelector;
groups = new Dictionary <TKey, KeyGroup>(comparer);
Attach();
}
public void MultiplyChecked_Int_Observable_Update()
{
checked
{
var updated = false;
var dummy = new ObservableDummy<int>() { Item = 3 };
var test = new ObservingFunc<Dummy<int>, int>(d => d.Item * 7);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(21, e.OldValue);
updated = true;
};
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.IsTrue(updated);
Assert.AreEqual(42, result.Value);
}
}
public void ConditionalExpression_ObservableTest_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<bool>() { Item = false };
var test = new ObservingFunc<Dummy<bool>, string>(d => d.Item ? "42" : "23");
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => update = true;
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
result.Detach();
dummy.Item = true;
Assert.IsFalse(update);
result.Attach();
Assert.IsTrue(update);
Assert.AreEqual("42", result.Value);
update = false;
dummy.Item = false;
Assert.IsTrue(update);
}
public void ConditionalExpression_NoObservableTruePart_NoUpdates()
{
var update = false;
var dummy = new ObservableDummy <bool>()
{
Item = true
};
var dummy2 = new Dummy <string>()
{
Item = "23"
};
var test = new ObservingFunc <Dummy <bool>, string>(d => d.Item ? dummy2.Item : "23");
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => update = true;
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
dummy2.Item = "42";
Assert.IsFalse(update);
}
public void SubtractChecked_Long_NoObservable_NoUpdate()
{
checked
{
var updated = false;
var dummy = new Dummy <long>()
{
Item = 5
};
var test = new ObservingFunc <Dummy <long>, long>(d => d.Item - 3L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(2L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.AreEqual(2L, result.Value);
Assert.IsFalse(updated);
}
}
public void NotifySystem_CheckSwitchPosition_Generated()
{
ObservingFunc <Generated <ISwitchPosition>, bool> func = new ObservingFunc <Generated <ISwitchPosition>, bool>(swP => swP.Item.Switch.CurrentPosition == swP.Item.Position);
var switchPosition = RailwayContainer.Routes[0].Follows.OfType <ISwitchPosition>().FirstOrDefault();
var test = func.Observe(new Generated <ISwitchPosition>(switchPosition));
var resultChanged = false;
var expectedOld = true;
var expectedNew = false;
test.ValueChanged += (o, e) =>
{
resultChanged = true;
Assert.AreEqual(expectedOld, e.OldValue);
Assert.AreEqual(expectedNew, e.NewValue);
};
Assert.IsTrue(test.Value);
Assert.IsFalse(resultChanged);
switchPosition.Switch.CurrentPosition = Position.LEFT;
Assert.IsTrue(resultChanged);
Assert.IsFalse(test.Value);
resultChanged = false;
expectedOld = false;
expectedNew = true;
switchPosition.Position = Position.LEFT;
Assert.IsTrue(resultChanged);
Assert.IsTrue(test.Value);
}
public void Divide_Long_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy <long>()
{
Item = 16
};
var test = new ObservingFunc <Dummy <long>, long>(d => d.Item / 2L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(8L, e.OldValue);
updated = true;
};
Assert.AreEqual(8L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 84;
Assert.IsTrue(updated);
Assert.AreEqual(42L, result.Value);
}
public LeftGuardedSynchronizationJob(ISynchronizationJob <TLeft, TRight> inner, ObservingFunc <TLeft, bool> guard)
: base(inner)
{
if (guard == null)
{
throw new ArgumentNullException("guard");
}
Guard = guard;
}
public ITransformationRuleDependency CreateRightToLeftOnlyDependency(ObservingFunc <TRight, bool> guard)
{
if (guard != null)
{
return(new GuardedRTLOnlyDependency(this, guard));
}
else
{
return(new RTLOnlyDependency(this));
}
}
public ITransformationRuleDependency CreateLeftToRightOnlyDependency(ObservingFunc <TLeft, bool> guard)
{
if (guard != null)
{
return(new GuardedLTROnlyDependency(this, guard));
}
else
{
return(new LTROnlyDependency(this));
}
}
public SynchronizationSingleDependency(SynchronizationRule <TLeft, TRight> parentRule, SynchronizationRule <TDepLeft, TDepRight> childRule, Expression <Func <TLeft, TDepLeft> > leftSelector, Expression <Func <TRight, TDepRight> > rightSelector, Action <TLeft, TDepLeft> leftSetter, Action <TRight, TDepRight> rightSetter)
{
if (parentRule == null)
{
throw new ArgumentNullException("parentRule");
}
if (childRule == null)
{
throw new ArgumentNullException("childRule");
}
if (leftSelector == null)
{
throw new ArgumentNullException("leftSelector");
}
if (rightSelector == null)
{
throw new ArgumentNullException("rightSelector");
}
this.parentRule = parentRule;
this.childRule = childRule;
this.leftGetter = ExpressionCompileRewriter.Compile(leftSelector);
this.rightGetter = ExpressionCompileRewriter.Compile(rightSelector);
if (leftSetter == null)
{
var leftSetterExp = SetExpressionRewriter.CreateSetter(leftSelector);
if (leftSetterExp != null)
{
this.leftSetter = ExpressionCompileRewriter.Compile(leftSetterExp);
}
this.leftFunc = Observable.Func(leftSelector);
}
else
{
this.leftSetter = leftSetter;
this.leftFunc = Observable.Func(leftSelector, leftSetter);
}
if (rightSetter == null)
{
var rightSetterExp = SetExpressionRewriter.CreateSetter(rightSelector);
if (rightSetterExp != null)
{
this.rightSetter = ExpressionCompileRewriter.Compile(rightSetterExp);
}
this.rightFunc = Observable.Func(rightSelector);
}
else
{
this.rightSetter = rightSetter;
this.rightFunc = Observable.Func(rightSelector, rightSetter);
}
}
public MonotoneTopX(INotifyEnumerable <T> source, ObservingFunc <T, TKey> keySelector, int x, IComparer <TKey> keyComparer)
{
_source = source;
_keySelector = keySelector;
_x = x;
_keyComparer = keyComparer ?? new ReverseComparer <TKey>(Comparer <TKey> .Default);
foreach (var item in _source)
{
AddItem(item);
}
}
public ObservableSelect(INotifyEnumerable <TSource> source, ObservingFunc <TSource, TResult> lambda)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (lambda == null)
{
throw new ArgumentNullException("lambda");
}
this.source = source;
this.lambda = lambda;
}
public ObservableWhere(INotifyEnumerable <T> source, ObservingFunc <T, bool> lambda)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (lambda == null)
{
throw new ArgumentNullException("lambda");
}
this.source = source;
this.lambda = lambda;
}
public ObservableSimpleSelectMany(INotifyEnumerable <TSource> source,
ObservingFunc <TSource, IEnumerable <TResult> > selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
this.source = source;
this.selector = selector;
}
public ObservableThenBy(IOrderableNotifyEnumerable <TItem> source, ObservingFunc <TItem, TKey> keySelector, IComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
this.source = source;
this.keySelector = keySelector;
this.comparer = comparer;
}
public void NotifySystem_CheckSwitchPositionSensor()
{
ObservingFunc <IRoute, ISwitchPosition, bool> func = new ObservingFunc <IRoute, ISwitchPosition, bool>(
(r, swP) => swP.Switch.Sensor != null && !r.DefinedBy.Contains(swP.Switch.Sensor));
var route = RailwayContainer.Routes[0];
var route2 = RailwayContainer.Invalids.OfType <IRoute>().FirstOrDefault();
var switchPosition = route.Follows.OfType <ISwitchPosition>().FirstOrDefault();
var test = func.Observe(route, switchPosition);
test.Successors.SetDummy();
var resultChanged = false;
var expectedOld = false;
var expectedNew = true;
test.ValueChanged += (o, e) =>
{
resultChanged = true;
Assert.AreEqual(expectedOld, e.OldValue);
Assert.AreEqual(expectedNew, e.NewValue);
};
Assert.IsFalse(test.Value);
Assert.IsFalse(resultChanged);
// For this to work, we would need to execute the model changes in a transaction
//var originalSwitch = switchPosition.Switch;
//var newSwitch = route2.DefinedBy[0].Elements.OfType<ISwitch>().FirstOrDefault();
//switchPosition.Switch = newSwitch;
//Assert.IsTrue(resultChanged);
//Assert.IsTrue(test.Value);
//route.DefinedBy.Remove(originalSwitch.Sensor);
//Assert.IsFalse(resultChanged);
//route.DefinedBy.Add(newSwitch.Sensor);
//resultChanged = false;
//expectedOld = true;
//expectedNew = false;
//switchPosition.Switch.Sensor = null;
//Assert.IsTrue(resultChanged);
//Assert.IsFalse(test.Value);
}
public ObservableOrderBy(INotifyEnumerable <TItem> source, ObservingFunc <TItem, TKey> keySelector, IComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
this.source = source;
this.keySelector = keySelector;
this.searchTree = new SortedDictionary <TKey, Collection <TItem> >(comparer);
}
public ObservableGroupBy(INotifyEnumerable <TItem> source, ObservingFunc <TItem, TKey> keySelector, IEqualityComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
this.groups = new Dictionary <TKey, ObservableGroup <TKey, TItem> >(comparer);
this.source = source;
this.keySelector = keySelector;
}
public OneWayPropertySynchronizationJob(Expression <Func <TSource, TValue> > sourceGetter, Action <TTarget, TValue> targetSetter, bool isEarly)
{
if (sourceGetter == null)
{
throw new ArgumentNullException("leftSelector");
}
if (targetSetter == null)
{
throw new ArgumentNullException("rightSelector");
}
sourceFunc = new ObservingFunc <TSource, TValue>(sourceGetter);
this.sourceGetter = sourceGetter.Compile();
this.targetSetter = targetSetter;
this.isEarly = isEarly;
}
public void Divide_Int_NoObservable_NoUpdate()
{
var updated = false;
var dummy = new Dummy<int>() { Item = 16 };
var test = new ObservingFunc<Dummy<int>, int>(d => d.Item / 2);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(8, result.Value);
Assert.IsFalse(updated);
dummy.Item = 84;
Assert.AreEqual(8, result.Value);
Assert.IsFalse(updated);
}
public ObservableOrderBy(INotifyEnumerable <TItem> source, ObservingFunc <TItem, TKey> keySelector, IComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
this.source = source;
this.keySelector = keySelector;
this.searchTree = new SortedDictionary <TKey, ObservableCollection <TItem> >(comparer);
this.manualRaiseSequences = new ManualObservableCollectionView <IEnumerable <TItem> >(searchTree.Values);
Attach();
}
public void LessThanEquals_Int_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<int>() { Item = 1 };
var test = new ObservingFunc<Dummy<int>, bool>(d => d.Item <= 0);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsFalse(result.Value);
Assert.IsFalse(updated);
dummy.Item = -1;
Assert.IsFalse(result.Value);
Assert.IsFalse(updated);
}
public void Equals_Int_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<int>() { Item = 42 };
var test = new ObservingFunc<Dummy<int>, bool>(d => d.Item == 42);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = 23;
Assert.IsFalse(result.Value);
Assert.IsTrue(updated);
}
public void Equals_Class_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<string>() { Item = "42" };
var test = new ObservingFunc<Dummy<string>, bool>(d => d.Item == "42");
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = "23";
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
}
public void GreaterThanEquals_Long_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<long>() { Item = 1 };
var test = new ObservingFunc<Dummy<long>, bool>(d => d.Item >= 0);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = -1;
Assert.IsFalse(result.Value);
Assert.IsTrue(updated);
}
public void MultiplyChecked_Long_NoObservable_NoUpdate()
{
checked
{
var updated = false;
var dummy = new Dummy<long>() { Item = 3 };
var test = new ObservingFunc<Dummy<long>, long>(d => d.Item * 7L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(21L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.AreEqual(21L, result.Value);
Assert.IsFalse(updated);
}
}
public void SubtractChecked_Int_NoObservable_NoUpdate()
{
checked
{
var updated = false;
var dummy = new Dummy<int>() { Item = 5 };
var test = new ObservingFunc<Dummy<int>, int>(d => d.Item - 3);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(2, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.AreEqual(2, result.Value);
Assert.IsFalse(updated);
}
}
public void Divide_Long_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<long>() { Item = 16 };
var test = new ObservingFunc<Dummy<long>, long>(d => d.Item / 2L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(8L, e.OldValue);
updated = true;
};
Assert.AreEqual(8L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 84;
Assert.IsTrue(updated);
Assert.AreEqual(42L, result.Value);
}
public void GreaterThan_Decimal_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<decimal>() { Item = 1 };
var test = new ObservingFunc<Dummy<decimal>, bool>(d => d.Item > 0);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = -1;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
}
public void ConditionalExpression_ObservableFalsePart_Updates()
{
var update = false;
var dummy = new ObservableDummy<bool>() { Item = false };
var dummy2 = new ObservableDummy<string>() { Item = "23" };
var test = new ObservingFunc<Dummy<bool>, string>(d => d.Item ? "23" : dummy2.Item);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldValue);
Assert.AreEqual("42", e.NewValue);
};
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
dummy2.Item = "42";
Assert.IsTrue(update);
Assert.AreEqual("42", result.Value);
}
public void Subtract_Decimal_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<decimal>() { Item = 5 };
var test = new ObservingFunc<Dummy<decimal>, decimal>(d => d.Item - 3);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(2m, e.OldValue);
updated = true;
};
Assert.AreEqual(2, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.IsTrue(updated);
Assert.AreEqual(42, result.Value);
}
public void LessThan_Double_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<double>() { Item = 1 };
var test = new ObservingFunc<Dummy<double>, bool>(d => d.Item < 0);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsFalse(result.Value);
Assert.IsFalse(updated);
dummy.Item = -1;
Assert.IsTrue(result.Value);
Assert.IsTrue(updated);
}
public void ConditionalExpression_NoObservableTruePart_NoUpdates()
{
var update = false;
var dummy = new ObservableDummy<bool>() { Item = true };
var dummy2 = new Dummy<string>() { Item = "23" };
var test = new ObservingFunc<Dummy<bool>, string>(d => d.Item ? dummy2.Item : "23");
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => update = true;
Assert.AreEqual("23", result.Value);
Assert.IsFalse(update);
dummy2.Item = "42";
Assert.IsFalse(update);
}
public void AddChecked_Long_Observable_Update()
{
checked
{
var updated = false;
var dummy = new ObservableDummy<long>() { Item = 5 };
var test = new ObservingFunc<Dummy<long>, long>(d => d.Item + 7L);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(12L, e.OldValue);
updated = true;
};
Assert.AreEqual(12L, result.Value);
Assert.IsFalse(updated);
dummy.Item = 35;
Assert.IsTrue(updated);
Assert.AreEqual(42L, result.Value);
}
}
public void Multiply_Decimal_NoObservable_NoUpdate()
{
unchecked
{
var updated = false;
var dummy = new Dummy<decimal>() { Item = 3 };
var test = new ObservingFunc<Dummy<decimal>, decimal>(d => d.Item * 7);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
dummy.Item = 6;
Assert.AreEqual(21, result.Value);
Assert.IsFalse(updated);
}
}
public void OrElse_Boolean_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<bool>() { Item = true };
var test = new ObservingFunc<Dummy<bool>, bool>(d => d.Item || false);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = false;
Assert.IsFalse(result.Value);
Assert.IsTrue(updated);
}
public void ObservableFuncT4_ExplicitFromNull_ArgumentNullException()
{
Expression<Func<object, object, object, object, string>> expression = null;
ObservingFunc<object, object, object, object, string> func = new ObservingFunc<object, object, object, object, string>(expression);
}
public void Subtract_ULong_Observable_Update()
{
unchecked
{
var updated = false;
var dummy = new ObservableDummy<ulong>() { Item = 5 };
var test = new ObservingFunc<Dummy<ulong>, ulong>(d => d.Item - 3);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) =>
{
Assert.AreEqual(2ul, e.OldValue);
updated = true;
};
Assert.AreEqual(2ul, result.Value);
Assert.IsFalse(updated);
dummy.Item = 45;
Assert.IsTrue(updated);
Assert.AreEqual(42ul, result.Value);
}
}
public void GreaterThanEquals_UInt_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<uint>() { Item = 2 };
var test = new ObservingFunc<Dummy<uint>, bool>(d => d.Item >= 1);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = 0;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
}
public void TypeAs_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<object>() { Item = "42" };
var test = new ObservingFunc<Dummy<object>, string>(d => d.Item as string);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual("42", result.Value);
Assert.IsFalse(updated);
dummy.Item = 42;
Assert.IsTrue(updated);
Assert.IsNull(result.Value);
}
public void TypeIs_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<object>() { Item = "42" };
var test = new ObservingFunc<Dummy<object>, bool>(d => d.Item is string);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
dummy.Item = 42;
Assert.IsTrue(result.Value);
Assert.IsFalse(updated);
}
public void LessThan_ULong_NoObservable_NoUpdates()
{
var updated = false;
var dummy = new Dummy<ulong>() { Item = 2 };
var test = new ObservingFunc<Dummy<ulong>, bool>(d => d.Item < 1);
var result = test.Observe(dummy);
result.ValueChanged += (o, e) => updated = true;
Assert.IsFalse(result.Value);
Assert.IsFalse(updated);
dummy.Item = 0;
Assert.IsFalse(result.Value);
Assert.IsFalse(updated);
}
