Пример #1
0
        public void CanPassOnRemovedProcessedEvents()
        {
            //Arrange
            var       branching = new TestAbstractBranchingOperation();
            const int nOps      = 5;
            var       ops       = new IOperation[nOps];

            for (var i = 0; i < nOps; i++)
            {
                ops[i] = Substitute.For <IOperation>();
                branching.Add(ops[i]);
            }

            //Act
            branching.OnRowProcessed += _processAction;
            branching.OnRowProcessed -= _processAction;

            //Assert
            foreach (var op in ops)
            {
                op.Received(1).OnRowProcessed += _processAction;
                op.Received(1).OnRowProcessed -= _processAction;
            }

            Assert.Single(GetEventHandlers(branching, nameof(branching.OnRowProcessed)));
        }
Пример #2
0
        public void    CanPassOnRemovedProcessedEvents()
        {
            //Arrange
            var    branching =    new    TestAbstractBranchingOperation();
            const int nOps = 5;
            var    ops    = new IOperation[nOps];
            for    (var i = 0;    i <    nOps; i++)
            {
                ops[i] = MockRepository.GenerateMock<IOperation>();
                ops[i].Expect(x    => x.OnRowProcessed    += processAction);
                ops[i].Expect(x    => x.OnRowProcessed    -= processAction);
                branching.Add(ops[i]);
            }

            //Act
            branching.OnRowProcessed +=    processAction;
            branching.OnRowProcessed -=    processAction;

            //Assert
            foreach    (var op    in ops)
                op.VerifyAllExpectations();

            var    handlerInfos = typeof(AbstractOperation).GetField("OnRowProcessed",    BindingFlags.Static    | BindingFlags.Instance    | BindingFlags.NonPublic);
            Assert.Equal(1,    ((Delegate)(handlerInfos.GetValue(branching))).GetInvocationList().Length);
        }
Пример #3
0
        public void    CanPassOnRemovedProcessedEvents()
        {
            //Arrange
            var       branching = new    TestAbstractBranchingOperation();
            const int nOps      = 5;
            var       ops       = new IOperation[nOps];

            for (var i = 0; i < nOps; i++)
            {
                ops[i] = MockRepository.GenerateMock <IOperation>();
                ops[i].Expect(x => x.OnRowProcessed += processAction);
                ops[i].Expect(x => x.OnRowProcessed -= processAction);
                branching.Add(ops[i]);
            }

            //Act
            branching.OnRowProcessed += processAction;
            branching.OnRowProcessed -= processAction;

            //Assert
            foreach (var op    in ops)
            {
                op.VerifyAllExpectations();
            }

            var handlerInfos = typeof(AbstractOperation).GetField("OnRowProcessed", BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);

            Assert.Single(((Delegate)(handlerInfos.GetValue(branching))).GetInvocationList());
        }
Пример #4
0
        public void    CanPassOnRemovedFinishedEvents()
        {
            var       branching = new    TestAbstractBranchingOperation();
            const int nOps      = 5;
            var       ops       = new IOperation[nOps];

            for (var i = 0; i < nOps; i++)
            {
                ops[i] = MockRepository.GenerateMock <IOperation>();
                ops[i].Expect(x => x.OnFinishedProcessing += finishedAction);
                ops[i].Expect(x => x.OnFinishedProcessing -= finishedAction);
                branching.Add(ops[i]);
            }

            branching.OnFinishedProcessing += finishedAction;
            branching.OnFinishedProcessing -= finishedAction;

            foreach (var op    in ops)
            {
                op.VerifyAllExpectations();
            }

            var handlerInfos = typeof(AbstractOperation).GetField("OnFinishedProcessing", BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);

            Assert.Equal(1, ((Delegate)(handlerInfos.GetValue(branching))).GetInvocationList().Length);
        }
Пример #5
0
        public void CanPassOnAddedFinishedEvents()
        {
            var       branching = new TestAbstractBranchingOperation();
            const int nOps      = 5;
            var       ops       = new IOperation[nOps];

            for (var i = 0; i < nOps; i++)
            {
                ops[i] = Substitute.For <IOperation>();
                branching.Add(ops[i]);
            }

            branching.OnFinishedProcessing += _finishedAction;

            foreach (var op in ops)
            {
                op.Received(1).OnFinishedProcessing += _finishedAction;
            }

            Assert.Equal(2, GetEventHandlers(branching, nameof(branching.OnFinishedProcessing)).Length);
        }