private void RemoveFromMap(TestSuiteTreeNode node)
{
foreach (TestSuiteTreeNode child in node.Nodes)
{
RemoveFromMap(child);
}
treeMap.Remove(node.Test.UniqueName);
}
/// <summary>
/// When Collapse context menu item is clicked, collapse the node
/// </summary>
private void collapseMenuItem_Click(object sender, System.EventArgs e)
{
TestSuiteTreeNode targetNode = contextNode != null ? contextNode : (TestSuiteTreeNode)SelectedNode;
if (targetNode != null)
{
targetNode.Collapse();
}
}
/// <summary>
/// When Expand context menu item is clicked, expand the node
/// </summary>
private void expandMenuItem_Click(object sender, System.EventArgs e)
{
TestSuiteTreeNode targetNode = explicitlySelectedNode != null ? explicitlySelectedNode : (TestSuiteTreeNode)SelectedNode;
if (targetNode != null)
{
targetNode.Expand();
}
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.HasResult &&
(node.Result.ResultState == ResultState.Failure ||
node.Result.ResultState == ResultState.Error))
{
tests.Add(node.Test);
}
}
/// <summary>
/// Remove a node from the tree itself and the hashtable
/// </summary>
/// <param name="node">Node to remove</param>
private void RemoveNode(TestSuiteTreeNode node)
{
if (explicitlySelectedNode == node)
{
explicitlySelectedNode = null;
}
RemoveFromMap(node);
node.Remove();
}
private void propertiesMenuItem_Click(object sender, System.EventArgs e)
{
TestSuiteTreeNode targetNode = contextNode != null ? contextNode : (TestSuiteTreeNode)SelectedNode;
if (targetNode != null)
{
ShowPropertiesDialog(targetNode);
}
}
/// <summary>
/// Remove a node from the tree itself and the hashtable
/// </summary>
/// <param name="node">Node to remove</param>
private void RemoveNode(TestSuiteTreeNode node)
{
if (contextNode == node)
{
contextNode = null;
}
RemoveFromMap(node);
node.Remove();
}
private void FindCheckedNodes(TestSuiteTreeNode node, bool topLevel)
{
if (node.Checked)
{
checkedTests.Add(new CheckedTestInfo(node.Test, topLevel));
topLevel = false;
}
FindCheckedNodes(node.Nodes, topLevel);
}
/// <summary>
/// Reload the tree with a changed test hierarchy
/// while maintaining as much gui state as possible
/// </summary>
/// <param name="test">Test suite to be loaded</param>
public void Reload(UITestNode test)
{
TestSuiteTreeNode rootNode = (TestSuiteTreeNode)Nodes[0];
// Temporary change till framework is updated
// if ( !Match( rootNode, test ) )
// throw( new ArgumentException( "Reload called with non-matching test" ) );
UpdateNode(rootNode, test);
}
private TestSuiteTreeNode FindNode(ITest test)
{
TestSuiteTreeNode node = treeMap[test.TestName.UniqueName] as TestSuiteTreeNode;
if (node == null)
{
node = FindNodeByName(test.TestName.FullName);
}
return(node);
}
/// <summary>
/// Helper returns true if the node test is not in
/// the list of tests provided.
/// </summary>
/// <param name="node">Node to examine</param>
/// <param name="tests">List of tests to match with node</param>
private bool NodeWasDeleted(TestSuiteTreeNode node, IList tests)
{
foreach (TestNode test in tests)
{
if (Match(node, test))
{
return(false);
}
}
return(true);
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.Result != null && node.Result.IsFailure)
{
node.Checked = true;
node.EnsureVisible();
}
else
{
node.Checked = false;
}
}
public TestPropertiesDialog( TestSuiteTreeNode node )
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
this.node = node;
}
public TestPropertiesDialog(TestSuiteTreeNode node)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
this.node = node;
}
private void ProcessTreeNodes(TestSuiteTreeNode node)
{
if (IsInteresting(node))
{
this.Nodes.Add(new VisualTreeNode(node));
}
foreach (TestSuiteTreeNode childNode in node.Nodes)
{
ProcessTreeNodes(childNode);
}
}
private void TestSuiteTreeView_DoubleClick(object sender, System.EventArgs e)
{
TestSuiteTreeNode node = SelectedNode as TestSuiteTreeNode;
if (runCommandSupported && runCommandEnabled && node.Nodes.Count == 0 && node.Included)
{
runCommandEnabled = false;
// TODO: Since this is a terminal node, don't use a category filter
RunTests(new ITest[] { SelectedTest }, true);
}
}
/// <summary>
/// Helper expands all fixtures under a node
/// </summary>
/// <param name="node">Node under which to expand fixtures</param>
private void ExpandFixturesUnderNode(TestSuiteTreeNode node)
{
if (node.Test.IsFixture)
{
node.Expand();
}
else
{
foreach (TestSuiteTreeNode child in node.Nodes)
{
ExpandFixturesUnderNode(child);
}
}
}
protected override void OnAfterSelect(System.Windows.Forms.TreeViewEventArgs e)
{
explicitlySelectedNode = null;
if (!suppressEvents)
{
if (SelectedTestChanged != null)
{
SelectedTestChanged(SelectedTest);
}
base.OnAfterSelect(e);
}
}
/// <summary>
/// Helper collapses all fixtures under a node
/// </summary>
/// <param name="node">Node under which to collapse fixtures</param>
private void CollapseFixturesUnderNode(TestSuiteTreeNode node)
{
if (node.Test.IsFixture)
{
node.Collapse();
}
else
{
foreach (TestSuiteTreeNode child in node.Nodes)
{
CollapseFixturesUnderNode(child);
}
}
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.HasResult &&
(node.Result.ResultState == ResultState.Failure ||
node.Result.ResultState == ResultState.Error))
{
node.Checked = true;
node.EnsureVisible();
}
else
{
node.Checked = false;
}
}
private void failedAssumptionsMenuItem_Click(object sender, System.EventArgs e)
{
TestSuiteTreeNode targetNode = explicitlySelectedNode != null ? explicitlySelectedNode : (TestSuiteTreeNode)SelectedNode;
TestSuiteTreeNode theoryNode = targetNode != null?targetNode.GetTheoryNode() : null;
if (theoryNode != null)
{
MenuItem item = (MenuItem)sender;
BeginUpdate();
item.Checked = !item.Checked;
theoryNode.ShowFailedAssumptions = item.Checked;
EndUpdate();
}
}
public void Restore(TestSuiteTreeView treeView)
{
treeView.CheckBoxes = this.ShowCheckBoxes;
foreach (VisualTreeNode visualNode in this.Nodes)
{
TestSuiteTreeNode treeNode = treeView[visualNode.UniqueName];
if (treeNode != null)
{
if (treeNode.IsExpanded != visualNode.Expanded)
{
treeNode.Toggle();
}
treeNode.Checked = visualNode.Checked;
}
}
if (this.SelectedNode != null)
{
TestSuiteTreeNode treeNode = treeView[this.SelectedNode];
if (treeNode != null)
{
treeView.SelectedNode = treeNode;
}
}
if (this.TopNode != null)
{
TestSuiteTreeNode treeNode = treeView[this.TopNode];
if (treeNode != null)
{
treeView.TopNode = treeNode;
}
}
if (this.SelectedCategories != null)
{
TestFilter filter = new CategoryFilter(this.SelectedCategories.Split(new char[] { ',' }));
if (this.ExcludeCategories)
{
filter = new NotFilter(filter);
}
treeView.CategoryFilter = filter;
}
treeView.Select();
}
public VisualTreeNode(TestSuiteTreeNode treeNode)
{
this.UniqueName = treeNode.Test.TestName.UniqueName;
this.Expanded = treeNode.IsExpanded;
this.Checked = treeNode.Checked;
int count = treeNode.Nodes.Count;
if (count > 0)
{
this.Nodes = new VisualTreeNode[count];
for (int i = 0; i < count; i++)
{
this.Nodes[i] = new VisualTreeNode((TestSuiteTreeNode)treeNode.Nodes[i]);
}
}
}
private void AddToMap(TestSuiteTreeNode node)
{
string key = node.Test.TestName.UniqueName;
if (treeMap.ContainsKey(key))
{
Trace.WriteLine("Duplicate entry: " + key);
}
// UserMessage.Display( string.Format(
// "The test {0} is duplicated\r\rResults will not be displayed correctly in the tree.", node.Test.FullName ), "Duplicate Test" );
else
{
//Trace.WriteLine( "Added to map: " + node.Test.UniqueName );
treeMap.Add(key, node);
}
}
/// <summary>
/// Gets the Theory node associated with the current
/// node. If the current node is a Theory, then the
/// current node is returned. Otherwise, if the current
/// node is a test case under a theory node, then that
/// node is returned. Otherwise, null is returned.
/// </summary>
/// <returns></returns>
public TestSuiteTreeNode GetTheoryNode()
{
if (this.Test.TestType == "Theory")
{
return(this);
}
TestSuiteTreeNode parent = this.Parent as TestSuiteTreeNode;
if (parent != null && parent.Test.TestType == "Theory")
{
return(parent);
}
return(null);
}
/// <summary>
/// Add the result of a test to the tree
/// </summary>
/// <param name="result">The result of the test</param>
public void SetTestResult(TestResult result)
{
TestSuiteTreeNode node = this[result];
if (node == null)
{
throw new ArgumentException("Test not found in tree");
}
node.SetResult(result);
if (DisplayTestProgress)
{
Invalidate(node.Bounds);
Update();
}
}
private void ShowPropertiesDialog(TestSuiteTreeNode node)
{
if (propertiesDialog == null)
{
Form owner = this.FindForm();
propertiesDialog = new TestPropertiesDialog(node);
propertiesDialog.Owner = owner;
propertiesDialog.StartPosition = FormStartPosition.Manual;
propertiesDialog.Left = owner.Left + (owner.Width - propertiesDialog.Width) / 2;
propertiesDialog.Top = owner.Top + (owner.Height - propertiesDialog.Height) / 2;
propertiesDialog.Show();
propertiesDialog.Closed += new EventHandler(OnPropertiesDialogClosed);
}
else
{
propertiesDialog.DisplayProperties(node);
}
}
/// <summary>
/// Add nodes to the tree constructed from a test
/// </summary>
/// <param name="nodes">The TreeNodeCollection to which the new node should be added</param>
/// <param name="rootTest">The test for which a node is to be built</param>
/// <param name="highlight">If true, highlight the text for this node in the tree</param>
/// <returns>A newly constructed TestNode, possibly with descendant nodes</returns>
private TestSuiteTreeNode AddTreeNodes(IList nodes, ITest rootTest, bool highlight)
{
TestSuiteTreeNode node = new TestSuiteTreeNode(rootTest);
// if ( highlight ) node.ForeColor = Color.Blue;
treeMap.Add(node.Test.UniqueName, node);
nodes.Add(node);
if (rootTest.IsSuite)
{
foreach (UITestNode test in rootTest.Tests)
{
AddTreeNodes(node.Nodes, test, highlight);
}
}
return(node);
}
/// <summary>
/// A node has been matched with a test, so update it
/// and then process child nodes and tests recursively.
/// If a child was added or removed, then this node
/// will expand itself.
/// </summary>
/// <param name="node">Node to be updated</param>
/// <param name="test">Test to plug into node</param>
/// <returns>True if a child node was added or deleted</returns>
private bool UpdateNode(TestSuiteTreeNode node, UITestNode test)
{
node.UpdateTest(test);
if (!test.IsSuite)
{
return(false);
}
bool showChildren = UpdateNodes(node.Nodes, test.Tests);
if (showChildren)
{
node.Expand();
}
return(showChildren);
}
/// <summary>
/// Load the tree with a test hierarchy
/// </summary>
/// <param name="test">Test to be loaded</param>
public void Load(TestNode test)
{
using (new CP.Windows.Forms.WaitCursor())
{
Clear();
BeginUpdate();
try
{
AddTreeNodes(Nodes, test, false);
SetInitialExpansion();
}
finally
{
EndUpdate();
contextNode = null;
}
}
}
/// <summary>
/// Add nodes to the tree constructed from a test
/// </summary>
/// <param name="nodes">The TreeNodeCollection to which the new node should be added</param>
/// <param name="rootTest">The test for which a node is to be built</param>
/// <param name="highlight">If true, highlight the text for this node in the tree</param>
/// <returns>A newly constructed TestNode, possibly with descendant nodes</returns>
private TestSuiteTreeNode AddTreeNodes(IList nodes, TestNode rootTest, bool highlight)
{
TestSuiteTreeNode node = new TestSuiteTreeNode(rootTest);
// if ( highlight ) node.ForeColor = Color.Blue;
AddToMap(node);
nodes.Add(node);
if (rootTest.IsSuite)
{
foreach (TestNode test in rootTest.Tests)
{
AddTreeNodes(node.Nodes, test, highlight);
}
}
return(node);
}
private bool IsInteresting(TestSuiteTreeNode node)
{
return node.IsExpanded || node.Checked;
}
/// <summary>
/// Helper routine that compares a node with a test
/// </summary>
/// <param name="node">Node to compare</param>
/// <param name="test">Test to compare</param>
/// <returns>True if the test has the same name</returns>
private bool Match( TestSuiteTreeNode node, TestNode test )
{
return node.Test.TestName.FullName == test.TestName.FullName;
}
private void OnTestUnloaded( object sender, TestEventArgs e)
{
ClosePropertiesDialog();
if ( Services.UserSettings.GetSetting( "Gui.TestTree.SaveVisualState", true ) && loader != null)
try
{
new VisualState(this).Save(VisualState.GetVisualStateFileName(loader.TestFileName));
}
catch(Exception ex)
{
Debug.WriteLine( "Unable to save visual state." );
Debug.WriteLine( ex );
}
Clear();
contextNode = null;
runCommandEnabled = false;
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.Result != null &&
(node.Result.ResultState == ResultState.Failure ||
node.Result.ResultState == ResultState.Error) )
{
tests.Add(node.Test);
filter.Add(node.Test.TestName);
}
}
public TestPropertiesDialog(TestSuiteTreeNode node)
{
InitializeComponent();
this.node = node;
}
/// <summary>
/// Match a set of nodes against a set of tests.
/// Remove nodes that are no longer represented
/// in the tests. Update any nodes that match.
/// Add new nodes for new tests.
/// </summary>
/// <param name="nodes">List of nodes to be matched</param>
/// <param name="tests">List of tests to be matched</param>
/// <param name="deletedNodes">List of nodes previously removed,
/// in case they show up lower in the tree.</param>
/// <returns>True if the parent should expand to show that something was added or deleted</returns>
private bool UpdateNodes( IList nodes, IList tests, IList deletedNodes )
{
// As of NUnit 2.3.6006, the newly reloaded tests
// are guaranteed to be in the same order as the
// originally loaded tests. Hence, we can merge
// the two lists. However, we can only use an
// equality comparison, since we don't know what
// determines the order. Hence the two passes.
bool showChanges = false;
// Pass1: delete nodes that are not in the list of tests.
// Some of these nodes may reappear lower in the tree,
// if we are switching from fixture display to tree display,
// so we save them for checking later.
int nodeIndex = nodes.Count;
while( --nodeIndex >= 0 )
{
TestSuiteTreeNode node = (TestSuiteTreeNode)nodes[nodeIndex];
if ( NodeWasDeleted( node, tests ) )
{
log.Debug( "Deleting " + node.Test.TestName.Name );
deletedNodes.Add(node);
RemoveNode( node );
showChanges = true;
}
}
// Pass2: All nodes in the node list are also
// in the tests, so we can merge in changes
// and add any new nodes.
nodeIndex = 0;
foreach( TestNode test in tests )
{
TestSuiteTreeNode node = nodeIndex < nodes.Count ? (TestSuiteTreeNode)nodes[nodeIndex] : null;
if ( node != null && node.Test.TestName.FullName == test.TestName.FullName )
UpdateNode( node, test, deletedNodes );
else
{
// Create a new node or use a deleted node
TestSuiteTreeNode newNode = null;
// Check previously deleted nodes
foreach( TestSuiteTreeNode deletedNode in deletedNodes )
if (deletedNode.Test.TestName.FullName == test.TestName.FullName)
{
newNode = deletedNode;
deletedNodes.Remove(deletedNode);
break;
}
// If not found, it's completely new
if (newNode == null)
newNode = new TestSuiteTreeNode(test);
AddToMap( newNode );
nodes.Insert( nodeIndex, newNode );
if ( test.IsSuite )
{
if ( UpdateNodes(newNode.Nodes, test.Tests, deletedNodes) )
newNode.Expand();
//foreach( TestNode childTest in test.Tests )
// AddTreeNodes(newNode.Nodes, childTest, false);
}
showChanges = true;
}
nodeIndex++;
}
return showChanges;
}
/// <summary>
/// Helper returns true if the node test is not in
/// the list of tests provided.
/// </summary>
/// <param name="node">Node to examine</param>
/// <param name="tests">List of tests to match with node</param>
private bool NodeWasDeleted( TestSuiteTreeNode node, IList tests )
{
foreach ( TestNode test in tests )
if( Match( node, test ) )
return false;
return true;
}
/// <summary>
/// Helper collapses all fixtures under a node
/// </summary>
/// <param name="node">Node under which to collapse fixtures</param>
private void HideTestsUnderNode( TestSuiteTreeNode node )
{
bool expand = false;
foreach( TestSuiteTreeNode child in node.Nodes )
if ( child.Test.IsSuite )
{
expand = true;
HideTestsUnderNode( child );
}
if ( expand )
node.Expand();
else
node.Collapse();
}
private TestSuiteTreeNode AddTreeNodes( IList nodes, TestResult rootResult, bool highlight )
{
TestSuiteTreeNode node = new TestSuiteTreeNode( rootResult );
AddToMap( node );
nodes.Add( node );
if ( rootResult.HasResults )
{
foreach( TestResult result in rootResult.Results )
AddTreeNodes( node.Nodes, result, highlight );
}
node.UpdateImageIndex();
return node;
}
/// <summary>
/// Add nodes to the tree constructed from a test
/// </summary>
/// <param name="nodes">The TreeNodeCollection to which the new node should be added</param>
/// <param name="rootTest">The test for which a node is to be built</param>
/// <param name="highlight">If true, highlight the text for this node in the tree</param>
/// <returns>A newly constructed TestNode, possibly with descendant nodes</returns>
private TestSuiteTreeNode AddTreeNodes( IList nodes, TestNode rootTest, bool highlight )
{
TestSuiteTreeNode node = new TestSuiteTreeNode( rootTest );
// if ( highlight ) node.ForeColor = Color.Blue;
AddToMap( node );
nodes.Add( node );
if ( rootTest.IsSuite )
{
foreach( TestNode test in rootTest.Tests )
AddTreeNodes( node.Nodes, test, highlight );
}
return node;
}
private void AddToMap( TestSuiteTreeNode node )
{
string key = node.Test.TestName.UniqueName;
if ( treeMap.ContainsKey( key ) )
log.Error( "Duplicate entry: " + key );
// UserMessage.Display( string.Format(
// "The test {0} is duplicated\r\rResults will not be displayed correctly in the tree.", node.Test.FullName ), "Duplicate Test" );
else
{
log.Debug( "Added to map: " + node.Test.TestName.UniqueName );
treeMap.Add( key, node );
}
}
/// <summary>
/// Handles right mouse button down by
/// remembering the proper context item
/// and implements multiple select with the left button.
/// </summary>
/// <param name="e">MouseEventArgs structure with information about the mouse position and button state</param>
protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
{
if (e.Button == MouseButtons.Right )
{
CheckPropertiesDialog();
TreeNode theNode = GetNodeAt( e.X, e.Y );
contextNode = theNode as TestSuiteTreeNode;
}
// else if (e.Button == MouseButtons.Left )
// {
// if ( Control.ModifierKeys == Keys.Control )
// {
// TestSuiteTreeNode theNode = GetNodeAt( e.X, e.Y ) as TestSuiteTreeNode;
// if ( theNode != null )
// theNode.IsSelected = true;
// }
// else
// {
// ClearSelected();
// }
// }
base.OnMouseDown( e );
}
public override void Visit( TestSuiteTreeNode node )
{
node.Included = filter.Pass( node.Test );
}
/// <summary>
/// Load the tree with a test hierarchy
/// </summary>
/// <param name="test">Test to be loaded</param>
public void Load( TestNode test )
{
using( new CP.Windows.Forms.WaitCursor() )
{
Clear();
BeginUpdate();
try
{
AddTreeNodes( Nodes, test, false );
SetInitialExpansion();
}
finally
{
EndUpdate();
contextNode = null;
this.Select();
}
if ( Services.UserSettings.GetSetting( "Gui.TestTree.SaveVisualState", true ) && loader != null)
RestoreVisualState();
}
}
private void ProcessTreeNodes(TestSuiteTreeNode node)
{
if (IsInteresting(node))
this.Nodes.Add(new VisualTreeNode(node));
foreach (TestSuiteTreeNode childNode in node.Nodes)
ProcessTreeNodes(childNode);
}
public VisualTreeNode( TestSuiteTreeNode treeNode )
{
this.UniqueName = treeNode.Test.TestName.UniqueName;
this.Expanded = treeNode.IsExpanded;
this.Checked = treeNode.Checked;
}
/// <summary>
/// A node has been matched with a test, so update it
/// and then process child nodes and tests recursively.
/// If a child was added or removed, then this node
/// will expand itself.
/// </summary>
/// <param name="node">Node to be updated</param>
/// <param name="test">Test to plug into node</param>
/// <returns>True if a child node was added or deleted</returns>
private bool UpdateNode( TestSuiteTreeNode node, TestNode test, IList deletedNodes )
{
if ( node.Test.TestName.FullName != test.TestName.FullName )
throw( new TreeStructureChangedException(
string.Format( "Attempting to update {0} with {1}", node.Test.TestName.FullName, test.TestName.FullName ) ) );
treeMap.Remove( node.Test.TestName.UniqueName );
node.Test = test;
treeMap.Add( test.TestName.UniqueName, node );
if ( !test.IsSuite )
return false;
bool showChildren = UpdateNodes( node.Nodes, test.Tests, deletedNodes );
if ( showChildren ) node.Expand();
return showChildren;
}
private void ShowPropertiesDialog( TestSuiteTreeNode node )
{
if ( propertiesDialog == null )
{
Form owner = this.FindForm();
propertiesDialog = new TestPropertiesDialog( node );
propertiesDialog.Owner = owner;
propertiesDialog.StartPosition = FormStartPosition.Manual;
propertiesDialog.Left = Math.Max(0, owner.Left + ( owner.Width - propertiesDialog.Width ) / 2);
propertiesDialog.Top = Math.Max(0, owner.Top + ( owner.Height - propertiesDialog.Height ) / 2);
propertiesDialog.Show();
propertiesDialog.Closed += new EventHandler( OnPropertiesDialogClosed );
}
else
{
propertiesDialog.DisplayProperties( node );
}
}
/// <summary>
/// Remove a node from the tree itself and the hashtable
/// </summary>
/// <param name="node">Node to remove</param>
private void RemoveNode( TestSuiteTreeNode node )
{
if ( contextNode == node )
contextNode = null;
RemoveFromMap( node );
node.Remove();
}
public void DisplayProperties(TestSuiteTreeNode node)
{
this.node = node;
this.test = node.Test;
this.result = node.Result;
SetTitleBarText();
testResult.Text = node.StatusText;
testResult.Font = new Font(this.Font, FontStyle.Bold);
if (node.TestType == "Project" || node.TestType == "Assembly")
testName.Text = Path.GetFileName(test.TestName.Name);
else
testName.Text = test.TestName.Name;
testType.Text = node.TestType;
fullName.Text = test.TestName.FullName;
description.Text = test.Description;
StringBuilder sb1 = new StringBuilder();
foreach (string cat in test.Categories)
if (sb1.Length > 0)
{
sb1.Append(", ");
sb1.Append(cat);
}
categories.Text = sb1.ToString();
testCaseCount.Text = test.TestCount.ToString();
switch (test.RunState)
{
case RunState.Explicit:
shouldRun.Text = "Explicit";
break;
case RunState.Runnable:
shouldRun.Text = "Yes";
break;
default:
shouldRun.Text = "No";
break;
}
ignoreReason.Text = test.IgnoreReason;
FillPropertyList();
elapsedTime.Text = "Execution Time:";
assertCount.Text = "Assert Count:";
message.Text = "";
stackTrace.Text = "";
if (result != null)
{
elapsedTime.Text = string.Format("Execution Time: {0}", result.Time);
assertCount.Text = string.Format("Assert Count: {0}", result.AssertCount);
// message may have a leading blank line
// TODO: take care of this in label?
if (result.Message != null)
{
if (result.Message.Length > 64000)
message.Text = TrimLeadingBlankLines(result.Message.Substring(0, 64000));
else
message.Text = TrimLeadingBlankLines(result.Message);
}
stackTrace.Text = result.StackTrace;
}
BeginPanel();
CreateRow(testTypeLabel, testType);
CreateRow(fullNameLabel, fullName);
CreateRow(descriptionLabel, description);
CreateRow(categoriesLabel, categories);
CreateRow(testCaseCountLabel, testCaseCount, shouldRunLabel, shouldRun);
CreateRow(ignoreReasonLabel, ignoreReason);
CreateRow(propertiesLabel, properties);
CreateRow(hiddenProperties);
groupBox1.ClientSize = new Size(
groupBox1.ClientSize.Width, maxY + 12);
groupBox2.Location = new Point(
groupBox1.Location.X, groupBox1.Bottom + 12);
BeginPanel();
CreateRow(elapsedTime, assertCount);
CreateRow(messageLabel, message);
CreateRow(stackTraceLabel, stackTrace);
groupBox2.ClientSize = new Size(
groupBox2.ClientSize.Width, this.maxY + 12);
this.ClientSize = new Size(
this.ClientSize.Width, groupBox2.Bottom + 12);
}
private void RemoveFromMap( TestSuiteTreeNode node )
{
foreach( TestSuiteTreeNode child in node.Nodes )
RemoveFromMap( child );
treeMap.Remove( node.Test.TestName.UniqueName );
}
/// <summary>
/// Match a set of nodes against a set of tests.
/// Remove nodes that are no longer represented
/// in the tests. Update any nodes that match.
/// Add new nodes for new tests.
/// </summary>
/// <param name="nodes">List of nodes to be matched</param>
/// <param name="tests">List of tests to be matched</param>
/// <param name="deletedNodes">List of nodes previously removed,
/// in case they show up lower in the tree.</param>
/// <returns>True if the parent should expand to show that something was added or deleted</returns>
private bool UpdateNodes( IList nodes, IList tests, IList deletedNodes )
{
// For NUnit 2.4 and the original release of 2.5, the newly
// reloaded tests were guaranteed to be in the same order as
// the originally loaded tests, so we simply merged the two
// lists. Beginning with NUnit 2.5.1, this is no longer
// guaranteed - parameterized tests may be re-ordered within
// their containing suite. Therefore, we no longer rely on
// ordering of tests within a suite.
bool showChanges = false;
// We use two passes to keep the code as simple as possible
//
// Pass1: delete nodes that are not in the list of tests.
// Some of these nodes may reappear lower in the tree,
// if we are switching from fixture display to tree display,
// so we save them for checking later.
int nodeIndex = nodes.Count;
while( --nodeIndex >= 0 )
{
TestSuiteTreeNode node = (TestSuiteTreeNode)nodes[nodeIndex];
if ( !IsTestInList( node.Test, tests ) )
{
log.Debug( "Deleting " + node.Test.TestName.Name );
deletedNodes.Add(node);
RemoveNode( node );
showChanges = true;
}
}
// Pass2: All nodes in the node list are also
// in the tests, so we can merge in changes
// and add any new nodes.
nodeIndex = 0;
foreach( TestNode test in tests )
{
TestSuiteTreeNode node = nodeIndex < nodes.Count ? (TestSuiteTreeNode)nodes[nodeIndex] : null;
if ( node != null && node.Test.TestName.FullName == test.TestName.FullName )
UpdateNode( node, test, deletedNodes );
else
{
TestSuiteTreeNode newNode = null;
for (int i = nodeIndex + 1; i < nodes.Count; i++)
{
TestSuiteTreeNode tryNode = (TestSuiteTreeNode)nodes[i];
if (tryNode.Test.TestName.FullName == test.TestName.FullName)
{
// Exchange the two nodes
nodes.Remove(tryNode);
if (node != null) nodes.Remove(node);
nodes.Insert(nodeIndex, tryNode);
if ( node != null )nodes.Insert(i, node);
UpdateNode(tryNode, test, deletedNodes);
newNode = tryNode;
break;
}
}
// Create a new node or use a deleted node
if (newNode == null)
{
// Check previously deleted nodes
foreach (TestSuiteTreeNode deletedNode in deletedNodes)
if (deletedNode.Test.TestName.FullName == test.TestName.FullName)
{
newNode = deletedNode;
deletedNodes.Remove(deletedNode);
break;
}
// If not found, it's completely new
if (newNode == null)
newNode = new TestSuiteTreeNode(test);
AddToMap(newNode);
nodes.Insert(nodeIndex, newNode);
if (test.IsSuite)
{
if (UpdateNodes(newNode.Nodes, test.Tests, deletedNodes))
newNode.Expand();
//foreach( TestNode childTest in test.Tests )
// AddTreeNodes(newNode.Nodes, childTest, false);
}
showChanges = true;
}
}
nodeIndex++;
}
return showChanges;
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.HasResult &&
(node.Result.ResultState == ResultState.Failure ||
node.Result.ResultState == ResultState.Error) )
{
tests.Add(node.Test);
}
}
private void FindCheckedNodes( TestSuiteTreeNode node, bool topLevel )
{
if ( node.Checked )
{
checkedTests.Add( new CheckedTestInfo( node.Test, topLevel ) );
topLevel = false;
}
FindCheckedNodes( node.Nodes, topLevel );
}
public override void Visit(TestSuiteTreeNode node)
{
if (!node.Test.IsSuite && node.Result != null &&
(node.Result.ResultState == ResultState.Failure ||
node.Result.ResultState == ResultState.Error) )
{
node.Checked = true;
node.EnsureVisible();
}
else
node.Checked = false;
}
public void DisplayProperties( TestSuiteTreeNode node)
{
this.node = node;
this.test = node.Test;
this.result = node.Result;
SetTitleBarText();
categories.Items.Clear();
foreach( string cat in test.Categories )
categories.Items.Add( cat );
testResult.Text = node.StatusText;
testName.Text = test.TestName.Name;
testType.Text = node.TestType;
fullName.Text = test.TestName.FullName;
switch( test.RunState )
{
case RunState.Explicit:
shouldRun.Text = "Explicit";
break;
case RunState.Runnable:
shouldRun.Text = "Yes";
break;
default:
shouldRun.Text = "No";
break;
}
description.Text = test.Description;
ignoreReason.Text = test.IgnoreReason;
testCaseCount.Text = test.TestCount.ToString();
properties.Items.Clear();
foreach( DictionaryEntry entry in test.Properties )
properties.Items.Add( entry.Key + "=" + entry.Value.ToString() );
message.Text = "";
elapsedTime.Text = "Execution Time:";
assertCount.Text = "Assert Count:";
stackTrace.Text = "";
if ( result != null )
{
// message may have a leading blank line
// TODO: take care of this in label?
if (result.Message != null)
{
if (result.Message.Length > 64000)
message.Text = TrimLeadingBlankLines(result.Message.Substring(0, 64000));
else
message.Text = TrimLeadingBlankLines(result.Message);
}
elapsedTime.Text = string.Format( "Execution Time: {0}", result.Time );
assertCount.Text = string.Format( "Assert Count: {0}", result.AssertCount );
stackTrace.Text = result.StackTrace;
}
}
public override void Visit(TestSuiteTreeNode node)
{
node.Checked = false;
}
public abstract void Visit(TestSuiteTreeNode node);
/// <summary>
/// Helper collapses all fixtures under a node
/// </summary>
/// <param name="node">Node under which to collapse fixtures</param>
private void HideTestsUnderNode( TestSuiteTreeNode node )
{
if (node.Test.IsSuite)
{
if (node.Test.TestType == "TestFixture")
node.Collapse();
else
{
node.Expand();
foreach (TestSuiteTreeNode child in node.Nodes)
HideTestsUnderNode(child);
}
}
}
