Fixed SD2-1220. Code coverage result tree nodes are now sorted.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@2148 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageClassTreeNode.cs

@@ -34,6 +34,9 @@ namespace ICSharpCode.CodeCoverage
 				CodeCoverageMethodTreeNode node = new CodeCoverageMethodTreeNode(method);
 				node.AddTo(this);
 			}
+			
+			// Sort nodes.
+			SortChildNodes();
 		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethod.cs

@@ -190,20 +190,6 @@ namespace ICSharpCode.CodeCoverage
 			return matchedMethods;
 		}
 		
-		/// <summary>
-		/// Gets only those methods whose namespaces exactly match the specified string.
-		/// </summary>
-		public static List<CodeCoverageMethod> GetMethods(List<CodeCoverageMethod> methods, string ns)
-		{
-			List<CodeCoverageMethod> matchedMethods = new List<CodeCoverageMethod>();
-			foreach (CodeCoverageMethod method in methods) {
-				if (method.ClassNamespace == ns) {
-					matchedMethods.Add(method);
-				}
-			}
-			return matchedMethods;
-		}
-		
 		/// <summary>
 		/// Gets only those methods for the specified class.
 		/// </summary>

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageMethodTreeNode.cs

@@ -48,5 +48,32 @@ namespace ICSharpCode.CodeCoverage
 			}
 		}
 		
+		/// <summary>
+		/// Gets the string to be used when comparing method tree nodes
+		/// on sorting.
+		/// </summary>
+		/// <remarks>
+		/// Until we group the getter and setter into its own
+		/// property tree node we return a compare string of the
+		/// form "PropertyName set" so sorting is acceptable.
+		/// </remarks>
+		public override string CompareString {
+			get { 
+				if (IsGetterOrSetter(Name)) {
+					string getterSetterPart = Name.Substring(0, 3);
+					string property = Name.Substring(4);
+					return String.Concat(property, ' ', getterSetterPart);
+				}
+				return base.CompareString; 
+			}
+		}
+		
+		/// <summary>
+		/// Determines if the name refers to a getter or setter method.
+		/// </summary>
+		static bool IsGetterOrSetter(string name)
+		{
+			return name.StartsWith("get_") || name.StartsWith("set_");
+		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageModuleTreeNode.cs

@@ -10,6 +10,10 @@ using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.CodeCoverage
 {
+	/// <summary>
+	/// Represents an assembly in the code coverage tree view. NCover 
+	/// refers to it as a module. 
+	/// </summary>
 	public class CodeCoverageModuleTreeNode : CodeCoverageTreeNode
 	{
 		CodeCoverageModule module;
@@ -37,6 +41,8 @@ namespace ICSharpCode.CodeCoverage
 				classNode.AddTo(this);
 			}
 			
+			// Sort these nodes.
+			SortChildNodes();
 		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageNamespaceTreeNode.cs

@@ -20,6 +20,7 @@ namespace ICSharpCode.CodeCoverage
 		
 		public CodeCoverageNamespaceTreeNode(string namespacePrefix, string name, List<CodeCoverageMethod> methods) : base(name, methods, CodeCoverageImageListIndex.Namespace)
 		{
+			sortOrder = 1;
 			this.namespacePrefix = namespacePrefix;
 		}
 		
@@ -40,6 +41,9 @@ namespace ICSharpCode.CodeCoverage
 				CodeCoverageClassTreeNode classNode = new CodeCoverageClassTreeNode(className, CodeCoverageMethod.GetMethods(Methods, fullNamespace, className));
 				classNode.AddTo(this);
 			}
+			
+			// Sort nodes added.
+			SortChildNodes();
 		}
 	}
 }

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeNode.cs

@@ -33,6 +33,7 @@ namespace ICSharpCode.CodeCoverage
 		
 		public CodeCoverageTreeNode(string name, CodeCoverageImageListIndex index, int visitedCount, int notVisitedCount)
 		{
+			sortOrder = 10;
 			this.visitedCount = visitedCount;
 			this.notVisitedCount = notVisitedCount;
 			
@@ -64,6 +65,25 @@ namespace ICSharpCode.CodeCoverage
 			}
 		}
 		
+		/// <summary>
+		/// Gets the string to use when sorting the code coverage tree node. 
+		/// </summary>
+		public override string CompareString {
+			get { 
+				return Name;
+			}
+		}
+		
+		/// <summary>
+		/// Sorts the child nodes of this node. This sort is not
+		/// recursive so it only sorts the immediate children.
+		/// </summary>
+		protected void SortChildNodes()
+		{
+			ExtTreeView treeView = (ExtTreeView)TreeView;
+			treeView.SortNodes(Nodes, false);
+		}
+		
 		static string GetPercentage(int visitedCount, int totalCount)
 		{
 			int percentage = (visitedCount * 100) / totalCount;

src/AddIns/Misc/CodeCoverage/Project/Src/CodeCoverageTreeView.cs

@@ -40,6 +40,5 @@ namespace ICSharpCode.CodeCoverage
 			}
 			base.OnAfterSelect(e);
 		}
-		
 	}
 }

src/AddIns/Misc/CodeCoverage/Test/CodeCoverage.Tests.csproj

@@ -51,6 +51,7 @@
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="CodeCoverageResultsTestFixture.cs" />
     <Compile Include="CodeCoverageTreeViewTestFixture.cs" />
+    <Compile Include="DerivedCodeCoverageTreeView.cs" />
     <Compile Include="ModuleVisitedSequencePointsTestFixture.cs" />
     <Compile Include="AddCodeCoverageMarkersTestFixture.cs" />
     <Compile Include="MockDocument.cs" />
@@ -64,6 +65,8 @@
     <Compile Include="CodeCoverageMarkersInvalidEndColumnTestFixture.cs" />
     <Compile Include="NCoverSettingsTestFixture.cs" />
     <None Include="Strings.resources" />
+    <Compile Include="TreeViewAfterSelectTestFixture.cs" />
+    <Compile Include="TreeViewSortingTestFixture.cs" />
     <Compile Include="ZeroCodeCoverageTreeViewTestFixture.cs" />
     <Compile Include="InvalidSequencePointDataTestFixture.cs" />
     <Compile Include="MethodHasNoNamespaceTestFixture.cs" />

src/AddIns/Misc/CodeCoverage/Test/DerivedCodeCoverageTreeView.cs

@@ -0,0 +1,57 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Windows.Forms;
+using ICSharpCode.CodeCoverage;
+using ICSharpCode.SharpDevelop.Gui;
+
+namespace ICSharpCode.CodeCoverage.Tests
+{
+	/// <summary>
+	/// Derived code coverage tree view that gives us access to the
+	/// AfterSelect method.
+	/// </summary>
+	public class DerivedCodeCoverageTreeView : CodeCoverageTreeView
+	{
+		public void CallOnAfterSelect(TreeNode node)
+		{
+			base.OnAfterSelect(new TreeViewEventArgs(node));
+		}
+	}
+	
+	/// <summary>
+	/// Derived ExtTreeNode class so we can check the IsInitialized
+	/// property.
+	/// </summary>
+	public class DerivedExtTreeNode : ExtTreeNode
+	{
+		public bool IsInitialized {
+			get {
+				return base.isInitialized;
+			}
+		}
+	}
+	
+	/// <summary>
+	/// Derived CodeCoverageTreeNode class so we can check the IsInitialized
+	/// property.
+	/// </summary>
+	public class DerivedCodeCoverageTreeNode : CodeCoverageTreeNode
+	{
+		public DerivedCodeCoverageTreeNode(string name, CodeCoverageImageListIndex index)
+			: base(name, index)
+		{
+		}
+		
+		public bool IsInitialized {
+			get {
+				return base.isInitialized;
+			}
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/TreeViewAfterSelectTestFixture.cs

@@ -0,0 +1,54 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.SharpDevelop.Gui;
+using NUnit.Framework;
+
+namespace ICSharpCode.CodeCoverage.Tests
+{
+	/// <summary>
+	/// Tests the CodeCoverageResultsTreeView AfterSelect method.
+	/// </summary>
+	[TestFixture]
+	public class TreeViewAfterSelectTestFixture
+	{
+		/// <summary>
+		/// Code coverage tree node should be initialised in OnAfterSelect method.
+		/// </summary>
+		[Test]
+		public void NodeInitialised()
+		{
+			DerivedCodeCoverageTreeView treeView = new DerivedCodeCoverageTreeView();
+			DerivedCodeCoverageTreeNode node = new DerivedCodeCoverageTreeNode("Test", CodeCoverageImageListIndex.Class);
+			treeView.CallOnAfterSelect(node);
+			Assert.IsTrue(node.IsInitialized);
+		}
+		
+		/// <summary>
+		/// Non code coverage tree node should not initialised in OnAfterSelect method.
+		/// </summary>
+		[Test]
+		public void NonCodeCoverageNodeNotInitialised()
+		{
+			DerivedCodeCoverageTreeView treeView = new DerivedCodeCoverageTreeView();
+			DerivedExtTreeNode node = new DerivedExtTreeNode();
+			treeView.CallOnAfterSelect(node);
+			Assert.IsFalse(node.IsInitialized);
+		}
+		
+		/// <summary>
+		/// Check that the OnAfterSelect method handles a null node.
+		/// </summary>
+		[Test]
+		public void NullNode()
+		{
+			DerivedCodeCoverageTreeView treeView = new DerivedCodeCoverageTreeView();
+			treeView.CallOnAfterSelect(null);
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/TreeViewSortingTestFixture.cs

@@ -0,0 +1,253 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using ICSharpCode.CodeCoverage;
+using ICSharpCode.SharpDevelop.Gui;
+using NUnit.Framework;
+
+namespace ICSharpCode.CodeCoverage.Tests
+{
+	/// <summary>
+	/// Tests that the code coverage tree view is sorted correctly for
+	/// all node types.
+	/// </summary>
+	[TestFixture]
+	public class TreeViewSortingTestFixture
+	{
+		IComparer<TreeNode> nodeSorter;
+		CodeCoverageTreeView treeView;
+		CodeCoverageModuleTreeNode codeCoverageModuleTreeNode;
+		CodeCoverageModuleTreeNode zModuleTreeNode;
+		CodeCoverageTreeNode betaNamespaceTreeNode;
+		CodeCoverageTreeNode testFixtureClassTreeNode;
+		CodeCoverageTreeNode aardvarkNamespaceTreeNode;
+		CodeCoverageTreeNode anotherTestFixtureTreeNode;
+		CodeCoverageTreeNode testFixtureTreeNode;
+		CodeCoverageTreeNode addNodeTestTreeNode;
+		CodeCoverageTreeNode removeMarkersTestTreeNode;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			treeView = new CodeCoverageTreeView();
+			nodeSorter = treeView.NodeSorter;
+			
+			List<CodeCoverageModule> modules = new List<CodeCoverageModule>();
+			
+			// Create a module called Z.
+			CodeCoverageModule zModule = new CodeCoverageModule("Z");
+			modules.Add(zModule);
+		
+			// Create a module called CodeCoverage.
+			CodeCoverageModule codeCoverageModule = new CodeCoverageModule("CodeCoverage");
+			modules.Add(codeCoverageModule);
+			
+			// Add a method that lives in a class without any namespace.
+			CodeCoverageMethod testMethod = new CodeCoverageMethod("Test", "TestFixture");
+			codeCoverageModule.Methods.Add(testMethod);
+			
+			// Add a method which produces a namespace that alphabetically 
+			// occurs after the class already added.
+			CodeCoverageMethod removeCodeMarkersMethod = new CodeCoverageMethod("RemoveCodeMarkersMethod", "Beta.TestFixture");
+			codeCoverageModule.Methods.Add(removeCodeMarkersMethod);
+			
+			// Add a method that lives in a namespace that 
+			// occurs before the removeCodeMarkersMethod. We want to 
+			// make sure that this namespace node gets added before the Beta one.
+			CodeCoverageMethod zebraMethod = new CodeCoverageMethod("Zebra", "Aardvark.TestFixture");
+			codeCoverageModule.Methods.Add(zebraMethod);
+			
+			// Add a second class in the beta namespace so we check the 
+			// sorting of classes.
+			CodeCoverageMethod addCodeMarkersMethod = new CodeCoverageMethod("AddCodeMarkersMethod", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(addCodeMarkersMethod);
+			
+			// Add a method which produces occurs before the remove code markers method.
+			CodeCoverageMethod addNodeMethod = new CodeCoverageMethod("AddNode", "Beta.TestFixture");
+			codeCoverageModule.Methods.Add(addNodeMethod);
+			
+			// Add two get and set properties.
+			CodeCoverageMethod method = new CodeCoverageMethod("get_Zebra", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(method);
+			method = new CodeCoverageMethod("set_Zebra", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(method);
+			
+			method = new CodeCoverageMethod("set_Aardvark", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(method);
+			method = new CodeCoverageMethod("get_Aardvark", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(method);
+			
+			// Add a method which should appear between the two properties.
+			method = new CodeCoverageMethod("Chimp", "Beta.AnotherTestFixture");
+			codeCoverageModule.Methods.Add(method);
+
+			
+			// Add the modules to the tree.
+			treeView.AddModules(modules);
+			
+			codeCoverageModuleTreeNode = (CodeCoverageModuleTreeNode)treeView.Nodes[0];
+			zModuleTreeNode = (CodeCoverageModuleTreeNode)treeView.Nodes[1];
+			
+			// Initialise the code coverage module tree node.
+			codeCoverageModuleTreeNode.PerformInitialization();
+			aardvarkNamespaceTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[0];
+			betaNamespaceTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[1];
+			testFixtureClassTreeNode = (CodeCoverageTreeNode)codeCoverageModuleTreeNode.Nodes[2];
+		
+			// Initialise the beta namespace tree node.
+			betaNamespaceTreeNode.PerformInitialization();
+			anotherTestFixtureTreeNode = (CodeCoverageTreeNode)betaNamespaceTreeNode.Nodes[0];
+			testFixtureTreeNode = (CodeCoverageTreeNode)betaNamespaceTreeNode.Nodes[1];
+		
+			// Initialise the test fixture class tree node
+			testFixtureTreeNode.PerformInitialization();
+			addNodeTestTreeNode = (CodeCoverageTreeNode)testFixtureTreeNode.Nodes[0];
+			removeMarkersTestTreeNode = (CodeCoverageTreeNode)testFixtureTreeNode.Nodes[1];
+		
+			// Initialise the anotherTestFixtureTreeNode
+			anotherTestFixtureTreeNode.PerformInitialization();
+		}
+		
+		[TestFixtureTearDown]
+		public void TearDownFixture()
+		{
+			treeView.Dispose();
+		}
+		
+		[Test]
+		public void FirstModuleTreeNode()
+		{
+			Assert.AreEqual("CodeCoverage", codeCoverageModuleTreeNode.Name);
+		}
+		
+		[Test]
+		public void SecondModuleTreeNode()
+		{
+			Assert.AreEqual("Z", zModuleTreeNode.Name);
+		}
+		
+		/// <summary>
+		/// Makes sure this is the second child node of the code coverage module
+		/// parent tree node.
+		/// </summary>
+		[Test]
+		public void BetaNamespaceTreeNodeName()
+		{
+			Assert.AreEqual("Beta", betaNamespaceTreeNode.Name);
+		}
+		
+		[Test]
+		public void AardvarkNamespaceTreeNodeName()
+		{
+			Assert.AreEqual("Aardvark", aardvarkNamespaceTreeNode.Name);
+		}
+		
+		/// <summary>
+		/// Test the code coverage tree view's node sorted correctly 
+		/// orders the namespace tree nodes.
+		/// </summary>
+		[Test]
+		public void SameNamespaceTreeNodeCompared()
+		{
+			Assert.AreEqual(0, nodeSorter.Compare(aardvarkNamespaceTreeNode, aardvarkNamespaceTreeNode));
+		}
+		
+		[Test]
+		public void FirstNamespaceTreeNodeLessThan()
+		{
+			int expectedResult = aardvarkNamespaceTreeNode.CompareString.CompareTo(betaNamespaceTreeNode.CompareString);
+			Assert.AreEqual(aardvarkNamespaceTreeNode.Name, aardvarkNamespaceTreeNode.CompareString);
+			Assert.AreEqual(betaNamespaceTreeNode.Name, betaNamespaceTreeNode.CompareString);
+			Assert.AreEqual(expectedResult, nodeSorter.Compare(aardvarkNamespaceTreeNode, betaNamespaceTreeNode));
+		}
+		
+		[Test]
+		public void FirstNamespaceTreeNodeMoreThan()
+		{		
+			int expectedResult = betaNamespaceTreeNode.CompareString.CompareTo(aardvarkNamespaceTreeNode.CompareString);
+			Assert.AreEqual(expectedResult, nodeSorter.Compare(betaNamespaceTreeNode, aardvarkNamespaceTreeNode));
+		}
+		
+		/// <summary>
+		/// The namespace node should always be ordered before any class node.
+		/// </summary>
+		[Test]
+		public void ClassAndNamespaceTreeNodeCompared()
+		{
+			List<CodeCoverageMethod> methods = new List<CodeCoverageMethod>();
+			CodeCoverageNamespaceTreeNode namespaceTreeNode = new CodeCoverageNamespaceTreeNode("Z", methods);
+			CodeCoverageClassTreeNode classTreeNode = new CodeCoverageClassTreeNode("A", methods);
+			Assert.AreEqual(-1, nodeSorter.Compare(namespaceTreeNode, classTreeNode));
+			Assert.Greater(classTreeNode.SortOrder, namespaceTreeNode.SortOrder);
+		}
+		
+		/// <summary>
+		/// The compare string should be the name of the node not including
+		/// any percentages.
+		/// </summary>
+		[Test]
+		public void CodeCoverageTreeNodeCompareString()
+		{
+			CodeCoverageTreeNode node = new CodeCoverageTreeNode("A", CodeCoverageImageListIndex.Class, 1, 2);
+			Assert.AreEqual("A", node.CompareString);
+		}
+		
+		[Test]
+		public void TestFixtureTreeNodeName()
+		{
+			Assert.AreEqual("TestFixture", testFixtureTreeNode.Name);
+		}
+		
+		[Test]
+		public void AnotherTestFixtureTreeNodeName()
+		{
+			Assert.AreEqual("AnotherTestFixture", anotherTestFixtureTreeNode.Name);
+		}
+		
+		[Test]
+		public void RemoveMarkersTestTreeNodeName()
+		{
+			Assert.AreEqual("RemoveCodeMarkersMethod", removeMarkersTestTreeNode.Name);
+		}
+		
+		[Test]
+		public void AddNodeTestTreeNodeName()
+		{
+			Assert.AreEqual("AddNode", addNodeTestTreeNode.Name);
+		}
+		
+		[Test]
+		public void PropertyMethodsSorted()
+		{
+			Assert.AreEqual("get_Aardvark", anotherTestFixtureTreeNode.Nodes[0].Name);
+			Assert.AreEqual("set_Aardvark", anotherTestFixtureTreeNode.Nodes[1].Name);
+			Assert.AreEqual("AddCodeMarkersMethod", anotherTestFixtureTreeNode.Nodes[2].Name);
+			Assert.AreEqual("Chimp", anotherTestFixtureTreeNode.Nodes[3].Name);
+			Assert.AreEqual("get_Zebra", anotherTestFixtureTreeNode.Nodes[4].Name);
+			Assert.AreEqual("set_Zebra", anotherTestFixtureTreeNode.Nodes[5].Name);
+		}
+		
+		[Test]
+		public void GetterPropertyCompareString()
+		{
+			CodeCoverageMethod getterMethod = new CodeCoverageMethod("get_Aardvark", "Animal");
+			CodeCoverageMethodTreeNode getterNode = new CodeCoverageMethodTreeNode(getterMethod);
+			Assert.AreEqual("Aardvark get", getterNode.CompareString);
+		}
+		
+		[Test]
+		public void SetterPropertyCompareString()
+		{
+			CodeCoverageMethod setterMethod = new CodeCoverageMethod("set_Aardvark", "Animal");
+			CodeCoverageMethodTreeNode setterNode = new CodeCoverageMethodTreeNode(setterMethod);
+			Assert.AreEqual("Aardvark set", setterNode.CompareString);
+		}
+	}
+}

src/AddIns/Misc/CodeCoverage/Test/ZeroCodeCoverageTreeViewTestFixture.cs

@@ -99,6 +99,7 @@ namespace ICSharpCode.CodeCoverage.Tests
 		{
 			fooTestMethodTreeNode.VisitedCount = 1;
 			Assert.AreEqual(CodeCoverageImageListIndex.Method, (CodeCoverageImageListIndex)(fooTestMethodTreeNode.ImageIndex));
+			Assert.AreEqual(1, fooTestMethodTreeNode.VisitedCount);
 		}
 
 		[Test]
@@ -107,6 +108,7 @@ namespace ICSharpCode.CodeCoverage.Tests
 			fooTestMethodTreeNode.NotVisitedCount = 0;
 			fooTestMethodTreeNode.VisitedCount = 2;
 			Assert.AreEqual(Color.Empty, fooTestMethodTreeNode.ForeColor);
+			Assert.AreEqual(0, fooTestMethodTreeNode.NotVisitedCount);
 		}
 	}
 }