Exemple #1
0
        public void NotifyCollectionChangedEventArgsConstructor2Test()
        {
            /* Expected Behavior:
             *
             * If action is Add, success.
             * If action is Remove, success.
             * If action is Reset:
             *    If changedItems is null, success.
             *    If changedItems is non-null, throw an Argument Exception
             * If action is Move or Replace, throw an Argument Exception
             */

            IList changedItems = new List <object>();

            // Trying with Add
            var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, changedItems);

            CollectionChangedEventValidators.ValidateAddOperation(args, changedItems, "#B01");

            // Trying to add a null array
            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, null));
                Assert.Fail("Cannot call .ctor if changedItems is null.");
            }
            catch (ArgumentNullException ex)
            {
                No.Op(ex);
            }

            // Trying with Remove
            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, changedItems);

            CollectionChangedEventValidators.ValidateRemoveOperation(args, changedItems, "#B02");

            // Trying with Reset (works if changedItems is null)
            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset, null);

            CollectionChangedEventValidators.ValidateResetOperation(args, "#B03");

            try
            {
                args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset, changedItems);
                GC.KeepAlive(args);
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Reset.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }

            // Trying with Move
            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, changedItems));
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Move.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }

            // Trying with Replace
            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, changedItems));
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Replace.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }

            // Add some items, and repeat
            changedItems.Add(new object());
            changedItems.Add(new object());
            changedItems.Add(new object());

            // Trying with Add
            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, changedItems);

            CollectionChangedEventValidators.ValidateAddOperation(args, changedItems, "#B04");

            // Trying with Remove
            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, changedItems);

            CollectionChangedEventValidators.ValidateRemoveOperation(args, changedItems, "#B05");
        }
Exemple #2
0
        public void NotifyCollectionChangedEventArgsConstructor3Test()
        {
            /* Expected Behavior:
             *
             * If action is Add, success.
             * If action is Remove, success.
             * If action is Reset:
             *    If changedItem is null, success.
             *    If changedItem is non-null, throw an Argument Exception
             * If action is Move or Replace, throw an Argument Exception
             */

            var changedItem = new object();

            // Trying with Add
            var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, changedItem);

            CollectionChangedEventValidators.ValidateAddOperation(args, new[] { changedItem }, "#C01");

            // Trying with Remove
            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, changedItem);

            CollectionChangedEventValidators.ValidateRemoveOperation(args, new[] { changedItem }, "#C02");

            // Trying with Reset

            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset, (object)null);

            CollectionChangedEventValidators.ValidateResetOperation(args, "#C03");

            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset, changedItem));
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Reset.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }

            // Trying with Move
            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, changedItem));
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Move.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }

            // Trying with Replace
            try
            {
                GC.KeepAlive(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, changedItem));
                Assert.Fail("Should not be able to call .ctor with NotifyCollectionChangedAction.Replace.");
            }
            catch (ArgumentException ex)
            {
                No.Op(ex);
            }
        }
        public void ClassTest()
        {
            // Because the collection cannot change, check to make sure exceptions are thrown for modifications.

            List <char> initial = new List <char> ();

            initial.Add('A');
            initial.Add('B');
            initial.Add('C');

            ObservableCollection <char>         collection         = new ObservableCollection <char> (initial);
            ReadOnlyObservableCollection <char> readOnlyCollection = new ReadOnlyObservableCollection <char> (collection);

            // Test the events

            PropertyChangedEventHandler pceh = delegate(object sender, PropertyChangedEventArgs e)
            {
                Assert.Fail("No properties should change.");
            };

            NotifyCollectionChangedEventHandler ncceh = delegate(object sender, NotifyCollectionChangedEventArgs e)
            {
                Assert.Fail("The collection should not change.");
            };

            ((INotifyPropertyChanged)readOnlyCollection).PropertyChanged += pceh;

            ((INotifyCollectionChanged)readOnlyCollection).CollectionChanged += ncceh;

            // Done with the events.
            ((INotifyPropertyChanged)readOnlyCollection).PropertyChanged -= pceh;

            ((INotifyCollectionChanged)readOnlyCollection).CollectionChanged -= ncceh;

            Assert.AreEqual(3, readOnlyCollection.Count, "RO_1");
            CollectionChangedEventValidators.AssertEquivalentLists(initial, readOnlyCollection, "RO_2");

            // Modifying the underlying collection

            bool propChanged = false;

            pceh = delegate(object sender, PropertyChangedEventArgs e)
            {
                propChanged = true;
            };

            ncceh = delegate(object sender, NotifyCollectionChangedEventArgs e)
            {
                CollectionChangedEventValidators.ValidateAddOperation(e, new char []
                                                                      { 'I' }, 3, "RO_3");
            };

            ((INotifyPropertyChanged)readOnlyCollection).PropertyChanged += pceh;

            ((INotifyCollectionChanged)readOnlyCollection).CollectionChanged += ncceh;

            // In theory, this will cause the properties to change.
            collection.Add('I');

            Assert.IsTrue(propChanged, "RO_4");
        }