public void CorrectRunnerIsUsed(string files, string domainUsage, Type expectedType) { var package = new TestPackage(files.Split(new char[] { ' ' })); if (domainUsage != null) package.Settings["DomainUsage"] = domainUsage; Assert.That(_factory.MakeTestRunner(package), Is.TypeOf(expectedType)); }
/// <summary> /// Expands a TestPackage based on a known project format, populating it /// with the project contents and any settings the project provides. /// Note that the package file path must be checked to ensure that it is /// a known project format before calling this method. /// </summary> /// <param name="package">The TestPackage to be expanded</param> public void ExpandProjectPackage(TestPackage package) { Guard.ArgumentNotNull(package, "package"); Guard.ArgumentValid(package.SubPackages.Count == 0, "Package is already expanded", "package"); string path = package.FullName; if (!File.Exists(path)) return; IProject project = LoadFrom(path); Guard.ArgumentValid(project != null, "Unable to load project " + path, "package"); string configName = package.GetSetting(EnginePackageSettings.ActiveConfig, (string)null); // Need RunnerSetting TestPackage tempPackage = project.GetTestPackage(configName); // The original package held overrides, so don't change them, but // do apply any settings specified within the project itself. foreach (string key in tempPackage.Settings.Keys) if (!package.Settings.ContainsKey(key)) // Don't override settings from command line package.Settings[key] = tempPackage.Settings[key]; foreach (var subPackage in tempPackage.SubPackages) package.AddSubPackage(subPackage); // If no config is specified (by user or by the proejct loader) check // to see if one exists in same directory as the package. If so, we // use it. If not, each assembly will use it's own config, if present. if (!package.Settings.ContainsKey(EnginePackageSettings.ConfigurationFile)) { var packageConfig = Path.ChangeExtension(path, ".config"); if (File.Exists(packageConfig)) package.Settings[EnginePackageSettings.ConfigurationFile] = packageConfig; } }
public void GetById_ReturnsProject_WithMatchedId() { var p = new TestPackage(); var expectedId = p.ProjectSetMock.Object.First().ProjectId; var project = p.Tested.Get(expectedId); Assert.AreEqual(project.ProjectId, expectedId); }
public void NamespaceSetUpFixtureReplacesNamespaceNodeInTree() { string nameSpace = "NUnit.TestData.SetupFixture.Namespace1"; TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage( testAssembly ); package.TestName = nameSpace; Test suite= builder.Build( package ); Assert.IsNotNull(suite); Assert.AreEqual(testAssembly, suite.TestName.Name); Assert.AreEqual(1, suite.Tests.Count); string[] nameSpaceBits = nameSpace.Split('.'); for (int i = 0; i < nameSpaceBits.Length; i++) { suite = suite.Tests[0] as TestSuite; Assert.AreEqual(nameSpaceBits[i], suite.TestName.Name); Assert.AreEqual(1, suite.Tests.Count); } Assert.IsInstanceOf(typeof(SetUpFixture), suite); suite = suite.Tests[0] as TestSuite; Assert.AreEqual("SomeTestFixture", suite.TestName.Name); Assert.AreEqual(1, suite.Tests.Count); }
/// <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 = CreateAppDomainSetup(package); 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); // Set PrincipalPolicy for the domain if called for in the settings if (_settingsService != null && _settingsService.GetSetting("Options.TestLoader.SetPrincipalPolicy", false)) { runnerDomain.SetPrincipalPolicy(_settingsService.GetSetting( "Options.TestLoader.PrincipalPolicy", PrincipalPolicy.UnauthenticatedPrincipal)); } return runnerDomain; }
/// <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>An ITestEngineRunner</returns> public virtual ITestEngineRunner MakeTestRunner(TestPackage package) { DomainUsage domainUsage = (DomainUsage)System.Enum.Parse( typeof(DomainUsage), package.GetSetting(EnginePackageSettings.DomainUsage, "Default")); switch (domainUsage) { default: case DomainUsage.Default: if (package.SubPackages.Count > 1) return new MultipleTestDomainRunner(this.ServiceContext, package); else return new TestDomainRunner(this.ServiceContext, package); case DomainUsage.Multiple: return new MultipleTestDomainRunner(ServiceContext, package); case DomainUsage.None: return new LocalTestRunner(ServiceContext, package); case DomainUsage.Single: return new TestDomainRunner(ServiceContext, package); } }
/// <summary> /// Load a TestPackage for possible execution /// </summary> /// <param name="package">The TestPackage to be loaded</param> /// <returns>A TestEngineResult.</returns> protected override TestEngineResult LoadPackage() { List<TestPackage> packages = new List<TestPackage>(); foreach (string testFile in TestPackage.TestFiles) { TestPackage subPackage = new TestPackage(testFile); if (Services.ProjectService.IsProjectFile(testFile)) Services.ProjectService.ExpandProjectPackage(subPackage); foreach (string key in TestPackage.Settings.Keys) subPackage.Settings[key] = TestPackage.Settings[key]; packages.Add(subPackage); } List<TestEngineResult> results = new List<TestEngineResult>(); foreach (TestPackage subPackage in packages) { var runner = CreateRunner(subPackage); _runners.Add(runner); results.Add(runner.Load()); } return ResultHelper.Merge(results); }
public AbstractTestRunner(IServiceLocator services, TestPackage package) { Services = services; TestPackage = package; TestRunnerFactory = Services.GetService<ITestRunnerFactory>(); ProjectService = Services.GetService<IProjectService>(); }
public void ChangePassword_Validates_And_Saves() { var p = new TestPackage(); p.Tested.ChangePassword(1, "Password", "password123"); p.PasswordSetMock.Verify(x => x.Attach(It.IsAny<Password>()), Times.Once); p.ContextProviderMock.Verify(x => x.SetEntryModified(It.IsAny<Password>()), Times.Once); p.ContextProviderMock.Verify(x => x.SaveChanges(), Times.Once); }
public void calling_Reserve_with_2_queues_should_call_BLPop_with_2_queues() { var package = new TestPackage(new[] { "queue1", "queue2" }); var job = package.UnderTest.Reserve(); package.RedisMock.Verify(x => x.BLPop(new[] { "queue:queue1", "queue:queue2" }, It.IsAny<int>())); }
public void calling_Reserve_should_get_a_job() { var package = new TestPackage(new[] {""}); var job = package.UnderTest.Reserve(); Assert.That(job, Is.Not.Null); }
public void Setup() { TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage(AssemblyHelper.GetAssemblyPath(typeof(ActionAttributeExceptionFixture))); package.TestName = typeof(ActionAttributeExceptionFixture).Namespace; _Suite = builder.Build(package); }
/// <summary> /// Creates a new AppDomain for running the test package /// </summary> /// <param name="package">The test package to be run</param> /// <returns></returns> public static AppDomain CreateDomain(TestPackage package) { AppDomainSetup setup = CreateAppDomainSetup(package); string domainName = "test-domain-" + package.Name; return AppDomain.CreateDomain(domainName, null, setup); }
[SetUp] public void LoadFixture() { string testsDll = AssemblyHelper.GetAssemblyPath(typeof(DerivedTestFixture)); TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage( testsDll ); package.TestName = typeof(DerivedTestFixture).FullName; suite= builder.Build( package ); }
[SetUp] public void LoadFixture() { string testsDll = "test-assembly.dll"; TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage( testsDll ); package.TestName = "NUnit.TestData.TestFixtureExtension.DerivedTestFixture"; suite= builder.Build( package ); }
private TestResult runTests(string nameSpace, TestFilter filter) { TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage( testAssembly ); package.TestName = nameSpace; Test suite = builder.Build( package ); return suite.Run(new NullListener(),filter); }
// Create a MultipleTestProcessRunner with a fake package consisting of // some number of assemblies and with an optional MaxAgents setting. // Zero means that MaxAgents is not specified. MultipleTestProcessRunner CreateRunner(int assemblyCount, int maxAgents) { // Currently, we can get away with null entries here var package = new TestPackage(new string[assemblyCount]); if (maxAgents > 0) package.Settings[EnginePackageSettings.MaxAgents] = maxAgents; return new MultipleTestProcessRunner(new ServiceContext(), package); }
public void LoadTestFixtureFromAssembly() { TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage( thisDll ); package.TestName = this.GetType().FullName; Test suite= builder.Build( package ); Assert.IsNotNull(suite, "Should not be Null"); }
public void Create_AddsProject_And_SavesContext() { var p = new TestPackage(); var user = p.ContextProviderMock.Object.Users.First(); var newProject = p.Tested.Create(new Project {Title = "new project", UserId = user.UserId}); Assert.Greater(newProject.ProjectId, 0); p.ProjectSetMock.Verify(x => x.Add(It.IsAny<Project>()), Times.Once()); p.ContextProviderMock.Verify(x => x.SaveChanges(), Times.Once); }
public void Delete_Removes_And_SavesContext() { var p = new TestPackage(); var project = p.ContextProviderMock.Object.Projects.First(); p.Tested.Delete(project.ProjectId); p.ProjectSetMock.Verify(x => x.Remove(It.IsAny<Project>()), Times.Once()); p.ContextProviderMock.Verify(x => x.SaveChanges(), Times.Once); }
public AbstractTestRunner(ServiceContext services, TestPackage package) { this.Services = services; this.TestPackage = package; TestRunnerFactory = Services.GetService<ITestRunnerFactory>(); #if NUNIT_ENGINE ProjectService = Services.GetService<IProjectService>(); #endif }
/// <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 = CreateAppDomainSetup(package); 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: Find an approach that works across all platforms //// TODO: Try to eliminate this test. Currently, running on //// Linux with the permission set specified causes an //// unexplained crash when unloading the domain. //if (Environment.OSVersion.Platform == PlatformID.Win32NT) //{ // PermissionSet permissionSet = new PermissionSet( PermissionState.Unrestricted ); // runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup, permissionSet, null); //} //else runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup); // Set PrincipalPolicy for the domain if called for in the settings if (ServiceContext.UserSettings.GetSetting("Options.TestLoader.SetPrincipalPolicy", false)) runnerDomain.SetPrincipalPolicy((PrincipalPolicy)ServiceContext.UserSettings.GetSetting( "Options.TestLoader.PrincipalPolicy", PrincipalPolicy.UnauthenticatedPrincipal)); //// 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> /// 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 ITestEngineRunner MakeTestRunner(TestPackage package) { int assemblyCount = 0; int projectCount = 0; foreach (var subPackage in package.SubPackages) { var testFile = subPackage.FullName; if (PathUtils.IsAssemblyFileType(testFile)) assemblyCount++; else if (_projectService.CanLoadFrom(testFile)) projectCount++; } // If we have multiple projects or a project plus assemblies // then defer to the AggregatingTestRunner, which will make // the decision on a file by file basis so that each project // runs with its own settings. if (projectCount > 1 || projectCount > 0 && assemblyCount > 0) return new AggregatingTestRunner(ServiceContext, package); // If we have a single project by itself, expand it here. if (projectCount > 0 && assemblyCount == 0) { var p = package.SubPackages[0]; _projectService.ExpandProjectPackage(p); package = p; } // TODO: What about bad extensions? ProcessModel processModel = GetTargetProcessModel(package); switch (processModel) { default: case ProcessModel.Default: if (package.SubPackages.Count > 1) return new MultipleTestProcessRunner(this.ServiceContext, package); else return new ProcessRunner(this.ServiceContext, package); case ProcessModel.Multiple: return new MultipleTestProcessRunner(this.ServiceContext, package); case ProcessModel.Separate: return new ProcessRunner(this.ServiceContext, package); case ProcessModel.InProcess: return base.MakeTestRunner(package); } }
public DirectTestRunner(IServiceLocator services, TestPackage package) : base(services, package) { // Bypass the resolver if not in the default AppDomain. This prevents trying to use the resolver within // NUnit's own automated tests (in a test AppDomain) which does not make sense anyway. if (AppDomain.CurrentDomain.IsDefaultAppDomain()) { _assemblyResolver = new ProvidedPathsAssemblyResolver(); _assemblyResolver.Install(); } }
public void GetByUserId_Returns_AllProjectsForUser() { const int userId = 2; var p = new TestPackage(); var projects = p.Tested.GetByUserId(userId); foreach (var project in projects) { Assert.AreEqual(project.UserId, userId); } }
public void calling_Reserve_with_splat_should_call_SMembers() { var package = new TestPackage(new[] { "*" }); package.RedisMock.Setup(x => x.SMembers("queues")).Returns(new[] {"RandomQueue"}) .Verifiable(); var job = package.UnderTest.Reserve(); package.RedisMock.Verify(); }
public MasterTestRunner(IServiceLocator services, TestPackage package) { _services = services; TestPackage = package; _testRunnerFactory = _services.GetService<ITestRunnerFactory>(); _projectService = _services.GetService<IProjectService>(); _runtimeService = _services.GetService<IRuntimeFrameworkService>(); _extensionService = _services.GetService<ExtensionService>(); _engineRunner = _testRunnerFactory.MakeTestRunner(package); }
public void Setup() { ActionAttributeFixture.Results = new List<string>(); TestSuiteBuilder builder = new TestSuiteBuilder(); TestPackage package = new TestPackage(AssemblyHelper.GetAssemblyPath(typeof(ActionAttributeFixture))); package.TestName = typeof(ActionAttributeFixture).Namespace; Test suite = builder.Build(package); _result = suite.Run(new NullListener(), new ActionAttributeFixtureFilter()); }
/// <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>An ITestEngineRunner</returns> public virtual ITestEngineRunner MakeTestRunner(TestPackage package) { switch (package.GetSetting(PackageSettings.DomainUsage, "Default")) { case "None": return new LocalTestRunner(ServiceContext, package); default: case "Single": return new TestDomainRunner(ServiceContext, package); } }
/// <summary> /// Creates a new AppDomainSetup /// </summary> /// <param name="package"></param> /// <returns></returns> private static AppDomainSetup CreateAppDomainSetup(TestPackage package) { AppDomainSetup setup = new AppDomainSetup(); // We need to use distinct application name, when runnin tests in parallel setup.ApplicationName = string.Format("Tests_{0}", Environment.TickCount); setup.ApplicationBase = package.GetBasePath(); setup.ConfigurationFile = package.ConfigurationFile; return setup; }
public void PackageContainsOneSubPackagePerTestFile(params string[] testFiles) { TestPackage package = _model.MakeTestPackage(testFiles); Assert.That(package.SubPackages.Select(p => p.Name), Is.EqualTo(testFiles)); }
void IProjectService.ExpandProjectPackage(TestPackage package) { throw new NotImplementedException(); }
/// <summary> /// Use Mono.Cecil to get information about all assemblies and /// apply it to the package using special internal keywords. /// </summary> /// <param name="package"></param> private static void ApplyImageData(TestPackage package) { string packageName = package.FullName; Version targetVersion = new Version(0, 0); string frameworkName = null; bool requiresX86 = false; bool requiresAssemblyResolver = false; // We are doing two jobs here: (1) in the else clause (below) // we get information about a single assembly and record it, // (2) in the if clause, we recursively examine all subpackages // and then apply policies for promulgating each setting to // a containing package. We could implement the policy part at // a higher level, but it seems simplest to do it right here. if (package.SubPackages.Count > 0) { foreach (var subPackage in package.SubPackages) { ApplyImageData(subPackage); // Collect the highest version required Version v = subPackage.GetSetting(InternalEnginePackageSettings.ImageRuntimeVersion, new Version(0, 0)); if (v > targetVersion) { targetVersion = v; } // Collect highest framework name // TODO: This assumes lexical ordering is valid - check it string fn = subPackage.GetSetting(InternalEnginePackageSettings.ImageTargetFrameworkName, ""); if (fn != "") { if (frameworkName == null || fn.CompareTo(frameworkName) < 0) { frameworkName = fn; } } // If any assembly requires X86, then the aggregate package requires it if (subPackage.GetSetting(InternalEnginePackageSettings.ImageRequiresX86, false)) { requiresX86 = true; } if (subPackage.GetSetting(InternalEnginePackageSettings.ImageRequiresDefaultAppDomainAssemblyResolver, false)) { requiresAssemblyResolver = true; } } } else if (File.Exists(packageName) && PathUtils.IsAssemblyFileType(packageName)) { var assemblyDef = AssemblyDefinition.ReadAssembly(packageName); var module = assemblyDef.MainModule; var NativeEntryPoint = (ModuleAttributes)16; var mask = ModuleAttributes.Required32Bit | NativeEntryPoint; if (module.Architecture != TargetArchitecture.AMD64 && module.Architecture != TargetArchitecture.IA64 && (module.Attributes & mask) != 0) { requiresX86 = true; log.Debug("Assembly {0} will be run x86", packageName); } targetVersion = new Version(module.RuntimeVersion.Substring(1)); log.Debug("Assembly {0} uses version {1}", packageName, targetVersion); foreach (var attr in assemblyDef.CustomAttributes) { if (attr.AttributeType.FullName == "System.Runtime.Versioning.TargetFrameworkAttribute") { frameworkName = attr.ConstructorArguments[0].Value as string; } else if (attr.AttributeType.FullName == "NUnit.Framework.TestAssemblyDirectoryResolveAttribute") { requiresAssemblyResolver = true; } } if (frameworkName == null) { foreach (var reference in module.AssemblyReferences) { if (reference.Name == "mscorlib" && BitConverter.ToUInt64(reference.PublicKeyToken, 0) == 0xac22333d05b89d96) { // We assume 3.5, since that's all we are supporting // Could be extended to other versions if necessary // Format for FrameworkName is invented - it is not // known if any compilers supporting CF use the attribute frameworkName = ".NETCompactFramework,Version=3.5"; break; } } } } if (targetVersion.Major > 0) { package.Settings[InternalEnginePackageSettings.ImageRuntimeVersion] = targetVersion; } if (!string.IsNullOrEmpty(frameworkName)) { package.Settings[InternalEnginePackageSettings.ImageTargetFrameworkName] = frameworkName; } package.Settings[InternalEnginePackageSettings.ImageRequiresX86] = requiresX86; if (requiresX86) { package.Settings[EnginePackageSettings.RunAsX86] = true; } package.Settings[InternalEnginePackageSettings.ImageRequiresDefaultAppDomainAssemblyResolver] = requiresAssemblyResolver; }
private IEnumerable <AutoTest.TestRunners.Shared.Results.TestResult> runTests(Options options, TestPackage package, TestRunner testRunner) { testRunner.Load(package); if (testRunner.Test == null) { testRunner.Unload(); return(new AutoTest.TestRunners.Shared.Results.TestResult[] { ErrorHandler.GetError("NUnit", "Unable to locate fixture") }); } var harvester = new TestHarvester(_channel); var testFilter = getTestFilter(options); string savedDirectory = Environment.CurrentDirectory; var result = run(testRunner, harvester, testFilter, savedDirectory); if (result != null) { return(harvester.Results); } return(harvester.Results); }
/// <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); }
public MasterTestRunner(ServiceContext services, TestPackage package) : base(services, package) { }
private int RunTests(TestPackage package, TestFilter filter) { var writer = new ColorConsoleWriter(!_options.NoColor); foreach (var spec in _options.ResultOutputSpecifications) { var outputPath = Path.Combine(_workDirectory, spec.OutputPath); IResultWriter resultWriter; try { resultWriter = GetResultWriter(spec); } catch (Exception ex) { throw new NUnitEngineException($"Error encountered in resolving output specification: {spec}", ex); } try { var outputDirectory = Path.GetDirectoryName(outputPath); Directory.CreateDirectory(outputDirectory); } catch (SystemException ex) { writer.WriteLine(ColorStyle.Error, String.Format( "The directory in --result {0} could not be created", spec.OutputPath)); writer.WriteLine(ColorStyle.Error, ExceptionHelper.BuildMessage(ex)); return(ConsoleRunner.UNEXPECTED_ERROR); } try { resultWriter.CheckWritability(outputPath); } catch (SystemException ex) { throw new NUnitEngineException( String.Format( "The path specified in --result {0} could not be written to", spec.OutputPath), ex); } } var labels = _options.DisplayTestLabels != null ? _options.DisplayTestLabels.ToUpperInvariant() : "ON"; XmlNode result = null; NUnitEngineUnloadException unloadException = null; NUnitEngineException engineException = null; try { using (new SaveConsoleOutput()) using (ITestRunner runner = _engine.GetRunner(package)) using (var output = CreateOutputWriter()) { var eventHandler = new TestEventHandler(output, labels); result = runner.Run(eventHandler, filter); } } catch (NUnitEngineUnloadException ex) { unloadException = ex; } catch (NUnitEngineException ex) { engineException = ex; } if (result != null) { var reporter = new ResultReporter(result, writer, _options); reporter.ReportResults(); foreach (var spec in _options.ResultOutputSpecifications) { var outputPath = Path.Combine(_workDirectory, spec.OutputPath); GetResultWriter(spec).WriteResultFile(result, outputPath); writer.WriteLine("Results ({0}) saved as {1}", spec.Format, spec.OutputPath); } if (engineException != null) { writer.WriteLine(ColorStyle.Error, Environment.NewLine + ExceptionHelper.BuildMessage(engineException)); return(ConsoleRunner.UNEXPECTED_ERROR); } if (unloadException != null) { writer.WriteLine(ColorStyle.Warning, Environment.NewLine + ExceptionHelper.BuildMessage(unloadException)); } if (reporter.Summary.UnexpectedError) { return(ConsoleRunner.UNEXPECTED_ERROR); } if (reporter.Summary.InvalidAssemblies > 0) { return(ConsoleRunner.INVALID_ASSEMBLY); } return(reporter.Summary.InvalidTestFixtures > 0 ? ConsoleRunner.INVALID_TEST_FIXTURE : reporter.Summary.FailureCount + reporter.Summary.ErrorCount + reporter.Summary.InvalidCount); } // If we got here, it's because we had an exception, but check anyway if (engineException != null) { writer.WriteLine(ColorStyle.Error, ExceptionHelper.BuildMessage(engineException)); writer.WriteLine(); writer.WriteLine(ColorStyle.Error, ExceptionHelper.BuildMessageAndStackTrace(engineException)); } return(ConsoleRunner.UNEXPECTED_ERROR); }
public IList <string> GetConfigNames(TestPackage package) { return(Services.ProjectService.LoadFrom(package.FullName).ConfigNames); }
public AggregatingTestRunner(IServiceLocator services, TestPackage package) : base(services, package) { }
protected virtual ITestEngineRunner CreateRunner(TestPackage package) { return(TestRunnerFactory.MakeTestRunner(package)); }
protected override ITestEngineRunner CreateRunner(TestPackage package) { return(new TestDomainRunner(Services, package)); }
/// <summary> /// Initializes a new instance of the <see cref="MultipleTestDomainRunner"/> class. /// </summary> /// <param name="services">The services.</param> /// <param name="package">The package.</param> public MultipleTestDomainRunner(IServiceLocator services, TestPackage package) : base(services, package) { }
private Guid LaunchAgentProcess(TestPackage package) { RuntimeFramework targetRuntime; string runtimeSetting = package.GetSetting(EnginePackageSettings.RuntimeFramework, ""); if (runtimeSetting.Length > 0) { if (!RuntimeFramework.TryParse(runtimeSetting, out targetRuntime)) { throw new NUnitEngineException("Invalid or unknown framework requested: " + runtimeSetting); } } else { targetRuntime = RuntimeFramework.CurrentFramework; } if (targetRuntime.Runtime == RuntimeType.Any) { targetRuntime = new RuntimeFramework(RuntimeFramework.CurrentFramework.Runtime, targetRuntime.ClrVersion); } bool useX86Agent = package.GetSetting(EnginePackageSettings.RunAsX86, false); bool debugTests = package.GetSetting(EnginePackageSettings.DebugTests, false); bool debugAgent = package.GetSetting(EnginePackageSettings.DebugAgent, false); string traceLevel = package.GetSetting(EnginePackageSettings.InternalTraceLevel, "Off"); bool loadUserProfile = package.GetSetting(EnginePackageSettings.LoadUserProfile, false); string workDirectory = package.GetSetting(EnginePackageSettings.WorkDirectory, string.Empty); // Set options that need to be in effect before the package // is loaded by using the command line. string agentArgs = "--pid=" + Process.GetCurrentProcess().Id.ToString(); if (traceLevel != "Off") { agentArgs += " --trace:" + traceLevel; } if (debugAgent) { agentArgs += " --debug-agent"; } if (workDirectory != string.Empty) { agentArgs += " --work=" + workDirectory; } log.Info("Getting {0} agent for use under {1}", useX86Agent ? "x86" : "standard", targetRuntime); if (!targetRuntime.IsAvailable) { throw new ArgumentException( string.Format("The {0} framework is not available", targetRuntime), "framework"); } string agentExePath = GetTestAgentExePath(useX86Agent); if (!File.Exists(agentExePath)) { throw new FileNotFoundException( $"{Path.GetFileName(agentExePath)} could not be found.", agentExePath); } log.Debug("Using nunit-agent at " + agentExePath); Process p = new Process(); p.StartInfo.UseShellExecute = false; p.StartInfo.CreateNoWindow = true; p.EnableRaisingEvents = true; p.Exited += OnAgentExit; Guid agentId = Guid.NewGuid(); string arglist = agentId.ToString() + " " + ServerUrl + " " + agentArgs; targetRuntime = ServiceContext.GetService <RuntimeFrameworkService>().GetBestAvailableFramework(targetRuntime); switch (targetRuntime.Runtime) { case RuntimeType.Mono: p.StartInfo.FileName = RuntimeFramework.MonoExePath; string monoOptions = "--runtime=v" + targetRuntime.ClrVersion.ToString(3); if (debugTests || debugAgent) { monoOptions += " --debug"; } p.StartInfo.Arguments = string.Format("{0} \"{1}\" {2}", monoOptions, agentExePath, arglist); break; case RuntimeType.Net: p.StartInfo.FileName = agentExePath; // Override the COMPLUS_Version env variable, this would cause CLR meta host to run a CLR of the specific version string envVar = "v" + targetRuntime.ClrVersion.ToString(3); p.StartInfo.EnvironmentVariables["COMPLUS_Version"] = envVar; // Leave a marker that we have changed this variable, so that the agent could restore it for any code or child processes running within the agent string cpvOriginal = Environment.GetEnvironmentVariable("COMPLUS_Version"); p.StartInfo.EnvironmentVariables["TestAgency_COMPLUS_Version_Original"] = string.IsNullOrEmpty(cpvOriginal) ? "NULL" : cpvOriginal; p.StartInfo.Arguments = arglist; p.StartInfo.LoadUserProfile = loadUserProfile; break; default: p.StartInfo.FileName = agentExePath; p.StartInfo.Arguments = arglist; break; } p.Start(); log.Debug("Launched Agent process {0} - see nunit-agent_{0}.log", p.Id); log.Debug("Command line: \"{0}\" {1}", p.StartInfo.FileName, p.StartInfo.Arguments); _agentData.Add(new AgentRecord(agentId, p, null, AgentStatus.Starting)); return(agentId); }
// This is public static for ease of testing public static TestPackage MakeTestPackage(ConsoleOptions options) { TestPackage package = new TestPackage(options.InputFiles); if (options.ProcessModelSpecified) { package.AddSetting(EnginePackageSettings.ProcessModel, options.ProcessModel); } if (options.DomainUsageSpecified) { package.AddSetting(EnginePackageSettings.DomainUsage, options.DomainUsage); } if (options.FrameworkSpecified) { package.AddSetting(EnginePackageSettings.RuntimeFramework, options.Framework); } if (options.RunAsX86) { package.AddSetting(EnginePackageSettings.RunAsX86, true); } // Console runner always sets DisposeRunners //if (options.DisposeRunners) package.AddSetting(EnginePackageSettings.DisposeRunners, true); if (options.ShadowCopyFiles) { package.AddSetting(EnginePackageSettings.ShadowCopyFiles, true); } if (options.LoadUserProfile) { package.AddSetting(EnginePackageSettings.LoadUserProfile, true); } if (options.SkipNonTestAssemblies) { package.AddSetting(EnginePackageSettings.SkipNonTestAssemblies, true); } if (options.DefaultTimeout >= 0) { package.AddSetting(FrameworkPackageSettings.DefaultTimeout, options.DefaultTimeout); } if (options.InternalTraceLevelSpecified) { package.AddSetting(FrameworkPackageSettings.InternalTraceLevel, options.InternalTraceLevel); } if (options.ActiveConfigSpecified) { package.AddSetting(EnginePackageSettings.ActiveConfig, options.ActiveConfig); } // Always add work directory, in case current directory is changed var workDirectory = options.WorkDirectory ?? Environment.CurrentDirectory; package.AddSetting(FrameworkPackageSettings.WorkDirectory, workDirectory); if (options.StopOnError) { package.AddSetting(FrameworkPackageSettings.StopOnError, true); } if (options.MaxAgentsSpecified) { package.AddSetting(EnginePackageSettings.MaxAgents, options.MaxAgents); } if (options.NumberOfTestWorkersSpecified) { package.AddSetting(FrameworkPackageSettings.NumberOfTestWorkers, options.NumberOfTestWorkers); } if (options.RandomSeedSpecified) { package.AddSetting(FrameworkPackageSettings.RandomSeed, options.RandomSeed); } if (options.DebugTests) { package.AddSetting(FrameworkPackageSettings.DebugTests, true); if (!options.NumberOfTestWorkersSpecified) { package.AddSetting(FrameworkPackageSettings.NumberOfTestWorkers, 0); } } if (options.PauseBeforeRun) { package.AddSetting(FrameworkPackageSettings.PauseBeforeRun, true); } if (options.PrincipalPolicy != null) { package.AddSetting(EnginePackageSettings.PrincipalPolicy, options.PrincipalPolicy); } #if DEBUG if (options.DebugAgent) { package.AddSetting(EnginePackageSettings.DebugAgent, true); } //foreach (KeyValuePair<string, object> entry in package.Settings) // if (!(entry.Value is string || entry.Value is int || entry.Value is bool)) // throw new Exception(string.Format("Package setting {0} is not a valid type", entry.Key)); #endif if (options.DefaultTestNamePattern != null) { package.AddSetting(FrameworkPackageSettings.DefaultTestNamePattern, options.DefaultTestNamePattern); } if (options.TestParameters.Count != 0) { AddTestParametersSetting(package, options.TestParameters); } if (options.ConfigurationFile != null) { package.AddSetting(EnginePackageSettings.ConfigurationFile, options.ConfigurationFile); } return(package); }
public void CreateRunner(TestPackage testPackage) { package = testPackage; Runner = TestEngine.GetRunner(package); }
/// <summary> /// Selects a target runtime framework for a TestPackage based on /// the settings in the package and the assemblies themselves. /// The package RuntimeFramework setting may be updated as a /// result and the selected runtime is returned. /// </summary> /// <param name="package">A TestPackage</param> /// <returns>The selected RuntimeFramework</returns> public RuntimeFramework SelectRuntimeFramework(TestPackage package) { RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; string frameworkSetting = package.GetSetting(RunnerSettings.RuntimeFramework, ""); RuntimeFramework requestedFramework = frameworkSetting.Length > 0 ? RuntimeFramework.Parse(frameworkSetting) : new RuntimeFramework(RuntimeType.Any, RuntimeFramework.DefaultVersion); log.Debug("Current framework is {0}", currentFramework); if (requestedFramework == null) { log.Debug("No specific framework requested"); } else { log.Debug("Requested framework is {0}", requestedFramework); } RuntimeType targetRuntime = requestedFramework.Runtime; Version targetVersion = requestedFramework.FrameworkVersion; if (targetRuntime == RuntimeType.Any) { targetRuntime = currentFramework.Runtime; } if (targetVersion == RuntimeFramework.DefaultVersion) { if (ServiceContext.UserSettings.GetSetting("Options.TestLoader.RuntimeSelectionEnabled", true)) { foreach (string assembly in package.TestFiles) { using (AssemblyReader reader = new AssemblyReader(assembly)) { Version v = new Version(reader.ImageRuntimeVersion.Substring(1)); log.Debug("Assembly {0} uses version {1}", assembly, v); if (v > targetVersion) { targetVersion = v; } } } } else { targetVersion = RuntimeFramework.CurrentFramework.ClrVersion; } RuntimeFramework checkFramework = new RuntimeFramework(targetRuntime, targetVersion); if (!checkFramework.IsAvailable || !ServiceContext.TestAgency.IsRuntimeVersionSupported(targetVersion)) { log.Debug("Preferred version {0} is not installed or this NUnit installation does not support it", targetVersion); if (targetVersion < currentFramework.FrameworkVersion) { targetVersion = currentFramework.FrameworkVersion; } } } RuntimeFramework targetFramework = new RuntimeFramework(targetRuntime, targetVersion); package.Settings[RunnerSettings.RuntimeFramework] = targetFramework.ToString(); log.Debug("Test will use {0} framework", targetFramework); return(targetFramework); }
/// <summary> /// Use Mono.Cecil to get information about all assemblies and /// apply it to the package using special internal keywords. /// </summary> /// <param name="package"></param> private static void ApplyImageData(TestPackage package) { string packageName = package.FullName; Version targetVersion = new Version(0, 0); string frameworkName = null; bool requiresX86 = false; bool requiresAssemblyResolver = false; // We are doing two jobs here: (1) in the else clause (below) // we get information about a single assembly and record it, // (2) in the if clause, we recursively examine all subpackages // and then apply policies for promulgating each setting to // a containing package. We could implement the policy part at // a higher level, but it seems simplest to do it right here. if (package.SubPackages.Count > 0) { foreach (var subPackage in package.SubPackages) { ApplyImageData(subPackage); // Collect the highest version required Version v = subPackage.GetSetting(InternalEnginePackageSettings.ImageRuntimeVersion, new Version(0, 0)); if (v > targetVersion) { targetVersion = v; } // Collect highest framework name // TODO: This assumes lexical ordering is valid - check it string fn = subPackage.GetSetting(InternalEnginePackageSettings.ImageTargetFrameworkName, ""); if (fn != "") { if (frameworkName == null || fn.CompareTo(frameworkName) < 0) { frameworkName = fn; } } // If any assembly requires X86, then the aggregate package requires it if (subPackage.GetSetting(InternalEnginePackageSettings.ImageRequiresX86, false)) { requiresX86 = true; } if (subPackage.GetSetting(InternalEnginePackageSettings.ImageRequiresDefaultAppDomainAssemblyResolver, false)) { requiresAssemblyResolver = true; } } } else if (File.Exists(packageName) && PathUtils.IsAssemblyFileType(packageName)) { var assembly = AssemblyDefinition.ReadAssembly(packageName); targetVersion = assembly.GetRuntimeVersion(); log.Debug($"Assembly {packageName} uses version {targetVersion}"); frameworkName = assembly.GetFrameworkName(); log.Debug($"Assembly {packageName} targets {frameworkName}"); if (assembly.RequiresX86()) { requiresX86 = true; log.Debug($"Assembly {packageName} will be run x86"); } if (assembly.HasAttribute("NUnit.Framework.TestAssemblyDirectoryResolveAttribute")) { requiresAssemblyResolver = true; log.Debug($"Assembly {packageName} requires default app domain assembly resolver"); } } if (targetVersion.Major > 0) { package.Settings[InternalEnginePackageSettings.ImageRuntimeVersion] = targetVersion; } if (!string.IsNullOrEmpty(frameworkName)) { package.Settings[InternalEnginePackageSettings.ImageTargetFrameworkName] = frameworkName; } package.Settings[InternalEnginePackageSettings.ImageRequiresX86] = requiresX86; if (requiresX86) { package.Settings[EnginePackageSettings.RunAsX86] = true; } package.Settings[InternalEnginePackageSettings.ImageRequiresDefaultAppDomainAssemblyResolver] = requiresAssemblyResolver; }
public override ITestEngineRunner CreateRunner(TestPackage package) { _package = package; return(this); }
public ITestEngineRunner CreateRunner(TestPackage package) { return(_remoteAgent.CreateRunner(package)); }
string IRuntimeFrameworkService.SelectRuntimeFramework(TestPackage package) { return(string.Empty); }
public static Mock <TestPackageReader> CreateNuGetPackage( string id = "theId", string version = "01.0.42.0", string title = "theTitle", string summary = "theSummary", string authors = "theFirstAuthor, theSecondAuthor", string owners = "Package owners", string description = "theDescription", string tags = "theTags", string language = null, string copyright = "theCopyright", string releaseNotes = "theReleaseNotes", string minClientVersion = null, Uri licenseUrl = null, Uri projectUrl = null, Uri iconUrl = null, bool requireLicenseAcceptance = true, IEnumerable <PackageDependencyGroup> packageDependencyGroups = null, IEnumerable <NuGet.Packaging.Core.PackageType> packageTypes = null, RepositoryMetadata repositoryMetadata = null, bool isSigned = false) { licenseUrl = licenseUrl ?? new Uri("http://thelicenseurl/"); projectUrl = projectUrl ?? new Uri("http://theprojecturl/"); iconUrl = iconUrl ?? new Uri("http://theiconurl/"); if (packageDependencyGroups == null) { packageDependencyGroups = new[] { new PackageDependencyGroup( new NuGetFramework("net40"), new[] { new NuGet.Packaging.Core.PackageDependency( "theFirstDependency", VersionRange.Parse("[1.0.0, 2.0.0)")), new NuGet.Packaging.Core.PackageDependency( "theSecondDependency", VersionRange.Parse("[1.0]")), new NuGet.Packaging.Core.PackageDependency( "theThirdDependency") }), new PackageDependencyGroup( new NuGetFramework("net35"), new[] { new NuGet.Packaging.Core.PackageDependency( "theFourthDependency", VersionRange.Parse("[1.0]")) }) }; } if (packageTypes == null) { packageTypes = new[] { new NuGet.Packaging.Core.PackageType("dependency", new Version("1.0.0")), new NuGet.Packaging.Core.PackageType("DotNetCliTool", new Version("2.1.1")) }; } var testPackage = TestPackage.CreateTestPackageStream( id, version, title, summary, authors, owners, description, tags, language, copyright, releaseNotes, minClientVersion, licenseUrl, projectUrl, iconUrl, requireLicenseAcceptance, packageDependencyGroups, packageTypes, repositoryMetadata, archive => { if (isSigned) { var entry = archive.CreateEntry(SigningSpecifications.V1.SignaturePath); using (var stream = entry.Open()) using (var writer = new StreamWriter(stream)) { writer.Write("Fake signature file."); } } }); var mock = new Mock <TestPackageReader>(testPackage); mock.CallBase = true; return(mock); }
string IRuntimeFrameworkService.SelectRuntimeFramework(TestPackage package) { throw new NotImplementedException(); }
/// <summary> /// Creates a test runner /// </summary> public abstract ITestEngineRunner CreateRunner(TestPackage package);
public ProcessRunner(ServiceContext services, TestPackage package) : base(services, package) { }
private Process LaunchAgentProcess(TestPackage package, Guid agentId) { string runtimeSetting = package.GetSetting(EnginePackageSettings.RuntimeFramework, ""); // TEMPORARY Guard in preparation for removing Runtime.Any Guard.OperationValid(runtimeSetting.Length > 0, "LaunchAgentProcess called with no runtime specified"); var targetRuntime = RuntimeFramework.Parse(runtimeSetting); bool useX86Agent = package.GetSetting(EnginePackageSettings.RunAsX86, false); bool debugTests = package.GetSetting(EnginePackageSettings.DebugTests, false); bool debugAgent = package.GetSetting(EnginePackageSettings.DebugAgent, false); string traceLevel = package.GetSetting(EnginePackageSettings.InternalTraceLevel, "Off"); bool loadUserProfile = package.GetSetting(EnginePackageSettings.LoadUserProfile, false); string workDirectory = package.GetSetting(EnginePackageSettings.WorkDirectory, string.Empty); var agentArgs = new StringBuilder(); // Set options that need to be in effect before the package // is loaded by using the command line. agentArgs.Append("--pid=").Append(Process.GetCurrentProcess().Id); if (traceLevel != "Off") { agentArgs.Append(" --trace:").EscapeProcessArgument(traceLevel); } if (debugAgent) { agentArgs.Append(" --debug-agent"); } if (workDirectory != string.Empty) { agentArgs.Append(" --work=").EscapeProcessArgument(workDirectory); } log.Info("Getting {0} agent for use under {1}", useX86Agent ? "x86" : "standard", targetRuntime); if (!_runtimeService.IsAvailable(targetRuntime.Id)) { throw new ArgumentException( string.Format("The {0} framework is not available", targetRuntime), "framework"); } string agentExePath = GetTestAgentExePath(useX86Agent); if (!File.Exists(agentExePath)) { throw new FileNotFoundException( $"{Path.GetFileName(agentExePath)} could not be found.", agentExePath); } log.Debug("Using testcentric-agent at " + agentExePath); Process p = new Process(); p.StartInfo.UseShellExecute = false; p.StartInfo.CreateNoWindow = true; p.EnableRaisingEvents = true; p.Exited += (sender, e) => OnAgentExit((Process)sender, agentId); string arglist = agentId.ToString() + " " + ServerUrl + " " + agentArgs; targetRuntime = ServiceContext.GetService <RuntimeFrameworkService>().GetBestAvailableFramework(targetRuntime); if (targetRuntime.Runtime == Runtime.Mono) { p.StartInfo.FileName = targetRuntime.MonoExePath; string monoOptions = "--runtime=v" + targetRuntime.ClrVersion.ToString(3); if (debugTests || debugAgent) { monoOptions += " --debug"; } p.StartInfo.Arguments = string.Format("{0} \"{1}\" {2}", monoOptions, agentExePath, arglist); } else if (targetRuntime.Runtime == Runtime.Net) { p.StartInfo.FileName = agentExePath; // Override the COMPLUS_Version env variable, this would cause CLR meta host to run a CLR of the specific version string envVar = "v" + targetRuntime.ClrVersion.ToString(3); p.StartInfo.EnvironmentVariables["COMPLUS_Version"] = envVar; // Leave a marker that we have changed this variable, so that the agent could restore it for any code or child processes running within the agent string cpvOriginal = Environment.GetEnvironmentVariable("COMPLUS_Version"); p.StartInfo.EnvironmentVariables["TestAgency_COMPLUS_Version_Original"] = string.IsNullOrEmpty(cpvOriginal) ? "NULL" : cpvOriginal; p.StartInfo.Arguments = arglist; p.StartInfo.LoadUserProfile = loadUserProfile; } else { p.StartInfo.FileName = agentExePath; p.StartInfo.Arguments = arglist; } p.Start(); log.Debug("Launched Agent process {0} - see testcentric-agent_{0}.log", p.Id); log.Debug("Command line: \"{0}\" {1}", p.StartInfo.FileName, p.StartInfo.Arguments); _agents.Start(agentId, p); return(p); }
public ProcessRunner(IServiceLocator services, TestPackage package) : base(services, package) { _agency = Services.GetService <TestAgency>(); }
/// <summary> /// Selects a target runtime framework for a TestPackage based on /// the settings in the package and the assemblies themselves. /// The package RuntimeFramework setting may be updated as a result /// and a string representing the selected runtime is returned. /// </summary> /// <param name="package">A TestPackage</param> /// <returns>A string representing the selected RuntimeFramework</returns> public string SelectRuntimeFramework(TestPackage package) { // Evaluate package target framework ApplyImageData(package); // Examine the provided settings RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework; string frameworkSetting = package.GetSetting(EnginePackageSettings.RuntimeFramework, ""); RuntimeFramework requestedFramework; if (frameworkSetting.Length > 0) { if (!RuntimeFramework.TryParse(frameworkSetting, out requestedFramework)) { throw new NUnitEngineException("Invalid or unknown framework requested: " + frameworkSetting); } } else { requestedFramework = new RuntimeFramework(RuntimeType.Any, RuntimeFramework.DefaultVersion); } log.Debug("Current framework is {0}", currentFramework); if (requestedFramework == null) { log.Debug("No specific framework requested"); } else { log.Debug("Requested framework is {0}", requestedFramework); } RuntimeType targetRuntime = requestedFramework.Runtime; Version targetVersion = requestedFramework.FrameworkVersion; if (targetRuntime == RuntimeType.Any) { targetRuntime = currentFramework.Runtime; } if (targetVersion == RuntimeFramework.DefaultVersion) { targetVersion = package.GetSetting(InternalEnginePackageSettings.ImageRuntimeVersion, currentFramework.FrameworkVersion); } if (!new RuntimeFramework(targetRuntime, targetVersion).IsAvailable) { log.Debug("Preferred version {0} is not installed or this NUnit installation does not support it", targetVersion); if (targetVersion < currentFramework.FrameworkVersion) { targetVersion = currentFramework.FrameworkVersion; } } RuntimeFramework targetFramework = new RuntimeFramework(targetRuntime, targetVersion); package.Settings[EnginePackageSettings.RuntimeFramework] = targetFramework.ToString(); log.Debug("Test will use {0} framework", targetFramework); return(targetFramework.ToString()); }
private static TestRunner MakeRunnerFromCommandLine(ConsoleOptions options) { TestPackage package; ConsoleOptions.DomainUsage domainUsage = ConsoleOptions.DomainUsage.Default; if (options.IsTestProject) { NUnitProject project = NUnitProject.LoadProject((string)options.Parameters[0]); string configName = options.config; if (configName != null) { project.SetActiveConfig(configName); } package = project.ActiveConfig.MakeTestPackage(); package.TestName = options.fixture; domainUsage = ConsoleOptions.DomainUsage.Single; } else if (options.Parameters.Count == 1) { package = new TestPackage((string)options.Parameters[0]); domainUsage = ConsoleOptions.DomainUsage.Single; } else { package = new TestPackage("UNNAMED", options.Parameters); domainUsage = ConsoleOptions.DomainUsage.Multiple; } if (options.domain != ConsoleOptions.DomainUsage.Default) { domainUsage = options.domain; } TestRunner testRunner = null; switch (domainUsage) { case ConsoleOptions.DomainUsage.None: testRunner = new NUnit.Core.RemoteTestRunner(); // Make sure that addins are available CoreExtensions.Host.AddinRegistry = Services.AddinRegistry; break; case ConsoleOptions.DomainUsage.Single: testRunner = new TestDomain(); break; case ConsoleOptions.DomainUsage.Multiple: testRunner = new MultipleTestDomainRunner(); break; } package.TestName = options.fixture; package.Settings["ShadowCopyFiles"] = !options.noshadow; package.Settings["UseThreadedRunner"] = !options.nothread; testRunner.Load(package); return(testRunner); }
public ITestAgent GetAgent(TestPackage package, int waitTime) { // TODO: Decide if we should reuse agents return(CreateRemoteAgent(package, waitTime)); }
public AgentProcess(TestAgency agency, TestPackage package, Guid agentId) { // Get target runtime string runtimeSetting = package.GetSetting(EnginePackageSettings.TargetRuntimeFramework, ""); TargetRuntime = RuntimeFramework.Parse(runtimeSetting); // Access other package settings bool runAsX86 = package.GetSetting(EnginePackageSettings.RunAsX86, false); bool debugTests = package.GetSetting(EnginePackageSettings.DebugTests, false); bool debugAgent = package.GetSetting(EnginePackageSettings.DebugAgent, false); string traceLevel = package.GetSetting(EnginePackageSettings.InternalTraceLevel, "Off"); bool loadUserProfile = package.GetSetting(EnginePackageSettings.LoadUserProfile, false); string workDirectory = package.GetSetting(EnginePackageSettings.WorkDirectory, string.Empty); AgentArgs = new StringBuilder($"{agentId} {agency.ServerUrl} --pid={Process.GetCurrentProcess().Id}"); // Set options that need to be in effect before the package // is loaded by using the command line. if (traceLevel != "Off") { AgentArgs.Append(" --trace=").EscapeProcessArgument(traceLevel); } if (debugAgent) { AgentArgs.Append(" --debug-agent"); } if (workDirectory != string.Empty) { AgentArgs.Append(" --work=").EscapeProcessArgument(workDirectory); } AgentExePath = GetTestAgentExePath(TargetRuntime, runAsX86); log.Debug("Using nunit-agent at " + AgentExePath); StartInfo.UseShellExecute = false; StartInfo.CreateNoWindow = true; StartInfo.WorkingDirectory = Environment.CurrentDirectory; EnableRaisingEvents = true; if (TargetRuntime.Runtime == RuntimeType.Mono) { StartInfo.FileName = RuntimeFramework.MonoExePath; string monoOptions = "--runtime=v" + TargetRuntime.ClrVersion.ToString(3); if (debugTests || debugAgent) { monoOptions += " --debug"; } StartInfo.Arguments = string.Format("{0} \"{1}\" {2}", monoOptions, AgentExePath, AgentArgs); } else if (TargetRuntime.Runtime == RuntimeType.Net) { StartInfo.FileName = AgentExePath; StartInfo.Arguments = AgentArgs.ToString(); StartInfo.LoadUserProfile = loadUserProfile; } else { StartInfo.FileName = AgentExePath; StartInfo.Arguments = AgentArgs.ToString(); } }