public void AddTriggerThenManyOnNextOneAdd()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
var scheduler = new TestScheduler();
using var trigger = new Subject <object?>();
using var view = new FilteredView <int>(source, x => true, TimeSpan.FromMilliseconds(10), scheduler, leaveOpen: true, triggers: trigger);
using var actual = view.SubscribeAll();
source.Add(4);
for (var i = 0; i < 10; i++)
{
trigger.OnNext(null);
}
CollectionAssert.IsEmpty(actual);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, view);
scheduler.Start();
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(4, 3),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, view);
}
public static void Add()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
using var view = source.AsMappingView(Collections.ReadOnlyViews.MappingViewTests.Model.Create);
CollectionAssert.AreEqual(source, view.Select(x => x.Value));
using var actual = view.SubscribeAll();
source.Add(4);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[3], 3),
};
CollectionAssert.AreEqual(source, view.Select(x => x.Value));
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(5);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[4], 4),
});
CollectionAssert.AreEqual(source, view.Select(x => x.Value));
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void ReplaceFilteredWithVisible()
{
var source = new ObservableCollection <int> {
1
};
var scheduler = new TestScheduler();
using (var view = source.AsReadOnlyFilteredView(x => x % 2 == 0, scheduler))
{
scheduler.Start();
using (var changes = view.SubscribeAll())
{
source[0] = 2;
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2 }, view);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default);
}
}
}
public void FilterRemoveOneThenAdd()
{
_view.Filter = x => x < 3;
_scheduler?.Start();
CollectionAssert.AreEqual(new[] { 1, 2 }, _view);
_expected.Add(Notifier.CountPropertyChangedEventArgs);
_expected.Add(Notifier.IndexerPropertyChangedEventArgs);
_expected.Add(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, 3, 2));
_actual.RemoveAll(
x =>
x is PropertyChangedEventArgs &&
((PropertyChangedEventArgs)x).PropertyName == FilterChangedEventArgs.PropertyName);
CollectionAssert.AreEqual(_expected, _actual, EventArgsComparer.Default);
_view.Filter = x => true;
_scheduler?.Start();
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, _view);
_expected.Add(Notifier.CountPropertyChangedEventArgs);
_expected.Add(Notifier.IndexerPropertyChangedEventArgs);
_expected.Add(Diff.CreateAddEventArgs(3, 2));
_actual.RemoveAll(
x =>
x is PropertyChangedEventArgs &&
((PropertyChangedEventArgs)x).PropertyName == FilterChangedEventArgs.PropertyName);
CollectionAssert.AreEqual(_expected, _actual, EventArgsComparer.Default);
}
public static void Add()
{
var source = new ObservableCollection <int>();
using var modelView = source.AsMappingView(Collections.ReadOnlyViews.MappingViewTests.Model.Create);
using var modelViewChanges = modelView.SubscribeAll();
using var indexedView = modelView.AsMappingView(
Collections.ReadOnlyViews.MappingViewTests.Vm.Create,
(x, i) => x);
using var indexedChanges = indexedView.SubscribeAll();
using var vmView = modelView.AsMappingView(Collections.ReadOnlyViews.MappingViewTests.Vm.Create);
using var vmViewChanges = vmView.SubscribeAll();
source.Add(1);
var expected = new EventArgs?[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
null,
};
expected[2] = Diff.CreateAddEventArgs(modelView[0], 0);
CollectionAssert.AreEqual(expected, modelViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateAddEventArgs(vmView[0], 0);
CollectionAssert.AreEqual(expected, vmViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateAddEventArgs(indexedView[0], 0);
CollectionAssert.AreEqual(expected, indexedChanges, EventArgsComparer.Default);
}
public void OnNextAddsOne()
{
using (var subject = new Subject <IEnumerable <int> >())
{
using (var view = subject.AsReadOnlyView())
{
using (var actual = view.SubscribeAll())
{
subject.OnNext(new[] { 1 });
CollectionAssert.AreEqual(new[] { 1 }, view);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(1, 0),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
subject.OnNext(new[] { 1, 2 });
CollectionAssert.AreEqual(new[] { 1, 2 }, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 1),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
}
public async Task AddFiltered()
{
var source = new ObservableCollection <int> {
1, 2, 3
};
using (var view = source.AsFilteredView(x => x % 2 == 0))
{
using (var actual = view.SubscribeAll())
{
view.Add(4);
await Application.Current.Dispatcher.SimulateYield();
CollectionAssert.AreEqual(new[] { 2, 4 }, view);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, source);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(4, 1)
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
public void AddVisibleWhenFilteredBuffered()
{
var source = new ObservableCollection <int>();
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.IsEmpty(view);
CollectionAssert.IsEmpty(actual);
source.Add(2);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2 }, view);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
public void NotifiesAdd()
{
var ints = new ObservableCollection <int>();
var expected = ints.SubscribeAll();
var modelView = ints.AsMappingView(x => new Model(x));
var modelViewChanges = modelView.SubscribeAll();
var indexedView = modelView.AsMappingView((x, i) => new Vm {
Model = x, Index = i
});
var indexedChanges = indexedView.SubscribeAll();
var vmView = modelView.AsMappingView(x => new Vm {
Model = x
});
var vmViewChanges = vmView.SubscribeAll();
ints.Add(1);
expected[2] = Diff.CreateAddEventArgs(modelView[0], 0);
CollectionAssert.AreEqual(expected, modelViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateAddEventArgs(vmView[0], 0);
CollectionAssert.AreEqual(expected, vmViewChanges, EventArgsComparer.Default);
expected[2] = Diff.CreateAddEventArgs(indexedView[0], 0);
CollectionAssert.AreEqual(expected, indexedChanges, EventArgsComparer.Default);
}
public static void SetSourceAdd()
{
using var view = new ReadOnlySerialView <int>(new[] { 1, 2, 3 });
using var actual = view.SubscribeAll();
var newSource1 = new[] { 1, 2, 3, 4 };
view.SetSource(newSource1);
CollectionAssert.AreEqual(newSource1, view);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(4, 3),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
var newSource2 = new ObservableCollection <int> {
1, 2, 3, 4, 5
};
view.SetSource(newSource2);
CollectionAssert.AreEqual(newSource2, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(5, 4),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void FilterRemoveOneThenAdd()
{
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>();
expected.Add(CachedEventArgs.CountPropertyChanged);
expected.Add(CachedEventArgs.IndexerPropertyChanged);
expected.Add(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, 3, 2));
Assert.AreEqual(1, actual.Count(x => EventArgsComparer.Equals(x, FilterChangedEventArgs)));
CollectionAssert.AreEqual(expected, actual.Where(x => !EventArgsComparer.Equals(x, FilterChangedEventArgs)), EventArgsComparer.Default);
this.View.Filter = x => true;
this.Scheduler?.Start();
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, this.View);
expected.Add(CachedEventArgs.CountPropertyChanged);
expected.Add(CachedEventArgs.IndexerPropertyChanged);
expected.Add(Diff.CreateAddEventArgs(3, 2));
Assert.AreEqual(2, actual.Count(x => EventArgsComparer.Equals(x, FilterChangedEventArgs)));
CollectionAssert.AreEqual(expected, actual.Where(x => !EventArgsComparer.Equals(x, FilterChangedEventArgs)), EventArgsComparer.Default);
}
}
public static void ObserveValueAsReadOnlyViewWhenArrayOfTWhenCast()
{
var with = new With <int[]>();
using var view = with.ObserveValue(x => x.Value).Select(x => (IMaybe <int[]>)x).AsReadOnlyView();
using var actual = view.SubscribeAll();
with.Value = new[] { 1 };
CollectionAssert.AreEqual(new[] { 1 }, view);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(1, 0),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
with.Value = new[] { 1, 2 };
CollectionAssert.AreEqual(new[] { 1, 2 }, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 1),
CachedEventArgs.GetOrCreatePropertyChangedEventArgs("Source"),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
private static IReadOnlyList <EventArgs> CreateAddEventArgsCollection(object item, int index)
{
return(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
Diff.CreateAddEventArgs(item, index),
});
}
public void Reacts()
{
var changes = new List <NotifyCollectionChangedEventArgs>();
var source = new ObservableCollection <int>();
source.ObserveCollectionChangedSlim(false)
.Subscribe(changes.Add);
source.Add(1);
CollectionAssert.AreEqual(new[] { Diff.CreateAddEventArgs(1, 0) }, changes, EventArgsComparer.Default);
}
public void NotifiesWithOnlyCollectionChangedSubscription()
{
var ints = new ObservableCollection <int>();
var view = ints.AsReadOnlyFilteredView(x => true);
var changes = new List <EventArgs>();
view.ObserveCollectionChangedSlim(false)
.Subscribe(x => changes.Add(x));
ints.Add(1);
var expected = new[] { Diff.CreateAddEventArgs(1, 0) };
CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default);
}
/// <inheritdoc/>
protected override void InsertItem(int index, T item)
{
var sourceIndex = index == this.Count
? this.Source.Count
: this.SourceIndex(index);
base.InsertItem(index, item);
var change = Diff.CreateAddEventArgs(item, index);
this.UpdatedSourceWith = change;
this.Notify(change);
this.Source.Insert(sourceIndex, item);
this.UpdatedSourceWith = null;
}
public void Add()
{
var source = new ObservableCollection <int>();
using (var view = source.AsMappingView(CreateStrictMock, WithIndex, x => x.Object.Dispose()))
{
using (var actual = view.SubscribeAll())
{
source.Add(1);
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.CreateAddEventArgs(view[0], 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(1);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
CollectionAssert.AreEqual(source.Select((_, i) => i), view.Select(x => x.Object.Index));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[1], 1),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(2);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
CollectionAssert.AreEqual(source.Select((_, i) => i), view.Select(x => x.Object.Index));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[2], 2),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
foreach (var mock in view)
{
mock.Setup(x => x.Dispose());
}
}
}
}
public void ReplaceFilteredWithVisible()
{
var ints = new ObservableCollection <int>(new[] { 1 });
var view = ints.AsReadOnlyFilteredView(x => x % 2 == 0);
var changes = view.SubscribeAll();
ints[0] = 2;
CollectionAssert.AreEqual(new[] { 2 }, view);
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateAddEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, changes, 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 static void Add()
{
var source = new ObservableCollection <Collections.ReadOnlyViews.MappingViewTests.Model <int> >();
using var view = source.AsMappingView(CreateStrictMock, x => x.Object.Dispose());
using var actual = view.SubscribeAll();
var model1 = Collections.ReadOnlyViews.MappingViewTests.Model.Create(1);
source.Add(model1);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[0], 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(model1);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[1], 1),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(Collections.ReadOnlyViews.MappingViewTests.Model.Create(2));
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[2], 2),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
foreach (var mock in view)
{
mock.Setup(x => x.Dispose());
}
}
public async Task AddVisibleWhenEmpty()
{
var source = new ObservableCollection <int>();
using var view = source.AsFilteredView(x => true);
using var actual = view.SubscribeAll();
view.Add(1);
await Application.Current.Dispatcher.SimulateYield();
CollectionAssert.AreEqual(new[] { 1 }, view);
CollectionAssert.AreEqual(new[] { 1 }, source);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(1, 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void Add()
{
var source = new ObservableCollection <Model <int> >();
using (var view = source.AsMappingView(Vm.Create))
{
using (var actual = view.SubscribeAll())
{
var model1 = Model.Create(1);
source.Add(model1);
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[0], 0)
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(model1);
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[1], 1)
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(Model.Create(2));
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
expected.AddRange(new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(view[2], 2)
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
}
}
public async Task ReplaceFilteredWithVisible()
{
var source = new ObservableCollection <int> {
1
};
using var view = source.AsFilteredView(x => x % 2 == 0);
using var changes = view.SubscribeAll();
source[0] = 2;
await Application.Current.Dispatcher.SimulateYield();
CollectionAssert.AreEqual(new[] { 2 }, view);
var expected = new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 0),
};
CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default);
}
public void AddVisibleWhenFiltered()
{
var ints = new ObservableCollection <int>();
var view = ints.AsFilteredView(x => x % 2 == 0);
var changes = view.SubscribeAll();
int countChanges = 0;
view.ObservePropertyChanged(x => x.Count, false)
.Subscribe(_ => countChanges++);
Assert.AreEqual(0, countChanges);
ints.Add(2);
CollectionAssert.AreEqual(new[] { 2 }, view);
var expected = new EventArgs[]
{
Notifier.CountPropertyChangedEventArgs,
Notifier.IndexerPropertyChangedEventArgs,
Diff.CreateAddEventArgs(2, 0)
};
CollectionAssert.AreEqual(expected, changes, EventArgsComparer.Default);
Assert.AreEqual(1, countChanges);
}
public static void ObservesItem()
{
var source = new ObservableCollection <With <int> > {
new With <int> {
Value = 1
}
};
using var view = source.AsReadOnlyFilteredView(x => x.Value > 1, x => x.ObserveValue(item => item.Value).Select(_ => (object?)null));
using var actual = view.SubscribeAll();
CollectionAssert.IsEmpty(view);
CollectionAssert.IsEmpty(actual);
source[0].Value = 2;
CollectionAssert.AreEqual(source, view);
var expected = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(source[0], 0),
};
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void ManyOnNextsOneAdd()
{
var subject = new Subject <object>();
_view.Triggers.Add(subject);
_ints.Add(4);
for (int i = 0; i < 10; i++)
{
subject.OnNext(null);
}
CollectionAssert.IsEmpty(_actualChanges);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, _view);
_scheduler.Start();
var expected = new EventArgs[] { Notifier.CountPropertyChangedEventArgs, Notifier.IndexerPropertyChangedEventArgs, Diff.CreateAddEventArgs(4, 3) };
CollectionAssert.AreEqual(expected, _actualChanges, EventArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, _view);
}
public static void AddManyVisibleWhenFiltered()
{
var source = new ObservableCollection <int>();
var scheduler = new TestScheduler();
using var view = source.AsReadOnlyFilteredView(x => x % 2 == 0, scheduler);
scheduler.Start();
CollectionAssert.IsEmpty(view);
using var actual = view.SubscribeAll();
source.Add(1);
scheduler.Start();
CollectionAssert.IsEmpty(view);
var expected = new List <EventArgs>();
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(2);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2 }, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(2, 0),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(3);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2 }, view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(4);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2, 4 }, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(4, 1),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(5);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2, 4 }, view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
source.Add(6);
scheduler.Start();
CollectionAssert.AreEqual(new[] { 2, 4, 6 }, view);
expected.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
Diff.CreateAddEventArgs(6, 2),
});
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
