/// <summary>
/// Flags Unity projects for debugging with this addin
/// </summary>
protected override bool CanExecute (SolutionEntityItem item, ExecutionContext context, ConfigurationSelector configuration)
{
if (CanExecuteProject (item as Project, context)) {
return context.ExecutionHandler.CanExecute (new UnityExecutionCommand (item.BaseDirectory.FullPath));
}
return base.CanExecute (item, context, configuration);
}
protected override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
if (base.OnGetCanExecute(context, configuration))
{
return base.OnExecute(monitor, context, configuration);
}
try
{
var project = Project as DotNetProject;
if (project != null && IsSupportedProject)
{
const string SoftDebuggerName = RhinoSoftDebuggerEngine.DebuggerName;
var config = project.GetConfiguration(configuration) as DotNetProjectConfiguration;
var cmd = new RhinoCommonExecutionCommand(project.GetOutputFileName(configuration), project);
cmd.Arguments = config.CommandLineParameters;
cmd.WorkingDirectory = Path.GetDirectoryName(config.CompiledOutputName);
cmd.EnvironmentVariables = config.GetParsedEnvironmentVariables();
cmd.TargetRuntime = project.TargetRuntime;
cmd.UserAssemblyPaths = project.GetUserAssemblyPaths(configuration);
var executionModes = Runtime.ProcessService.GetExecutionModes();
var executionMode = executionModes.SelectMany(r => r.ExecutionModes).FirstOrDefault(r => r.Id == SoftDebuggerName);
var console = context.ConsoleFactory.CreateConsole(new OperationConsoleFactory.CreateConsoleOptions(true));
var operation = executionMode.ExecutionHandler.Execute(cmd, console);
monitor.CancellationToken.Register(() => operation.Cancel());
return operation.Task;
}
}
catch (Exception ex)
{
monitor.ReportError($"An error occurred starting Rhino.\n{ex}", ex);
}
return null;
}
/// <summary>
/// Determines whether this solution item can be executed using the specified context and configuration.
/// </summary>
/// <param name="context">Context.</param>
/// <param name="solutionConfiguration">Solution configuration.</param>
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector solutionConfiguration)
{
var conf = (CProjectConfiguration)GetConfiguration(solutionConfiguration);
ExecutionCommand cmd = CreateExecutionCommand(conf);
return((target == CompileTarget.Exe) && context.ExecutionHandler.CanExecute(cmd));
}
public static AsyncOperation RunTests(IEnumerable <UnitTest> tests, MonoDevelop.Projects.ExecutionContext context)
{
var result = RunTests(tests, context, IdeApp.Preferences.BuildBeforeRunningTests);
result.Task.ContinueWith(t => OnTestSessionCompleted(), TaskScheduler.FromCurrentSynchronizationContext());
return(result);
}
internal protected virtual Task Execute (ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionRunConfiguration runConfiguration)
{
context.RunConfiguration = runConfiguration;
#pragma warning disable 618 // Type or member is obsolete
return Execute (monitor, context, configuration);
#pragma warning restore 618 // Type or member is obsolete
}
public static AsyncOperation RunTest(UnitTest test, MonoDevelop.Projects.ExecutionContext context)
{
var result = RunTest(test, context, true);
result.Task.ContinueWith(t => OnTestSessionCompleted(), TaskScheduler.FromCurrentSynchronizationContext());
return(result);
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector config)
{
var configuration = (AspNetAppProjectConfiguration)GetConfiguration(config);
var cmd = CreateExecutionCommand(config, configuration);
return(context.ExecutionHandler.CanExecute(cmd));
}
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
IodineConfiguration config = (IodineConfiguration)GetConfiguration (configuration);
IConsole console = config.ExternalConsole ?
context.ExternalConsoleFactory.CreateConsole (!config.PauseConsoleOutput) :
context.ConsoleFactory.CreateConsole (!config.PauseConsoleOutput);
AggregatedOperationMonitor aggregatedMonitor = new AggregatedOperationMonitor (monitor);
try {
string param = string.Format ("\"{0}\" {1}", config.MainFile, config.CommandLineParameters);
IProcessAsyncOperation op = Runtime.ProcessService.StartConsoleProcess ("iodine",
param, BaseDirectory,
config.EnvironmentVariables, console, null);
monitor.CancelRequested += delegate {
op.Cancel ();
};
aggregatedMonitor.AddOperation (op);
op.WaitForCompleted ();
monitor.Log.WriteLine ("Iodine exited with code: " + op.ExitCode);
} catch (Exception e) {
monitor.ReportError (GettextCatalog.GetString ("Cannot execute \"{0}\"", config.MainFile), e);
} finally {
console.Dispose ();
aggregatedMonitor.Dispose ();
}
}
internal static async Task RunTests(IEnumerable <UnitTest> tests, MonoDevelop.Projects.ExecutionContext context, bool buildOwnerObject, bool checkCurrentRunOperation, CancellationTokenSource cs)
{
if (buildOwnerObject)
{
var build_targets = new HashSet <IBuildTarget> ();
foreach (var t in tests)
{
if (t.OwnerObject is IBuildTarget bt)
{
build_targets.Add(bt);
}
}
var res = await IdeApp.ProjectOperations.CheckAndBuildForExecute(
build_targets, IdeApp.Workspace.ActiveConfiguration, buildWithoutPrompting : !IdeApp.Preferences.BuildBeforeRunningTests,
false, null, cs.Token);
if (!res)
{
return;
}
var test_names = new HashSet <string> (tests.Select((v) => v.FullName));
await RefreshTests(cs.Token);
tests = test_names.Select((fullName) => SearchTest(fullName)).Where((t) => t != null).ToList();
if (tests.Any())
{
await RunTests(tests, context, false, checkCurrentRunOperation, cs);
}
return;
}
if (checkCurrentRunOperation && !IdeApp.ProjectOperations.ConfirmExecutionOperation())
{
return;
}
Pad resultsPad = GetTestResultsPad();
var test = tests.Count() == 1 ? tests.First() : new UnitTestSelection(tests, tests.First().OwnerObject);
TestSession session = new TestSession(test, context, (TestResultsPad)resultsPad.Content, cs);
OnTestSessionStarting(new TestSessionEventArgs {
Session = session, Test = test
});
if (checkCurrentRunOperation)
{
IdeApp.ProjectOperations.AddRunOperation(session);
}
try {
await session.Start();
} finally {
resultsPad.Sticky = false;
}
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector solutionConfiguration)
{
ValaProjectConfiguration conf = (ValaProjectConfiguration)GetConfiguration(solutionConfiguration);
ExecutionCommand cmd = CreateExecutionCommand(conf);
return((conf.CompileTarget == ValaBinding.CompileTarget.Bin) &&
context.ExecutionHandler.CanExecute(cmd));
}
public TestSession(UnitTest test, MonoDevelop.Projects.ExecutionContext context, TestResultsPad resultsPad, CancellationTokenSource cs)
{
this.test = test;
this.context = new Projects.ExecutionContext(context.ExecutionHandler, new CustomConsoleFactory(context.ConsoleFactory, cs), context.ExecutionTarget);
CancellationTokenSource = cs;
this.monitor = new TestMonitor(resultsPad, CancellationTokenSource);
this.resultsPad = resultsPad;
resultsPad.InitializeTestRun(test, cs);
}
internal TestContext (ITestProgressMonitor monitor, TestResultsPad resultsPad, MonoDevelop.Projects.ExecutionContext executionContext, DateTime testDate)
{
this.monitor = monitor;
if (executionContext == null)
executionContext = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, IdeApp.Workbench.ProgressMonitors.ConsoleFactory, null);
this.executionContext = executionContext;
// Round to seconds
this.testDate = new DateTime ((testDate.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
}
public static bool CanRun(OpenFLProject project, OpenFLProjectConfiguration configuration, ExecutionContext context)
{
ExecutionCommand cmd = (NativeExecutionCommand)CreateExecutionCommand (project, configuration);
if (cmd == null)
{
return false;
}
return context.ExecutionHandler.CanExecute (cmd);
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (runConfiguration == unitTestingRunConfigurationInstance)
{
UnitTest test = FindRootTest();
return((test != null) && test.CanRun(context.ExecutionHandler));
}
return(base.OnGetCanExecute(context, configuration, runConfiguration));
}
public static IAsyncOperation Debug (this ProjectOperations opers, IBuildTarget entry)
{
if (opers.CurrentRunOperation != null && !opers.CurrentRunOperation.IsCompleted)
return opers.CurrentRunOperation;
ExecutionContext context = new ExecutionContext (DebuggingService.GetExecutionHandler (), IdeApp.Workbench.ProgressMonitors, IdeApp.Workspace.ActiveExecutionTarget);
IAsyncOperation op = opers.Execute (entry, context);
return op;
}
public override bool CanExecute (IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration)
{
var retval = false;
if(item is DotNetProject)
{
var p = item as DotNetProject;
retval = p.References.Any(y=>y.Reference.Contains("manos"));
}
return retval || base.CanExecute(item,context, configuration);
}
public static IAsyncOperation ProfileFile (IProfiler profiler, string fileName)
{
if (IdeApp.ProjectOperations.CurrentRunOperation != null
&& !IdeApp.ProjectOperations.CurrentRunOperation.IsCompleted)
return IdeApp.ProjectOperations.CurrentRunOperation;
SwitchWorkbenchContext (ProfileWorkbenchContext);
ExecutionContext context = new ExecutionContext (profiler.GetDefaultExecutionHandlerFactory (), IdeApp.Workbench.ProgressMonitors);
return IdeApp.ProjectOperations.ExecuteFile (fileName, context);
}
public override bool CanExecute (IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration)
{
// We check for DefaultExecutionHandlerFactory because the tests can't run using any other execution mode
bool res = base.CanExecute (item, context, configuration);
if (!res && (item is IWorkspaceObject)) {
UnitTest test = NUnitService.Instance.FindRootTest ((IWorkspaceObject)item);
return (test != null) && test.CanRun (context.ExecutionHandler);
} else
return res;
}
protected override bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
if(IdeApp.Workspace.GetAllSolutions().Any((s) => s.StartupItem == this))
{
return context.ExecutionTarget is MicroFrameworkExecutionTarget && base.OnGetCanExecute(context, configuration);
}
else
{
return base.OnGetCanExecute(context, configuration);
}
}
/// <summary>
/// Launch Unity project
/// </summary>
public override void Execute (MonoDevelop.Core.IProgressMonitor monitor, IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration)
{
if (CanExecuteProject (item as Project, context)) {
DispatchService.GuiDispatch (delegate {
IdeApp.Workbench.CurrentLayout = "Debug";
IdeApp.ProjectOperations.CurrentRunOperation = context.ExecutionHandler.Execute (new UnityExecutionCommand (item.BaseDirectory.FullPath), context.ConsoleFactory.CreateConsole (true));
});
} else {
base.Execute (monitor, item, context, configuration);
}
}
internal TestContext(ITestProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext executionContext, DateTime testDate)
{
this.monitor = monitor;
if (executionContext == null)
{
executionContext = new ExecutionContext(Runtime.ProcessService.DefaultExecutionHandler, IdeApp.Workbench.ProgressMonitors.ConsoleFactory, null);
}
this.executionContext = executionContext;
// Round to seconds
this.testDate = new DateTime((testDate.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
}
async Task RunTests(IEnumerable <ProjectFileEventArgs> l)
{
if (l.Count() == 1 && l.First().First().ProjectFile.FilePath.FileName.ToLower().StartsWith("resource.designer"))
{
return;
}
var commonProject = l.Select(r => r.CommonProject).Distinct().First();
var rootTest = UnitTestService.FindRootTest(commonProject.ParentSolution.RootFolder);
HashSet <UnitTest> tests = new HashSet <UnitTest>();
var rootGroup = rootTest as UnitTestGroup;
foreach (var e in l)
{
foreach (var file in e)
{
foreach (var testGroup in rootGroup.Tests)
{
if (AddInPreferences.ProjectTestMap.Any(p => p.Project == file.Project.Name && p.Test == testGroup.Name))
{
tests.Add(testGroup);
}
}
}
}
var coll = new CustomTestGroup(
"Specified tests",
rootTest.OwnerObject
);
var context = new MonoDevelop.Projects.ExecutionContext(
Runtime.ProcessService.DefaultExecutionHandler, IdeApp.Workbench.ProgressMonitors.ConsoleFactory, IdeApp.Workspace.ActiveExecutionTarget);
foreach (var test in tests)
{
var tmp = new CustomTestGroup("this isnt a real test", test.OwnerObject);
// We're only calling this so that the owner object gets built properly.
// This will fail to run the tests because it tries to find the test
// by name again after building the project, in case it was removed.
// Since this is a temporary test group, it won't find it and will just return.
await UnitTestService.RunTest(tmp, context).Task;
coll.Tests.Add(test);
}
// To get around this, run the tests again but don't build the owner object:
UnitTestService.RunTest(coll, context, false);
}
public static IAsyncOperation ProfileApplication (IProfiler profiler, string executable, string workingDirectory, string args)
{
if (IdeApp.ProjectOperations.CurrentRunOperation != null
&& !IdeApp.ProjectOperations.CurrentRunOperation.IsCompleted)
return IdeApp.ProjectOperations.CurrentRunOperation;
SwitchWorkbenchContext (ProfileWorkbenchContext);
ExecutionContext context = new ExecutionContext (profiler.GetDefaultExecutionHandlerFactory (), IdeApp.Workbench.ProgressMonitors);
//TODO:
return NullAsyncOperation.Failure;
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector config)
{
var cfg = GetConfiguration(config);
if (cfg == null)
{
return(false);
}
var cmd = CreateExecutionCommand(config, cfg);
return(context.ExecutionHandler.CanExecute(cmd));
}
public static void ExecuteProject(DubProject prj,IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, string dubVerb = "run")
{
bool isDebug = context.ExecutionHandler.GetType ().Name.StartsWith ("Debug");
var conf = prj.GetConfiguration(configuration) as DubProjectConfiguration;
IConsole console;
if (conf.ExternalConsole)
console = context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput);
else
console = context.ConsoleFactory.CreateConsole(true);
var operationMonitor = new AggregatedOperationMonitor(monitor);
var sr = new StringBuilder();
if (!isDebug) {
sr.Append (dubVerb);
BuildCommonArgAppendix (sr, prj, configuration);
}
try
{
var cmd = isDebug ? prj.CreateExecutionCommand(configuration) : new NativeExecutionCommand(DubSettings.Instance.DubCommand, sr.ToString(), prj.BaseDirectory.ToString());
if (!context.ExecutionHandler.CanExecute(cmd))
{
monitor.ReportError("Cannot execute \"" + cmd.Command + " " + cmd.Arguments + "\". The selected execution mode is not supported for Dub projects.", null);
return;
}
var op = context.ExecutionHandler.Execute(cmd, console);
operationMonitor.AddOperation(op);
op.WaitForCompleted();
if(op.ExitCode != 0)
monitor.ReportError(cmd.Command+" exited with code: "+op.ExitCode.ToString(), null);
else
monitor.Log.WriteLine(cmd.Command+" exited with code: {0}", op.ExitCode);
}
catch (Exception ex)
{
monitor.ReportError("Cannot execute \"" + sr.ToString() + "\"", ex);
}
finally
{
operationMonitor.Dispose();
console.Dispose();
}
}
protected override void Execute (IProgressMonitor monitor, SolutionEntityItem entry, ExecutionContext context, ConfigurationSelector configuration)
{
SolutionItemConfiguration conf = entry.GetConfiguration (configuration) as SolutionItemConfiguration;
if (conf != null) {
ExecutionContext localContext = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory);
conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.BeforeExecute, localContext, configuration);
if (monitor.IsCancelRequested)
return;
}
base.Execute (monitor, entry, context, configuration);
if (conf != null && !monitor.IsCancelRequested) {
ExecutionContext localContext = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory);
conf.CustomCommands.ExecuteCommand (monitor, entry, CustomCommandType.AfterExecute, localContext, configuration);
}
}
public static IAsyncOperation Debug (this ProjectOperations opers, IBuildTarget entry)
{
if (opers.CurrentRunOperation != null && !opers.CurrentRunOperation.IsCompleted)
return opers.CurrentRunOperation;
string oldLayout = IdeApp.Workbench.CurrentLayout;
IdeApp.Workbench.CurrentLayout = "Debug";
ExecutionContext context = new ExecutionContext (DebuggingService.GetExecutionHandler (), IdeApp.Workbench.ProgressMonitors, IdeApp.Workspace.ActiveExecutionTarget);
IAsyncOperation op = opers.Execute (entry, context);
op.Completed += delegate {
Gtk.Application.Invoke (delegate {
IdeApp.Workbench.CurrentLayout = oldLayout;
});
};
return op;
}
public static bool CanRun(HaxeProject project, HaxeProjectConfiguration configuration, ExecutionContext context)
{
// need to optimize so this caches the result
ExecutionCommand cmd = CreateExecutionCommand (project, configuration);
if (cmd == null)
{
return false;
}
else if (cmd is NativeExecutionCommand)
{
return context.ExecutionHandler.CanExecute (cmd);
}
else
{
return true;
}
}
/// <summary>
/// Executes the project
/// </summary>
/// <param name="monitor">Progress monitor.</param>
/// <param name="context">Execution context.</param>
/// <param name="configuration">Configuration to execute.</param>
/// <returns>The execute.</returns>
protected async override Task DoExecute(ProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration)
{
var conf = (CProjectConfiguration)GetConfiguration(configuration);
bool pause = conf.PauseConsoleOutput;
OperationConsole console;
if (conf.CompileTarget != CompileTarget.Exe)
{
MessageService.ShowMessage("Compile target is not an executable!");
return;
}
monitor.Log.WriteLine("Running project...");
if (conf.ExternalConsole)
{
console = context.ExternalConsoleFactory.CreateConsole(!pause, monitor.CancellationToken);
}
else
{
console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken);
}
try {
ExecutionCommand cmd = CreateExecutionCommand(conf);
if (!context.ExecutionHandler.CanExecute(cmd))
{
monitor.ReportError("Cannot execute \"" + conf.Output + "\". The selected execution mode is not supported for C projects.", null);
return;
}
ProcessAsyncOperation op = context.ExecutionHandler.Execute(cmd, console);
using (var t = monitor.CancellationToken.Register(op.Cancel))
await op.Task;
monitor.Log.WriteLine("The operation exited with code: {0}", op.ExitCode);
} catch (Exception ex) {
LoggingService.LogError(string.Format("Cannot execute \"{0}\"", conf.Output), ex);
monitor.ReportError("Cannot execute \"" + conf.Output + "\"", ex);
} finally {
console.Dispose();
}
}
protected override bool OnGetCanExecute(MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration)
{
// We check for DefaultExecutionHandlerFactory because the tests can't run using any other execution mode
var res = base.OnGetCanExecute(context, configuration);
lock (canExecuteCheckLock) {
if (checkingCanExecute)
{
return(res);
}
}
if (res)
{
return(true);
}
UnitTest test = FindRootTest();
return((test != null) && test.CanRun(context.ExecutionHandler));
}
internal static void ExecuteProject(DubProject prj,IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
var conf = prj.GetConfiguration(configuration) as DubProjectConfiguration;
IConsole console;
if (conf.ExternalConsole)
console = context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput);
else
console = context.ConsoleFactory.CreateConsole(true);
var operationMonitor = new AggregatedOperationMonitor(monitor);
var sr = new StringBuilder("run");
Instance.BuildCommonArgAppendix(sr, prj, configuration);
try
{
var cmd = new NativeExecutionCommand(Instance.DubExecutable, sr.ToString(), prj.BaseDirectory.ToString());
if (!context.ExecutionHandler.CanExecute(cmd))
{
monitor.ReportError("Cannot execute \"" + "\". The selected execution mode is not supported for Dub projects.", null);
return;
}
var op = context.ExecutionHandler.Execute(cmd, console);
operationMonitor.AddOperation(op);
op.WaitForCompleted();
monitor.Log.WriteLine(Instance.DubExecutable+" exited with code: {0}", op.ExitCode);
}
catch (Exception ex)
{
monitor.ReportError("Cannot execute \"" + sr.ToString() + "\"", ex);
}
finally
{
operationMonitor.Dispose();
console.Dispose();
}
}
/// <summary>
/// Launch project
/// </summary>
public override void Execute (MonoDevelop.Core.IProgressMonitor monitor, IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration)
{
if (CanExecuteProject (item as Project, context)) {
DispatchService.GuiDispatch (delegate {
foreach(var file in ((Project)item).Files)
{
string filePath = file.FilePath.ToString();
if(filePath.Contains(@"Game\Scripts"))
{
WorkingDir = Path.Combine(filePath.Remove(filePath.LastIndexOf(@"Game\Scripts")), "Bin32");
break;
}
}
IdeApp.Workbench.CurrentLayout = "Debug";
IdeApp.ProjectOperations.CurrentRunOperation = context.ExecutionHandler.Execute (new CryEngineExecutionCommand (item.BaseDirectory.FullPath), context.ConsoleFactory.CreateConsole (true));
});
} else {
base.Execute (monitor, item, context, configuration);
}
}
public override void Execute (MonoDevelop.Core.IProgressMonitor monitor, IBuildTarget item, ExecutionContext context, ConfigurationSelector configuration)
{
if (base.CanExecute (item, context, configuration)) {
// It is executable by default
base.Execute(monitor, item, context, configuration);
return;
} else if (item is IWorkspaceObject) {
UnitTest test = NUnitService.Instance.FindRootTest ((IWorkspaceObject)item);
if (test != null) {
IAsyncOperation oper = null;
DispatchService.GuiSyncDispatch (delegate {
oper = NUnitService.Instance.RunTest (test, context.ExecutionHandler, false);
});
// if (oper != null) {
// monitor.CancelRequested += delegate {
// oper.Cancel ();
// };
// oper.WaitForCompleted ();
// }
}
}
}
/*protected virtual*/ Task OnPrepareExecution(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
return(Task.FromResult(0));
}
internal protected virtual bool OnGetCanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
return(next.OnGetCanExecute(context, configuration));
}
public IAsyncOperation Execute (IBuildTarget entry, ExecutionContext context)
{
if (currentRunOperation != null && !currentRunOperation.IsCompleted) return currentRunOperation;
NullProgressMonitor monitor = new NullProgressMonitor ();
DispatchService.ThreadDispatch (delegate {
ExecuteSolutionItemAsync (monitor, entry, context);
});
currentRunOperation = monitor.AsyncOperation;
currentRunOperationOwner = entry;
currentRunOperation.Completed += delegate {
DispatchService.GuiDispatch (() => {
var error = monitor.Errors.FirstOrDefault ();
if (error != null)
IdeApp.Workbench.StatusBar.ShowError (error.Message);
currentRunOperationOwner = null;
});
};
return currentRunOperation;
}
public bool CanExecuteFile (string file, IExecutionHandler handler)
{
ExecutionContext context = new ExecutionContext (handler, IdeApp.Workbench.ProgressMonitors);
return CanExecuteFile (file, context);
}
public bool CanExecute (IBuildTarget entry)
{
ExecutionContext context = new ExecutionContext (Runtime.ProcessService.DefaultExecutionHandler, IdeApp.Workbench.ProgressMonitors);
return CanExecute (entry, context);
}
public bool CanExecute (IBuildTarget entry, ExecutionContext context)
{
return entry.CanExecute (context, IdeApp.Workspace.ActiveConfiguration);
}
public Task PrepareExecution(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
return(SolutionExtension.PrepareExecution(monitor, context, configuration));
}
public bool CanExecuteFile (string file, ExecutionContext context)
{
Project tempProject = MonoDevelop.Projects.Services.ProjectService.CreateSingleFileProject (file);
if (tempProject != null) {
bool res = CanExecute (tempProject, context);
tempProject.Dispose ();
return res;
}
else
return false;
}
internal static Task RunTest(UnitTest test, MonoDevelop.Projects.ExecutionContext context, bool buildOwnerObject, bool checkCurrentRunOperation, CancellationTokenSource cs)
{
return(RunTests(new UnitTest [] { test }, context, buildOwnerObject, checkCurrentRunOperation, cs));
}
internal static async Task RunTests(IEnumerable <UnitTest> tests, MonoDevelop.Projects.ExecutionContext context, bool buildOwnerObject, bool checkCurrentRunOperation, CancellationTokenSource cs)
{
if (buildOwnerObject)
{
var build_targets = new HashSet <IBuildTarget> ();
foreach (var t in tests)
{
IBuildTarget bt = t.OwnerObject as IBuildTarget;
if (bt != null)
{
build_targets.Add(bt);
}
}
if (build_targets.Count > 0)
{
if (!IdeApp.ProjectOperations.CurrentRunOperation.IsCompleted)
{
MonoDevelop.Ide.Commands.StopHandler.StopBuildOperations();
await IdeApp.ProjectOperations.CurrentRunOperation.Task;
}
foreach (var bt in build_targets)
{
var res = await IdeApp.ProjectOperations.Build(bt, cs.Token).Task;
if (res.HasErrors)
{
return;
}
}
var test_names = new HashSet <string> (tests.Select((v) => v.FullName));
await RefreshTests(cs.Token);
tests = test_names.Select((fullName) => SearchTest(fullName)).Where((t) => t != null).ToList();
if (tests.Any())
{
await RunTests(tests, context, false, checkCurrentRunOperation, cs);
}
return;
}
}
if (checkCurrentRunOperation && !IdeApp.ProjectOperations.ConfirmExecutionOperation())
{
return;
}
Pad resultsPad = GetTestResultsPad();
var test = tests.Count() == 1 ? tests.First() : new UnitTestSelection(tests, tests.First().OwnerObject);
TestSession session = new TestSession(test, context, (TestResultsPad)resultsPad.Content, cs);
OnTestSessionStarting(new TestSessionEventArgs {
Session = session, Test = test
});
if (checkCurrentRunOperation)
{
IdeApp.ProjectOperations.AddRunOperation(session);
}
try {
await session.Start();
} finally {
resultsPad.Sticky = false;
}
}
protected override async Task OnExecute(MonoDevelop.Core.ProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration)
{
bool defaultCanExecute;
lock (canExecuteCheckLock) {
try {
checkingCanExecute = true;
defaultCanExecute = Project.CanExecute(context, configuration);
} finally {
checkingCanExecute = false;
}
}
if (defaultCanExecute)
{
// It is executable by default
await base.OnExecute(monitor, context, configuration);
return;
}
UnitTest test = FindRootTest();
if (test != null)
{
var cs = new CancellationTokenSource();
using (monitor.CancellationToken.Register(cs.Cancel))
await NUnitService.Instance.RunTest(test, context.ExecutionHandler, false, false, cs);
}
}
public bool CanExecute(ExecutionContext context, string configuration)
{
return(CanExecute(context, (SolutionConfigurationSelector)configuration));
}
public bool CanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
return(SolutionExtension.CanExecute(context, configuration));
}
protected override async Task OnExecute(MonoDevelop.Core.ProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration)
{
if (runConfiguration == unitTestingRunConfigurationInstance)
{
// The user selected to run the tests
UnitTest test = FindRootTest();
if (test != null)
{
var cs = new CancellationTokenSource();
using (monitor.CancellationToken.Register(cs.Cancel))
await UnitTestService.RunTest(test, context, false, false, cs);
}
}
else
{
await base.OnExecute(monitor, context, configuration, runConfiguration);
}
}
public Task Execute(ProgressMonitor monitor, ExecutionContext context, string configuration)
{
return(Execute(monitor, context, (SolutionConfigurationSelector)configuration));
}
internal protected virtual Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
return(next.OnExecute(monitor, context, configuration));
}
public static AsyncOperation RunTest(UnitTest test, MonoDevelop.Projects.ExecutionContext context, bool buildOwnerObject)
{
var cs = new CancellationTokenSource();
return(new AsyncOperation(RunTest(test, context, buildOwnerObject, true, cs), cs));
}
public IAsyncOperation ExecuteFile (string file, ExecutionContext context)
{
Project tempProject = MonoDevelop.Projects.Services.ProjectService.CreateSingleFileProject (file);
if (tempProject != null) {
IAsyncOperation aop = Execute (tempProject, context);
aop.Completed += delegate { tempProject.Dispose (); };
return aop;
} else {
MessageService.ShowError(GettextCatalog.GetString ("No runnable executable found."));
return NullAsyncOperation.Failure;
}
}
internal static async Task RunTest(UnitTest test, MonoDevelop.Projects.ExecutionContext context, bool buildOwnerObject, bool checkCurrentRunOperation, CancellationTokenSource cs)
{
string testName = test.FullName;
if (buildOwnerObject)
{
IBuildTarget bt = test.OwnerObject as IBuildTarget;
if (bt != null)
{
if (!IdeApp.ProjectOperations.CurrentRunOperation.IsCompleted)
{
MonoDevelop.Ide.Commands.StopHandler.StopBuildOperations();
await IdeApp.ProjectOperations.CurrentRunOperation.Task;
}
var res = await IdeApp.ProjectOperations.Build(bt, cs.Token).Task;
if (res.HasErrors)
{
return;
}
await RefreshTests(cs.Token);
test = SearchTest(testName);
if (test != null)
{
await RunTest(test, context, false, checkCurrentRunOperation, cs);
}
return;
}
}
if (checkCurrentRunOperation && !IdeApp.ProjectOperations.ConfirmExecutionOperation())
{
return;
}
Pad resultsPad = IdeApp.Workbench.GetPad <TestResultsPad>();
if (resultsPad == null)
{
resultsPad = IdeApp.Workbench.ShowPad(new TestResultsPad(), "MonoDevelop.UnitTesting.TestResultsPad", GettextCatalog.GetString("Test results"), "Bottom", "md-solution");
}
// Make the pad sticky while the tests are runnig, so the results pad is always visible (even if minimized)
// That's required since when running in debug mode, the layout is automatically switched to debug.
resultsPad.Sticky = true;
resultsPad.BringToFront();
TestSession session = new TestSession(test, context, (TestResultsPad)resultsPad.Content, cs);
OnTestSessionStarting(new TestSessionEventArgs {
Session = session, Test = test
});
if (checkCurrentRunOperation)
{
IdeApp.ProjectOperations.CurrentRunOperation = session;
}
try {
await session.Start();
} finally {
resultsPad.Sticky = false;
}
}
public bool CanExecute (IBuildTarget entry, IExecutionHandler handler)
{
ExecutionContext context = new ExecutionContext (handler, IdeApp.Workbench.ProgressMonitors);
return entry.CanExecute (context, IdeApp.Workspace.ActiveConfiguration);
}
internal protected override bool CanExecute(ExecutionContext context, ConfigurationSelector configuration)
{
return(Solution.OnGetCanExecute(context, configuration));
}
public IAsyncOperation Execute (IBuildTarget entry, IExecutionHandler handler)
{
ExecutionContext context = new ExecutionContext (handler, IdeApp.Workbench.ProgressMonitors);
return Execute (entry, context);
}
internal protected override Task PrepareExecution(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
return(Solution.OnPrepareExecution(monitor, context, configuration));
}
void ExecuteSolutionItemAsync (IProgressMonitor monitor, IBuildTarget entry, ExecutionContext context)
{
try {
OnBeforeStartProject ();
entry.Execute (monitor, context, IdeApp.Workspace.ActiveConfiguration);
} catch (Exception ex) {
monitor.ReportError (GettextCatalog.GetString ("Execution failed."), ex);
LoggingService.LogError ("Execution failed", ex);
} finally {
monitor.Dispose ();
}
}
protected override void Execute(IProgressMonitor monitor, SolutionEntityItem entry, ExecutionContext context, ConfigurationSelector configuration)
{
SolutionItemConfiguration conf = entry.GetConfiguration(configuration) as SolutionItemConfiguration;
if (conf != null)
{
ExecutionContext localContext = new ExecutionContext(Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory);
if (conf.CustomCommands.CanExecute(entry, CustomCommandType.BeforeExecute, localContext, configuration))
{
conf.CustomCommands.ExecuteCommand(monitor, entry, CustomCommandType.BeforeExecute, localContext, configuration);
}
if (monitor.IsCancelRequested)
{
return;
}
}
base.Execute(monitor, entry, context, configuration);
if (conf != null && !monitor.IsCancelRequested)
{
ExecutionContext localContext = new ExecutionContext(Runtime.ProcessService.DefaultExecutionHandler, context.ConsoleFactory);
if (conf.CustomCommands.CanExecute(entry, CustomCommandType.AfterExecute, localContext, configuration))
{
conf.CustomCommands.ExecuteCommand(monitor, entry, CustomCommandType.AfterExecute, localContext, configuration);
}
}
}
public static DebuggerFeatures GetSupportedFeatures (IBuildTarget target)
{
FeatureCheckerHandlerFactory fc = new FeatureCheckerHandlerFactory ();
ExecutionContext ctx = new ExecutionContext (fc, null);
target.CanExecute (ctx, IdeApp.Workspace.ActiveConfiguration);
return fc.SupportedFeatures;
}
protected override void OnExecute(IProgressMonitor monitor, MonoDevelop.Projects.ExecutionContext context, ConfigurationSelector configuration)
{
}