public void CanParseExcludedCategories()
{
CategoryExpression expr = new CategoryExpression( "-One,Two,Three" );
NotFilter notFilter = (NotFilter)expr.Filter;
CategoryFilter catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three" } ) );
}
public void ParseCategoryPUT([PexAssumeUnderTest] String s)
{
PexAssume.IsTrue(s.Length > 0 && !s.Contains("\n"));
PexAssume.IsTrue(Regex.IsMatch(s, "^(a[;,]b[;,])*$")); //|| Regex.IsMatch(s, "a,b"));
CategoryExpression expr = new CategoryExpression(s);
String[] seperator = { ",", ";" };
s = s.Replace("\n", "");
if (s.EndsWith(";") || s.EndsWith(","))
{
s = s.Remove(s.Length - 1);
}
String[] tokens_split = s.Split(seperator, 10, StringSplitOptions.None);
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr, 0);
for (int i = 0; i < tokens_split.Length; i++)
{
//Console.WriteLine(arr[i]);
PexAssert.AreEqual(tokens_split[i], arr[i]);
}
if (tokens_split.Length == 0)
{
PexAssert.IsTrue(expr.Filter.IsEmpty);
}
}
public void CanParseSimpleCategory()
{
CategoryExpression expr = new CategoryExpression("Data");
CategoryFilter filter = (CategoryFilter)expr.Filter;
Assert.That(filter.Categories, Is.EqualTo(new string[] { "Data" }));
}
public void CanParseCompoundCategory()
{
CategoryExpression expr = new CategoryExpression("One , Two; Three,Four");
CategoryFilter filter = (CategoryFilter)expr.Filter;
Assert.That(filter.Categories, Is.EqualTo(new string[] { "One", "Two", "Three", "Four" }));
}
public void CanParseExcludedCategories()
{
CategoryExpression expr = new CategoryExpression("-One,Two,Three");
NotFilter notFilter = (NotFilter)expr.Filter;
CategoryFilter catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.AreEqual(catFilter.Categories, new string[] { "One", "Two", "Three" });
}
public void CanParseSimpleCategory()
{
CategoryExpression expr = new CategoryExpression("Data");
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr, 0);
PexAssert.AreEqual("Data", arr[0]);
}
public void OrAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression( "A|B-C-D|E" );
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
AndFilter andFilter = (AndFilter)orFilter.Filters[1];
Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( NotFilter) ) );
Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
}
public void CanParseCompoundCategory()
{
CategoryExpression expr = new CategoryExpression("One , Two; Three,Four");
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr,0);
PexAssert.AreEqual("One", arr[0]);
PexAssert.AreEqual("Two", arr[1]);
PexAssert.AreEqual("Three", arr[2]);
PexAssert.AreEqual("Four", arr[3]);
}
public void CanParseCompoundCategory()
{
CategoryExpression expr = new CategoryExpression("One , Two; Three,Four");
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr, 0);
PexAssert.AreEqual("One", arr[0]);
PexAssert.AreEqual("Two", arr[1]);
PexAssert.AreEqual("Three", arr[2]);
PexAssert.AreEqual("Four", arr[3]);
}
public void PlusAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A+B-C-D+E");
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.That(andFilter.Filters.Length, Is.EqualTo(5));
Assert.That(andFilter.Filters[0], Is.TypeOf(typeof(CategoryFilter)));
Assert.That(andFilter.Filters[1], Is.TypeOf(typeof(CategoryFilter)));
Assert.That(andFilter.Filters[2], Is.TypeOf(typeof(NotFilter)));
Assert.That(andFilter.Filters[3], Is.TypeOf(typeof(NotFilter)));
Assert.That(andFilter.Filters[4], Is.TypeOf(typeof(CategoryFilter)));
}
public void CanParseMultipleCategoriesWithAnd()
{
CategoryExpression expr = new CategoryExpression( "One + Two+Three" );
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One" } ) );
catFilter = (CategoryFilter)andFilter.Filters[1];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two" } ) );
catFilter = (CategoryFilter)andFilter.Filters[2];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three" } ) );
}
public void CanParseMultipleAlternatives()
{
CategoryExpression expr = new CategoryExpression( "One|Two|Three" );
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.That( orFilter.Filters.Length, Is.EqualTo( 3 ) );
CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "One" } ) );
catFilter = (CategoryFilter)orFilter.Filters[1];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Two" } ) );
catFilter = (CategoryFilter)orFilter.Filters[2];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "Three" } ) );
}
public void PlusAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A+B-C-D+E");
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.AreEqual(andFilter.Filters.Length, 5);
Assert.AreEqual(andFilter.Filters[0], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[1], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[2], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[3], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[4], typeof(CategoryFilter));
}
public void OrAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A|B-C-D|E");
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.That(orFilter.Filters.Length, Is.EqualTo(3));
AndFilter andFilter = (AndFilter)orFilter.Filters[1];
Assert.That(andFilter.Filters.Length, Is.EqualTo(3));
Assert.That(andFilter.Filters[0], Is.TypeOf(typeof(CategoryFilter)));
Assert.That(andFilter.Filters[1], Is.TypeOf(typeof(NotFilter)));
Assert.That(andFilter.Filters[2], Is.TypeOf(typeof(NotFilter)));
}
public void OrAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A|B-C-D|E");
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.AreEqual(orFilter.Filters.Length, 3);
AndFilter andFilter = (AndFilter)orFilter.Filters[1];
Assert.AreEqual(andFilter.Filters.Length, 3);
Assert.AreEqual(andFilter.Filters[0], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[1], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[2], typeof(NotFilter));
}
public void CanParseMultipleCategoriesWithAndPUT([PexAssumeUnderTest] CategoryExpression expr)
{
//CategoryExpression expr = new CategoryExpression("One + Two+Three");
AndFilter andFilter = (AndFilter)expr.Filter;
String[] tokens = expr.GetToken().Split('|');
PexAssert.AreEqual(tokens.Length, andFilter.Filters.Length);
for (int i = 0; i < andFilter.Filters.Length; i++)
{
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[i];
PexAssert.AreEqual(catFilter.Categories, tokens[i]);
}
}
public void CanParseMultipleAlternatives()
{
CategoryExpression expr = new CategoryExpression("One|Two|Three");
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.AreEqual(orFilter.Filters.Length, 3);
CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "One" });
catFilter = (CategoryFilter)orFilter.Filters[1];
Assert.AreEqual(catFilter.Categories, new string[] { "Two" });
catFilter = (CategoryFilter)orFilter.Filters[2];
Assert.AreEqual(catFilter.Categories, new string[] { "Three" });
}
public void CanParseMultipleCategoriesWithAnd()
{
CategoryExpression expr = new CategoryExpression("One + Two+Three");
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.AreEqual(andFilter.Filters.Length, 3);
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "One" });
catFilter = (CategoryFilter)andFilter.Filters[1];
Assert.AreEqual(catFilter.Categories, new string[] { "Two" });
catFilter = (CategoryFilter)andFilter.Filters[2];
Assert.AreEqual(catFilter.Categories, new string[] { "Three" });
}
public void CanParseMultipleAlternativesPUT([PexAssumeUnderTest] CategoryExpression expr)
{
// CategoryExpression expr = new CategoryExpression("One|Two|Three");
OrFilter orFilter = (OrFilter)expr.Filter;
char[] orSeperator = { '|' };
String[] tokens = expr.GetToken().Split(orSeperator);
PexAssert.AreEqual(tokens.Length, orFilter.Filters.Length);
for (int i = 0; i < orFilter.Filters.Length; i++)
{
CategoryFilter catFilter = (CategoryFilter)orFilter.Filters[i];
PexAssert.AreEqual(catFilter.Categories, tokens[i]);
}
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xmlText);
XmlNode firstChild = xmlDocument.FirstChild;
if (firstChild.Name != "filter")
{
throw new Exception("Expected filter element at top level");
}
TestFilter testFilter = Empty;
bool flag = true;
XmlNodeList xmlNodeList = firstChild.SelectNodes("tests/test");
XmlNodeList xmlNodeList2 = firstChild.SelectNodes("include/category");
XmlNodeList xmlNodeList3 = firstChild.SelectNodes("exclude/category");
if (xmlNodeList.Count > 0)
{
SimpleNameFilter simpleNameFilter = new SimpleNameFilter();
foreach (XmlNode item in firstChild.SelectNodes("tests/test"))
{
simpleNameFilter.Add(item.InnerText);
}
testFilter = simpleNameFilter;
flag = false;
}
if (xmlNodeList2.Count > 0)
{
XmlNode xmlNode2 = xmlNodeList2[0];
TestFilter filter = new CategoryExpression(xmlNode2.InnerText).Filter;
testFilter = ((!flag) ? new AndFilter(testFilter, filter) : filter);
flag = false;
}
if (xmlNodeList3.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode item2 in xmlNodeList3)
{
categoryFilter.AddCategory(item2.InnerText);
}
TestFilter testFilter2 = new NotFilter(categoryFilter);
testFilter = ((!flag) ? new AndFilter(testFilter, testFilter2) : testFilter2);
flag = false;
}
return(testFilter);
}
public void PrecedenceTest()
{
CategoryExpression expr = new CategoryExpression( "A + B | C + -D,E,F" );
OrFilter orFilter = (OrFilter)expr.Filter;
AndFilter andFilter = (AndFilter)orFilter.Filters[0];
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
catFilter = (CategoryFilter)andFilter.Filters[1];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
andFilter = (AndFilter)orFilter.Filters[1];
catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
NotFilter notFilter = (NotFilter)andFilter.Filters[1];
catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
}
public void PrecedenceTest()
{
CategoryExpression expr = new CategoryExpression("A + B | C + -D,E,F");
OrFilter orFilter = (OrFilter)expr.Filter;
AndFilter andFilter = (AndFilter)orFilter.Filters[0];
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "A" });
catFilter = (CategoryFilter)andFilter.Filters[1];
Assert.AreEqual(catFilter.Categories, new string[] { "B" });
andFilter = (AndFilter)orFilter.Filters[1];
catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "C" });
NotFilter notFilter = (NotFilter)andFilter.Filters[1];
catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.AreEqual(catFilter.Categories, new string[] { "D", "E", "F" });
}
public void CombinedPUT([PexAssumeUnderTest] CategoryExpression expr)
{
AndFilter andFilter = (AndFilter)expr.Filter;
String token = expr.GetToken();
String[] seperator = { "+", "-" };
String[] tokens_split = token.Split(seperator, 10, StringSplitOptions.None);
PexAssert.AreEqual(tokens_split.Length, andFilter.Filters.Length);
List <String> list = new List <String>();
char[] plus = { '+' };
String[] tokens_withMinus = token.Split(plus);
char[] minus = { '-' };
for (int i = 0; i < tokens_withMinus.Length; i++)
{
//"A+B-C"
if (tokens_withMinus[i].Contains("-"))
{
String[] subTokens = tokens_withMinus[i].Split(minus);
for (int j = 1; j < subTokens.Length; j++)
{
PexAssert.AreEqual(subTokens[j], typeof(NotFilter));
}
}
}
String[] tokens_withPlus = token.Split(minus);
for (int i = 0; i < tokens_withMinus.Length; i++)
{
//"A+B-C"
if (tokens_withMinus[i].Contains("+"))
{
String[] subTokens = tokens_withMinus[i].Split(plus);
for (int j = 1; j < subTokens.Length; j++)
{
PexAssert.AreEqual(subTokens[j], typeof(CategoryFilter));
}
}
}
}
public void PrecedenceTestWithParentheses()
{
CategoryExpression expr = new CategoryExpression("A + (B | C) - D,E,F");
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.AreEqual(andFilter.Filters.Length, 3);
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "A" });
OrFilter orFilter = (OrFilter)andFilter.Filters[1];
catFilter = (CategoryFilter)orFilter.Filters[0];
Assert.AreEqual(catFilter.Categories, new string[] { "B" });
catFilter = (CategoryFilter)orFilter.Filters[1];
Assert.AreEqual(catFilter.Categories, new string[] { "C" });
NotFilter notFilter = (NotFilter)andFilter.Filters[2];
catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.AreEqual(catFilter.Categories, new string[] { "D", "E", "F" });
}
public void PrecedenceTestWithParentheses()
{
CategoryExpression expr = new CategoryExpression( "A + (B | C) - D,E,F" );
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.That( andFilter.Filters.Length, Is.EqualTo( 3 ) );
CategoryFilter catFilter = (CategoryFilter)andFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "A" } ) );
OrFilter orFilter = (OrFilter)andFilter.Filters[1];
catFilter = (CategoryFilter)orFilter.Filters[0];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "B" } ) );
catFilter = (CategoryFilter)orFilter.Filters[1];
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "C" } ) );
NotFilter notFilter = (NotFilter)andFilter.Filters[2];
catFilter = (CategoryFilter)notFilter.BaseFilter;
Assert.That( catFilter.Categories, Is.EqualTo( new string[] { "D", "E", "F" } ) );
}
public void OrAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A|B-C-D|E");
OrFilter orFilter = (OrFilter)expr.Filter;
Assert.AreEqual(orFilter.Filters.Length, 3);
AndFilter andFilter = (AndFilter)orFilter.Filters[1];
Assert.AreEqual(andFilter.Filters.Length, 3);
Assert.AreEqual(andFilter.Filters[0], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[1], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[2], typeof(NotFilter));
}
public void ParseCategoryPUT([PexAssumeUnderTest]String s)
{
PexAssume.IsTrue(s.Length > 0 && !s.Contains("\n"));
PexAssume.IsTrue(Regex.IsMatch(s, "^(a[;,]b[;,])*$")); //|| Regex.IsMatch(s, "a,b"));
CategoryExpression expr = new CategoryExpression(s);
String[] seperator = { ",", ";" };
s = s.Replace("\n", "");
if (s.EndsWith(";") || s.EndsWith(","))
{
s = s.Remove(s.Length - 1);
}
String[] tokens_split = s.Split(seperator, 10, StringSplitOptions.None);
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr, 0);
for (int i = 0; i < tokens_split.Length; i++)
{
//Console.WriteLine(arr[i]);
PexAssert.AreEqual(tokens_split[i],arr[i]);
}
if (tokens_split.Length == 0)
{
PexAssert.IsTrue(expr.Filter.IsEmpty);
}
}
public void PlusAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression("A+B-C-D+E");
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.AreEqual(andFilter.Filters.Length, 5);
Assert.AreEqual(andFilter.Filters[0], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[1], typeof(CategoryFilter));
Assert.AreEqual(andFilter.Filters[2], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[3], typeof(NotFilter));
Assert.AreEqual(andFilter.Filters[4], typeof(CategoryFilter));
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlText);
XmlNode topNode = doc.FirstChild;
if (topNode.Name != "filter")
{
throw new Exception("Expected filter element at top level");
}
// Initially, an empty filter
TestFilter result = TestFilter.Empty;
bool isEmptyResult = true;
XmlNodeList testNodes = topNode.SelectNodes("tests/test");
XmlNodeList includeNodes = topNode.SelectNodes("include/category");
XmlNodeList excludeNodes = topNode.SelectNodes("exclude/category");
if (testNodes.Count > 0)
{
SimpleNameFilter nameFilter = new SimpleNameFilter();
foreach (XmlNode testNode in topNode.SelectNodes("tests/test"))
{
nameFilter.Add(testNode.InnerText);
}
result = nameFilter;
isEmptyResult = false;
}
if (includeNodes.Count > 0)
{
//CategoryFilter includeFilter = new CategoryFilter();
//foreach (XmlNode includeNode in includeNodes)
// includeFilter.AddCategory(includeNode.InnerText);
// Temporarily just look at the first element
XmlNode includeNode = includeNodes[0];
TestFilter includeFilter = new CategoryExpression(includeNode.InnerText).Filter;
if (isEmptyResult)
{
result = includeFilter;
}
else
{
result = new AndFilter(result, includeFilter);
}
isEmptyResult = false;
}
if (excludeNodes.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode excludeNode in excludeNodes)
{
categoryFilter.AddCategory(excludeNode.InnerText);
}
TestFilter excludeFilter = new NotFilter(categoryFilter);
if (isEmptyResult)
{
result = excludeFilter;
}
else
{
result = new AndFilter(result, excludeFilter);
}
isEmptyResult = false;
}
return(result);
}
public void CanParseCompoundCategory()
{
CategoryExpression expr = new CategoryExpression( "One , Two; Three,Four" );
CategoryFilter filter = (CategoryFilter)expr.Filter;
Assert.That( filter.Categories, Is.EqualTo( new string[] { "One", "Two", "Three", "Four" } ) );
}
public void CanParseSimpleCategory()
{
CategoryExpression expr = new CategoryExpression("Data");
CategoryFilter filter = (CategoryFilter)expr.Filter;
String[] arr = new String[filter.Categories.Count];
filter.Categories.CopyTo(arr, 0);
PexAssert.AreEqual("Data", arr[0]);
}
public void EmptyStringReturnsEmptyFilter()
{
CategoryExpression expr = new CategoryExpression( "" );
Assert.That( expr.Filter.IsEmpty );
}
public void PlusAndMinusCombined()
{
CategoryExpression expr = new CategoryExpression( "A+B-C-D+E" );
AndFilter andFilter = (AndFilter)expr.Filter;
Assert.That( andFilter.Filters.Length, Is.EqualTo( 5 ) );
Assert.That( andFilter.Filters[0], Is.TypeOf( typeof( CategoryFilter) ) );
Assert.That( andFilter.Filters[1], Is.TypeOf( typeof( CategoryFilter) ) );
Assert.That( andFilter.Filters[2], Is.TypeOf( typeof( NotFilter) ) );
Assert.That( andFilter.Filters[3], Is.TypeOf( typeof( NotFilter) ) );
Assert.That( andFilter.Filters[4], Is.TypeOf( typeof( CategoryFilter) ) );
}
internal static bool CreateTestFilter(ConsoleOptions options, out TestFilter testFilter)
{
testFilter = TestFilter.Empty;
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
foreach (string name in TestNameParser.Parse(options.run))
{
nameFilter.Add(name);
}
testFilter = nameFilter;
}
if (options.runlist != null && options.runlist != string.Empty)
{
Console.WriteLine("Run list: " + options.runlist);
try
{
using (StreamReader rdr = new StreamReader(options.runlist))
{
// NOTE: We can't use rdr.EndOfStream because it's
// not present in .NET 1.x.
string line = rdr.ReadLine();
while (line != null && line.Length > 0)
{
if (line[0] != '#')
{
nameFilter.Add(line);
}
line = rdr.ReadLine();
}
}
}
catch (Exception e)
{
if (e is FileNotFoundException || e is DirectoryNotFoundException)
{
Console.WriteLine("Unable to locate file: " + options.runlist);
return(false);
}
throw;
}
testFilter = nameFilter;
}
if (!string.IsNullOrEmpty(options.include))
{
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
Console.WriteLine("Included categories: " + includeFilter);
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (!string.IsNullOrEmpty(options.exclude))
{
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
Console.WriteLine("Excluded categories: " + excludeFilter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
return(true);
}
public int Execute(ConsoleOptions options)
{
XmlTextReader transformReader = GetTransformReader(options);
if (transformReader == null)
{
return(FILE_NOT_FOUND);
}
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(options.output);
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(options.err);
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TestRunner testRunner = MakeRunnerFromCommandLine(options);
try
{
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
EventCollector collector = new EventCollector(options, outWriter, errorWriter);
TestFilter testFilter = TestFilter.Empty;
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test: " + options.run);
testFilter = new SimpleNameFilter(options.run);
}
if (options.include != null && options.include != string.Empty)
{
Console.WriteLine("Included categories: " + options.include);
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
Console.WriteLine("Excluded categories: " + options.exclude);
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
try
{
//CreateSummaryDocument(xmlOutput, transformReader );
XmlResultTransform xform = new XmlResultTransform(transformReader);
xform.Transform(new StringReader(xmlOutput), Console.Out);
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex.Message);
return(TRANSFORM_ERROR);
}
}
// Write xml output here
string xmlResultFile = options.xml == null || options.xml == string.Empty
? "TestResult.xml" : options.xml;
using (StreamWriter writer = new StreamWriter(xmlResultFile))
{
writer.Write(xmlOutput);
}
}
//if ( testRunner != null )
// testRunner.Unload();
if (collector.HasExceptions)
{
collector.WriteExceptions();
return(UNEXPECTED_ERROR);
}
if (!result.IsFailure)
{
return(OK);
}
ResultSummarizer summ = new ResultSummarizer(result);
return(summ.FailureCount);
}
finally
{
testRunner.Unload();
}
}
public int Execute(ExtendedConsoleOptions options)
{
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(options.output);
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(options.err);
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TextWriter testResultWriter = null;
if (options.IsResults)
{
testResultWriter = new StreamWriter(options.results, false, Encoding.UTF8);
((StreamWriter)testResultWriter).AutoFlush = true;
}
TestPackage package = MakeTestPackage(options);
Console.WriteLine("ProcessModel: {0} DomainUsage: {1}",
package.Settings.Contains("ProcessModel")
? package.Settings["ProcessModel"]
: "Default",
package.Settings.Contains("DomainUsage")
? package.Settings["DomainUsage"]
: "Default");
Console.WriteLine("Execution Runtime: {0}",
package.Settings.Contains("RuntimeFramework")
? package.Settings["RuntimeFramework"]
: "Default");
TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
testRunner.Load(package);
try
{
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
ExtendedEventCollector collector = new ExtendedEventCollector(options, outWriter, errorWriter, testResultWriter);
TestFilter testFilter = TestFilter.Empty;
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
testFilter = new SimpleNameFilter(options.run);
}
if (options.include != null && options.include != string.Empty)
{
Console.WriteLine("Included categories: " + options.include);
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
Console.WriteLine("Excluded categories: " + options.exclude);
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
if (options.IsResults)
{
testResultWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
int returnCode = UNEXPECTED_ERROR;
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
ResultSummarizer summary = new ResultSummarizer(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
WriteSummaryReport(summary);
if (summary.ErrorsAndFailures > 0)
{
WriteErrorsAndFailuresReport(result);
}
if (summary.TestsNotRun > 0)
{
WriteNotRunReport(result);
}
}
// Write xml output here
string xmlResultFile = options.xml == null || options.xml == string.Empty
? "TestResult.xml" : options.xml;
if (!String.IsNullOrEmpty(options.xml))
{
using (StreamWriter writer = new StreamWriter(xmlResultFile))
{
writer.Write(xmlOutput);
}
}
returnCode = summary.ErrorsAndFailures;
}
if (collector.HasExceptions)
{
collector.WriteExceptions();
returnCode = UNEXPECTED_ERROR;
}
return(returnCode);
}
finally
{
testRunner.Unload();
}
}
public void EmptyStringReturnsEmptyFilter()
{
CategoryExpression expr = new CategoryExpression("");
PexAssert.IsTrue(expr.Filter.IsEmpty);
}
public static TestFilter FromXml(string xmlText)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlText);
XmlNode topNode = doc.FirstChild;
if (topNode.Name != "filter")
throw new Exception("Expected filter element at top level");
// Initially, an empty filter
TestFilter result = TestFilter.Empty;
bool isEmptyResult = true;
XmlNodeList testNodes = topNode.SelectNodes("tests/test");
XmlNodeList includeNodes = topNode.SelectNodes("include/category");
XmlNodeList excludeNodes = topNode.SelectNodes("exclude/category");
if (testNodes.Count > 0)
{
SimpleNameFilter nameFilter = new SimpleNameFilter();
foreach (XmlNode testNode in topNode.SelectNodes("tests/test"))
nameFilter.Add(testNode.InnerText);
result = nameFilter;
isEmptyResult = false;
}
if (includeNodes.Count > 0)
{
//CategoryFilter includeFilter = new CategoryFilter();
//foreach (XmlNode includeNode in includeNodes)
// includeFilter.AddCategory(includeNode.InnerText);
// Temporarily just look at the first element
XmlNode includeNode = includeNodes[0];
TestFilter includeFilter = new CategoryExpression(includeNode.InnerText).Filter;
if (isEmptyResult)
result = includeFilter;
else
result = new AndFilter(result, includeFilter);
isEmptyResult = false;
}
if (excludeNodes.Count > 0)
{
CategoryFilter categoryFilter = new CategoryFilter();
foreach (XmlNode excludeNode in excludeNodes)
categoryFilter.AddCategory(excludeNode.InnerText);
TestFilter excludeFilter = new NotFilter(categoryFilter);
if (isEmptyResult)
result = excludeFilter;
else
result = new AndFilter(result, excludeFilter);
isEmptyResult = false;
}
return result;
}
public int Execute(ConsoleOptions options)
{
this.workDir = options.work;
if (workDir == null || workDir == string.Empty)
{
workDir = Environment.CurrentDirectory;
}
else
{
workDir = Path.GetFullPath(workDir);
if (!Directory.Exists(workDir))
{
Directory.CreateDirectory(workDir);
}
}
TextWriter outWriter = Console.Out;
bool redirectOutput = options.output != null && options.output != string.Empty;
if (redirectOutput)
{
StreamWriter outStreamWriter = new StreamWriter(Path.Combine(workDir, options.output));
outStreamWriter.AutoFlush = true;
outWriter = outStreamWriter;
}
TextWriter errorWriter = Console.Error;
bool redirectError = options.err != null && options.err != string.Empty;
if (redirectError)
{
StreamWriter errorStreamWriter = new StreamWriter(Path.Combine(workDir, options.err));
errorStreamWriter.AutoFlush = true;
errorWriter = errorStreamWriter;
}
TestPackage package = MakeTestPackage(options);
ProcessModel processModel = package.Settings.Contains("ProcessModel")
? (ProcessModel)package.Settings["ProcessModel"]
: ProcessModel.Default;
DomainUsage domainUsage = package.Settings.Contains("DomainUsage")
? (DomainUsage)package.Settings["DomainUsage"]
: DomainUsage.Default;
RuntimeFramework framework = package.Settings.Contains("RuntimeFramework")
? (RuntimeFramework)package.Settings["RuntimeFramework"]
: RuntimeFramework.CurrentFramework;
#if CLR_2_0 || CLR_4_0
Console.WriteLine("ProcessModel: {0} DomainUsage: {1}", processModel, domainUsage);
Console.WriteLine("Execution Runtime: {0}", framework);
#else
Console.WriteLine("DomainUsage: {0}", domainUsage);
if (processModel != ProcessModel.Default && processModel != ProcessModel.Single)
{
Console.WriteLine("Warning: Ignoring project setting 'processModel={0}'", processModel);
}
if (!RuntimeFramework.CurrentFramework.Supports(framework))
{
Console.WriteLine("Warning: Ignoring project setting 'runtimeFramework={0}'", framework);
}
#endif
using (TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package))
{
testRunner.Load(package);
if (testRunner.Test == null)
{
testRunner.Unload();
Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return(FIXTURE_NOT_FOUND);
}
EventCollector collector = new EventCollector(options, outWriter, errorWriter);
TestFilter testFilter = TestFilter.Empty;
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
foreach (string name in TestNameParser.Parse(options.run))
{
nameFilter.Add(name);
}
testFilter = nameFilter;
}
if (options.runlist != null && options.runlist != string.Empty)
{
Console.WriteLine("Run list: " + options.runlist);
using (StreamReader rdr = new StreamReader(options.runlist))
{
// NOTE: We can't use rdr.EndOfStream because it's
// not present in .NET 1.x.
string line = rdr.ReadLine();
while (line != null)
{
if (line[0] != '#')
{
nameFilter.Add(line);
}
line = rdr.ReadLine();
}
}
testFilter = nameFilter;
}
if (options.include != null && options.include != string.Empty)
{
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
Console.WriteLine("Included categories: " + includeFilter.ToString());
if (testFilter.IsEmpty)
{
testFilter = includeFilter;
}
else
{
testFilter = new AndFilter(testFilter, includeFilter);
}
}
if (options.exclude != null && options.exclude != string.Empty)
{
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
Console.WriteLine("Excluded categories: " + excludeFilter.ToString());
if (testFilter.IsEmpty)
{
testFilter = excludeFilter;
}
else if (testFilter is AndFilter)
{
((AndFilter)testFilter).Add(excludeFilter);
}
else
{
testFilter = new AndFilter(testFilter, excludeFilter);
}
}
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
TestResult result = null;
string savedDirectory = Environment.CurrentDirectory;
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
try
{
result = testRunner.Run(collector, testFilter, false, LoggingThreshold.Off);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
{
outWriter.Close();
}
if (redirectError)
{
errorWriter.Close();
}
Environment.CurrentDirectory = savedDirectory;
Console.SetOut(savedOut);
Console.SetError(savedError);
}
Console.WriteLine();
int returnCode = UNEXPECTED_ERROR;
if (result != null)
{
string xmlOutput = CreateXmlOutput(result);
ResultSummarizer summary = new ResultSummarizer(result);
if (options.xmlConsole)
{
Console.WriteLine(xmlOutput);
}
else
{
WriteSummaryReport(summary);
if (summary.ErrorsAndFailures > 0 || result.IsError || result.IsFailure)
{
if (options.stoponerror)
{
Console.WriteLine("Test run was stopped after first error, as requested.");
Console.WriteLine();
}
WriteErrorsAndFailuresReport(result);
}
if (summary.TestsNotRun > 0)
{
WriteNotRunReport(result);
}
if (!options.noresult)
{
// Write xml output here
string xmlResultFile = options.result == null || options.result == string.Empty
? "TestResult.xml" : options.result;
using (StreamWriter writer = new StreamWriter(Path.Combine(workDir, xmlResultFile)))
{
writer.Write(xmlOutput);
}
}
}
returnCode = summary.ErrorsAndFailures;
}
if (collector.HasExceptions)
{
collector.WriteExceptions();
returnCode = UNEXPECTED_ERROR;
}
return(returnCode);
}
}
public void CanParseSimpleCategory()
{
CategoryExpression expr = new CategoryExpression( "Data" );
CategoryFilter filter = (CategoryFilter)expr.Filter;
Assert.That( filter.Categories, Is.EqualTo( new string[] { "Data" } ) );
}
