private static double GetLoadTime([NotNull] TreeNode node,
                                          [NotNull] QualityVerification verification,
                                          [NotNull] ICollection <Dataset> included)
        {
            double loadTime = 0;

            foreach (TreeNode child in node.Nodes)
            {
                var dataset = node.Tag as Dataset;

                if (dataset != null && !included.Contains(dataset))
                {
                    QualityVerificationDataset verificationDataset =
                        verification.GetVerificationDataset(dataset);

                    if (verificationDataset != null)
                    {
                        loadTime += verificationDataset.LoadTime;
                    }

                    included.Add(dataset);
                }

                loadTime += GetLoadTime(child, verification, included);
            }

            return(loadTime);
        }
        private static VerifiedDatasetItem CreateVerifiedDatasetItem(
            [NotNull] QualityVerification qualityVerification,
            [NotNull] Dataset dataset,
            [NotNull] QualityConditionVerification conditionVerification)
        {
            QualityVerificationDataset verifiedDataset =
                qualityVerification.GetVerificationDataset(dataset);

            return(new VerifiedDatasetItem(conditionVerification, dataset,
                                           verifiedDataset == null
                                                               ? 0
                                                               : verifiedDataset.LoadTime));
        }
Пример #3
0
        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;
                }
            }
        }
        private void PaintInfo([NotNull] TreeNodeCollection treeNodes,
                               [CanBeNull] PaintEventArgs e,
                               [NotNull] ICollection <DrawInfo> drawInfo,
                               [NotNull] QualityVerification verification)
        {
            TimeSpan timeSpan = verification.EndDate - verification.StartDate;

            // factor was reaching infinity on verification with exactly 0 duration...
            //      ... this is caused, by QaGraphicConflict test (https://issuetracker02.eggits.net/browse/GEN-575 submitted)
            double factor;

            if (Math.Abs(timeSpan.TotalSeconds) < double.Epsilon)
            {
                factor = (_panelExecuteInfo.Width - _leftMargin - _rightMargin) /
                         _minimumTestExecutionTimeSeconds;
            }
            else
            {
                factor = (_panelExecuteInfo.Width - _leftMargin - _rightMargin) /
                         timeSpan.TotalSeconds;
            }

            foreach (TreeNode node in treeNodes)
            {
                if (node.IsExpanded)
                {
                    PaintInfo(node.Nodes, e, drawInfo, verification);
                }

                if (node.IsVisible == false)
                {
                    continue;
                }

                drawInfo.Add(new DrawInfo(node.Tag,
                                          new Point(node.Bounds.X,
                                                    node.Bounds.Y)));

                if (e == null)
                {
                    continue;
                }

                int top    = node.Bounds.Top + 1;
                int height = node.Bounds.Height - 2;

                if (node.Tag is QualityConditionVerification)
                {
                    var conditionVerification = (QualityConditionVerification)node.Tag;

                    double startTime = 0;

                    // load times
                    startTime = Draw(top, height, _leftMargin,
                                     startTime, conditionVerification.LoadTime(verification),
                                     e.Graphics, _loadColor, factor);

                    // execute times
                    startTime = Draw(top, height, _leftMargin,
                                     startTime, conditionVerification.ExecuteTime,
                                     e.Graphics, _testColor, factor);

                    startTime = Draw(top, height, _leftMargin,
                                     startTime, conditionVerification.RowExecuteTime,
                                     e.Graphics, _testColor, factor);

                    Draw(top, height, _leftMargin,
                         startTime, conditionVerification.TileExecuteTime,
                         e.Graphics, _testColor, factor);
                }
                else if (node.Tag is Dataset)
                {
                    var dataset = (Dataset)node.Tag;
                    QualityVerificationDataset verificationDataset =
                        verification.GetVerificationDataset(dataset);

                    if (verificationDataset != null)
                    {
                        double startTime = 0;
                        startTime = Draw(top, height, _leftMargin,
                                         startTime, verificationDataset.LoadTime,
                                         e.Graphics, _loadColor, factor);

                        // load times
                        startTime = Draw(top, height, _leftMargin,
                                         startTime, GetLoadTime(node, verification),
                                         e.Graphics, _loadColor, factor);

                        // show child times
                        Draw(top, height, _leftMargin,
                             startTime, GetExecutionTime(node),
                             e.Graphics, _testColor, factor);
                    }
                }
            }
        }