public void CategoryFilter_AddCategories()
{
var filter = new CategoryFilter();
filter.AddCategory("Dummy");
filter.AddCategory("Another");
Assert.False(filter.IsEmpty);
Assert.That(filter.Match(dummyFixture));
Assert.That(filter.Match(anotherFixture));
Assert.False(filter.Match(yetAnotherFixture));
}
void ChainCategoryFilter(IEnumerable <string> categories, bool negate, ref ITestFilter chain)
{
bool gotCategories = false;
if (categories != null)
{
var filter = new CategoryFilter();
foreach (string c in categories)
{
Log.Info(LogTag, $" {c}");
filter.AddCategory(c);
gotCategories = true;
}
if (gotCategories)
{
chain = new AndFilter(chain, negate ? new NotFilter(filter) : (ITestFilter)filter);
}
}
if (!gotCategories)
{
Log.Info(LogTag, " none");
}
}
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");
}
}
private CategoryFilter GetCategoryFilter()
{
CategoryFilter categoryFilter = new CategoryFilter(token);
while (GetToken() == "," || token == ";")
{
categoryFilter.AddCategory(GetToken());
}
return(categoryFilter);
}
private static TestFilter FromXml(XmlNode xmlNode)
{
switch (xmlNode.Name)
{
case "filter":
case "and":
var andFilter = new AndFilter();
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
andFilter.Add(FromXml(childNode));
}
return(andFilter);
case "or":
var orFilter = new OrFilter();
foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
{
orFilter.Add(FromXml(childNode));
}
return(orFilter);
case "not":
return(new NotFilter(FromXml(xmlNode.FirstChild)));
case "id":
var idFilter = new IdFilter();
foreach (string id in xmlNode.InnerText.Split(COMMA))
{
idFilter.Add(int.Parse(id));
}
return(idFilter);
case "tests":
var testFilter = new SimpleNameFilter();
foreach (XmlNode childNode in xmlNode.SelectNodes("test"))
{
testFilter.Add(childNode.InnerText);
}
return(testFilter);
case "cat":
var catFilter = new CategoryFilter();
foreach (string cat in xmlNode.InnerText.Split(COMMA))
{
catFilter.AddCategory(cat);
}
return(catFilter);
default:
throw new ArgumentException("Invalid filter element: " + xmlNode.Name, "xmlNode");
}
}
public void RunSuiteByCategory()
{
TestSuite testSuite = new TestSuite("Mock Test Suite");
testSuite.Add(mockTestFixture);
CategoryFilter filter = new CategoryFilter();
filter.AddCategory("FixtureCategory");
RecordingListener listener = new RecordingListener();
testSuite.Run(listener, filter);
Assert.AreEqual(MockTestFixture.ResultCount, listener.testStarted.Count);
}
public void AddCategory__Category_IsNull__Throws()
{
// Arrange:
var list = new List <Category> {
new Category(10, 20)
};
var filter = new CategoryFilter(list);
Category nullCategory = null;
// Action:
// Assert:
Assert.Catch <ArgumentNullException>(() => filter.AddCategory(nullCategory));
}
public void RunTestByCategory()
{
TestSuite testSuite = new TestSuite("Mock Test Suite");
testSuite.Add(mockTestFixture);
CategoryFilter filter = new CategoryFilter();
filter.AddCategory("MockCategory");
RecordingListener listener = new RecordingListener();
testSuite.Run(listener, filter);
CollectionAssert.AreEquivalent(
new string[] { "MockTest2", "MockTest3" },
listener.testStarted);
}
public void RunTestByCategory()
{
TestSuite testSuite = new TestSuite("Mock Test Suite");
testSuite.Add(mockTestFixture);
CategoryFilter filter = new CategoryFilter();
filter.AddCategory("MockCategory");
RecordingListener listener = new RecordingListener();
testSuite.Run(listener, filter);
Assert.AreEqual(2, listener.testStarted.Count);
Assert.IsTrue(listener.testStarted.Contains("MockTest2"));
Assert.IsTrue(listener.testStarted.Contains("MockTest3"));
}
public void RunTestExcludingCategory()
{
TestSuite testSuite = new TestSuite("Mock Test Suite");
testSuite.Add(mockTestFixture);
CategoryFilter filter = new CategoryFilter();
filter.AddCategory("MockCategory");
RecordingListener listener = new RecordingListener();
testSuite.Run(listener, new NotFilter(filter));
CollectionAssert.AreEquivalent(
new string[] { "MockTest1", "MockTest4", "MockTest5", "TestWithManyProperties" },
listener.testStarted);
}
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 RunTestExcludingCategory()
{
TestSuite testSuite = new TestSuite("Mock Test Suite");
testSuite.Add(mockTestFixture);
CategoryFilter filter = new CategoryFilter();
filter.AddCategory("MockCategory");
RecordingListener listener = new RecordingListener();
NotFilter notFilter = new NotFilter(filter);
notFilter.TopLevel = true;
testSuite.Run(listener, notFilter);
CollectionAssert.AreEquivalent(
new string[] { "MockTest1", "MockTest4", "MockTest5",
"TestWithManyProperties", "NotRunnableTest", "FailingTest",
"TestWithException", "InconclusiveTest" },
listener.testStarted);
}
static void ChainCategoryFilter(IEnumerable <string> categories, bool negate, ref TestFilter chain)
{
bool gotCategories = false;
if (categories != null)
{
var filter = new CategoryFilter();
foreach (string c in categories)
{
Log.Info(TAG, " {0}", c);
filter.AddCategory(c);
gotCategories = true;
}
chain = new AndFilter(chain, negate ? (TestFilter) new NotFilter(filter) : (TestFilter)filter);
}
if (!gotCategories)
{
Log.Info(TAG, " none");
}
}
private CategoryFilter GetCategoryFilter()
{
CategoryFilter filter = new CategoryFilter( token );
while( GetToken() == "," || token == ";" )
filter.AddCategory( GetToken() );
return filter;
}
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 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);
}
