public AssemblyDefinition Resolve(AssemblyNameReference name)
{
AssemblyDefinition assemblyDefn;
if (!cache.TryGetValue(name.FullName, out assemblyDefn))
{
string assemblyFile = FindAssemblyByPartialName(name.Name);
if (assemblyFile == null)
{
Assembly assembly = Assembly.ReflectionOnlyLoad(name.FullName);
if (assembly != null)
{
assemblyFile = AssemblyUtils.GetAssemblyLocalPath(assembly);
}
else
{
throw new FileNotFoundException(String.Format("Could not find assembly '{0}'.", name.FullName));
}
}
assemblyDefn = LoadAssembly(assemblyFile);
cache[name.FullName] = assemblyDefn; // ensure this exact variation of the full name is cached too
}
return(assemblyDefn);
}
private IEnumerable <string> GetPlugins()
{
var acadRunnerDir = Path.GetDirectoryName(
AssemblyUtils.GetAssemblyLocalPath(typeof(AcadPluginLocator).Assembly));
const string searchPattern = "Gallio.AutoCAD.Plugin*.dll";
foreach (var path in GetFilesInDirectory(acadRunnerDir, searchPattern, SearchOption.TopDirectoryOnly))
{
yield return(path);
}
// Check if Gallio is running directly out of its source tree.
string devPath = acadRunnerDir;
while (devPath != null && Path.GetFileName(devPath) != @"src")
{
devPath = Path.GetDirectoryName(devPath);
}
if (devPath == null)
{
yield break;
}
var projectOutputDir = Path.Combine(devPath, @"Extensions\AutoCAD\Gallio.AutoCAD.Plugin\bin");
if (fileSystem.DirectoryExists(projectOutputDir))
{
foreach (var path in GetFilesInDirectory(projectOutputDir, searchPattern, SearchOption.AllDirectories))
{
yield return(path);
}
}
}
private static ProcessTask RunMSTest(string options)
{
string value = (string)RegistryUtils.GetValueWithBitness(
ProcessorArchitecture.X86, RegistryHive.LocalMachine,
@"Software\Microsoft\VisualStudio\9.0",
"InstallDir", null);
if (value == null)
{
Assert.Inconclusive("Visual Studio 2008 does not appear to be installed.");
}
string executablePath = Path.Combine(value, "MSTest.exe");
if (!File.Exists(executablePath))
{
Assert.Inconclusive("Visual Studio 2008 appears to be installed but MSTest.exe was not found.");
}
string testAssemblyPath = AssemblyUtils.GetAssemblyLocalPath(typeof(SimpleTest).Assembly);
string workingDirectory = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(GallioTipIntegrationTest).Assembly));
ProcessTask task = Tasks.StartProcessTask(executablePath,
"\"/testcontainer:" + testAssemblyPath + "\" " + options,
workingDirectory);
Assert.IsTrue(task.Run(TimeSpan.FromSeconds(60)), "A timeout occurred.");
return(task);
}
public void GetXmlDocumentation_GetsDocumentationForDocumentedMember()
{
Type type = typeof(DocumentedClass);
Assert.AreEqual("<summary>\nA documented class.\n</summary>\n<remarks>\nThe XML documentation of this test is significant.\n Including the leading whitespace on this line.\n And the extra 8 trailing spaces on this line!\n</remarks>",
resolver.GetXmlDocumentation(AssemblyUtils.GetAssemblyLocalPath(type.Assembly), "T:" + type.FullName));
}
public void FallsBackOnNativelyLoadableAssemblies()
{
ReflectionOnlyAssemblyLoader loader = new ReflectionOnlyAssemblyLoader();
Assembly nativeAssembly = typeof(ReflectionOnlyAssemblyLoader).Assembly;
IAssemblyInfo assembly = loader.ReflectionPolicy.LoadAssembly(nativeAssembly.GetName());
Assert.AreEqual(AssemblyUtils.GetAssemblyLocalPath(nativeAssembly), assembly.Path);
}
public void FixtureSetUp()
{
string binPath = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly));
workingDirectory = Path.Combine(binPath, @"..\TestBuildFiles");
executablePath = Path.Combine(binPath, @"..\..\libs\NAnt.exe");
Assert.IsTrue(File.Exists(executablePath), "Cannot find the NAnt executable!");
}
/// <summary>
/// Sets the configuration file path to the *.config file associated with an assembly.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="assembly"/> is null.</exception>
public void SetConfigurationFilePathFromAssembly(Assembly assembly)
{
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
configurationFilePath = AssemblyUtils.GetAssemblyLocalPath(assembly) + @".config";
}
private ProcessTask StartAmbienceServer(string arguments)
{
string workingDirectory = Path.GetDirectoryName((AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)));
string executablePath = Path.Combine(workingDirectory, "Gallio.Ambience.Server.exe");
ProcessTask task = Tasks.StartProcessTask(executablePath, arguments, workingDirectory);
Thread.Sleep(10000);
return(task);
}
public void FixtureSetUp()
{
string frameworkPath = RuntimeEnvironment.GetRuntimeDirectory();
executablePath = frameworkPath + @"MSBuild.exe";
Assert.IsTrue(File.Exists(executablePath), "Cannot find the MSBuild executable!");
workingDirectory = Path.Combine(Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)), @"..\TestBuildFiles");
}
public void CreateInstanceFromCreatesAValidObjectHandle()
{
using (IHost host = Factory.CreateHost(new HostSetup(), new MarkupStreamLogger(TestLog.Default)))
{
Type serviceType = typeof(RemoteHostFactoryTest.TestService);
RemoteHostFactoryTest.TestService serviceProxy = (RemoteHostFactoryTest.TestService)host.GetHostService().CreateInstanceFrom(
AssemblyUtils.GetAssemblyLocalPath(serviceType.Assembly), serviceType.FullName).Unwrap();
Assert.AreEqual(42, serviceProxy.Add(23, 19));
}
}
public void LoadsAssembliesFromHintPathPreferentially()
{
ReflectionOnlyAssemblyLoader loader = new ReflectionOnlyAssemblyLoader();
string binDir = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(ReflectionOnlyAssemblyLoader).Assembly));
loader.AddHintDirectory("non-existent-folder-is-ignored-without-sideeffects");
loader.AddHintDirectory(binDir);
IAssemblyInfo assembly = loader.ReflectionPolicy.LoadAssembly(new AssemblyName("Gallio")); // would ordinarily be loaded from somewhere else
Assert.StartsWith(assembly.Path, binDir);
}
public void FormatWritesTheTransformedReport()
{
string resourcePath = Path.Combine(Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)), @"..\Reports");
IReportWriter reportWriter = Mocks.StrictMock <IReportWriter>();
IReportContainer reportContainer = Mocks.StrictMock <IReportContainer>();
IProgressMonitor progressMonitor = NullProgressMonitor.CreateInstance();
string reportPath = SpecialPathPolicy.For <XsltReportFormatter>().CreateTempFileWithUniqueName().FullName;
using (Stream tempFileStream = File.OpenWrite(reportPath))
{
using (Mocks.Record())
{
SetupResult.For(reportWriter.ReportContainer).Return(reportContainer);
reportWriter.SerializeReport(null, AttachmentContentDisposition.Link);
LastCall.Constraints(Is.NotNull(), Is.Equal(AttachmentContentDisposition.Link))
.Do((SerializeReportDelegate) delegate(XmlWriter writer, AttachmentContentDisposition contentDisposition)
{
XmlDocument doc = new XmlDocument();
doc.InnerXml = "<report>The report.</report>";
doc.Save(writer);
});
SetupResult.For(reportContainer.ReportName).Return("Foo");
Expect.Call(reportContainer.OpenWrite("Foo.ext", MimeTypes.PlainText, new UTF8Encoding(false)))
.Return(tempFileStream);
reportWriter.AddReportDocumentPath("Foo.ext");
Expect.Call(reportContainer.OpenWrite(@"Foo\MbUnitLogo.png", MimeTypes.Png, null)).Return(new MemoryStream());
reportWriter.SaveReportAttachments(null);
LastCall.Constraints(Is.NotNull());
}
using (Mocks.Playback())
{
XsltReportFormatter formatter = new XsltReportFormatter("ext", MimeTypes.PlainText, new DirectoryInfo(resourcePath), "Diagnostic.xslt", new string[] { "MbUnitLogo.png" });
var reportFormatterOptions = new ReportFormatterOptions();
reportFormatterOptions.AddProperty(XsltReportFormatter.AttachmentContentDispositionOption, AttachmentContentDisposition.Link.ToString());
formatter.Format(reportWriter, reportFormatterOptions, progressMonitor);
string reportContents = File.ReadAllText(reportPath);
TestLog.EmbedXml("Diagnostic report contents", reportContents);
Assert.Contains(reportContents, "<resourceRoot>Foo</resourceRoot>");
Assert.Contains(reportContents, "The report.");
File.Delete(reportPath);
}
}
}
public string ResolveAssemblyLocalPath(string assemblyName, bool reflectionOnly)
{
try
{
Assembly assembly = reflectionOnly ? Assembly.ReflectionOnlyLoad(assemblyName) : Assembly.Load(assemblyName);
return(AssemblyUtils.GetAssemblyLocalPath(assembly));
}
catch
{
return(null);
}
}
private static void RunInstallScript(string options)
{
string installScriptDir = Path.GetFullPath(Path.Combine(AssemblyUtils.GetAssemblyLocalPath(typeof(GallioTipIntegrationTest).Assembly), @"..\..\..\..\..\.."));
string installScriptPath = Path.Combine(installScriptDir, "Install.bat");
// We start our process manually because if we use the tasks, it will redirect output
// which causes the "sed" program used by the script to malfunction. Crazy Windows shell...
DiagnosticLog.WriteLine(installScriptPath);
Process process = Process.Start(installScriptPath, options);
process.WaitForExit();
Assert.AreEqual(0, process.ExitCode, "The install script failed.");
}
public void TaskPassesDefaultArgumentsToLauncher()
{
var task = new StubbedRunGallioCommand();
task.SetRunLauncherAction(delegate(TestLauncher launcher)
{
Assert.IsFalse(launcher.DoNotRun);
Assert.IsTrue(launcher.EchoResults);
Assert.IsTrue(launcher.TestExecutionOptions.FilterSet.IsEmpty);
Assert.IsInstanceOfType(typeof(CommandLogger), launcher.Logger);
Assert.IsInstanceOfType(typeof(CommandProgressMonitorProvider), launcher.ProgressMonitorProvider);
Assert.AreEqual("Reports", launcher.TestProject.ReportDirectory);
Assert.IsFalse(launcher.TestProject.IsReportDirectorySpecified);
Assert.AreElementsEqual(new string[] { }, launcher.ReportFormats);
Assert.AreEqual("test-report-{0}-{1}", launcher.TestProject.ReportNameFormat);
Assert.IsFalse(launcher.TestProject.IsReportNameFormatSpecified);
Assert.IsFalse(launcher.ShowReports);
Assert.AreEqual(ReportArchive.Normal, launcher.TestProject.ReportArchive);
Assert.IsNull(launcher.RunTimeLimit);
Assert.AreEqual(StandardTestRunnerFactoryNames.IsolatedProcess, launcher.TestProject.TestRunnerFactoryName);
Assert.IsFalse(launcher.TestProject.IsTestRunnerFactoryNameSpecified);
Assert.AreEqual(0, launcher.TestProject.TestRunnerExtensions.Count);
Assert.AreElementsEqual(new string[] { }, launcher.TestProject.TestRunnerExtensionSpecifications);
Assert.IsNull(launcher.RuntimeSetup.ConfigurationFilePath);
Assert.AreEqual(Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(RunGallioCommand).Assembly)), launcher.RuntimeSetup.RuntimePath);
Assert.AreElementsEqual(new string[] { }, launcher.RuntimeSetup.PluginDirectories);
Assert.AreElementsEqual(new string[] { }, from x in launcher.FilePatterns select x.ToString());
Assert.AreElementsEqual(new string[] { }, from x in launcher.TestProject.TestPackage.HintDirectories select x.ToString());
Assert.IsNull(launcher.TestProject.TestPackage.ApplicationBaseDirectory);
Assert.IsFalse(launcher.TestProject.TestPackage.IsApplicationBaseDirectorySpecified);
Assert.IsNull(launcher.TestProject.TestPackage.WorkingDirectory);
Assert.IsFalse(launcher.TestProject.TestPackage.IsWorkingDirectorySpecified);
Assert.IsFalse(launcher.TestProject.TestPackage.ShadowCopy);
Assert.IsFalse(launcher.TestProject.TestPackage.IsShadowCopySpecified);
Assert.IsNull(launcher.TestProject.TestPackage.DebuggerSetup);
Assert.IsFalse(launcher.TestProject.TestPackage.IsDebuggerSetupSpecified);
Assert.IsNull(launcher.TestProject.TestPackage.RuntimeVersion);
Assert.IsFalse(launcher.TestProject.TestPackage.IsRuntimeVersionSpecified);
Assert.AreEqual(new PropertySet(), launcher.TestRunnerOptions.Properties);
Assert.AreEqual(new PropertySet(), launcher.ReportFormatterOptions.Properties);
return(new TestLauncherResult(new Report()));
});
task.ExecuteWithMessagePump();
}
public IMetadataAccess ResolveAssembly(AssemblyNameInfo name, out FileSystemPath assemblyLocation)
{
try
{
Assembly assembly = Assembly.Load(name.FullName);
assemblyLocation = new FileSystemPath((AssemblyUtils.GetAssemblyLocalPath(assembly)));
return(MetadataProviderFactory.DefaultProvider.GetFromFile(assemblyLocation));
}
catch
{
assemblyLocation = null;
return(null);
}
}
private ProcessTask RunPowerShell(string options)
{
string executablePath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.System),
@"windowspowershell\v1.0\powershell.exe");
string workingDirectory = Path.GetDirectoryName((AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)));
ProcessTask task = Tasks.StartProcessTask(executablePath,
"\"& Add-PSSnapIn Gallio; $DebugPreference = 'Continue'; Run-Gallio 'MbUnit.TestResources.dll' -pd '" +
RuntimeAccessor.RuntimePath + "' " + options + "\"",
workingDirectory);
Assert.IsTrue(task.Run(TimeSpan.FromSeconds(60)), "A timeout occurred.");
return(task);
}
private void InstallRegistryKeysForFramework(string frameworkName, AssemblySignature frameworkAssembly, int priority, IProgressMonitor progressMonitor, RegistryKey hiveKey, string rootKeyPath)
{
string subKeyName = string.Concat(rootKeyPath, @"\", RunnerRegKeyPrefix, " - ", frameworkName, " (", frameworkAssembly, ")");
string message = string.Format("Adding TestDriven.Net runner registry key for framework '{0}'.", frameworkName);
logger.Log(LogSeverity.Info, message);
progressMonitor.SetStatus(message);
using (RegistryKey subKey = hiveKey.CreateSubKey(subKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree))
{
subKey.SetValue(null, priority.ToString());
subKey.SetValue("AssemblyPath", AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly));
subKey.SetValue("TargetFrameworkAssemblyName", frameworkAssembly.ToString()); // n.b. TDNet supports version ranges in the same format we use
subKey.SetValue("TypeName", "Gallio.TDNetRunner.GallioTestRunner");
subKey.SetValue("TypeName_Resident", "Gallio.TDNetRunner.GallioResidentTestRunner");
}
}
public void TaskPassesDefaultArgumentsToLauncher()
{
var task = new StubbedGallioTask();
task.SetRunLauncherAction(launcher =>
{
Assert.IsFalse(launcher.DoNotRun);
Assert.IsFalse(launcher.EchoResults);
Assert.IsTrue(launcher.TestExecutionOptions.FilterSet.IsEmpty);
Assert.AreEqual(LogSeverity.Important, ((FilteredLogger)launcher.Logger).MinSeverity);
Assert.IsInstanceOfType(typeof(LogProgressMonitorProvider), launcher.ProgressMonitorProvider);
Assert.AreEqual("Reports", launcher.TestProject.ReportDirectory);
Assert.IsFalse(launcher.TestProject.IsReportDirectorySpecified);
Assert.AreElementsEqual(new string[] { }, launcher.ReportFormats);
Assert.AreEqual("test-report-{0}-{1}", launcher.TestProject.ReportNameFormat);
Assert.IsFalse(launcher.TestProject.IsTestRunnerFactoryNameSpecified);
Assert.IsFalse(launcher.ShowReports);
Assert.IsNull(launcher.RunTimeLimit);
Assert.AreEqual(ReportArchive.Normal, launcher.TestProject.ReportArchive);
Assert.AreEqual(StandardTestRunnerFactoryNames.IsolatedProcess, launcher.TestProject.TestRunnerFactoryName);
Assert.IsFalse(launcher.TestProject.IsTestRunnerFactoryNameSpecified);
Assert.AreEqual(1, launcher.TestProject.TestRunnerExtensions.Count);
Assert.IsInstanceOfType(typeof(TaskLogExtension), launcher.TestProject.TestRunnerExtensions[0]);
Assert.AreElementsEqual(new string[] { }, launcher.TestProject.TestRunnerExtensionSpecifications);
Assert.IsNull(launcher.RuntimeSetup.ConfigurationFilePath);
Assert.AreEqual(Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(Gallio).Assembly)), launcher.RuntimeSetup.RuntimePath);
Assert.AreElementsEqual(new string[] { }, launcher.RuntimeSetup.PluginDirectories);
Assert.AreElementsEqual(new string[] { }, from x in launcher.FilePatterns select x.ToString());
Assert.AreElementsEqual(new string[] { }, from x in launcher.TestProject.TestPackage.HintDirectories select x.ToString());
Assert.IsNull(launcher.TestProject.TestPackage.ApplicationBaseDirectory);
Assert.IsFalse(launcher.TestProject.TestPackage.IsApplicationBaseDirectorySpecified);
Assert.IsNull(launcher.TestProject.TestPackage.WorkingDirectory);
Assert.IsFalse(launcher.TestProject.TestPackage.IsWorkingDirectorySpecified);
Assert.IsFalse(launcher.TestProject.TestPackage.ShadowCopy);
Assert.IsNull(launcher.TestProject.TestPackage.DebuggerSetup);
Assert.IsNull(launcher.TestProject.TestPackage.RuntimeVersion);
Assert.IsFalse(launcher.TestProject.TestPackage.IsRuntimeVersionSpecified);
Assert.AreEqual(new PropertySet(), launcher.TestRunnerOptions.Properties);
Assert.AreEqual(new PropertySet(), launcher.ReportFormatterOptions.Properties);
var result = new TestLauncherResult(new Report());
result.SetResultCode(ResultCode.Success);
return(result);
});
Assert.IsTrue(task.InternalExecute());
}
private ProcessTask RunEcho(string options)
{
string testAssemblyPath = AssemblyUtils.GetAssemblyLocalPath(typeof(SimpleTest).Assembly);
string workingDirectory = Path.GetDirectoryName((AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)));
#if DEBUG
string executablePath = Path.Combine(workingDirectory, "Gallio.Echo.exe");
#else
string executablePath = Path.Combine(RuntimeAccessor.Instance.GetRuntimeSetup().RuntimePath, "Gallio.Echo.exe");
#endif
ProcessTask task = Tasks.StartProcessTask(executablePath,
"\"" + testAssemblyPath + "\" /pd:\"" + RuntimeAccessor.RuntimePath + "\" " + options,
workingDirectory);
Assert.IsTrue(task.Run(TimeSpan.FromSeconds(60)), "A timeout occurred.");
return task;
}
/// <summary>
/// Gets the location of a source file that contains the declaration of a method, or
/// unknown if not available.
/// </summary>
/// <param name="method">The method.</param>
/// <returns>The source location, or <see cref="CodeLocation.Unknown" /> if unknown.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="method"/> is null.</exception>
public static CodeLocation GetSourceLocation(MethodBase method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
Assembly assembly = method.DeclaringType.Assembly;
string assemblyPath = AssemblyUtils.GetAssemblyLocation(assembly); // use the shadow-copied location if applicable
if (assemblyPath == null)
{
return(CodeLocation.Unknown);
}
if (AppDomain.CurrentDomain.ShadowCopyFiles)
{
try
{
string pdbPath = Path.ChangeExtension(assemblyPath, @".pdb");
if (!File.Exists(pdbPath))
{
string originalAssemblyPath = AssemblyUtils.GetAssemblyLocalPath(assembly);
if (originalAssemblyPath == null)
{
return(CodeLocation.Unknown);
}
string originalPdbPath = Path.ChangeExtension(originalAssemblyPath, @".pdb");
if (!File.Exists(originalPdbPath))
{
return(CodeLocation.Unknown);
}
File.Copy(originalPdbPath, pdbPath);
}
}
catch (IOException)
{
return(CodeLocation.Unknown);
}
}
return(Resolver.GetSourceLocationForMethod(assemblyPath, method.MetadataToken));
}
public void RunAssemblyPassesCorrectOptionsToTheLauncher()
{
StubbedLocalTestRunner tr = new StubbedLocalTestRunner();
Assembly assembly = typeof(TDNetAddInTests).Assembly;
string assemblyPath = AssemblyUtils.GetAssemblyLocalPath(assembly);
tr.SetRunLauncherAction(delegate(TestLauncher launcher)
{
AssertTestLauncherOptions(launcher, assemblyPath, "*");
return(new TestLauncherResult(new Report()));
});
FacadeOptions facadeOptions = new FacadeOptions();
tr.Run(MockRepository.GenerateStub <IFacadeTestListener>(), assemblyPath, null, facadeOptions);
}
/// <summary>
/// Gets the report generator executable path.
/// </summary>
/// <returns>The report generator executable path.</returns>
private static string GetReportGeneratorExePath()
{
string pluginDir = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(PartCoverTool).Assembly));
string partcoverDir = Path.Combine(pluginDir, @"libs\ReportGenerator\ReportGenerator.exe");
if (File.Exists(partcoverDir))
{
return(partcoverDir);
}
#if DEBUG
partcoverDir = Path.GetFullPath(Path.Combine(pluginDir, @"..\..\libs\ReportGenerator\ReportGenerator.exe"));
if (File.Exists(partcoverDir))
{
return(partcoverDir);
}
#endif
return(null);
}
public IMetadataAccess ResolveAssembly(AssemblyName name, out string assemblyLocation)
{
try
{
Assembly assembly = Assembly.Load(name);
assemblyLocation = AssemblyUtils.GetAssemblyLocalPath(assembly);
#if RESHARPER_31 || RESHARPER_40 || RESHARPER_41
return(MetadataProvider.GetFromFile(assemblyLocation));
#else
return(MetadataProvider.Instance.GetFromFile(assemblyLocation));
#endif
}
catch
{
assemblyLocation = null;
return(null);
}
}
public static Solution OpenSolutionIfNeeded()
{
string solutionPath = Path.Combine(Path.GetDirectoryName(
AssemblyUtils.GetAssemblyLocalPath(typeof(VisualStudioTestHarness).Assembly)), @"..\TestSolution.sln");
Solution solution = null;
visualStudio.Call(dte =>
{
if (!dte.Solution.IsOpen)
{
dte.Solution.Open(solutionPath);
}
solution = dte.Solution;
});
return(solution);
}
public void RunReturnsCorrectResultCode(int resultCode, FacadeTestRunState expectedRunState)
{
StubbedLocalTestRunner tr = new StubbedLocalTestRunner();
Assembly assembly = typeof(TDNetAddInTests).Assembly;
string assemblyPath = AssemblyUtils.GetAssemblyLocalPath(assembly);
tr.SetRunLauncherAction(delegate
{
TestLauncherResult result = new TestLauncherResult(new Report());
result.SetResultCode(resultCode);
return(result);
});
FacadeOptions facadeOptions = new FacadeOptions();
FacadeTestRunState runResult = tr.Run(MockRepository.GenerateStub <IFacadeTestListener>(), assemblyPath, null, facadeOptions);
Assert.AreEqual(expectedRunState, runResult);
}
/// <summary>
/// Gets the XML documentation for a member.
/// </summary>
/// <param name="member">The member.</param>
/// <returns>The XML documentation for the member, or null if none available.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="member"/> is null.</exception>
public static string GetXmlDocumentation(MemberInfo member)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
Type type = member as Type ?? member.DeclaringType;
string assemblyPath = AssemblyUtils.GetAssemblyLocalPath(type.Assembly);
if (assemblyPath == null)
{
return(null);
}
string memberId = FormatId(member);
return(Resolver.GetXmlDocumentation(assemblyPath, memberId));
}
public override string GetInstallDir()
{
string pluginDir = Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(typeof(NCoverV1Tool).Assembly));
string ncoverDir = Path.Combine(pluginDir, @"libs\NCover");
if (Directory.Exists(ncoverDir))
{
return(ncoverDir);
}
#if DEBUG
ncoverDir = Path.GetFullPath(Path.Combine(pluginDir, @"..\..\libs\NCover"));
if (Directory.Exists(ncoverDir))
{
return(ncoverDir);
}
#endif
return(null);
}
public void RunMemberWithTypePassesCorrectOptionsToTheLauncher()
{
StubbedLocalTestRunner tr = new StubbedLocalTestRunner();
Type type = typeof(TDNetAddInTests);
Assembly assembly = type.Assembly;
string assemblyPath = AssemblyUtils.GetAssemblyLocalPath(assembly);
tr.SetRunLauncherAction(delegate(TestLauncher launcher)
{
AssertTestLauncherOptions(launcher, assemblyPath,
string.Format("Type: {0}", type.FullName));
return(new TestLauncherResult(new Report()));
});
FacadeOptions facadeOptions = new FacadeOptions();
tr.Run(MockRepository.GenerateStub <IFacadeTestListener>(), assemblyPath, "T:" + type.FullName, facadeOptions);
}
public void RunNamespacePassesCorrectOptionsToTheLauncher()
{
StubbedLocalTestRunner tr = new StubbedLocalTestRunner();
Assembly assembly = typeof(TDNetAddInTests).Assembly;
string assemblyPath = AssemblyUtils.GetAssemblyLocalPath(assembly);
string @namespace = "Foo";
tr.SetRunLauncherAction(delegate(TestLauncher launcher)
{
AssertTestLauncherOptions(launcher, AssemblyUtils.GetAssemblyLocalPath(assembly),
string.Format("Namespace: {0}", @namespace));
return(new TestLauncherResult(new Report()));
});
FacadeOptions facadeOptions = new FacadeOptions();
tr.Run(MockRepository.GenerateStub <IFacadeTestListener>(), assemblyPath, "N:" + @namespace, facadeOptions);
}
