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'"); }
private void AssertOrderingCorrect(bool startWithABeforeB, bool aAndBadjacent) { for (int iTruth = 0; iTruth < truthTable.Length; ++iTruth) { ProcessorExecutionOrder orderA = (ProcessorExecutionOrder)truthTable[iTruth][0]; ProcessorExecutionOrder orderB = (ProcessorExecutionOrder)truthTable[iTruth][1]; int swapValue = (int)truthTable[iTruth][2]; MockPipelineBuilder pb = new MockPipelineBuilder(); // Tell mock not to call validate, since we only want to order pb.OnValidateCalled = p => false; OrderableMockProcessorEchoString processorA = new OrderableMockProcessorEchoString() { Name = "ProcessorA" }; OrderableMockProcessorEchoString processorB = new OrderableMockProcessorEchoString() { Name = "ProcessorB" }; MockProcessor1 processorC = new MockProcessor1() { Name = "ProcessorC" }; if (orderA == ProcessorExecutionOrder.Before) { processorA.RunBefore = processorB; } if (orderA == ProcessorExecutionOrder.After) { processorA.RunAfter = processorB; } if (orderB == ProcessorExecutionOrder.Before) { processorB.RunBefore = processorA; } if (orderB == ProcessorExecutionOrder.After) { processorB.RunAfter = processorA; } Processor[] processors = (startWithABeforeB) ? (aAndBadjacent) ? new Processor[] { processorA, processorB } : new Processor[] { processorA, processorC, processorB } : (aAndBadjacent) ? new Processor[] { processorB, processorA } : new Processor[] { processorB, processorC, processorA }; Pipeline pipeline = null; Exception thrownException = null; try { pipeline = pb.Build( processors, Enumerable.Empty <ProcessorArgument>(), Enumerable.Empty <ProcessorArgument>() ); } catch (Exception e) { thrownException = e; } if (swapValue < 0) { Assert.IsNotNull(thrownException, "Expected exception when orderA=" + orderA + " and orderB=" + orderB + ", aFirst=" + startWithABeforeB + ", adjacent=" + aAndBadjacent); } else { Assert.IsNull(thrownException, "Expected no exception when orderA=" + orderA + " and orderB=" + orderB + ", aFirst=" + startWithABeforeB + ", adjacent=" + aAndBadjacent); int indexA = pipeline.Processors.IndexOf(processorA); int indexB = pipeline.Processors.IndexOf(processorB); if (orderA == ProcessorExecutionOrder.Before || orderB == ProcessorExecutionOrder.After) { Assert.IsTrue(indexA < indexB, "Expected A to come before when orderA=" + orderA + " and orderB=" + orderB); } else if (orderB == ProcessorExecutionOrder.Before || orderA == ProcessorExecutionOrder.After) { Assert.IsTrue(indexB < indexA, "Expected B to come before when orderA=" + orderA + " and orderB=" + orderB + ", aFirst=" + startWithABeforeB + ", adjacent=" + aAndBadjacent); } else { if (startWithABeforeB) { Assert.IsTrue(indexA < indexB, "Expected A to come before when orderA=" + orderA + " and orderB=" + orderB + ", aFirst=" + startWithABeforeB + ", adjacent=" + aAndBadjacent); } else { Assert.IsTrue(indexB < indexA, "Expected A to come before when orderA=" + orderA + " and orderB=" + orderB + ", aFirst=" + startWithABeforeB + ", adjacent=" + aAndBadjacent); } } } } }