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 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 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 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" } ) ); }