private IList GetFixtures(Assembly assembly, string ns) { ArrayList fixtures = new ArrayList(); log.Debug("Examining assembly for test fixtures"); IList testTypes = GetCandidateFixtureTypes(assembly, ns); log.Debug("Found {0} classes to examine", testTypes.Count); #if NET_2_0 System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch(); timer.Start(); #endif foreach (Type testType in testTypes) { if (TestFixtureBuilder.CanBuildFrom(testType)) { fixtures.Add(TestFixtureBuilder.BuildFrom(testType)); } } #if NET_2_0 log.Debug("Found {0} fixtures in {1} seconds", fixtures.Count, timer.Elapsed); #else log.Debug("Found {0} fixtures", fixtures.Count); #endif return(fixtures); }
/// <summary> /// Build a TestSuite from type provided. /// </summary> /// <param name="type">The type of the fixture to be used</param> /// <returns>A TestSuite</returns> public Test BuildFrom(Type type) { TestSuite suite = new LegacySuite(type); if (suite.RunState == RunState.NotRunnable) { string reason = null; if (!IsValidFixtureType(type, ref reason)) { suite.RunState = RunState.NotRunnable; suite.Properties.Set(PropertyNames.SkipReason, reason); } } PropertyInfo suiteProperty = GetSuiteProperty(type); MethodInfo method = suiteProperty.GetGetMethod(true); if (method.GetParameters().Length > 0) { suite.RunState = RunState.NotRunnable; suite.Properties.Set(PropertyNames.SkipReason, "Suite property may not be indexed"); } // TODO: Stop checking for name else if (method.ReturnType.FullName == "NUnit.Framework.Internal.TestSuite") { TestSuite s = (TestSuite)suiteProperty.GetValue(null, new Object[0]); foreach (Test test in s.Tests) { suite.Add(test); } } else if (typeof(IEnumerable).IsAssignableFrom(method.ReturnType)) { foreach (object obj in (IEnumerable)suiteProperty.GetValue(null, new object[0])) { Type objType = obj as Type; if (objType != null && TestFixtureBuilder.CanBuildFrom(objType)) { suite.Add(TestFixtureBuilder.BuildFrom(objType)); } else { suite.Add(TestFixtureBuilder.BuildFrom(obj)); } } } else { suite.RunState = RunState.NotRunnable; suite.Properties.Set(PropertyNames.SkipReason, "Suite property must return either TestSuite or IEnumerable"); } return(suite); }
private Test Build(string assemblyName, Type testType, bool autoSuites) { // TODO: This is the only situation in which we currently // recognize and load legacy suites. We need to determine // whether to allow them in more places. if (legacySuiteBuilder.CanBuildFrom(testType)) { return(legacySuiteBuilder.BuildFrom(testType)); } else if (TestFixtureBuilder.CanBuildFrom(testType)) { return(BuildTestAssembly(assemblyName, new Test[] { TestFixtureBuilder.BuildFrom(testType) }, autoSuites)); } return(null); }
private IList GetFixtures(Assembly assembly, string ns) { ArrayList fixtures = new ArrayList(); IList testTypes = GetCandidateFixtureTypes(assembly, ns); foreach (Type testType in testTypes) { if (TestFixtureBuilder.CanBuildFrom(testType)) { fixtures.Add(TestFixtureBuilder.BuildFrom(testType)); } } return(fixtures); }
public TestResult RunAllUnitTests(Action <string> callback, Assembly testAssembly = null) { if (testAssembly == null) { testAssembly = Assembly.GetCallingAssembly(); } CoreExtensions.Host.InitializeService(); TestExecutionContext.CurrentContext.TestPackage = new TestPackage(string.Format("TestPackage for {0}", testAssembly.GetName().FullName)); var builder = new NamespaceTreeBuilder(new TestAssembly(testAssembly, testAssembly.GetName().FullName)); var fixtures = testAssembly.GetTypes().Where(i => TestFixtureBuilder.CanBuildFrom(i)).Select(i => TestFixtureBuilder.BuildFrom(i)).ToList(); builder.Add(fixtures); return(builder.RootSuite.Run(new ConsoleListener(callback), TestFilter.Empty)); }
/// <summary> /// Runs all of the tests defined in the specified assembly, specifically not running /// any of the tests in the calling type. /// </summary> /// <param name="assemblyToTest"> /// The assembly to be tested. /// </param> /// <param name="callingType"> /// No tests will be run that are defined in this type. /// </param> /// <returns> /// The result of running the suite of tests. /// </returns> private TestResult RunTestsInParallelImpl(Assembly assemblyToTest, Type callingType) { // NUnit requires this initialization step before any tests can be run CoreExtensions.Host.InitializeService(); this.Listener = new ParallelListener(); this.Filter = new IgnoreFilter(this.Listener); List <Test> concurrentTestFixtures; try { concurrentTestFixtures = assemblyToTest.GetTypes() .Where(type => callingType != type && TestFixtureBuilder.CanBuildFrom(type)) .Select(TestFixtureBuilder.BuildFrom) .ToList(); } catch (ReflectionTypeLoadException ex) { Console.WriteLine("ReflectionTypeLoadException caught..."); foreach (Exception loaderException in ex.LoaderExceptions) { Console.WriteLine("Loader Exception --------------------"); Console.WriteLine("Message:{0}", loaderException.Message); if (loaderException is FileNotFoundException) { Console.WriteLine((loaderException as FileNotFoundException).FusionLog); } Console.WriteLine("StackTrace: {0}", loaderException.StackTrace); } throw; } var stopwatch = new Stopwatch(); stopwatch.Start(); var currentDirectory = Path.GetDirectoryName(assemblyToTest.Location); Parallel.ForEach(concurrentTestFixtures, testFixture => { Environment.CurrentDirectory = currentDirectory; TestContext.Save(); testFixture.Run(this.Listener, this.Filter); }); stopwatch.Stop(); // Find out what the failures were var testResults = this.AllResults(this.Listener.Results) .Where(x => x.Results == null) .ToList(); var failuresAndErrors = testResults .Where(result => (result.IsFailure || result.IsError)) .ToList(); // Report the errors if there are any Console.WriteLine(); foreach (TestResult failure in failuresAndErrors) { Console.WriteLine("------------------------------------------------"); Console.WriteLine(failure.Test.TestName + " failed"); Console.WriteLine(failure.Message); Console.WriteLine(failure.StackTrace); } Console.WriteLine("================================================="); var totalErrors = testResults.Count(x => x.IsError); var totalFailures = testResults.Count(x => x.IsFailure); var totalInconclusive = testResults.Count(x => x.ResultState == ResultState.Inconclusive); var totalIgnored = testResults.Count(x => x.ResultState == ResultState.Ignored); var totalSkipped = testResults.Count(x => x.ResultState == ResultState.Skipped); var totalNotRunnable = testResults.Count(x => x.ResultState == ResultState.NotRunnable); var totalNotRun = totalInconclusive + totalIgnored + totalSkipped + totalNotRunnable; var totalRun = testResults.Count - totalNotRun; Console.WriteLine( String.Format("Tests run: {0}, Errors: {1}, Failures: {2}, Inconclusive: {3}, Time: {4} seconds", totalRun, totalErrors, totalFailures, totalInconclusive, stopwatch.Elapsed.TotalSeconds)); Console.WriteLine(String.Format(" Not run: {0}, Invalid: {1}, Ignored: {2}, Skipped: {3}", totalNotRun, failuresAndErrors.Count, totalIgnored, totalSkipped)); Console.WriteLine("================================================="); // Build up the results for return var finalResult = new TestResult(new TestName()); foreach (var result in this.Listener.Results) { finalResult.AddResult(result); } return(finalResult); }