private static Core.TestFilter FromXml(XmlNode xmlNode)
        {
            switch (xmlNode.Name)
            {
            case "filter":
            case "and":
                var andFilter = new Core.Filters.AndFilter();
                foreach (XmlNode childNode in xmlNode.ChildNodes)
                {
                    andFilter.Add(FromXml(childNode));
                }
                return(andFilter);

            case "or":
                var orFilter = new Core.Filters.OrFilter();
                foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
                {
                    orFilter.Add(FromXml(childNode));
                }
                return(orFilter);

            case "not":
                return(new Core.Filters.NotFilter(FromXml(xmlNode.FirstChild)));

            case "test":
                if (xmlNode.Attributes["re"] != null)
                {
                    throw new NUnitEngineException("Filters with regular expressions are only supported when running NUnit 3 tests");
                }
                return(new Core.Filters.SimpleNameFilter(xmlNode.InnerText));

            case "cat":
                if (xmlNode.Attributes["re"] != null)
                {
                    throw new NUnitEngineException("Filters with regular expressions are only supported when running NUnit 3 tests");
                }
                var catFilter = new Core.Filters.CategoryFilter();
                foreach (string cat in xmlNode.InnerText.Split(COMMA))
                {
                    catFilter.AddCategory(cat);
                }
                return(catFilter);

            case "id":
            case "name":
            case "class":
            case "method":
                throw new NUnitEngineException(string.Format("Filtering on {0} is only valid when running NUnit 3 tests", xmlNode.Name));

            case "prop":
                throw new NUnitEngineException("Filtering on a property value is only valid when running NUnit 3 tests");

            default:
                throw new NUnitEngineException(string.Format("Invalid filter passed to the NUnit V2 driver: {0} is not a known filter type", xmlNode.Name));
            }
        }
Example #2
0
        private static Core.TestFilter FromXml(XmlNode xmlNode)
        {
            switch (xmlNode.Name)
            {
            case "filter":
            case "and":
                var andFilter = new Core.Filters.AndFilter();
                foreach (XmlNode childNode in xmlNode.ChildNodes)
                {
                    andFilter.Add(FromXml(childNode));
                }
                return(andFilter);

            case "or":
                var orFilter = new Core.Filters.OrFilter();
                foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
                {
                    orFilter.Add(FromXml(childNode));
                }
                return(orFilter);

            case "not":
                return(new NotFilter(FromXml(xmlNode.FirstChild)));

            case "tests":
                var testFilter = new Core.Filters.SimpleNameFilter();
                var testNodes  = xmlNode.SelectNodes("test");
                if (testNodes != null)
                {
                    foreach (XmlNode childNode in testNodes)
                    {
                        testFilter.Add(childNode.InnerText);
                    }
                }
                return(testFilter);

            case "cat":
                var catFilter = new Core.Filters.CategoryFilter();
                foreach (string cat in xmlNode.InnerText.Split(COMMA))
                {
                    catFilter.AddCategory(cat);
                }
                return(catFilter);

            default:
                throw new ArgumentException("Invalid filter element: " + xmlNode.Name, "xmlNode");
            }
        }
Example #3
0
        private static Core.TestFilter FromXml(XmlNode xmlNode)
        {
            switch (xmlNode.Name)
            {
                case "filter":
                case "and":
                    var andFilter = new Core.Filters.AndFilter();
                    foreach (XmlNode childNode in xmlNode.ChildNodes)
                        andFilter.Add(FromXml(childNode));
                    return andFilter;

                case "or":
                    var orFilter = new Core.Filters.OrFilter();
                    foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
                        orFilter.Add(FromXml(childNode));
                    return orFilter;

                case "not":
                    return new Core.Filters.NotFilter(FromXml(xmlNode.FirstChild));

                case "test":
                    if (xmlNode.Attributes["re"] != null)
                        throw new NUnitEngineException("Filters with regular expressions are only supported when running NUnit 3 tests");
                    return new Core.Filters.SimpleNameFilter(xmlNode.InnerText);

                case "cat":
                    if (xmlNode.Attributes["re"] != null)
                        throw new NUnitEngineException("Filters with regular expressions are only supported when running NUnit 3 tests");
                    var catFilter = new Core.Filters.CategoryFilter();
                    foreach (string cat in xmlNode.InnerText.Split(COMMA))
                        catFilter.AddCategory(cat);
                    return catFilter;

                case "id":
                case "name":
                case "class":
                case "method":
                    throw new NUnitEngineException(string.Format("Filtering on {0} is only valid when running NUnit 3 tests", xmlNode.Name));
                case "prop":
                    throw new NUnitEngineException("Filtering on a property value is only valid when running NUnit 3 tests");
                default:
                    throw new NUnitEngineException(string.Format("Invalid filter passed to the NUnit V2 driver: {0} is not a known filter type", xmlNode.Name));
            }
        }
        private static Core.TestFilter FromXml(XmlNode xmlNode)
        {
            switch (xmlNode.Name)
            {
                case "filter":
                case "and":
                    var andFilter = new Core.Filters.AndFilter();
                    foreach (XmlNode childNode in xmlNode.ChildNodes)
                        andFilter.Add(FromXml(childNode));
                    return andFilter;

                case "or":
                    var orFilter = new Core.Filters.OrFilter();
                    foreach (System.Xml.XmlNode childNode in xmlNode.ChildNodes)
                        orFilter.Add(FromXml(childNode));
                    return orFilter;

                case "not":
                    return new NotFilter(FromXml(xmlNode.FirstChild));

                case "tests":
                    var testFilter = new Core.Filters.SimpleNameFilter();
                    var testNodes = xmlNode.SelectNodes("test");
                    if(testNodes != null)
                        foreach (XmlNode childNode in testNodes)
                            testFilter.Add(childNode.InnerText);
                    return testFilter;

                case "cat":
                    var catFilter = new Core.Filters.CategoryFilter();
                    foreach (string cat in xmlNode.InnerText.Split(COMMA))
                        catFilter.AddCategory(cat);
                    return catFilter;

                default:
                    throw new ArgumentException("Invalid filter element: " + xmlNode.Name, "xmlNode");
            }
        }