in src/Microsoft.TestPlatform.ObjectModel/RunSettings/RunConfiguration.cs [562:892]
public static RunConfiguration FromXml(XmlReader reader)
{
ValidateArg.NotNull(reader, nameof(reader));
var runConfiguration = new RunConfiguration();
var empty = reader.IsEmptyElement;
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
// Process the fields in Xml elements
reader.Read();
if (!empty)
{
while (reader.NodeType == XmlNodeType.Element)
{
string elementName = reader.Name;
switch (elementName)
{
case "ResultsDirectory":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string resultsDir = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(resultsDir))
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
resultsDir,
elementName));
}
runConfiguration.ResultsDirectory = resultsDir;
break;
case "CollectSourceInformation":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string collectSourceInformationStr = reader.ReadElementContentAsString();
bool bCollectSourceInformation = true;
if (!bool.TryParse(collectSourceInformationStr, out bCollectSourceInformation))
{
throw new SettingsException(String.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, bCollectSourceInformation, elementName));
}
runConfiguration.ShouldCollectSourceInformation = bCollectSourceInformation;
break;
case "MaxCpuCount":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string cpuCount = reader.ReadElementContentAsString();
if (!int.TryParse(cpuCount, out int count) || count < 0)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
cpuCount,
elementName));
}
runConfiguration.MaxCpuCount = count;
break;
case "BatchSize":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string batchSize = reader.ReadElementContentAsString();
if (!long.TryParse(batchSize, out long size) || size < 0)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
batchSize,
elementName));
}
runConfiguration.BatchSize = size;
break;
case "TestSessionTimeout":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string testSessionTimeout = reader.ReadElementContentAsString();
if (!long.TryParse(testSessionTimeout, out long sessionTimeout) || sessionTimeout < 0)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
testSessionTimeout,
elementName));
}
runConfiguration.TestSessionTimeout = sessionTimeout;
break;
case "DesignMode":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string designModeValueString = reader.ReadElementContentAsString();
if (!bool.TryParse(designModeValueString, out bool designMode))
{
throw new SettingsException(String.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, designModeValueString, elementName));
}
runConfiguration.DesignMode = designMode;
break;
case "InIsolation":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string inIsolationValueString = reader.ReadElementContentAsString();
if (!bool.TryParse(inIsolationValueString, out bool inIsolation))
{
throw new SettingsException(String.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, inIsolationValueString, elementName));
}
runConfiguration.InIsolation = inIsolation;
break;
case "DisableAppDomain":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string disableAppDomainValueString = reader.ReadElementContentAsString();
if (!bool.TryParse(disableAppDomainValueString, out bool disableAppDomainCheck))
{
throw new SettingsException(String.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, disableAppDomainValueString, elementName));
}
runConfiguration.DisableAppDomain = disableAppDomainCheck;
break;
case "DisableParallelization":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string disableParallelizationValueString = reader.ReadElementContentAsString();
if (!bool.TryParse(disableParallelizationValueString, out bool disableParallelizationCheck))
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, disableParallelizationValueString, elementName));
}
runConfiguration.DisableParallelization = disableParallelizationCheck;
break;
case "TargetPlatform":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
Architecture archType;
string value = reader.ReadElementContentAsString();
try
{
archType = (Architecture)Enum.Parse(typeof(Architecture), value, true);
// Ensure that the parsed value is actually in the enum, and that Default or AnyCpu are not provided.
if (!Enum.IsDefined(typeof(Architecture), archType) || Architecture.Default == archType || Architecture.AnyCPU == archType)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
value,
elementName));
}
}
catch (ArgumentException)
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, value, elementName));
}
runConfiguration.TargetPlatform = archType;
break;
case "TargetFrameworkVersion":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
Framework frameworkType;
value = reader.ReadElementContentAsString();
try
{
frameworkType = Framework.FromString(value);
if (frameworkType == null)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
value,
elementName));
}
}
catch (ArgumentException)
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, value, elementName));
}
runConfiguration.TargetFramework = frameworkType;
break;
case "TestAdaptersPaths":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
runConfiguration.TestAdaptersPaths = reader.ReadElementContentAsString();
break;
case "TreatTestAdapterErrorsAsWarnings":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
bool treatTestAdapterErrorsAsWarnings = false;
value = reader.ReadElementContentAsString();
try
{
treatTestAdapterErrorsAsWarnings = bool.Parse(value);
}
catch (ArgumentException)
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, value, elementName));
}
catch (FormatException)
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, value, elementName));
}
runConfiguration.TreatTestAdapterErrorsAsWarnings = treatTestAdapterErrorsAsWarnings;
break;
case "SolutionDirectory":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string solutionDirectory = reader.ReadElementContentAsString();
#if !NETSTANDARD1_0
solutionDirectory = Environment.ExpandEnvironmentVariables(solutionDirectory);
#endif
if (string.IsNullOrEmpty(solutionDirectory)
#if !NETSTANDARD1_0
|| !System.IO.Directory.Exists(solutionDirectory)
#endif
)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error(string.Format(CultureInfo.CurrentCulture, Resources.Resources.SolutionDirectoryNotExists, solutionDirectory));
}
solutionDirectory = null;
}
runConfiguration.SolutionDirectory = solutionDirectory;
break;
case "BinariesRoot":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
runConfiguration.BinariesRoot = reader.ReadElementContentAsString();
break;
case "ExecutionThreadApartmentState":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string executionThreadApartmentState = reader.ReadElementContentAsString();
if (!Enum.TryParse(executionThreadApartmentState, out PlatformApartmentState apartmentState))
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue,
Constants.RunConfigurationSettingsName,
executionThreadApartmentState,
elementName));
}
runConfiguration.ExecutionThreadApartmentState = apartmentState;
break;
case "TargetDevice":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
runConfiguration.TargetDevice = reader.ReadElementContentAsString();
break;
case "TestCaseFilter":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
runConfiguration.TestCaseFilter = reader.ReadElementContentAsString();
break;
case "DotNetHostPath":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
runConfiguration.DotnetHostPath = reader.ReadElementContentAsString();
break;
case "TreatNoTestsAsError":
XmlRunSettingsUtilities.ThrowOnHasAttributes(reader);
string treatNoTestsAsErrorValueString = reader.ReadElementContentAsString();
if (!bool.TryParse(treatNoTestsAsErrorValueString, out bool treatNoTestsAsError))
{
throw new SettingsException(string.Format(CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsIncorrectValue, Constants.RunConfigurationSettingsName, treatNoTestsAsErrorValueString, elementName));
}
runConfiguration.TreatNoTestsAsError = treatNoTestsAsError;
break;
default:
// Ignore a runsettings element that we don't understand. It could occur in the case
// the test runner is of a newer version, but the test host is of an earlier version.
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Warning(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidSettingsXmlElement,
Constants.RunConfigurationSettingsName,
reader.Name));
}
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
return runConfiguration;
}