public void TestCollectionSync()
{
string item0 = "Item0";
string item1 = "Item1";
string item2 = "Item2";
string item3 = "Item3";
ObservableCollection<string> collection = new ObservableCollection<string>();
HelperLabeledViewModelCollection viewModel = new HelperLabeledViewModelCollection(null, collection, o => o);
collection.Add(item0);
collection.Add(item1);
collection.Add(item3);
Assert.IsTrue(CompareCollectionValues(collection, viewModel), "Add did not work.");
collection.Insert(2, item2);
Assert.IsTrue(CompareCollectionValues(collection, viewModel), "Insert did not work.");
collection.Remove(item3);
Assert.IsTrue(CompareCollectionValues(collection, viewModel), "Remove did not work.");
collection.Move(0, 1);
Assert.IsTrue(CompareCollectionValues(collection, viewModel), "Move did not work.");
collection.Clear();
Assert.IsTrue(CompareCollectionValues(collection, viewModel), "Clear did not work.");
}
public TestWindowViewModel()
{
RWLock = new ReaderWriterLockSlim();
Observable = new ObservableCollection<int>();
BindingOperations.EnableCollectionSynchronization(Observable, RWLock, new CollectionSynchronizationCallback(lockCollection));
AddCommand = new Command(() =>
{
Task.Factory.StartNew(() =>
{
RWLock.EnterWriteLock();
for (int i = 0; i < 10; i++)
{
Observable.Add(i);
}
RWLock.ExitWriteLock();
});
});
ClearCommand = new Command(() =>
{
Task.Factory.StartNew(() =>
{
RWLock.EnterWriteLock();
Observable.Move(0,5);
RWLock.ExitWriteLock();
int k = 0;
for (int i = 0; i < 1000; i++)
{
k++;
}
});
});
}
/// <summary>
/// Given a collection, will move an item from the oldIndex to the newIndex.
/// </summary>
public void MoveItemTest(ReadOnlyObservableCollection<string> readOnlyCol, ObservableCollection<string> collection,
int oldIndex, int newIndex)
{
INotifyPropertyChanged readOnlyPropertyChanged = readOnlyCol;
readOnlyPropertyChanged.PropertyChanged += Collection_PropertyChanged;
_expectedPropertyChanged = new[] { new PropertyNameExpected(ITEMARRAY) };
INotifyCollectionChanged readOnlyCollectionChange = readOnlyCol;
readOnlyCollectionChange.CollectionChanged += Collection_CollectionChanged;
string itemAtOldIndex = collection[oldIndex];
_expectedCollectionChangedFired++;
_expectedAction = NotifyCollectionChangedAction.Move;
_expectedNewItems = new string[] { itemAtOldIndex };
_expectedNewStartingIndex = newIndex;
_expectedOldItems = new string[] { itemAtOldIndex };
_expectedOldStartingIndex = oldIndex;
collection.Move(oldIndex, newIndex);
Assert.Equal(collection.Count, readOnlyCol.Count);
Assert.Equal(itemAtOldIndex, readOnlyCol[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 moved an item.");
readOnlyCollectionChange.CollectionChanged -= Collection_CollectionChanged;
readOnlyPropertyChanged.PropertyChanged -= Collection_PropertyChanged;
}
public static void MoveTest_Negative()
{
string[] anArray = new string[] { "one", "two", "three", "four" };
ObservableCollection<string> collection = new ObservableCollection<string>(anArray);
ReadOnlyObservableCollection<string> readonlyCol = new ReadOnlyObservableCollection<string>(collection);
((INotifyCollectionChanged)readonlyCol).CollectionChanged += (o, e) => { throw new ShouldNotBeInvokedException(); };
int validIndex = 2;
int[] iArrInvalidValues = new Int32[] { -1, -2, -100, -1000, -10000, -100000, -1000000, -10000000, -100000000, -1000000000, Int32.MinValue };
int[] iArrLargeValues = new Int32[] { anArray.Length, Int32.MaxValue, Int32.MaxValue / 2, Int32.MaxValue / 10 };
foreach (var index in iArrInvalidValues)
{
// invalid startIndex, valid destination index.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(index, validIndex));
Assert.Equal(anArray.Length, collection.Count);
}
foreach (var index in iArrLargeValues)
{
// invalid startIndex, valid destination index.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(index, validIndex));
Assert.Equal(anArray.Length, collection.Count);
}
}
/// <summary>
/// Given a collection, will move an item from the oldIndex to the newIndex.
/// </summary>
public void MoveItemTest(ObservableCollection<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;
}
public static void MoveTest_Negative()
{
string[] anArray = new string[] { "one", "two", "three", "four" };
ObservableCollection<string> collection = null;
int validIndex = 2;
int[] iArrInvalidValues = new Int32[] { -1, -2, -100, -1000, -10000, -100000, -1000000, -10000000, -100000000, -1000000000, Int32.MinValue };
int[] iArrLargeValues = new Int32[] { anArray.Length, Int32.MaxValue, Int32.MaxValue / 2, Int32.MaxValue / 10 };
foreach (var index in iArrInvalidValues)
{
collection = new ObservableCollection<string>(anArray);
collection.CollectionChanged += (o, e) =>
{
Assert.True(false, "Should not have thrown collection changed event when removing items from invalid indices");
};
// invalid startIndex, valid destination index.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(index, validIndex));
Assert.Equal(anArray.Length, collection.Count);
// valid startIndex, invalid destIndex.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(validIndex, index));
//NOTE: It actually moves the item right out of the collection.So the count is one less.
//Assert.Equal(anArray.Length, collection.Count, "Collection should not have changed. index: " + index);
}
foreach (var index in iArrLargeValues)
{
collection = new ObservableCollection<string>(anArray);
collection.CollectionChanged += (o, e) =>
{
Assert.True(false, "Should not have thrown collection changed event when removing items from invalid indices");
};
// invalid startIndex, valid destination index.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(index, validIndex));
Assert.Equal(anArray.Length, collection.Count);
// valid startIndex, invalid destIndex.
Assert.Throws<ArgumentOutOfRangeException>(() => collection.Move(validIndex, index));
//NOTE: It actually moves the item right out of the collection. So the count is one less.
//Assert.Equal(anArray.Length, collection.Count, "Collection should not have changed.");
}
}
public static void MoveTest()
{
Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
ObservableCollection<Guid> col01 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray);
ObservableCollection<Guid> col10 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray);
ObservableCollection<Guid> col12 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray);
ObservableCollection<Guid> col21 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray);
ObservableCollection<Guid> col20 = new ObservableCollection<Guid>((IEnumerable<Guid>)anArray);
col01.Move(0, 1);
Assert.Equal(anArray[0], col01[1]);
col10.Move(1, 0);
Assert.Equal(anArray[1], col10[0]);
col12.Move(1, 2);
Assert.Equal(anArray[1], col12[2]);
col21.Move(2, 1);
Assert.Equal(anArray[2], col21[1]);
col20.Move(2, 0);
Assert.Equal(anArray[2], col20[0]);
CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester();
string[] anArrayString = new string[] { "one", "two", "three", "four" };
ObservableCollection<string> collection = new ObservableCollection<string>(anArrayString);
helper.MoveItemTest(collection, 0, 2);
helper.MoveItemTest(collection, 3, 0);
helper.MoveItemTest(collection, 1, 2);
}
// keep inner and outer CollViews' GroupDescription collections in synch
private void SynchronizeGroupDescriptions(NotifyCollectionChangedEventArgs e, ObservableCollection<GroupDescription> origin, ObservableCollection<GroupDescription> clone)
{
if (clone == null)
return; // the clone might be lazily-created _groupBy
int i;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Debug.Assert(e.NewStartingIndex >= 0);
if (clone.Count + e.NewItems.Count != origin.Count)
goto case NotifyCollectionChangedAction.Reset;
for (i = 0; i < e.NewItems.Count; i++)
{
clone.Insert(e.NewStartingIndex + i, (GroupDescription) e.NewItems[i]);
}
break;
case NotifyCollectionChangedAction.Remove:
Debug.Assert(e.OldStartingIndex >= 0);
if (clone.Count - e.OldItems.Count != origin.Count)
goto case NotifyCollectionChangedAction.Reset;
for (i = 0; i < e.OldItems.Count; i++)
{
clone.RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Replace:
Debug.Assert(e.OldStartingIndex >= 0);
if (clone.Count + e.NewItems.Count - e.OldItems.Count != origin.Count)
goto case NotifyCollectionChangedAction.Reset;
// If there are as many new items as old items, then
// this is a straight replace.
if (e.OldItems.Count == e.NewItems.Count)
{
for (i = 0; i < e.OldItems.Count; i++)
{
clone[e.OldStartingIndex + i] = (GroupDescription) e.NewItems[i];
}
}
else
{
for (i = 0; i < e.OldItems.Count; i++)
{
clone.RemoveAt(e.OldStartingIndex);
}
for (i = 0; i < e.NewItems.Count; i++)
{
clone.Insert(e.NewStartingIndex + i, (GroupDescription) e.NewItems[i]);
}
}
break;
case NotifyCollectionChangedAction.Move:
Debug.Assert(e.OldStartingIndex >= 0);
if (clone.Count != origin.Count)
goto case NotifyCollectionChangedAction.Reset;
if (e.OldItems.Count == 1)
{
clone.Move(e.OldStartingIndex, e.NewStartingIndex);
}
else
{
if (e.NewStartingIndex < e.OldStartingIndex)
{
for (i = 0; i < e.OldItems.Count; i++)
{
clone.Move(e.OldStartingIndex + i, e.NewStartingIndex + i);
}
}
else if (e.NewStartingIndex > e.OldStartingIndex)
{
for (i = e.OldItems.Count - 1; i >= 0; i--)
{
clone.Move(e.OldStartingIndex + i, e.NewStartingIndex + i);
}
}
}
break;
// this arm also handles cases where the two collections have gotten
// out of [....] (typically because exceptions prevented a previous [....]
// from happening)
case NotifyCollectionChangedAction.Reset:
CloneList(clone, origin);
break;
default:
throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action));
}
}
