private void CalculateSweetTotalsOnOuterSweet(testsuiteType suite)
        {
            var suiteItems  = suite.results.Items.ToList();
            var innerSuites = suiteItems.Where(x => x.GetType() == typeof(testsuiteType)).Cast <testsuiteType>();

            suite.asserts = innerSuites.Sum(x => Convert.ToInt16(x.asserts)).ToString();
            suite.result  = innerSuites.Any(x => x.result == "Failure") ? "Failure" : "Success";
            suite.time    = innerSuites.Sum(x => Convert.ToDouble(x.time)).ToString();
        }
        static void AppendTestSuite(XDocument xdocument, testsuiteType suite)
        {
            var ser = new XmlSerializer(typeof(testsuiteType));

            using (var writer = xdocument.Root.CreateWriter())
            {
                // We need this for some reason...
                writer.WriteWhitespace("");
                ser.Serialize(writer, suite);
            }
        }
        private void CalculateCaseTotalsOnSuite(testsuiteType suite)
        {
            //result types
            //Ignored, Failure, NotRunnable, Error, Success

            //success is true or false

            var suiteItems = suite.results.Items.ToList();
            var cases      = suiteItems.Where(x => x.GetType() == typeof(testcaseType)).Cast <testcaseType>();

            suite.asserts = cases.Sum(x => Convert.ToInt16(x.asserts)).ToString();
            suite.result  = cases.Any(x => x.result == "Failure") ? "Failure" : "Success";
            suite.time    = cases.Sum(x => Convert.ToDouble(x.time)).ToString();
            //suite.executed = cases.All(x => x.executed == "False") ? "False" : "True";
            suite.executed = true.ToString();
        }
        /// <summary>
        /// Find or create a fixture in a suite by name.
        /// </summary>
        /// <param name="suite"></param>
        /// <returns></returns>
        private testsuiteType FindOrCreateFixtureResults(resultsType results, string fixtureName)
        {
            testsuiteType fixture = null;

            if (results.Items != null && results.Items.Any())
            {
                fixture = (testsuiteType)results.Items.
                          FirstOrDefault(x => x.GetType() == typeof(testsuiteType) && ((testsuiteType)x).name == fixtureName);

                if (fixture != null)
                {
                    return(fixture);
                }
            }

            fixture = new testsuiteType
            {
                name        = fixtureName,
                description = "Unit tests in Revit.",
                time        = "0.0",
                type        = "TestFixture",
                result      = "Success",
                executed    = "True",
                results     = new resultsType {
                    Items = new object[] { }
                }
            };

            //add the newly created fixture to the list of fixtures
            List <object> currentFixtures = null;

            currentFixtures = results.Items != null?
                              results.Items.ToList() :
                                  new List <object>();

            currentFixtures.Add(fixture);
            results.Items = currentFixtures.ToArray();

            return(fixture);
        }
        private List<TestCaseResult> ReadTestCases(testsuiteType suite)
        {
            if (suite.results == null)
                return null;

            var results = new List<TestCaseResult>();

            foreach (object obj in suite.results.Items)
            {
                if (obj is testsuiteType)
                {
                    var nextLevelResults = ReadTestCases(obj as testsuiteType);
                    results.AddRange(nextLevelResults);
                }
                else if (obj is testcaseType)
                {
                    TestCaseResult result = ParseTest(obj as testcaseType);
                    results.Add(result);
                }
            }

            return results;
        }