/// <summary> /// Build a suite based on a TestPackage /// </summary> /// <param name="package">The TestPackage</param> /// <returns>A TestSuite</returns> public TestSuite Build(TestPackage package) { bool autoNamespaceSuites = package.GetSetting("AutoNamespaceSuites", true); bool mergeAssemblies = package.GetSetting("MergeAssemblies", false); if (package.IsSingleAssembly) { return(BuildSingleAssembly(package)); } string targetAssemblyName = null; if (package.TestName != null && package.Assemblies.Contains(package.TestName)) { targetAssemblyName = package.TestName; package.TestName = null; } TestSuite rootSuite = new TestSuite(package.FullName); NamespaceTreeBuilder namespaceTree = new NamespaceTreeBuilder(rootSuite); builders.Clear(); foreach (string assemblyName in package.Assemblies) { if (targetAssemblyName == null || targetAssemblyName == assemblyName) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Add(builder); Test testAssembly = builder.Build(assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies); if (testAssembly != null) { if (!mergeAssemblies) { rootSuite.Add(testAssembly); } else if (autoNamespaceSuites) { namespaceTree.Add(testAssembly.Tests); rootSuite = namespaceTree.RootSuite; } else { foreach (Test test in testAssembly.Tests) { rootSuite.Add(test); } } } } } if (rootSuite.Tests.Count == 0) { return(null); } return(rootSuite); }
/// <summary> /// Load a TestPackage /// </summary> /// <param name="package">The package to be loaded</param> /// <returns>True on success, false on failure</returns> public bool Load(TestPackage package) { log.Debug("Loading package " + package.Name); this.builder = new TestSuiteBuilder(); _compatibility = package.GetSetting("NUnit3Compatibility", false); _workDirectory = package.GetSetting("WorkDirectory", Environment.CurrentDirectory); if (_compatibility) { Compatibility.BeginCollection(_workDirectory); } try { this.test = builder.Build(package); } finally { if (_compatibility) { Compatibility.EndCollection(); } } if (test == null) { return(false); } test.SetRunnerID(this.runnerID, true); TestExecutionContext.CurrentContext.TestPackage = package; return(true); }
public override bool Load(TestPackage package) { log.Info("Loading Test Package " + package.Name ); // Initialize ExtensionHost if not already done if ( !CoreExtensions.Host.Initialized ) CoreExtensions.Host.InitializeService(); // Delayed creation of downstream runner allows us to // use a different runner type based on the package bool useThreadedRunner = package.GetSetting( "UseThreadedRunner", true ); TestRunner runner = new SimpleTestRunner( this.runnerID ); if (useThreadedRunner) { ApartmentState apartmentState = (ApartmentState)package.GetSetting("ApartmentState", ApartmentState.Unknown); ThreadPriority priority = (ThreadPriority)package.GetSetting("ThreadPriority", ThreadPriority.Normal); runner = new ThreadedTestRunner(runner, apartmentState, priority); } this.TestRunner = runner; if( base.Load (package) ) { log.Info("Loaded package successfully" ); return true; } else { log.Info("Package load failed" ); return false; } }
/// <summary> /// Build a suite based on a TestPackage /// </summary> /// <param name="package">The TestPackage</param> /// <returns>A TestSuite</returns> public TestSuite Build( TestPackage package ) { bool autoNamespaceSuites = package.GetSetting( "AutoNamespaceSuites", true ); bool mergeAssemblies = package.GetSetting( "MergeAssemblies", false ); TestExecutionContext.CurrentContext.TestCaseTimeout = package.GetSetting("DefaultTimeout", 0); if ( package.IsSingleAssembly ) return BuildSingleAssembly( package ); string targetAssemblyName = null; if( package.TestName != null && package.Assemblies.Contains( package.TestName ) ) { targetAssemblyName = package.TestName; package.TestName = null; } TestSuite rootSuite = new ProjectRootSuite( package.FullName ); NamespaceTreeBuilder namespaceTree = new NamespaceTreeBuilder( rootSuite ); builders.Clear(); foreach(string assemblyName in package.Assemblies) { if ( targetAssemblyName == null || targetAssemblyName == assemblyName ) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Add( builder ); Test testAssembly = builder.Build( assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies ); if ( testAssembly != null ) { if (!mergeAssemblies) { rootSuite.Add(testAssembly); } else if (autoNamespaceSuites) { namespaceTree.Add(testAssembly.Tests); rootSuite = namespaceTree.RootSuite; } else { foreach (Test test in testAssembly.Tests) rootSuite.Add(test); } } } } ProviderCache.Clear(); if (rootSuite.Tests.Count == 0) return null; return rootSuite; }
public override bool Load(TestPackage package) { log.Info("Loading Test Package " + package.Name ); // Initialize ExtensionHost if not already done if ( !CoreExtensions.Host.Initialized ) CoreExtensions.Host.InitializeService(); // Delayed creation of downstream runner allows us to // use a different runner type based on the package bool useThreadedRunner = package.GetSetting( "UseThreadedRunner", true ); TestRunner runner = new SimpleTestRunner( this.runnerID ); if ( useThreadedRunner ) runner = new ThreadedTestRunner( runner ); this.TestRunner = runner; if( base.Load (package) ) { log.Info("Loaded package successfully" ); return true; } else { log.Info("Package load failed" ); return false; } }
public override bool Load(TestPackage package) { NTrace.Info("Loading test package " + package.Name); // Initialize ExtensionHost if not already done if (!CoreExtensions.Host.Initialized) { CoreExtensions.Host.InitializeService(); } // Delayed creation of downstream runner allows us to // use a different runner type based on the package bool useThreadedRunner = package.GetSetting("UseThreadedRunner", true); TestRunner runner = new SimpleTestRunner(this.runnerID); if (useThreadedRunner) { runner = new ThreadedTestRunner(runner); } this.TestRunner = runner; return(base.Load(package)); }
private TestSuite BuildSingleAssembly(TestPackage package) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Clear(); builders.Add(builder); TestSuite suite = (TestSuite)builder.Build( package.FullName, package.TestName, package.GetSetting("AutoNamespaceSuites", true), package.GetSetting("NUnit3Compatibility", false)); ProviderCache.Clear(); return(suite); }
/// <summary> /// Build a suite based on a TestPackage /// </summary> /// <param name="package">The TestPackage</param> /// <returns>A TestSuite</returns> public TestSuite Build( TestPackage package ) { bool autoNamespaceSuites = package.GetSetting( "AutoNamespaceSuites", true ); bool mergeAssemblies = package.GetSetting( "MergeAssemblies", false ); if ( package.IsSingleAssembly ) return BuildSingleAssembly( package ); TestSuite rootSuite = new TestSuite( package.FullName ); NamespaceTreeBuilder namespaceTree = new NamespaceTreeBuilder( rootSuite ); builders.Clear(); foreach(string assemblyName in package.Assemblies) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Add( builder ); Test testAssembly = builder.Build( assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies ); if ( testAssembly != null ) { if (!mergeAssemblies) { rootSuite.Add(testAssembly); } else if (autoNamespaceSuites) { namespaceTree.Add(testAssembly.Tests); rootSuite = namespaceTree.RootSuite; } else { foreach (Test test in testAssembly.Tests) rootSuite.Add(test); } } } if ( rootSuite.Tests.Count == 0 ) return null; return rootSuite; }
private TestSuite BuildSingleAssembly(TestPackage package) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Clear(); builders.Add(builder); return((TestSuite)builder.Build( package.FullName, package.TestName, package.GetSetting("AutoNamespaceSuites", true))); }
private ProcessModel GetTargetProcessModel(TestPackage package) { RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; RuntimeFramework targetFramework = selector.SelectRuntimeFramework(package); ProcessModel processModel = (ProcessModel)package.GetSetting("ProcessModel", ProcessModel.Default); if (processModel == ProcessModel.Default) if (!currentFramework.Supports(targetFramework)) processModel = ProcessModel.Separate; return processModel; }
/// <summary> /// Returns a test runner based on the settings in a TestPackage. /// Any setting that is "consumed" by the factory is removed, so /// that downstream runners using the factory will not repeatedly /// create the same type of runner. /// </summary> /// <param name="package">The TestPackage to be loaded and run</param> /// <returns>A TestRunner</returns> public static TestRunner MakeTestRunner(TestPackage package) { RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; RuntimeFramework targetFramework = package.Settings["RuntimeFramework"] as RuntimeFramework; if (targetFramework == null) targetFramework = currentFramework; else if (targetFramework.Runtime == RuntimeType.Any) { targetFramework = new RuntimeFramework(currentFramework.Runtime, targetFramework.Version); package.Settings["RuntimeFramework"] = targetFramework; } log.Debug("Test requires {0} framework", targetFramework); ProcessModel processModel = (ProcessModel)package.GetSetting("ProcessModel", ProcessModel.Default); if ( processModel == ProcessModel.Default ) if ( !targetFramework.Matches( currentFramework ) ) processModel = ProcessModel.Separate; switch (processModel) { case ProcessModel.Multiple: package.Settings.Remove("ProcessModel"); return new MultipleTestProcessRunner(); case ProcessModel.Separate: package.Settings.Remove("ProcessModel"); return new ProcessRunner(); default: DomainUsage domainUsage = (DomainUsage)package.GetSetting("DomainUsage", DomainUsage.Default); if (domainUsage == DomainUsage.Multiple) { package.Settings.Remove("DomainUsage"); return new MultipleTestDomainRunner(); } else return new TestDomain(); } }
public override bool Load(TestPackage package) { log.Info("Loading Test Package " + package.Name); // Initialize ExtensionHost if not already done if (!CoreExtensions.Host.Initialized) { CoreExtensions.Host.InitializeService(); } // Delayed creation of downstream runner allows us to // use a different runner type based on the package bool useThreadedRunner = package.GetSetting("UseThreadedRunner", true); TestRunner runner = new SimpleTestRunner(this.runnerID); if (useThreadedRunner) { ApartmentState apartmentState = (ApartmentState)package.GetSetting("ApartmentState", ApartmentState.Unknown); ThreadPriority priority = (ThreadPriority)package.GetSetting("ThreadPriority", ThreadPriority.Normal); runner = new ThreadedTestRunner(runner, apartmentState, priority); } this.TestRunner = runner; if (base.Load(package)) { log.Info("Loaded package successfully"); return(true); } else { log.Info("Package load failed"); return(false); } }
/// <summary> /// Returns a test runner based on the settings in a TestPackage. /// Any setting that is "consumed" by the factory is removed, so /// that downstream runners using the factory will not repeatedly /// create the same type of runner. /// </summary> /// <param name="package">The TestPackage to be loaded and run</param> /// <returns>A TestRunner</returns> public virtual TestRunner MakeTestRunner(TestPackage package) { DomainUsage domainUsage = (DomainUsage)package.GetSetting("DomainUsage", DomainUsage.Default); switch (domainUsage) { case DomainUsage.Multiple: package.Settings.Remove("DomainUsage"); return new MultipleTestDomainRunner(); case DomainUsage.None: return new RemoteTestRunner(); case DomainUsage.Single: default: return new TestDomain(); } }
public override bool Load(TestPackage package) { // Initialize ExtensionHost if not already done if ( !CoreExtensions.Host.Initialized ) CoreExtensions.Host.InitializeService(); // Delayed creation of downstream runner allows us to // use a different runner type based on the package bool useThreadedRunner = package.GetSetting( "UseThreadedRunner", true ); TestRunner runner = new SimpleTestRunner( this.runnerID ); if ( useThreadedRunner ) runner = new ThreadedTestRunner( runner ); this.TestRunner = runner; return base.Load (package); }
public override bool CanReuse(TestRunner runner, TestPackage package) { RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; RuntimeFramework targetFramework = selector.SelectRuntimeFramework(package); ProcessModel processModel = (ProcessModel)package.GetSetting("ProcessModel", ProcessModel.Default); if (processModel == ProcessModel.Default) if (!currentFramework.Supports(targetFramework)) processModel = ProcessModel.Separate; switch (processModel) { case ProcessModel.Multiple: return runner is MultipleTestProcessRunner; case ProcessModel.Separate: ProcessRunner processRunner = runner as ProcessRunner; return processRunner != null && processRunner.RuntimeFramework == targetFramework; default: return base.CanReuse(runner, package); } }
/// <summary> /// Returns a test runner based on the settings in a TestPackage. /// Any setting that is "consumed" by the factory is removed, so /// that downstream runners using the factory will not repeatedly /// create the same type of runner. /// </summary> /// <param name="package">The TestPackage to be loaded and run</param> /// <returns>A TestRunner</returns> public override TestRunner MakeTestRunner(TestPackage package) { RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; RuntimeFramework targetFramework = selector.SelectRuntimeFramework(package); ProcessModel processModel = (ProcessModel)package.GetSetting("ProcessModel", ProcessModel.Default); if ( processModel == ProcessModel.Default ) if ( !targetFramework.Matches( currentFramework ) ) processModel = ProcessModel.Separate; switch (processModel) { case ProcessModel.Multiple: package.Settings.Remove("ProcessModel"); return new MultipleTestProcessRunner(); case ProcessModel.Separate: package.Settings.Remove("ProcessModel"); return new ProcessRunner(); default: return base.MakeTestRunner(package); } }
public override bool Load(TestPackage package) { log.Info("Loading " + package.Name); Unload(); runtimeFramework = package.Settings["RuntimeFramework"] as RuntimeFramework; if ( runtimeFramework == null ) runtimeFramework = RuntimeFramework.CurrentFramework; bool enableDebug = package.GetSetting("EnableDebug", false); bool loaded = false; try { if (this.agent == null) { this.agent = Services.TestAgency.GetAgent( runtimeFramework, 30000, enableDebug); if (this.agent == null) return false; } if ( this.TestRunner == null ) this.TestRunner = agent.CreateRunner(this.runnerID); loaded = base.Load (package); return loaded; } finally { // Clean up if the load failed if ( !loaded ) Unload(); } }
private TestSuite BuildSingleAssembly( TestPackage package ) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Clear(); builders.Add( builder ); return (TestSuite)builder.Build( package.FullName, package.TestName, package.GetSetting( "AutoNamespaceSuites", true ) ); }
/// <summary> /// Construct an application domain for running a test package /// </summary> /// <param name="package">The TestPackage to be run</param> public AppDomain CreateDomain( TestPackage package ) { FileInfo testFile = new FileInfo( package.FullName ); AppDomainSetup setup = new AppDomainSetup(); //For paralell tests, we need to use distinct application name setup.ApplicationName = "Tests" + "_" + Environment.TickCount; //setup.ApplicationName = package.Name; string appBase = package.BasePath; if ( appBase == null || appBase == string.Empty ) appBase = testFile.DirectoryName; setup.ApplicationBase = appBase; string configFile = package.ConfigurationFile; if ( configFile == null || configFile == string.Empty ) configFile = NUnitProject.IsProjectFile(testFile.Name) ? Path.GetFileNameWithoutExtension( testFile.Name ) + ".config" : testFile.Name + ".config"; // Note: Mono needs full path to config file... setup.ConfigurationFile = Path.Combine( appBase, configFile ); string binPath = package.PrivateBinPath; if ( package.AutoBinPath ) binPath = GetPrivateBinPath( appBase, package.Assemblies ); setup.PrivateBinPath = binPath; if (package.GetSetting("ShadowCopyFiles", true)) { setup.ShadowCopyFiles = "true"; setup.ShadowCopyDirectories = appBase; setup.CachePath = GetCachePath(); } else setup.ShadowCopyFiles = "false"; string domainName = "test-domain-" + package.Name; // Setup the Evidence Evidence evidence = new Evidence(AppDomain.CurrentDomain.Evidence); if (evidence.Count == 0) { Zone zone = new Zone(SecurityZone.MyComputer); evidence.AddHost(zone); Assembly assembly = Assembly.GetExecutingAssembly(); Url url = new Url(assembly.CodeBase); evidence.AddHost(url); Hash hash = new Hash(assembly); evidence.AddHost(hash); } log.Info("Creating AppDomain " + domainName); AppDomain runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup); // HACK: Only pass down our AddinRegistry one level so that tests of NUnit // itself start without any addins defined. if ( !IsTestDomain( AppDomain.CurrentDomain ) ) runnerDomain.SetData("AddinRegistry", Services.AddinRegistry); // Inject DomainInitializer into the remote domain - there are other // approaches, but this works for all CLR versions. DomainInitializer initializer = DomainInitializer.CreateInstance(runnerDomain); initializer.InitializeDomain( IsTestDomain(AppDomain.CurrentDomain) ? TraceLevel.Off : InternalTrace.Level ); return runnerDomain; }
public AppDomain CreateDomain(TestPackage package) { AppDomainSetup info = new AppDomainSetup(); info.ApplicationName = "Tests_" + Environment.TickCount; FileInfo fileInfo = string.IsNullOrEmpty(package.FullName) ? null : new FileInfo(package.FullName); string str = package.BasePath; string path2 = package.ConfigurationFile; string privateBinPath = package.PrivateBinPath; if (fileInfo != null) { if (string.IsNullOrEmpty(str)) str = fileInfo.DirectoryName; if (string.IsNullOrEmpty(path2)) path2 = this.CanLoadProject(fileInfo.Name) ? Path.GetFileNameWithoutExtension(fileInfo.Name) + ".config" : fileInfo.Name + ".config"; } else if (string.IsNullOrEmpty(str)) str = DomainManager.GetCommonAppBase(package.Assemblies); char ch = str[str.Length - 1]; if (ch != Path.DirectorySeparatorChar && ch != Path.AltDirectorySeparatorChar) str = str + Path.DirectorySeparatorChar; info.ApplicationBase = str; info.ConfigurationFile = path2 == null ? null : Path.Combine(str, path2); if (package.AutoBinPath) privateBinPath = DomainManager.GetPrivateBinPath(str, package.Assemblies); info.PrivateBinPath = privateBinPath; if (package.GetSetting("ShadowCopyFiles", true)) { info.ShadowCopyFiles = "true"; info.ShadowCopyDirectories = str; info.CachePath = this.GetCachePath(); } else info.ShadowCopyFiles = "false"; string friendlyName = "test-domain-" + package.Name; Evidence securityInfo = new Evidence(AppDomain.CurrentDomain.Evidence); if (securityInfo.Count == 0) { Zone zone = new Zone(SecurityZone.MyComputer); securityInfo.AddHost(zone); Assembly executingAssembly = Assembly.GetExecutingAssembly(); Url url = new Url(executingAssembly.CodeBase); securityInfo.AddHost(url); Hash hash = new Hash(executingAssembly); securityInfo.AddHost(hash); } AppDomain domain; if (Environment.OSVersion.Platform == PlatformID.Win32NT) { PermissionSet grantSet = new PermissionSet(PermissionState.Unrestricted); domain = AppDomain.CreateDomain(friendlyName, securityInfo, info, grantSet, null); } else domain = AppDomain.CreateDomain(friendlyName, securityInfo, info); if (Services.UserSettings.GetSetting("Options.TestLoader.SetPrincipalPolicy", false)) domain.SetPrincipalPolicy((PrincipalPolicy)Services.UserSettings.GetSetting("Options.TestLoader.PrincipalPolicy", PrincipalPolicy.UnauthenticatedPrincipal)); if (!this.IsTestDomain(AppDomain.CurrentDomain)) domain.SetData("AddinRegistry", Services.AddinRegistry); DomainInitializer.CreateInstance(domain).InitializeDomain(this.IsTestDomain(AppDomain.CurrentDomain) ? 1 : (int)InternalTrace.Level); return domain; }
/// <summary> /// Construct an application domain for running a test package /// </summary> /// <param name="package">The TestPackage to be run</param> public AppDomain CreateDomain( TestPackage package ) { FileInfo testFile = new FileInfo( package.FullName ); AppDomainSetup setup = new AppDomainSetup(); // We always use the same application name setup.ApplicationName = "Tests"; string appBase = package.BasePath; if ( appBase == null || appBase == string.Empty ) appBase = testFile.DirectoryName; setup.ApplicationBase = appBase; string configFile = package.ConfigurationFile; if ( configFile == null || configFile == string.Empty ) configFile = NUnitProject.IsProjectFile(testFile.Name) ? Path.GetFileNameWithoutExtension( testFile.Name ) + ".config" : testFile.Name + ".config"; // Note: Mono needs full path to config file... setup.ConfigurationFile = Path.Combine( appBase, configFile ); string binPath = package.PrivateBinPath; if ( package.AutoBinPath ) binPath = GetPrivateBinPath( appBase, package.Assemblies ); setup.PrivateBinPath = binPath; if ( package.GetSetting( "ShadowCopyFiles", true ) ) { setup.ShadowCopyFiles = "true"; setup.ShadowCopyDirectories = appBase; setup.CachePath = GetCachePath(); } string domainName = "domain-" + package.Name; Evidence baseEvidence = AppDomain.CurrentDomain.Evidence; Evidence evidence = new Evidence(baseEvidence); AppDomain runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup); // Inject assembly resolver into remote domain to help locate our assemblies AssemblyResolver assemblyResolver = (AssemblyResolver)runnerDomain.CreateInstanceFromAndUnwrap( typeof(AssemblyResolver).Assembly.CodeBase, typeof(AssemblyResolver).FullName); // Tell resolver to use our core assemblies in the test domain assemblyResolver.AddFile( typeof( NUnit.Core.RemoteTestRunner ).Assembly.Location ); assemblyResolver.AddFile( typeof( NUnit.Core.ITest ).Assembly.Location ); // No reference to extensions, so we do it a different way string moduleName = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName; string nunitDirPath = Path.GetDirectoryName(moduleName); // string coreExtensions = Path.Combine(nunitDirPath, "nunit.core.extensions.dll"); // assemblyResolver.AddFile( coreExtensions ); //assemblyResolver.AddFiles( nunitDirPath, "*.dll" ); string addinsDirPath = Path.Combine(nunitDirPath, "addins"); assemblyResolver.AddDirectory( addinsDirPath ); // HACK: Only pass down our AddinRegistry one level so that tests of NUnit // itself start without any addins defined. if ( !IsTestDomain( AppDomain.CurrentDomain ) ) runnerDomain.SetData("AddinRegistry", Services.AddinRegistry); return runnerDomain; }
/// <summary> /// Construct an application domain for running a test package /// </summary> /// <param name="package">The TestPackage to be run</param> public AppDomain CreateDomain( TestPackage package ) { AppDomainSetup setup = new AppDomainSetup(); //For paralell tests, we need to use distinct application name setup.ApplicationName = "Tests" + "_" + Environment.TickCount; FileInfo testFile = package.FullName != null && package.FullName != string.Empty ? new FileInfo(package.FullName) : null; string appBase = package.BasePath; string configFile = package.ConfigurationFile; string binPath = package.PrivateBinPath; if (testFile != null) { if (appBase == null || appBase == string.Empty) appBase = testFile.DirectoryName; if (configFile == null || configFile == string.Empty) configFile = Services.ProjectService.CanLoadProject(testFile.Name) ? Path.GetFileNameWithoutExtension(testFile.Name) + ".config" : testFile.Name + ".config"; } else if (appBase == null || appBase == string.Empty) appBase = GetCommonAppBase(package.Assemblies); setup.ApplicationBase = appBase; // TODO: Check whether Mono still needs full path to config file... setup.ConfigurationFile = appBase != null && configFile != null ? Path.Combine(appBase, configFile) : configFile; if (package.AutoBinPath) binPath = GetPrivateBinPath( appBase, package.Assemblies ); setup.PrivateBinPath = binPath; if (package.GetSetting("ShadowCopyFiles", true)) { setup.ShadowCopyFiles = "true"; setup.ShadowCopyDirectories = appBase; setup.CachePath = GetCachePath(); } else setup.ShadowCopyFiles = "false"; string domainName = "test-domain-" + package.Name; // Setup the Evidence Evidence evidence = new Evidence(AppDomain.CurrentDomain.Evidence); if (evidence.Count == 0) { Zone zone = new Zone(SecurityZone.MyComputer); evidence.AddHost(zone); Assembly assembly = Assembly.GetExecutingAssembly(); Url url = new Url(assembly.CodeBase); evidence.AddHost(url); Hash hash = new Hash(assembly); evidence.AddHost(hash); } log.Info("Creating AppDomain " + domainName); AppDomain runnerDomain; // TODO: Try to eliminate this test. Currently, running on // Linux with the permission set specified causes an // unexplained crash when unloading the domain. #if NET_2_0 if (Environment.OSVersion.Platform == PlatformID.Win32NT) { PermissionSet permissionSet = new PermissionSet( PermissionState.Unrestricted ); runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup, permissionSet, null); } else #endif runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup); // HACK: Only pass down our AddinRegistry one level so that tests of NUnit // itself start without any addins defined. if ( !IsTestDomain( AppDomain.CurrentDomain ) ) runnerDomain.SetData("AddinRegistry", Services.AddinRegistry); // Inject DomainInitializer into the remote domain - there are other // approaches, but this works for all CLR versions. DomainInitializer initializer = DomainInitializer.CreateInstance(runnerDomain); // HACK: Under nunit-console, direct use of the enum fails int traceLevel = IsTestDomain(AppDomain.CurrentDomain) ? (int)InternalTraceLevel.Off : (int)InternalTrace.Level; initializer.InitializeDomain(traceLevel); return runnerDomain; }
/// <summary> /// Build a suite based on a TestPackage /// </summary> /// <param name="package">The TestPackage</param> /// <returns>A TestSuite</returns> public TestSuite Build(TestPackage package) { bool autoNamespaceSuites = package.GetSetting("AutoNamespaceSuites", true); bool mergeAssemblies = package.GetSetting("MergeAssemblies", false); bool checkCompatibility = package.GetSetting("NUnit3Compatibility", false); TestExecutionContext.CurrentContext.TestCaseTimeout = package.GetSetting("DefaultTimeout", 0); if (package.IsSingleAssembly) { return(BuildSingleAssembly(package)); } string targetAssemblyName = null; if (package.TestName != null && package.Assemblies.Contains(package.TestName)) { targetAssemblyName = package.TestName; package.TestName = null; } TestSuite rootSuite = new ProjectRootSuite(package.FullName); NamespaceTreeBuilder namespaceTree = new NamespaceTreeBuilder(rootSuite); builders.Clear(); foreach (string assemblyName in package.Assemblies) { if (targetAssemblyName == null || targetAssemblyName == assemblyName) { TestAssemblyBuilder builder = new TestAssemblyBuilder(); builders.Add(builder); Test testAssembly = builder.Build(assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies, checkCompatibility); if (testAssembly != null) { if (!mergeAssemblies) { rootSuite.Add(testAssembly); } else if (autoNamespaceSuites) { namespaceTree.Add(testAssembly.Tests); rootSuite = namespaceTree.RootSuite; } else { foreach (Test test in testAssembly.Tests) { rootSuite.Add(test); } } } } } ProviderCache.Clear(); if (rootSuite.Tests.Count == 0) { return(null); } return(rootSuite); }