public TestEngineResult Load(TestPackage package)
{
//System.Diagnostics.Debug.Assert(false, "Attach debugger if desired");
this.runner = Services.TestRunnerFactory.MakeTestRunner(package);
return(runner.Load(package));
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
log.Info("Loading " + TestPackage.Name);
Unload();
try
{
if (_agent == null)
{
_agent = _agency.GetAgent(TestPackage, 30000);
if (_agent == null)
throw new Exception("Unable to acquire remote process agent");
}
if (_remoteRunner == null)
_remoteRunner = _agent.CreateRunner(TestPackage);
return _remoteRunner.Load();
}
catch(Exception)
{
// TODO: Check if this is really needed
// Clean up if the load failed
Unload();
throw;
}
}
public TestEngineResult Load()
{
//System.Diagnostics.Debug.Assert(false, "Attach debugger if desired");
_runner = Services.GetService <ITestRunnerFactory>().MakeTestRunner(_package);
return(_runner.Load());
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
// Some files in the top level package may be projects.
// Expand them so that they contain subprojects for
// each contained assembly.
ExpandProjects();
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
_runtimeService.SelectRuntimeFramework(TestPackage);
if (IntPtr.Size == 8 &&
TestPackage.GetSetting(PackageSettings.ProcessModel, "") == "InProcess" &&
TestPackage.GetSetting(PackageSettings.RunAsX86, false))
{
throw new NUnitEngineException("Cannot run tests in process - a 32 bit process is required.");
}
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return(_realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName));
}
//Exposed for testing
internal ITestEngineRunner GetEngineRunner()
{
if (_engineRunner == null)
{
// Expand any project subpackages
_packageAnalyzer.ExpandProjectPackages(TestPackage);
// Add package settings to reflect the target runtime
// and test framework usage of each assembly.
foreach (var package in TestPackage.Select(p => p.IsAssemblyPackage()))
{
if (File.Exists(package.FullName))
{
_packageAnalyzer.ApplyImageSettings(package);
}
}
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
_runtimeService.SelectRuntimeFramework(TestPackage);
_engineRunner = _testRunnerFactory.MakeTestRunner(TestPackage);
}
return(_engineRunner);
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
log.Info("Loading " + TestPackage.Name);
Unload();
try
{
if (_agent == null)
{
_agent = _agency.GetAgent(TestPackage, 30000);
if (_agent == null)
{
throw new Exception("Unable to acquire remote process agent");
}
}
if (_remoteRunner == null)
{
_remoteRunner = _agent.CreateRunner(TestPackage);
}
return(_remoteRunner.Load());
}
catch (Exception)
{
// TODO: Check if this is really needed
// Clean up if the load failed
Unload();
throw;
}
}
public TestExecutionTask(ITestEngineRunner runner, ITestEventListener listener, TestFilter filter, bool disposeRunner)
{
_disposeRunner = disposeRunner;
_filter = filter;
_listener = listener;
_runner = runner;
}
public TestExecutionTask(ITestEngineRunner runner, ITestEventListener listener, TestFilter filter, bool disposeRunner)
{
_disposeRunner = disposeRunner;
_filter = filter;
_listener = listener;
_runner = runner;
}
public override bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
RuntimeFramework targetFramework = ServiceContext.RuntimeFrameworkSelector.SelectRuntimeFramework(package);
ProcessModel processModel = (ProcessModel)System.Enum.Parse(
typeof(ProcessModel),
package.GetSetting(RunnerSettings.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));
}
}
public MasterTestRunner(IServiceLocator services, TestPackage package)
{
if (services == null)
{
throw new ArgumentNullException("services");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
_services = services;
TestPackage = package;
// Get references to the services we use
_projectService = _services.GetService <IProjectService>();
#if !NETSTANDARD1_6 && !NETSTANDARD2_0
_runtimeService = _services.GetService <IRuntimeFrameworkService>();
#endif
#if !NETSTANDARD1_6
_extensionService = _services.GetService <ExtensionService>();
#endif
_engineRunner = _services.GetService <ITestRunnerFactory>().MakeTestRunner(package);
InitializePackage();
}
// TODO: Review this method once used by a gui - the implementation is
// overly simplistic. It is not currently used by any known runner.
public bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
#if NETSTANDARD2_0
return(false);
#else
return(runner is MultipleTestProcessRunner);
#endif
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Temporarily using AggregatingTestRunner for everything
//_realRunner = new AggregatingTestRunner(Services, TestPackage);
_realRunner = Services.TestRunnerFactory.MakeTestRunner(TestPackage);
return(_realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName));
}
/// <summary>
/// Construct a new TestRun
/// </summary>
/// <param name="listener">The ITestEventListener to use for this run</param>
/// <param name="filter">The TestFilter to use for this run</param>
public TestRun(ITestEngineRunner runner)
{
_runner = runner;
_worker = new BackgroundWorker();
_worker.WorkerSupportsCancellation = true;
_worker.WorkerReportsProgress = true; // ?
}
/// <summary>
/// Initializes a new instance of the <see cref="TestRun"/> class.
/// </summary>
/// <param name="runner">The <see cref="ITestEngineRunner"/> to use for this run.</param>
public TestRun(ITestEngineRunner runner)
{
_runner = runner;
_worker = new BackgroundWorker();
_worker.WorkerSupportsCancellation = true;
_worker.WorkerReportsProgress = true; // ?
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void UnloadPackage()
{
if (_remoteRunner != null)
{
log.Info("Unloading remote runner");
_remoteRunner.Unload();
_remoteRunner = null;
}
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void Unload()
{
if (this.remoteRunner != null)
{
log.Info("Unloading remote runner");
this.remoteRunner.Unload();
this.remoteRunner = null;
}
}
private void CommandLoop()
{
bool keepRunning = true;
var socketReader = new SocketReader(_clientSocket, new BinarySerializationProtocol());
while (keepRunning)
{
var command = socketReader.GetNextMessage <CommandMessage>();
switch (command.CommandName)
{
case "CreateRunner":
var package = (TestPackage)command.Arguments[0];
_runner = CreateRunner(package);
break;
case "Load":
SendResult(_runner.Load());
break;
case "Reload":
SendResult(_runner.Reload());
break;
case "Unload":
_runner.Unload();
break;
case "Explore":
var filter = (TestFilter)command.Arguments[0];
SendResult(_runner.Explore(filter));
break;
case "CountTestCases":
filter = (TestFilter)command.Arguments[0];
SendResult(_runner.CountTestCases(filter));
break;
case "Run":
filter = (TestFilter)command.Arguments[0];
SendResult(_runner.Run(this, filter));
break;
case "RunAsync":
filter = (TestFilter)command.Arguments[0];
_runner.RunAsync(this, filter);
break;
case "Stop":
keepRunning = false;
break;
}
}
Stop();
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return(_realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName));
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return _realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName);
}
private static RunnerResult GetRunnerResult(ITestEngineRunner runner)
{
var result = new RunnerResult(runner.GetType());
if (runner is AggregatingTestRunner aggRunner)
{
result.SubRunners = aggRunner.Runners.Select(GetRunnerResult).ToList();
}
return(result);
}
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 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);
}
private void PerformPackageSetup(TestPackage package)
{
this.TestPackage = package;
// Expand projects, updating the count of projects and assemblies
ExpandProjects();
// If there is more than one project or a mix of assemblies and
// projects, AggregatingTestRunner will call MakeTestRunner for
// each project or assembly.
_realRunner = _projectCount > 1 || _projectCount > 0 && _assemblyCount > 0
? new AggregatingTestRunner(Services, package)
: Services.TestRunnerFactory.MakeTestRunner(package);
}
public MasterTestRunner(TestPackage package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
TestPackage = package;
// Get references to the services we use
var runnerFactory = new DefaultTestRunnerFactory();
_engineRunner = runnerFactory.MakeTestRunner(package);
InitializePackage();
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void UnloadPackage()
{
try
{
if (_remoteRunner != null)
{
log.Info("Unloading remote runner");
_remoteRunner.Unload();
_remoteRunner = null;
}
}
catch (Exception e)
{
log.Warning("Failed to unload the remote runner. {0}", e.Message);
_remoteRunner = null;
}
}
private void CreateAgentAndRunnerIfNeeded()
{
if (_agent == null)
{
_agent = _agency.GetAgent(TestPackage);
if (_agent == null)
{
throw new NUnitEngineException("Unable to acquire remote process agent");
}
}
if (_remoteRunner == null)
{
_remoteRunner = _agent.CreateRunner(TestPackage);
}
}
// TODO: Review this method once we have a gui - not used by console runner
public override bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
ProcessModel processModel = GetTargetProcessModel(package);
switch (processModel)
{
case ProcessModel.Default:
case ProcessModel.Multiple:
return(runner is MultipleTestProcessRunner);
case ProcessModel.Separate:
return(runner is ProcessRunner);
default:
return(base.CanReuse(runner, package));
}
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void UnloadPackage()
{
try
{
if (_remoteRunner != null)
{
log.Info("Unloading " + TestPackage.Name);
_remoteRunner.Unload();
_remoteRunner = null;
}
}
catch (Exception e)
{
log.Warning("Failed to unload the remote runner. {0}", ExceptionHelper.BuildMessageAndStackTrace(e));
_remoteRunner = null;
throw;
}
}
public void Run(string filePath, string expectedType)
{
// We only create runners for subpackages
var package = new TestPackage(filePath).SubPackages[0];
ITestEngineRunner runner = CreateRunner(package);
var result = runner.Run(new NullListener(), TestFilter.Empty).Xml;
Assert.That(result.Name, Is.EqualTo("test-suite"));
Assert.That(result.GetAttribute("id"), Is.EqualTo(package.ID));
Assert.That(result.GetAttribute("name"), Is.EqualTo(filePath));
Assert.That(result.GetAttribute("fullname"), Is.EqualTo(Path.GetFullPath(filePath)));
Assert.That(result.GetAttribute("type"), Is.EqualTo(expectedType));
Assert.That(result.GetAttribute("runstate"), Is.EqualTo(_expectedRunState));
Assert.That(result.GetAttribute("testcasecount"), Is.EqualTo("0"));
Assert.That(GetSkipReason(result), Is.EqualTo(_expectedReason));
Assert.That(result.SelectNodes("test-suite").Count, Is.EqualTo(0), "Load result should not have child tests");
Assert.That(result.GetAttribute("result"), Is.EqualTo(_expectedResult));
Assert.That(result.GetAttribute("label"), Is.EqualTo(_expectedLabel));
Assert.That(result.SelectSingleNode("reason/message").InnerText, Is.EqualTo(_expectedReason));
}
public MasterTestRunner(IServiceLocator services, TestPackage package)
{
if (services == null)
{
throw new ArgumentNullException("services");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
_services = services;
TestPackage = package;
_projectService = _services.GetService <IProjectService>();
_runtimeService = _services.GetService <IRuntimeFrameworkService>();
_extensionService = _services.GetService <ExtensionService>();
_engineRunner = _services.GetService <ITestRunnerFactory>().MakeTestRunner(package);
LoadPackage();
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
// Some files in the top level package may be projects.
// Expand them so that they contain subprojects for
// each contained assembly.
ExpandProjects();
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
RuntimeService.SelectRuntimeFramework(TestPackage);
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return(_realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName));
}
//Exposed for testing
internal ITestEngineRunner GetEngineRunner()
{
if (_engineRunner == null)
{
// Expand projects and update package settings to reflect the
// target runtime and test framework usage of each assembly.
_packageSettingsService.UpdatePackage(TestPackage);
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
#if !NETSTANDARD2_0
_runtimeService.SelectRuntimeFramework(TestPackage);
#endif
_engineRunner = _testRunnerFactory.MakeTestRunner(TestPackage);
}
return(_engineRunner);
}
private void CreateAgentAndRunner()
{
if (_agent == null)
{
// Increase the timeout to give time to attach a debugger
bool debug = TestPackage.GetSetting(EnginePackageSettings.DebugAgent, false) ||
TestPackage.GetSetting(EnginePackageSettings.PauseBeforeRun, false);
_agent = _agency.GetAgent(TestPackage, debug ? DEBUG_TIMEOUT : NORMAL_TIMEOUT);
if (_agent == null)
{
throw new NUnitEngineException("Unable to acquire remote process agent");
}
}
if (_remoteRunner == null)
{
_remoteRunner = _agent.CreateRunner(TestPackage);
}
}
private void CreateAgentAndRunner(bool enableDebug, string agentArgs)
{
if (_agent == null)
{
_agent = Services.TestAgency.GetAgent(
RuntimeFramework,
30000,
enableDebug,
agentArgs);
if (_agent == null)
{
throw new Exception("Unable to acquire remote process agent");
}
}
if (_remoteRunner == null)
{
_remoteRunner = _agent.CreateRunner(TestPackage);
}
}
//Exposed for testing
internal ITestEngineRunner GetEngineRunner()
{
if (_engineRunner == null)
{
// Some files in the top level package may be projects.
// Expand them so that they contain subprojects for
// each contained assembly.
EnsurePackagesAreExpanded(TestPackage);
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
#if !NETSTANDARD1_6 && !NETSTANDARD2_0
_runtimeService.SelectRuntimeFramework(TestPackage);
#endif
_engineRunner = _testRunnerFactory.MakeTestRunner(TestPackage);
}
return(_engineRunner);
}
public override bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
RuntimeFramework currentFramework = RuntimeFramework.CurrentFramework;
RuntimeFramework targetFramework = ServiceContext.RuntimeFrameworkSelector.SelectRuntimeFramework(package);
ProcessModel processModel = (ProcessModel)System.Enum.Parse(
typeof(ProcessModel),
package.GetSetting(RunnerSettings.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);
}
}
public virtual bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
return false;
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
// Some files in the top level package may be projects.
// Expand them so that they contain subprojects for
// each contained assembly.
ExpandProjects();
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
_runtimeService.SelectRuntimeFramework(TestPackage);
if (TestPackage.GetSetting(PackageSettings.ProcessModel, "") == "InProcess" &&
TestPackage.GetSetting(PackageSettings.RunAsX86, false))
{
throw new NUnitEngineException("Cannot run tests in process - a 32 bit process is required.");
}
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return _realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestRun"/> class.
/// </summary>
public TestRun(ITestEngineRunner runner)
{
_runner = runner;
_waitHandle = new ManualResetEvent(initialState: false);
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void UnloadPackage()
{
try
{
if (_remoteRunner != null)
{
log.Info("Unloading remote runner");
_remoteRunner.Unload();
_remoteRunner = null;
}
}
catch (Exception e)
{
log.Warning("Failed to unload the remote runner. {0}", e.Message);
_remoteRunner = null;
}
}
public TestEngineResult Load()
{
//System.Diagnostics.Debug.Assert(false, "Attach debugger if desired");
_runner = Services.GetService<ITestRunnerFactory>().MakeTestRunner(_package);
return _runner.Load();
}
private void PerformPackageSetup(TestPackage package)
{
this.TestPackage = package;
// Expand projects, updating the count of projects and assemblies
ExpandProjects();
// If there is more than one project or a mix of assemblies and
// projects, AggregatingTestRunner will call MakeTestRunner for
// each project or assembly.
_realRunner = _projectCount > 1 || _projectCount > 0 && _assemblyCount > 0
? new AggregatingTestRunner(Services, package)
: Services.TestRunnerFactory.MakeTestRunner(package);
}
private void CreateAgentAndRunner(bool enableDebug, string agentArgs)
{
if (_agent == null)
{
_agent = Services.TestAgency.GetAgent(
RuntimeFramework,
30000,
enableDebug,
agentArgs);
if (_agent == null)
throw new Exception("Unable to acquire remote process agent");
}
if (_remoteRunner == null)
_remoteRunner = _agent.CreateRunner(TestPackage);
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
// Last chance to catch invalid settings in package,
// in case the client runner missed them.
ValidatePackageSettings();
// Some files in the top level package may be projects.
// Expand them so that they contain subprojects for
// each contained assembly.
ExpandProjects();
// Use SelectRuntimeFramework for its side effects.
// Info will be left behind in the package about
// each contained assembly, which will subsequently
// be used to determine how to run the assembly.
RuntimeService.SelectRuntimeFramework(TestPackage);
_realRunner = TestRunnerFactory.MakeTestRunner(TestPackage);
return _realRunner.Load().Aggregate(TEST_RUN_ELEMENT, TestPackage.Name, TestPackage.FullName);
}
/// <summary>
/// Unload any loaded TestPackage and clear
/// the reference to the remote runner.
/// </summary>
public override void UnloadPackage()
{
if (_remoteRunner != null)
{
log.Info("Unloading remote runner");
_remoteRunner.Unload();
_remoteRunner = null;
}
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <returns>A TestEngineResult.</returns>
protected override TestEngineResult LoadPackage()
{
log.Info("Loading " + TestPackage.Name);
Unload();
try
{
if (_agent == null)
{
// Increase the timeout to give time to attach a debugger
bool debug = TestPackage.GetSetting(PackageSettings.DebugAgent, false) ||
TestPackage.GetSetting(PackageSettings.PauseBeforeRun, false);
_agent = _agency.GetAgent(TestPackage, debug ? DEBUG_TIMEOUT : NORMAL_TIMEOUT);
if (_agent == null)
throw new Exception("Unable to acquire remote process agent");
}
if (_remoteRunner == null)
_remoteRunner = _agent.CreateRunner(TestPackage);
return _remoteRunner.Load();
}
catch(Exception)
{
// TODO: Check if this is really needed
// Clean up if the load failed
Unload();
throw;
}
}
// TODO: Review this method once we have a gui - not used by console runner
public override bool CanReuse(ITestEngineRunner runner, TestPackage package)
{
ProcessModel processModel = GetTargetProcessModel(package);
switch (processModel)
{
case ProcessModel.Default:
case ProcessModel.Multiple:
return runner is MultipleTestProcessRunner;
case ProcessModel.Separate:
return runner is ProcessRunner;
default:
return base.CanReuse(runner, package);
}
}
