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