//--------------------------------------
// INITIALIZE
//--------------------------------------
//--------------------------------------
// PUBLIC METHODS
//--------------------------------------
public static List<TNode> ParseFile(string FileName, string FilePath)
{
List<TNode> nodes = new List<TNode>();
string[] lines;
if(FilePath.Equals(string.Empty)) {
lines = new string[0];
} else {
lines = System.IO.File.ReadAllLines(FilePath);
}
int index = 0;
foreach(string line in lines) {
index++;
int ind;
string comment = string.Empty;
if(line.Contains("//")) {
ind = line.IndexOf("//") + 2;
comment = line.Substring(ind, line.Length - ind);
} else {
//continue;
if(line.Contains("/*")) {
ind = line.IndexOf("/*") + 2;
comment = line.Substring(ind, line.Length - ind);
if(comment.Contains("*/")) {
ind = comment.IndexOf("*/");
comment = comment.Substring(0, ind);
}
} else {
continue;
}
}
comment = comment.Trim();
foreach(TagTemplate tag in TCore.view.tags) {
if(tag.isAllTag) {
continue;
}
if(comment.Length >= tag.patern.Length) {
if(comment.Substring(0, tag.patern.Length).ToLower().Equals(tag.patern.ToLower())) {
TNode tpl = new TNode();
tpl.fileName = FileName;
tpl.filePath = FilePath;
tpl.tag = tag.name;
tpl.text = comment.Substring(tag.patern.Length, comment.Length - tag.patern.Length);
tpl.line = index;
nodes.Add(tpl);
break;
}
}
}
}
return nodes;
}
/// <summary>
/// Adds an XML node
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="recursive">True if recursive</param>
/// <returns>The added XML node</returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode result = parentNode.AddElement(ElementName, ExpectedValue);
if (IsRegex)
result.AddAttribute("re", "1");
return result;
}
/// <summary>
/// Convert the TestOutput object to an XML string
/// </summary>
public string ToXml()
{
TNode tnode = new TNode("test-output", Text, true);
tnode.AddAttribute("stream", Stream);
if (TestName != null)
tnode.AddAttribute("testname", TestName);
return tnode.OuterXml;
}
/// <summary>
/// Adds an XML node
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="recursive">True if recursive</param>
/// <returns>The added XML node</returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode result = parentNode.AddElement(ElementName);
if (recursive)
foreach (ITestFilter filter in Filters)
filter.AddToXml(result, true);
return result;
}
public void Insert()
{
var tree = new BinarySearchTree<MockComparable>();
var mock = new MockComparable(3);
var node = new TNode<MockComparable>(mock);
tree.Insert(node);
Assert.IsNull(node.Parent, "#A01");
var mock2 = new MockComparable(7);
var node2 = new TNode<MockComparable>(mock2);
tree.Insert(node2);
Assert.AreEqual(node2, node.RightChild, "#A02");
Assert.AreEqual(node, node2.Parent, "#A02bis");
}
public void Delete()
{
var tree = new BinarySearchTree<int>();
var firstNode = new TNode<int>(17);
tree.Insert(firstNode);
var secondNode = new TNode<int>(7);
tree.Insert(secondNode);
var thirdNode = new TNode<int>(4);
tree.Insert(thirdNode);
var fourthNode = new TNode<int>(15);
tree.Insert(fourthNode);
tree.Insert(new TNode<int>(10));
tree.Insert(new TNode<int>(16));
tree.Insert(new TNode<int>(8));
tree.Insert(new TNode<int>(12));
tree.Delete(secondNode);
var result = tree.CollectInOrder().ToArray();
var expected = new int[] {4,8,10,12,15,16,17};
for(int i=0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], result[i], "#E"+i);
}
tree.Delete(thirdNode);
result = tree.CollectInOrder().ToArray();
expected = new int[] {8, 10, 12, 15, 16, 17 };
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], result[i], "#EE" + i);
}
tree.Delete(firstNode);
result = tree.CollectInOrder().ToArray();
expected = new int[] { 8, 10, 12, 15, 16};
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], result[i], "#EEE" + i);
}
}
private TNode MakeTestRunElement(ITestResult result)
{
TNode testRun = new TNode("test-run");
testRun.AddAttribute("id", "2");
testRun.AddAttribute("name", result.Name);
testRun.AddAttribute("fullname", result.FullName);
testRun.AddAttribute("testcasecount", result.Test.TestCaseCount.ToString());
testRun.AddAttribute("result", result.ResultState.Status.ToString());
if (result.ResultState.Label != string.Empty)
testRun.AddAttribute("label", result.ResultState.Label);
testRun.AddAttribute("start-time", result.StartTime.ToString("u"));
testRun.AddAttribute("end-time", result.EndTime.ToString("u"));
testRun.AddAttribute("duration", result.Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
testRun.AddAttribute("total", (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRun.AddAttribute("passed", result.PassCount.ToString());
testRun.AddAttribute("failed", result.FailCount.ToString());
testRun.AddAttribute("inconclusive", result.InconclusiveCount.ToString());
testRun.AddAttribute("skipped", result.SkipCount.ToString());
testRun.AddAttribute("asserts", result.AssertCount.ToString());
testRun.AddAttribute("random-seed", Randomizer.InitialSeed.ToString());
// NOTE: The console runner adds attributes for engine-version and clr-version
// Neither of these is needed under nunitlite since there is no engine involved
// and we are running under the same runtime as the tests.
return testRun;
}
private static string GetSkipReason(TNode result)
{
var propNode = result.SelectSingleNode(string.Format("properties/property[@name='{0}']", PropertyNames.SkipReason));
return propNode == null ? null : propNode.Attributes["value"];
}
public void GoTo(TNode node)
{
VisitedNodes.Add(node);
_state.PheromoneNodes[node] += _state.Q / VisitedNodes.Count;
}
private static TNode MakeTestFilterElement(TestFilter filter)
{
TNode result = new TNode("filter");
if (!filter.IsEmpty)
filter.AddToXml(result, true);
return result;
}
public override TNode AddToXml(TNode parentNode, bool recursive)
{
throw new NotImplementedException();
}
private TNode AddOutputElement(TNode targetNode)
{
return targetNode.AddElementWithCDATA("output", Output);
}
private static TestFilter FromXml(TNode node)
{
switch (node.Name)
{
case "filter":
case "and":
var andFilter = new AndFilter();
foreach (var childNode in node.ChildNodes)
andFilter.Add(FromXml(childNode));
return andFilter;
case "or":
var orFilter = new OrFilter();
foreach (var childNode in node.ChildNodes)
orFilter.Add(FromXml(childNode));
return orFilter;
case "not":
return new NotFilter(FromXml(node.FirstChild));
case "id":
var idFilter = new IdFilter();
if (node.Value != null)
foreach (string id in node.Value.Split(COMMA))
idFilter.Add(id);
return idFilter;
case "tests":
var testFilter = new SimpleNameFilter();
foreach (var childNode in node.SelectNodes("test"))
testFilter.Add(childNode.Value);
return testFilter;
case "cat":
var catFilter = new CategoryFilter();
if (node.Value != null)
foreach (string cat in node.Value.Split(COMMA))
catFilter.AddCategory(cat);
return catFilter;
default:
throw new ArgumentException("Invalid filter element: " + node.Name, "xmlNode");
}
}
/// <summary>
/// Inserts settings element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <param name="settings">Settings dictionary</param>
/// <returns>The new node</returns>
public static TNode InsertSettingsElement(TNode targetNode, IDictionary<string, object> settings)
{
TNode settingsNode = new TNode("settings");
targetNode.ChildNodes.Insert(0, settingsNode);
foreach (string key in settings.Keys)
AddSetting(settingsNode, key, settings[key]);
#if PARALLEL
// Add default values for display
if (!settings.ContainsKey(PackageSettings.NumberOfTestWorkers))
AddSetting(settingsNode, PackageSettings.NumberOfTestWorkers, NUnitTestAssemblyRunner.DefaultLevelOfParallelism);
#endif
return settingsNode;
}
/// <summary>
/// Add standard attributes and members to a test node.
/// </summary>
/// <param name="thisNode"></param>
/// <param name="recursive"></param>
protected void PopulateTestNode(TNode thisNode, bool recursive)
{
thisNode.AddAttribute("id", this.Id.ToString());
thisNode.AddAttribute("name", this.Name);
thisNode.AddAttribute("fullname", this.FullName);
if (this.MethodName != null)
thisNode.AddAttribute("methodname", this.MethodName);
if (this.ClassName != null)
thisNode.AddAttribute("classname", this.ClassName);
thisNode.AddAttribute("runstate", this.RunState.ToString());
if (Properties.Keys.Count > 0)
Properties.AddToXml(thisNode, recursive);
}
public TNode AddToXml(TNode parentNode, bool recursive)
{
throw new NotImplementedException();
}
public void TestSuccessor()
{
var tree = new BinarySearchTree<int>();
var firstNode = new TNode<int> (7);
tree.Insert(firstNode);
Assert.IsNull(tree.Sucessor(firstNode), "#C01");
var secondNode = new TNode<int>( 4 );
tree.Insert(secondNode);
Assert.AreEqual(firstNode, tree.Sucessor(secondNode), "#C02");
var thirdNode = new TNode<int> (5) ;
tree.Insert(thirdNode);
Assert.AreEqual(thirdNode, tree.Sucessor(secondNode), "#C03");
Assert.IsNull(tree.Sucessor(firstNode), "#C04");
var fourthNode = new TNode<int>(9);
tree.Insert(fourthNode);
Assert.IsNull(tree.Sucessor(fourthNode), "#C05");
}
public void Search()
{
var tree = new BinarySearchTree<int>();
var firstNode = new TNode<int>(7);
tree.Insert(firstNode);
var secondNode = new TNode<int>(4);
tree.Insert(secondNode);
var thirdNode = new TNode<int>(5);
tree.Insert(thirdNode);
var fourthNode = new TNode<int>(9);
tree.Insert(fourthNode);
Assert.AreEqual(secondNode, tree.Search(4),"#D01");
Assert.AreEqual(fourthNode, tree.Search(9), "#D02");
}
/// <summary>
/// Returns an XmlNode representing the current result after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode thisNode = parentNode.AddElement("test-suite");
thisNode.AddAttribute("type", this.TestType);
PopulateTestNode(thisNode, recursive);
thisNode.AddAttribute("testcasecount", this.TestCaseCount.ToString());
if (recursive)
foreach (Test test in this.Tests)
test.AddToXml(thisNode, recursive);
return thisNode;
}
public override TNode AddToXml(TNode parentNode, bool recursive)
{
return parentNode.AddElement("filter");
}
public Node(TNode value)
{
this.value = value;
prev = new FixedIndexList <int>();
next = new FixedIndexList <int>();
}
/// <summary> /// Returns an XmlNode representing the current result after /// adding it as a child of the supplied parent node. /// </summary> /// <param name="parentNode">The parent node.</param> /// <param name="recursive">If true, descendant results are included</param> /// <returns></returns> public abstract TNode AddToXml(TNode parentNode, bool recursive);
public void MaximumMinimum()
{
var tree = new BinarySearchTree<MockComparable>();
var mock = new MockComparable(3);
var node = new TNode<MockComparable>(mock);
tree.Insert(node);
Assert.AreEqual(3, tree.Maximum().Content.Value, "#AA01");
Assert.AreEqual(3, tree.Minimum().Content.Value, "#AA01bis");
var mock2 = new MockComparable(7);
var node2 = new TNode<MockComparable>(mock2);
tree.Insert(node2);
Assert.AreEqual(7, tree.Maximum().Content.Value, "#AA02");
Assert.AreEqual(3, tree.Minimum().Content.Value, "#AA02bis");
}
/// <summary>
/// Adds an XML node
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="recursive">True if recursive</param>
/// <returns>The added XML node</returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode result = base.AddToXml(parentNode, recursive);
result.AddAttribute("name", _propertyName);
return result;
}
/// <summary>
/// Returns a TNode representing the current result after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode thisNode = parentNode.AddElement(XmlElementName);
PopulateTestNode(thisNode, recursive);
thisNode.AddAttribute("seed", this.Seed.ToString());
return thisNode;
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
env.AddAttribute("framework-version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
env.AddAttribute("clr-version", Environment.Version.ToString());
env.AddAttribute("os-version", Environment.OSVersion.ToString());
env.AddAttribute("platform", Environment.OSVersion.Platform.ToString());
#if !NETCF
env.AddAttribute("cwd", Environment.CurrentDirectory);
env.AddAttribute("machine-name", Environment.MachineName);
env.AddAttribute("user", Environment.UserName);
env.AddAttribute("user-domain", Environment.UserDomainName);
#endif
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("os-architecture", GetProcessorArchitecture());
return env;
}
/// <summary>
/// Adds a reason element to a node and returns it.
/// </summary>
/// <param name="targetNode">The target node.</param>
/// <returns>The new reason element.</returns>
private TNode AddReasonElement(TNode targetNode)
{
TNode reasonNode = targetNode.AddElement("reason");
return reasonNode.AddElementWithCDATA("message", Message);
}
private static void AddSetting(TNode settingsNode, string name, object value)
{
TNode setting = new TNode("setting");
setting.AddAttribute("name", name);
setting.AddAttribute("value", value.ToString());
settingsNode.ChildNodes.Add(setting);
}
private void LeftMouseClick()
{
float RECT_H = 46f;
if (TCore.size == TODOListSize.SMALL)
{
RECT_H = 29f;
}
TNode selectedNode = null;
Vector2 pos = Event.current.mousePosition;
pos.y += scrollPos.y;
//pos.x = position.width - pos.x;
pos.x -= TAGS_PANLE_WIDTH;
foreach (TNode node in TCore.nodes)
{
Rect r = node.rect;
r.y += RECT_H;
if (r.Contains(pos))
{
if (!node.isSelected)
{
selectedNode = node;
}
else
{
OpenClass(node.filePath, node.line);
}
}
}
foreach (TNode node in TCore.nodes)
{
node.isSelected = false;
}
if (selectedNode != null)
{
selectedNode.isSelected = true;
}
pos.x += TAGS_PANLE_WIDTH;
TagTemplate selectedTag = null;
foreach (TagTemplate tag in tags)
{
Rect r = tag.rect;
r.y += RECT_H;
if (r.Contains(pos))
{
selectedTag = tag;
}
}
if (selectedTag != null)
{
foreach (TagTemplate tag in tags)
{
tag.isSelected = false;
}
selectedTag.isSelected = true;
}
Repaint();
}
/// <summary>
/// Adds the XML representation of the result as a child of the
/// supplied parent node..
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public virtual TNode AddToXml(TNode parentNode, bool recursive)
{
// A result node looks like a test node with extra info added
TNode thisNode = Test.AddToXml(parentNode, false);
thisNode.AddAttribute("result", ResultState.Status.ToString());
if (ResultState.Label != string.Empty) // && ResultState.Label != ResultState.Status.ToString())
thisNode.AddAttribute("label", ResultState.Label);
if (ResultState.Site != FailureSite.Test)
thisNode.AddAttribute("site", ResultState.Site.ToString());
thisNode.AddAttribute("start-time", StartTime.ToString("u"));
thisNode.AddAttribute("end-time", EndTime.ToString("u"));
thisNode.AddAttribute("duration", Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
if (Test is TestSuite)
{
thisNode.AddAttribute("total", (PassCount + FailCount + SkipCount + InconclusiveCount).ToString());
thisNode.AddAttribute("passed", PassCount.ToString());
thisNode.AddAttribute("failed", FailCount.ToString());
thisNode.AddAttribute("inconclusive", InconclusiveCount.ToString());
thisNode.AddAttribute("skipped", SkipCount.ToString());
}
thisNode.AddAttribute("asserts", AssertCount.ToString());
switch (ResultState.Status)
{
case TestStatus.Failed:
AddFailureElement(thisNode);
break;
case TestStatus.Skipped:
case TestStatus.Passed:
case TestStatus.Inconclusive:
if (Message != null)
AddReasonElement(thisNode);
break;
}
if (Output.Length > 0)
AddOutputElement(thisNode);
if (recursive && HasChildren)
foreach (TestResult child in Children)
child.AddToXml(thisNode, recursive);
return thisNode;
}
public static void renderNode(TNode node, int index, Rect position) {
int FONT_SIZE = 12;
int d = 33;
int w = 40;
int m = 40;
int l = 28;
int x = 12;
if(TCore.size == TODOListSize.SMALL) {
FONT_SIZE = 11;
m = 25;
d = 20;
w = 25;
x = 5;
l = 18;
}
node.rect = new Rect (0, index * m - d - x, position.width, w);
if(index % 2 == 0 && !node.isSelected) {
GUILayout.BeginArea(node.rect, ""); {
if(!TODOUtils.isLightMode) {
GUILayout.Box("", new GUILayoutOption[]{GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)});
} else {
Color GUIColor = GUI.color;
float p = 233f;
GUI.color = new Color(p/255f, p/255f, p/255f);
GUILayout.Box("", new GUILayoutOption[]{GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)});
GUI.color = GUIColor;
}
} GUILayout.EndArea();
}
if(node.isSelected) {
Rect r = node.rect;
r.x += 1f;
r.y += 1f;
r.height -= 1f;
if(TCore.view.selectionTexture == null) {
TCore.view.createSelectionTexture();
}
GUI.DrawTexture(r, TCore.view.selectionTexture);
}
GUILayout.BeginArea(new Rect (15, index * m - d, position.width, 50), ""); {
GUIStyle s;
if(TCore.size == TODOListSize.SMALL) {
s = new GUIStyle(EditorStyles.label);
} else {
s = new GUIStyle(EditorStyles.boldLabel);
}
s.fontSize = FONT_SIZE;
GUILayout.Label(node.text, s);
} GUILayout.EndArea();
GUILayout.BeginArea(new Rect (-20, index * m - d + l - 14, position.width, 50), ""); {
GUIStyle s = new GUIStyle(EditorStyles.boldLabel);
s.fontSize = 10;
s.fontStyle = FontStyle.Italic;
s.alignment = TextAnchor.LowerRight;
GUILayout.Label(node.fileName, s);
} GUILayout.EndArea();
Drawing.DrawDashLine(new Vector2(0, index * m - d + l), 10, position.width + 10);
}
/// <summary>
/// Adds a failure element to a node and returns it.
/// </summary>
/// <param name="targetNode">The target node.</param>
/// <returns>The new failure element.</returns>
private TNode AddFailureElement(TNode targetNode)
{
TNode failureNode = targetNode.AddElement("failure");
if (Message != null)
failureNode.AddElementWithCDATA("message", Message);
if (StackTrace != null)
failureNode.AddElementWithCDATA("stack-trace", StackTrace);
return failureNode;
}
/// <summary>
/// Returns an XmlNode representing the PropertyBag after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">Not used</param>
/// <returns></returns>
public TNode AddToXml(TNode parentNode, bool recursive)
{
TNode properties = parentNode.AddElement("properties");
foreach (string key in Keys)
{
foreach (object value in this[key])
{
TNode prop = properties.AddElement("property");
// TODO: Format as string
prop.AddAttribute("name", key.ToString());
prop.AddAttribute("value", value.ToString());
}
}
return properties;
}
/// <summary>
/// Create a TestFilter from it's TNode representation
/// </summary>
public static TestFilter FromXml(TNode node)
{
bool isRegex = node.Attributes["re"] == "1";
switch (node.Name)
{
case "filter":
case "and":
var andFilter = new AndFilter();
foreach (var childNode in node.ChildNodes)
andFilter.Add(FromXml(childNode));
return andFilter;
case "or":
var orFilter = new OrFilter();
foreach (var childNode in node.ChildNodes)
orFilter.Add(FromXml(childNode));
return orFilter;
case "not":
return new NotFilter(FromXml(node.FirstChild));
case "id":
return new IdFilter(node.Value);
case "test":
return new FullNameFilter(node.Value) { IsRegex = isRegex };
case "name":
return new TestNameFilter(node.Value) { IsRegex = isRegex };
case "method":
return new MethodNameFilter(node.Value) { IsRegex = isRegex };
case "class":
return new ClassNameFilter(node.Value) { IsRegex = isRegex };
case "cat":
return new CategoryFilter(node.Value) { IsRegex = isRegex };
case "prop":
string name = node.Attributes["name"];
if (name != null)
return new PropertyFilter(name, node.Value) { IsRegex = isRegex };
break;
}
throw new ArgumentException("Invalid filter element: " + node.Name, "xmlNode");
}
/// <summary> /// Returns an XmlNode representing the current result after /// adding it as a child of the supplied parent node. /// </summary> /// <param name="parentNode">The parent node.</param> /// <param name="recursive">If true, descendant results are included</param> /// <returns></returns> public abstract TNode AddToXml(TNode parentNode, bool recursive);
