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