public void AddRangeTest()
{
// There was an issue with ConcurrentObservableDictionary.AddMany throwing an
// exception when passed an IEnumerable.
IEnumerable <KeyValuePair <string, string> > GetIEnumerable()
{
for (int i = 0; i < 10; ++i)
{
yield return(new KeyValuePair <string, string>(i.ToString(), i.ToString()));
}
}
var itemsToAdd = GetIEnumerable();
var dictionary1 = new ConcurrentObservableDictionary <string, string>();
dictionary1.AddRange(itemsToAdd);
Assert.IsTrue(dictionary1.Count == itemsToAdd.Count(), "Right number of items");
var sourceDictionary = itemsToAdd.ToDictionary(a => a.Key, b => b.Value);
var dictionary2 = new ConcurrentObservableDictionary <string, string>();
dictionary2.AddRange(sourceDictionary);
Assert.IsTrue(dictionary2.Count == sourceDictionary.Count, "Right number of items");
}
public void Test_ConcurrentObservableDictionary_Clear()
{
var initial = Enumerable.Range(0, 100).Select(x => new KeyValuePair <int, int>(x, x));
var collection = new ConcurrentObservableDictionary <int, 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.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(initial.Zip(returnedArgs.OldItems.OfType <KeyValuePair <int, int> >(), (a, b) => a.Key == b.Key && a.Value == b.Value).All(c => c));
}
public void Test_ConcurrentObservableCollection_RemoveRange_ByItems_IEnumerable()
{
var initial = Enumerable.Range(0, 100).Select(x => new KeyValuePair <int, int>(x, x));
var toRemove = Enumerable.Range(1, 40).Select(x => x * 2);
var collection = new ConcurrentObservableDictionary <int, 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(toRemove);
// 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(-1, returnedArgs.OldStartingIndex);
Assert.IsNull(returnedArgs.NewItems);
Assert.IsNotNull(returnedArgs.OldItems);
Assert.AreEqual(toRemove.Count(), returnedArgs.OldItems.Count);
Assert.IsTrue(CollectionsAreEqual(toRemove, returnedArgs.OldItems));
}
public void Test_ConcurrentObservableDictionary_AddRange_Dictionary()
{
var toAdd = Enumerable.Range(0, 100).Select(x => new KeyValuePair <int, int>(x, x)).ToDictionary(x => x.Key, x => x.Value);
var collection = new ConcurrentObservableDictionary <int, int>();
// Record all the collection changed events
List <(object, NotifyCollectionChangedEventArgs)> returnedList = new List <(object, NotifyCollectionChangedEventArgs)>();
collection.CollectionChanged += (s, e) => returnedList.Add((s, e));
collection.AddRange(toAdd);
// Check just one collection changed event was fired
Assert.AreEqual(1, returnedList.Count);
(var returnedObject, var returnedArgs) = returnedList[0];
Assert.AreEqual(returnedObject, collection);
Assert.AreEqual(returnedArgs.Action, NotifyCollectionChangedAction.Add);
Assert.IsNotNull(returnedArgs.NewItems);
Assert.IsNull(returnedArgs.OldItems);
Assert.AreEqual(toAdd.Count(), returnedArgs.NewItems.Count);
Assert.IsTrue(CollectionsAreEqual(toAdd, returnedArgs.NewItems));
}
protected async Task AddRange(List <KeyValuePair <string, string> > itemsToAdd, ConcurrentObservableDictionary <string, string> destCollection, bool onGuiThread)
{
await AddRange(itemsToAdd, destCollection, (items) => destCollection.AddRange(items), onGuiThread);
}
protected async Task AddItemsParallel(List <KeyValuePair <string, string> > itemsToAdd, ConcurrentObservableDictionary <string, string> destCollection)
{
Action <List <KeyValuePair <string, string> > > addBatchAction = (batch) => destCollection.AddRange(batch);
await AddItemsParallel(itemsToAdd, destCollection, addBatchAction);
}
public void TestIndexOfInViews()
{
var initial = Enumerable.Range(0, 100).Select(x => new KeyValuePair <int, string>(x, x.ToString())).ToList();
var other = Enumerable.Range(100, 100).Select(x => new KeyValuePair <int, string>(x, x.ToString())).ToList();
var testCollection = new ConcurrentObservableDictionary <int, string>();
testCollection.AddRange(initial);
var collectionView = testCollection.CollectionView;
var keysView = testCollection.Keys;
var valuesView = testCollection.Values;
// Test the IList implementation because it had a bug
IList collectionList = (IList)testCollection.CollectionView;
IList keysList = (IList)testCollection.Keys;
IList valuesList = (IList)testCollection.Values;
foreach (var item in initial)
{
Assert.IsTrue(testCollection.Contains(item));
Assert.IsTrue(collectionView.Contains(item));
Assert.IsTrue(keysView.Contains(item.Key));
Assert.IsTrue(valuesView.Contains(item.Value));
Assert.IsTrue(collectionList.Contains(item));
Assert.IsTrue(keysList.Contains(item.Key));
Assert.IsTrue(valuesList.Contains(item.Value));
}
foreach (var item in other)
{
Assert.IsFalse(testCollection.Contains(item));
Assert.IsFalse(collectionView.Contains(item));
Assert.IsFalse(keysView.Contains(item.Key));
Assert.IsFalse(valuesView.Contains(item.Value));
Assert.IsFalse(collectionList.Contains(item));
Assert.IsFalse(keysList.Contains(item.Key));
Assert.IsFalse(valuesList.Contains(item.Value));
}
for (int i = 0; i < initial.Count; ++i)
{
Assert.AreEqual(initial[i], collectionView[i]);
Assert.AreEqual(initial[i].Key, keysView[i]);
Assert.AreEqual(initial[i].Value, valuesView[i]);
Assert.AreEqual(initial[i], collectionList[i]);
Assert.AreEqual(initial[i].Key, keysList[i]);
Assert.AreEqual(initial[i].Value, valuesList[i]);
Assert.AreEqual(i, collectionView.IndexOf(initial[i]));
Assert.AreEqual(i, keysView.IndexOf(initial[i].Key));
Assert.AreEqual(i, valuesView.IndexOf(initial[i].Value));
Assert.AreEqual(i, collectionList.IndexOf(initial[i]));
Assert.AreEqual(i, keysList.IndexOf(initial[i].Key));
Assert.AreEqual(i, valuesList.IndexOf(initial[i].Value));
}
}
