public void Distinct_ObservableSource_NoUpdateWhenDetached() { var update = false; var coll = new List<int>() { 1, 2, 2, 3 }; var test = coll.WithUpdates().Distinct(); test.CollectionChanged += (o, e) => update = true; Assert.AreEqual(3, test.Count()); Assert.IsFalse(update); test.Detach(); update = false; coll.Add(4); Assert.IsFalse(update); test.Attach(); Assert.IsTrue(update); Assert.AreEqual(4, test.Count()); update = true; coll.Remove(4); Assert.IsTrue(update); }
public void Min_NoObservableSourceNewMinAdded_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var test = Observable.Expression(() => coll.WithUpdates().Min()); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(1, test.Value); Assert.AreEqual(1, coll.WithUpdates().Min()); Assert.IsFalse(update); coll.Add(0); Assert.IsFalse(update); }
public void LambdaMax_NoObservableSourceNewMaxAdded_NoUpdate() { var update = false; var coll = new List<Dummy<int>>() { new Dummy<int>(-1), new Dummy<int>(-2), new Dummy<int>(-3) }; var test = Observable.Expression(() => coll.WithUpdates().Max(d => d.Item)); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(-1, test.Value); Assert.AreEqual(-1, coll.WithUpdates().Max(d => d.Item)); Assert.IsFalse(update); coll.Add(new Dummy<int>(0)); Assert.IsFalse(update); }
public void Distinct_NoObservableSourceNewItemAdded_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 2, 3 }; var test = coll.WithUpdates().Distinct(); test.CollectionChanged += (o, e) => update = true; Assert.AreEqual(3, test.Count()); Assert.IsFalse(update); coll.Add(4); Assert.IsFalse(update); }
public void Count_NoObservableSourceItemAdded_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var test = Observable.Expression(() => coll.WithUpdates().Count()); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(3, test.Value); Assert.IsFalse(update); coll.Add(4); Assert.IsFalse(update); }
public void Contains_NoObservableSourceElementAdded_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var test = Observable.Expression(() => coll.WithUpdates().Contains(4)); test.ValueChanged += (o, e) => update = true; Assert.IsFalse(test.Value); Assert.IsFalse(update); coll.Add(4); Assert.IsFalse(update); }
public void Any_NoObservableSourceItemRemovedThusEmptyCollection_NoUpdate() { var update = false; var coll = new List<int>() { 1 }; var test = Observable.Expression(() => coll.WithUpdates().Any()); test.ValueChanged += (o, e) => update = true; Assert.IsTrue(test.Value); Assert.IsFalse(update); coll.Remove(1); Assert.IsFalse(update); }
public void FirstOrDefault_NoObservableSourceFirstItemAdded_NoUpdate() { var update = false; var coll = new List<string>(); var test = Observable.Expression(() => coll.WithUpdates().FirstOrDefault()); test.ValueChanged += (o, e) => update = true; Assert.IsNull(test.Value); Assert.IsFalse(update); coll.Add("42"); Assert.IsFalse(update); }
public void OfTypeTests_NoObservableSourceItemRemoved_NoUpdate() { var update = false; var coll = new List<object>() { 23, "42", null }; var test = coll.WithUpdates().OfType<string>(); test.CollectionChanged += (o, e) => update = true; test.AssertSequence("42"); Assert.IsFalse(update); coll.Remove("42"); Assert.IsFalse(update); }
public void OfTypeTests_ItemOfOtherTypeAdded_NoUpdate() { var update = false; var coll = new List<object>() { 23, "42", null }; var test = coll.WithUpdates().OfType<string>(); test.CollectionChanged += (o, e) => update = true; test.AssertSequence("42"); Assert.IsFalse(update); coll.Add(2.0); Assert.IsFalse(update); }
public void OrderBy_NoObservableSourceItemAdded_NoUpdate() { var update = false; var coll = new List<string>() { "C", "A", "D" }; var test = coll.WithUpdates().OrderBy(item => item); test.CollectionChanged += (o, e) => update = true; test.AssertSequence("A", "C", "D"); Assert.AreEqual(3, test.Sequences.Count()); Assert.IsFalse(update); coll.Add("B"); Assert.IsFalse(update); }
public void Concat_NoObservableSource1ItemAdded_NoUpdate() { var update = false; var coll1 = new List<int>() { 1, 2, 3 }; var coll2 = new List<int>() { 4, 5, 6 }; var test = coll1.WithUpdates().Concat(coll2); test.CollectionChanged += (o, e) => update = true; test.AssertSequence(1, 2, 3, 4, 5, 6); Assert.IsFalse(update); coll1.Add(4); Assert.IsFalse(update); }
public void Select_NoObservableSourceItemAdded_NoUpdate() { var update = false; ICollection<Dummy<string>> coll = new List<Dummy<string>>(); var test = coll.WithUpdates().Select(d => d.Item); test.CollectionChanged += (o, e) => update = true; Assert.IsTrue(!test.Any()); Assert.IsFalse(update); coll.Add(new Dummy<string>() { Item = "42" }); Assert.IsTrue(!test.Any()); Assert.IsFalse(update); }
public void All_NoObservableSourceItemRemoved_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3, -1 }; var test = Observable.Expression(() => coll.WithUpdates().All(i => i > 0)); test.ValueChanged += (o, e) => update = true; Assert.IsFalse(test.Value); Assert.IsFalse(update); coll.Remove(-1); Assert.IsFalse(update); }
public void Where_NoObservableSourceSuppressedAdded_NoUpdates() { var update = false; ICollection<Dummy<bool>> coll = new List<Dummy<bool>>(); var dummy = new Dummy<bool>() { Item = false }; var test = coll.WithUpdates().Where(d => d.Item); test.CollectionChanged += (o, e) => update = true; Assert.IsFalse(Sys.Contains(test, dummy)); Assert.IsFalse(update); coll.Add(dummy); Assert.IsFalse(update); Assert.IsFalse(Sys.Contains(test, dummy)); }
public void IntSum_NoObservableSourceItemRemoved_NoUpdates() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var testColl = coll.WithUpdates(); var test = Observable.Expression(() => testColl.Sum()); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(6, test.Value); Assert.AreEqual(6, testColl.Sum()); Assert.IsFalse(update); coll.Remove(3); Assert.IsFalse(update); }
public void LambdaIntAverage_NoObservableSourceItemAdded_NoUpdates() { var update = false; var coll = new List<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); coll.Add(new Dummy<int>(4)); Assert.IsFalse(update); }
public void Select_NoObservableSourceItemRemoved_NoUpdate() { var update = false; ICollection<Dummy<string>> coll = new List<Dummy<string>>(); var dummy = new Dummy<string>() { Item = "42" }; coll.Add(dummy); var test = coll.WithUpdates().Select(d => d.Item); test.CollectionChanged += (o, e) => update = true; Assert.IsTrue(Sys.Contains(test, "42")); Assert.IsFalse(update); coll.Remove(dummy); Assert.IsFalse(Sys.Contains(test, "42")); Assert.IsFalse(update); }
public void LambdaIntSum_NoObservableSourceItemRemoved_NoUpdates() { var update = false; var dummy = new Dummy<int>(3); var coll = new List<Dummy<int>>() { new Dummy<int>(1), new Dummy<int>(2), dummy }; var testColl = coll.WithUpdates(); var test = Observable.Expression(() => testColl.Sum(d => d.Item)); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(6, test.Value); Assert.AreEqual(6, testColl.Sum(d => d.Item)); Assert.IsFalse(update); coll.Remove(dummy); Assert.IsFalse(update); }
public void SelectMany_NoObservableSourceSubSourceAdded_NoUpdates() { 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 Dummy<ICollection<Dummy<string>>>() { Item = new List<Dummy<string>>() { dummy } }; var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item); test.CollectionChanged += (o, e) => update = true; Assert.IsFalse(Sys.Contains(test, "23")); Assert.IsFalse(update); coll.Add(dummy2); Assert.IsFalse(update); }
public void LambdaNullableDecimalSum_NoObservableSourceItemAdded_NoUpdates() { var update = false; var coll = new List<Dummy<decimal?>>() { new Dummy<decimal?>(1), new Dummy<decimal?>(2), new Dummy<decimal?>(3) }; var testColl = coll.WithUpdates(); var test = Observable.Expression(() => testColl.Sum(d => d.Item)); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(6, test.Value); Assert.AreEqual(6, testColl.Sum(d => d.Item)); Assert.IsFalse(update); coll.Add(new Dummy<decimal?>(4)); Assert.IsFalse(update); }
public void LambdaNullableMaxComparer_NoObservableSourceNewMaxAdded_NoUpdate() { var update = false; var coll = new List<Dummy<int?>>() { new Dummy<int?>(-1), new Dummy<int?>(2), new Dummy<int?>(), new Dummy<int?>(-3) }; var test = Observable.Expression(() => coll.WithUpdates().Max(d => d.Item, new AbsoluteValueComparer())); test.ValueChanged += (o, e) => update = true; Assert.AreEqual(-3, test.Value); Assert.AreEqual(-3, coll.WithUpdates().Max(d => d.Item, new AbsoluteValueComparer())); Assert.IsFalse(update); coll.Add(new Dummy<int?>(4)); Assert.IsFalse(update); }
public void SelectMany_ObservableSubSourceReset_Update() { var update = false; var coll = new List<Dummy<ICollection<Dummy<string>>>>() { new Dummy<ICollection<Dummy<string>>>( new ObservableCollection<Dummy<string>>() { new Dummy<string>("42") }) }; var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item); test.CollectionChanged += (o, e) => { Assert.AreEqual(NotifyCollectionChangedAction.Remove, e.Action); Assert.AreEqual(1, e.OldItems.Count); Assert.AreEqual("42", e.OldItems[0]); update = true; }; coll[0].Item.Clear(); Assert.IsTrue(update); Assert.IsFalse(test.Any()); }
public void SelectMany_ObservableSubSourceItemAdded_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 Dummy<ICollection<Dummy<string>>>() { Item = new ObservableCollection<Dummy<string>>() }; coll.Add(dummy2); var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item); test.CollectionChanged += (o, e) => update = true; Assert.IsFalse(Sys.Contains(test, "23")); Assert.IsFalse(update); test.Detach(); update = false; dummy2.Item.Add(dummy); Assert.IsFalse(update); test.Attach(); Assert.IsTrue(update); Assert.IsTrue(test.Contains("23")); update = false; dummy2.Item.Remove(dummy); Assert.IsTrue(update); }
public void SelectMany_NoObservableSubSourceReset_NoUpdate() { var update = false; var coll = new List<Dummy<ICollection<Dummy<string>>>>() { new Dummy<ICollection<Dummy<string>>>( new List<Dummy<string>>() { new Dummy<string>("42") }) }; var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item); test.CollectionChanged += (o, e) => update = true; coll[0].Item.Clear(); Assert.IsFalse(update); }
public void SelectMany_ObservableSubSourceItemAdded_Updates() { var update = 0; ICollection<Dummy<ICollection<Dummy<string>>>> coll = new List<Dummy<ICollection<Dummy<string>>>>(); var dummy = new Dummy<string>() { Item = "23" }; var dummy2 = new Dummy<ICollection<Dummy<string>>>() { Item = new ObservableCollection<Dummy<string>>() }; coll.Add(dummy2); var test = coll.WithUpdates().SelectMany(d => d.Item, (d1, d2) => d2.Item); test.CollectionChanged += (o, e) => { update++; Assert.AreEqual("23", e.NewItems[0]); }; Assert.IsFalse(Sys.Contains(test, "23")); Assert.AreEqual(0, update); dummy2.Item.Add(dummy); Assert.AreEqual(1, update); Assert.IsTrue(Sys.Contains(test, "23")); }
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 SelectMany_ObservableSourceItemSubSourceChanges_Updates() { 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; switch (e.Action) { case System.Collections.Specialized.NotifyCollectionChangedAction.Add: Assert.AreEqual(0, e.NewItems.Count); break; case System.Collections.Specialized.NotifyCollectionChangedAction.Remove: Assert.AreEqual("23", e.OldItems[0]); break; default: Assert.Fail(); break; } }; Assert.IsTrue(Sys.Contains(test, "23")); Assert.IsFalse(update); dummy2.Item = new List<Dummy<string>>(); Assert.IsTrue(update); Assert.IsTrue(!test.Any()); }
public void ContainsComparer_NoObservableSourceElementRemoved_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var test = Observable.Expression(() => coll.WithUpdates().Contains(-3, new AbsoluteValueComparer())); test.ValueChanged += (o, e) => update = true; Assert.IsTrue(test.Value); Assert.IsFalse(update); coll.Remove(3); Assert.IsFalse(update); }
public void Contains_NoObservableSourceReset_NoUpdate() { var update = false; var coll = new List<int>() { 1, 2, 3 }; var test = Observable.Expression(() => coll.WithUpdates().Contains(2)); test.ValueChanged += (o, e) => update = true; coll.Clear(); Assert.IsFalse(update); }