public void ReversableDivide_Double_CorrectResult()
{
var dummy = new ObservableDummy <double>();
SetValue(() => dummy.Item / 7, 6.0);
Assert.AreEqual(42, dummy.Item);
}
public void OrderByDescending_ObservableItemChanges_Update()
{
var update = false;
var dummy1 = new ObservableDummy <int>(1);
var dummy2 = new Dummy <int>(3);
var dummy3 = new Dummy <int>(5);
var coll = new List <Dummy <int> >()
{
dummy1, dummy2, dummy3
};
var test = coll.WithUpdates().OrderByDescending(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.AreSame(dummy1, e.NewItems[0]);
Assert.AreSame(dummy1, e.OldItems[0]);
update = true;
};
test.AssertSequence(dummy3, dummy2, dummy1);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsFalse(update);
dummy1.Item = 4;
Assert.IsTrue(update);
test.AssertSequence(dummy3, dummy1, dummy2);
}
public void Select_ObservableItem_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new List <Dummy <string> >();
var dummy = new ObservableDummy <string>()
{
Item = "23"
};
coll.Add(dummy);
var test = coll.WithUpdates().Select(d => d.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldItems[0]);
};
Assert.IsTrue(Sys.Contains(test, "23"));
Assert.IsFalse(update);
dummy.Item = "42";
Assert.IsTrue(update);
Assert.IsTrue(Sys.Contains(test, "42"));
}
public void OrderByTransaction_ChangeReplace_Update()
{
ExecutionEngine.Current = new SequentialExecutionEngine();
var update = false;
var dummy1 = new ObservableDummy <int>(1);
var dummy2 = new Dummy <int>(3);
var dummy3 = new Dummy <int>(5);
var coll = new NotifyCollection <Dummy <int> >()
{
dummy1, dummy2, dummy3
};
var collCasted = (INotifyCollection <Dummy <int> >)coll;
var newDummy = new Dummy <int>(2);
var test = collCasted.OrderBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
test.AssertSequence(dummy1, dummy2, dummy3);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsFalse(update);
ExecutionEngine.Current.BeginTransaction();
dummy1.Item = 0;
coll[0] = newDummy;
Assert.IsFalse(update);
ExecutionEngine.Current.CommitTransaction();
test.AssertSequence(newDummy, dummy2, dummy3);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsTrue(update);
}
public void ReversableDivide_UInt_CorrectResult()
{
var dummy = new ObservableDummy <uint>();
SetValue(() => dummy.Item / 7, 6u);
Assert.AreEqual(42u, dummy.Item);
}
public void ReversableSubtract_ULong_CorrectResult()
{
var dummy = new ObservableDummy <ulong>();
SetValue(() => dummy.Item - 8, 34ul);
Assert.AreEqual(42ul, dummy.Item);
}
public void ReversableDivide_Float_CorrectResult()
{
var dummy = new ObservableDummy <float>();
SetValue(() => dummy.Item / 7, 6f);
Assert.AreEqual(42, dummy.Item);
}
public void ReversableDivide_Decimal_CorrectResult()
{
var dummy = new ObservableDummy <decimal>();
SetValue(() => dummy.Item / 7, 6m);
Assert.AreEqual(42m, dummy.Item);
}
public void GroupBy_ObservableKeyChangesEraseGroup_Update()
{
var update = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var dummy1 = new Dummy <string>("A");
var dummy2 = new ObservableDummy <string>("B");
coll.Add(dummy1);
coll.Add(dummy2);
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) =>
{
Assert.IsTrue(ContainsGroup(e.OldItems, "B"));
update = true;
};
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "A"), dummy1));
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "B"), dummy2));
Assert.IsFalse(update);
dummy2.Item = "A";
Assert.IsTrue(update);
Assert.AreEqual(1, test.Count());
Assert.IsTrue(Sys.Contains(Sys.Single(test, group => group.Key == "A"), dummy2));
}
public void ReversableSubtractMinuend_Long_CorrectResult()
{
var dummy = new ObservableDummy <long>();
SetValue(() => 76 - dummy.Item, 34L);
Assert.AreEqual(42, dummy.Item);
}
public void ParameterDependency_WrongMemberWorks()
{
var semaphore = new Semaphore {
Id = 42
};
var dummy = new ObservableDummy <Semaphore>(semaphore);
var changed = false;
var test = Observable.Expression(() => WrongMember(dummy.Item));
test.ValueChanged += (o, e) => changed = true;
Assert.IsTrue(test.Value);
Assert.IsFalse(changed);
semaphore.Id = 23;
Assert.IsTrue(test.Value);
Assert.IsFalse(changed);
dummy.Item = new Semaphore {
Id = 23
};
Assert.IsTrue(changed);
Assert.IsFalse(test.Value);
}
public void ReversableSubtract_UInt_CorrectResult()
{
var dummy = new ObservableDummy <uint>();
SetValue(() => dummy.Item - 8, 34u);
Assert.AreEqual(42u, dummy.Item);
}
public void ReversableSubtract_Decimal_CorrectResult()
{
var dummy = new ObservableDummy <decimal>();
SetValue(() => dummy.Item - 8, 34m);
Assert.AreEqual(42, dummy.Item);
}
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 ReversableSubtract_Float_CorrectResult()
{
var dummy = new ObservableDummy <float>();
SetValue(() => dummy.Item - 8, 34f);
Assert.AreEqual(42, dummy.Item);
}
public void WhereOrderByTransaction_ChangeRemove_Update() // Works without Transaction
{
ExecutionEngine.Current = new SequentialExecutionEngine();
var update = false;
var dummy1 = new ObservableDummy <int>(1);
var dummy2 = new Dummy <int>(3);
var dummy3 = new Dummy <int>(5);
var coll = new NotifyCollection <Dummy <int> >()
{
dummy1, dummy2, dummy3
};
var test = coll.Where(d => d.Item > 0).OrderBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
test.AssertSequence(dummy1, dummy2, dummy3);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsFalse(update);
ExecutionEngine.Current.BeginTransaction();
dummy1.Item = 0;
Assert.IsFalse(update);
ExecutionEngine.Current.CommitTransaction();
test.AssertSequence(dummy2, dummy3);
Assert.AreEqual(2, test.Sequences.Count());
Assert.IsTrue(update);
}
public void ReversableDivide2_Int_CorrectResult()
{
var dummy = new ObservableDummy <int>(1);
SetValue(() => 252 / dummy.Item, 6);
Assert.AreEqual(42, dummy.Item);
}
public void ReversableDivide_Long_CorrectResult()
{
var dummy = new ObservableDummy <long>();
SetValue(() => dummy.Item / 7, 6L);
Assert.AreEqual(42, dummy.Item);
}
public void ReversableMultiply_ULong_CorrectResult()
{
var dummy = new ObservableDummy <ulong>();
SetValue(() => dummy.Item * 2, 84ul);
Assert.AreEqual(42ul, dummy.Item);
}
public void SelectMany_ObservableSubSourceItemChanges_Updates()
{
var update = false;
ICollection <Dummy <ICollection <Dummy <string> > > > coll = new List <Dummy <ICollection <Dummy <string> > > >();
var dummy = new ObservableDummy <string>()
{
Item = "23"
};
var dummy2 = new Dummy <ICollection <Dummy <string> > >()
{
Item = new List <Dummy <string> >()
{
dummy
}
};
coll.Add(dummy2);
var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldItems[0]);
Assert.AreEqual("42", e.NewItems[0]);
};
Assert.IsTrue(Sys.Contains(test, "23"));
Assert.IsFalse(update);
dummy.Item = "42";
Assert.IsTrue(update);
Assert.IsTrue(Sys.Contains(test, "42"));
}
public void ListInit_Observable_NoUpdateWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<string>("foo");
var test = Observable.Expression(() => new List<string>() { dummy.Item });
test.ValueChanged += (o, e) => update = true;
Assert.IsTrue(test.Value.Contains("foo"));
Assert.IsFalse(update);
test.Detach();
dummy.Item = "bar";
Assert.IsFalse(update);
Assert.AreEqual(0, test.Value.Count);
test.Attach();
Assert.AreEqual(1, test.Value.Count);
Assert.IsTrue(test.Value.Contains("bar"));
dummy.Item = "42";
Assert.AreEqual(1, test.Value.Count);
Assert.IsTrue(test.Value.Contains("42"));
}
public void ReversableMultiply_Decimal_CorrectResult()
{
var dummy = new ObservableDummy <decimal>();
SetValue(() => dummy.Item * 2, 84m);
Assert.AreEqual(42, dummy.Item);
}
public void AddChecked_Int_Observable_NoUpdateWhenDetached()
{
checked
{
var updated = false;
var dummy = new ObservableDummy<int>() { Item = 5 };
var result = Observable.Expression(() => dummy.Item + 7);
result.ValueChanged += (o, e) => updated = true;
Assert.AreEqual(12, result.Value);
Assert.IsFalse(updated);
result.Detach();
dummy.Item = 35;
Assert.AreEqual(12, result.Value);
Assert.IsFalse(updated);
result.Attach();
Assert.IsTrue(updated);
Assert.AreEqual(42, result.Value);
updated = false;
dummy.Item = 5;
Assert.IsTrue(updated);
}
}
public void New_Observable_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<int>() { Item = 23 };
var test = new NotifyValue<Dummy<int>>(() => new Dummy<int>(dummy.Item));
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual(23, (test.Value as Dummy<int>).Item);
Assert.IsFalse(update);
test.Detach();
dummy.Item = 42;
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.AreEqual(42, test.Value.Item);
update = false;
dummy.Item = 1;
Assert.IsTrue(update);
}
public void WhereSelectOrderByTransaction_RemoveCausingChange_Update() // Works without Transaction
{
ExecutionEngine.Current = new SequentialExecutionEngine();
var update = false;
var dummy1 = new ObservableDummy <int>(1);
var dummy2 = new Dummy <int>(3);
var dummy3 = new Dummy <int>(5);
var coll = new NotifyCollection <Dummy <int> >()
{
dummy1, dummy2, dummy3
};
var test = coll.Where(d => d.Item > 0).Select(d => new Dummy <int>(d.Item * 2)).OrderBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
((IEnumerable <Dummy <int> >)test).Select(d => d.Item).AssertSequence(dummy1.Item * 2, dummy2.Item * 2, dummy3.Item * 2);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsFalse(update);
ExecutionEngine.Current.BeginTransaction();
dummy1.Item = 0;
Assert.IsFalse(update);
ExecutionEngine.Current.CommitTransaction();
// Calling Select directly on test leads to quadrupling of the entries in test
((IEnumerable <Dummy <int> >)test).Select(d => d.Item).AssertSequence(dummy2.Item * 2, dummy3.Item * 2);
Assert.AreEqual(2, test.Sequences.Count());
Assert.IsTrue(update);
}
public void Where_ObservableItem_Updates()
{
var update = false;
ICollection <Dummy <bool> > coll = new List <Dummy <bool> >();
var dummy = new ObservableDummy <bool>()
{
Item = true
};
coll.Add(dummy);
var test = coll.WithUpdates().Where(d => d.Item);
test.CollectionChanged += (o, e) =>
{
update = true;
Assert.AreEqual(dummy, e.OldItems[0]);
};
Assert.IsTrue(Sys.Contains(test, dummy));
Assert.IsFalse(update);
dummy.Item = false;
Assert.IsFalse(test.Any());
Assert.IsTrue(update);
}
public void ReversableMultiply_Float_CorrectResult()
{
var dummy = new ObservableDummy <float>();
SetValue(() => dummy.Item * 2, 84f);
Assert.AreEqual(42, dummy.Item);
}
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 ArrayCreation_Observable_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<int>() { Item = 23 };
var test = new NotifyValue<int[]>(() => new int[dummy.Item]);
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual(23, (test.Value as int[]).Length);
Assert.IsFalse(update);
test.Detach();
dummy.Item = 42;
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.AreEqual(42, test.Value.Length);
update = false;
dummy.Item = 2;
Assert.IsTrue(update);
}
public void OrderBy_ObservableItemChanges_NoUpdateWhenDetached()
{
var update = false;
var dummy1 = new ObservableDummy<int>(1);
var dummy2 = new ObservableDummy<int>(3);
var dummy3 = new ObservableDummy<int>(5);
var coll = new List<Dummy<int>>() { dummy1, dummy2, dummy3 };
var test = coll.WithUpdates().OrderBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
test.AssertSequence(dummy1, dummy2, dummy3);
Assert.AreEqual(3, test.Sequences.Count());
Assert.IsFalse(update);
test.Detach();
update = false;
dummy1.Item = 4;
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
test.AssertSequence(dummy2, dummy1, dummy3);
update = true;
dummy1.Item = 2;
Assert.IsTrue(update);
}
public void All_ObservableItem_Update()
{
var update = false;
var dummy = new ObservableDummy <bool>(true);
var coll = new List <Dummy <bool> >()
{
dummy
};
var test = Observable.Expression(() => coll.WithUpdates().All(d => d.Item));
test.ValueChanged += (o, e) =>
{
Assert.IsTrue((bool)e.OldValue);
Assert.IsFalse((bool)e.NewValue);
update = true;
};
Assert.IsTrue(test.Value);
Assert.IsFalse(update);
dummy.Item = false;
Assert.IsTrue(update);
}
public void ReversableAdd_Int_CorrectResult()
{
var dummy = new ObservableDummy <int>();
SetValue(() => dummy.Item + 2, 44);
Assert.AreEqual(42, dummy.Item);
}
public void MemberInitialization_Observable_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<int>(23);
var test = Observable.Expression(() => new Dummy<int>() { Item = dummy.Item });
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual(23, (test.Value as Dummy<int>).Item);
Assert.IsFalse(update);
test.Detach();
dummy.Item = 42;
Assert.IsFalse(update);
Assert.AreNotSame(dummy, test.Value);
Assert.AreEqual(23, test.Value.Item);
test.Attach();
Assert.AreEqual(42, test.Value.Item);
dummy.Item = 1;
Assert.AreEqual(1, test.Value.Item);
}
public void ReversableMultiply_UInt_CorrectResult()
{
var dummy = new ObservableDummy <uint>();
SetValue(() => dummy.Item * 2, 84u);
Assert.AreEqual(42u, dummy.Item);
}
public void ReversableDivide2_ULong_CorrectResult()
{
var dummy = new ObservableDummy <ulong>(1);
SetValue(() => 252 / dummy.Item, 6ul);
Assert.AreEqual(42ul, dummy.Item);
}
public void Cast_String_Observable_NoUpdatesWhenDetached()
{
var update = false;
var dummy = new ObservableDummy<object>() { Item = "23" };
var test = new NotifyValue<string>(() => (string)dummy.Item);
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual("23", test.Value);
Assert.IsFalse(update);
test.Detach();
dummy.Item = "42";
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.AreEqual("42", test.Value);
update = false;
dummy.Item = "1";
Assert.IsTrue(update);
}
public void OrElse_RightHandThrowsException_NoExceptionOnUpdate()
{
var dummy = new ObservableDummy<bool>(false);
var test = Observable.Expression(() => dummy.Item || ThrowExceptionIf(dummy.Item));
Assert.IsTrue(test.Value);
dummy.Item = true;
Assert.IsTrue(test.Value);
}
public void AndAlso_RightHandThrowsException_NoExceptionOnUpdate()
{
var dummy = new ObservableDummy<bool>(true);
var test = Observable.Expression(() => dummy.Item && ThrowExceptionIf(!dummy.Item));
Assert.IsTrue(test.Value);
dummy.Item = false;
Assert.IsFalse(test.Value);
}
public void GroupBy_ObservableKeyChangesBetweenGroups_Update()
{
var updateGroups = false;
var updateGroupA = false;
var updateGroupB = false;
ICollection <Dummy <string> > coll = new ObservableCollection <Dummy <string> >();
var dummy1 = new Dummy <string>("A");
var dummy2 = new Dummy <string>("B");
var dummyChange = new ObservableDummy <string>("A");
coll.Add(dummy1);
coll.Add(dummy2);
coll.Add(dummyChange);
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) => updateGroups = true;
var groupA = Sys.Single(test, g => g.Key == "A") as ObservableGroup <string, Dummy <string> >;
var groupB = Sys.Single(test, g => g.Key == "B") as ObservableGroup <string, Dummy <string> >;
Assert.IsNotNull(groupA);
Assert.IsNotNull(groupB);
Assert.IsTrue(Sys.Contains(groupA, dummy1));
Assert.IsTrue(Sys.Contains(groupA, dummyChange));
Assert.IsTrue(Sys.Contains(groupB, dummy2));
Assert.IsFalse(updateGroups);
var notifierA = groupA as INotifyCollectionChanged;
var notifierB = groupB as INotifyCollectionChanged;
Assert.IsNotNull(notifierA);
Assert.IsNotNull(notifierB);
notifierA.CollectionChanged += (o, e) =>
{
Assert.IsTrue(e.OldItems.Contains(dummyChange));
updateGroupA = true;
};
notifierB.CollectionChanged += (o, e) =>
{
Assert.IsTrue(e.NewItems.Contains(dummyChange));
updateGroupB = true;
};
dummyChange.Item = "B";
Assert.IsFalse(updateGroups);
Assert.IsTrue(updateGroupA);
Assert.IsTrue(updateGroupB);
Assert.IsTrue(Sys.Contains(groupA, dummy1));
Assert.IsTrue(Sys.Contains(groupB, dummy2));
Assert.IsTrue(Sys.Contains(groupB, dummyChange));
}
public void SelectMany_ObservableSourceItemSubSourceChanges_NoUpdatesWhenDetached()
{
var update = false;
ICollection <Dummy <ICollection <Dummy <string> > > > coll = new List <Dummy <ICollection <Dummy <string> > > >();
var dummy = new Dummy <string>()
{
Item = "23"
};
var dummy2 = new ObservableDummy <ICollection <Dummy <string> > >()
{
Item = new List <Dummy <string> >()
{
dummy
}
};
coll.Add(dummy2);
var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item);
test.CollectionChanged += (o, e) => update = true;
Assert.IsTrue(Sys.Contains(test, "23"));
Assert.IsFalse(update);
test.Detach();
update = false;
dummy2.Item = new List <Dummy <string> >()
{
new Dummy <string>("42")
};
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.IsTrue(test.Contains("42"));
update = false;
dummy2.Item = new List <Dummy <string> >()
{
dummy
};
Assert.IsTrue(update);
}
public void Modulo_Int_ModuloDoesNotChange_NoUpdate()
{
var update = false;
var dummy = new ObservableDummy<int>(7);
var test = Observable.Expression(() => dummy.Item % 2);
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual(1, test.Value);
Assert.IsFalse(update);
dummy.Item = 3;
Assert.IsFalse(update);
}
public void And_Boolean_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<bool>() { Item = true };
var result = Observable.Expression(() => dummy.Item & true);
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 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_Class_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<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.IsFalse(result.Value);
Assert.IsTrue(updated);
}
public void LessThan_Int_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<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.IsTrue(result.Value);
Assert.IsTrue(updated);
}
public void RecursiveFac()
{
var dummy = new ObservableDummy<int>(4);
var test = Observable.Expression(() => Fac(dummy.Item));
var resultChanged = false;
Assert.AreEqual(24, test.Value);
test.ValueChanged += (o, e) =>
{
resultChanged = true;
Assert.AreEqual(24, e.OldValue);
};
dummy.Item = 5;
Assert.IsTrue(resultChanged);
Assert.AreEqual(120, test.Value);
}
public void Add_String_Observable_Update()
{
var updated = false;
var dummy = new ObservableDummy<string>() { Item = "5" };
var result = Observable.Expression(() => dummy.Item + "2");
result.ValueChanged += (o, e) =>
{
Assert.AreEqual("52", e.OldValue);
updated = true;
};
Assert.AreEqual("52", result.Value);
Assert.IsFalse(updated);
dummy.Item = "4";
Assert.IsTrue(updated);
Assert.AreEqual("42", result.Value);
}
public void ArrayCreation_Observable_Updates()
{
var update = false;
var dummy = new ObservableDummy<int>() { Item = 23 };
var test = new NotifyValue<int[]>(() => new int[dummy.Item]);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(23, (e.OldValue as int[]).Length);
Assert.AreEqual(42, (e.NewValue as int[]).Length);
};
Assert.AreEqual(23, (test.Value as int[]).Length);
Assert.IsFalse(update);
dummy.Item = 42;
Assert.IsTrue(update);
}
public void New_Observable_Updates()
{
var update = false;
var dummy = new ObservableDummy<int>() { Item = 23 };
var test = new NotifyValue<Dummy<int>>(() => new Dummy<int>(dummy.Item));
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(23, (e.OldValue as Dummy<int>).Item);
Assert.AreEqual(42, (e.NewValue as Dummy<int>).Item);
};
Assert.AreEqual(23, (test.Value as Dummy<int>).Item);
Assert.IsFalse(update);
dummy.Item = 42;
Assert.IsTrue(update);
}
public void GroupBy_ObservableSource_NoUpdatesWhenDetached()
{
var update = false;
ICollection<Dummy<string>> coll = new NotifyCollection<Dummy<string>>();
var test = coll.WithUpdates().GroupBy(d => d.Item);
test.CollectionChanged += (o, e) => update = true;
Assert.IsTrue(!test.Any());
Assert.IsFalse(update);
test.Detach();
update = false;
var testDummy = new ObservableDummy<string>() { Item = "42" };
coll.Add(testDummy);
Assert.IsFalse(update);
testDummy.Item = "23";
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.AreEqual("23", test.FirstOrDefault().Key);
update = false;
testDummy.Item = "42";
Assert.IsTrue(update);
update = false;
coll.Remove(testDummy);
Assert.IsTrue(update);
}
public void Cast_String_Observable_Update()
{
var update = false;
var dummy = new ObservableDummy<object>() { Item = "23" };
var test = new NotifyValue<string>(() => (string)dummy.Item);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual("23", e.OldValue);
Assert.AreEqual("42", e.NewValue);
};
Assert.AreEqual("23", test.Value);
Assert.IsFalse(update);
dummy.Item = "42";
Assert.IsTrue(update);
Assert.AreEqual("42", test.Value);
}
public void Modulo_Int_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<int>(7);
var test = Observable.Expression(() => dummy.Item % 2);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(1, e.OldValue);
Assert.AreEqual(0, e.NewValue);
};
Assert.AreEqual(1, test.Value);
Assert.IsFalse(update);
dummy.Item = 42;
Assert.IsTrue(update);
Assert.AreEqual(0, test.Value);
}
public void Coalesce_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<string>();
var test = Observable.Expression(() => dummy.Item ?? "42");
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual("42", e.OldValue);
Assert.AreEqual("23", e.NewValue);
};
Assert.AreEqual("42", test.Value);
Assert.IsFalse(update);
dummy.Item = "23";
Assert.IsTrue(update);
Assert.AreEqual("23", test.Value);
}
public void BitwiseAnd_Int_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<int>(7);
var test = Observable.Expression(() => 21 & dummy.Item);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(5, e.OldValue);
Assert.AreEqual(1, e.NewValue);
};
Assert.AreEqual(5, test.Value);
Assert.IsFalse(update);
dummy.Item = 3;
Assert.IsTrue(update);
Assert.AreEqual(1, test.Value);
}
public void BitwiseOr_Long_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<long>(7);
var test = Observable.Expression(() => 21 | dummy.Item);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(23L, e.OldValue);
Assert.AreEqual(29L, e.NewValue);
};
Assert.AreEqual(23L, test.Value);
Assert.IsFalse(update);
dummy.Item = 13;
Assert.IsTrue(update);
Assert.AreEqual(29L, test.Value);
}
public void LeftShift_Long_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<long>(1);
var test = Observable.Expression(() => dummy.Item << 1);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(2L, e.OldValue);
Assert.AreEqual(6L, e.NewValue);
};
Assert.AreEqual(2L, test.Value);
Assert.IsFalse(update);
dummy.Item = 3;
Assert.IsTrue(update);
Assert.AreEqual(6L, test.Value);
}
public void MemberExpression_ObservableSourceTargetChanges_Update()
{
var update = false;
var dummy = new ObservableDummy<Dummy<int>>() { Item = new Dummy<int>(23) };
var test = new NotifyValue<int>(() => dummy.Item.Item);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(23, e.OldValue);
Assert.AreEqual(42, e.NewValue);
};
Assert.AreEqual(23, test.Value);
Assert.IsFalse(update);
dummy.Item = new Dummy<int>(42);
Assert.IsTrue(update);
Assert.AreEqual(42, test.Value);
}
public void LeftShift_Int_ObservableSource_Update()
{
var update = false;
var dummy = new ObservableDummy<int>(1);
var test = Observable.Expression(() => 1 << dummy.Item);
test.ValueChanged += (o, e) =>
{
update = true;
Assert.AreEqual(2, e.OldValue);
Assert.AreEqual(8, e.NewValue);
};
Assert.AreEqual(2, test.Value);
Assert.IsFalse(update);
dummy.Item = 3;
Assert.IsTrue(update);
Assert.AreEqual(8, test.Value);
}
public void LambdaIntAverage_ObservableSourceItemAdded_NoUpdatesWhenDetached()
{
var update = false;
var coll = new NotifyCollection<Dummy<int>>() { new Dummy<int>(1), new Dummy<int>(2), new Dummy<int>(3) };
var testColl = coll.WithUpdates();
var test = Observable.Expression(() => testColl.Average(d => d.Item));
test.ValueChanged += (o, e) => update = true;
Assert.AreEqual(2, test.Value);
Assert.AreEqual(2, testColl.Average(d => d.Item));
Assert.IsFalse(update);
test.Detach();
var testDummy = new ObservableDummy<int>(5);
coll.Add(testDummy);
Assert.IsFalse(update);
testDummy.Item = 4;
Assert.IsFalse(update);
test.Attach();
Assert.IsTrue(update);
Assert.AreEqual(2.5, test.Value);
update = false;
testDummy.Item = 5;
Assert.IsTrue(update);
update = false;
coll.Remove(testDummy);
}
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);
}
