public void InsertWithSortingOnUnsharedPropertyTest()
{
// we will create a collection of type object, with instances of ClassA and ClassB,
// which are not related classes. however, they share a property of the same name and type
ObservableCollection<object> collection = new ObservableCollection<object>()
{
new ClassA(){IntProperty=1, SomeProperty="A"},
new ClassB(){IntProperty=3, SomeProperty=true},
new ClassA(){IntProperty=5, SomeProperty="B"},
new ClassB(){IntProperty=7, SomeProperty=false},
};
PagedCollectionView pcv = new PagedCollectionView(collection);
// first verify that we can sort
pcv.SortDescriptions.Add(new SortDescription("IntProperty", ListSortDirection.Descending));
Assert.AreEqual(typeof(ClassB), pcv[0].GetType());
Assert.AreEqual(typeof(ClassA), pcv[1].GetType());
Assert.AreEqual(typeof(ClassB), pcv[2].GetType());
Assert.AreEqual(typeof(ClassA), pcv[3].GetType());
// next insert an item and verify that it gets correctly inserted based on
// the correct sort index
ClassA addItem = new ClassA() { IntProperty = 4, SomeProperty = "C" };
collection.Add(addItem);
Assert.AreEqual(2, pcv.IndexOf(addItem));
// now test on the other property that has the same name
// but different type. we should not get an error, and just
// treat the variable as a null or default value
pcv.SortDescriptions.Clear();
pcv.SortDescriptions.Add(new SortDescription("SomeProperty", ListSortDirection.Ascending));
Assert.AreEqual("3 True", pcv[0].ToString());
Assert.AreEqual("7 False", pcv[1].ToString());
Assert.AreEqual("1 A", pcv[2].ToString());
Assert.AreEqual("5 B", pcv[3].ToString());
Assert.AreEqual("4 C", pcv[4].ToString());
}
public void AddRemoveEventsWithListBoxTest()
{
ObservableCollection<TestClass> collection = new ObservableCollection<TestClass>()
{
new TestClass { IntProperty = 1, StringProperty = "A" },
new TestClass { IntProperty = 1, StringProperty = "C" },
new TestClass { IntProperty = 2, StringProperty = "D" }
};
PagedCollectionView cv = new PagedCollectionView(collection);
ListBox lb = new ListBox();
lb.ItemsSource = cv;
this.CreateAsyncTask(
lb,
delegate
{
Assert.AreEqual(3, lb.Items.Count);
cv.AddNew();
cv.CommitNew();
Assert.AreEqual(4, lb.Items.Count);
cv.RemoveAt(3);
Assert.AreEqual(3, lb.Items.Count);
cv.SortDescriptions.Add(new System.ComponentModel.SortDescription("StringProperty", System.ComponentModel.ListSortDirection.Ascending));
TestClass newItem1 = new TestClass() { StringProperty = "B", IntProperty = 2 };
collection.Add(newItem1);
// Should have inserted into due to sorting
// {A, [B], C, D}
Assert.AreEqual(1, cv.IndexOf(newItem1));
Assert.AreEqual(1, lb.Items.IndexOf(newItem1));
cv.GroupDescriptions.Add(new PropertyGroupDescription("IntProperty"));
// Should now be grouped as
// {1A, 1C}
// {2B, 2D}
Assert.AreEqual(2, lb.Items.IndexOf(newItem1));
TestClass newItem2 = new TestClass() { StringProperty = "E", IntProperty = 1 };
collection.Add(newItem2);
// Should have inserted into due here to sorting/grouping
// {1A, 1C, [1E]}
// {2B, 2D}
Assert.AreEqual(2, cv.IndexOf(newItem2));
Assert.AreEqual(2, lb.Items.IndexOf(newItem2));
// Testing that with sorting/grouping, item is removed from the correct index
cv.RemoveAt(1);
Assert.AreEqual(newItem2, lb.Items[1]);
// Test 'Replace' operation.
TestClass newItem3 = new TestClass() { StringProperty = "F", IntProperty = 2 };
TestClass replacedItem = collection[0];
collection[0] = newItem3;
// This operation should have deleted old and added new
// {[-deleted-], 1E}
// {2B, 2D, [2F]}
Assert.AreEqual(-1, lb.Items.IndexOf(replacedItem));
Assert.AreEqual(3, lb.Items.IndexOf(newItem3));
});
EnqueueTestComplete();
}