public int IndexOf(object dataItem)
        {
            IList list = this.List;

            if (list != null)
            {
                return(list.IndexOf(dataItem));
            }

            PagedCollectionView cv = this.DataSource as PagedCollectionView;

            if (cv != null)
            {
                return(cv.IndexOf(dataItem));
            }

            IEnumerable enumerable = this.DataSource;

            if (enumerable != null && dataItem != null)
            {
                int index = 0;
                foreach (object dataItemTmp in enumerable)
                {
                    if ((dataItem == null && dataItemTmp == null) ||
                        dataItem.Equals(dataItemTmp))
                    {
                        return(index);
                    }
                    index++;
                }
            }
            return(-1);
        }
        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();
        }