public void Test_ConcurrentObservableCollection_RemoveRange_ByIndex()
{
var initial = Enumerable.Range(0, 100).ToList();
var startIndex = 50;
var removeCount = 40;
var collection = new ConcurrentObservableCollection <int>();
collection.AddRange(initial);
Assert.AreEqual(100, collection.Count);
// Record all the collection changed events
List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>();
collection.CollectionChanged += (s, e) => returnedList.Add((s, e));
collection.RemoveRange(startIndex, removeCount);
// Check just one collection changed event was fired
Assert.AreEqual(1, returnedList.Count);
(var returnedObject, var returnedArgs) = returnedList[0];
Assert.IsNotNull(returnedObject);
Assert.IsNotNull(returnedArgs);
Assert.AreEqual(returnedObject, collection);
Assert.AreEqual(NotifyCollectionChangedAction.Remove, returnedArgs.Action);
Assert.AreEqual(startIndex, returnedArgs.OldStartingIndex);
Assert.IsNull(returnedArgs.NewItems);
Assert.IsNotNull(returnedArgs.OldItems);
Assert.AreEqual(removeCount, returnedArgs.OldItems.Count);
var toRemove = initial.Skip(startIndex).Take(removeCount).ToList();
Assert.IsTrue(CollectionsAreEqual(toRemove, returnedArgs.OldItems));
}
public void Test_ConcurrentObservableCollection_Clear()
{
var initial = Enumerable.Range(0, 100).ToList();
var collection = new ConcurrentObservableCollection <int>();
collection.AddRange(initial);
Assert.AreEqual(100, collection.Count);
// Record all the collection changed events
List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>();
collection.CollectionChanged += (s, e) => returnedList.Add((s, e));
collection.Clear();
// Check just one collection changed event was fired
Assert.AreEqual(1, returnedList.Count);
(var returnedObject, var returnedArgs) = returnedList[0];
Assert.IsNotNull(returnedObject);
Assert.IsNotNull(returnedArgs);
Assert.AreEqual(0, collection.Count);
Assert.AreEqual(returnedObject, collection);
Assert.AreEqual(NotifyCollectionChangedAction.Remove, returnedArgs.Action);
Assert.IsNull(returnedArgs.NewItems);
Assert.IsNotNull(returnedArgs.OldItems);
Assert.AreEqual(initial.Count(), returnedArgs.OldItems.Count);
Assert.IsTrue(CollectionsAreEqual(initial, returnedArgs.OldItems));
}
public void Write_AddRange_ElementsAdded()
{
var col = new ConcurrentObservableCollection <string>();
var expected = new[] { "a", "b" };
col.AddRange(expected);
CollectionAssert.AreEquivalent(expected, col);
}
public void Write_AddRange_ElementsAdded()
{
var col = new ConcurrentObservableCollection <string>();
var expected = new[] { "a", "b" };
col.AddRange(expected);
col.Should().BeEquivalentTo(expected);
}
public void AddRange_5SequentialAdds_CollectionChangeEventsAreReported()
{
var col = new ConcurrentObservableCollection <string>(new[] { "a" });
var argsList = new List <NotifyCollectionChangedEventArgs>();
col.CollectionChanged += (sender, args) => { argsList.Add(args); };
col.AddRange(new[] { "z1", "f1", "y1" });
col.AddRange(new[] { "z2", "f2", "y2" });
col.AddRange(new[] { "z3", "f3", "y3" });
col.AddRange(new[] { "z4", "f4", "y4" });
col.AddRange(new[] { "z5", "f5", "y5" });
argsList.Count(x => x.Action == NotifyCollectionChangedAction.Add).Should().Be(5);
foreach (var args in argsList)
{
col.Skip(args.NewStartingIndex).Take(args.NewItems.Count).Should().BeEquivalentTo(args.NewItems.OfType <string>());
}
col.Should().BeEquivalentTo("a", "z1", "f1", "y1", "z2", "f2", "y2", "z3", "f3", "y3", "z4", "f4", "y4",
"z5", "f5", "y5");
}
public void Write_ComplexOperation_CollectionUpdatedProperly()
{
var col = new ConcurrentObservableCollection <string>(new[] { "a", "b", "c" });
col.Add("d");
col.Remove("b");
col.Insert(0, "x");
col.AddRange(new[] { "z", "f", "y" });
col.RemoveAt(4);
col.RemoveRange(new[] { "y", "c" });
col[2] = "p";
CollectionAssert.AreEquivalent(new[] { "x", "a", "p", "f" }, col);
}
public void AddRange_FiresAddEvent()
{
var col = new ConcurrentObservableCollection <string>();
string received = string.Empty;
col.CollectionChanged += (sender, args) =>
{
if (args.Action == NotifyCollectionChangedAction.Add)
{
received = args.NewItems.OfType <string>().First();
}
};
col.AddRange(new[] { "a", "b", "c" });
Assert.That(received, Is.EqualTo("a"));
}
private async Task StressTestCollection(ConcurrentObservableCollection <string> collection)
{
_stopStressTest = false;
await Task.Factory.StartNew(() =>
{
while (!_stopStressTest)
{
collection.AddRange(Enumerable.Range(1, 1000).Select(x => $"{x}").ToList());
while (collection.Count > 0)
{
collection.RemoveLast();
}
Thread.Sleep(200);
}
});
}
public void Test_ConcurrentObservableCollection_Reset()
{
var initial = Enumerable.Range(0, 100).ToList();
var toAdd = Enumerable.Range(100, 100).ToList();
var collection = new ConcurrentObservableCollection <int>();
collection.AddRange(initial);
Assert.AreEqual(100, collection.Count);
// Record all the collection changed events
List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>();
collection.CollectionChanged += (s, e) => returnedList.Add((s, e));
collection.Reset(toAdd);
// Check two collection changed events were fired
Assert.AreEqual(2, returnedList.Count);
(var returnedObject0, var returnedArgs0) = returnedList[0];
(var returnedObject1, var returnedArgs1) = returnedList[1];
Assert.IsNotNull(returnedObject0);
Assert.IsNotNull(returnedArgs0);
Assert.IsNotNull(returnedObject1);
Assert.IsNotNull(returnedArgs1);
Assert.AreEqual(returnedObject0, collection);
Assert.AreEqual(returnedObject1, collection);
Assert.AreEqual(NotifyCollectionChangedAction.Remove, returnedArgs0.Action);
Assert.AreEqual(NotifyCollectionChangedAction.Add, returnedArgs1.Action);
Assert.IsNull(returnedArgs0.NewItems);
Assert.IsNotNull(returnedArgs0.OldItems);
Assert.AreEqual(initial.Count(), returnedArgs0.OldItems.Count);
Assert.IsTrue(CollectionsAreEqual(initial, returnedArgs0.OldItems));
Assert.IsNull(returnedArgs1.OldItems);
Assert.IsNotNull(returnedArgs1.NewItems);
Assert.AreEqual(toAdd.Count(), returnedArgs1.NewItems.Count);
Assert.IsTrue(CollectionsAreEqual(toAdd, returnedArgs1.NewItems));
}
protected async Task AddRange(List <T> itemsToAdd, ConcurrentObservableCollection <T> destCollection, bool onGuiThread)
{
await AddRange(itemsToAdd, destCollection, (items) => destCollection.AddRange(items), onGuiThread);
}
protected async Task AddItemsParallel(List <T> itemsToAdd, ConcurrentObservableCollection <T> destCollection)
{
Action <List <T> > addBatchAction = (batch) => destCollection.AddRange(batch);
await AddItemsParallel(itemsToAdd, destCollection, addBatchAction);
}
