private static void AssignExecutionTime(
            [NotNull] ITest test,
            [NotNull] QualityConditionVerification conditionVerification,
            [NotNull] VerificationTimeStats verificationTimes)
        {
            double milliseconds;

            if (verificationTimes.TryGetTestTime(test, out milliseconds))
            {
                conditionVerification.ExecuteTime = milliseconds / 1000.0;
                return;
            }

            var containerTest = test as ContainerTest;

            if (containerTest == null)
            {
                return;
            }

            double rowMilliseconds;
            double tileCompletionMilliseconds;

            if (verificationTimes.TryGetContainerTestTimes(containerTest,
                                                           out rowMilliseconds,
                                                           out tileCompletionMilliseconds))
            {
                conditionVerification.RowExecuteTime  = rowMilliseconds / 1000.0;
                conditionVerification.TileExecuteTime = tileCompletionMilliseconds / 1000.0;
            }
        }
        public void Execute(IEnumerable <ITest> tests,
                            AreaOfInterest areaOfInterest,
                            CancellationTokenSource cancellationTokenSource)
        {
            Assert.NotNull(TestAssembler, nameof(TestAssembler));

            StartVerification(QualityVerification);

            TimeSpan processorStartTime = Process.GetCurrentProcess().UserProcessorTime;

            CancellationTokenSource = cancellationTokenSource;

            CancellationTokenSource.Token.Register(() => _executeContainer?.StopExecute());

            VerificationTimeStats = new VerificationTimeStats();

            _testPerimeter = areaOfInterest?.Geometry;

            IList <ITest> containerTests = TestAssembler.AssembleTests(
                tests, areaOfInterest, FilterTableRowsUsingRelatedGeometry,
                out IList <TestsWithRelatedGeometry> testsWithRelatedGeometry);

            var container = GetTestContainer(containerTests, AllowEditing, _tileSize,
                                             ForceFullScanForNonContainerTests);

            RowsWithStopConditions.Clear();

            VerifyByRelatedGeometry(testsWithRelatedGeometry);

            if (!Cancelled)
            {
                Verify(container, areaOfInterest);
            }

            EndVerification(QualityVerification, processorStartTime);

            _msg.DebugFormat("Number of rows with stop conditions: {0}",
                             RowsWithStopConditions.Count);
        }
        internal static void AssignExecutionTimes(
            [NotNull] QualityVerification qualityVerification,
            [NotNull] IEnumerable <KeyValuePair <ITest, TestVerification> > testVerifications,
            [NotNull] VerificationTimeStats verificationTimeStats,
            [NotNull] IDatasetLookup datasetLookup)
        {
            // Assign execute time
            foreach (KeyValuePair <ITest, TestVerification> pair in testVerifications)
            {
                AssignExecutionTime(pair.Key,
                                    pair.Value.QualityConditionVerification,
                                    verificationTimeStats);
            }

            // Assign load time
            foreach (
                KeyValuePair <IDataset, double> pair in verificationTimeStats.DatasetLoadTimes)
            {
                IDataset gdbDataset = pair.Key;

                Dataset dataset = datasetLookup.GetDataset((IDatasetName)gdbDataset.FullName);

                if (dataset == null)
                {
                    continue;
                }

                QualityVerificationDataset verificationDataset =
                    qualityVerification.GetVerificationDataset(dataset);

                if (verificationDataset != null)
                {
                    verificationDataset.LoadTime = pair.Value / 1000.0;
                }
            }
        }