public void Constructor_does_not_raise_an_exception()
        {
            // Act
            var sut = new EventRaisingList <Person> (_source);

            // Assert
            Assert.NotNull(sut);
        }
        public void Set_Item_modifies_source_list()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            // Act
            sut [1] = Replacement;

            // Assert
            Assert.AreSame(Replacement, _source [1]);
        }
        public void Get_Item_returns_correct_item()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            // Act
            var result = sut [1];

            // Assert
            Assert.AreEqual(_source [1], result);
        }
        public void Set_Item_invokes_before_add_callback()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            sut.BeforeAdd += RecordingCallbackOne;

            // Act
            sut [1] = Replacement;

            sut.BeforeAdd -= RecordingCallbackOne;

            // Assert
            Assert.IsTrue(CallbackOneCalled);
        }
        public void Insert_includes_index_of_new_item()
        {
            var sut = new EventRaisingList <Person> (_source);
            AfterModifyEventArgs <Person> capturedArgs = default;

            void OnAfterAdd(object sender, AfterModifyEventArgs <Person> args) => capturedArgs = args;

            sut.AfterAdd += OnAfterAdd;

            sut.Insert(1, new Person());

            sut.AfterAdd -= OnAfterAdd;

            Assert.That(capturedArgs, Is.InstanceOf <AfterModifyListEventArgs <Person> >().And.Property(nameof(IHasListIndex.Index)).EqualTo(1));
        }
        public void RemoveAt_includes_index_of_removed_item()
        {
            var sut = new EventRaisingList <Person> (_source);
            AfterModifyEventArgs <Person> capturedArgs = default;

            void OnAfterRemove(object sender, AfterModifyEventArgs <Person> args) => capturedArgs = args;

            sut.AfterRemove += OnAfterRemove;

            sut.RemoveAt(1);

            sut.AfterRemove -= OnAfterRemove;

            Assert.That(capturedArgs, Is.InstanceOf <AfterModifyListEventArgs <Person> >().And.Property(nameof(IHasListIndex.Index)).EqualTo(1));
        }
        public void RemoveAt_triggers_CollectionChanged()
        {
            var sut = new EventRaisingList <Person> (_source);
            NotifyCollectionChangedEventArgs capturedArgs = default;

            void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args) => capturedArgs = args;

            sut.CollectionChanged += OnCollectionChanged;

            sut.RemoveAt(1);

            sut.CollectionChanged -= OnCollectionChanged;

            Assert.That(capturedArgs, Is.Not.Null);
        }
        public void Set_Item_does_not_replace_item_if_before_add_cancels()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            sut.BeforeAdd += CancellingCallback;

            // Act
            sut [1] = Replacement;

            sut.BeforeAdd -= CancellingCallback;

            // Assert
            Assert.AreNotSame(Replacement, _source [1]);
        }
        public void Set_Item_does_not_trigger_after_add_if_before_add_cancels()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            sut.BeforeAdd += CancellingCallback;
            sut.AfterAdd  += RecordingCallbackOne;

            // Act
            sut [1] = Replacement;

            sut.BeforeAdd -= CancellingCallback;
            sut.AfterAdd  -= RecordingCallbackOne;

            // Assert
            Assert.IsFalse(CallbackOneCalled);
        }
        public void Insert_triggers_both_add_events()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            sut.BeforeAdd += RecordingCallbackOne;
            sut.AfterAdd  += RecordingCallbackTwo;

            // Act
            sut.Insert(1, new Person());

            sut.BeforeRemove -= RecordingCallbackOne;
            sut.AfterRemove  -= RecordingCallbackTwo;

            // Assert
            Assert.IsTrue(CallbackOneCalled, "Callback one");
            Assert.IsTrue(CallbackTwoCalled, "Callback two");
        }
        public void RemoveAt_triggers_both_remove_events()
        {
            // Arrange
            var sut = new EventRaisingList <Person> (_source);

            sut.BeforeRemove += RecordingCallbackOne;
            sut.AfterRemove  += RecordingCallbackTwo;

            // Act
            sut.RemoveAt(1);

            sut.BeforeRemove -= RecordingCallbackOne;
            sut.AfterRemove  -= RecordingCallbackTwo;

            // Assert
            Assert.IsTrue(CallbackOneCalled, "Callback one");
            Assert.IsTrue(CallbackTwoCalled, "Callback two");
        }