public void EventRemove()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1);
NotifyCollectionChangedEventArgs MyEventArgs = null;
//****************************************
var MyView = new ObservableListView <int>(MyRecords);
MyRecords.Add(42);
MyView.CollectionChanged += (sender, e) => MyEventArgs = e;
MyRecords.RemoveAt(0);
//****************************************
Assert.AreEqual(0, MyView.Count, "Item count does not match");
Assert.IsNotNull(MyEventArgs, "No Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Remove, MyEventArgs.Action);
Assert.IsNotNull(MyEventArgs.OldItems, "No Old Items");
Assert.AreEqual(0, MyEventArgs.OldStartingIndex, "Starting Index incorrect");
Assert.AreEqual(1, MyEventArgs.OldItems.Count, "Old Items Count incorrect");
Assert.AreEqual(42, MyEventArgs.OldItems[0], "Old Items Value incorrect");
}
public void PrePopulateFilter([Values(16, 24, 777, 1024)] int count)
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(count);
//****************************************
for (int Index = 0; Index < count; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
//****************************************
var MyView = new ObservableListView <int>(MyRecords, FilterMoreThan512);
//****************************************
var MySortedRecords = MyRecords.Where(FilterMoreThan512).ToArray();
Array.Sort(MySortedRecords);
CollectionAssert.AreEqual(MySortedRecords, MyView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void PrePopulateMaximum([Values(256, 512, 1024, 2048)] int maximum)
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
//****************************************
var MyView = new ObservableListView <int>(MyRecords, maximum);
//****************************************
var MySortedRecords = MyRecords.ToArray();
Array.Sort(MySortedRecords);
if (MySortedRecords.Length > maximum)
{
Array.Resize(ref MySortedRecords, maximum);
}
CollectionAssert.AreEqual(MySortedRecords, MyView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void CollectionChangedTest()
{
var originalCollection = new ObservableCollection <MyModel>()
{
new MyModel()
};
var listView = new ObservableListView <MyModel>(originalCollection);
AssertHelper.SequenceEqual(originalCollection, listView);
// Check add operation with collection changed event.
bool handlerCalled = false;
void Handler(object sender, NotifyCollectionChangedEventArgs e)
{
handlerCalled = true;
Assert.AreEqual(listView, sender);
Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action);
Assert.AreEqual(1, e.NewStartingIndex);
Assert.AreEqual(originalCollection.Last(), e.NewItems.Cast <MyModel>().Single());
}
listView.CollectionChanged += Handler;
originalCollection.Add(new MyModel());
Assert.IsTrue(handlerCalled);
// After dispose the collection does not synchronize anymore
handlerCalled = false;
listView.Dispose();
originalCollection.Add(new MyModel());
Assert.IsFalse(handlerCalled);
listView.CollectionChanged -= Handler;
}
public void RemoveFilter()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
var MyView = new ObservableListView <int>(MyRecords, FilterLessThan512);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
for (int Index = 0; Index < 512; Index++)
{
MyRecords.RemoveAt(MyRandom.Next(MyRecords.Count));
}
//****************************************
var MySortedRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MySortedRecords);
CollectionAssert.AreEqual(MySortedRecords, MyView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void ReplaceFilterSeed([Values(357656222)] int seed)
{ //****************************************
var MyRandom = new Random(seed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
var MyView = new ObservableListView <int>(MyRecords, FilterLessThan512);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
for (int Index = 0; Index < 1024; Index++)
{
var MyInnerRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MyInnerRecords);
CollectionAssert.AreEqual(MyInnerRecords, MyView, "Iteration {0}", Index);
MyRecords[MyRandom.Next(1024)] = MyRandom.Next(short.MaxValue);
}
//****************************************
var MySortedRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MySortedRecords);
CollectionAssert.AreEqual(MySortedRecords, MyView);
Thread.Sleep(1);
}
public void PrePopulate()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
//****************************************
var MyView = new ObservableListView <int>(MyRecords);
//****************************************
var MySortedRecords = MyRecords.ToArray();
Array.Sort(MySortedRecords);
CollectionAssert.AreEqual(MySortedRecords, MyView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void EventRemoveMaximumFilter([Values(256, 512, 1024)] int maximum)
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
var MyView = new ObservableListView <int>(MyRecords, FilterLessThan512, maximum);
var MyTopView = new ObservableListView <int>(MyView);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
for (int Index = 0; Index < 512; Index++)
{
MyRecords.RemoveAt(MyRandom.Next(MyRecords.Count));
}
//****************************************
var MySortedRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MySortedRecords);
if (MySortedRecords.Length > maximum)
{
Array.Resize(ref MySortedRecords, maximum);
}
CollectionAssert.AreEqual(MySortedRecords, MyTopView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void EventReplaceMaximumSeed([Values(355591720, 356919648)] int seed, [Values(256, 512)] int maximum)
{ //****************************************
var MyRandom = new Random(seed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
var MyView = new ObservableListView <int>(MyRecords, maximum);
var MyTopView = new ObservableListView <int>(MyView);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
for (int Index = 0; Index < 1024; Index++)
{
CollectionAssert.AreEqual(MyView, MyTopView, "Iteration {0}", Index);
MyRecords[MyRandom.Next(1024)] = MyRandom.Next(short.MaxValue);
}
//****************************************
var MySortedRecords = MyRecords.ToArray();
Array.Sort(MySortedRecords);
if (MySortedRecords.Length > maximum)
{
Array.Resize(ref MySortedRecords, maximum);
}
CollectionAssert.AreEqual(MySortedRecords, MyTopView);
Thread.Sleep(1);
}
protected override void OnInitialize()
{
base.OnInitialize();
originalList = new ObservableCollection <string>();
observableListView = new ObservableListView <string>(originalList);
NotifyCollectionChangedEventHandler collectionHandler = (sender, e) =>
{
eventArgs = e;
};
observableListView.CollectionChanged += collectionHandler;
PropertyChangedEventHandler propertyHandler = (sender, e) =>
{
if (e.PropertyName == nameof(observableListView.Count))
{
countChangedCount++;
}
else if (e.PropertyName == "Item[]")
{
indexerChangedCount++;
}
};
observableListView.PropertyChanged += propertyHandler;
}
public void EventRemoveMany()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
int EventCount = 0;
//****************************************
var MyView = new ObservableListView <int>(MyRecords);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
MyView.CollectionChanged += (sender, e) => { if (e.Action == NotifyCollectionChangedAction.Remove)
{
EventCount++;
}
};
while (MyRecords.Count > 0)
{
MyRecords.RemoveAt(MyRecords.Count - 1);
}
//****************************************
Assert.AreEqual(0, MyView.Count, "Item count does not match");
Assert.AreEqual(1024, EventCount, "Event Count does not match");
}
private void UpdateItemsListView()
{
itemsListView = new ObservableListView <FeedItem>(SelectionService.SelectedFeed?.Items ?? CollectionHelper.Empty <FeedItem>())
{
Filter = FilterFeedItems
};
RaisePropertyChanged(nameof(ItemsListView));
}
public void Initialize()
{
contactsView = new ObservableListView <Contact>(Root.Contacts, null, ContactListViewModel.Filter, null);
ContactListViewModel.Contacts = contactsView;
ContactListViewModel.SelectedContact = Root.Contacts.FirstOrDefault();
selectContactViewModel.ContactListView = ContactListViewModel.View;
selectContactViewModel.OkCommand = selectContactCommand;
contactListViewModelPropertyChangedProxy = WeakEvent.PropertyChanged.Add(ContactListViewModel, ContactListViewModelPropertyChanged);
}
public void Initialize()
{
emailsView = new ObservableListView <Email>(EmailFolder.Emails, filter: EmailListViewModel.Filter, sort: x => x.OrderByDescending(y => y.Sent));
EmailListViewModel.Emails = emailsView;
EmailListViewModel.DeleteEmailCommand = DeleteEmailCommand;
PropertyChangedEventManager.AddHandler(EmailListViewModel, EmailListViewModelPropertyChanged, "");
emailLayoutViewModel.EmailListView = EmailListViewModel.View;
emailLayoutViewModel.EmailView = EmailViewModel.View;
}
public void Initialize()
{
emailsView = new ObservableListView <Email>(EmailFolder.Emails, null, EmailListViewModel.Filter, x => x.OrderByDescending(y => y.Sent));
EmailListViewModel.Emails = emailsView;
EmailListViewModel.DeleteEmailCommand = DeleteEmailCommand;
emailListViewModelPropertyChangedProxy = WeakEvent.PropertyChanged.Add(EmailListViewModel, EmailListViewModelPropertyChanged);
emailLayoutViewModel.EmailListView = EmailListViewModel.View;
emailLayoutViewModel.EmailView = EmailViewModel.View;
}
static WeakReference WeakTest(ObservableCollection <MyModel> originalCollection)
{
var listView = new ObservableListView <MyModel>(originalCollection);
var weakListView = new WeakReference(listView);
originalCollection.Add(new MyModel());
Assert.IsTrue(weakListView.IsAlive);
return(weakListView);
}
public void Initialize()
{
contactsView = new ObservableListView <Contact>(Root.Contacts, null, ContactListViewModel.Filter, null);
ContactListViewModel.Contacts = contactsView;
ContactListViewModel.SelectedContact = Root.Contacts.FirstOrDefault();
selectContactViewModel.ContactListView = ContactListViewModel.View;
selectContactViewModel.OkCommand = selectContactCommand;
PropertyChangedEventManager.AddHandler(ContactListViewModel, ContactListViewModelPropertyChanged, "");
}
public void Initialize()
{
contactsView = new ObservableListView <Contact>(Root !.Contacts, null, ContactListViewModel.Filter, null);
ContactListViewModel.Contacts = contactsView;
ContactListViewModel.DeleteContactCommand = DeleteContactCommand;
WeakEvent.PropertyChanged.Add(ContactListViewModel, ContactListViewModelPropertyChanged);
contactLayoutViewModel.ContactListView = ContactListViewModel.View;
contactLayoutViewModel.ContactView = ContactViewModel.View;
}
public void Initialize()
{
contactsView = new ObservableListView <Contact>(Root.Contacts, null, ContactListViewModel.Filter, null);
ContactListViewModel.Contacts = contactsView;
ContactListViewModel.DeleteContactCommand = DeleteContactCommand;
PropertyChangedEventManager.AddHandler(ContactListViewModel, ContactListViewModelPropertyChanged, "");
contactLayoutViewModel.ContactListView = ContactListViewModel.View;
contactLayoutViewModel.ContactView = ContactViewModel.View;
}
public void Initialize()
{
personViewModel.CreateNewEmailCommand = createNewEmailCommand;
personViewModel.PropertyChanged += PersonViewModelPropertyChanged;
PersonsView = new ObservableListView <Person>(entityService.Persons, null, personListViewModel.Filter, null);
personListViewModel.Persons = PersonsView;
personListViewModel.AddNewCommand = addNewCommand;
personListViewModel.RemoveCommand = removeCommand;
personListViewModel.CreateNewEmailCommand = createNewEmailCommand;
personListViewModel.PropertyChanged += PersonListViewModelPropertyChanged;
shellService.PersonListView = personListViewModel.View;
shellService.PersonView = personViewModel.View;
personListViewModel.SelectedPerson = personListViewModel.Persons.FirstOrDefault();
}
public void WeakEventHandlerTest()
{
var originalCollection = new ObservableCollection <MyModel>();
var listView = new ObservableListView <MyModel>(originalCollection);
var weakListView = new WeakReference(listView);
originalCollection.Add(new MyModel());
Assert.IsTrue(weakListView.IsAlive);
listView = null;
GC.Collect();
Assert.IsNotNull(originalCollection);
Assert.IsFalse(weakListView.IsAlive);
}
public void Initialize()
{
personViewModel.CreateNewEmailCommand = createNewEmailCommand;
PropertyChangedEventManager.AddHandler(personViewModel, PersonViewModelPropertyChanged, "");
PersonsView = new ObservableListView <Person>(entityService.Persons, filter: personListViewModel.Filter);
personListViewModel.Persons = PersonsView;
personListViewModel.AddNewCommand = addNewCommand;
personListViewModel.RemoveCommand = removeCommand;
personListViewModel.CreateNewEmailCommand = createNewEmailCommand;
PropertyChangedEventManager.AddHandler(personListViewModel, PersonListViewModelPropertyChanged, "");
shellService.PersonListView = personListViewModel.View;
shellService.PersonView = personViewModel.View;
personListViewModel.SelectedPerson = personListViewModel.Persons.FirstOrDefault();
}
public void Initialize()
{
bookViewModel.LendToCommand = lendToCommand;
bookViewModel.PropertyChanged += BookViewModelPropertyChanged;
bookDataModels = new SynchronizingCollection <BookDataModel, Book>(entityService.Books, b => new BookDataModel(b, lendToCommand));
BooksView = new ObservableListView <BookDataModel>(bookDataModels, null, bookListViewModel.Filter, null);
bookListViewModel.Books = BooksView;
bookListViewModel.AddNewCommand = addNewCommand;
bookListViewModel.RemoveCommand = removeCommand;
bookListViewModel.PropertyChanged += BookListViewModelPropertyChanged;
shellService.BookListView = bookListViewModel.View;
shellService.BookView = bookViewModel.View;
bookListViewModel.SelectedBook = bookListViewModel.Books.FirstOrDefault();
}
public void EventMove()
{ //****************************************
var MySeed = Environment.TickCount;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1);
NotifyCollectionChangedEventArgs MyFirstEventArgs = null, MySecondEventArgs = null;
//****************************************
var MyView = new ObservableListView <int>(MyRecords);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
MyView.CollectionChanged += (sender, e) => { if (MyFirstEventArgs == null)
{
MyFirstEventArgs = e;
}
else
{
MySecondEventArgs = e;
} };
var OldValue = MyRecords[512];
var NewValue = OldValue + 1024;
MyRecords[512] = NewValue;
//****************************************
Assert.AreEqual(1024, MyView.Count, "Item count does not match");
Assert.IsNotNull(MyFirstEventArgs, "No First Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Remove, MyFirstEventArgs.Action);
Assert.IsNotNull(MySecondEventArgs, "No Second Event Raised");
Assert.AreEqual(NotifyCollectionChangedAction.Add, MySecondEventArgs.Action);
Assert.IsNotNull(MyFirstEventArgs.OldItems, "No Old Items");
Assert.AreEqual(1, MyFirstEventArgs.OldItems.Count, "Old Items Count incorrect");
Assert.AreEqual(OldValue, MyFirstEventArgs.OldItems[0], "Old Items Value incorrect");
Assert.IsNotNull(MySecondEventArgs.NewItems, "No New Items");
Assert.AreEqual(1, MySecondEventArgs.NewItems.Count, "New Items Count incorrect");
Assert.AreEqual(NewValue, MySecondEventArgs.NewItems[0], "New Items Value incorrect");
}
public void ReplaceMaximumFilterSeed()
{ //****************************************
var MySeed = 356114168;
var MyRandom = new Random(MySeed);
var MyRecords = new ObservableList <int>(1024);
//****************************************
var MyView = new ObservableListView <int>(MyRecords, FilterLessThan512, 256);
for (int Index = 0; Index < 1024; Index++)
{
MyRecords.Add(MyRandom.Next(short.MaxValue));
}
for (int Index = 0; Index < 1024; Index++)
{
var MyInnerRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MyInnerRecords);
if (MyInnerRecords.Length > 256)
{
Array.Resize(ref MyInnerRecords, 256);
}
CollectionAssert.AreEqual(MyInnerRecords, MyView, "Iteration {0}", Index);
MyRecords[MyRandom.Next(1024)] = MyRandom.Next(short.MaxValue);
}
//****************************************
var MySortedRecords = MyRecords.Where(FilterLessThan512).ToArray();
Array.Sort(MySortedRecords);
if (MySortedRecords.Length > 256)
{
Array.Resize(ref MySortedRecords, 256);
}
CollectionAssert.AreEqual(MySortedRecords, MyView, "Bad Seed was {0}", MySeed);
Thread.Sleep(1);
}
public void DisposeTest()
{
var originalCollection = new ObservableCollection <MyModel>();
var filterCalled = false;
var listView = new ObservableListView <MyModel>(originalCollection, null, x =>
{
filterCalled = true;
return(true);
}, null);
originalCollection.Add(new MyModel());
Assert.IsTrue(filterCalled);
// Calling dispose twice must not throw an exception.
listView.Dispose();
listView.Dispose();
filterCalled = false;
originalCollection.Add(new MyModel());
Assert.IsFalse(filterCalled);
}
public void ConstructorTest()
{
var originalList = new ObservableCollection <string>(new[] { "D", "A", "c", "b" });
Predicate <string> filter = x => x != "c";
Func <IEnumerable <string>, IOrderedEnumerable <string> > sort = x => x.OrderBy(y => y);
var listView = new ObservableListView <string>(originalList, StringComparer.OrdinalIgnoreCase);
listView.Filter = filter;
listView.Sort = sort;
AssertHelper.SequenceEqual(new[] { "A", "b", "D" }, listView);
listView.Dispose();
listView = new ObservableListView <string>(originalList, StringComparer.OrdinalIgnoreCase, filter, sort);
AssertHelper.SequenceEqual(new[] { "A", "b", "D" }, listView);
Assert.AreSame(filter, listView.Filter);
Assert.AreSame(sort, listView.Sort);
listView.Dispose();
AssertHelper.ExpectedException <ArgumentNullException>(() => new ObservableListView <string>(null !));
}
public MockSelectionService()
{
innerMusicFiles = new ObservableCollection <MusicFileDataModel>();
SelectedMusicFiles = new ObservableCollection <MusicFileDataModel>();
MusicFiles = new ObservableListView <MusicFileDataModel>(innerMusicFiles);
}
public void Initialize(IEnumerable <MusicFile> musicFiles)
{
MusicFiles = new ObservableListView <MusicFileDataModel>(
new SynchronizingCollection <MusicFileDataModel, MusicFile>(musicFiles, x => new MusicFileDataModel(x)));
}
