public void DictionaryGenericTest(IDictionary <string, TestItem> dictionary)
{
Assert.IsNotNull(dictionary as INotifyDictionaryChanged <string, TestItem>);
MockEvent.AddNotifiersDictionary(dictionary as INotifyDictionaryChanged <string, TestItem>);
//Special case: ObservableListKeyed must have key match mapped property in object.
if (dictionary is ObservableListKeyed <string, TestItem> )
{
Key1 = Item1.Id;
Key2 = Item2.Id;
Key3 = Item3.Id;
DefaultKey = DefaultValue.Id;
UpdateKey = UpdateValue.Id;
}
//Add Test
dictionary.Add(Key1, Item1);
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Contains test
Assert.IsTrue(dictionary.ContainsKey(Key1));
Assert.IsFalse(dictionary.ContainsKey(Key2));
//Remove Test
dictionary.Remove(Key1);
Assert.AreEqual(0, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//index[] test
dictionary[DefaultKey] = DefaultValue;
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Special case: ObservableListKeyed must have key match mapped property in object.
if (dictionary is ObservableListKeyed <string, TestItem> )
{
UpdateValue.Id = DefaultKey;
}
dictionary[DefaultKey] = UpdateValue;
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Clear Test
dictionary.Clear();
Assert.AreEqual(0, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Keys/Value Test
if (dictionary is ObservableSortedList <string, TestItem> ) //Special case for a sorted list
{
Key1 = "1";
Key2 = "2";
}
dictionary.Add(Key1, Item1);
dictionary.Add(Key2, Item2);
// ReSharper disable once GenericEnumeratorNotDisposed
var keys = dictionary.Keys.GetEnumerator();
keys.MoveNext();
Assert.AreSame(Key1, keys.Current);
keys.MoveNext();
Assert.AreSame(Key2, keys.Current);
keys.MoveNext();
Assert.IsNull(keys.Current);
// ReSharper disable once GenericEnumeratorNotDisposed
var values = dictionary.Values.GetEnumerator();
values.MoveNext();
Assert.AreSame(Item1, values.Current);
values.MoveNext();
Assert.AreSame(Item2, values.Current);
values.MoveNext();
Assert.IsNull(values.Current);
//TryGetValue test
TestItem item = null;
Assert.IsTrue(dictionary.TryGetValue(Key1, out item));
Assert.IsFalse(dictionary.TryGetValue(Key3, out item));
//Readonlytest
Assert.IsNotNull(dictionary.IsReadOnly);
var enumerator = dictionary.GetEnumerator();
enumerator.MoveNext();
Assert.AreSame(Key1, enumerator.Current.Key);
Assert.AreSame(Item1, enumerator.Current.Value);
enumerator.MoveNext();
Assert.AreSame(Key2, enumerator.Current.Key);
Assert.AreSame(Item2, enumerator.Current.Value);
enumerator.MoveNext();
Assert.IsNull(enumerator.Current.Key);
Assert.IsNull(enumerator.Current.Value);
//ICollection<KVP>, IEnumerable<KVP>, IEnumerable
//TrygetValue
}
public void CollectionKeyValuePairTest(ICollection <KeyValuePair <string, TestItem> > collection)
{
Assert.IsNotNull(collection as INotifyDictionaryChanged <string, TestItem>);
MockEvent.AddNotifiersDictionary(collection as INotifyDictionaryChanged <string, TestItem>);
//Special case, ObservableListKeyed must have Keys match Item ID
if (collection is ObservableListKeyed <string, TestItem> )
{
Key1 = Item1.Id;
Key2 = Item2.Id;
Key3 = Item3.Id;
}
//Special case, ObservableSortedList puts keys in order, so it must be added in alphabetical order to pass this general dictionary test.
if (collection is ObservableSortedList <string, TestItem> )
{
Key1 = "1";
Key2 = "2";
Key3 = "3";
}
//Add and count
var kvp1 = new KeyValuePair <string, TestItem>(Key1, Item1);
var kvp2 = new KeyValuePair <string, TestItem>(Key2, Item2);
var kvp3 = new KeyValuePair <string, TestItem>(Key3, Item3);
collection.Add(kvp1);
Assert.AreEqual(1, collection.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Remove Test
collection.Remove(kvp1);
Assert.AreEqual(0, collection.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//ClearTest
collection.Add(kvp1);
collection.Add(kvp2);
Assert.AreEqual(2, collection.Count);
MockEvent.AssertMockNotifiersDictionary(2);
collection.Clear();
Assert.AreEqual(0, collection.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Contains Test
collection.Add(kvp1);
Assert.IsTrue(collection.Contains(kvp1));
Assert.IsFalse(collection.Contains(kvp2));
//Syncroot Test
Assert.IsFalse(collection.IsReadOnly);
//IEnumerator/ EnumeratorGeneric test
collection.Clear();
collection.Add(kvp1);
collection.Add(kvp2);
collection.Add(kvp3);
Assert.AreEqual(3, collection.Count);
IEnumerator enumerator = collection.GetEnumerator();
Assert.IsNotNull(enumerator);
enumerator.MoveNext();
Assert.AreEqual(kvp1.Key, ((KeyValuePair <string, TestItem>)enumerator.Current).Key);
Assert.AreEqual(kvp1.Value, ((KeyValuePair <string, TestItem>)enumerator.Current).Value);
IEnumerator <KeyValuePair <string, TestItem> > enumeratorGeneric = collection.GetEnumerator();
Assert.IsNotNull(enumeratorGeneric);
enumeratorGeneric.MoveNext();
Assert.AreEqual(kvp1.Key, enumeratorGeneric.Current.Key);
Assert.AreEqual(kvp1.Value, enumeratorGeneric.Current.Value);
//CopyTo test
var array = new KeyValuePair <string, TestItem> [3];
collection.CopyTo(array, 0);
Assert.AreEqual(array[0], kvp1);
Assert.AreEqual(array[1], kvp2);
Assert.AreEqual(array[2], kvp3);
}
public void DictionaryTest(IDictionary dictionary)
{
Assert.IsNotNull(dictionary as INotifyDictionaryChanged <string, TestItem>);
MockEvent.AddNotifiersDictionary(dictionary as INotifyDictionaryChanged <string, TestItem>);
//Special case: ObservableListKeyed must have key match mapped property in object.
if (dictionary is ObservableListKeyed <string, TestItem> )
{
Key1 = Item1.Id;
Key2 = Item2.Id;
Key3 = Item3.Id;
DefaultKey = DefaultValue.Id;
UpdateKey = UpdateValue.Id;
}
//Add Test
dictionary.Add(Key1, Item1);
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Contains test
Assert.IsTrue(dictionary.Contains(Key1));
Assert.IsFalse(dictionary.Contains(Key2));
//Remove Test
dictionary.Remove(Key1);
Assert.AreEqual(0, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//index[] test
dictionary[DefaultKey] = DefaultValue;
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Special case: ObservableListKeyed must have key match mapped property in object.
if (dictionary is ObservableListKeyed <string, TestItem> )
{
UpdateValue.Id = DefaultKey;
}
dictionary[DefaultKey] = UpdateValue;
Assert.AreEqual(1, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Clear Test
dictionary.Clear();
Assert.AreEqual(0, dictionary.Count);
MockEvent.AssertMockNotifiersDictionary(1);
//Keys/Value Test
//Special Case: Observable Sorted List will sort these, they must be in order or it will fail general test.
if (dictionary is ObservableSortedList <string, TestItem> )
{
Key1 = "1";
Key2 = "2";
}
dictionary.Add(Key1, Item1);
dictionary.Add(Key2, Item2);
var keys = dictionary.Keys.GetEnumerator();
keys.MoveNext();
Assert.AreSame(Key1, keys.Current);
keys.MoveNext();
Assert.AreSame(Key2, keys.Current);
var values = dictionary.Values.GetEnumerator();
values.MoveNext();
Assert.AreSame(Item1, values.Current);
values.MoveNext();
Assert.AreSame(Item2, values.Current);
//Readonlytest
Assert.IsNotNull(dictionary.IsReadOnly);
//IsFixedSize
Assert.IsNotNull(dictionary.IsFixedSize);
//Icollection
var enumerator = dictionary.GetEnumerator();
enumerator.MoveNext();
Assert.AreSame(Key1, enumerator.Key);
Assert.AreSame(Item1, enumerator.Value);
enumerator.MoveNext();
Assert.AreSame(Key2, enumerator.Key);
Assert.AreSame(Item2, enumerator.Value);
}
