예제 #1
0
        /// <summary>
        /// Create a TreeGridNode for a coverage item.
        /// </summary>
        /// <param name="parent">Parent of the tree node.</param>
        /// <param name="item">Coverage item.</param>
        /// <returns>TreeGridNode for the coverage item.</returns>
        private TreeGridNode CreateCoverageNode(TreeGridNode parent, CoverageItem item)
        {
            TreeGridNode node = new TreeGridNode {
                Tag = item
            };

            ((parent != null) ? parent.Nodes : _grdCoverage.Nodes).Add(node);
            node.SetValues(item.Name, item.UncoveredBlocks, item.UncoveredBlocksPercentage, item.CoveredBlocks, item.CoveredBlocksPercentage, null);
            switch (item.ItemType)
            {
            case CoverageItemType.Assembly:
                node.ImageIndex = 0;
                node.Expand();
                break;

            case CoverageItemType.Namespace:
                node.ImageIndex = 1;
                node.Expand();
                break;

            case CoverageItemType.Type:
                node.ImageIndex = 2;
                node.Expand();
                break;

            case CoverageItemType.Method:
                node.ImageIndex = 3;
                break;
            }
            return(node);
        }
예제 #2
0
        /// <summary>
        /// View the coverage data for a specific item.
        /// </summary>
        /// <param name="sender">DataGrid cell.</param>
        /// <param name="e">Event arguments.</param>
        private void OnCoverageCellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            // Get the node for the clicked row
            TreeGridNode node = _grdCoverage.GetNodeForRow(e.RowIndex);

            if (node != null)
            {
                // Get the associated coverage item
                CoverageItem item = node.Tag as CoverageItem;
                if (item != null)
                {
                    // Walk down the children until we have a file
                    while (string.IsNullOrEmpty(item.File) && item.Children.Count > 0)
                    {
                        item = item.Children[0];
                    }

                    // Change to the file if we can
                    if (!string.IsNullOrEmpty(item.File))
                    {
                        ViewCoverageItem(item);
                    }
                }
            }
        }
예제 #3
0
        /// <summary>
        /// View the coverage data for an item.
        /// </summary>
        /// <param name="item">Coverage item to view.</param>
        private void ViewCoverageItem(CoverageItem item)
        {
            if (SelectedItem == item)
            {
                return;
            }
            SelectedItem = item;

            // Only change the source tab if the file is different
            if (string.Compare(SelectedFile, item.File, StringComparison.OrdinalIgnoreCase) != 0)
            {
                SelectedFile    = item.File;
                _lblFile.Text   = Path.GetFileName(item.File);
                _txtSource.Text = File.ReadAllText(item.File);
                _cmbIRMethods.Items.Clear();

                // Highlight the file
                List <CoverageItem> intervals;
                if (Highlighting.TryGetValue(item.File, out intervals))
                {
                    foreach (CoverageItem interval in intervals)
                    {
                        Color highlight = GetHighlightColor(interval.Covered);
                        for (int line = interval.StartLine; line <= interval.EndLine; line++)
                        {
                            int start = (line == interval.StartLine) ?
                                        interval.StartColumn :
                                        0;
                            int end = (line == interval.EndLine) ?
                                      interval.EndColumn :
                                      -1;
                            HighlightLine(_txtSource, line, start, end, highlight);
                        }
                    }
                }

                // Fill the LIR drop down
                CoverageItem typeItem = item.Parent;
                foreach (CoverageItem methodItem in typeItem.Children)
                {
                    _cmbIRMethods.Items.Add(methodItem);
                }
            }

            // Scroll to the desired line in the source tab (though we move 5
            // lines up in the file since the method lines start at the first
            // instruction instead of the declaration)
            _txtSource.Select(_txtSource.GetFirstCharIndexFromLine(Math.Max(0, item.StartLine - 5)), 0);
            _txtSource.ScrollToCaret();

            // Select the item in the LIR drop down
            _cmbIRMethods.SelectedItem = SelectedItem;
        }
예제 #4
0
        /// <summary>
        /// Load code coverage data.
        /// </summary>
        /// <param name="path">Path to the coverage data.</param>
        /// <param name="newPathPrefix">New path prefix for files.</param>
        public void LoadCoverageData(string path, string newPathPrefix)
        {
            // Clear any existing values
            _grdCoverage.Nodes.Clear();
            SelectedFile    = null;
            _lblFile.Text   = null;
            _txtSource.Text = null;

            // Load the coverage data
            CoverageDataPath = path;
            CoverageData     = XDocument.Load(path);
            IEnumerable <CoverageItem> data = CoverageItem.Parse(CoverageData, newPathPrefix);

            Highlighting = new Dictionary <string, List <CoverageItem> >();

            // Populate the grid
            foreach (CoverageItem assemblyItem in data)
            {
                TreeGridNode assemblyNode = CreateCoverageNode(null, assemblyItem);
                foreach (CoverageItem namespaceItem in assemblyItem.Children)
                {
                    TreeGridNode namespaceNode = CreateCoverageNode(assemblyNode, namespaceItem);
                    foreach (CoverageItem typeItem in namespaceItem.Children)
                    {
                        TreeGridNode typeNode = CreateCoverageNode(namespaceNode, typeItem);
                        foreach (CoverageItem methodItem in typeItem.Children)
                        {
                            CreateCoverageNode(typeNode, methodItem);
                            foreach (CoverageItem blockItem in methodItem.Children)
                            {
                                List <CoverageItem> intervals = null;
                                if (!Highlighting.TryGetValue(blockItem.File, out intervals))
                                {
                                    intervals = new List <CoverageItem>();
                                    Highlighting[blockItem.File] = intervals;
                                }
                                intervals.Add(blockItem);
                            }
                        }
                        typeNode.Collapse();
                    }
                }
            }

            // Sort the highlights (see HighlightComparer for more details)
            foreach (List <CoverageItem> list in Highlighting.Values)
            {
                list.Sort(CoverageItem.HighlightComparer);
            }
        }
예제 #5
0
        /// <summary>
        /// Compare the highlight ordering of two coverage items.
        /// </summary>
        /// <param name="first">First coverage item.</param>
        /// <param name="second">Second coverage item.</param>
        /// <returns>
        /// 0 if the items are equal, -1 if first comes before second, or 1 if
        /// second comes before first.
        /// </returns>
        public static int HighlightComparer(CoverageItem first, CoverageItem second)
        {
            // Basic blocks will only overlap by nesting one inside the other.
            // Therefore we want to sort with the largest containing blocks at
            // the front of the list (so they will be "painted" first)

            if (first == null)
            {
                // If one or both are null
                return((second == null) ? 0 : 1);
            }
            else if (first == second)
            {
                // If they're the same object
                return(0);
            }
            else if (first.StartLine <= second.StartLine && first.EndLine >= second.EndLine)
            {
                // If the first contains the second
                return(-1);
            }
            else if (second.StartLine <= first.StartLine && second.EndLine >= first.EndLine)
            {
                // If the second contains the first
                return(1);
            }
            else if (first.StartLine != second.StartLine)
            {
                // Otherwise sort them be file position
                return((first.StartLine <= second.StartLine) ? -1 : 1);
            }
            else if (first.StartColumn != second.StartColumn)
            {
                // Or sort them by line position
                return((first.StartColumn <= second.StartColumn) ? -1 : 1);
            }
            else if (first.Covered != second.Covered)
            {
                // Or if they're the same character, make the uncovered one go
                // last so people can see it easier
                return(first.Covered ? -1 : 1);
            }
            else
            {
                return(0);
            }
        }
예제 #6
0
        /// <summary>
        /// Reload the LIR when the selected index is changed.
        /// </summary>
        /// <param name="sender">Combo box.</param>
        /// <param name="e">Event arguments.</param>
        private void OnIRMethodsSelectedIndexChanged(object sender, EventArgs e)
        {
            _txtIR.Text = "";

            // Get the selected item
            CoverageItem methodItem = _cmbIRMethods.SelectedItem as CoverageItem;

            if (methodItem == null)
            {
                return;
            }

            // Get the IR instructions
            string fullTypeName = methodItem.Parent.Parent.Name + '.' + methodItem.Parent.Name;

            XElement[] instructions =
                CoverageData
                .Descendants("method")
                .Where(m =>
                       string.Compare(m.Attribute("name").Value, methodItem.Name, StringComparison.OrdinalIgnoreCase) == 0 &&
                       string.Compare(m.Attribute("class").Value, fullTypeName, StringComparison.OrdinalIgnoreCase) == 0)
                .Descendants("instruction")
                .ToArray();

            // Build up the coverage display
            StringBuilder source = new StringBuilder();

            foreach (XElement instruction in instructions)
            {
                source.AppendLine(instruction.Value);
            }
            _txtIR.Text = source.ToString();

            // Highlight the coverage
            Dictionary <string, bool> coverage = methodItem.Children.ToDictionary(i => i.Name, i => i.Covered);

            for (int i = 0; i < instructions.Length; i++)
            {
                bool   covered;
                string block = instructions[i].Attribute("block").Value;
                if (coverage.TryGetValue(block, out covered))
                {
                    HighlightLine(_txtIR, i, 0, -1, GetHighlightColor(covered));
                }
            }
        }
예제 #7
0
 /// <summary>
 /// Compare the names of two coverage items for sorting.
 /// </summary>
 /// <param name="first">First coverage item.</param>
 /// <param name="second">Second coverage item.</param>
 /// <returns>
 /// 0 if the names are equal, -1 if first comes before second, or 1 if
 /// second comes before first.
 /// </returns>
 public static int SortComparer(CoverageItem first, CoverageItem second)
 {
     return(string.CompareOrdinal(first.Name, second.Name));
 }
예제 #8
0
        /// <summary>
        /// Parse a coverage data file into coverage items.
        /// </summary>
        /// <param name="document">XDocument containing the file.</param>
        /// <param name="newPathPrefix">New path prefix for files.</param>
        /// <returns>Top level coverage items.</returns>
        public static IEnumerable <CoverageItem> Parse(XDocument document, string newPathPrefix)
        {
            // Obtain the value of old prefix used in coverage.xml
            string oldpathprefix = document.Root.Attribute("pathprefix").Value;

            // Covert the XML into CoverageItems
            List <CoverageItem> assemblies = new List <CoverageItem>();

            foreach (XElement assemblyElement in document.Root.Elements("assembly"))
            {
                // Get coverate details for an assembly
                CoverageItem assemblyItem = new CoverageItem
                {
                    ItemType = CoverageItemType.Assembly,
                    Name     = assemblyElement.Attribute("name").Value
                };
                assemblies.Add(assemblyItem);
                foreach (XElement methodElement in assemblyElement.Elements("method"))
                {
                    // Split the type name into namespace/type
                    string fullName      = methodElement.Attribute("class").Value;
                    int    partition     = fullName.LastIndexOf('.');
                    string namespaceName = (partition < 0) ? "" : fullName.Substring(0, partition);
                    string typeName      = fullName.Substring(partition + 1, fullName.Length - partition - 1);

                    // Get coverage details for the namespace
                    CoverageItem namespaceItem = null;
                    foreach (CoverageItem ns in assemblyItem.Children)
                    {
                        if (string.Compare(ns.Name, namespaceName, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            namespaceItem = ns;
                            break;
                        }
                    }
                    if (namespaceItem == null)
                    {
                        namespaceItem = new CoverageItem
                        {
                            ItemType = CoverageItemType.Namespace,
                            Name     = namespaceName,
                            Parent   = assemblyItem
                        };
                        assemblyItem.Children.Add(namespaceItem);
                    }

                    // Get coverage details for the type
                    CoverageItem typeItem = null;
                    foreach (CoverageItem t in namespaceItem.Children)
                    {
                        if (string.Compare(t.Name, typeName, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            typeItem = t;
                            break;
                        }
                    }
                    if (typeItem == null)
                    {
                        typeItem = new CoverageItem
                        {
                            ItemType = CoverageItemType.Type,
                            Name     = typeName,
                            Parent   = namespaceItem
                        };
                        namespaceItem.Children.Add(typeItem);
                    }

                    // Replace the old file path prefix in method with new prefix if not null
                    string tempmethodstr = methodElement.Attribute("file").Value;
                    tempmethodstr = ChangeAbsolutePath(tempmethodstr, oldpathprefix, newPathPrefix);

                    // Get coverage details for the method
                    CoverageItem methodItem = new CoverageItem
                    {
                        ItemType  = CoverageItemType.Method,
                        Name      = methodElement.Attribute("name").Value,
                        File      = tempmethodstr,
                        StartLine = int.Parse(methodElement.Attribute("line").Value, CultureInfo.InvariantCulture),
                        Parent    = typeItem
                    };
                    typeItem.Children.Add(methodItem);

                    // Get coverage details for the method's blocks
                    foreach (XElement blockElement in methodElement.Descendants("block"))
                    {
                        // Replace the old file path prefix in block with new prefix if not null
                        string tempblockstr = blockElement.Attribute("file").Value;
                        tempblockstr = ChangeAbsolutePath(tempblockstr, oldpathprefix, newPathPrefix);

                        CoverageItem blockItem = new CoverageItem
                        {
                            ItemType      = CoverageItemType.Block,
                            Name          = blockElement.Attribute("id").Value,
                            File          = tempblockstr,
                            CoveredBlocks = string.Compare(blockElement.Attribute("visited").Value, "1", StringComparison.OrdinalIgnoreCase) == 0 ? 1 : 0,
                            TotalBlocks   = 1,
                            StartLine     = int.Parse(blockElement.Attribute("startLine").Value, CultureInfo.InvariantCulture),
                            StartColumn   = int.Parse(blockElement.Attribute("startColumn").Value, CultureInfo.InvariantCulture),
                            EndLine       = int.Parse(blockElement.Attribute("lastLine").Value, CultureInfo.InvariantCulture),
                            EndColumn     = int.Parse(blockElement.Attribute("lastColumn").Value, CultureInfo.InvariantCulture),
                            Parent        = methodItem
                        };
                        methodItem.Children.Add(blockItem);

                        // Update the coverage statistics
                        assemblyItem.TotalBlocks++;
                        namespaceItem.TotalBlocks++;
                        typeItem.TotalBlocks++;
                        methodItem.TotalBlocks++;
                        if (blockItem.Covered)
                        {
                            assemblyItem.CoveredBlocks++;
                            namespaceItem.CoveredBlocks++;
                            typeItem.CoveredBlocks++;
                            methodItem.CoveredBlocks++;
                        }
                    }
                }

                // Sort all of the lists when an assembly is finished
                List <CoverageItem> namespaces = assemblyItem.Children as List <CoverageItem>;
                namespaces.Sort(SortComparer);
                foreach (CoverageItem namespaceItem in assemblyItem.Children)
                {
                    List <CoverageItem> types = namespaceItem.Children as List <CoverageItem>;
                    types.Sort(SortComparer);

                    foreach (CoverageItem typeItem in namespaceItem.Children)
                    {
                        List <CoverageItem> methods = typeItem.Children as List <CoverageItem>;
                        methods.Sort(SortComparer);
                    }
                }
            }

            assemblies.Sort(SortComparer);
            return(assemblies);
        }
예제 #9
0
        /// <summary>
        /// View the coverage data for an item.
        /// </summary>
        /// <param name="item">Coverage item to view.</param>
        private void ViewCoverageItem(CoverageItem item)
        {
            if (SelectedItem == item)
            {
                return;
            }
            SelectedItem = item;

            // Only change the source tab if the file is different
            if (string.Compare(SelectedFile, item.File, StringComparison.OrdinalIgnoreCase) != 0)
            {
                SelectedFile = item.File;
                _lblFile.Text = Path.GetFileName(item.File);
                _txtSource.Text = File.ReadAllText(item.File);
                _cmbIRMethods.Items.Clear();

                // Highlight the file
                List<CoverageItem> intervals;
                if (Highlighting.TryGetValue(item.File, out intervals))
                {
                    foreach (CoverageItem interval in intervals)
                    {
                        Color highlight = GetHighlightColor(interval.Covered);
                        for (int line = interval.StartLine; line <= interval.EndLine; line++)
                        {
                            int start = (line == interval.StartLine) ?
                                interval.StartColumn :
                                0;
                            int end = (line == interval.EndLine) ?
                                interval.EndColumn :
                                -1;
                            HighlightLine(_txtSource, line, start, end, highlight);
                        }
                    }
                }

                // Fill the LIR drop down
                CoverageItem typeItem = item.Parent;
                foreach (CoverageItem methodItem in typeItem.Children)
                {
                    _cmbIRMethods.Items.Add(methodItem);
                }
            }

            // Scroll to the desired line in the source tab (though we move 5
            // lines up in the file since the method lines start at the first
            // instruction instead of the declaration)
            _txtSource.Select(_txtSource.GetFirstCharIndexFromLine(Math.Max(0, item.StartLine - 5)), 0);
            _txtSource.ScrollToCaret();

            // Select the item in the LIR drop down
            _cmbIRMethods.SelectedItem = SelectedItem;
        }
예제 #10
0
 /// <summary>
 /// Create a TreeGridNode for a coverage item.
 /// </summary>
 /// <param name="parent">Parent of the tree node.</param>
 /// <param name="item">Coverage item.</param>
 /// <returns>TreeGridNode for the coverage item.</returns>
 private TreeGridNode CreateCoverageNode(TreeGridNode parent, CoverageItem item)
 {
     TreeGridNode node = new TreeGridNode { Tag = item };
     ((parent != null) ? parent.Nodes : _grdCoverage.Nodes).Add(node);
     node.SetValues(item.Name, item.UncoveredBlocks, item.UncoveredBlocksPercentage, item.CoveredBlocks, item.CoveredBlocksPercentage, null);
     switch (item.ItemType)
     {
         case CoverageItemType.Assembly:
             node.ImageIndex = 0;
             node.Expand();
             break;
         case CoverageItemType.Namespace:
             node.ImageIndex = 1;
             node.Expand();
             break;
         case CoverageItemType.Type:
             node.ImageIndex = 2;
             node.Expand();
             break;
         case CoverageItemType.Method:
             node.ImageIndex = 3;
             break;
     }
     return node;
 }
        /// <summary>
        /// Compare the highlight ordering of two coverage items.
        /// </summary>
        /// <param name="first">First coverage item.</param>
        /// <param name="second">Second coverage item.</param>
        /// <returns>
        /// 0 if the items are equal, -1 if first comes before second, or 1 if
        /// second comes before first.
        /// </returns>
        public static int HighlightComparer(CoverageItem first, CoverageItem second)
        {
            // Basic blocks will only overlap by nesting one inside the other.
            // Therefore we want to sort with the largest containing blocks at
            // the front of the list (so they will be "painted" first)

            if (first == null)
            {
                // If one or both are null
                return (second == null) ? 0 : 1;
            }
            else if (first == second)
            {
                // If they're the same object
                return 0;
            }
            else if (first.StartLine <= second.StartLine && first.EndLine >= second.EndLine)
            {
                // If the first contains the second
                return -1;
            }
            else if (second.StartLine <= first.StartLine && second.EndLine >= first.EndLine)
            {
                // If the second contains the first
                return 1;
            }
            else if (first.StartLine != second.StartLine)
            {
                // Otherwise sort them be file position
                return (first.StartLine <= second.StartLine) ? -1 : 1;
            }
            else if (first.StartColumn != second.StartColumn)
            {
                // Or sort them by line position
                return (first.StartColumn <= second.StartColumn) ? -1 : 1;
            }
            else if (first.Covered != second.Covered)
            {
                // Or if they're the same character, make the uncovered one go
                // last so people can see it easier
                return first.Covered ? -1 : 1;
            }
            else
            {
                return 0;
            }
        }
 /// <summary>
 /// Compare the names of two coverage items for sorting.
 /// </summary>
 /// <param name="first">First coverage item.</param>
 /// <param name="second">Second coverage item.</param>
 /// <returns>
 /// 0 if the names are equal, -1 if first comes before second, or 1 if
 /// second comes before first.
 /// </returns>
 public static int SortComparer(CoverageItem first, CoverageItem second)
 {
     return string.CompareOrdinal(first.Name, second.Name);
 }
        /// <summary>
        /// Parse a coverage data file into coverage items.
        /// </summary>
        /// <param name="document">XDocument containing the file.</param>
        /// <param name="newPathPrefix">New path prefix for files.</param>
        /// <returns>Top level coverage items.</returns>
        public static IEnumerable<CoverageItem> Parse(XDocument document, string newPathPrefix)
        {
            // Obtain the value of old prefix used in coverage.xml
            string oldpathprefix = document.Root.Attribute("pathprefix").Value;

            // Covert the XML into CoverageItems
            List<CoverageItem> assemblies = new List<CoverageItem>();
            foreach (XElement assemblyElement in document.Root.Elements("assembly"))
            {
                // Get coverate details for an assembly
                CoverageItem assemblyItem = new CoverageItem
                {
                    ItemType = CoverageItemType.Assembly,
                    Name = assemblyElement.Attribute("name").Value
                };
                assemblies.Add(assemblyItem);
                foreach (XElement methodElement in assemblyElement.Elements("method"))
                {
                    // Split the type name into namespace/type
                    string fullName = methodElement.Attribute("class").Value;
                    int partition = fullName.LastIndexOf('.');
                    string namespaceName = (partition < 0) ? "" : fullName.Substring(0, partition);
                    string typeName = fullName.Substring(partition + 1, fullName.Length - partition - 1);

                    // Get coverage details for the namespace
                    CoverageItem namespaceItem = null;
                    foreach (CoverageItem ns in assemblyItem.Children)
                    {
                        if (string.Compare(ns.Name, namespaceName, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            namespaceItem = ns;
                            break;
                        }
                    }
                    if (namespaceItem == null)
                    {
                        namespaceItem = new CoverageItem
                        {
                            ItemType = CoverageItemType.Namespace,
                            Name = namespaceName,
                            Parent = assemblyItem
                        };
                        assemblyItem.Children.Add(namespaceItem);
                    }

                    // Get coverage details for the type
                    CoverageItem typeItem = null;
                    foreach (CoverageItem t in namespaceItem.Children)
                    {
                        if (string.Compare(t.Name, typeName, StringComparison.OrdinalIgnoreCase) == 0)
                        {
                            typeItem = t;
                            break;
                        }
                    }
                    if (typeItem == null)
                    {
                        typeItem = new CoverageItem
                        {
                            ItemType = CoverageItemType.Type,
                            Name = typeName,
                            Parent = namespaceItem
                        };
                        namespaceItem.Children.Add(typeItem);
                    }

                    // Replace the old file path prefix in method with new prefix if not null
                    string tempmethodstr = methodElement.Attribute("file").Value;
                    tempmethodstr = ChangeAbsolutePath(tempmethodstr, oldpathprefix, newPathPrefix);

                    // Get coverage details for the method
                    CoverageItem methodItem = new CoverageItem
                    {
                        ItemType = CoverageItemType.Method,
                        Name = methodElement.Attribute("name").Value,
                        File = tempmethodstr,
                        StartLine = int.Parse(methodElement.Attribute("line").Value, CultureInfo.InvariantCulture),
                        Parent = typeItem
                    };
                    typeItem.Children.Add(methodItem);

                    // Get coverage details for the method's blocks
                    foreach (XElement blockElement in methodElement.Descendants("block"))
                    {
                        // Replace the old file path prefix in block with new prefix if not null
                        string tempblockstr = blockElement.Attribute("file").Value;
                        tempblockstr = ChangeAbsolutePath(tempblockstr, oldpathprefix, newPathPrefix);

                        CoverageItem blockItem = new CoverageItem
                        {
                            ItemType = CoverageItemType.Block,
                            Name = blockElement.Attribute("id").Value,
                            File = tempblockstr,
                            CoveredBlocks = string.Compare(blockElement.Attribute("visited").Value, "1", StringComparison.OrdinalIgnoreCase) == 0 ? 1 : 0,
                            TotalBlocks = 1,
                            StartLine = int.Parse(blockElement.Attribute("startLine").Value, CultureInfo.InvariantCulture),
                            StartColumn = int.Parse(blockElement.Attribute("startColumn").Value, CultureInfo.InvariantCulture),
                            EndLine = int.Parse(blockElement.Attribute("lastLine").Value, CultureInfo.InvariantCulture),
                            EndColumn = int.Parse(blockElement.Attribute("lastColumn").Value, CultureInfo.InvariantCulture),
                            Parent = methodItem
                        };
                        methodItem.Children.Add(blockItem);

                        // Update the coverage statistics
                        assemblyItem.TotalBlocks++;
                        namespaceItem.TotalBlocks++;
                        typeItem.TotalBlocks++;
                        methodItem.TotalBlocks++;
                        if (blockItem.Covered)
                        {
                            assemblyItem.CoveredBlocks++;
                            namespaceItem.CoveredBlocks++;
                            typeItem.CoveredBlocks++;
                            methodItem.CoveredBlocks++;
                        }
                    }
                }

                // Sort all of the lists when an assembly is finished
                List<CoverageItem> namespaces = assemblyItem.Children as List<CoverageItem>;
                namespaces.Sort(SortComparer);
                foreach (CoverageItem namespaceItem in assemblyItem.Children)
                {
                    List<CoverageItem> types = namespaceItem.Children as List<CoverageItem>;
                    types.Sort(SortComparer);

                    foreach (CoverageItem typeItem in namespaceItem.Children)
                    {
                        List<CoverageItem> methods = typeItem.Children as List<CoverageItem>;
                        methods.Sort(SortComparer);
                    }
                }
            }

            assemblies.Sort(SortComparer);
            return assemblies;
        }