/// <inheritdoc />
protected override object RunIsolatedTaskInHost <TIsolatedTask>(HostSetup hostSetup, StatusReporter statusReporter, object[] args)
{
NCoverTool tool = NCoverTool.GetInstance(version, hostSetup.ProcessorArchitecture);
if (!tool.IsInstalled())
{
throw new TestIsolationException(string.Format("{0} does not appear to be installed.", tool.Name));
}
string ncoverArguments, ncoverCoverageFile;
NCoverHost.GetNCoverProperties(hostSetup, out ncoverArguments, out ncoverCoverageFile);
if (File.Exists(ncoverCoverageFile))
{
File.Delete(ncoverCoverageFile);
}
if (batch != null)
{
hostSetup = hostSetup.Copy();
string tempCoverageFile = batch.Enlist(ncoverCoverageFile);
NCoverHost.SetNCoverCoverageFile(hostSetup, tempCoverageFile);
}
return(base.RunIsolatedTaskInHost <TIsolatedTask>(hostSetup, statusReporter, args));
}
/// <summary>
/// Called when the local player joins the lobby.
/// </summary>
/// <param name="connection"></param>
private void OnLobbyLocalPeerConnected(SteamConnection connection)
{
network.LocalConnection = connection;
network.MaxPlayers = SteamMatchmaking.GetLobbyMemberLimit(connection.LobbyID);
network.OnSetDefaultLobbyMemberData(connection);
// Get Lobby Member Data
int numMembers = SteamMatchmaking.GetNumLobbyMembers(connection.LobbyID);
for (int i = 0; i < numMembers; i++)
{
CSteamID id = SteamMatchmaking.GetLobbyMemberByIndex(connection.LobbyID, i);
if (id == connection.SteamID)
{
continue;
}
connection.AddConnection(id);
}
//GetModule<AuthModule>().BeginAuthentication(authenticationLevel);
if (connection.IsHost)
{
HostSetup?.Invoke(connection);
}
else
{
ClientSetup?.Invoke(connection);
}
connection.IsConnected = true;
}
/// <summary>
/// Gets the part cover properties.
/// </summary>
/// <param name="hostSetup">The host setup.</param>
/// <param name="partcoverIncludes">The partcover includes.</param>
/// <param name="partcoverExcludes">The partcover excludes.</param>
/// <param name="partcoverCoverageFile">The partcover coverage file.</param>
internal static void GetPartCoverProperties(HostSetup hostSetup,
out string partcoverIncludes, out string partcoverExcludes, out string partcoverCoverageFile)
{
if (hostSetup == null)
{
throw new ArgumentNullException("hostSetup");
}
partcoverIncludes = hostSetup.Properties.GetValue("PartCoverIncludes");
partcoverExcludes = hostSetup.Properties.GetValue("PartCoverExcludes");
partcoverCoverageFile = hostSetup.Properties.GetValue("PartCoverCoverageFile");
if (partcoverIncludes == null)
{
partcoverIncludes = "[*]*";
}
if (partcoverExcludes == null)
{
partcoverExcludes = "[Gallio*]*;[MbUnit*]*;[Microsoft*]*";
}
if (string.IsNullOrEmpty(partcoverCoverageFile))
{
partcoverCoverageFile = "Coverage.xml";
}
partcoverCoverageFile = Path.GetFullPath(partcoverCoverageFile);
}
private void ExploreOrRun(ITestIsolationContext testIsolationContext, TestPackage testPackage, TestExplorationOptions testExplorationOptions,
TestExecutionOptions testExecutionOptions, IMessageSink messageSink, IProgressMonitor progressMonitor, string taskName)
{
using (progressMonitor.BeginTask(taskName, 1))
{
if (progressMonitor.IsCanceled)
{
return;
}
FileInfo testDriverScriptFile = GetTestDriverScriptFile(testPackage);
if (testDriverScriptFile == null)
{
return;
}
HostSetup hostSetup = CreateHostSetup(testPackage);
ScriptRuntimeSetup scriptRuntimeSetup = CreateScriptRuntimeSetup(testPackage);
string testDriverScriptPath = testDriverScriptFile.FullName;
var remoteMessageSink = new RemoteMessageSink(messageSink);
var remoteLogger = new RemoteLogger(logger);
using (var remoteProgressMonitor = new RemoteProgressMonitor(progressMonitor.CreateSubProgressMonitor(1)))
{
testIsolationContext.RunIsolatedTask <ExploreOrRunTask>(hostSetup,
(statusMessage) => progressMonitor.SetStatus(statusMessage),
new object[] { testPackage, scriptRuntimeSetup, testDriverScriptPath, testExplorationOptions, testExecutionOptions,
remoteMessageSink, remoteProgressMonitor, remoteLogger });
}
}
}
protected override void ConfigureHostSetup(HostSetup hostSetup, TestPackage testPackage, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
base.ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
// csUnit always creates its own AppDomain with shadow copy enabled so we do not need this.
hostSetup.ShadowCopy = false;
}
public void Copy()
{
HostSetup setup = new HostSetup
{
ApplicationBaseDirectory = @"C:\AppBase",
Configuration = { ConfigurationXml = "<xml/>" },
ConfigurationFileLocation = ConfigurationFileLocation.AppBase,
ProcessorArchitecture = ProcessorArchitecture.Amd64,
ShadowCopy = true,
DebuggerSetup = new DebuggerSetup(),
RuntimeVersion = "2.0.50727",
Elevated = true,
WorkingDirectory = @"C:\WorkingDir",
};
setup.AddHintDirectory("Abc");
setup.AddProperty("abc", "def");
HostSetup copy = setup.Copy();
Assert.AreEqual(setup.ApplicationBaseDirectory, copy.ApplicationBaseDirectory);
Assert.AreEqual(setup.Configuration.ConfigurationXml, copy.Configuration.ConfigurationXml);
Assert.AreEqual(setup.ConfigurationFileLocation, copy.ConfigurationFileLocation);
Assert.AreEqual(setup.ProcessorArchitecture, copy.ProcessorArchitecture);
Assert.AreEqual(setup.ShadowCopy, copy.ShadowCopy);
Assert.AreEqual(setup.Elevated, copy.Elevated);
Assert.IsNotNull(copy.DebuggerSetup);
Assert.AreEqual(setup.RuntimeVersion, copy.RuntimeVersion);
Assert.AreEqual(setup.WorkingDirectory, copy.WorkingDirectory);
Assert.AreEqual(setup.HintDirectories, copy.HintDirectories);
Assert.AreEqual(setup.Properties, copy.Properties);
}
/// <summary>
/// Creates a host setup for a test package.
/// </summary>
/// <param name="testPackage">The test package, not null.</param>
/// <returns>The host setup setup.</returns>
protected HostSetup CreateHostSetup(TestPackage testPackage)
{
HostSetup hostSetup = testPackage.CreateHostSetup();
ConfigureHostSetup(hostSetup, testPackage);
return(hostSetup);
}
/// <inheritdoc />
protected override IHost CreateHostImpl(HostSetup hostSetup, ILogger logger)
{
NCoverHost host = new NCoverHost(hostSetup, logger, RuntimePath, version);
host.Connect();
return(host);
}
public void WriteTemporaryConfigurationFile_ReturnsNullWhenNone()
{
HostSetup setup = new HostSetup();
setup.ConfigurationFileLocation = ConfigurationFileLocation.None;
Assert.IsNull(setup.WriteTemporaryConfigurationFile());
}
public void WriteTemporaryConfigurationFile_ThrowsIfApplicationBaseDirectoryMissingButRequested()
{
HostSetup setup = new HostSetup();
setup.ConfigurationFileLocation = ConfigurationFileLocation.AppBase;
Assert.Throws <InvalidOperationException>(() => setup.WriteTemporaryConfigurationFile());
}
public void ProcessorArchitecture_CanGetSet()
{
HostSetup setup = new HostSetup();
Assert.AreEqual(ProcessorArchitecture.MSIL, setup.ProcessorArchitecture);
setup.ProcessorArchitecture = ProcessorArchitecture.X86;
Assert.AreEqual(ProcessorArchitecture.X86, setup.ProcessorArchitecture);
}
/// <summary>
/// Creates a host setup for a particular assembly within a test package.
/// </summary>
/// <param name="testPackage">The test package, not null.</param>
/// <param name="assemblyPath">The assembly path, not null.</param>
/// <param name="assemblyMetadata">The assembly metadata, not null.</param>
/// <returns>The host setup setup.</returns>
protected HostSetup CreateHostSetup(TestPackage testPackage, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
HostSetup hostSetup = testPackage.CreateHostSetup();
ConfigureHostSetupForAssembly(hostSetup, assemblyPath, assemblyMetadata);
ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
return(hostSetup);
}
/// <summary>
/// Sets the part cover coverage file.
/// </summary>
/// <param name="hostSetup">The host setup.</param>
/// <param name="partCoverCoverageFile">The part cover coverage file.</param>
internal static void SetPartCoverCoverageFile(HostSetup hostSetup, string partCoverCoverageFile)
{
if (hostSetup == null)
{
throw new ArgumentNullException("hostSetup");
}
hostSetup.RemoveProperty("PartCoverCoverageFile");
hostSetup.AddProperty("PartCoverCoverageFile", partCoverCoverageFile);
}
private IHost CreateHost()
{
var hostSetup = new HostSetup();
hostSetup.Elevated = true;
var hostFactory = new IsolatedProcessHostFactory(runtime);
var host = hostFactory.CreateHost(hostSetup, runtime.Logger);
return(host);
}
private HostSetup CreateHostSetup(TestPackage testPackage, FileInfo file)
{
HostSetup hostSetup = testPackage.CreateHostSetup();
using (var reader = new PEImageReader(file.FullName))
{
PEImageInfo info = reader.Read();
hostSetup.ProcessorArchitecture = info.Architecture;
}
return(hostSetup);
}
public void HostRunsWithShadowCopyingEnabledOnRequest()
{
HostSetup hostSetup = new HostSetup();
hostSetup.ShadowCopy = true;
using (IHost host = Factory.CreateHost(hostSetup, new MarkupStreamLogger(TestLog.Default)))
{
HostAssemblyResolverHook.InstallCallback(host);
Assert.IsTrue(host.GetHostService().Do <object, bool>(IsShadowCopyFilesEnabled, null));
}
}
/// <inheritdoc />
protected override object RunIsolatedTaskImpl <TIsolatedTask>(HostSetup hostSetup, StatusReporter statusReporter, object[] args)
{
if (batch == null)
{
using (BeginBatch(statusReporter))
RunIsolatedTaskImpl <TIsolatedTask>(hostSetup, statusReporter, args);
}
TestIsolationServer server = batch.GetTestIsolationServer(hostSetup.DebuggerSetup);
return(server.RunIsolatedTaskOnClient(typeof(TIsolatedTask), args));
}
public void LaunchesMSILHostByDefault()
{
HostSetup hostSetup = new HostSetup();
using (IHost host = Factory.CreateHost(hostSetup, new MarkupStreamLogger(TestLog.Default)))
{
HostAssemblyResolverHook.InstallCallback(host);
string processName = host.GetHostService().Do <object, string>(GetHostProcessName, null);
Assert.Contains(processName, "Gallio.Host.exe");
}
}
public void HostRunsWithSpecifiedApplicationBaseDirectory()
{
HostSetup hostSetup = new HostSetup();
hostSetup.ApplicationBaseDirectory = Path.GetTempPath();
using (IHost host = Factory.CreateHost(hostSetup, new MarkupStreamLogger(TestLog.Default)))
{
HostAssemblyResolverHook.InstallCallback(host);
AssertArePathsEqualIgnoringFinalBackslash(Path.GetTempPath(), host.GetHostService().Do <object, string>(GetApplicationBaseDirectory, null));
}
}
/// <inheritdoc />
protected override IHost CreateHostImpl(HostSetup hostSetup, ILogger logger)
{
if (!Service.IsInstalled)
{
throw new IntegrationNotInstalledException("TypeMock does not appear to be installed.");
}
TypeMockHost host = new TypeMockHost(hostSetup, logger, RuntimePath);
host.Connect();
return(host);
}
/// <inheritdoc />
sealed protected override object RunIsolatedTaskImpl <TIsolatedTask>(HostSetup hostSetup, StatusReporter statusReporter, object[] args)
{
hostSetup = hostSetup.Copy();
foreach (var pair in TestIsolationOptions.Properties)
{
if (!hostSetup.Properties.ContainsKey(pair.Key))
{
hostSetup.AddProperty(pair.Key, pair.Value);
}
}
return(RunIsolatedTaskInHost <TIsolatedTask>(hostSetup, statusReporter, args));
}
protected override void ConfigureHostSetup(HostSetup hostSetup, TestPackage testPackage,
string assemblyPath, AssemblyMetadata assemblyMetadata)
{
base.ConfigureHostSetup(hostSetup, testPackage, assemblyPath, assemblyMetadata);
if (hostSetup.ProcessorArchitecture == ProcessorArchitecture.Amd64 ||
hostSetup.ProcessorArchitecture == ProcessorArchitecture.IA64)
{
throw new ModelException("Cannot run MSTest tests compiled for 64bit because MSTest.exe throws exceptions when run without isolation as a 64bit process.");
}
hostSetup.ProcessorArchitecture = ProcessorArchitecture.X86;
}
private void ConfigureHostSetupForAssembly(HostSetup hostSetup, string assemblyPath, AssemblyMetadata assemblyMetadata)
{
string assemblyDir = Path.GetDirectoryName(assemblyPath);
if (hostSetup.ApplicationBaseDirectory == null)
{
hostSetup.ApplicationBaseDirectory = assemblyDir;
}
if (hostSetup.WorkingDirectory == null)
{
hostSetup.WorkingDirectory = assemblyDir;
}
hostSetup.ConfigurationFileLocation = ConfigurationFileLocation.AppBase;
string assemblyConfigFilePath = assemblyPath + @".config";
if (File.Exists(assemblyConfigFilePath))
{
string configurationXml = File.ReadAllText(assemblyConfigFilePath);
hostSetup.Configuration.ConfigurationXml = configurationXml;
if (hostSetup.RuntimeVersion == null)
{
hostSetup.RuntimeVersion = GetPreferredRuntimeVersion(configurationXml);
}
}
foreach (AssemblyBinding assemblyBinding in RuntimeAccessor.Instance.GetAllPluginAssemblyBindings())
{
if (assemblyBinding.CodeBase != null)
{
hostSetup.Configuration.AddAssemblyBinding(assemblyBinding);
}
}
if (hostSetup.ProcessorArchitecture == ProcessorArchitecture.None ||
hostSetup.ProcessorArchitecture == ProcessorArchitecture.MSIL)
{
hostSetup.ProcessorArchitecture = assemblyMetadata.ProcessorArchitecture;
}
if (hostSetup.RuntimeVersion == null)
{
hostSetup.RuntimeVersion = assemblyMetadata.RuntimeVersion;
}
ConfigureHostSetupForAssembly(hostSetup, assemblyPath);
}
/// <inheritdoc />
public object RunIsolatedTask <TIsolatedTask>(HostSetup hostSetup, StatusReporter statusReporter, object[] args)
where TIsolatedTask : IsolatedTask, new()
{
if (hostSetup == null)
{
throw new ArgumentNullException("hostSetup");
}
if (statusReporter == null)
{
throw new ArgumentNullException("statusReporter");
}
return(RunIsolatedTaskImpl <TIsolatedTask>(hostSetup, statusReporter, args));
}
public void LaunchesX86HostWhenDemandedByProcessorArchitecture()
{
HostSetup hostSetup = new HostSetup();
hostSetup.ProcessorArchitecture = ProcessorArchitecture.X86;
using (IHost host = Factory.CreateHost(hostSetup, new MarkupStreamLogger(TestLog.Default)))
{
HostAssemblyResolverHook.InstallCallback(host);
string processName = host.GetHostService().Do <object, string>(GetHostProcessName, null);
Assert.Contains(processName, "Gallio.Host.x86.exe");
}
}
private void onMatchList(bool success, string extendedInfo, List <MatchInfoSnapshot> matchList)
{
if (!success)
{
Debug.Log("Please refresh...");
}
foreach (MatchInfoSnapshot match in matchList)
{
GameObject listGameObj = Instantiate(PrefabForHost);
listGameObj.transform.SetParent(ParentForHost.transform);
HostSetup hostSetup = listGameObj.GetComponent <HostSetup>();
hostSetup.Setup(match);
}
}
private void onMatchList(bool success, string extendedInfo, List <MatchInfoSnapshot> responseData)
{
if (!success)
{
Debug.Log("Refresh");
}
foreach (MatchInfoSnapshot match in responseData)
{
GameObject ListGameObject = Instantiate(GamePrefab);
ListGameObject.transform.SetParent(parentForHost.transform);
HostSetup host = ListGameObject.GetComponent <HostSetup> ();
host.Setup(match);
}
}
public void CreateHostDelegatesToCreateHostImplWithACanonicalizedHostSetup()
{
StubHostFactory factory = new StubHostFactory();
HostSetup originalHostSetup = new HostSetup();
originalHostSetup.WorkingDirectory = "";
ILogger logger = new MarkupStreamLogger(TestLog.Default);
Assert.IsNotNull(factory.CreateHost(originalHostSetup, logger));
Assert.AreNotSame(originalHostSetup, factory.HostSetup);
Assert.AreEqual(Environment.CurrentDirectory, factory.HostSetup.WorkingDirectory);
Assert.AreSame(logger, factory.Logger);
}
/// <summary>
/// Creates a host setup based on the package properties.
/// </summary>
/// <returns>The host setup.</returns>
public HostSetup CreateHostSetup()
{
var hostSetup = new HostSetup
{
DebuggerSetup = DebuggerSetup,
ShadowCopy = ShadowCopy,
ApplicationBaseDirectory = ApplicationBaseDirectory != null ? ApplicationBaseDirectory.FullName : null,
WorkingDirectory = WorkingDirectory != null ? WorkingDirectory.FullName : null,
RuntimeVersion = RuntimeVersion
};
GenericCollectionUtils.ForEach(Properties, x => hostSetup.AddProperty(x.Key, x.Value));
GenericCollectionUtils.ForEach(HintDirectories, x => hostSetup.AddHintDirectory(x.FullName));
return(hostSetup);
}
internal static void GetNCoverProperties(HostSetup hostSetup,
out string ncoverArguments, out string ncoverCoverageFile)
{
ncoverArguments = hostSetup.Properties.GetValue("NCoverArguments");
ncoverCoverageFile = hostSetup.Properties.GetValue("NCoverCoverageFile");
if (ncoverArguments == null)
{
ncoverArguments = string.Empty;
}
if (string.IsNullOrEmpty(ncoverCoverageFile))
{
ncoverCoverageFile = "Coverage.xml";
}
ncoverCoverageFile = Path.GetFullPath(ncoverCoverageFile);
}
