Esempio n. 1
0
        /// <inheritdoc/>
        public bool OnMessage(_MessageSinkMessage message)
        {
            Guard.ArgumentNotNull(nameof(message), message);

            if (message is _TestSkipped testSkipped)
            {
                var testFailed = new _TestFailed
                {
                    AssemblyUniqueID       = testSkipped.AssemblyUniqueID,
                    ExceptionParentIndices = new[] { -1 },
                    ExceptionTypes         = new[] { "FAIL_SKIP" },
                    ExecutionTime          = 0m,
                    Messages               = new[] { testSkipped.Reason },
                    Output                 = "",
                    StackTraces            = new[] { "" },
                    TestCaseUniqueID       = testSkipped.TestCaseUniqueID,
                    TestClassUniqueID      = testSkipped.TestClassUniqueID,
                    TestCollectionUniqueID = testSkipped.TestCollectionUniqueID,
                    TestMethodUniqueID     = testSkipped.TestMethodUniqueID,
                    TestUniqueID           = testSkipped.TestUniqueID
                };

                return(innerSink.OnMessage(testFailed));
            }

            // TODO: Shouldn't there be conversions of all the finished messages up the stack, to rectify the counts?

            if (message is _TestCollectionFinished testCollectionFinished)
            {
                testCollectionFinished = new _TestCollectionFinished
                {
                    AssemblyUniqueID       = testCollectionFinished.AssemblyUniqueID,
                    ExecutionTime          = testCollectionFinished.ExecutionTime,
                    TestCollectionUniqueID = testCollectionFinished.TestCollectionUniqueID,
                    TestsFailed            = testCollectionFinished.TestsFailed + testCollectionFinished.TestsSkipped,
                    TestsRun     = testCollectionFinished.TestsRun,
                    TestsSkipped = 0
                };

                return(innerSink.OnMessage(testCollectionFinished));
            }

            if (message is _TestAssemblyFinished assemblyFinished)
            {
                assemblyFinished = new _TestAssemblyFinished
                {
                    AssemblyUniqueID = assemblyFinished.AssemblyUniqueID,
                    ExecutionTime    = assemblyFinished.ExecutionTime,
                    TestsFailed      = assemblyFinished.TestsFailed + assemblyFinished.TestsSkipped,
                    TestsRun         = assemblyFinished.TestsRun,
                    TestsSkipped     = 0
                };

                return(innerSink.OnMessage(assemblyFinished));
            }

            return(innerSink.OnMessage(message));
        }
Esempio n. 2
0
        /// <summary>
        /// INTERNAL METHOD, FOR TESTING PURPOSES ONLY. DO NOT CALL.
        /// </summary>
        protected void Run(
            IEnumerable <Xunit1TestCase> testCases,
            _IMessageSink messageSink)
        {
            var results       = new Xunit1RunSummary();
            var environment   = $"{IntPtr.Size * 8}-bit .NET {Environment.Version}";
            var testCasesList = testCases.ToList();

            var testAssemblyStartingMessage = new _TestAssemblyStarting
            {
                AssemblyName             = testAssemblyName,
                AssemblyPath             = assemblyFileName,
                AssemblyUniqueID         = TestAssemblyUniqueID,
                ConfigFilePath           = configFileName,
                StartTime                = DateTimeOffset.Now,
                TestEnvironment          = environment,
                TestFrameworkDisplayName = TestFrameworkDisplayName,
            };

            if (messageSink.OnMessage(testAssemblyStartingMessage))
            {
                try
                {
                    if (testCasesList.Count != 0)
                    {
                        results = RunTestCollection(testCasesList, messageSink);
                    }
                }
                catch (Exception ex)
                {
                    var errorMetadata = Xunit1ExceptionUtility.ConvertToErrorMetadata(ex);
                    var errorMessage  = new _ErrorMessage
                    {
                        ExceptionParentIndices = errorMetadata.ExceptionParentIndices,
                        ExceptionTypes         = errorMetadata.ExceptionTypes,
                        Messages    = errorMetadata.Messages,
                        StackTraces = errorMetadata.StackTraces
                    };
                    messageSink.OnMessage(errorMessage);
                }
                finally
                {
                    var assemblyFinished = new _TestAssemblyFinished
                    {
                        AssemblyUniqueID = testAssemblyStartingMessage.AssemblyUniqueID,
                        ExecutionTime    = results.Time,
                        TestsFailed      = results.Failed,
                        TestsRun         = results.Total,
                        TestsSkipped     = results.Skipped
                    };

                    messageSink.OnMessage(assemblyFinished);
                }
            }
        }