コード例 #1
0
        public async Task <int> Run()
        {
            var testRunner = new ThreadlessXunitTestRunner();
            var filters    = new XunitFilters();

            foreach (var trait in ExcludedTraits)
            {
                ParseEqualSeparatedArgument(filters.ExcludedTraits, trait);
            }
            foreach (var trait in IncludedTraits)
            {
                ParseEqualSeparatedArgument(filters.IncludedTraits, trait);
            }
            foreach (var ns in IncludedNamespaces)
            {
                filters.IncludedNamespaces.Add(ns);
            }
            foreach (var cl in IncludedClasses)
            {
                filters.IncludedClasses.Add(cl);
            }
            foreach (var me in IncludedMethods)
            {
                filters.IncludedMethods.Add(me);
            }

            var result = await testRunner.Run(TestAssembly, printXml : true, filters);

            return(result);
        }
コード例 #2
0
        public static void EmptyFiltersListAlwaysPasses()
        {
            var filters = new XunitFilters();
            var method  = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name1");

            var result = filters.Filter(method);

            Assert.True(result);
        }
コード例 #3
0
        public static void EmptyFiltersListAlwaysPasses()
        {
            var filters = new XunitFilters();
            var method  = Mocks.TestCase <ClassUnderTest>("MethodWithNoTraits");

            var result = filters.Filter(method);

            Assert.True(result);
        }
コード例 #4
0
        public void EmptyFiltersListAlwaysPasses()
        {
            var filters = new XunitFilters();
            var method  = new TestMethod("method1", "Display Name 1", traits: null);

            bool result = filters.Filter(method);

            Assert.True(result);
        }
コード例 #5
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void SingleFilter_IncludesMatchingTrait()
        {
            var filters = new XunitFilters();

            filters.IncludedTraits.Add("foo", "bar");

            Assert.False(filters.Filter(NonClassTest));
            Assert.False(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(MethodWithNoTraits));
            Assert.True(filters.Filter(MethodWithFooBarTrait));
            Assert.False(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #6
0
        public void CanFilterItemsByTrait()
        {
            var filters = new XunitFilters();
            var method1 = new TestMethod("method1", "Display Name 1", MakeTraits("foo", "bar"));
            var method2 = new TestMethod("method2", "Display Name 2", MakeTraits("baz", "biff"));
            var method3 = new TestMethod("method3", "Display Name 3", traits: null);

            filters.IncludedTraits.AddValue("foo", "bar");

            Assert.True(filters.Filter(method1));
            Assert.False(filters.Filter(method2));
            Assert.False(filters.Filter(method3));
        }
コード例 #7
0
        public static void CanFilterFactsByFullName()
        {
            var filters = new XunitFilters();
            var method1 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name1");
            var method2 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name2");
            var method3 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name3");

            filters.IncludedMethods.Add("Namespace1.ClassInNamespace1+InnerClass1.Name1");

            Assert.True(filters.Filter(method1));
            Assert.False(filters.Filter(method2));
            Assert.False(filters.Filter(method3));
        }
コード例 #8
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void WildcardMatch_ExcludesMatchingMethod()
        {
            var filters = new XunitFilters();

            filters.ExcludedMethods.Add($"*.nAmE1");

            Assert.True(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
        }
コード例 #9
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void SingleFilter_ExcludesMatchingClass()
        {
            var filters = new XunitFilters();

            filters.ExcludedClasses.Add(typeof(InnerClass1).FullName !);

            Assert.True(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(InnerClass1Name1));
            Assert.False(filters.Filter(InnerClass1Name2));
            Assert.False(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
        }
コード例 #10
0
        public static void CanFilterItemsByTrait()
        {
            var filters            = new XunitFilters();
            var methodWithFooBar   = Mocks.TestCase <ClassUnderTest>("MethodWithFooBar");
            var methodWithBazBiff  = Mocks.TestCase <ClassUnderTest>("MethodWithBazBiff");
            var methodWithNoTraits = Mocks.TestCase <ClassUnderTest>("MethodWithNoTraits");

            filters.IncludedTraits.Add("foo", "bar");

            Assert.True(filters.Filter(methodWithFooBar));
            Assert.False(filters.Filter(methodWithBazBiff));
            Assert.False(filters.Filter(methodWithNoTraits));
        }
コード例 #11
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void ExactMatch_ExcludesMatchingMethod()
        {
            var filters = new XunitFilters();

            filters.ExcludedMethods.Add($"{typeof(InnerClass1).FullName}.{nameof(InnerClass1.Name1)}");

            Assert.True(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
        }
コード例 #12
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void MultipleFilters_ActsAsAndOperation()
        {
            var filters = new XunitFilters();

            filters.IncludedTraits.Add("fOo", "bAr");
            filters.IncludedTraits.Add("bAz", "bIff");

            Assert.False(filters.Filter(NonClassTest));
            Assert.False(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(MethodWithNoTraits));
            Assert.True(filters.Filter(MethodWithFooBarTrait));
            Assert.True(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #13
0
        public static void MultipleNameFiltersAreAnOrOperation()
        {
            var filters = new XunitFilters();
            var method1 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name1");
            var method2 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass1>("Name2");
            var method3 = Mocks.TestCase <Namespace1.ClassInNamespace1.InnerClass2>("Name3");

            filters.IncludedMethods.Add("Namespace1.ClassInNamespace1+InnerClass1.Name2");
            filters.IncludedClasses.Add("namespace1.classinnamespace1+InnerClass2");

            Assert.False(filters.Filter(method1));
            Assert.True(filters.Filter(method2));
            Assert.True(filters.Filter(method3));
        }
コード例 #14
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void MultipleFilters_ActsAsAndOperation()
        {
            var filters = new XunitFilters();

            filters.IncludedMethods.Add($"{typeof(InnerClass1).FullName}.{nameof(InnerClass1.Name1)}");
            filters.IncludedMethods.Add($"*.{nameof(InnerClass1.Name2).ToUpperInvariant()}");

            Assert.False(filters.Filter(NonClassTest));
            Assert.False(filters.Filter(NonMethodTest));
            Assert.True(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.False(filters.Filter(InnerClass1Name3));
            Assert.False(filters.Filter(InnerClass2Name3));
        }
コード例 #15
0
        public void MultipleTraitFiltersAreAnAndOperation()
        {
            var filters = new XunitFilters();
            var method1 = new TestMethod("method1", "Display Name 1", MakeTraits("foo", "bar"));
            var method2 = new TestMethod("method2", "Display Name 2", MakeTraits("baz", "biff"));
            var method3 = new TestMethod("method3", "Display Name 3", traits: null);

            filters.ExcludedTraits.AddValue("foo", "bar");
            filters.ExcludedTraits.AddValue("baz", "biff");

            Assert.False(filters.Filter(method1));
            Assert.False(filters.Filter(method2));
            Assert.True(filters.Filter(method3));
        }
コード例 #16
0
        public static void MultipleTraitFiltersAreAnAndOperation()
        {
            var filters            = new XunitFilters();
            var methodWithFooBar   = Mocks.TestCase <ClassUnderTest>("MethodWithFooBar");
            var methodWithBazBiff  = Mocks.TestCase <ClassUnderTest>("MethodWithBazBiff");
            var methodWithNoTraits = Mocks.TestCase <ClassUnderTest>("MethodWithNoTraits");

            filters.IncludedTraits.Add("fOo", "bAr");
            filters.IncludedTraits.Add("bAz", "bIff");

            Assert.True(filters.Filter(methodWithFooBar));
            Assert.True(filters.Filter(methodWithBazBiff));
            Assert.False(filters.Filter(methodWithNoTraits));
        }
コード例 #17
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void MultipleFilters_ActsAsAnOrOperation()
        {
            var filters = new XunitFilters();

            filters.ExcludedClasses.Add(typeof(InnerClass1).FullName !);
            filters.ExcludedClasses.Add(typeof(InnerClass2).FullName !.ToUpperInvariant());

            Assert.True(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(InnerClass1Name1));
            Assert.False(filters.Filter(InnerClass1Name2));
            Assert.False(filters.Filter(InnerClass1Name3));
            Assert.False(filters.Filter(InnerClass2Name3));
        }
コード例 #18
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void AlwaysPass()
        {
            var filters = new XunitFilters();

            Assert.True(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.True(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
            Assert.True(filters.Filter(MethodWithNoTraits));
            Assert.True(filters.Filter(MethodWithFooBarTrait));
            Assert.True(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #19
0
    public static int Main(string[] args)
    {
        var asm = typeof(SingleFileTestRunner).Assembly;

        Console.WriteLine("Running assembly:" + asm.FullName);

        var diagnosticSink = new ConsoleDiagnosticMessageSink();
        var testsFinished  = new TaskCompletionSource();
        var testSink       = new TestMessageSink();
        var summarySink    = new DelegatingExecutionSummarySink(testSink,
                                                                () => false,
                                                                (completed, summary) => Console.WriteLine($"Tests run: {summary.Total}, Errors: {summary.Errors}, Failures: {summary.Failed}, Skipped: {summary.Skipped}. Time: {TimeSpan.FromSeconds((double)summary.Time).TotalSeconds}s"));
        var resultsXmlAssembly = new XElement("assembly");
        var resultsSink        = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);

        testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
        testSink.Execution.TestFailedEvent  += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{Xunit.ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{Xunit.ExceptionUtility.CombineStackTraces(args.Message)}"); };

        testSink.Execution.TestAssemblyFinishedEvent += args =>
        {
            Console.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}");
            testsFinished.SetResult();
        };

        var xunitTestFx = new SingleFileTestRunner(diagnosticSink);
        var asmInfo     = Reflector.Wrap(asm);
        var asmName     = asm.GetName();

        var discoverySink = new TestDiscoverySink();
        var discoverer    = xunitTestFx.CreateDiscoverer(asmInfo);

        discoverer.Find(false, discoverySink, TestFrameworkOptions.ForDiscovery());
        discoverySink.Finished.WaitOne();
        XunitFilters filters = new XunitFilters();

        filters.ExcludedTraits.Add("category", new List <string> {
            "failing"
        });
        var filteredTestCases = discoverySink.TestCases.Where(filters.Filter).ToList();
        var executor          = xunitTestFx.CreateExecutor(asmName);

        executor.RunTests(filteredTestCases, resultsSink, TestFrameworkOptions.ForExecution());

        resultsSink.Finished.WaitOne();

        var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;

        return(failed ? 1 : 0);
    }
コード例 #20
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void SingleFilter_ExcludesMatchingClass()
        {
            var filters = new XunitFilters();

            filters.IncludedNamespaces.Add(typeof(InnerClass1).Namespace !);

            Assert.False(filters.Filter(NonClassTest));
            Assert.False(filters.Filter(NonMethodTest));
            Assert.True(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
            Assert.False(filters.Filter(MethodWithNoTraits));
            Assert.False(filters.Filter(MethodWithFooBarTrait));
            Assert.False(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #21
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void ActsAsAnAndOperation()
        {
            var filters = new XunitFilters();

            filters.IncludedClasses.Add(typeof(InnerClass1).FullName !);
            filters.IncludedMethods.Add("*.nAmE3");

            Assert.False(filters.Filter(NonClassTest));
            Assert.False(filters.Filter(NonMethodTest));
            Assert.False(filters.Filter(InnerClass1Name1));
            Assert.False(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.False(filters.Filter(InnerClass2Name3));
            Assert.False(filters.Filter(MethodWithNoTraits));
            Assert.False(filters.Filter(MethodWithFooBarTrait));
            Assert.False(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #22
0
ファイル: XunitFiltersTests.cs プロジェクト: jbhensley/xunit
        public static void MultipleFilters_ActsAsAnOrOperation()
        {
            var filters = new XunitFilters();

            filters.IncludedNamespaces.Add(typeof(InnerClass1).Namespace !);
            filters.IncludedNamespaces.Add(typeof(ClassWithTraits).Namespace !.ToUpperInvariant());

            Assert.False(filters.Filter(NonClassTest));
            Assert.True(filters.Filter(NonMethodTest));
            Assert.True(filters.Filter(InnerClass1Name1));
            Assert.True(filters.Filter(InnerClass1Name2));
            Assert.True(filters.Filter(InnerClass1Name3));
            Assert.True(filters.Filter(InnerClass2Name3));
            Assert.True(filters.Filter(MethodWithNoTraits));
            Assert.True(filters.Filter(MethodWithFooBarTrait));
            Assert.True(filters.Filter(MethodWithBazBiffTrait));
        }
コード例 #23
0
ファイル: runner.cs プロジェクト: stjordanis/mono
    public static XunitFilters ParseArgumentsToFilter(Stack <string> arguments)
    {
        var filters = new XunitFilters();

        while (arguments.Count > 0)
        {
            var option = arguments.Pop();
            if (option.StartsWith("@"))                 // response file handling
            {
                var fileName    = option.Substring(1);
                var fileContent = File.ReadAllLines(fileName);
                foreach (var line in fileContent)
                {
                    if (line.StartsWith("#") || String.IsNullOrWhiteSpace(line))
                    {
                        continue;
                    }

                    var parts = line.Split(" ", StringSplitOptions.RemoveEmptyEntries);
                    for (var i = parts.Length - 1; i >= 0; i--)
                    {
                        arguments.Push(parts[i]);
                    }
                }
                continue;
            }

            switch (option)
            {
            case "-nomethod": filters.ExcludedMethods.Add(arguments.Pop()); break;

            case "-noclass": filters.ExcludedClasses.Add(arguments.Pop()); break;

            case "-nonamespace": filters.ExcludedNamespaces.Add(arguments.Pop()); break;

            case "-notrait": ParseEqualSeparatedArgument(filters.ExcludedTraits, arguments.Pop()); break;

            default: throw new ArgumentException($"Not supported option: '{option}'");
            }
            ;
        }

        return(filters);
    }
コード例 #24
0
ファイル: Program.cs プロジェクト: redoz/xunit
        static XElement ExecuteAssembly(object consoleLock, string defaultDirectory, XunitProjectAssembly assembly, bool needsXml, bool teamCity, bool appVeyor, bool?parallelizeTestCollections, int?maxThreadCount, XunitFilters filters)
        {
            if (cancel)
            {
                return(null);
            }

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                {
                    return(null);
                }

                var discoveryOptions = new XunitDiscoveryOptions(assembly.Configuration);
                var executionOptions = new XunitExecutionOptions(assembly.Configuration);
                if (maxThreadCount.HasValue)
                {
                    executionOptions.MaxParallelThreads = maxThreadCount.GetValueOrDefault();
                }
                if (parallelizeTestCollections.HasValue)
                {
                    executionOptions.DisableParallelization = !parallelizeTestCollections.GetValueOrDefault();
                }

                lock (consoleLock)
                {
                    if (assembly.Configuration.DiagnosticMessages)
                    {
                        Console.WriteLine("Discovering: {0} (method display = {1}, parallel test collections = {2}, max threads = {3})",
                                          Path.GetFileNameWithoutExtension(assembly.AssemblyFilename),
                                          discoveryOptions.MethodDisplay,
                                          !executionOptions.DisableParallelization,
                                          executionOptions.MaxParallelThreads);
                    }
                    else
                    {
                        Console.WriteLine("Discovering: {0}", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));
                    }
                }

                using (var controller = new XunitFrontController(assembly.AssemblyFilename, assembly.ConfigFilename, assembly.ShadowCopy))
                    using (var discoveryVisitor = new TestDiscoveryVisitor())
                    {
                        controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, discoveryOptions: discoveryOptions);
                        discoveryVisitor.Finished.WaitOne();

                        lock (consoleLock)
                            Console.WriteLine("Discovered:  {0}", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));

                        var resultsVisitor    = CreateVisitor(consoleLock, defaultDirectory, assemblyElement, teamCity, appVeyor);
                        var filteredTestCases = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                        if (filteredTestCases.Count == 0)
                        {
                            lock (consoleLock)
                            {
                                Console.ForegroundColor = ConsoleColor.Red;
                                Console.WriteLine("ERROR:       {0} has no tests to run", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));
                                Console.ForegroundColor = ConsoleColor.Gray;
                            }
                        }
                        else
                        {
                            controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                            resultsVisitor.Finished.WaitOne();
                        }
                    }
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType().FullName, ex.Message);
                failed = true;
            }

            return(assemblyElement);
        }
コード例 #25
0
        public async Task <int> Run(string assemblyFileName, bool printXml, XunitFilters filters)
        {
            var configuration = new TestAssemblyConfiguration()
            {
                ShadowCopy = false, ParallelizeAssembly = false, ParallelizeTestCollections = false, MaxParallelThreads = 1, PreEnumerateTheories = false
            };
            var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
            var discoverySink    = new TestDiscoverySink();
            var diagnosticSink   = new ConsoleDiagnosticMessageSink();
            var testOptions      = TestFrameworkOptions.ForExecution(configuration);
            var testSink         = new TestMessageSink();
            var controller       = new Xunit2(AppDomainSupport.Denied, new NullSourceInformationProvider(), assemblyFileName, configFileName: null, shadowCopy: false, shadowCopyFolder: null, diagnosticMessageSink: diagnosticSink, verifyTestAssemblyExists: false);

            discoveryOptions.SetSynchronousMessageReporting(true);
            testOptions.SetSynchronousMessageReporting(true);

            Console.WriteLine($"Discovering: {assemblyFileName} (method display = {discoveryOptions.GetMethodDisplayOrDefault()}, method display options = {discoveryOptions.GetMethodDisplayOptionsOrDefault()})");
            var assembly     = Assembly.LoadFrom(assemblyFileName);
            var assemblyInfo = new global::Xunit.Sdk.ReflectionAssemblyInfo(assembly);
            var discoverer   = new ThreadlessXunitDiscoverer(assemblyInfo, new NullSourceInformationProvider(), discoverySink);

            discoverer.FindWithoutThreads(includeSourceInformation: false, discoverySink, discoveryOptions);
            discoverySink.Finished.WaitOne();
            var testCasesToRun = discoverySink.TestCases.Where(filters.Filter).ToList();

            Console.WriteLine($"Discovered:  {assemblyFileName} (found {testCasesToRun.Count} of {discoverySink.TestCases.Count} test cases)");

            var summarySink        = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { Console.WriteLine($"{Environment.NewLine}=== TEST EXECUTION SUMMARY ==={Environment.NewLine}Total: {summary.Total}, Errors: 0, Failed: {summary.Failed}, Skipped: {summary.Skipped}, Time: {TimeSpan.FromSeconds((double)summary.Time).TotalSeconds}s{Environment.NewLine}"); });
            var resultsXmlAssembly = new XElement("assembly");
            var resultsSink        = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);

            if (Environment.GetEnvironmentVariable("XHARNESS_LOG_TEST_START") != null)
            {
                testSink.Execution.TestStartingEvent += args => { Console.WriteLine($"[STRT] {args.Message.Test.DisplayName}"); };
            }
            testSink.Execution.TestPassedEvent  += args => { Console.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); };
            testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
            testSink.Execution.TestFailedEvent  += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces(args.Message)}"); };

            testSink.Execution.TestAssemblyStartingEvent += args => { Console.WriteLine($"Starting:    {assemblyFileName}"); };
            testSink.Execution.TestAssemblyFinishedEvent += args => { Console.WriteLine($"Finished:    {assemblyFileName}"); };

            controller.RunTests(testCasesToRun, resultsSink, testOptions);

            while (!resultsSink.Finished.WaitOne(0))
            {
                await Task.Delay(1);
            }

            if (printXml)
            {
                Console.WriteLine($"STARTRESULTXML");
                var resultsXml = new XElement("assemblies");
                resultsXml.Add(resultsXmlAssembly);
                resultsXml.Save(Console.OpenStandardOutput());
                Console.WriteLine();
                Console.WriteLine($"ENDRESULTXML");
            }

            var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;

            return(failed ? 1 : 0);
        }
コード例 #26
0
        public int Run(string assemblyFileName, bool printXml, XunitFilters filters)
        {
            var configuration = new TestAssemblyConfiguration()
            {
                ShadowCopy = false, ParallelizeAssembly = false, ParallelizeTestCollections = false, MaxParallelThreads = 1, PreEnumerateTheories = false
            };
            var discoveryOptions = TestFrameworkOptions.ForDiscovery(configuration);
            var discoverySink    = new TestDiscoverySink();
            var diagnosticSink   = new ConsoleDiagnosticMessageSink();
            var testOptions      = TestFrameworkOptions.ForExecution(configuration);
            var testSink         = new TestMessageSink();
            var controller       = new Xunit2(AppDomainSupport.Denied, new NullSourceInformationProvider(), assemblyFileName, configFileName: null, shadowCopy: false, shadowCopyFolder: null, diagnosticMessageSink: diagnosticSink, verifyTestAssemblyExists: false);

            discoveryOptions.SetSynchronousMessageReporting(true);
            testOptions.SetSynchronousMessageReporting(true);

            Console.WriteLine($"Discovering tests for {assemblyFileName}");
            var assembly     = Assembly.LoadFrom(assemblyFileName);
            var assemblyInfo = new global::Xunit.Sdk.ReflectionAssemblyInfo(assembly);
            var discoverer   = new ThreadlessXunitDiscoverer(assemblyInfo, new NullSourceInformationProvider(), discoverySink);

            discoverer.FindWithoutThreads(includeSourceInformation: false, discoverySink, discoveryOptions);
            discoverySink.Finished.WaitOne();
            var testCasesToRun = discoverySink.TestCases.Where(filters.Filter).ToList();

            Console.WriteLine($"Discovery finished.");

            var summarySink        = new DelegatingExecutionSummarySink(testSink, () => false, (completed, summary) => { Console.WriteLine($"Tests run: {summary.Total}, Errors: 0, Failures: {summary.Failed}, Skipped: {summary.Skipped}. Time: {TimeSpan.FromSeconds((double)summary.Time).TotalSeconds}s"); });
            var resultsXmlAssembly = new XElement("assembly");
            var resultsSink        = new DelegatingXmlCreationSink(summarySink, resultsXmlAssembly);

            testSink.Execution.TestPassedEvent  += args => { Console.WriteLine($"[PASS] {args.Message.Test.DisplayName}"); };
            testSink.Execution.TestSkippedEvent += args => { Console.WriteLine($"[SKIP] {args.Message.Test.DisplayName}"); };
            testSink.Execution.TestFailedEvent  += args => { Console.WriteLine($"[FAIL] {args.Message.Test.DisplayName}{Environment.NewLine}{ExceptionUtility.CombineMessages(args.Message)}{Environment.NewLine}{ExceptionUtility.CombineStackTraces(args.Message)}"); };

            testSink.Execution.TestAssemblyStartingEvent += args => { Console.WriteLine($"Running tests for {args.Message.TestAssembly.Assembly}"); };
            testSink.Execution.TestAssemblyFinishedEvent += args => { Console.WriteLine($"Finished {args.Message.TestAssembly.Assembly}{Environment.NewLine}"); };

            controller.RunTests(testCasesToRun, resultsSink, testOptions);
            var threadpoolPump = typeof(ThreadPool).GetMethod("PumpThreadPool", BindingFlags.NonPublic | BindingFlags.Static);

            if (threadpoolPump != null)
            {
                while (!resultsSink.Finished.WaitOne(0))
                {
                    threadpoolPump.Invoke(this, null);
                }
            }
            else
            {
                resultsSink.Finished.WaitOne();
            }

            if (printXml)
            {
                Console.WriteLine($"STARTRESULTXML");
                var resultsXml = new XElement("assemblies");
                resultsXml.Add(resultsXmlAssembly);
                resultsXml.Save(Console.OpenStandardOutput());
                Console.WriteLine();
                Console.WriteLine($"ENDRESULTXML");
            }

            var failed = resultsSink.ExecutionSummary.Failed > 0 || resultsSink.ExecutionSummary.Errors > 0;

            return(failed ? 1 : 0);
        }
コード例 #27
0
ファイル: Program.cs プロジェクト: zabulus/xunit
        static XElement ExecuteAssembly(object consoleLock,
                                        XunitProjectAssembly assembly,
                                        bool serialize,
                                        bool needsXml,
                                        bool?parallelizeTestCollections,
                                        int?maxThreadCount,
                                        bool diagnosticMessages,
                                        bool noColor,
                                        bool noAppDomain,
                                        bool failSkips,
                                        XunitFilters filters)
        {
            if (cancel)
            {
                return(null);
            }

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                {
                    return(null);
                }

                // Turn off pre-enumeration of theories, since there is no theory selection UI in this runner
                assembly.Configuration.PreEnumerateTheories = false;
                assembly.Configuration.DiagnosticMessages  |= diagnosticMessages;

                if (noAppDomain)
                {
                    assembly.Configuration.AppDomain = AppDomainSupport.Denied;
                }

                // Setup discovery and execution options with command-line overrides
                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                if (maxThreadCount.HasValue)
                {
                    executionOptions.SetMaxParallelThreads(maxThreadCount);
                }
                if (parallelizeTestCollections.HasValue)
                {
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());
                }

                var assemblyDisplayName      = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
                var diagnosticMessageVisitor = new DiagnosticMessageVisitor(consoleLock, assemblyDisplayName, assembly.Configuration.DiagnosticMessagesOrDefault, noColor);
                var appDomainSupport         = assembly.Configuration.AppDomainOrDefault;
                var shadowCopy = assembly.Configuration.ShadowCopyOrDefault;

                using (var controller = new XunitFrontController(appDomainSupport, assembly.AssemblyFilename, assembly.ConfigFilename, shadowCopy, diagnosticMessageSink: diagnosticMessageVisitor))
                    using (var discoveryVisitor = new TestDiscoveryVisitor())
                    {
                        // Discover & filter the tests
                        reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(assembly, controller.CanUseAppDomains && appDomainSupport != AppDomainSupport.Denied, shadowCopy, discoveryOptions));

                        controller.Find(false, discoveryVisitor, discoveryOptions);
                        discoveryVisitor.Finished.WaitOne();

                        var testCasesDiscovered = discoveryVisitor.TestCases.Count;
                        var filteredTestCases   = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                        var testCasesToRun      = filteredTestCases.Count;

                        reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));

                        // Run the filtered tests
                        if (testCasesToRun == 0)
                        {
                            completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());
                        }
                        else
                        {
                            if (serialize)
                            {
                                filteredTestCases = filteredTestCases.Select(controller.Serialize).Select(controller.Deserialize).ToList();
                            }

                            reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));

                            IExecutionVisitor resultsVisitor = new XmlAggregateVisitor(reporterMessageHandler, completionMessages, assemblyElement, () => cancel);
                            if (failSkips)
                            {
                                resultsVisitor = new FailSkipVisitor(resultsVisitor);
                            }

                            controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                            resultsVisitor.Finished.WaitOne();

                            reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsVisitor.ExecutionSummary));
                        }
                    }
            }
            catch (Exception ex)
            {
                failed = true;

                var e = ex;
                while (e != null)
                {
                    Console.WriteLine($"{e.GetType().FullName}: {e.Message}");
                    e = e.InnerException;
                }
            }

            return(assemblyElement);
        }
コード例 #28
0
        XElement ExecuteAssembly(object consoleLock,
                                 XunitProjectAssembly assembly,
                                 bool serialize,
                                 bool needsXml,
                                 bool?parallelizeTestCollections,
                                 int?maxThreadCount,
                                 bool diagnosticMessages,
                                 bool noColor,
                                 AppDomainSupport?appDomains,
                                 bool failSkips,
                                 bool stopOnFail,
                                 XunitFilters filters,
                                 bool internalDiagnosticMessages)
        {
            if (cancel)
            {
                return(null);
            }

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                {
                    return(null);
                }

                // Turn off pre-enumeration of theories, since there is no theory selection UI in this runner
                assembly.Configuration.PreEnumerateTheories        = false;
                assembly.Configuration.DiagnosticMessages         |= diagnosticMessages;
                assembly.Configuration.InternalDiagnosticMessages |= internalDiagnosticMessages;

                if (appDomains.HasValue)
                {
                    assembly.Configuration.AppDomain = appDomains;
                }

                // Setup discovery and execution options with command-line overrides
                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                executionOptions.SetStopOnTestFail(stopOnFail);
                if (maxThreadCount.HasValue)
                {
                    executionOptions.SetMaxParallelThreads(maxThreadCount);
                }
                if (parallelizeTestCollections.HasValue)
                {
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());
                }

                var assemblyDisplayName            = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
                var diagnosticMessageSink          = DiagnosticMessageSink.ForDiagnostics(consoleLock, assemblyDisplayName, assembly.Configuration.DiagnosticMessagesOrDefault, noColor);
                var internalDiagnosticsMessageSink = DiagnosticMessageSink.ForInternalDiagnostics(consoleLock, assemblyDisplayName, assembly.Configuration.InternalDiagnosticMessagesOrDefault, noColor);
                var appDomainSupport   = assembly.Configuration.AppDomainOrDefault;
                var shadowCopy         = assembly.Configuration.ShadowCopyOrDefault;
                var longRunningSeconds = assembly.Configuration.LongRunningTestSecondsOrDefault;

                using (AssemblyHelper.SubscribeResolveForAssembly(assembly.AssemblyFilename, internalDiagnosticsMessageSink))
                    using (var controller = new XunitFrontController(appDomainSupport, assembly.AssemblyFilename, assembly.ConfigFilename, shadowCopy, diagnosticMessageSink: diagnosticMessageSink))
                        using (var discoverySink = new TestDiscoverySink(() => cancel))
                        {
                            // Discover & filter the tests
                            reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(assembly, controller.CanUseAppDomains && appDomainSupport != AppDomainSupport.Denied, shadowCopy, discoveryOptions));

                            controller.Find(false, discoverySink, discoveryOptions);
                            discoverySink.Finished.WaitOne();

                            var testCasesDiscovered = discoverySink.TestCases.Count;
                            var filteredTestCases   = discoverySink.TestCases.Where(filters.Filter).ToList();
                            var testCasesToRun      = filteredTestCases.Count;

                            reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));

                            // Run the filtered tests
                            if (testCasesToRun == 0)
                            {
                                completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());
                            }
                            else
                            {
                                if (serialize)
                                {
                                    filteredTestCases = filteredTestCases.Select(controller.Serialize).Select(controller.Deserialize).ToList();
                                }

                                reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));

                                IExecutionSink resultsSink = new DelegatingExecutionSummarySink(reporterMessageHandler, () => cancel, (path, summary) => completionMessages.TryAdd(path, summary), logger);
                                if (assemblyElement != null)
                                {
                                    logger.LogMessage($"Adding DelegatingXmlCreationSink");
                                    resultsSink = new DelegatingXmlCreationSink(resultsSink, assemblyElement, logger);
                                }
                                if (longRunningSeconds > 0)
                                {
                                    resultsSink = new DelegatingLongRunningTestDetectionSink(resultsSink, TimeSpan.FromSeconds(longRunningSeconds), MessageSinkWithTypesAdapter.Wrap(diagnosticMessageSink));
                                }
                                if (failSkips)
                                {
                                    resultsSink = new DelegatingFailSkipSink(resultsSink);
                                }

                                controller.RunTests(filteredTestCases, resultsSink, executionOptions);
                                resultsSink.Finished.WaitOne();


                                reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsSink.ExecutionSummary));
                                if (stopOnFail && resultsSink.ExecutionSummary.Failed != 0)
                                {
                                    Console.WriteLine("Canceling due to test failure...");
                                    cancel = true;
                                }
                            }
                        }
            }
            catch (Exception ex)
            {
                failed = true;

                var e = ex;
                while (e != null)
                {
                    Console.WriteLine($"{e.GetType().FullName}: {e.Message}");

                    if (internalDiagnosticMessages)
                    {
                        Console.WriteLine(e.StackTrace);
                    }

                    e = e.InnerException;
                }
            }

            logger.LogMessage($"ExecuteAssembly: {assemblyElement}");
            return(assemblyElement);
        }
コード例 #29
0
ファイル: Program.cs プロジェクト: ursenzler/xunit
        static XElement ExecuteAssembly(object consoleLock,
                                        XunitProjectAssembly assembly,
                                        bool serialize,
                                        bool needsXml,
                                        bool? parallelizeTestCollections,
                                        int? maxThreadCount,
                                        bool diagnosticMessages,
                                        bool noColor,
                                        bool noAppDomain,
                                        bool failSkips,
                                        XunitFilters filters)
        {
            if (cancel)
                return null;

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                    return null;

                // Turn off pre-enumeration of theories, since there is no theory selection UI in this runner
                assembly.Configuration.PreEnumerateTheories = false;
                assembly.Configuration.DiagnosticMessages |= diagnosticMessages;

                if (noAppDomain)
                    assembly.Configuration.AppDomain = AppDomainSupport.Denied;

                // Setup discovery and execution options with command-line overrides
                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                if (maxThreadCount.HasValue)
                    executionOptions.SetMaxParallelThreads(maxThreadCount);
                if (parallelizeTestCollections.HasValue)
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());

                var assemblyDisplayName = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
                var diagnosticMessageVisitor = new DiagnosticMessageVisitor(consoleLock, assemblyDisplayName, assembly.Configuration.DiagnosticMessagesOrDefault, noColor);
                var appDomainSupport = assembly.Configuration.AppDomainOrDefault;

                using (var controller = new XunitFrontController(appDomainSupport, assembly.AssemblyFilename, assembly.ConfigFilename, assembly.ShadowCopy, diagnosticMessageSink: diagnosticMessageVisitor))
                using (var discoveryVisitor = new TestDiscoveryVisitor())
                {
                    // Discover & filter the tests
                    reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(assembly, controller.CanUseAppDomains && appDomainSupport != AppDomainSupport.Denied, discoveryOptions));

                    controller.Find(false, discoveryVisitor, discoveryOptions);
                    discoveryVisitor.Finished.WaitOne();

                    var testCasesDiscovered = discoveryVisitor.TestCases.Count;
                    var filteredTestCases = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                    var testCasesToRun = filteredTestCases.Count;

                    reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));

                    // Run the filtered tests
                    if (testCasesToRun == 0)
                        completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());
                    else
                    {
                        if (serialize)
                            filteredTestCases = filteredTestCases.Select(controller.Serialize).Select(controller.Deserialize).ToList();

                        reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));

                        IExecutionVisitor resultsVisitor = new XmlAggregateVisitor(reporterMessageHandler, completionMessages, assemblyElement, () => cancel);
                        if (failSkips)
                            resultsVisitor = new FailSkipVisitor(resultsVisitor);

                        controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                        resultsVisitor.Finished.WaitOne();

                        reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsVisitor.ExecutionSummary));
                    }
                }
            }
            catch (Exception ex)
            {
                failed = true;

                var e = ex;
                while (e != null)
                {
                    Console.WriteLine($"{e.GetType().FullName}: {e.Message}");
                    e = e.InnerException;
                }
            }

            return assemblyElement;
        }
コード例 #30
0
        XElement ExecuteAssembly(object consoleLock,
                                 XunitProjectAssembly assembly,
                                 bool needsXml,
                                 bool?parallelizeTestCollections,
                                 int?maxThreadCount,
                                 bool diagnosticMessages,
                                 bool noColor,
                                 XunitFilters filters,
                                 bool designTime,
                                 bool listTestCases,
                                 IReadOnlyList <string> designTimeFullyQualifiedNames)
        {
            if (cancel)
            {
                return(null);
            }

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                // Turn off pre-enumeration of theories when we're not running in Visual Studio
                if (!designTime)
                {
                    assembly.Configuration.PreEnumerateTheories = false;
                }

                if (diagnosticMessages)
                {
                    assembly.Configuration.DiagnosticMessages = true;
                }

                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                if (maxThreadCount.HasValue)
                {
                    executionOptions.SetMaxParallelThreads(maxThreadCount);
                }
                if (parallelizeTestCollections.HasValue)
                {
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());
                }

                var assemblyDisplayName       = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
                var diagnosticMessageVisitor  = new DiagnosticMessageVisitor(consoleLock, assemblyDisplayName, assembly.Configuration.DiagnosticMessagesOrDefault, noColor);
                var sourceInformationProvider = new SourceInformationProviderAdapater(testHostServices?.SourceInformationProvider);

                using (var controller = new XunitFrontController(AppDomainSupport.Denied, assembly.AssemblyFilename, assembly.ConfigFilename, false, diagnosticMessageSink: diagnosticMessageVisitor, sourceInformationProvider: sourceInformationProvider))
                    using (var discoveryVisitor = new TestDiscoveryVisitor())
                    {
                        var includeSourceInformation = designTime && listTestCases;

                        // Discover & filter the tests
                        reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(assembly, false, false, discoveryOptions));

                        controller.Find(includeSourceInformation: includeSourceInformation, messageSink: discoveryVisitor, discoveryOptions: discoveryOptions);
                        discoveryVisitor.Finished.WaitOne();

                        IDictionary <ITestCase, VsTestCase> vsTestCases = null;
                        if (designTime)
                        {
                            vsTestCases = DesignTimeTestConverter.Convert(discoveryVisitor.TestCases);
                        }

                        if (listTestCases)
                        {
                            lock (consoleLock)
                            {
                                if (designTime)
                                {
                                    var sink = testHostServices.TestDiscoverySink;

                                    foreach (var testcase in vsTestCases.Values)
                                    {
                                        if (sink != null)
                                        {
                                            sink.SendTest(testcase);
                                        }

                                        Console.WriteLine(testcase.FullyQualifiedName);
                                    }
                                }
                                else
                                {
                                    foreach (var testcase in discoveryVisitor.TestCases)
                                    {
                                        Console.WriteLine(testcase.DisplayName);
                                    }
                                }
                            }

                            return(assemblyElement);
                        }

                        IExecutionVisitor resultsVisitor;

                        if (designTime)
                        {
                            resultsVisitor = new DesignTimeExecutionVisitor(testHostServices.TestExecutionSink, vsTestCases, reporterMessageHandler);
                        }
                        else
                        {
                            resultsVisitor = new XmlAggregateVisitor(reporterMessageHandler, completionMessages, assemblyElement, () => cancel);
                        }

                        IList <ITestCase> filteredTestCases;
                        var testCasesDiscovered = discoveryVisitor.TestCases.Count;
                        if (!designTime || designTimeFullyQualifiedNames.Count == 0)
                        {
                            filteredTestCases = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                        }
                        else
                        {
                            filteredTestCases = vsTestCases.Where(t => designTimeFullyQualifiedNames.Contains(t.Value.FullyQualifiedName)).Select(t => t.Key).ToList();
                        }
                        var testCasesToRun = filteredTestCases.Count;

                        reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));

                        if (filteredTestCases.Count == 0)
                        {
                            completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());
                        }
                        else
                        {
                            reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));

                            controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                            resultsVisitor.Finished.WaitOne();

                            reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsVisitor.ExecutionSummary));
                        }
                    }
            }
            catch (Exception ex)
            {
                failed = true;

                var e = ex;
                while (e != null)
                {
                    Console.WriteLine("{0}: {1}", e.GetType().FullName, e.Message);
                    e = e.InnerException;
                }
            }

            return(assemblyElement);
        }
コード例 #31
0
        static XElement ExecuteAssembly(object consoleLock, string defaultDirectory, XunitProjectAssembly assembly, bool needsXml, bool teamCity, bool appVeyor, bool silent, bool parallelizeTestCollections, int maxThreadCount, XunitFilters filters)
        {
            if (cancel)
            {
                return(null);
            }

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                {
                    return(null);
                }

                using (var controller = new XunitFrontController(assembly.AssemblyFilename, assembly.ConfigFilename, assembly.ShadowCopy))
                    using (var discoveryVisitor = new TestDiscoveryVisitor())
                    {
                        controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, options: new TestFrameworkOptions());
                        discoveryVisitor.Finished.WaitOne();

                        var executionOptions = new XunitExecutionOptions {
                            DisableParallelization = !parallelizeTestCollections, MaxParallelThreads = maxThreadCount
                        };
                        var resultsVisitor = CreateVisitor(consoleLock, defaultDirectory, assemblyElement, teamCity, appVeyor, silent);
                        controller.RunTests(discoveryVisitor.TestCases.Where(filters.Filter).ToList(), resultsVisitor, executionOptions);
                        resultsVisitor.Finished.WaitOne();
                    }
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType().FullName, ex.Message);
                failed = true;
            }

            return(assemblyElement);
        }
コード例 #32
0
ファイル: Program.cs プロジェクト: ChadNedzlek/buildtools
        static XElement ExecuteAssembly(object consoleLock, string defaultDirectory, XunitProjectAssembly assembly, bool needsXml, bool teamCity, bool appVeyor, bool showProgress, bool? parallelizeTestCollections, int? maxThreadCount, XunitFilters filters)
        {
            if (cancel)
                return null;

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                    return null;

                // Turn off pre-enumeration of theories, since there is no theory selection UI in this runner
                assembly.Configuration.PreEnumerateTheories = false;

                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                if (maxThreadCount.HasValue)
                    executionOptions.SetMaxParallelThreads(maxThreadCount.GetValueOrDefault());
                if (parallelizeTestCollections.HasValue)
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());

                lock (consoleLock)
                {
                    if (assembly.Configuration.DiagnosticMessages ?? false)
                        Console.WriteLine("Discovering: {0} (method display = {1}, parallel test collections = {2}, max threads = {3})",
                                          Path.GetFileNameWithoutExtension(assembly.AssemblyFilename),
                                          discoveryOptions.GetMethodDisplay(),
                                          !executionOptions.GetDisableParallelization(),
                                          executionOptions.GetMaxParallelThreads());
                    else
                        Console.WriteLine("Discovering: {0}", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));
                }

                using (var controller = new XunitFrontController(AppDomainSupport.Denied, assembly.AssemblyFilename, assembly.ConfigFilename, assembly.Configuration.ShadowCopyOrDefault))
                using (var discoveryVisitor = new TestDiscoveryVisitor())
                {
                    controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, discoveryOptions: discoveryOptions);
                    discoveryVisitor.Finished.WaitOne();

                    lock (consoleLock)
                    {
                        Console.WriteLine("Discovered:  {0}", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));
                    }

                    var resultsVisitor = CreateVisitor(consoleLock, defaultDirectory, assemblyElement, teamCity, appVeyor, showProgress);
                    var filteredTestCases = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                    if (filteredTestCases.Count == 0)
                    {
                        lock (consoleLock)
                        {
                            Console.ForegroundColor = ConsoleColor.DarkYellow;
                            Console.WriteLine("Info:        {0} has no tests to run", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));
                            Console.ForegroundColor = ConsoleColor.Gray;
                        }
                    }
                    else
                    {
                        controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                        resultsVisitor.Finished.WaitOne();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType().FullName, ex.Message);
                failed = true;
            }

            return assemblyElement;
        }
コード例 #33
0
ファイル: Program.cs プロジェクト: kouweizhong/xunit
        static XElement ExecuteAssembly(object consoleLock, string defaultDirectory, XunitProjectAssembly assembly, bool needsXml, bool teamCity, bool appVeyor, bool silent, bool parallelizeTestCollections, int maxThreadCount, XunitFilters filters)
        {
            if (cancel)
                return null;

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                    return null;

                using (var controller = new XunitFrontController(assembly.AssemblyFilename, assembly.ConfigFilename, assembly.ShadowCopy))
                using (var discoveryVisitor = new TestDiscoveryVisitor())
                {
                    controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, options: new TestFrameworkOptions());
                    discoveryVisitor.Finished.WaitOne();

                    var executionOptions = new XunitExecutionOptions { DisableParallelization = !parallelizeTestCollections, MaxParallelThreads = maxThreadCount };
                    var resultsVisitor = CreateVisitor(consoleLock, defaultDirectory, assemblyElement, teamCity, appVeyor, silent);
                    controller.RunTests(discoveryVisitor.TestCases.Where(filters.Filter).ToList(), resultsVisitor, executionOptions);
                    resultsVisitor.Finished.WaitOne();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0}: {1}", ex.GetType().FullName, ex.Message);
                failed = true;
            }

            return assemblyElement;
        }
コード例 #34
0
ファイル: Program.cs プロジェクト: MichalisN/xunit
        static XElement ExecuteAssembly(object consoleLock,
                                        string defaultDirectory,
                                        XunitProjectAssembly assembly,
                                        bool quiet,
                                        bool serialize,
                                        bool needsXml,
                                        bool teamCity,
                                        bool appVeyor,
                                        bool? parallelizeTestCollections,
                                        int? maxThreadCount,
                                        bool diagnosticMessages,
                                        XunitFilters filters)
        {
            if (cancel)
                return null;

            var assemblyElement = needsXml ? new XElement("assembly") : null;

            try
            {
                if (!ValidateFileExists(consoleLock, assembly.AssemblyFilename) || !ValidateFileExists(consoleLock, assembly.ConfigFilename))
                    return null;

                if (diagnosticMessages)
                    assembly.Configuration.DiagnosticMessages = true;

                var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
                var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
                if (maxThreadCount.HasValue && maxThreadCount.Value > -1)
                    executionOptions.SetMaxParallelThreads(maxThreadCount.GetValueOrDefault());
                if (parallelizeTestCollections.HasValue)
                    executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());

                var assemblyDisplayName = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);

                if (!quiet)
                    lock (consoleLock)
                    {
                        if (assembly.Configuration.DiagnosticMessagesOrDefault)
                            Console.WriteLine("Discovering: {0} (method display = {1}, parallel test collections = {2}, max threads = {3})",
                                              assemblyDisplayName,
                                              discoveryOptions.GetMethodDisplayOrDefault(),
                                              !executionOptions.GetDisableParallelizationOrDefault(),
                                              executionOptions.GetMaxParallelThreadsOrDefault());
                        else
                            Console.WriteLine("Discovering: {0}", assemblyDisplayName);
                    }

                var diagnosticMessageVisitor = new DiagnosticMessageVisitor(consoleLock, assemblyDisplayName, assembly.Configuration.DiagnosticMessagesOrDefault);

                using (var controller = new XunitFrontController(assembly.AssemblyFilename, assembly.ConfigFilename, assembly.ShadowCopy, diagnosticMessageSink: diagnosticMessageVisitor))
                using (var discoveryVisitor = new TestDiscoveryVisitor())
                {
                    controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, discoveryOptions: discoveryOptions);
                    discoveryVisitor.Finished.WaitOne();

                    if (!quiet)
                        lock (consoleLock)
                            Console.WriteLine("Discovered:  {0}", Path.GetFileNameWithoutExtension(assembly.AssemblyFilename));

                    var filteredTestCases = discoveryVisitor.TestCases.Where(filters.Filter).ToList();
                    if (filteredTestCases.Count == 0)
                        completionMessages.TryAdd(Path.GetFileName(assembly.AssemblyFilename), new ExecutionSummary());
                    else
                    {
                        if (serialize)
                            filteredTestCases = filteredTestCases.Select(controller.Serialize).Select(controller.Deserialize).ToList();

                        var resultsVisitor = CreateVisitor(consoleLock, quiet, defaultDirectory, assemblyElement, teamCity, appVeyor);
                        controller.RunTests(filteredTestCases, resultsVisitor, executionOptions);
                        resultsVisitor.Finished.WaitOne();
                    }
                }
            }
            catch (Exception ex)
            {
                failed = true;

                var e = ex;
                while (e != null)
                {
                    Console.WriteLine("{0}: {1}", e.GetType().FullName, e.Message);
                    e = e.InnerException;
                }
            }

            return assemblyElement;
        }