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