/// <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 = 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)
{
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());
}
public void CanDisplayFrameworkAsString(FrameworkData data)
{
RuntimeFramework framework = new RuntimeFramework(data.runtime, data.frameworkVersion);
Assert.That(framework.ToString(), Is.EqualTo(data.representation));
Assert.That(framework.DisplayName, Is.EqualTo(data.displayName));
}
public void CanDisplayFrameworkAsString(FrameworkData data)
{
RuntimeFramework framework = new RuntimeFramework(data.runtime, data.frameworkVersion);
Assert.AreEqual(data.representation, framework.ToString());
Assert.AreEqual(data.displayName, framework.DisplayName);
}
private static RuntimeFramework SelectRuntimeFrameworkInner(TestPackage package)
{
foreach (var subPackage in package.SubPackages)
{
SelectRuntimeFrameworkInner(subPackage);
}
// Examine the provided settings
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
log.Debug("Current framework is " + currentFramework);
string frameworkSetting = package.GetSetting(EnginePackageSettings.RequestedRuntimeFramework, "");
RuntimeFramework requestedFramework;
if (frameworkSetting.Length > 0)
{
if (!RuntimeFramework.TryParse(frameworkSetting, out requestedFramework))
{
throw new NUnitEngineException("Invalid or unknown framework requested: " + frameworkSetting);
}
log.Debug($"Requested framework for {package.Name} is {requestedFramework}");
}
else
{
requestedFramework = new RuntimeFramework(RuntimeType.Any, RuntimeFramework.DefaultVersion);
log.Debug($"No specific framework requested for {package.Name}");
}
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.TargetRuntimeFramework] = targetFramework.ToString();
log.Debug($"Test will use {targetFramework} for {package.Name}");
return(targetFramework);
}
public void UnspecifiedRuntime_SameVersion_Supported(RuntimeFramework f1)
{
// NOTE: Mono 1.0 has a 1.1 ClrVersion, so this doesn't work.
// Since we're phasing out support for 1.x versions, we
// aren't planning to fix this.
Assume.That(f1.ToString() != "mono-1.0");
RuntimeFramework f2 = new RuntimeFramework(RuntimeType.Any, f1.FrameworkVersion);
Assert.That(f1.Supports(f2));
Assert.That(f2.Supports(f1));
}
public void Mono11IsSynonymousWithMono10()
{
RuntimeFramework mono10 = new RuntimeFramework(RuntimeType.Mono, new Version(1, 0));
RuntimeFramework mono11 = new RuntimeFramework(RuntimeType.Mono, new Version(1, 1));
Assert.That(mono11.ToString(), Is.EqualTo("mono-1.0"));
Assert.That(mono11.DisplayName, Is.EqualTo("Mono 1.0"));
Assert.That(mono11.Runtime, Is.EqualTo(RuntimeType.Mono));
Assert.That(mono11.FrameworkVersion, Is.EqualTo(new Version(1, 0)));
Assert.That(mono11.Supports(mono10));
Assert.That(mono10.Supports(mono11));
}
/// <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)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
string frameworkSetting = package.GetSetting(PackageSettings.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)
{
// If the file is not an assembly or doesn't exist, then it can't
// contribute any information to the decision, so we skip it.
if (PathUtils.IsAssemblyFileType(assembly) && File.Exists(assembly))
{
using (var reader = new AssemblyReader(assembly))
{
if (!reader.IsValidPeFile)
{
log.Debug("{0} is not a valid PE file", assembly);
}
else if (!reader.IsDotNetFile)
{
log.Debug("{0} is not a managed assembly", assembly);
}
else
{
if (reader.ShouldRun32Bit)
{
package.Settings[PackageSettings.RunAsX86] = true;
log.Debug("Assembly {0} will be run x86", assembly);
}
var imageRuntimeVersion = reader.ImageRuntimeVersion;
if (imageRuntimeVersion != null)
{
var v = new Version(imageRuntimeVersion.Substring(1));
log.Debug("Assembly {0} uses version {1}", assembly, v);
// TODO: We are doing two jobs here: (1) getting the
// target version and (2) applying a policy that says
// we run under the highest version of all assemblies.
// We should implement the policy at a higher level.
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[PackageSettings.RuntimeFramework] = targetFramework.ToString();
log.Debug("Test will use {0} framework", targetFramework);
return(targetFramework.ToString());
}
/// <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)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
string frameworkSetting = package.GetSetting(PackageSettings.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)
{
var packages = package.SubPackages;
if (packages.Count == 0)
packages.Add(package);
foreach (var subPackage in packages)
{
var assembly = subPackage.FullName;
// If the file is not an assembly or doesn't exist, then it can't
// contribute any information to the decision, so we skip it.
if (PathUtils.IsAssemblyFileType(assembly) && File.Exists(assembly))
{
using (var reader = new AssemblyReader(assembly))
{
if (!reader.IsValidPeFile)
log.Debug("{0} is not a valid PE file", assembly);
else if (!reader.IsDotNetFile)
log.Debug("{0} is not a managed assembly", assembly);
else
{
if (reader.ShouldRun32Bit)
{
package.Settings[PackageSettings.RunAsX86] = true;
log.Debug("Assembly {0} will be run x86", assembly);
}
var imageRuntimeVersion = reader.ImageRuntimeVersion;
if (imageRuntimeVersion != null)
{
var v = new Version(imageRuntimeVersion.Substring(1));
log.Debug("Assembly {0} uses version {1}", assembly, v);
// TODO: We are doing two jobs here: (1) getting the
// target version and (2) applying a policy that says
// we run under the highest version of all assemblies.
// We should implement the policy at a higher level.
if (v > targetVersion) targetVersion = v;
}
}
}
}
}
RuntimeFramework checkFramework = new RuntimeFramework(targetRuntime, targetVersion);
if (!checkFramework.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[PackageSettings.RuntimeFramework] = targetFramework.ToString();
log.Debug("Test will use {0} framework", targetFramework);
return targetFramework.ToString();
}
/// <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)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
string frameworkSetting = package.GetSetting(PackageSettings.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)
{
var packages = package.SubPackages;
if (packages.Count == 0)
{
packages.Add(package);
}
foreach (var subPackage in packages)
{
var assembly = subPackage.FullName;
// If the file is not an assembly or doesn't exist, then it can't
// contribute any information to the decision, so we skip it.
if (PathUtils.IsAssemblyFileType(assembly) && File.Exists(assembly))
{
var module = AssemblyDefinition.ReadAssembly(assembly).MainModule;
var NativeEntryPoint = (ModuleAttributes)16;
var mask = ModuleAttributes.Required32Bit | NativeEntryPoint;
if (module.Architecture != TargetArchitecture.AMD64 &&
module.Architecture != TargetArchitecture.IA64 &&
(module.Attributes & mask) != 0)
{
package.Settings[PackageSettings.RunAsX86] = true;
log.Debug("Assembly {0} will be run x86", assembly);
}
var v = new Version(module.RuntimeVersion.Substring(1));
log.Debug("Assembly {0} uses version {1}", assembly, v);
// TODO: We are doing two jobs here: (1) getting the
// target version and (2) applying a policy that says
// we run under the highest version of all assemblies.
// We should implement the policy at a higher level.
if (v > targetVersion)
{
targetVersion = v;
}
}
}
RuntimeFramework checkFramework = new RuntimeFramework(targetRuntime, targetVersion);
if (!checkFramework.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[PackageSettings.RuntimeFramework] = targetFramework.ToString();
log.Debug("Test will use {0} framework", targetFramework);
return(targetFramework.ToString());
}
public void CanDisplayFrameworkAsString(FrameworkData data)
{
RuntimeFramework framework = new RuntimeFramework(data.runtime, data.frameworkVersion);
Assert.AreEqual(data.representation, framework.ToString());
Assert.AreEqual(data.displayName, framework.DisplayName);
}
/// <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>
/// 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)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
string frameworkSetting = package.GetSetting(PackageSettings.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)
{
var packages = package.SubPackages;
if (packages.Count == 0)
packages.Add(package);
foreach (var subPackage in packages)
{
var assembly = subPackage.FullName;
// If the file is not an assembly or doesn't exist, then it can't
// contribute any information to the decision, so we skip it.
if (PathUtils.IsAssemblyFileType(assembly) && File.Exists(assembly))
{
var module = AssemblyDefinition.ReadAssembly(assembly).MainModule;
var NativeEntryPoint = (ModuleAttributes)16;
var mask = ModuleAttributes.Required32Bit | NativeEntryPoint;
if (module.Architecture != TargetArchitecture.AMD64 &&
module.Architecture != TargetArchitecture.IA64 &&
(module.Attributes & mask) != 0)
{
package.Settings[PackageSettings.RunAsX86] = true;
log.Debug("Assembly {0} will be run x86", assembly);
}
var v = new Version(module.RuntimeVersion.Substring(1));
log.Debug("Assembly {0} uses version {1}", assembly, v);
// TODO: We are doing two jobs here: (1) getting the
// target version and (2) applying a policy that says
// we run under the highest version of all assemblies.
// We should implement the policy at a higher level.
if (v > targetVersion) targetVersion = v;
}
}
RuntimeFramework checkFramework = new RuntimeFramework(targetRuntime, targetVersion);
if (!checkFramework.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[PackageSettings.RuntimeFramework] = targetFramework.ToString();
log.Debug("Test will use {0} framework", targetFramework);
return targetFramework.ToString();
}
/// <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)
{
// Start by examining the provided settings
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
string frameworkSetting = package.GetSetting(EnginePackageSettings.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;
// Examine the package
ApplyImageData(package);
// Modify settings if necessary
targetVersion = package.GetSetting(InternalEnginePackageSettings.ImageRuntimeVersion, targetVersion);
RuntimeFramework checkFramework = new RuntimeFramework(targetRuntime, targetVersion);
if (!checkFramework.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();
}
public void Mono11IsSynonymousWithMono10()
{
RuntimeFramework mono10 = new RuntimeFramework(RuntimeType.Mono, new Version(1, 0));
RuntimeFramework mono11 = new RuntimeFramework(RuntimeType.Mono, new Version(1, 1));
Assert.That(mono11.ToString(), Is.EqualTo("mono-1.0"));
Assert.That(mono11.DisplayName, Is.EqualTo("Mono 1.0"));
Assert.That(mono11.Runtime, Is.EqualTo(RuntimeType.Mono));
Assert.That(mono11.FrameworkVersion, Is.EqualTo(new Version(1, 0)));
Assert.That(mono11.Supports(mono10));
Assert.That(mono10.Supports(mono11));
}
private RuntimeFramework SelectRuntimeFrameworkInner(TestPackage package)
{
foreach (var subPackage in package.SubPackages)
{
SelectRuntimeFrameworkInner(subPackage);
}
// Examine the provided settings
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
log.Debug("Current framework is " + currentFramework);
string frameworkSetting = package.GetSetting(EnginePackageSettings.RequestedRuntimeFramework, "");
RuntimeFramework requestedFramework;
if (frameworkSetting.Length > 0)
{
if (!RuntimeFramework.TryParse(frameworkSetting, out requestedFramework))
{
throw new NUnitEngineException("Invalid or unknown framework requested: " + frameworkSetting);
}
log.Debug($"Requested framework for {package.Name} is {requestedFramework}");
if (!IsAvailable(frameworkSetting))
{
throw new NUnitEngineException("Requested framework is not available: " + frameworkSetting);
}
package.Settings[EnginePackageSettings.TargetRuntimeFramework] = frameworkSetting;
return(requestedFramework);
}
log.Debug($"No specific framework requested for {package.Name}");
string imageTargetFrameworkNameSetting = package.GetSetting(InternalEnginePackageSettings.ImageTargetFrameworkName, "");
RuntimeType targetRuntime;
Version targetVersion;
if (string.IsNullOrEmpty(imageTargetFrameworkNameSetting))
{
// Assume .NET Framework
targetRuntime = currentFramework.Runtime;
targetVersion = package.GetSetting(InternalEnginePackageSettings.ImageRuntimeVersion, new Version(2, 0));
}
else
{
FrameworkName frameworkName = new FrameworkName(imageTargetFrameworkNameSetting);
switch (frameworkName.Identifier)
{
case ".NETFramework":
targetRuntime = RuntimeType.Net;
break;
case ".NETCoreApp":
targetRuntime = RuntimeType.NetCore;
break;
default:
throw new NUnitEngineException("Unsupported Target Framework: " + imageTargetFrameworkNameSetting);
}
targetVersion = frameworkName.Version;
}
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.TargetRuntimeFramework] = targetFramework.ToString();
log.Debug($"Test will use {targetFramework} for {package.Name}");
return(targetFramework);
}
/// <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;
}
public void UnspecifiedRuntime_SameVersion_Supported(RuntimeFramework f1)
{
// NOTE: Mono 1.0 has a 1.1 ClrVersion, so this doesn't work.
// Since we're phasing out support for 1.x versions, we
// aren't planning to fix this.
Assume.That(f1.ToString() != "mono-1.0");
RuntimeFramework f2 = new RuntimeFramework(RuntimeType.Any, f1.FrameworkVersion);
Assert.That(f1.Supports(f2));
Assert.That(f2.Supports(f1));
}
