public void Setup()
{
_solutionSettings = new RunSettings
{
ProjectRegex = null,
AdditionalTestExecutionParam = "solution"
};
_projectSettings1 = new RunSettings
{
ProjectRegex = ".*PerformanceTests.exe",
AdditionalTestExecutionParam = "project1"
};
_projectSettings2 = new RunSettings
{
ProjectRegex = ".*UnitTests.exe",
AdditionalTestExecutionParam = "project2"
};
_container = new RunSettingsContainer {
SolutionSettings = _solutionSettings
};
_container.ProjectSettings.Add(_projectSettings1);
_container.ProjectSettings.Add(_projectSettings2);
}
private void GetValuesFromSolutionSettingsFile(RunSettingsContainer settingsContainer, ILogger logger)
{
string solutionRunSettingsFile = GetSolutionSettingsXmlFile();
try
{
if (File.Exists(solutionRunSettingsFile))
{
if (!settingsContainer.GetUnsetValuesFrom(solutionRunSettingsFile))
{
logger.Log(MessageLevel.Warning,
$"Solution test settings file found at '{solutionRunSettingsFile}', but does not contain {Constants.RunSettingsName} node");
}
}
}
catch (InvalidRunSettingsException e) when(e.InnerException != null)
{
logger.Log(MessageLevel.Error,
$"Solution test settings file could not be parsed, check file '{solutionRunSettingsFile}'. Error message: {e.InnerException.Message}");
}
catch (Exception e)
{
logger.Log(MessageLevel.Error,
$"Solution test settings file could not be parsed, check file '{solutionRunSettingsFile}'. Exception:{Environment.NewLine}{e}");
}
}
private void GetValuesFromSolutionSettingsFile(RunSettingsContainer settingsContainer, ILogger logger)
{
string solutionRunSettingsFile = GetSolutionSettingsXmlFile();
try
{
if (File.Exists(solutionRunSettingsFile))
{
if (!settingsContainer.GetUnsetValuesFrom(solutionRunSettingsFile))
{
logger.Log(MessageLevel.Warning, string.Format(Resources.SolutionFoundButMissingNode, solutionRunSettingsFile, Constants.RunSettingsName));
}
}
}
catch (InvalidRunSettingsException e) when(e.InnerException != null)
{
logger.Log(MessageLevel.Error,
$"Solution test settings file could not be parsed, check file '{solutionRunSettingsFile}'. Error message: {e.InnerException.Message}");
}
catch (Exception e)
{
logger.Log(MessageLevel.Error,
string.Format(Resources.CantParseSettings, solutionRunSettingsFile, e));
}
}
private void GetValuesFromGlobalSettings(RunSettingsContainer settingsContainer)
{
GetValuesFromGlobalSettings(settingsContainer.SolutionSettings);
foreach (RunSettings projectSettings in settingsContainer.ProjectSettings)
{
GetValuesFromGlobalSettings(projectSettings);
}
}
public IXPathNavigable AddRunSettings(IXPathNavigable runSettingDocument,
IRunSettingsConfigurationInfo configurationInfo, ILogger logger)
{
XPathNavigator runSettingsNavigator = runSettingDocument.CreateNavigator();
Debug.Assert(runSettingsNavigator != null, "userRunSettingsNavigator == null!");
if (!runSettingsNavigator.MoveToChild(Constants.RunSettingsName, ""))
{
logger.Log(MessageLevel.Warning, "RunSettingsDocument does not contain a RunSettings node! Canceling settings merging...");
return(runSettingsNavigator);
}
var settingsContainer = new RunSettingsContainer();
settingsContainer.SolutionSettings = new RunSettings();
if (CopyToUnsetValues(runSettingsNavigator, settingsContainer))
{
runSettingsNavigator.DeleteSelf(); // this node is to be replaced by the final run settings
}
string solutionRunSettingsFile = GetSolutionSettingsXmlFile();
try
{
if (File.Exists(solutionRunSettingsFile))
{
var solutionRunSettingsDocument = new XPathDocument(solutionRunSettingsFile);
XPathNavigator solutionRunSettingsNavigator = solutionRunSettingsDocument.CreateNavigator();
if (solutionRunSettingsNavigator.MoveToChild(Constants.RunSettingsName, ""))
{
CopyToUnsetValues(solutionRunSettingsNavigator, settingsContainer);
}
else
{
logger.Log(MessageLevel.Warning, $"Solution test settings file found at '{solutionRunSettingsFile}', but does not contain {Constants.RunSettingsName} node");
}
}
}
catch (Exception e)
{
logger.Log(MessageLevel.Warning,
$"Solution test settings file could not be parsed, check file: {solutionRunSettingsFile}{Environment.NewLine}Exception: {e}");
}
foreach (var projectSettings in settingsContainer.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(settingsContainer.SolutionSettings);
}
GetValuesFromGlobalSettings(settingsContainer);
runSettingsNavigator.MoveToChild(Constants.RunSettingsName, "");
runSettingsNavigator.AppendChild(settingsContainer.ToXml().CreateNavigator());
runSettingsNavigator.MoveToRoot();
return(runSettingsNavigator);
}
private bool CopyToUnsetValues(XPathNavigator sourceNavigator, RunSettingsContainer targetSettingsContainer)
{
if (sourceNavigator.MoveToChild(GoogleTestConstants.SettingsName, ""))
{
var sourceRunSettings = RunSettingsContainer.LoadFromXml(sourceNavigator);
targetSettingsContainer.GetUnsetValuesFrom(sourceRunSettings);
return(true);
}
return(false);
}
private static void AddProjectSettings(RunSettingsContainer settingsContainer, string project, string workingDir)
{
if (workingDir == null)
{
return;
}
settingsContainer.ProjectSettings.Add(new RunSettings
{
ProjectRegex = project,
WorkingDir = workingDir == "" ? null : workingDir
});
}
private string SerializeSettingsContainer(RunSettingsContainer settingsContainer)
{
var settingsNavigator = EmbedSettingsIntoRunSettings(settingsContainer);
var finalDocument = new XmlDocument();
finalDocument.LoadXml(settingsNavigator.OuterXml);
string targetFile = Path.GetTempFileName();
finalDocument.Save(targetFile);
return(targetFile);
}
public void GetUnsetValuesFrom__ResultsInCorrectlyMergedContainer()
{
var solutionSettings = new RunSettings
{
ProjectRegex = null,
AdditionalTestDiscoveryParam = "bar",
AdditionalTestExecutionParam = "foo",
BatchForTestSetup = "solution"
};
var projectSettings1 = new RunSettings
{
ProjectRegex = ".*PerformanceTests.exe",
AdditionalTestDiscoveryParam = "bar",
AdditionalTestExecutionParam = "foo",
BatchForTestSetup = "project1"
};
var projectSettings2 = new RunSettings
{
ProjectRegex = ".*IntegrationTests.exe",
AdditionalTestDiscoveryParam = "bar",
AdditionalTestExecutionParam = "foo",
BatchForTestSetup = "project2"
};
var container = new RunSettingsContainer {
SolutionSettings = solutionSettings
};
container.ProjectSettings.Add(projectSettings1);
container.ProjectSettings.Add(projectSettings2);
_container.GetUnsetValuesFrom(container);
_container.SolutionSettings.AdditionalTestDiscoveryParam.Should().Be("solution");
_container.SolutionSettings.AdditionalTestExecutionParam.Should().Be("solution");
_container.SolutionSettings.BatchForTestSetup.Should().Be("solution");
_container.ProjectSettings.Count.Should().Be(3);
_container.ProjectSettings[0].AdditionalTestDiscoveryParam.Should().Be("project1");
_container.ProjectSettings[1].AdditionalTestDiscoveryParam.Should().Be("project2");
_container.ProjectSettings[2].AdditionalTestDiscoveryParam.Should().Be("bar");
_container.ProjectSettings[0].AdditionalTestExecutionParam.Should().Be("project1");
_container.ProjectSettings[1].AdditionalTestExecutionParam.Should().Be("project2");
_container.ProjectSettings[2].AdditionalTestExecutionParam.Should().Be("foo");
_container.ProjectSettings[0].BatchForTestSetup.Should().Be("project1");
_container.ProjectSettings[1].BatchForTestSetup.Should().BeNull();
_container.ProjectSettings[2].BatchForTestSetup.Should().Be("project2");
}
public static RunSettingsContainer LoadFromXml(XPathNavigator rootElement)
{
ValidateArg.NotNull(rootElement, nameof(rootElement));
RunSettingsContainer runSettingsContainer = null;
if (rootElement.Name.Equals(GoogleTestConstants.SettingsName))
{
var schemaSet = new XmlSchemaSet();
var schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GoogleTestAdapterSettings.xsd");
var schemaSettings = new XmlReaderSettings(); // Don't use an object initializer for FxCop to understand.
schemaSettings.XmlResolver = null;
schemaSet.Add(null, XmlReader.Create(schemaStream, schemaSettings));
var settings = new XmlReaderSettings(); // Don't use an object initializer for FxCop to understand.
settings.Schemas = schemaSet;
settings.ValidationType = ValidationType.Schema;
settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings;
settings.XmlResolver = null;
settings.ValidationEventHandler += (object o, ValidationEventArgs e) => throw e.Exception;
var reader = XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(rootElement.OuterXml)), settings);
try
{
var serializer = new XmlSerializer(typeof(SettingsSerializationContainer));
var serializationContainer = serializer.Deserialize(reader) as SettingsSerializationContainer;
runSettingsContainer = new RunSettingsContainer(serializationContainer);
ValidateAdditionalRunSettingsConstraints(runSettingsContainer.SolutionSettings);
foreach (var runSettings in runSettingsContainer.ProjectSettings)
{
ValidateAdditionalRunSettingsConstraints(runSettings);
}
}
catch (InvalidRunSettingsException)
{
throw;
}
catch (InvalidOperationException e) when(e.InnerException is XmlSchemaValidationException)
{
throw new InvalidRunSettingsException(String.Format(Resources.Invalid, GoogleTestConstants.SettingsName), e.InnerException);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
return(runSettingsContainer ?? new RunSettingsContainer());
}
public void Load(XmlReader reader)
{
var document = new XPathDocument(reader);
var navigator = document.CreateNavigator();
RunSettingsContainer container = null;
try
{
if (navigator.MoveToChild(GoogleTestConstants.SettingsName, ""))
{
container = RunSettingsContainer.LoadFromXml(navigator);
}
}
catch (InvalidRunSettingsException)
{ }
SettingsContainer = container ?? new RunSettingsContainer();
}
private RunSettingsContainer SetupSettingsContainer(string solutionWorkingDir,
string project1WorkingDir, string project2WorkingDir, string project3WorkingDir)
{
var settingsContainer = new RunSettingsContainer
{
SolutionSettings = new RunSettings
{
ProjectRegex = null,
WorkingDir = solutionWorkingDir
},
ProjectSettings = new List <RunSettings>()
};
AddProjectSettings(settingsContainer, "project1", project1WorkingDir);
AddProjectSettings(settingsContainer, "project2", project2WorkingDir);
AddProjectSettings(settingsContainer, "project3", project3WorkingDir);
return(settingsContainer);
}
private static XPathNavigator EmbedSettingsIntoRunSettings(RunSettingsContainer settingsContainer)
{
var settingsDocument = new XmlDocument();
XmlDeclaration xmlDeclaration = settingsDocument.CreateXmlDeclaration("1.0", "UTF-8", null);
XmlElement root = settingsDocument.DocumentElement;
settingsDocument.InsertBefore(xmlDeclaration, root);
XmlElement runSettingsNode = settingsDocument.CreateElement("", Constants.RunSettingsName, "");
settingsDocument.AppendChild(runSettingsNode);
var settingsNavigator = settingsDocument.CreateNavigator();
settingsNavigator.MoveToChild(Constants.RunSettingsName, "");
settingsNavigator.AppendChild(settingsContainer.ToXml().CreateNavigator());
settingsNavigator.MoveToRoot();
return(settingsNavigator);
}
public IXPathNavigable AddRunSettings(IXPathNavigable runSettingDocument,
IRunSettingsConfigurationInfo configurationInfo, ILogger logger)
{
XPathNavigator runSettingsNavigator = runSettingDocument.CreateNavigator();
Debug.Assert(runSettingsNavigator != null, "userRunSettingsNavigator == null!");
if (!runSettingsNavigator.MoveToChild(Constants.RunSettingsName, ""))
{
logger.Log(MessageLevel.Warning, "RunSettingsDocument does not contain a RunSettings node! Canceling settings merging...");
return(runSettingsNavigator);
}
var settingsContainer = new RunSettingsContainer();
try
{
if (settingsContainer.GetUnsetValuesFrom(runSettingsNavigator))
{
runSettingsNavigator.DeleteSelf(); // this node is to be replaced by the final run settings
}
}
catch (InvalidRunSettingsException e)
{
logger.Log(MessageLevel.Error, $"Invalid run settings: {e.Message}");
}
GetValuesFromSolutionSettingsFile(settingsContainer, logger);
foreach (var projectSettings in settingsContainer.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(settingsContainer.SolutionSettings);
}
GetValuesFromGlobalSettings(settingsContainer);
runSettingsNavigator.MoveToChild(Constants.RunSettingsName, "");
runSettingsNavigator.AppendChild(settingsContainer.ToXml().CreateNavigator());
runSettingsNavigator.MoveToRoot();
return(runSettingsNavigator);
}
public void GetUnsetValuesFrom(RunSettingsContainer other)
{
SolutionSettings.GetUnsetValuesFrom(other.SolutionSettings);
var allOtherProjectSettings = new List <RunSettings>(other.ProjectSettings);
foreach (RunSettings myProjectSettings in ProjectSettings)
{
var otherProjectSettings =
allOtherProjectSettings.FirstOrDefault(s => myProjectSettings.ProjectRegex == s.ProjectRegex);
if (otherProjectSettings != null)
{
allOtherProjectSettings.Remove(otherProjectSettings);
myProjectSettings.GetUnsetValuesFrom(otherProjectSettings);
}
}
foreach (RunSettings remainingProjectSettings in allOtherProjectSettings)
{
ProjectSettings.Add(remainingProjectSettings);
}
}
public void LoadFromXml_UserSettings_AreLoadedCorrectly()
{
var xmlDocument = new XmlDocument();
xmlDocument.Load(TestResources.UserTestSettings);
var navigator = xmlDocument.CreateNavigator();
navigator.MoveToChild(Constants.RunSettingsName, "");
navigator.MoveToChild(GoogleTestConstants.SettingsName, "");
var runSettingsContainer = RunSettingsContainer.LoadFromXml(navigator);
runSettingsContainer.Should().NotBeNull();
runSettingsContainer.SolutionSettings.Should().NotBeNull();
runSettingsContainer.ProjectSettings.Count.Should().Be(1);
runSettingsContainer.SolutionSettings.MaxNrOfThreads.Should().Be(3);
runSettingsContainer.ProjectSettings[0].MaxNrOfThreads.Should().Be(4);
runSettingsContainer.SolutionSettings.TraitsRegexesBefore.Should().Be("User///A,B");
runSettingsContainer.ProjectSettings[0].TraitsRegexesBefore.Should().BeNull();
}
public static RunSettingsContainer LoadFromXml(XmlReader reader)
{
ValidateArg.NotNull(reader, nameof(reader));
RunSettingsContainer runSettingsContainer = null;
if (reader.Read() && reader.Name.Equals(GoogleTestConstants.SettingsName))
{
try
{
var serializer = new XmlSerializer(typeof(SettingsSerializationContainer));
var serializationContainer = serializer.Deserialize(reader) as SettingsSerializationContainer;
runSettingsContainer = new RunSettingsContainer(serializationContainer);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
}
return(runSettingsContainer ?? new RunSettingsContainer());
}
private RunSettingsContainer SetupFinalRunSettingsContainer(
string solutionSolutionWorkingDir, string solutionProject1WorkingDir, string solutionProject2WorkingDir,
string userSolutionWorkingDir, string userProject1WorkingDir, string userProject3WorkingDir)
{
var globalSettings = new RunSettings {
ProjectRegex = null, WorkingDir = GlobalWorkingDir
};
var mockGlobalRunSettings = new Mock <IGlobalRunSettings2>();
mockGlobalRunSettings.Setup(grs => grs.RunSettings).Returns(globalSettings);
var solutionSettingsContainer = SetupSettingsContainer(solutionSolutionWorkingDir, solutionProject1WorkingDir, solutionProject2WorkingDir, null);
var solutionSettingsNavigator = EmbedSettingsIntoRunSettings(solutionSettingsContainer);
var solutionSettingsFile = SerializeSolutionSettings(solutionSettingsNavigator);
var userSettingsContainer = SetupSettingsContainer(userSolutionWorkingDir, userProject1WorkingDir, null, userProject3WorkingDir);
var userSettingsNavigator = EmbedSettingsIntoRunSettings(userSettingsContainer);
IXPathNavigable navigable;
try
{
var serviceUnderTest = new RunSettingsServiceUnderTest(mockGlobalRunSettings.Object, solutionSettingsFile);
navigable = serviceUnderTest.AddRunSettings(userSettingsNavigator,
new Mock <IRunSettingsConfigurationInfo>().Object, new Mock <ILogger>().Object);
}
finally
{
File.Delete(solutionSettingsFile);
}
var navigator = navigable.CreateNavigator();
navigator.MoveToChild(Constants.RunSettingsName, "");
navigator.MoveToChild(GoogleTestConstants.SettingsName, "");
return(RunSettingsContainer.LoadFromXml(navigator));
}
public void AddRunSettings_ComplexConfiguration_IsMergedCorrectly()
{
string global = "GlobalSettings";
string solutionSolution = "solutionSolution";
string solutionProject1 = "solutionProject1";
string solutionProject2 = "solutionProject2";
string userSolution = "userSolution";
string userProject1 = "userProject1";
string userProject3 = "userProject3";
var solutionSettingsContainer = new RunSettingsContainer
{
SolutionSettings = new RunSettings
{
ProjectRegex = null,
AdditionalTestExecutionParam = solutionSolution,
PathExtension = solutionSolution,
TestDiscoveryRegex = solutionSolution,
TraitsRegexesAfter = solutionSolution,
WorkingDir = solutionSolution,
MaxNrOfThreads = 1,
},
ProjectSettings = new List <RunSettings>
{
new RunSettings
{
ProjectRegex = "project1",
AdditionalTestExecutionParam = solutionProject1,
BatchForTestTeardown = solutionProject1,
PathExtension = solutionProject1,
TestDiscoveryRegex = solutionProject1,
NrOfTestRepetitions = 2,
ShuffleTestsSeed = 2
},
new RunSettings
{
ProjectRegex = "project2",
AdditionalTestExecutionParam = solutionProject2,
BatchForTestTeardown = solutionProject2,
TestNameSeparator = solutionProject2,
TraitsRegexesAfter = solutionProject2,
WorkingDir = solutionProject2,
NrOfTestRepetitions = 3,
}
}
};
var userSettingsContainer = new RunSettingsContainer
{
SolutionSettings = new RunSettings
{
ProjectRegex = null,
BatchForTestSetup = userSolution,
BatchForTestTeardown = userSolution,
TestDiscoveryRegex = userSolution,
TraitsRegexesAfter = userSolution,
MaxNrOfThreads = 4,
ShuffleTestsSeed = 4
},
ProjectSettings = new List <RunSettings>
{
new RunSettings
{
ProjectRegex = "project1",
BatchForTestTeardown = userProject1,
PathExtension = userProject1,
TestNameSeparator = userProject1,
WorkingDir = userProject1,
MaxNrOfThreads = 5,
ShuffleTestsSeed = 5
},
new RunSettings
{
ProjectRegex = "project3",
AdditionalTestExecutionParam = userProject3,
BatchForTestTeardown = userProject3,
TestDiscoveryRegex = userProject3,
TestNameSeparator = userProject3,
TraitsRegexesBefore = userProject3,
MaxNrOfThreads = 6,
}
}
};
var globalSettings = new RunSettings
{
ProjectRegex = null,
AdditionalTestExecutionParam = global,
BatchForTestSetup = global,
BatchForTestTeardown = global,
PathExtension = global,
TestDiscoveryRegex = global,
TestNameSeparator = global,
TraitsRegexesAfter = global,
TraitsRegexesBefore = global,
WorkingDir = global,
MaxNrOfThreads = 0,
NrOfTestRepetitions = 0,
ShuffleTestsSeed = 0
};
var mockGlobalRunSettings = new Mock <IGlobalRunSettings>();
mockGlobalRunSettings.Setup(grs => grs.RunSettings).Returns(globalSettings);
var userSettingsNavigator = EmbedSettingsIntoRunSettings(userSettingsContainer);
string solutionSettingsFile = SerializeSettingsContainer(solutionSettingsContainer);
IXPathNavigable navigable;
try
{
var serviceUnderTest = new RunSettingsServiceUnderTest(mockGlobalRunSettings.Object, solutionSettingsFile);
navigable = serviceUnderTest.AddRunSettings(userSettingsNavigator,
new Mock <IRunSettingsConfigurationInfo>().Object, new Mock <ILogger>().Object);
}
finally
{
File.Delete(solutionSettingsFile);
}
var navigator = navigable.CreateNavigator();
navigator.MoveToChild("RunSettings", "");
navigator.MoveToChild(GoogleTestConstants.SettingsName, "");
var resultingContainer = RunSettingsContainer.LoadFromXml(navigator.ReadSubtree());
resultingContainer.Should().NotBeNull();
resultingContainer.SolutionSettings.Should().NotBeNull();
resultingContainer.ProjectSettings.Count.Should().Be(3);
resultingContainer.SolutionSettings.AdditionalTestExecutionParam.Should().Be(solutionSolution);
resultingContainer.SolutionSettings.BatchForTestSetup.Should().Be(userSolution);
resultingContainer.SolutionSettings.BatchForTestTeardown.Should().Be(userSolution);
resultingContainer.SolutionSettings.PathExtension.Should().Be(solutionSolution);
resultingContainer.SolutionSettings.TestDiscoveryRegex.Should().Be(userSolution);
resultingContainer.SolutionSettings.TestNameSeparator.Should().Be(global);
resultingContainer.SolutionSettings.TraitsRegexesAfter.Should().Be(userSolution);
resultingContainer.SolutionSettings.TraitsRegexesBefore.Should().Be(global);
resultingContainer.SolutionSettings.WorkingDir.Should().Be(solutionSolution);
resultingContainer.SolutionSettings.MaxNrOfThreads.Should().Be(4);
resultingContainer.SolutionSettings.MaxNrOfThreads.Should().Be(4);
resultingContainer.SolutionSettings.NrOfTestRepetitions.Should().Be(0);
var projectContainer = resultingContainer.GetSettingsForExecutable("project1");
projectContainer.Should().NotBeNull();
projectContainer.AdditionalTestExecutionParam.Should().Be(solutionProject1);
projectContainer.BatchForTestSetup.Should().Be(userSolution);
projectContainer.BatchForTestTeardown.Should().Be(userProject1);
projectContainer.PathExtension.Should().Be(userProject1);
projectContainer.TestDiscoveryRegex.Should().Be(userSolution);
projectContainer.TestNameSeparator.Should().Be(userProject1);
projectContainer.TraitsRegexesAfter.Should().Be(userSolution);
projectContainer.TraitsRegexesBefore.Should().Be(global);
projectContainer.WorkingDir.Should().Be(userProject1);
projectContainer.MaxNrOfThreads.Should().Be(5);
projectContainer.MaxNrOfThreads.Should().Be(5);
projectContainer.NrOfTestRepetitions.Should().Be(2);
projectContainer = resultingContainer.GetSettingsForExecutable("project2");
projectContainer.Should().NotBeNull();
projectContainer.AdditionalTestExecutionParam.Should().Be(solutionProject2);
projectContainer.BatchForTestSetup.Should().Be(global);
projectContainer.BatchForTestTeardown.Should().Be(solutionProject2);
projectContainer.PathExtension.Should().Be(solutionSolution);
projectContainer.TestDiscoveryRegex.Should().Be(solutionSolution);
projectContainer.TestNameSeparator.Should().Be(solutionProject2);
projectContainer.TraitsRegexesAfter.Should().Be(solutionProject2);
projectContainer.TraitsRegexesBefore.Should().Be(global);
projectContainer.WorkingDir.Should().Be(solutionProject2);
projectContainer.MaxNrOfThreads.Should().Be(1);
projectContainer.MaxNrOfThreads.Should().Be(1);
projectContainer.NrOfTestRepetitions.Should().Be(3);
projectContainer = resultingContainer.GetSettingsForExecutable("project3");
projectContainer.Should().NotBeNull();
projectContainer.AdditionalTestExecutionParam.Should().Be(userProject3);
projectContainer.BatchForTestSetup.Should().Be(userSolution);
projectContainer.BatchForTestTeardown.Should().Be(userProject3);
projectContainer.PathExtension.Should().Be(global);
projectContainer.TestDiscoveryRegex.Should().Be(userProject3);
projectContainer.TestNameSeparator.Should().Be(userProject3);
projectContainer.TraitsRegexesAfter.Should().Be(userSolution);
projectContainer.TraitsRegexesBefore.Should().Be(userProject3);
projectContainer.WorkingDir.Should().Be(global);
projectContainer.MaxNrOfThreads.Should().Be(6);
projectContainer.MaxNrOfThreads.Should().Be(6);
projectContainer.NrOfTestRepetitions.Should().Be(0);
}
public void Load(XmlReader reader)
{
SettingsContainer = RunSettingsContainer.LoadFromXml(reader);
}
public IXPathNavigable AddRunSettings(IXPathNavigable runSettingDocument,
IRunSettingsConfigurationInfo configurationInfo, ILogger logger)
{
XPathNavigator runSettingsNavigator = runSettingDocument.CreateNavigator();
Debug.Assert(runSettingsNavigator != null, "userRunSettingsNavigator == null!");
if (!runSettingsNavigator.MoveToChild(Constants.RunSettingsName, ""))
{
logger.Log(MessageLevel.Warning, Resources.RunSettingsMissingNode);
return(runSettingsNavigator);
}
var settingsContainer = new RunSettingsContainer();
settingsContainer.SolutionSettings = new RunSettings();
try
{
if (CopyToUnsetValues(runSettingsNavigator, settingsContainer))
{
runSettingsNavigator.DeleteSelf(); // this node is to be replaced by the final run settings
}
}
catch (InvalidRunSettingsException)
{
}
string solutionRunSettingsFile = GetSolutionSettingsXmlFile();
try
{
if (File.Exists(solutionRunSettingsFile))
{
var settings = new XmlReaderSettings(); // Don't use an object initializer for FxCop to understand.
settings.XmlResolver = null;
using (var reader = XmlReader.Create(solutionRunSettingsFile, settings))
{
var solutionRunSettingsDocument = new XPathDocument(reader);
XPathNavigator solutionRunSettingsNavigator = solutionRunSettingsDocument.CreateNavigator();
if (solutionRunSettingsNavigator.MoveToChild(Constants.RunSettingsName, ""))
{
CopyToUnsetValues(solutionRunSettingsNavigator, settingsContainer);
}
else
{
logger.Log(MessageLevel.Warning, string.Format(Resources.SolutionFoundButMissingNode, solutionRunSettingsFile, Constants.RunSettingsName));
}
}
}
}
catch (Exception e)
{
logger.Log(MessageLevel.Warning,
string.Format(Resources.CantParseSettings, solutionRunSettingsFile, e));
}
foreach (var projectSettings in settingsContainer.ProjectSettings)
{
projectSettings.GetUnsetValuesFrom(settingsContainer.SolutionSettings);
}
GetValuesFromGlobalSettings(settingsContainer);
runSettingsNavigator.MoveToChild(Constants.RunSettingsName, "");
runSettingsNavigator.AppendChild(settingsContainer.ToXml().CreateNavigator());
runSettingsNavigator.MoveToRoot();
return(runSettingsNavigator);
}
