public async Task RemoveFiltered()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
using (var view = source.AsFilteredView(x => x % 2 == 0))
{
using (var actual = view.SubscribeAll())
{
view.RemoveAt(0);
await Application.Current.Dispatcher.SimulateYield();
CollectionAssert.IsEmpty(view);
CollectionAssert.AreEqual(new[] { 1, 3 }, source);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
public static void DisposeAfterNotifyRemove()
{
var source = new ObservableCollection <int> {
1
};
using var view = source.AsMappingView(CreateStrictMock, WithIndex, x => x.Object.Dispose());
using var actual = view.SubscribeAll();
var mock = view[0];
mock.Setup(x => x.Dispose()).Callback(() => actual.Add(EventArgs.Empty));
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Once);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
CollectionAssert.AreEqual(source.Select((_, i) => i), view.Select(x => x.Object.Index));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
EventArgs.Empty,
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public static void RemoveVisibleBuffered()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
var scheduler = new TestScheduler();
using var view = source.AsReadOnlyFilteredView(x => x % 2 == 0, TimeSpan.FromMilliseconds(100), scheduler);
scheduler.Start();
using var actual = view.SubscribeAll();
CollectionAssert.AreEqual(new[] { 2 }, view);
CollectionAssert.IsEmpty(actual);
source.Remove(2);
scheduler.Start();
CollectionAssert.IsEmpty(view);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(2, 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public static void Remove()
{
var model1 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(1);
var model2 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(2);
var model3 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(3);
var source = new ObservableCollection <Collections.ReadOnlyViews.MappingViewTests.Model <int> >(
new[]
{
model1,
model1,
model1,
model2,
model2,
model2,
model3,
model3,
model3,
});
using var view = source.AsMappingView(Collections.ReadOnlyViews.MappingViewTests.Vm.Create);
using var actual = view.SubscribeAll();
var mapped0 = view[0];
source.RemoveAt(0);
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mapped0, 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public async Task UpdatesAndNotifiesOnObservableCollectionChangedWhenFiltered()
{
var source = new ObservableCollection <int> {
1, 2
};
using var view = source.AsFilteredView(x => true);
source.Add(1);
await Application.Current.Dispatcher.SimulateYield();
using var actual = view.SubscribeAll();
view.Filter = x => x < 2;
await Application.Current.Dispatcher.SimulateYield();
var expected = new EventArgs[]
{
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Filter"),
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(2, 1),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 1, 1 }, view);
}
public static void SetSourceRemove()
{
using var view = new ReadOnlySerialView <int>(new[] { 1, 2, 3 });
using var actual = view.SubscribeAll();
var newSource = new[] { 1, 2 };
view.SetSource(newSource);
CollectionAssert.AreEqual(newSource, view);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(3, 2),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
newSource = new[] { 1 };
view.SetSource(newSource);
CollectionAssert.AreEqual(newSource, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(2, 1),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void RemoveVisible()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
var scheduler = new TestScheduler();
using (var view = source.AsReadOnlyFilteredView(x => x % 2 == 0, scheduler))
{
scheduler.Start();
using (var actual = view.SubscribeAll())
{
source.Remove(2);
scheduler.Start();
CollectionAssert.IsEmpty(view);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
public void Remove()
{
var source = new ObservableCollection <int> {
1
};
using (var modelView = source.AsMappingView(Model.Create))
{
using (var modelViewChanges = modelView.SubscribeAll())
{
using (var vmView = modelView.AsMappingView(Vm.Create))
{
using (var vmViewChanges = vmView.SubscribeAll())
{
var oldModel = modelView[0];
var oldView = vmView[0];
source.Remove(1);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
null
};
expected[2] = Diff.CreateRemoveEventArgs(oldModel, 0);
CollectionAssert.AreEqual(expected, modelViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateRemoveEventArgs(oldView, 0);
CollectionAssert.AreEqual(expected, vmViewChanges, EventArgsComparer.Default);
}
}
}
}
}
private static IReadOnlyList <EventArgs> CreateRemoveEventArgsCollection(object item, int index)
{
return(new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateRemoveEventArgs(item, index),
});
}
public void ClearOne()
{
var before = new[] { 1 };
var ints = new ObservableCollection <int>(before);
ints.Clear();
var actual = Diff.CollectionChange(new[] { 1 }, ints);
AssertEx.AreEqual(Diff.CreateRemoveEventArgs(1, 0), actual);
}
public void Repro2()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
var scheduler = new TestScheduler();
var max = 5;
using (var trigger = new Subject <object>())
{
// ReSharper disable once AccessToModifiedClosure
using (var view = new FilteredView <int>(source, x => x < max, TimeSpan.FromMilliseconds(10), scheduler, leaveOpen: true, triggers: trigger))
{
using (var actual = view.SubscribeAll())
{
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, view);
CollectionAssert.IsEmpty(actual);
max = 2;
trigger.OnNext(null);
scheduler.Start();
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
CachedEventArgs.NotifyCollectionReset,
};
CollectionAssert.AreEqual(new[] { 1 }, view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
for (var i = 4; i < 10; i++)
{
source.Add(i);
}
scheduler.Start();
CollectionAssert.AreEqual(new[] { 1 }, view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Clear();
scheduler.Start();
CollectionAssert.IsEmpty(view);
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(1, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
}
public void RemoveNonFiltered()
{
var ints = new ObservableCollection <int>(new[] { 1, 2, 3 });
var view = ints.AsReadOnlyFilteredView(x => x % 2 == 0);
var changes = view.SubscribeAll();
ints.Remove(2);
CollectionAssert.IsEmpty(view);
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateRemoveEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default);
}
/// <inheritdoc/>
protected override void RemoveItem(int index)
{
var item = this[index];
var sourceIndex = this.SourceIndex(index);
base.RemoveItem(index);
var change = Diff.CreateRemoveEventArgs(item, index);
this.UpdatedSourceWith = change;
this.Notify(change);
if (sourceIndex >= 0)
{
this.Source.RemoveAt(sourceIndex);
}
this.UpdatedSourceWith = null;
}
public void FilterRemoveOne()
{
using var actual = this.View.SubscribeAll();
this.View.Filter = x => x < 3;
this.Scheduler?.Start();
CollectionAssert.AreEqual(new[] { 1, 2 }, this.View);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(3, 2),
};
Assert.AreEqual(1, actual.Count(x => EventArgsComparer.Equals(x, FilterChangedEventArgs)));
CollectionAssert.AreEqual(expected, actual.Where(x => !EventArgsComparer.Equals(x, FilterChangedEventArgs)), EventArgsComparer.Default);
}
public void EnqueueTrimsOverflowAndNotifies()
{
var queue = new ObservableFixedSizeQueue <int>(2);
queue.Enqueue(1);
queue.Enqueue(2);
using var actual = queue.SubscribeAll();
queue.Enqueue(3);
CollectionAssert.AreEqual(new[] { 2, 3 }, queue);
var expected = new EventArgs[]
{
Diff.CreateRemoveEventArgs(1, 0),
Diff.CreateAddEventArgs(3, 1),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void FilterEnumerable()
{
var subject = new Subject <object>();
var source = Enumerable.Range(1, 3);
var view = source.AsReadOnlyFilteredView(Filter, subject);
var actual = view.SubscribeAll();
_filter = x => x < 3;
subject.OnNext(null);
CollectionAssert.AreEqual(new[] { 1, 2 }, view);
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateRemoveEventArgs(3, 2),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void NotifiesRemove()
{
var ints = new ObservableCollection <int>(new[] { 1 });
var expected = ints.SubscribeAll();
var modelView = ints.AsMappingView(x => new Model(x));
var modelViewChanges = modelView.SubscribeAll();
var vmView = modelView.AsMappingView(x => new Vm {
Model = x
});
var vmViewChanges = vmView.SubscribeAll();
var oldModel = modelView[0];
var oldView = vmView[0];
ints.Remove(1);
expected[2] = Diff.CreateRemoveEventArgs(oldModel, 0);
CollectionAssert.AreEqual(expected, modelViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateRemoveEventArgs(oldView, 0);
CollectionAssert.AreEqual(expected, vmViewChanges, EventArgsComparer.Default);
}
public void FilterRemoveOne()
{
_view.Filter = x => x < 3;
if (_scheduler != null)
{
_scheduler.Start();
}
CollectionAssert.AreEqual(new[] { 1, 2 }, _view);
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateRemoveEventArgs(3, 2),
};
_actual.RemoveAll(
x =>
x is PropertyChangedEventArgs &&
((PropertyChangedEventArgs)x).PropertyName == FilterChangedEventArgs.PropertyName);
CollectionAssert.AreEqual(expected, _actual, EventArgsComparer.Default);
}
public void UpdatesAndNotifiesOnObservableCollectionChangedWhenFiltered()
{
var ints = new ObservableCollection <int>(new List <int> {
1, 2
});
var view = ints.AsFilteredView(x => true);
ints.Add(1);
var actual = view.SubscribeAll();
view.Filter = x => x < 2;
view.Refresh();
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateRemoveEventArgs(2, 1),
new PropertyChangedEventArgs("Filter"),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 1, 1 }, view);
}
public void Remove()
{
var source = new ObservableCollection <int>
{
1,
1,
1,
2,
2,
2,
3,
3,
3,
};
using (var view = source.AsMappingView(CreateStrictMock, x => x.Object.Dispose()))
{
using (var actual = view.SubscribeAll())
{
var mock = view[0];
mock.Setup(x => x.Dispose());
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Once);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
mock = view[0];
mock.Setup(x => x.Dispose());
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Once);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
mock = view[0];
mock.Setup(x => x.Dispose());
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Once);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
foreach (var mock in view)
{
mock.Setup(x => x.Dispose());
}
}
}
public static void Remove()
{
var model1 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(1);
var model2 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(2);
var model3 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(3);
var source = new ObservableCollection <Collections.ReadOnlyViews.MappingViewTests.Model <int> >(
new[]
{
model1,
model1,
model1,
model2,
model2,
model2,
model3,
model3,
model3,
});
using var view = source.AsMappingView(CreateStrictMock, x => x.Object.Dispose());
using var actual = view.SubscribeAll();
var mock = view[0];
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Never);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Never);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
mock.Setup(x => x.Dispose());
source.RemoveAt(0);
mock.Verify(x => x.Dispose(), Times.Once);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateRemoveEventArgs(mock, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
foreach (var toDispose in view)
{
toDispose.Setup(x => x.Dispose());
}
}
