public static void Refresh()
{
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 ObservableBatchCollection <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 expected = source.SubscribeAll();
using var actual = view.SubscribeAll();
CollectionAssert.IsEmpty(actual);
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
source.AddRange(new[] { model1, model2, model2 });
CollectionAssert.AreEqual(source, view.Select(x => x.Model));
CollectionAssert.AreEqual(expected, actual);
source.Clear();
CollectionAssert.IsEmpty(view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
}
public void AddRange()
{
var batchCollection = new ObservableBatchCollection <int>();
using (var actualChanges = batchCollection.SubscribeAll())
{
var expectedChanges = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
CachedEventArgs.NotifyCollectionReset,
};
batchCollection.AddRange(new[] { 1, 2 });
CollectionAssert.AreEqual(new[] { 1, 2 }, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
batchCollection.AddRange(new[] { 3, 4 });
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, batchCollection);
expectedChanges.AddRange(
new EventArgs[]
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
CachedEventArgs.NotifyCollectionReset,
});
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
}
}
public MainWindowVM(
IEnumerable <UpdaterProcess> updaters)
{
Updaters = new ObservableBatchCollection <UpdaterVM>(
updaters.Select(updater => new UpdaterVM(updater)));
updateAllCommand = new RelayCommand(() =>
{
foreach (var updater in Updaters)
{
if (updater.UpdateCommand.CanExecute(null))
{
updater.UpdateCommand.Execute(null);
}
}
}, () =>
{
return(Updaters.All(updater => updater.UpdateCommand.CanExecute(null)));
});
foreach (var updater in Updaters)
{
updater.UpdateCommand.CanExecuteChanged += UpdateAllCommandCanExecuteChanged;
updater.PropertyChanged += UpdaterPropertyChanged;
}
QuitCommand = new RelayCommand(() =>
{
App.Current.MainWindow.Close();
});
}
public void Refresh()
{
var source = new ObservableBatchCollection <int>
{
1,
1,
1,
2,
2,
2,
3,
3,
3,
};
using (var view = source.AsMappingView(CreateStrictMock, WithIndex, x => x.Object.Dispose()))
{
using (var expected = source.SubscribeAll())
{
using (var actual = view.SubscribeAll())
{
CollectionAssert.IsEmpty(actual);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
CollectionAssert.AreEqual(source.Select((_, i) => i), view.Select(x => x.Object.Index));
var mocks = view.ToArray();
foreach (var mock in mocks)
{
mock.Setup(x => x.Dispose());
}
source.AddRange(new[] { 1, 2, 2 });
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Value));
CollectionAssert.AreEqual(source.Select((_, i) => i), view.Select(x => x.Object.Index));
CollectionAssert.AreEqual(expected, actual);
foreach (var mock in mocks)
{
mock.Verify(x => x.Dispose(), Times.Once);
}
mocks = view.ToArray();
foreach (var mock in mocks)
{
mock.Setup(x => x.Dispose());
}
source.Clear();
CollectionAssert.IsEmpty(view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
foreach (var mock in mocks)
{
mock.Verify(x => x.Dispose(), Times.Once);
}
}
}
}
}
public void Add()
{
var reference = new ObservableCollection <int>();
var expectedEvents = reference.SubscribeAllEvents();
var batchCol = new ObservableBatchCollection <int>();
var actualEvents = batchCol.SubscribeAllEvents();
reference.Add(1);
batchCol.Add(1);
CollectionAssert.AreEqual(expectedEvents, actualEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(reference, batchCol);
}
public void RefreshAddSingle()
{
var reference = new ObservableCollection <int>();
var expectedEvents = reference.SubscribeAllEvents();
var errors = new ObservableBatchCollection <int>();
var allEvents = errors.SubscribeAllEvents();
errors.Refresh(new[] { 1 });
reference.Add(1);
CollectionAssert.AreEqual(expectedEvents, allEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(reference, errors);
}
public void Refresh()
{
var model1 = Model.Create(1);
var model2 = Model.Create(2);
var model3 = Model.Create(3);
var source = new ObservableBatchCollection <Model <int> >(
new[]
{
model1,
model1,
model1,
model2,
model2,
model2,
model3,
model3,
model3,
});
using (var view = source.AsMappingView(CreateStrictMock, x => x.Object.Dispose()))
{
using (var expected = source.SubscribeAll())
{
using (var actual = view.SubscribeAll())
{
CollectionAssert.IsEmpty(actual);
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
source.AddRange(new[] { model1, model2, model2 });
CollectionAssert.AreEqual(source, view.Select(x => x.Object.Model));
CollectionAssert.AreEqual(expected, actual);
var mocks = view.ToArray();
foreach (var mock in mocks)
{
mock.Setup(x => x.Dispose());
}
source.Clear();
CollectionAssert.IsEmpty(view);
CollectionAssert.AreEqual(expected, actual, EventArgsComparer.Default);
foreach (var mock in mocks)
{
mock.Verify(x => x.Dispose(), Times.Once);
}
}
}
}
}
public KanjiProperties(
KanjiDict kanjiDict,
Kradfile kradfile,
Radkfile radkfile,
RadicalRemapper remapper)
{
this.kradfile = kradfile;
this.radkfile = radkfile;
this.remapper = remapper;
KanjiOrderings = new ObservableBatchCollection <KanjiOrdering>
{
KanjiOrdering.Create("Sort by stroke count", kanjiDict, x => x.StrokeCount),
KanjiOrdering.Create("Sort by frequency", kanjiDict, x => x.FrequencyRating)
};
}
public void SerializeRountrip()
{
var binaryFormatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
var ints = new ObservableBatchCollection <int> {
1, 2
};
binaryFormatter.Serialize(stream, ints);
stream.Position = 0;
var roundtripped = (ObservableBatchCollection <int>)binaryFormatter.Deserialize(stream);
Assert.AreEqual(ints, roundtripped);
}
}
public void AddRange()
{
var batchCol = new ObservableBatchCollection <int>();
var actualEvents = batchCol.SubscribeAllEvents();
batchCol.AddRange(new[] { 1, 2, 3 });
var expectedEvents = new EventArgs[]
{
new PropertyChangedEventArgs("Count"),
new PropertyChangedEventArgs("Item[]"),
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)
};
CollectionAssert.AreEqual(expectedEvents, actualEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, batchCol);
}
public void RefreshRemoveSingleEmpty()
{
var reference = new ObservableCollection <int> {
1
};
var expectedEvents = reference.SubscribeAllEvents();
var errors = new ObservableBatchCollection <int> {
1
};
var allEvents = errors.SubscribeAllEvents();
errors.Refresh(new int[0]);
reference.Remove(1);
CollectionAssert.AreEqual(expectedEvents, allEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(reference, errors);
}
public void ResetTo()
{
var batchCollection = new ObservableBatchCollection <int> {
1, 2, 3
};
using var actualChanges = batchCollection.SubscribeAll();
batchCollection.ResetTo(new[] { 4, 5 });
CollectionAssert.AreEqual(new[] { 4, 5 }, batchCollection);
var expectedChanges = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
CachedEventArgs.NotifyCollectionReset,
};
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
}
public void AddRangeSingle()
{
var reference = new ObservableCollection <int>();
using var expectedChanges = reference.SubscribeAll();
var batchCollection = new ObservableBatchCollection <int>();
using var actualChanges = batchCollection.SubscribeAll();
reference.Add(1);
batchCollection.AddRange(new[] { 1 });
CollectionAssert.AreEqual(reference, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
reference.Add(2);
batchCollection.AddRange(new[] { 2 });
CollectionAssert.AreEqual(reference, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
}
public void RefreshAddMany()
{
var errors = new ObservableBatchCollection <int> {
1
};
var allEvents = errors.SubscribeAllEvents();
errors.Refresh(new[] { 2, 3, 4 });
var expectedEvents = new List <EventArgs>
{
new PropertyChangedEventArgs("Count"),
new PropertyChangedEventArgs("Item[]"),
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)
};
CollectionAssert.AreEqual(expectedEvents, allEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(new[] { 2, 3, 4 }, errors);
}
public void RemoveAll()
{
var batchCollection = new ObservableBatchCollection <int> {
1, 2, 3, 4
};
var reference = batchCollection.ToList();
using var actualChanges = batchCollection.SubscribeAll();
var expectedChanges = new List <EventArgs>
{
CachedEventArgs.CountPropertyChanged,
CachedEventArgs.IndexerPropertyChanged,
CachedEventArgs.NotifyCollectionReset,
};
Assert.AreEqual(reference.RemoveAll(x => x % 2 == 0), batchCollection.RemoveAll(x => x % 2 == 0));
CollectionAssert.AreEqual(reference, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
}
public void BatchRemove()
{
var reference = new ObservableCollection <int> {
1, 2
};
var expectedEvents = reference.SubscribeAllEvents();
var batchCol = new ObservableBatchCollection <int> {
1, 2
};
var actualEvents = batchCol.SubscribeAllEvents();
reference.Remove(1);
using (batchCol.BeginChange())
{
batchCol.Remove(1);
}
CollectionAssert.AreEqual(expectedEvents, actualEvents, ObservableCollectionArgsComparer.Default);
CollectionAssert.AreEqual(reference, batchCol);
}
public void Remove()
{
var reference = new ObservableCollection <int> {
1, 2, 3
};
using var expectedChanges = reference.SubscribeAll();
var batchCollection = new ObservableBatchCollection <int>(reference);
using var actualChanges = batchCollection.SubscribeAll();
reference.Remove(1);
batchCollection.Remove(1);
CollectionAssert.AreEqual(reference, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
reference.Remove(2);
batchCollection.Remove(2);
CollectionAssert.AreEqual(reference, batchCollection);
CollectionAssert.AreEqual(expectedChanges, actualChanges, EventArgsComparer.Default);
}
public TagDisplay()
{
tags = new ObservableBatchCollection <KeyValuePair <Namespace, IReadOnlyList <Tag> > >();
InitializeComponent();
}
public ContextList(string rootPath, IEnumerable <Context> children, SimpleProject project)
{
this.rootPath = rootPath;
this.project = project;
this.children = new ObservableBatchCollection <Context>(children);
}
public MainWindowModel()
{
taxonomies = new ObservableSet <TaxonomyItem>();
namespaces = new ObservableBatchCollection <NamespaceItem>();
files = new ObservableBatchCollection <FileEntry>();
}
public LineVM(IEnumerable <WordVM> words)
{
Words = new ObservableBatchCollection <WordVM>(words);
}