/// <inheritdoc />
public DetachDebuggerResult DetachFromProcess(Process process)
{
if (process == null)
{
throw new ArgumentNullException("process");
}
DetachDebuggerResult result = DetachDebuggerResult.AlreadyDetached;
try
{
IVisualStudio visualStudio = GetVisualStudio(false, logger);
if (visualStudio != null)
{
visualStudio.Call(dte =>
{
EnvDTE.Process dteProcess = FindProcess(dte.Debugger.DebuggedProcesses, process);
if (dteProcess != null)
{
dteProcess.Detach(false);
result = DetachDebuggerResult.Detached;
}
});
}
}
catch (VisualStudioException ex)
{
result = DetachDebuggerResult.CouldNotDetach;
logger.Log(LogSeverity.Debug, "Failed to detach Visual Studio debugger from process.", ex);
}
return(result);
}
/// <summary>
/// Sets the working environment (i.e. WorkingDirectory and Environment) properties of the command line arguments
/// based on the provided details
/// </summary>
/// <param name="args">The arguments which to set</param>
/// <param name="source">The base source which will be executed</param>
/// <param name="settings">The BoostTestAdapterSettings which are currently applied</param>
/// <param name="vs">The current Visual Studio instance (if available)</param>
/// <exception cref="COMException"></exception>
public static void SetWorkingEnvironment(this BoostTestRunnerCommandLineArgs args, string source, BoostTestAdapterSettings settings, IVisualStudio vs)
{
Code.Require(args, "args");
Code.Require(source, "source");
Code.Require(settings, "settings");
// Default working directory
args.WorkingDirectory = Path.GetDirectoryName(source);
// Working directory extracted from test settings
if (!string.IsNullOrEmpty(settings.WorkingDirectory) && Directory.Exists(settings.WorkingDirectory))
{
args.WorkingDirectory = settings.WorkingDirectory;
}
if (vs != null)
{
// Visual Studio configuration has higher priority over settings (if available)
IVSDebugConfiguration vsConfiguration = LocateVSDebugConfiguration(source, vs);
if (vsConfiguration != null)
{
args.WorkingDirectory = vsConfiguration.WorkingDirectory;
args.SetEnvironment(vsConfiguration.Environment);
}
}
// Enforce windows style backward slashes
args.WorkingDirectory = args.WorkingDirectory.Replace('/', '\\');
}
/// <summary>
/// Gets an instance of Visual Studio.
/// </summary>
public static IVisualStudio GetVisualStudio()
{
if (visualStudio == null)
visualStudio = VisualStudioManager.Instance.LaunchVisualStudio(VisualStudioVersion.VS2008, NullLogger.Instance);
return visualStudio;
}
/// <inheritdoc />
public bool IsAttachedToProcess(Process process)
{
if (process == null)
{
throw new ArgumentNullException("process");
}
bool result = false;
try
{
// TODO: Consider all instances of Visual Studio if not attached to a particular one.
IVisualStudio visualStudio = GetVisualStudio(false, logger);
if (visualStudio == null)
{
return(false);
}
visualStudio.Call(dte =>
{
EnvDTE.Process dteProcess = FindProcess(dte.Debugger.DebuggedProcesses, process);
if (dteProcess != null)
{
result = true;
}
});
}
catch (VisualStudioException ex)
{
logger.Log(LogSeverity.Debug, "Failed to detect whether Visual Studio debugger was attached to process.", ex);
}
return(result);
}
/// <inheritdoc />
public IVisualStudio LaunchVisualStudio(VisualStudioVersion version, ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Pair <string, VisualStudioVersion>?installDirAndVersion = GetVisualStudioInstallDirAndVersion(version);
if (!installDirAndVersion.HasValue)
{
logger.Log(LogSeverity.Debug, string.Format("Could not find Visual Studio version '{0}'.", version));
return(null);
}
string devenvPath = Path.Combine(installDirAndVersion.Value.First, "devenv.exe");
ProcessTask devenvProcessTask = new ProcessTask(devenvPath, "", Environment.CurrentDirectory);
logger.Log(LogSeverity.Debug, string.Format("Launching Visual Studio using path: '{0}'.", devenvProcessTask.ExecutablePath));
devenvProcessTask.Start();
System.Diagnostics.Process devenvProcess = devenvProcessTask.Process;
if (devenvProcess != null)
{
int processId = devenvProcess.Id;
Stopwatch stopwatch = Stopwatch.StartNew();
for (;;)
{
IVisualStudio visualStudio = GetVisualStudioFromProcess(processId, installDirAndVersion.Value.Second, true, logger);
if (visualStudio != null)
{
return(visualStudio);
}
if (stopwatch.ElapsedMilliseconds > VisualStudioAttachTimeoutMilliseconds)
{
logger.Log(LogSeverity.Debug, string.Format("Stopped waiting for Visual Studio to launch after {0} milliseconds.", VisualStudioAttachTimeoutMilliseconds));
break;
}
if (!devenvProcessTask.IsRunning)
{
break;
}
Thread.Sleep(500);
}
}
if (devenvProcessTask.IsTerminated && devenvProcessTask.Result != null)
{
if (!devenvProcessTask.Result.HasValue)
{
logger.Log(LogSeverity.Debug, "Failed to launch Visual Studio.", devenvProcessTask.Result.Exception);
}
}
return(null);
}
public NewBuild(IVisualStudio vs, INUnit nunit, IWebServer webServer)
{
Vs = vs;
NUnit = nunit;
NUnit.NUnitConsolePath = @".\References\NUnit\nunit-console.exe";
WebServer = webServer;
}
public NewBuild(IVisualStudio vs, INUnit nunit, IWebServer webServer)
{
Vs = vs;
NUnit = nunit;
NUnit.NUnitConsolePath = @".\References\NUnit\nunit-console.exe";
WebServer = webServer;
}
/// <summary>
/// Commits any pending changes and builds a fake IVisualStudio instance.
/// </summary>
/// <returns>A fake IVisualStudio instance consisting of the previously registered solutions</returns>
public IVisualStudio Build()
{
IVisualStudio fake = A.Fake <IVisualStudio>();
A.CallTo(() => fake.Version).Returns("MockVisualStudioInstance");
A.CallTo(() => fake.Solution).Returns(this._solution);
return(fake);
}
/// <summary>
/// Gets an instance of Visual Studio.
/// </summary>
public static IVisualStudio GetVisualStudio()
{
if (visualStudio == null)
{
visualStudio = VisualStudioManager.Instance.LaunchVisualStudio(VisualStudioVersion.VS2008, NullLogger.Instance);
}
return(visualStudio);
}
/// <inheritdoc />
public AttachDebuggerResult AttachToProcess(Process process)
{
if (process == null)
{
throw new ArgumentNullException("process");
}
AttachDebuggerResult result = AttachDebuggerResult.CouldNotAttach;
try
{
IVisualStudio visualStudio = GetVisualStudio(true, logger);
if (visualStudio != null)
{
visualStudio.Call(dte =>
{
EnvDTE.Process dteProcess = FindProcess(dte.Debugger.DebuggedProcesses, process);
if (dteProcess != null)
{
result = AttachDebuggerResult.AlreadyAttached;
}
else
{
dteProcess = FindProcess(dte.Debugger.LocalProcesses, process);
if (dteProcess != null)
{
Process2 dteProcess2 = dteProcess as Process2;
Debugger2 dteDebugger2 = dte.Debugger as Debugger2;
if (dteProcess2 != null && dteDebugger2 != null)
{
IList <Guid> engineGuids = GetEngineGuids();
Engine[] engines = GetEngines(dteDebugger2, engineGuids);
dteProcess2.Attach2(engines);
}
else
{
dteProcess.Attach();
}
result = AttachDebuggerResult.Attached;
}
else
{
logger.Log(LogSeverity.Debug, "Failed to attach Visual Studio debugger to process because it was not found in the LocalProcesses list.");
}
}
});
}
}
catch (VisualStudioException ex)
{
logger.Log(LogSeverity.Debug, "Failed to attach Visual Studio debugger to process.", ex);
}
return(result);
}
private static void AssertExistingInstanceOfVisualStudioCanBeLocated(IVisualStudioManager manager, ILogger logger, VisualStudioVersion version)
{
IVisualStudio foundVisualStudio = manager.GetVisualStudio(version, false, logger);
Assert.IsNotNull(foundVisualStudio, "Since Visual Studio is running, GetVisualStudio should return a valid instance.");
Assert.IsFalse(foundVisualStudio.WasLaunched, "Existing instance found so WasLaunched should be false.");
foundVisualStudio = manager.GetVisualStudio(version, true, logger);
Assert.IsNotNull(foundVisualStudio, "Since Visual Studio is running, GetVisualStudio should return a valid instance.");
Assert.IsFalse(foundVisualStudio.WasLaunched, "Existing instance found so WasLaunched should be false.");
}
/// <summary>
/// Creates a Visual Studio debugger wrapper.
/// </summary>
/// <param name="debuggerSetup">The debugger setup options.</param>
/// <param name="logger">The logger.</param>
/// <param name="visualStudio">The instance of Visual Studio, or null if it should automatically find or
/// launch instances of Visual Studio as required.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="debuggerSetup"/>
/// or <paramref name="logger"/> is null.</exception>
public VisualStudioDebugger(DebuggerSetup debuggerSetup, ILogger logger, IVisualStudio visualStudio)
{
if (debuggerSetup == null)
throw new ArgumentNullException("debuggerSetup");
if (logger == null)
throw new ArgumentNullException("logger");
this.debuggerSetup = debuggerSetup;
this.logger = logger;
this.visualStudio = visualStudio;
}
public static void TearDown()
{
try
{
if (visualStudio != null)
{
visualStudio.Call(dte => dte.Quit());
visualStudio = null;
}
}
finally
{
ComRetryMessageFilter.Uninstall();
}
}
private static void AssertVisualStudioCanBeUsed(IVisualStudio visualStudio)
{
string version = null;
visualStudio.Call(dte => version = dte.Version);
Assert.IsNotNull(version);
Assert.Throws <ArgumentNullException>(() => visualStudio.Call(null));
Assert.DoesNotThrow(() => visualStudio.BringToFront());
Assert.IsNotNull(visualStudio.GetDebugger(new DebuggerSetup()));
Assert.Throws <ArgumentNullException>(() => visualStudio.GetDebugger(null));
}
public static void TearDown()
{
try
{
if (visualStudio != null)
{
visualStudio.Call(dte => dte.Quit());
visualStudio = null;
}
}
finally
{
ComRetryMessageFilter.Uninstall();
}
}
/// <summary>
/// Creates a Visual Studio debugger wrapper.
/// </summary>
/// <param name="debuggerSetup">The debugger setup options.</param>
/// <param name="logger">The logger.</param>
/// <param name="visualStudio">The instance of Visual Studio, or null if it should automatically find or
/// launch instances of Visual Studio as required.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="debuggerSetup"/>
/// or <paramref name="logger"/> is null.</exception>
public VisualStudioDebugger(DebuggerSetup debuggerSetup, ILogger logger, IVisualStudio visualStudio)
{
if (debuggerSetup == null)
{
throw new ArgumentNullException("debuggerSetup");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.debuggerSetup = debuggerSetup;
this.logger = logger;
this.visualStudio = visualStudio;
}
/// <inheritdoc />
public IVisualStudio GetVisualStudio(VisualStudioVersion version, bool launchIfNoActiveInstance, ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
IVisualStudio visualStudio = GetActiveVisualStudio(version, logger);
if (visualStudio == null && launchIfNoActiveInstance)
{
visualStudio = LaunchVisualStudio(version, logger);
}
return(visualStudio);
}
private static IVisualStudio GetActiveVisualStudio(VisualStudioVersion version, ILogger logger)
{
IVisualStudio visualStudio = null;
ForEachApplicableVersion(version, aVersion =>
{
object obj = GetActiveObject(versionInfos[aVersion].ProgID);
if (obj != null)
{
visualStudio = new VisualStudio((DTE)obj, aVersion, false, logger);
return(true);
}
return(false);
});
return(visualStudio);
}
public void LaunchAndGetVisualStudio()
{
var manager = VisualStudioManager.Instance;
var logger = new MarkupStreamLogger(TestLog.Default);
IVisualStudio visualStudio = manager.LaunchVisualStudio(VisualStudioVersion.Any, logger);
Assert.IsNotNull(visualStudio, "Should have started an instance.");
try
{
Assert.IsTrue(visualStudio.WasLaunched, "New instance launched so WasLaunched should be true.");
AssertVisualStudioCanBeUsed(visualStudio);
AssertExistingInstanceOfVisualStudioCanBeLocated(manager, logger, visualStudio.Version);
}
finally
{
visualStudio.Quit();
}
}
public void GetVisualStudio_WhenLaunchFlagIsTrue_ProvidesAnInstanceOrStartsOne()
{
var manager = VisualStudioManager.Instance;
var logger = new MarkupStreamLogger(TestLog.Default);
IVisualStudio visualStudio = manager.GetVisualStudio(VisualStudioVersion.Any, true, logger);
Assert.IsNotNull(visualStudio, "Should have found or started an instance.");
try
{
AssertVisualStudioCanBeUsed(visualStudio);
AssertExistingInstanceOfVisualStudioCanBeLocated(manager, logger, visualStudio.Version);
}
finally
{
if (visualStudio.WasLaunched)
{
visualStudio.Quit();
}
}
}
private bool NavigateToFileInVisualStudio(string path, int lineNumber, int columnNumber)
{
path = Path.GetFullPath(path);
var logger = NullLogger.Instance;
IVisualStudio visualStudio = visualStudioManager.GetVisualStudio(VisualStudioVersion.Any, true, logger);
if (visualStudio == null)
{
return(false);
}
visualStudio.Call(dte =>
{
Window window = OpenFile(dte, path);
if (window == null)
{
window = FindFileInSolution(dte, path);
}
TextSelection selection = window.Selection as TextSelection;
if (lineNumber != 0)
{
if (selection != null)
{
selection.MoveToLineAndOffset(lineNumber, Math.Max(1, columnNumber), false);
}
}
window.Activate();
window.Visible = true;
});
visualStudio.BringToFront();
return(true);
}
public LicenseExpirationHandler(IVisualStudio visualStudio, IProtector protector)
{
this.visualStudio = visualStudio;
this.protector = protector;
}
private static void AssertVisualStudioCanBeUsed(IVisualStudio visualStudio)
{
string version = null;
visualStudio.Call(dte => version = dte.Version);
Assert.IsNotNull(version);
Assert.Throws<ArgumentNullException>(() => visualStudio.Call(null));
Assert.DoesNotThrow(() => visualStudio.BringToFront());
Assert.IsNotNull(visualStudio.GetDebugger(new DebuggerSetup()));
Assert.Throws<ArgumentNullException>(() => visualStudio.GetDebugger(null));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="vs">The IVisualStudio instance which is to be provided on a 'Get()' call</param>
public DummyVSProvider(IVisualStudio vs)
{
this.Instance = vs;
}
/// <inheritdoc />
public Process LaunchProcess(ProcessStartInfo processStartInfo)
{
if (processStartInfo == null)
{
throw new ArgumentNullException("processStartInfo");
}
Process foundProcess = null;
try
{
IVisualStudio visualStudio = GetVisualStudio(true, logger);
if (visualStudio != null)
{
visualStudio.Call(dte =>
{
List <int> currentDebuggedProcesses = new List <int>();
if (dte.Debugger.DebuggedProcesses != null)
{
foreach (EnvDTE.Process dteProcess in dte.Debugger.DebuggedProcesses)
{
currentDebuggedProcesses.Add(dteProcess.ProcessID);
}
}
var serviceProvider = new VisualStudioServiceProvider(dte);
var debugger = serviceProvider.GetService <SVsShellDebugger, IVsDebugger2>();
var engineGuids = GetEngineGuids();
int debugTargetInfoSize = Marshal.SizeOf(typeof(VsDebugTargetInfo2));
int guidSize = Marshal.SizeOf(typeof(Guid));
IntPtr debugTargetInfoPtr = Marshal.AllocCoTaskMem(debugTargetInfoSize + guidSize * engineGuids.Count);
try
{
IntPtr engineGuidsPtr = new IntPtr(debugTargetInfoPtr.ToInt64() + debugTargetInfoSize);
var environment = new StringBuilder();
foreach (DictionaryEntry variable in processStartInfo.EnvironmentVariables)
{
environment.Append(variable.Key).Append('=').Append(variable.Value).Append('\0');
}
var debugTargetInfo = new VsDebugTargetInfo2()
{
cbSize = (uint)debugTargetInfoSize,
bstrExe = Path.GetFullPath(processStartInfo.FileName),
bstrArg = processStartInfo.Arguments,
bstrCurDir = string.IsNullOrEmpty(processStartInfo.WorkingDirectory) ? Environment.CurrentDirectory : Path.GetFullPath(processStartInfo.WorkingDirectory),
bstrEnv = environment.Length != 0 ? environment.ToString() : null,
dwDebugEngineCount = (uint)engineGuids.Count,
pDebugEngines = engineGuidsPtr,
fSendToOutputWindow = 1,
guidLaunchDebugEngine = VisualStudioDebugEngines.ManagedAndNative,
dlo = (int)DEBUG_LAUNCH_OPERATION.DLO_CreateProcess,
LaunchFlags = (int)(__VSDBGLAUNCHFLAGS.DBGLAUNCH_WaitForAttachComplete | __VSDBGLAUNCHFLAGS.DBGLAUNCH_Silent)
};
Marshal.StructureToPtr(debugTargetInfo, debugTargetInfoPtr, false);
for (int i = 0; i < engineGuids.Count; i++)
{
Marshal.StructureToPtr(engineGuids[i], new IntPtr(engineGuidsPtr.ToInt64() + i * guidSize), false);
}
int hresult = debugger.LaunchDebugTargets2(1, debugTargetInfoPtr);
if (hresult != S_OK)
{
Marshal.ThrowExceptionForHR(hresult);
}
}
finally
{
Marshal.FreeCoTaskMem(debugTargetInfoPtr);
}
if (dte.Debugger.DebuggedProcesses != null)
{
foreach (EnvDTE.Process dteProcess in dte.Debugger.DebuggedProcesses)
{
if (!currentDebuggedProcesses.Contains(dteProcess.ProcessID))
{
foundProcess = Process.GetProcessById(dteProcess.ProcessID);
break;
}
}
}
if (foundProcess == null)
{
logger.Log(LogSeverity.Debug, "Could not find the newly launched process.");
}
});
}
}
catch (VisualStudioException ex)
{
logger.Log(LogSeverity.Debug, "Failed to attach Visual Studio debugger to process.", ex);
}
return(foundProcess);
}
/// <summary>
/// Sets the working environment (i.e. WorkingDirectory and Environment) properties of the command line arguments
/// based on the provided details
/// </summary>
/// <param name="args">The arguments which to set</param>
/// <param name="source">The base source which will be executed</param>
/// <param name="settings">The BoostTestAdapterSettings which are currently applied</param>
/// <param name="vs">The current Visual Studio instance (if available)</param>
/// <exception cref="COMException"></exception>
public static void SetWorkingEnvironment(this BoostTestRunnerCommandLineArgs args, string source, BoostTestAdapterSettings settings, IVisualStudio vs)
{
Code.Require(args, "args");
Code.Require(source, "source");
Code.Require(settings, "settings");
// Default working directory
args.WorkingDirectory = Path.GetDirectoryName(source);
// Working directory extracted from test settings
if (!string.IsNullOrEmpty(settings.WorkingDirectory) && Directory.Exists(settings.WorkingDirectory))
{
args.WorkingDirectory = settings.WorkingDirectory;
}
if (vs != null)
{
// Visual Studio configuration has higher priority over settings (if available)
IVSDebugConfiguration vsConfiguration = LocateVSDebugConfiguration(source, vs);
if (vsConfiguration != null)
{
args.WorkingDirectory = vsConfiguration.WorkingDirectory;
args.SetEnvironment(vsConfiguration.Environment);
}
}
// Enforce windows style backward slashes
args.WorkingDirectory = args.WorkingDirectory.Replace('/', '\\');
}
/// <summary>
/// Locates the Visual Studio Debug configuration for the provided source
/// </summary>
/// <param name="source">The source to lookup its Visual Studio configuration</param>
/// <param name="vs">The Visual Studio instance from which to search</param>
/// <returns>The respective Visual Studio debug configuration or null if it cannot be located</returns>
private static IVSDebugConfiguration LocateVSDebugConfiguration(string source, IVisualStudio vs)
{
foreach (var project in vs.Solution.Projects)
{
var configuration = project.ActiveConfiguration;
if (string.Equals(source, configuration.PrimaryOutput, StringComparison.Ordinal))
{
return(configuration.VSDebugConfiguration);
}
}
return(null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="vs">The IVisualStudio instance which is to be provided on a 'Get()' call</param>
public DummyVSProvider(IVisualStudio vs)
{
this.Instance = vs;
}
/// <summary>
/// Locates the Visual Studio Debug configuration for the provided source
/// </summary>
/// <param name="source">The source to lookup its Visual Studio configuration</param>
/// <param name="vs">The Visual Studio instance from which to search</param>
/// <returns>The respective Visual Studio debug configuration or null if it cannot be located</returns>
private static IVSDebugConfiguration LocateVSDebugConfiguration(string source, IVisualStudio vs)
{
foreach (var project in vs.Solution.Projects)
{
var configuration = project.ActiveConfiguration;
if (string.Equals(source, configuration.PrimaryOutput, StringComparison.Ordinal))
{
return configuration.VSDebugConfiguration;
}
}
return null;
}
