public void Pipeline_UnbindArgument_Succeeds()
        {
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            Pipeline pipeline = new Pipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty <ProcessorArgument>(),
                Enumerable.Empty <ProcessorArgument>());

            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            Assert.IsTrue(
                pipeline.GetBoundToArguments(processor1.OutArguments[0]).Contains(processor2.InArguments[0]),
                "Expected GetBoundTo(out) to show we bound out to in");
            Assert.IsTrue(
                pipeline.GetBoundToArguments(processor2.InArguments[0]).Contains(processor1.OutArguments[0]),
                "Expected GetBoundTo(in) to show we bound out to in");

            pipeline.UnbindArguments(processor1.OutArguments[0], processor2.InArguments[0]);

            Assert.IsFalse(
                pipeline.GetBoundToArguments(processor1.OutArguments[0]).Contains(processor2.InArguments[0]),
                "Expected GetBoundTo(out) to show we unbound out to in");
            Assert.IsFalse(
                pipeline.GetBoundToArguments(processor2.InArguments[0]).Contains(processor1.OutArguments[0]),
                "Expected GetBoundTo(in) to show we unbound out to in");
        }
Пример #2
0
        public void PipelineBuilder_Build_Binds_By_Name_And_Executes()
        {
            MockPipelineBuilder     pb         = new MockPipelineBuilder();
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();

            // Rename processor inputs and outputs to bind by name to pipeline arguments and to each other:
            // pipeline[intInput] --> [intInput]p1[echoInput] --> [echoInput]p2[stringOutput] --> [stringOutput]pipeline
            processor1.InArguments[0].Name  = "intInput";
            processor2.InArguments[0].Name  = processor1.OutArguments[0].Name = "echoInput";
            processor2.OutArguments[0].Name = "stringOutput";

            Pipeline pipeline = pb.Build(
                new Processor[] { processor1, processor2 },
                new ProcessorArgument[] { new ProcessorArgument("intInput", typeof(int)) },
                new ProcessorArgument[] { new ProcessorArgument("stringOutput", typeof(string)) }
                );

            Assert.IsNotNull(pipeline, "Build should produce non-null pipeline");

            ProcessorResult result = pipeline.Execute(new object[] { 9 });

            Assert.IsNotNull(result, "Null result from execute");
            Assert.AreEqual(ProcessorStatus.Ok, result.Status, "Expected OK result status");
            Assert.IsNotNull(result.Output, "Expected non-null output");
            Assert.AreEqual(1, result.Output.Length, "Expected 1 output value");
            Assert.AreEqual(9.ToString(), result.Output[0], "Wrong output value");
        }
Пример #3
0
        public void PipelineBuilder_Build_Binds_By_Name()
        {
            MockPipelineBuilder     pb         = new MockPipelineBuilder();
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();

            // Rename processor inputs and outputs to bind by name to pipeline arguments and to each other:
            // pipeline[intInput] --> [intInput]p1[echoInput] --> [echoInput]p2[stringOutput] --> [stringOutput]pipeline
            processor1.InArguments[0].Name  = "intInput";
            processor2.InArguments[0].Name  = processor1.OutArguments[0].Name = "echoInput";
            processor2.OutArguments[0].Name = "stringOutput";

            Pipeline pipeline = pb.Build(
                new Processor[] { processor1, processor2 },
                new ProcessorArgument[] { new ProcessorArgument("intInput", typeof(int)) },
                new ProcessorArgument[] { new ProcessorArgument("stringOutput", typeof(string)) }
                );

            Assert.IsNotNull(pipeline, "Build should produce non-null pipeline");

            ProcessorArgument[] boundArgs = pipeline.GetBoundToArguments(pipeline.Processors[0].OutArguments[0]).ToArray();
            Assert.AreEqual(1, boundArgs.Length, "Expected 1 parameter bound to entry processor output");
            Assert.AreSame(processor1.InArguments[0], boundArgs[0], "Expected entry processor output to bind to processor 1 input");

            boundArgs = pipeline.GetBoundToArguments(pipeline.Processors[1].OutArguments[0]).ToArray();
            Assert.AreEqual(1, boundArgs.Length, "Expected 1 parameter bound to first processor output");
            Assert.AreSame(processor2.InArguments[0], boundArgs[0], "Expected first processor output to bind to second processor input");

            boundArgs = pipeline.GetBoundToArguments(pipeline.Processors[2].OutArguments[0]).ToArray();
            Assert.AreEqual(1, boundArgs.Length, "Expected 1 parameter bound to second processor output");
            Assert.AreSame(pipeline.Processors[3].InArguments[0], boundArgs[0], "Expected second processor output to bind to exit processor input");
        }
        public void Pipeline_Bind_OnBinding_OnBind_OnBound_Callbacks()
        {
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            MockPipeline            pipeline   = new MockPipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty <ProcessorArgument>(),
                Enumerable.Empty <ProcessorArgument>());
            BindArgumentsEventArgs bindingEventArgs = null;
            BindArgumentsEventArgs boundEventArgs   = null;
            ProcessorArgument      inArgFromBind    = null;
            ProcessorArgument      outArgFromBind   = null;

            pipeline.OnBindArgumentsCalled = (outArg, inArg) =>
            {
                inArgFromBind  = inArg;
                outArgFromBind = outArg;
            };

            pipeline.BindingArguments = (s, a) => { bindingEventArgs = a as BindArgumentsEventArgs; };
            pipeline.BoundArguments   = (s, a) => { boundEventArgs = a as BindArgumentsEventArgs; };

            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            Assert.IsNotNull(bindingEventArgs, "Did not receive BindingArguments callback");
            Assert.AreSame(processor1.OutArguments[0], bindingEventArgs.OutArgument, "Did not receive correct outArg in BindingArgument callback");
            Assert.AreSame(processor2.InArguments[0], bindingEventArgs.InArgument, "Did not receive correct inArg in BindingArgument callback");

            Assert.IsNotNull(boundEventArgs, "Did not receive BoundArguments callback");
            Assert.AreSame(processor1.OutArguments[0], boundEventArgs.OutArgument, "Did not receive correct outArg in BoundArgument callback");
            Assert.AreSame(processor2.InArguments[0], boundEventArgs.InArgument, "Did not receive correct inArg in BoundArgument callback");

            Assert.AreSame(processor1.OutArguments[0], outArgFromBind, "Did not receive correct outArg in OnBind virtual");
            Assert.AreSame(processor2.InArguments[0], inArgFromBind, "Did not receive correct inArg in OnBind virtual");
        }
Пример #5
0
        private void PipelineBuilder_Ordering_Random(Random random)
        {
            int nProcessors = (random.Next() % 10) + 1;

            System.Diagnostics.Debug.WriteLine("Number processors this pass: "******"Processor" + (i + 1)
                };
                p.OutArguments[0].Name = p.Name + "Out";
                processors[i]          = p;
            }

            for (int i = 0; i < nProcessors; ++i)
            {
                if (i == 0)
                {
                    processors[i].InArguments[0].Name = "PipeIn";
                }
                else
                {
                    processors[i].InArguments[0].Name = processors[i - 1].OutArguments[0].Name;
                }
            }

            Processor[] origProcessors = new Processor[nProcessors];
            Array.Copy(processors, origProcessors, nProcessors);

            // Now randomly scramble the processor order
            for (int i = 0; i < nProcessors; ++i)
            {
                int iSrc = random.Next() % nProcessors;
                int iDst = random.Next() % nProcessors;

                var temp = processors[iSrc];
                processors[iSrc] = processors[iDst];
                processors[iDst] = temp;
            }

            MockPipelineBuilder builder = new MockPipelineBuilder();

            Pipeline pipeline = builder.Build(
                processors,
                new ProcessorArgument[] { new ProcessorArgument("PipeIn", typeof(string)) },
                new ProcessorArgument[0]
                );

            for (int i = 0; i < nProcessors; ++i)
            {
                Assert.AreSame(origProcessors[i], pipeline.Processors[i + 1],
                               "Slot " + i + " had " + ((MockProcessorEchoString)pipeline.Processors[i + 1]).Name +
                               " but expected " + ((MockProcessorEchoString)origProcessors[i]).Name);
            }
        }
Пример #6
0
        public void PipelineBuilder_OnGetRelativeExecutionOrder_Virtual_IsCalled()
        {
            Processor processor1 = new MockProcessor1();
            Processor processor2 = new MockProcessorEchoString();
            Processor processor3 = new MockProcessorNoArgs();

            Processor[]         processors = new Processor[] { processor1, processor2, processor3 };
            ProcessorArgument[] inArgs     = new[] { new ProcessorArgument("intValue", typeof(int)) };
            ProcessorArgument[] outArgs    = new ProcessorArgument[0];

            // Bind input of echo processor to mock proc 1
            processor2.InArguments[0].Name = processor1.OutArguments[0].Name;

            bool firstOrderSet  = false;
            bool secondOrderSet = false;
            bool thirdOrderSet  = false;
            ProcessorExecutionOrder firstOrder  = default(ProcessorExecutionOrder);
            ProcessorExecutionOrder secondOrder = default(ProcessorExecutionOrder);
            ProcessorExecutionOrder thirdOrder  = default(ProcessorExecutionOrder);

            // Get a new pipeline because the prior one is now in a damaged state
            MockPipelineBuilder pb = new MockPipelineBuilder();

            pb.OnGetRelativeExecutionOrderCalled = (p1, p2, order) =>
            {
                if (p1 == processors[0] && p2 == processors[1])
                {
                    firstOrder    = order;
                    firstOrderSet = true;
                }

                if (p1 == processors[1] && p2 == processors[0])
                {
                    secondOrder    = order;
                    secondOrderSet = true;
                }

                if (p1 == processors[2] && p2 == processors[0])
                {
                    thirdOrder    = order;
                    thirdOrderSet = true;
                }
                return(order);
            };

            Pipeline pipeline = pb.Build(processors, inArgs, outArgs);

            Assert.IsTrue(firstOrderSet, "OnGetRelativeExecutionOrder virtual was not called for (p1,p2)");
            Assert.IsTrue(secondOrderSet, "OnGetRelativeExecutionOrder virtual was not called for (p2,p1)");
            Assert.IsTrue(thirdOrderSet, "OnGetRelativeExecutionOrder virtual was not called for (p3,p1)");

            Assert.AreEqual(ProcessorExecutionOrder.Before, firstOrder, "The (p1,p2) call should have yielded 'before'");
            Assert.AreEqual(ProcessorExecutionOrder.After, secondOrder, "The (p2, p1) call should have yielded 'after'");
            Assert.AreEqual(ProcessorExecutionOrder.Impartial, thirdOrder, "The (p3, p1) call should have yielded 'impartial'");
        }
        public void Pipeline_UnbindArgument_Throws_After_Initialize()
        {
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            Pipeline pipeline = new Pipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty <ProcessorArgument>(),
                Enumerable.Empty <ProcessorArgument>());

            pipeline.Initialize();

            ExceptionAssert.ThrowsInvalidOperation(
                "UnbindArgument should throw if called after initialize",
                () => pipeline.UnbindArguments(processor1.OutArguments[0], processor2.InArguments[0])
                );
        }
Пример #8
0
        public void Pipeline_Executes_With_No_Bindings()
        {
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            MockPipeline            pipeline   = new MockPipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty <ProcessorArgument>(),
                Enumerable.Empty <ProcessorArgument>());

            pipeline.Initialize();
            ProcessorResult result = pipeline.Execute(new object[0]);

            Assert.IsNotNull(result, "Expected non-null ProcessorResult");
            Assert.IsNotNull(result.Output, "Expected non-null output from unbound pipeline");
            Assert.AreEqual(0, result.Output.Length, "Expected empty array from unbound pipeline");
            Assert.AreEqual(ProcessorStatus.Ok, result.Status, "Expected OK status from pipeline");
        }
Пример #9
0
        public void Pipeline_Executes_With_No_Bindings_To_Pipeline()
        {
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            MockPipeline            pipeline   = new MockPipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty <ProcessorArgument>(),
                Enumerable.Empty <ProcessorArgument>());

            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            pipeline.Initialize();
            ProcessorResult result = pipeline.Execute(new object[0]);

            Assert.IsNotNull(result, "Expected non-null ProcessorResult");
            Assert.IsNotNull(result.Output, "Expected non-null output from unbound pipeline");
            Assert.AreEqual(0, result.Output.Length, "Expected empty array from unbound pipeline");

            // Verify processor1 pushed default(int) through to processor2
            object value = pipeline.Context.ReadInput(processor2.InArguments[0]);

            Assert.IsNotNull(value);
            Assert.AreEqual(default(int).ToString(), value, "Expected default(int) to be passed from processor1 to processor2");
        }
Пример #10
0
        public void PipelineBuilder_Validate_Throws_Input_Before_Output()
        {
            MockPipelineBuilder     pb         = new MockPipelineBuilder();
            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();

            // Rename processor inputs and outputs to bind by name to pipeline arguments and to each other:
            // pipeline[intInput] --> [intInput]p1[echoInput] --> [echoInput]p2[stringOutput] --> [stringOutput]pipeline
            processor1.InArguments[0].Name  = "intInput";
            processor2.InArguments[0].Name  = processor1.OutArguments[0].Name = "echoInput";
            processor2.OutArguments[0].Name = "stringOutput";

            // Defeat normal ordering
            pb.OnOrderCalled = p => p;

            ExceptionAssert.ThrowsInvalidOperation(
                "PipelineBuilder should throw when required input occurs before output",
                () => pb.Build(
                    new Processor[] { processor2, processor1 }, // <<<<<<<<< notice the order is flipped
                    new ProcessorArgument[] { new ProcessorArgument("intInput", typeof(int)) },
                    new ProcessorArgument[] { new ProcessorArgument("stringOutput", typeof(string)) }
                    )
                );
        }
Пример #11
0
        public void PipelineBuilder_Build_Invokes_All_Virtuals()
        {
            MockPipelineBuilder pb      = new MockPipelineBuilder();
            bool onOrderCalled          = false;
            bool onFilterCalled         = false;
            bool onCreatePipelineCalled = false;
            bool onInitializeCalled     = false;
            bool onValidateCalled       = false;
            bool onShouldBindCalled     = false;

            MockProcessor1          processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();

            pb.OnFilterCalled = p =>
            {
                onFilterCalled = true;
                Assert.IsFalse(onOrderCalled || onInitializeCalled || onCreatePipelineCalled || onValidateCalled || onShouldBindCalled,
                               "OnFilter should be called before OnOrder, OnInitialize, OnCreatePipeline, OnValidate, and OnShouldBind");
                return(p);
            };

            pb.OnOrderCalled = p =>
            {
                onOrderCalled = true;
                Assert.IsTrue(onFilterCalled, "OnOrder should be called after OnFilter");
                Assert.IsFalse(onInitializeCalled || onCreatePipelineCalled || onValidateCalled || onShouldBindCalled,
                               "OnOrder should be called before OnInitialize, OnCreatePipeline, OnValidate, and OnShouldBind");
                return(p);
            };

            pb.OnCreatePipelineCalled = (p, aIn, aOut) =>
            {
                onCreatePipelineCalled = true;
                Assert.IsTrue(onFilterCalled && onOrderCalled, "OnCreatePipeline should be called after OnFilter and OnOrder");
                Assert.IsFalse(onInitializeCalled || onValidateCalled || onShouldBindCalled,
                               "OnCreatePipeline should be called before OnInitialize, OnValidate, and OnShouldBind");
                return(new Pipeline(p, aIn, aOut));
            };

            pb.OnInitializeCalled = p =>
            {
                onInitializeCalled = true;
                Assert.IsNotNull(p, "Oninitialize passed null pipeline");
                Assert.IsTrue(onFilterCalled && onOrderCalled && onCreatePipelineCalled, "OnInitialize should be called after OnFilter, OnCreatePipeline and OnOrder");
                Assert.IsFalse(onValidateCalled || onShouldBindCalled,
                               "OnInitialize should be called before OnValidate and OnShouldBind");
                return(p);
            };

            pb.OnShouldArgumentBindCalled = (aOut, aIn) =>
            {
                onShouldBindCalled = true;
                Assert.IsTrue(onFilterCalled && onOrderCalled && onInitializeCalled && onCreatePipelineCalled, "OnInitialize should be called after OnFilter, OnCreatePipeline, OnOrder and OnInitialize");
                Assert.IsFalse(onValidateCalled, "OnShouldArgmentBind should be called before OnValidate");
                return(null);
            };

            pb.OnValidateCalled = p =>
            {
                Assert.IsTrue(onFilterCalled && onOrderCalled && onInitializeCalled && onShouldBindCalled && onCreatePipelineCalled,
                              "OnInitialize should be called after OnFilter, OnOrder, OnInitialize, OnCreatePipeline and OnShouldBind");
                onValidateCalled = true;
                return(true);    // call base.validate
            };

            // Rename processor inputs and outputs to bind by name to pipeline arguments and to each other:
            // pipeline[intInput] --> [intInput]p1[echoInput] --> [echoInput]p2[stringOutput] --> [stringOutput]pipeline
            processor1.InArguments[0].Name  = "intInput";       // same as pipeline input
            processor2.InArguments[0].Name  = processor1.OutArguments[0].Name = "echoInput";
            processor2.OutArguments[0].Name = "stringOutput";   // same as pipeline output

            Pipeline pipeline = pb.Build(
                new Processor[] { processor1, processor2 },
                new ProcessorArgument[] { new ProcessorArgument("intInput", typeof(int)) },
                new ProcessorArgument[] { new ProcessorArgument("stringOutput", typeof(string)) }
                );

            Assert.IsNotNull(pipeline, "Build should produce non-null pipeline");

            Assert.IsTrue(onFilterCalled, "OnFilter was not called");
            Assert.IsTrue(onOrderCalled, "OnOrder was not called");
            Assert.IsTrue(onInitializeCalled, "OnInitialize was not called");
            Assert.IsTrue(onShouldBindCalled, "OnShouldBind was not called");
            Assert.IsTrue(onValidateCalled, "OnValidate was not called");
        }
        public void Pipeline_Executes_With_No_Bindings_To_Pipeline()
        {
            MockProcessor1 processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            MockPipeline pipeline = new MockPipeline(
                                        new Processor[] { processor1, processor2 },
                                        Enumerable.Empty<ProcessorArgument>(),
                                        Enumerable.Empty<ProcessorArgument>());
            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            pipeline.Initialize();
            ProcessorResult result = pipeline.Execute(new object[0]);
            Assert.IsNotNull(result, "Expected non-null ProcessorResult");
            Assert.IsNotNull(result.Output, "Expected non-null output from unbound pipeline");
            Assert.AreEqual(0, result.Output.Length, "Expected empty array from unbound pipeline");

            // Verify processor1 pushed default(int) through to processor2
            object value = pipeline.Context.ReadInput(processor2.InArguments[0]);
            Assert.IsNotNull(value);
            Assert.AreEqual(default(int).ToString(), value, "Expected default(int) to be passed from processor1 to processor2");
        }
 public void Pipeline_Executes_With_No_Bindings()
 {
     MockProcessor1 processor1 = new MockProcessor1();
     MockProcessorEchoString processor2 = new MockProcessorEchoString();
     MockPipeline pipeline = new MockPipeline(
                                 new Processor[] { processor1, processor2 },
                                 Enumerable.Empty<ProcessorArgument>(),
                                 Enumerable.Empty<ProcessorArgument>());
     pipeline.Initialize();
     ProcessorResult result = pipeline.Execute(new object[0]);
     Assert.IsNotNull(result, "Expected non-null ProcessorResult");
     Assert.IsNotNull(result.Output, "Expected non-null output from unbound pipeline");
     Assert.AreEqual(0, result.Output.Length, "Expected empty array from unbound pipeline");
     Assert.AreEqual(ProcessorStatus.Ok, result.Status, "Expected OK status from pipeline");
 }
        public void Pipeline_UnbindArgument_Throws_After_Initialize()
        {
            MockProcessor1 processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            Pipeline pipeline = new Pipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty<ProcessorArgument>(),
                Enumerable.Empty<ProcessorArgument>());

            pipeline.Initialize();

            ExceptionAssert.ThrowsInvalidOperation(
                "UnbindArgument should throw if called after initialize",
                () => pipeline.UnbindArguments(processor1.OutArguments[0], processor2.InArguments[0])
                );
        }
        public void Pipeline_UnbindArgument_Succeeds()
        {
            MockProcessor1 processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            Pipeline pipeline = new Pipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty<ProcessorArgument>(),
                Enumerable.Empty<ProcessorArgument>());

            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            Assert.IsTrue(
                pipeline.GetBoundToArguments(processor1.OutArguments[0]).Contains(processor2.InArguments[0]),
                "Expected GetBoundTo(out) to show we bound out to in");
            Assert.IsTrue(
                pipeline.GetBoundToArguments(processor2.InArguments[0]).Contains(processor1.OutArguments[0]),
                "Expected GetBoundTo(in) to show we bound out to in");

            pipeline.UnbindArguments(processor1.OutArguments[0], processor2.InArguments[0]);

            Assert.IsFalse(
                pipeline.GetBoundToArguments(processor1.OutArguments[0]).Contains(processor2.InArguments[0]),
                "Expected GetBoundTo(out) to show we unbound out to in");
            Assert.IsFalse(
                pipeline.GetBoundToArguments(processor2.InArguments[0]).Contains(processor1.OutArguments[0]),
                "Expected GetBoundTo(in) to show we unbound out to in");
        }
        public void Pipeline_Bind_OnBinding_OnBind_OnBound_Callbacks()
        {
            MockProcessor1 processor1 = new MockProcessor1();
            MockProcessorEchoString processor2 = new MockProcessorEchoString();
            MockPipeline pipeline = new MockPipeline(
                new Processor[] { processor1, processor2 },
                Enumerable.Empty<ProcessorArgument>(),
                Enumerable.Empty<ProcessorArgument>());
            BindArgumentsEventArgs bindingEventArgs = null;
            BindArgumentsEventArgs boundEventArgs = null;
            ProcessorArgument inArgFromBind = null;
            ProcessorArgument outArgFromBind = null;

            pipeline.OnBindArgumentsCalled = (outArg, inArg) =>
            {
                inArgFromBind = inArg;
                outArgFromBind = outArg;
            };

            pipeline.BindingArguments = (s, a) => { bindingEventArgs = a as BindArgumentsEventArgs; };
            pipeline.BoundArguments = (s, a) => { boundEventArgs = a as BindArgumentsEventArgs; };

            pipeline.BindArguments(processor1.OutArguments[0], processor2.InArguments[0]);
            Assert.IsNotNull(bindingEventArgs, "Did not receive BindingArguments callback");
            Assert.AreSame(processor1.OutArguments[0], bindingEventArgs.OutArgument, "Did not receive correct outArg in BindingArgument callback");
            Assert.AreSame(processor2.InArguments[0], bindingEventArgs.InArgument, "Did not receive correct inArg in BindingArgument callback");

            Assert.IsNotNull(boundEventArgs, "Did not receive BoundArguments callback");
            Assert.AreSame(processor1.OutArguments[0], boundEventArgs.OutArgument, "Did not receive correct outArg in BoundArgument callback");
            Assert.AreSame(processor2.InArguments[0], boundEventArgs.InArgument, "Did not receive correct inArg in BoundArgument callback");

            Assert.AreSame(processor1.OutArguments[0], outArgFromBind, "Did not receive correct outArg in OnBind virtual");
            Assert.AreSame(processor2.InArguments[0], inArgFromBind, "Did not receive correct inArg in OnBind virtual");
        }