/// <summary>
        /// This method will listen to the CurrentChanged event and will commit any add or edit
        /// operations taking place in the PagedCollectionView.
        /// </summary>
        /// <param name="sender">PagedCollectionView firing the event</param>
        /// <param name="e">CurrentChanged event args</param>
        private void CommitAddOrEditOperation(object sender, EventArgs e)
        {
            PagedCollectionView pcv = sender as PagedCollectionView;

            if (pcv != null)
            {
                if (pcv.IsAddingNew)
                {
                    pcv.CommitNew();
                }
                else if (pcv.IsEditingItem)
                {
                    pcv.CommitEdit();
                }
            }
        }
        public void OnCollectionChangedTest()
        {
            List <EditableTestClass>         efbList      = new List <EditableTestClass>();
            ObservableCollection <TestClass> fbCollection = new ObservableCollection <TestClass>();

            PagedCollectionView pcv1 = new PagedCollectionView(efbList);
            PagedCollectionView pcv2 = new PagedCollectionView(fbCollection);

            pcv1.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv2.CollectionChanged += new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.Refresh(); });

            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { fbCollection.Clear(); });

            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { fbCollection.Add(new TestClass()); });

            EditableTestClass efb;

            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { efb = pcv1.AddNew() as EditableTestClass; });

            pcv1.CommitNew();

            // Add, then Cancel to fire a Remove
            this._expectedAction = NotifyCollectionChangedAction.Add;
            this.AssertExpectedEvent(delegate { pcv1.AddNew(); });

            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.CancelNew(); });

            // Set PageSize to 1 to Reset
            this._expectedAction = NotifyCollectionChangedAction.Reset;
            this.AssertExpectedEvent(delegate { pcv1.PageSize = 1; });

            // Remove an Item
            this._expectedAction = NotifyCollectionChangedAction.Remove;
            this.AssertExpectedEvent(delegate { pcv1.RemoveAt(0); });

            pcv2.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
            pcv1.CollectionChanged -= new NotifyCollectionChangedEventHandler(this.PagedCollectionViewCollectionChanged);
        }
        public void GroupingInListBoxTest()
        {
            ObservableCollection <TestClass> collection = new ObservableCollection <TestClass>()
            {
                new TestClass {
                    IntProperty = 1, StringProperty = "A"
                },
                new TestClass {
                    IntProperty = 2, StringProperty = "B"
                },
                new TestClass {
                    IntProperty = 3, StringProperty = "A"
                },
                new TestClass {
                    IntProperty = 4, StringProperty = "B"
                }
            };

            PagedCollectionView cv = new PagedCollectionView(collection);

            ListBox lb = new ListBox();

            lb.ItemsSource = cv;

            this.CreateAsyncTask(
                lb,
                delegate
            {
                Assert.AreEqual(4, lb.Items.Count);

                cv.GroupDescriptions.Add(new PropertyGroupDescription("StringProperty"));

                Assert.AreEqual(4, lb.Items.Count);
                Assert.AreEqual("A", (lb.Items[0] as TestClass).StringProperty);
                Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                Assert.AreEqual("B", (lb.Items[2] as TestClass).StringProperty);
                Assert.AreEqual("B", (lb.Items[3] as TestClass).StringProperty);

                cv.PageSize = 3;
                cv.MoveToPage(1);

                Assert.AreEqual(1, lb.Items.Count);
                Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);

                TestClass newItem      = cv.AddNew() as TestClass;
                newItem.StringProperty = "A";
                newItem.IntProperty    = 5;

                // ---------------------
                // |Page | 0  | 1  | 2  |
                // ---------------------
                // | 0   | A  | A  | B  |
                // | 1   | B  |-A- |    | <---- Current Page
                Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);
                Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                cv.CommitNew();

                // ---------------------
                // |Page | 0  | 1  | 2  |
                // ---------------------
                // | 0   | A  | A  |-A- |
                // | 1   | B  | B  |    | <---- Current Page
                Assert.AreEqual("B", (lb.Items[0] as TestClass).StringProperty);
                Assert.AreEqual("B", (lb.Items[1] as TestClass).StringProperty);

                cv.MoveToFirstPage();
                Assert.AreEqual("A", (lb.Items[0] as TestClass).StringProperty);
                Assert.AreEqual("A", (lb.Items[1] as TestClass).StringProperty);
                Assert.AreEqual("A", (lb.Items[2] as TestClass).StringProperty);
            });

            EnqueueTestComplete();
        }
        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();
        }