protected IDisposable PerformOneWay(TLeft left, TRight right, ISynchronizationContext context) { IDisposable dependency = null; switch (context.Direction) { case SynchronizationDirection.LeftToRight: case SynchronizationDirection.LeftToRightForced: var leftEx1 = leftFunc.Observe(left); leftEx1.Successors.SetDummy(); rightSetter(right, leftEx1.Value); dependency = new PropertySynchronization <TValue>(leftEx1, val => rightSetter(right, val)); break; case SynchronizationDirection.RightToLeft: case SynchronizationDirection.RightToLeftForced: var rightEx2 = rightFunc.Observe(right); rightEx2.Successors.SetDummy(); leftSetter(left, rightEx2.Value); dependency = new PropertySynchronization <TValue>(rightEx2, val => leftSetter(left, val)); break; case SynchronizationDirection.LeftWins: case SynchronizationDirection.RightWins: TValue leftVal; TValue rightVal; if (context.Direction == SynchronizationDirection.LeftWins) { var leftEx4 = leftFunc.Observe(left); leftEx4.Successors.SetDummy(); leftVal = leftEx4.Value; rightVal = rightGetter(right); dependency = new PropertySynchronization <TValue>(leftEx4, val => rightSetter(right, val)); } else { var rightEx4 = rightFunc.Observe(right); rightEx4.Successors.SetDummy(); leftVal = leftGetter(left); rightVal = rightEx4.Value; dependency = new PropertySynchronization <TValue>(rightEx4, val => leftSetter(left, val)); } var test = context.Direction == SynchronizationDirection.LeftWins ? typeof(TValue).IsValueType || leftVal != null : !(typeof(TValue).IsValueType || rightVal != null); if (test) { rightSetter(right, leftVal); } else { leftSetter(left, rightVal); } break; default: throw new InvalidOperationException(); } return(dependency); }
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); }
private bool AddItem(T item) { var notifiable = _keySelector.Observe(item); _keyDictionary.Add(item, notifiable); _keyDictionaryInverse.Add(notifiable, item); if (IsAttached) { notifiable.Successors.Set(this); } var index = _keys.BinarySearch(notifiable.Value, _keyComparer); if (index < 0) { index = ~index; } if (index < _x) { _keys.Insert(index, notifiable.Value); _items.Insert(index, item); if (_keys.Count > _x) { _keys.RemoveAt(_keys.Count - 1); _items.RemoveAt(_items.Count - 1); } return(true); } return(false); }
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 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); }
protected override void HandleReadyComputation(Computation computation) { var syncComputation = (SynchronizationComputation <TLeft, TRight>)computation; var left = syncComputation.Input; var right = syncComputation.Opposite.Input; switch (syncComputation.SynchronizationContext.ChangePropagation) { case ChangePropagationMode.None: if (guard.Evaluate(left, right)) { parent.CreateLeftToRightSynchronization(syncComputation); } break; case ChangePropagationMode.OneWay: case ChangePropagationMode.TwoWay: var tracker = guard.Observe(left, right); syncComputation.Dependencies.Add(new GuardedSynchronization <TLeft, TRight>(syncComputation, parent.CreateLeftToRightSynchronization, tracker)); break; default: break; } }
protected override void HandleReadyComputation(Computation computation) { var syncComputation = (SynchronizationComputation <TRight, TLeft>)computation; var right = syncComputation.Input; switch (syncComputation.SynchronizationContext.ChangePropagation) { case ChangePropagationMode.None: if (guard.Evaluate(right)) { parent.CreateRightToLeftOnlySynchronization(syncComputation); } break; case ChangePropagationMode.OneWay: case ChangePropagationMode.TwoWay: var tracker = guard.Observe(right); tracker.Successors.SetDummy(); syncComputation.Dependencies.Add(new GuardedSynchronization <TRight, TLeft>(syncComputation, parent.CreateRightToLeftOnlySynchronization, tracker)); break; default: break; } }
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 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 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 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 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 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 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 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 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 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_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 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 NotifySystem_SwitchSet_Full() { ObservingFunc <RailwayContainer, IEnumerableExpression <SwitchPosition> > func = new ObservingFunc <RailwayContainer, IEnumerableExpression <SwitchPosition> >( rc => from route in rc.Routes where route.Entry != null && route.Entry.Signal == Signal.GO from swP in route.Follows.OfType <SwitchPosition>() where swP.Switch.CurrentPosition != swP.Position select swP); var switchPosition = RailwayContainer.Routes[0].Follows.OfType <ISwitchPosition>().FirstOrDefault(); var test = func.Observe(RailwayContainer); test.Successors.SetDummy(); var resultChanged = false; test.ValueChanged += (o, e) => { resultChanged = true; }; var testCollection = test.Value.AsNotifiable(); Assert.AreEqual(3, testCollection.Count()); Assert.IsFalse(resultChanged); }
public ProcessPlate(string name, IEnumerableExpression <ProcessColumn> columns) { Name = name; Columns = columns; AllSamples = columns.SelectMany(c => c.AllSamples); AnyValidSample = _hasValidSample.Observe(this); AnyValidSample.Successors.SetDummy(); }
public ProcessColumn(int column, IEnumerableExpression <ProcessWell> wells) { Column = column; Samples = wells; AllSamples = wells.Select(w => w.Sample); AnyValidSample = _anyNonErrorSample.Observe(this); AnyValidSample.Successors.SetDummy(); }
private void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { if (e.Action != NotifyCollectionChangedAction.Reset) { if (e.Action == NotifyCollectionChangedAction.Remove && e.OldItems != null) { foreach (TItem item in e.OldItems) { Stack <Entry> entryStack = keys[item]; var entry = entryStack.Pop(); if (entryStack.Count == 0) { keys.Remove(item); } DetachItem(item, entry); } } else if (e.Action == NotifyCollectionChangedAction.Add && e.NewItems != null) { foreach (TItem item in e.NewItems) { var key = keySelector.Observe(item); AttachItem(item, key); } } else if (e.Action == NotifyCollectionChangedAction.Replace) { var count = Math.Min(e.NewItems.Count, e.OldItems.Count); for (int i = 0; i < count; i++) { var oldItem = (TItem)e.OldItems[i]; var newItem = (TItem)e.NewItems[i]; ReplaceItem(oldItem, newItem); } } } else { DetachCore(); OnCleared(); } }
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); }
protected IDisposable Perform(TSource source, TTarget target, ISynchronizationContext context) { targetSetter(target, sourceGetter(source)); switch (context.ChangePropagation) { case NMF.Transformations.ChangePropagationMode.None: return(null); case NMF.Transformations.ChangePropagationMode.OneWay: case NMF.Transformations.ChangePropagationMode.TwoWay: return(new PropertySynchronization <TValue>(sourceFunc.Observe(source), val => targetSetter(target, val))); default: throw new InvalidOperationException("Change propagation mode is not supported"); } }
private TResult AttachResult(KeyGroup group, TOuter outer, TInner inner) { var match = new Match(outer, inner); Stack <INotifyValue <TResult> > resultStack; if (!group.Results.TryGetValue(match, out resultStack)) { resultStack = new Stack <INotifyValue <TResult> >(); group.Results.Add(match, resultStack); } var result = resultSelector.Observe(outer, inner); result.ValueChanged += ResultValueChanged; resultStack.Push(result); return(result.Value); }
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 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 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 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); }
private IEnumerable <TResult> AttachItem(TSource item) { Stack <INotifyValue <IEnumerable <TResult> > > stack; if (!results.TryGetValue(item, out stack)) { stack = new Stack <INotifyValue <IEnumerable <TResult> > >(); results.Add(item, stack); } var subSource = selector.Observe(item); stack.Push(subSource); var notifier = subSource.Value as INotifyCollectionChanged; if (notifier != null) { notifier.CollectionChanged += SubSourceCollectionChanged; } subSource.ValueChanged += SubSourceChanged; return(subSource.Value); }
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 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 GreaterThan_ULong_Observable_Update() { var updated = false; var dummy = new ObservableDummy <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.IsTrue(result.Value); Assert.IsFalse(updated); dummy.Item = 0; Assert.IsFalse(result.Value); Assert.IsTrue(updated); }
public void GreaterThan_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.IsTrue(result.Value); Assert.IsFalse(updated); dummy.Item = -1; Assert.IsTrue(result.Value); Assert.IsFalse(updated); }
public void GreaterThanEquals_Decimal_Observable_Update() { var updated = false; var dummy = new ObservableDummy <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.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 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 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 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 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 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 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 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); }
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 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 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 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 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); }