/// <summary>
/// Clears the given Collection.
/// </summary>
public void ClearTest(CiccioSet <string> collection)
{
INotifyPropertyChanged collectionPropertyChanged = collection;
collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged;
_expectedPropertyChanged = new[]
{
new PropertyNameExpected(COUNT),
//new PropertyNameExpected(ITEMARRAY)
};
collection.CollectionChanged += Collection_CollectionChanged;
ExpectedCollectionChangedFired++;
ExpectedAction = NotifyCollectionChangedAction.Reset;
ExpectedNewItems = null;
ExpectedNewStartingIndex = -1;
ExpectedOldItems = null;
ExpectedOldStartingIndex = -1;
collection.Clear();
Assert.Equal(0, collection.Count);
Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired);
foreach (var item in _expectedPropertyChanged)
{
Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just cleared the collection");
}
collection.CollectionChanged -= Collection_CollectionChanged;
collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
}
public void SerializeDeserialize_Roundtrips(CiccioSet <int> c)
{
CiccioSet <int> clone = BinaryFormatterHelpers.Clone(c);
Assert.NotSame(c, clone);
Assert.Equal(c, clone);
}
public void Clear_INotifyPropertyChangedItems_RemovesPropertyChangedEventHandlers()
{
var item1 = new Item();
var item2 = new Item();
var list = new List <Item> {
item1, item2, null
};
var bindingList = new CiccioSet <Item>(list);
Assert.Equal(1, item1.InvocationList.Length);
Assert.Equal(1, item2.InvocationList.Length);
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) =>
{
calledListChanged = true;
Assert.Equal(ListChangedType.Reset, e.ListChangedType);
Assert.Equal(-1, e.NewIndex);
};
bindingList.Clear();
Assert.True(calledListChanged);
Assert.Empty(bindingList);
Assert.Null(item1.InvocationList);
Assert.Null(item2.InvocationList);
}
public static void CopyToTest_Negative()
{
string[] anArray = new string[] { "one", "two", "three", "four" };
CiccioSet <string> collection = new CiccioSet <string>(anArray);
int[] iArrInvalidValues = new int[] { -1, -2, -100, -1000, -10000, -100000, -1000000, -10000000, -100000000, -1000000000, int.MinValue };
foreach (var index in iArrInvalidValues)
{
string[] aCopy = new string[collection.Count];
AssertExtensions.Throws <ArgumentOutOfRangeException>("arrayIndex", "dstIndex", () => collection.CopyTo(aCopy, index));
}
int[] iArrLargeValues = new int[] { collection.Count, int.MaxValue, int.MaxValue / 2, int.MaxValue / 10 };
foreach (var index in iArrLargeValues)
{
string[] aCopy = new string[collection.Count];
AssertExtensions.Throws <ArgumentException>(null, null, () => collection.CopyTo(aCopy, index));
}
AssertExtensions.Throws <ArgumentNullException>("array", "dest", () => collection.CopyTo(null, 1));
string[] copy = new string[collection.Count - 1];
AssertExtensions.Throws <ArgumentException>(null, "", () => collection.CopyTo(copy, 0));
copy = new string[0];
AssertExtensions.Throws <ArgumentException>(null, "", () => collection.CopyTo(copy, 0));
}
public static void RemoveTest()
{
// trying to remove item in collection.
string[] anArray = { "one", "two", "three", "four" };
CiccioSet <string> col = new CiccioSet <string>(anArray);
CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester();
helper.RemoveItemTest(col, 2, "three", true, hasDuplicates: false);
// trying to remove item not in collection.
anArray = new string[] { "one", "two", "three", "four" };
col = new CiccioSet <string>(anArray);
helper = new CollectionAndPropertyChangedTester();
helper.RemoveItemTest(col, -1, "three2", false, hasDuplicates: false);
// removing null
anArray = new string[] { "one", "two", "three", "four" };
col = new CiccioSet <string>(anArray);
helper = new CollectionAndPropertyChangedTester();
helper.RemoveItemTest(col, -1, null, false, hasDuplicates: false);
//// trying to remove item in collection that has duplicates.
//anArray = new string[] { "one", "three", "two", "three", "four" };
//col = new CiccioSet<string>(anArray);
//helper = new CollectionAndPropertyChangedTester();
//helper.RemoveItemTest(col, 1, "three", true, hasDuplicates: true);
//// want to ensure that there is one "three" left in collection and not both were removed.
//int occurrencesThree = 0;
//foreach (var item in col)
//{
// if (item.Equals("three"))
// occurrencesThree++;
//}
//Assert.Equal(1, occurrencesThree);
}
public static void CopyToTest()
{
string[] anArray = new string[] { "one", "two", "three", "four" };
CiccioSet <string> collection = new CiccioSet <string>((IEnumerable <string>)anArray);
string[] aCopy = new string[collection.Count];
collection.CopyTo(aCopy, 0);
for (int i = 0; i < anArray.Length; ++i)
{
Assert.Equal(anArray[i], aCopy[i]);
}
// copy observable collection starting in middle, where array is larger than source.
aCopy = new string[collection.Count + 2];
int offsetIndex = 1;
collection.CopyTo(aCopy, offsetIndex);
for (int i = 0; i < aCopy.Length; i++)
{
string value = aCopy[i];
if (i == 0)
{
Assert.True(null == value, "Should not have a value since we did not start copying there.");
}
else if (i == (aCopy.Length - 1))
{
Assert.True(null == value, "Should not have a value since the collection is shorter than the copy array..");
}
else
{
int indexInCollection = i - offsetIndex;
Assert.Equal(collection.ToArray()[indexInCollection], aCopy[i]);
}
}
}
public static void IEnumerableConstructorTest_Empty()
{
var col = new CiccioSet <string>(new string[] { });
Assert.Equal(0, col.Count);
Assert.Empty(col);
}
public static void ParameterlessConstructorTest()
{
var col = new CiccioSet <string>();
Assert.Equal(0, col.Count);
Assert.Empty(col);
}
///// <summary>
///// Given a collection, will move an item from the oldIndex to the newIndex.
///// </summary>
//public void MoveItemTest(CiccioSet<string> collection, int oldIndex, int newIndex)
//{
// INotifyPropertyChanged collectionPropertyChanged = collection;
// collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged;
// _expectedPropertyChanged = new[] { new PropertyNameExpected(ITEMARRAY) };
// collection.CollectionChanged += Collection_CollectionChanged;
// string itemAtOldIndex = collection[oldIndex];
// ExpectedCollectionChangedFired++;
// ExpectedAction = NotifyCollectionChangedAction.Move;
// ExpectedNewItems = new string[] { itemAtOldIndex };
// ExpectedNewStartingIndex = newIndex;
// ExpectedOldItems = new string[] { itemAtOldIndex };
// ExpectedOldStartingIndex = oldIndex;
// int expectedCount = collection.Count;
// collection.Move(oldIndex, newIndex);
// Assert.Equal(expectedCount, collection.Count);
// Assert.Equal(itemAtOldIndex, collection[newIndex]);
// Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired);
// foreach (var item in _expectedPropertyChanged)
// Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just moved an item");
// collection.CollectionChanged -= Collection_CollectionChanged;
// collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
//}
///// <summary>
///// Will set that new item at the specified index in the given collection.
///// </summary>
//public void ReplaceItemTest(CiccioSet<string> collection, int index, string newItem)
//{
// INotifyPropertyChanged collectionPropertyChanged = collection;
// collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged;
// _expectedPropertyChanged = new[] { new PropertyNameExpected(ITEMARRAY) };
// collection.CollectionChanged += Collection_CollectionChanged;
// string itemAtOldIndex = collection.ToArray()[index];
// ExpectedCollectionChangedFired++;
// ExpectedAction = NotifyCollectionChangedAction.Replace;
// ExpectedNewItems = new string[] { newItem };
// ExpectedNewStartingIndex = index;
// ExpectedOldItems = new string[] { itemAtOldIndex };
// ExpectedOldStartingIndex = index;
// int expectedCount = collection.Count;
// collection[index] = newItem;
// Assert.Equal(expectedCount, collection.Count);
// Assert.Equal(newItem, collection[index]);
// Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired);
// foreach (var item in _expectedPropertyChanged)
// Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just replaced an item");
// collection.CollectionChanged -= Collection_CollectionChanged;
// collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
//}
/// <summary>
/// Given a collection, index and item to remove, will try to remove that item
/// from the index. If the item has duplicates, will verify that only the first
/// instance was removed.
/// </summary>
public void RemoveItemTest(CiccioSet <string> collection, int itemIndex, string itemToRemove, bool isSuccessfulRemove, bool hasDuplicates)
{
INotifyPropertyChanged collectionPropertyChanged = collection;
collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged;
_expectedPropertyChanged = new[]
{
new PropertyNameExpected(COUNT),
//new PropertyNameExpected(ITEMARRAY)
};
collection.CollectionChanged += Collection_CollectionChanged;
if (isSuccessfulRemove)
{
ExpectedCollectionChangedFired++;
}
ExpectedAction = NotifyCollectionChangedAction.Remove;
ExpectedNewItems = null;
ExpectedNewStartingIndex = -1;
ExpectedOldItems = new string[] { itemToRemove };
ExpectedOldStartingIndex = itemIndex;
int expectedCount = isSuccessfulRemove ? collection.Count - 1 : collection.Count;
bool removedItem = collection.Remove(itemToRemove);
Assert.Equal(expectedCount, collection.Count);
Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired);
if (isSuccessfulRemove)
{
foreach (var item in _expectedPropertyChanged)
{
Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since there were items removed.");
}
Assert.True(removedItem, "Should have been successful in removing the item.");
}
else
{
foreach (var item in _expectedPropertyChanged)
{
Assert.False(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since there were no items removed.");
}
Assert.False(removedItem, "Should not have been successful in removing the item.");
}
if (hasDuplicates)
{
return;
}
Assert.DoesNotContain(itemToRemove, collection);
collection.CollectionChanged -= Collection_CollectionChanged;
collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
}
public static void AddTest()
{
string[] anArray = { "one", "two", "three" };
CiccioSet <string> col = new CiccioSet <string>(anArray);
CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester();
helper.AddOrInsertItemTest(col, "four");
}
public static void ListConstructorTest()
{
List <string> collection = new List <string> {
"one", "two", "three"
};
var actual = new CiccioSet <string>(collection);
Assert.Equal(collection, actual);
}
public void OnDeserialized_MonitorNotInitialized_ExpectSuccess()
{
var observableCollection = new CiccioSet <int>();
MethodInfo onDeserializedMethodInfo = observableCollection.GetType().GetMethod("OnDeserialized",
BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
Assert.NotNull(onDeserializedMethodInfo);
onDeserializedMethodInfo.Invoke(observableCollection, new object[] { null });
}
public static void DebuggerAttributeTests()
{
CiccioSet <int> col = new CiccioSet <int>(new[] { 1, 2, 3, 4 });
DebuggerAttributes.ValidateDebuggerDisplayReferences(col);
DebuggerAttributeInfo info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(col);
PropertyInfo itemProperty = info.Properties.Single(pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>().State == DebuggerBrowsableState.RootHidden);
int[] items = itemProperty.GetValue(info.Instance) as int[];
Assert.Equal(col, items);
}
protected override IList NonGenericIListFactory(int count)
{
CiccioSet <string> collection = new CiccioSet <string>();
int seed = 9600;
while (collection.Count < count)
{
object toAdd = CreateT(seed++);
collection.Add((string)toAdd);
}
return(collection);
}
/// <summary>
/// Will perform an Add or Insert on the given Collection depending on whether the
/// insertIndex is null or not. If it is null, will Add, otherwise, will Insert.
/// </summary>
public void AddOrInsertItemTest(CiccioSet <string> collection, string itemToAdd, int?insertIndex = null)
{
INotifyPropertyChanged collectionPropertyChanged = collection;
collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged;
_expectedPropertyChanged = new[]
{
new PropertyNameExpected(COUNT),
//new PropertyNameExpected(ITEMARRAY)
};
collection.CollectionChanged += Collection_CollectionChanged;
ExpectedCollectionChangedFired++;
ExpectedAction = NotifyCollectionChangedAction.Add;
ExpectedNewItems = new string[] { itemToAdd };
if (insertIndex.HasValue)
{
ExpectedNewStartingIndex = insertIndex.Value;
}
else
{
ExpectedNewStartingIndex = collection.Count;
}
ExpectedOldItems = null;
ExpectedOldStartingIndex = -1;
int expectedCount = collection.Count + 1;
if (insertIndex.HasValue)
{
//collection.Insert(insertIndex.Value, itemToAdd);
//Assert.Equal(itemToAdd, collection[insertIndex.Value]);
}
else
{
collection.Add(itemToAdd);
Assert.Equal(itemToAdd, collection.ToArray()[collection.Count - 1]);
}
Assert.Equal(expectedCount, collection.Count);
Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired);
foreach (var item in _expectedPropertyChanged)
{
Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just added an item");
}
collection.CollectionChanged -= Collection_CollectionChanged;
collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
}
public void Ctor_Default()
{
var list = new CiccioSet <string>();
IBindingList iBindingList = list;
Assert.True(iBindingList.AllowEdit);
Assert.False(iBindingList.AllowNew);
Assert.True(iBindingList.AllowRemove);
Assert.Equal(ListSortDirection.Ascending, iBindingList.SortDirection);
Assert.True(iBindingList.SupportsChangeNotification);
Assert.False(iBindingList.SupportsSearching);
Assert.False(iBindingList.SupportsSorting);
Assert.False(((IRaiseItemChangedEvents)list).RaisesItemChangedEvents);
}
public static void GetEnumeratorTest()
{
Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
CiccioSet <Guid> col = new CiccioSet <Guid>((IEnumerable <Guid>)anArray);
int i = 0;
IEnumerator <Guid> e;
for (e = col.GetEnumerator(); e.MoveNext(); ++i)
{
Assert.Equal(anArray[i], e.Current);
}
Assert.Equal(col.Count, i);
e.Dispose();
}
public void Ctor_FixedSizeIList()
{
var array = new string[10];
var bindingList = new CiccioSet <string>(array);
IBindingList iBindingList = bindingList;
Assert.True(iBindingList.AllowEdit);
Assert.False(iBindingList.AllowNew);
Assert.True(iBindingList.AllowRemove);
Assert.False(iBindingList.IsSorted);
Assert.Equal(ListSortDirection.Ascending, iBindingList.SortDirection);
Assert.True(iBindingList.SupportsChangeNotification);
Assert.False(iBindingList.SupportsSearching);
Assert.False(iBindingList.SupportsSorting);
Assert.False(((IRaiseItemChangedEvents)bindingList).RaisesItemChangedEvents);
}
public static void ClearTest()
{
string[] anArray = { "one", "two", "three", "four" };
CiccioSet <string> col = new CiccioSet <string>(anArray);
col.Clear();
Assert.Equal(0, col.Count);
Assert.Empty(col);
//AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => col.ToArray()[1]);
//tests that the collectionChanged events are fired.
CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester();
col = new CiccioSet <string>(anArray);
helper.ClearTest(col);
}
public void Clear_Invoke_Success()
{
var bindingList = new CiccioSet <object> {
new object(), new object()
};
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) =>
{
calledListChanged = true;
Assert.Equal(ListChangedType.Reset, e.ListChangedType);
Assert.Equal(-1, e.NewIndex);
};
bindingList.Clear();
Assert.True(calledListChanged);
Assert.Empty(bindingList);
}
public static void ContainsTest()
{
string[] anArray = new string[] { "one", "two", "three", "four" };
CiccioSet <string> collection = new CiccioSet <string>((IEnumerable <string>)anArray);
string collectionString = "";
foreach (var item in collection)
{
collectionString += item + ", ";
}
for (int i = 0; i < collection.Count; ++i)
{
Assert.True(collection.Contains(anArray[i]), "ObservableCollection did not contain the item: " + anArray[i] + " Collection: " + collectionString);
}
string g = "six";
Assert.False(collection.Contains(g), "Collection contained an item that should not have been there. guid: " + g + " Collection: " + collectionString);
Assert.False(collection.Contains(null), "Collection should not have contained null. Collection: " + collectionString);
}
public void Reentrancy_MultipleListeners_Throws()
{
bool handler1Called = false;
bool handler2Called = false;
var collection = new CiccioSet <int>();
collection.CollectionChanged += (sender, e) => { handler1Called = true; };
collection.CollectionChanged += (sender, e) =>
{
handler2Called = true;
// More than one listener; throws.
Assert.Throws <InvalidOperationException>(() => collection.Add(2));
};
collection.Add(1);
Assert.True(handler1Called);
Assert.True(handler2Called);
Assert.Equal(1, collection.Count);
Assert.Equal(1, collection.ToArray()[0]);
}
public void Reentrancy_SingleListener_DoesNotThrow()
{
bool handlerCalled = false;
var collection = new CiccioSet <int>();
collection.CollectionChanged += (sender, e) =>
{
if (!handlerCalled)
{
handlerCalled = true;
// Single listener; does not throw.
collection.Add(2);
}
};
collection.Add(1);
Assert.True(handlerCalled);
Assert.Equal(2, collection.Count);
Assert.Equal(1, collection.ToArray()[0]);
Assert.Equal(2, collection.ToArray()[1]);
}
public void Remove_INotifyPropertyChangedItems_RemovesPropertyChangedEventHandlers()
{
var item = new Item();
var bindingList = new CiccioSet <Item> {
item
};
Assert.Equal(1, item.InvocationList.Length);
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) =>
{
calledListChanged = true;
Assert.Equal(ListChangedType.ItemDeleted, e.ListChangedType);
Assert.Equal(0, e.NewIndex);
};
bindingList.Remove(item);
Assert.True(calledListChanged);
Assert.Empty(bindingList);
Assert.Null(item.InvocationList);
}
public void Remove_Invoke_CallsListChanged()
{
var obj = new object();
var list = new List <object> {
obj
};
var bindingList = new CiccioSet <object>(list);
bool calledListChanged = false;
bindingList.ListChanged += (object sender, ListChangedEventArgs e) =>
{
calledListChanged = true;
Assert.Equal(0, e.NewIndex);
Assert.Equal(ListChangedType.ItemDeleted, e.ListChangedType);
// The event is raised after the removal.
Assert.Equal(0, bindingList.Count);
};
bindingList.Remove(obj);
Assert.True(calledListChanged);
}
public void SortProperty_Get_ReturnsNull()
{
IBindingList bindingList = new CiccioSet <object>();
Assert.Null(bindingList.SortProperty);
}
public static void IsReadOnlyTest()
{
var col = new CiccioSet <Guid>(new[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() });
Assert.False(((ICollection <Guid>)col).IsReadOnly);
}
public static void IEnumerableConstructorTest(IEnumerable <string> collection)
{
var actual = new CiccioSet <string>(collection);
Assert.Equal(collection, actual);
}
