public void OnMoveB()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
int moveFromIndex = 1;
int moveToIndex = 3;
B movedB = sourceCollectionB[moveFromIndex];
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Move, args.Action);
Assert.Equal(sourceCollectionA.Count + moveFromIndex, args.OldStartingIndex);
Assert.Equal(sourceCollectionA.Count + moveToIndex, args.NewStartingIndex);
Assert.Same(movedB, args.NewItems[0]);
};
//Act
sourceCollectionB.Move(moveFromIndex, moveToIndex);
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public void OnReplaceB()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
B replacingB = new B();
int replaceIndex = 1;
B replacedB = (B)readOnlyList[sourceCollectionA.Count + replaceIndex];
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Replace, args.Action);
Assert.Equal(sourceCollectionA.Count + replaceIndex, args.OldStartingIndex);
Assert.Equal(sourceCollectionA.Count + replaceIndex, args.NewStartingIndex);
Assert.Same(replacingB, args.NewItems[0]);
};
//Act
sourceCollectionB[replaceIndex] = replacingB;
//Assert
Assert.NotSame(replacedB, readOnlyList[replaceIndex]);
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public void OnReplaceA()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
WrappingObservableReadOnlyList <A> wrappedCollectionA = new WrappingObservableReadOnlyList <A>(sourceCollectionA);
WrappingObservableReadOnlyList <B> wrappedCollectionB = new WrappingObservableReadOnlyList <B>(sourceCollectionB);
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
new ConcatenatingObservableReadOnlyList <Super>(wrappedCollectionA, wrappedCollectionB);
A replacingA = new A();
int replaceIndex = 1;
A replacedA = (A)readOnlyList[replaceIndex];
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Replace, args.Action);
Assert.Equal(replaceIndex, args.OldStartingIndex);
Assert.Equal(replaceIndex, args.NewStartingIndex);
Assert.Same(replacingA, args.NewItems[0]);
};
//Act
sourceCollectionA[replaceIndex] = replacingA;
//Assert
Assert.NotSame(replacedA, readOnlyList[replaceIndex]);
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public void OnRemoveB()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
int removedIndex = 1;
B removedB = new B();
sourceCollectionB.Insert(removedIndex, removedB);
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Remove, args.Action);
Assert.Equal(sourceCollectionA.Count + removedIndex, args.OldStartingIndex);
Assert.Same(removedB, args.OldItems[0]);
};
//Act
sourceCollectionB.Remove(removedB);
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public MainWindowViewModel()
{
_models.Add(new Model(_i++));
_models.Add(new Model(_i++));
_models.Add(new Model(_i++));
_models.Add(new Model(_i++));
ViewModels = new TransformingObservableReadOnlyList <Model, ViewModel>(_models, model => new ViewModel(model));
_models.Add(new Model(_i++));
_models.Add(new Model(_i++));
ModelsA = new ObservableCollection <ModelA>();
ModelsB = new ObservableCollection <ModelB>();
ModelsA.Add(new ModelA(_a++));
ModelsA.Add(new ModelA(_a++));
ModelsA.Add(new ModelA(_a++));
ModelsA.Add(new ModelA(_a++));
ModelsB.Add(new ModelB(_b++));
ModelsB.Add(new ModelB(_b++));
WrappingObservableReadOnlyList <ModelA> wrapA = new WrappingObservableReadOnlyList <ModelA>(ModelsA);
WrappingObservableReadOnlyList <ModelB> wrapB = new WrappingObservableReadOnlyList <ModelB>(ModelsB);
ModelsA.Add(new ModelA(_a++));
ModelsB.Add(new ModelB(_b++));
TransformingObservableReadOnlyList <ModelA, ViewModelA> transA =
new TransformingObservableReadOnlyList <ModelA, ViewModelA>(wrapA, a => new ViewModelA(a));
TransformingObservableReadOnlyList <ModelB, ViewModelB> transB =
new TransformingObservableReadOnlyList <ModelB, ViewModelB>(wrapB, b => new ViewModelB(b));
ModelsA.Add(new ModelA(_a++));
ModelsB.Add(new ModelB(_b++));
ViewModelsAB = new ConcatenatingObservableReadOnlyList <ViewModel>(transA, transB);
ModelsA.Add(new ModelA(_a++));
ModelsB.Add(new ModelB(_b++));
}
public void FilledCollection()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
//Act
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
private static void StandardCheck(ObservableCollection <A> filledCollectionA, ObservableCollection <B> filledCollectionB,
ConcatenatingObservableReadOnlyList <Super> readOnlyList)
{
Assert.Equal(filledCollectionA.Count + filledCollectionB.Count, readOnlyList.Count);
int index = 0;
foreach (A a in filledCollectionA)
{
Assert.Same(a, readOnlyList[index++]);
}
foreach (B b in filledCollectionB)
{
Assert.Same(b, readOnlyList[index++]);
}
}
public void OnResetB()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Reset, args.Action);
};
//Act
sourceCollectionB.Clear();
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public void OnAdditionB()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
B addedB = new B();
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Add, args.Action);
Assert.Equal(readOnlyList.Count - 1, args.NewStartingIndex);
Assert.Same(addedB, args.NewItems[0]);
};
//Act
sourceCollectionB.Add(addedB);
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
public void OnInsertA()
{
//Arrange
ObservableCollection <A> sourceCollectionA = FilledCollectionA;
ObservableCollection <B> sourceCollectionB = FilledCollectionB;
ConcatenatingObservableReadOnlyList <Super> readOnlyList =
ConcatenatingObservableReadOnlyList <Super> .Concatenate(sourceCollectionA, sourceCollectionB);
A insertedA = new A();
int insertIndex = 1;
readOnlyList.CollectionChanged += (sender, args) =>
{
Assert.Equal(NotifyCollectionChangedAction.Add, args.Action);
Assert.Equal(insertIndex, args.NewStartingIndex);
Assert.Same(insertedA, args.NewItems[0]);
};
//Act
sourceCollectionA.Insert(insertIndex, insertedA);
//Assert
StandardCheck(sourceCollectionA, sourceCollectionB, readOnlyList);
}
