Partial implementation of IProgressStepOperation
Inheritance: IProgressStepOperation
Example #1
0
        public void SequentialProgressController_IProgressController_TryAbort_ControllerDrivenCancellation()
        {
            // Arrange
            ConfigurableProgressStepFactory   testFactory   = new ConfigurableProgressStepFactory();
            ConfigurableProgressTestOperation stepOperation = new ConfigurableProgressTestOperation(this.DoNothing)
            {
                CancellableAction = () =>
                {
                    // Using this opportunity to abort - the test assumes that Cancellable is called before the step is actually executed
                    this.testSubject.TryAbort().Should().BeTrue("Should be able to abort");
                    return(true);
                }
            };

            testFactory.CreateOpeartion = (d) => stepOperation;
            ProgressEventsVerifier verifier = new ProgressEventsVerifier(this.testSubject);

            this.testSubject.Initialize(testFactory, new[] { new StubProgressStepDefinition() });

            // Act
            this.testSubject.StartAsync().Wait();

            // Assert
            verifier.AssertCorrectExecution(ProgressControllerResult.Cancelled);
            verifier.AssertStepCorrectExecution(stepOperation, StepExecutionState.NotStarted);
            verifier.AssertCancellationChanges(3);
        }
Example #2
0
        public void ProgressObserver_EventMonitoringAndExecution_ViewModelOutOfSync()
        {
            ConfigurableProgressTestOperation step = new ConfigurableProgressTestOperation((c, e) => { })
            {
                Progress       = 0.0,
                Indeterminate  = false,
                ExecutionState = StepExecutionState.NotStarted
            };

            this.progressEvents.Steps = new IProgressStep[] { step };
            this.CreateTestSubject();

            // Create another step which is not observed
            ConfigurableProgressTestOperation anotherStep = new ConfigurableProgressTestOperation((c, e) => { })
            {
                ExecutionState = StepExecutionState.Succeeded,
                Progress       = 1.0,
                Indeterminate  = false
            };

            using (new AssertIgnoreScope())
            {
                this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(anotherStep));
            }

            this.testVisualizer.Root.MainProgress.Value.Should().Be(0.0, "The main progress should not change");
        }
        private static ConfigurableProgressTestOperation[] CreateRandomSteps(int numberOfSteps, bool visible, bool indeterminate, bool impacting)
        {
            ConfigurableProgressTestOperation[] steps = new ConfigurableProgressTestOperation[numberOfSteps];
            for (int i = 0; i < steps.Length; i++)
            {
                steps[i] = CreateRandomStep(visible, indeterminate, impacting);
            }

            return(steps);
        }
Example #4
0
        public void ProgressObserver_EventMonitoringAndExecution()
        {
            // Arrange - Create a determinate not started step
            int    initialProgress                 = 0;
            string initialProgressDetails          = null;
            ConfigurableProgressTestOperation step = new ConfigurableProgressTestOperation((c, e) => { })
            {
                Progress           = initialProgress,
                ProgressDetailText = initialProgressDetails,
                Indeterminate      = false,
                ExecutionState     = StepExecutionState.NotStarted,
                ImpactsProgress    = true
            };

            this.progressEvents.Steps = new IProgressStep[] { step };
            this.CreateTestSubject();
            this.threadService.SetCurrentThreadIsUIThread(false);

            // Show
            this.testVisualizer.IsShown.Should().BeFalse();
            this.testSubject.IsFinished.Should().BeFalse("Not started");
            this.progressEvents.InvokeStarted();
            this.testSubject.IsFinished.Should().BeFalse("Just started");
            this.testVisualizer.IsShown.Should().BeTrue();

            // Cancellability change
            this.progressEvents.InvokeCancellationSupportChanged(false);
            this.testVisualizer.Root.Cancellable.Should().BeFalse("Unexpected cancellable state");
            this.progressEvents.InvokeCancellationSupportChanged(true);
            this.testVisualizer.Root.Cancellable.Should().BeTrue("Unexpected cancellable state");

            ProgressStepViewModel viewModelStep = this.testVisualizer.Root.Steps[0];

            // Step execution changed
            viewModelStep.ExecutionState.Should().Be(StepExecutionState.NotStarted, "Inconclusive: unexpected initial state");
            step.ExecutionState = StepExecutionState.Executing;
            this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(step));
            viewModelStep.ExecutionState.Should().Be(StepExecutionState.Executing, "Execution state wasn't changed as expected");

            // Step progress reporting
            step.ProgressDetailText = "Hello world";
            step.Progress           = 1.0;
            viewModelStep.Progress.Value.Should().Be(initialProgress, "Inconclusive: unexpected initial Progress");
            viewModelStep.ProgressDetailText.Should().Be(initialProgressDetails, "Inconclusive: unexpected initial ProgressDetailText");
            this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(step));
            viewModelStep.Progress.Value.Should().Be(step.Progress, "Progress wasn't changed as expected");
            viewModelStep.ProgressDetailText.Should().Be(step.ProgressDetailText, "ProgressDetailText wasn't changed as expected");

            // Hide
            this.testSubject.IsFinished.Should().BeFalse("Not done yet");
            this.progressEvents.InvokeFinished(ProgressControllerResult.Cancelled /*doesn't matter*/);
            this.testSubject.IsFinished.Should().BeTrue("Can celled - > Finished");
            this.testVisualizer.IsShown.Should().BeFalse();
        }
Example #5
0
        public void SequentialProgressController_IProgressController_Start()
        {
            // Arrange
            ConfigurableProgressStepFactory   testFactory   = new ConfigurableProgressStepFactory();
            ConfigurableProgressTestOperation stepOperation = new ConfigurableProgressTestOperation(this.VerifyControllerExecuting);

            testFactory.CreateOpeartion = (d) => stepOperation;
            this.testSubject.Initialize(testFactory, new[] { new StubProgressStepDefinition() });

            this.testSubject.IsStarted.Should().BeFalse("Wasn't started yet");
            this.testSubject.IsFinished.Should().BeFalse("Wasn't started yet");

            // Act
            this.testSubject.StartAsync().Wait();

            this.testSubject.IsStarted.Should().BeTrue("Was started");
            this.testSubject.IsFinished.Should().BeTrue("Was finished");
        }
        private static ConfigurableProgressTestOperation CreateRandomStep(bool visible, bool indeterminate, bool impacting)
        {
            Random             random         = new Random();
            int                maxFlag        = ((int[])Enum.GetValues(typeof(StepExecutionState))).Max();
            StepExecutionState executionState = (StepExecutionState)random.Next(0, maxFlag + 1);

            ConfigurableProgressTestOperation step;

            step                    = new ConfigurableProgressTestOperation((c, e) => { });
            step.DisplayText        = "DisplayText:" + Environment.TickCount.ToString();
            step.ExecutionState     = executionState;
            step.Progress           = random.NextDouble();
            step.ProgressDetailText = "ProgressDetailText:" + Environment.TickCount.ToString();
            step.Indeterminate      = indeterminate;
            step.Hidden             = !visible;
            step.ImpactsProgress    = impacting;
            return(step);
        }
        private static ConfigurableProgressTestOperation CreateRandomStep(bool visible, bool indeterminate, bool impacting)
        {
            Random random = new Random();
            int maxFlag = ((int[])Enum.GetValues(typeof(StepExecutionState))).Max();
            StepExecutionState executionState = (StepExecutionState)random.Next(0, maxFlag + 1);

            ConfigurableProgressTestOperation step;
            step = new ConfigurableProgressTestOperation((c, e) => { });
            step.DisplayText = "DisplayText:" + Environment.TickCount.ToString();
            step.ExecutionState = executionState;
            step.Progress = random.NextDouble();
            step.ProgressDetailText = "ProgressDetailText:" + Environment.TickCount.ToString();
            step.Indeterminate = indeterminate;
            step.Hidden = !visible;
            step.ImpactsProgress = impacting;
            return step;
        }
        private static ConfigurableProgressTestOperation[] CreateRandomSteps(int numberOfSteps, bool visible, bool indeterminate, bool impacting)
        {
            ConfigurableProgressTestOperation[] steps = new ConfigurableProgressTestOperation[numberOfSteps];
            for (int i = 0; i < steps.Length; i++)
            {
                steps[i] = CreateRandomStep(visible, indeterminate, impacting);
            }

            return steps;
        }
        public void ProgressObserver_EventMonitoringAndExecution()
        {
            // Setup - Create a determinate not started step
            int initialProgress = 0;
            string initialProgressDetails = null;
            ConfigurableProgressTestOperation step = new ConfigurableProgressTestOperation((c, e) => { });
            step.Progress = initialProgress;
            step.ProgressDetailText = initialProgressDetails;
            step.Indeterminate = false;
            step.ExecutionState = StepExecutionState.NotStarted;
            step.ImpactsProgress = true;
            this.progressEvents.Steps = new IProgressStep[] { step };
            this.CreateTestSubject();
            this.threadService.SetCurrentThreadIsUIThread(false);

            // Show
            this.testVisualizer.AssertIsHidden();
            Assert.IsFalse(this.testSubject.IsFinished, "Not started");
            this.progressEvents.InvokeStarted();
            Assert.IsFalse(this.testSubject.IsFinished, "Just started");
            this.testVisualizer.AssertIsShown();

            // Cancellability change
            this.progressEvents.InvokeCancellationSupportChanged(false);
            Assert.IsFalse(this.testVisualizer.Root.Cancellable, "Unexpected cancellable state");
            this.progressEvents.InvokeCancellationSupportChanged(true);
            Assert.IsTrue(this.testVisualizer.Root.Cancellable, "Unexpected cancellable state");

            ProgressStepViewModel viewModelStep = this.testVisualizer.Root.Steps[0];

            // Step execution changed
            Assert.AreEqual(StepExecutionState.NotStarted, viewModelStep.ExecutionState, "Inconclusive: unexpected initial state");
            step.ExecutionState = StepExecutionState.Executing;
            this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(step));
            Assert.AreEqual(StepExecutionState.Executing, viewModelStep.ExecutionState, "Execution state wasn't changed as expected");

            // Step progress reporting
            step.ProgressDetailText = "Hello world";
            step.Progress = 1.0;
            Assert.AreEqual(initialProgress, viewModelStep.Progress.Value, "Inconclusive: unexpected initial Progress");
            Assert.AreEqual(initialProgressDetails, viewModelStep.ProgressDetailText, "Inconclusive: unexpected initial ProgressDetailText");
            this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(step));
            Assert.AreEqual(step.Progress, viewModelStep.Progress.Value, "Progress wasn't changed as expected");
            Assert.AreEqual(step.ProgressDetailText, viewModelStep.ProgressDetailText, "ProgressDetailText wasn't changed as expected");

            // Hide
            Assert.IsFalse(this.testSubject.IsFinished, "Not done yet");
            this.progressEvents.InvokeFinished(ProgressControllerResult.Cancelled/*doesn't matter*/);
            Assert.IsTrue(this.testSubject.IsFinished, "Can celled - > Finished");
            this.testVisualizer.AssertIsHidden();
        }
        public void ProgressObserver_EventMonitoringAndExecution_ViewModelOutOfSync()
        {
            ConfigurableProgressTestOperation step = new ConfigurableProgressTestOperation((c, e) => { });
            step.Progress = 0.0;
            step.Indeterminate = false;
            step.ExecutionState = StepExecutionState.NotStarted;
            this.progressEvents.Steps = new IProgressStep[] { step };
            this.CreateTestSubject();

            // Create another step which is not observed
            ConfigurableProgressTestOperation anotherStep = new ConfigurableProgressTestOperation((c, e) => { });
            anotherStep.ExecutionState = StepExecutionState.Succeeded;
            anotherStep.Progress = 1.0;
            anotherStep.Indeterminate = false;

            using (new AssertIgnoreScope())
            {
                this.progressEvents.InvokeStepExecutionChanged(new StepExecutionChangedEventArgs(anotherStep));
            }

            Assert.AreEqual(0.0, this.testVisualizer.Root.MainProgress.Value, "The main progress should not change");
        }
        public void ProgressObserver_ProgressUpdate_VisibleHiddenNotImpacting()
        {
            // Setup
            bool randomIndeterminate = Environment.TickCount % 2 == 0;
            ConfigurableProgressTestOperation noImpacting1 = CreateRandomStep(visible: true, indeterminate: randomIndeterminate, impacting: false);

            noImpacting1.ExecutionState = StepExecutionState.NotStarted;
            noImpacting1.Progress       = 0;

            ConfigurableProgressTestOperation hidden1 = CreateRandomStep(visible: false, indeterminate: false, impacting: true);

            hidden1.ExecutionState = StepExecutionState.NotStarted;
            hidden1.Progress       = 0;

            ConfigurableProgressTestOperation noImpacting2 = CreateRandomStep(visible: true, indeterminate: randomIndeterminate, impacting: false);

            noImpacting2.ExecutionState = StepExecutionState.NotStarted;
            noImpacting2.Progress       = 0;

            ConfigurableProgressTestOperation visible1 = CreateRandomStep(visible: true, indeterminate: false, impacting: true);

            visible1.ExecutionState = StepExecutionState.NotStarted;
            visible1.Progress       = 0;

            ConfigurableProgressTestOperation visible2 = CreateRandomStep(visible: true, indeterminate: false, impacting: true);

            visible2.ExecutionState = StepExecutionState.NotStarted;
            visible2.Progress       = 0;

            ConfigurableProgressTestOperation hidden2 = CreateRandomStep(visible: false, indeterminate: false, impacting: true);

            hidden2.ExecutionState = StepExecutionState.NotStarted;
            hidden2.Progress       = 0;

            ConfigurableProgressTestOperation[] steps = new[] { noImpacting1, hidden1, noImpacting2, visible1, visible2, hidden2 };
            this.progressEvents.Steps = steps;
            this.CreateTestSubject();
            double mainProgressSections = steps.Count(s => s.ImpactsProgress);

            // Verify initial state
            VerifyProgress(this.testVisualizer, 0, null, 0);

            ExecutionVerifier verifier = new ExecutionVerifier(this.testVisualizer, this.testSubject);

            verifier.AppendStepToGroup(0, hidden1);
            verifier.AppendStepToGroup(0, visible1);
            verifier.AppendStepToGroup(1, visible2);
            verifier.AppendStepToGroup(1, hidden2);

            // Non-impacting started to execute
            noImpacting1.Progress       = 0;
            noImpacting1.ExecutionState = StepExecutionState.Executing;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting1, null);

            // Non-impacting reports progress
            noImpacting1.Progress = 0.5;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting1, null);

            // Non-impacting completes
            noImpacting1.Progress       = 1.0;
            noImpacting1.ExecutionState = StepExecutionState.Succeeded;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting1, null);

            // Hidden1 starts
            hidden1.ExecutionState = StepExecutionState.Executing;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, hidden1, 0);

            // Hidden1 reports progress
            hidden1.Progress              = 0.5;
            verifier.ExpectedSubProgress  = hidden1.Progress / 2.0;                  // relative to the number of sub steps in group
            verifier.ExpectedMainProgress = hidden1.Progress / mainProgressSections; // relative to the number of impacting steps
            verifier.RunAndVerifyExecutingStep(this.progressEvents, hidden1, 0);

            // Hidden1 completes
            hidden1.ExecutionState        = StepExecutionState.Cancelled;
            verifier.ExpectedSubProgress  = 1.0 / 2.0;                  // relative to the number of sub steps in group
            verifier.ExpectedMainProgress = 1.0 / mainProgressSections; // relative to the number of impacting steps
            verifier.RunAndVerifyExecutingStep(this.progressEvents, hidden1, 0);

            // Non-impacting started to execute
            noImpacting2.Progress       = 0;
            noImpacting2.ExecutionState = StepExecutionState.Executing;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting2, 0);

            // Non-impacting reports progress
            noImpacting2.Progress = 0.5;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting2, 0);

            // Non-impacting completes
            noImpacting2.Progress       = 1.0;
            noImpacting2.ExecutionState = StepExecutionState.Succeeded;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, noImpacting2, 0);

            // Visible1 starts
            visible1.ExecutionState = StepExecutionState.Executing;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, visible1, 0);

            // Visible1 reports progress
            visible1.Progress             = 1.0;
            verifier.ExpectedSubProgress  = 2.0 / 2.0;                  // relative to the number of sub steps in group
            verifier.ExpectedMainProgress = 2.0 / mainProgressSections; // relative to the number of impacting steps
            verifier.RunAndVerifyExecutingStep(this.progressEvents, visible1, 0);

            // Visible1 completes
            visible1.ExecutionState       = StepExecutionState.Failed;
            verifier.ExpectedSubProgress  = 1.0;
            verifier.ExpectedMainProgress = 2.0 / mainProgressSections; // relative to the number of impacting steps
            verifier.RunAndVerifyExecutingStep(this.progressEvents, visible1, 0);

            // Visible2 completes
            visible2.ExecutionState       = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = 1.0 / 2.0; // relative to the number of sub steps in group
            verifier.ExpectedMainProgress = 3.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, visible2, 1);

            // Hidden2 completes
            hidden2.ExecutionState        = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = 2.0 / 2.0; // relative to the number of sub steps in group
            verifier.ExpectedMainProgress = 4.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, hidden2, 1);
        }
        public void ProgressObserver_ProgressUpdate_DeterminateIndeterminate()
        {
            // Setup
            ConfigurableProgressTestOperation determinate1 = CreateRandomStep(visible: true, indeterminate: false, impacting: true);

            determinate1.Progress       = 0;
            determinate1.ExecutionState = StepExecutionState.NotStarted;

            ConfigurableProgressTestOperation indeterminate1 = CreateRandomStep(visible: true, indeterminate: true, impacting: true);

            indeterminate1.Progress       = ProgressControllerHelper.Indeterminate;
            indeterminate1.ExecutionState = StepExecutionState.NotStarted;

            ConfigurableProgressTestOperation determinate2 = CreateRandomStep(visible: true, indeterminate: false, impacting: true);

            determinate2.Progress       = 0;
            determinate2.ExecutionState = StepExecutionState.NotStarted;

            ConfigurableProgressTestOperation indeterminate2 = CreateRandomStep(visible: true, indeterminate: true, impacting: true);

            indeterminate2.Progress       = ProgressControllerHelper.Indeterminate;
            indeterminate2.ExecutionState = StepExecutionState.NotStarted;

            this.progressEvents.Steps = new[] { determinate1, indeterminate1, determinate2, indeterminate2 };
            this.CreateTestSubject();
            double mainProgressSections = this.progressEvents.Steps.Count(s => s.ImpactsProgress);

            // Verify initial state
            VerifyProgress(this.testVisualizer, 0, null, 0);

            ExecutionVerifier verifier = new ExecutionVerifier(this.testVisualizer, this.testSubject);

            verifier.AppendStepToGroup(0, determinate1);
            verifier.AppendStepToGroup(1, indeterminate1);
            verifier.AppendStepToGroup(2, determinate2);
            verifier.AppendStepToGroup(3, indeterminate2);

            // First started to execute
            determinate1.ExecutionState = StepExecutionState.Executing;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate1, 0);

            // First reports progress
            determinate1.Progress         = 0.5;
            verifier.ExpectedSubProgress  = 0.5;
            verifier.ExpectedMainProgress = 0.5 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate1, 0);

            // First completes
            determinate1.ExecutionState   = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = 1.0;
            verifier.ExpectedMainProgress = 1.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate1, 0);

            // Second starts
            indeterminate1.ExecutionState = StepExecutionState.Executing;
            verifier.ExpectedSubProgress  = ProgressControllerHelper.Indeterminate;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, indeterminate1, 1);

            // Second completes
            indeterminate1.ExecutionState = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = ProgressControllerHelper.Indeterminate;
            verifier.ExpectedMainProgress = 2.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, indeterminate1, 1);

            // Third starts
            determinate2.ExecutionState  = StepExecutionState.Executing;
            verifier.ExpectedSubProgress = 0.0;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate2, 2);

            // Third reports progress
            determinate2.Progress         = 0.5;
            verifier.ExpectedSubProgress  = 0.5;
            verifier.ExpectedMainProgress = 2.5 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate2, 2);

            // Third reports progress
            determinate2.Progress         = 1.0;
            verifier.ExpectedSubProgress  = 1.0;
            verifier.ExpectedMainProgress = 3.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate2, 2);

            // Third completes
            determinate2.ExecutionState   = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = 1.0;
            verifier.ExpectedMainProgress = 3.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, determinate2, 2);

            // Fourth completes
            indeterminate2.ExecutionState = StepExecutionState.Succeeded;
            verifier.ExpectedSubProgress  = ProgressControllerHelper.Indeterminate;
            verifier.ExpectedMainProgress = 4.0 / mainProgressSections;
            verifier.RunAndVerifyExecutingStep(this.progressEvents, indeterminate2, 3);
        }
        public void SequentialProgressController_IProgressController_TryAbort_ControllerDrivenCancellation()
        {
            // Setup
            ConfigurableProgressStepFactory testFactory = new ConfigurableProgressStepFactory();
            ConfigurableProgressTestOperation stepOperation = new ConfigurableProgressTestOperation(this.DoNothing);
            stepOperation.CancellableAction = () =>
            {
                // Using this opportunity to abort - the test assumes that Cancellable is called before the step is actually executed
                Assert.IsTrue(this.testSubject.TryAbort(), "Should be able to abort");
                return true;
            };
            testFactory.CreateOpeartion = (d) => stepOperation;
            ProgressEventsVerifier verifier = new ProgressEventsVerifier(this.testSubject);
            this.testSubject.Initialize(testFactory, new[] { new StubProgressStepDefinition() });

            // Execute
            this.testSubject.Start().Wait();

            // Verify
            verifier.AssertCorrectExecution(ProgressControllerResult.Cancelled);
            verifier.AssertStepCorrectExecution(stepOperation, StepExecutionState.NotStarted);
            verifier.AssertCancellationChanges(3);
        }
        public void SequentialProgressController_IProgressController_Start()
        {
            // Setup
            ConfigurableProgressStepFactory testFactory = new ConfigurableProgressStepFactory();
            ConfigurableProgressTestOperation stepOperation = new ConfigurableProgressTestOperation(this.VerifyControllerExecuting);
            testFactory.CreateOpeartion = (d) => stepOperation;
            this.testSubject.Initialize(testFactory, new[] { new StubProgressStepDefinition() });

            Assert.IsFalse(this.testSubject.IsStarted, "Wasn't started yet");
            Assert.IsFalse(this.testSubject.IsFinished, "Wasn't started yet");

            // Execute
            this.testSubject.Start().Wait();

            Assert.IsTrue(this.testSubject.IsStarted, "Was started");
            Assert.IsTrue(this.testSubject.IsFinished, "Was finished");
        }