private static T GetNodeValue <T>(string settingsXml, string nodeName, Func <XmlReader, T> nodeParser)
{
// use XmlReader to avoid loading of the plugins in client code (mainly from VS).
if (!string.IsNullOrWhiteSpace(settingsXml))
{
using (var stringReader = new StringReader(settingsXml))
{
XmlReader reader = XmlReader.Create(stringReader, ReaderSettings);
// read to the fist child
XmlReaderUtilities.ReadToRootNode(reader);
reader.ReadToNextElement();
// Read till we reach nodeName element or reach EOF
while (!string.Equals(reader.Name, nodeName, StringComparison.OrdinalIgnoreCase)
&&
!reader.EOF)
{
reader.SkipToNextElement();
}
if (!reader.EOF)
{
// read nodeName element.
return(nodeParser(reader));
}
}
}
return(default(T));
}
public static DataCollectionRunSettings GetInProcDataCollectionRunSettings(string runSettingsXml)
{
// use XmlReader to avoid loading of the plugins in client code (mainly from VS).
if (!string.IsNullOrWhiteSpace(runSettingsXml))
{
runSettingsXml = runSettingsXml.Trim();
using (StringReader stringReader1 = new StringReader(runSettingsXml))
{
XmlReader reader = XmlReader.Create(stringReader1, ReaderSettings);
// read to the fist child
XmlReaderUtilities.ReadToRootNode(reader);
reader.ReadToNextElement();
// Read till we reach In Proc IDC element or reach EOF
while (!string.Equals(reader.Name, Constants.InProcDataCollectionRunSettingsName)
&&
!reader.EOF)
{
reader.SkipToNextElement();
}
// If reached EOF => IDC element not there
if (reader.EOF)
{
return(null);
}
// Reached here => In Proc IDC element present.
return(DataCollectionRunSettings.FromXml(reader, Constants.InProcDataCollectionRunSettingsName, Constants.InProcDataCollectorsSettingName, Constants.InProcDataCollectorSettingName));
}
}
return(null);
}
/// <summary>
/// Gets the adapter specific settings from the xml.
/// </summary>
/// <param name="runSettingsXml"> The xml with the settings passed from the test platform. </param>
/// <param name="settingName"> The name of the adapter settings to fetch - Its either MSTest or MSTestV2 </param>
/// <returns> The settings if found. Null otherwise. </returns>
internal static MSTestSettings GetSettings(string runSettingsXml, string settingName)
{
if (string.IsNullOrWhiteSpace(runSettingsXml))
{
return(null);
}
using (var stringReader = new StringReader(runSettingsXml))
{
XmlReader reader = XmlReader.Create(stringReader, XmlRunSettingsUtilities.ReaderSettings);
// read to the fist child
XmlReaderUtilities.ReadToRootNode(reader);
reader.ReadToNextElement();
// Read till we reach nodeName element or reach EOF
while (!string.Equals(reader.Name, settingName, StringComparison.OrdinalIgnoreCase)
&&
!reader.EOF)
{
reader.SkipToNextElement();
}
if (!reader.EOF)
{
// read nodeName element.
return(ToSettings(reader.ReadSubtree()));
}
}
return(null);
}
public I3DModel ParseFile(Entity root, string file)
{
if (!File.Exists(file))
{
throw new FileNotFoundException("File not found.", file);
}
if (Path.GetExtension(file) != ".i3d")
{
throw new Exception("File not I3D format.");
}
I3DModel output = new I3DModel {
Path = Path.GetDirectoryName(file)
};
string contents = File.ReadAllText(file);
int start = Environment.TickCount;
using (XmlReader xml = XmlReader.Create(new StringReader(contents)))
{
xml.ReadToFollowing("i3D"); //Skip all the initial shit
output.Name = xml.GetAttribute("name");
root.name = xml.GetAttribute("name");
root.Type = Entity.ShapeType.i3D;
while (xml.ReadToNextElement())
{
switch (xml.LocalName)
{
case "Files":
ParseFile_Files(ref output, xml);
Debug.Log("Parsing Files: " + PrintTime(ref start));
break;
case "Materials":
ParseFile_Materials(ref output, xml);
Debug.Log("Parsing Materials: " + PrintTime(ref start));
break;
case "Shapes":
ParseFile_Shapes(ref output, xml);
Debug.Log("Parsing Shapes: " + PrintTime(ref start));
break;
case "Scene":
ParseFile_SceneShapes(ref output, root, xml);
Debug.Log("Parsing Scenes: " + PrintTime(ref start));
break;
}
}
}
return(output);
}
/// <summary>
/// Skips the current element and moves to the next Element in the document.
/// </summary>
/// <param name="reader">Reader to move to the next element.</param>
public static void SkipToNextElement(this XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
reader.Skip();
if (reader.NodeType != XmlNodeType.Element)
{
reader.ReadToNextElement();
}
}
/// <summary>
/// Convert the parameter xml to TestSettings
/// </summary>
/// <param name="reader">Reader to load the settings from.</param>
/// <returns>An instance of the <see cref="MSTestSettings"/> class</returns>
private static RunConfigurationSettings ToSettings(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Expected format of the xml is: -
//
// <Runsettings>
// <RunConfiguration>
// <CollectSourceInformation>true</CollectSourceInformation>
// </RunConfiguration>
// </Runsettings>
RunConfigurationSettings settings = new RunConfigurationSettings();
// Read the first element in the section
reader.ReadToNextElement();
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.NodeType == XmlNodeType.Element)
{
bool result;
string elementName = reader.Name.ToUpperInvariant();
switch (elementName)
{
case "COLLECTSOURCEINFORMATION":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.CollectSourceInformation = result;
PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
"CollectSourceInformation value Found : {0} ",
result);
}
break;
}
default:
{
reader.SkipToNextElement();
break;
}
}
}
}
return(settings);
}
/// <summary>
/// Reads to the root node of the run settings and verifies that it is a "RunSettings" node.
/// </summary>
/// <param name="path">Path to the file.</param>
/// <param name="reader">XmlReader for the file.</param>
public static void ReadToRootNode(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Read to the root node.
reader.ReadToNextElement();
// Verify that it is a "RunSettings" node.
if (reader.Name != RunSettingsRootNodeName)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resources.Resources.InvalidRunSettingsRootNode));
}
}
private static T GetNodeValue <T>(string settingsXml, string nodeName, Func <XmlReader, T> nodeParser)
{
// use XmlReader to avoid loading of the plugins in client code (mainly from VS).
if (!string.IsNullOrWhiteSpace(settingsXml))
{
try
{
using (var stringReader = new StringReader(settingsXml))
{
XmlReader reader = XmlReader.Create(stringReader, ReaderSettings);
// read to the fist child
XmlReaderUtilities.ReadToRootNode(reader);
reader.ReadToNextElement();
// Read till we reach nodeName element or reach EOF
while (!string.Equals(reader.Name, nodeName, StringComparison.OrdinalIgnoreCase)
&&
!reader.EOF)
{
reader.SkipToNextElement();
}
if (!reader.EOF)
{
// read nodeName element.
return(nodeParser(reader));
}
}
}
catch (XmlException ex)
{
throw new SettingsException(
string.Format(CultureInfo.CurrentCulture, "{0} {1}", Resources.CommonResources.MalformedRunSettingsFile, ex.Message),
ex);
}
}
return(default(T));
}
/// <summary>
/// Reads test run settings from XmlReader
/// </summary>
/// <param name="reader"></param>
private void ReadRunSettings(XmlReader reader)
{
// If settings have already been loaded, throw.
if (this.isSettingsLoaded)
{
throw new InvalidOperationException(CommonResources.RunSettingsAlreadyLoaded);
}
this.isSettingsLoaded = true;
try
{
// Read to the root element.
XmlReaderUtilities.ReadToRootNode(reader);
// Read to the first section.
reader.ReadToNextElement();
// Lookup the settings provider for each of the elements.
var settingsExtensionManager = SettingsProviderExtensionManager.Create();
while (!reader.EOF)
{
this.LoadSection(reader, settingsExtensionManager);
reader.SkipToNextElement();
}
}
catch (SettingsException)
{
throw;
}
catch (Exception e)
{
throw new SettingsException(
string.Format(
CultureInfo.CurrentCulture,
CommonResources.RunSettingsParseError,
e.Message),
e);
}
}
private static ApiErrorException ParseError(XmlReader xmlReader)
{
var error = new ApiErrorException();
xmlReader.ReadToNextElement();
while (!xmlReader.EOF)
{
if (xmlReader.NodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "message":
error.ErrorMessage = xmlReader.ReadElementContentAsString();
break;
case "stack":
error.ErrorStackTrace = xmlReader.ReadElementContentAsString();
break;
case "type":
error.ErrorType = xmlReader.ReadElementContentAsString();
break;
default:
xmlReader.Skip();
break;
}
}
else
{
xmlReader.Read();
}
}
return(error);
}
private static ApiErrorException ParseError(XmlReader xmlReader)
{
var error = new ApiErrorException();
xmlReader.ReadToNextElement();
while (!xmlReader.EOF)
{
if (xmlReader.NodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "message":
error.ErrorMessage = xmlReader.ReadElementContentAsString();
break;
case "stack":
error.ErrorStackTrace = xmlReader.ReadElementContentAsString();
break;
case "type":
error.ErrorType = xmlReader.ReadElementContentAsString();
break;
default:
xmlReader.Skip();
break;
}
}
else
{
xmlReader.Read();
}
}
return error;
}
private void ProcessDisplayFolder(XmlReader rdr, ADOTabularTable table, IADOTabularFolderReference parent)
{
var folderReference = "";
string folderCaption = null;
string objRef = "";
while (!(rdr.NodeType == XmlNodeType.EndElement &&
rdr.LocalName == "DisplayFolder"))
{
if (rdr.NodeType == XmlNodeType.Element &&
rdr.LocalName == "DisplayFolder")
{
while (rdr.MoveToNextAttribute())
{
switch (rdr.LocalName)
{
case "Name":
folderReference = rdr.Value;
break;
case "Caption":
folderCaption = rdr.Value;
break;
}
}
// create folder and add to parent's folders
IADOTabularFolderReference folder = new ADOTabularDisplayFolder(folderCaption, folderReference);
parent.FolderItems.Add(folder);
rdr.ReadToNextElement();
// recurse down to child items
ProcessDisplayFolder(rdr, table, folder);
rdr.Read();
//rdr.ReadToNextElement(); // read the end element
}
// Reset DisplayFolder local variables
folderCaption = null;
folderReference = String.Empty;
if ((rdr.NodeType == XmlNodeType.Element) &&
(rdr.LocalName == "PropertyRef" ||
rdr.LocalName == "HierarchyRef"
))
{
while (rdr.MoveToNextAttribute())
{
switch (rdr.LocalName)
{
case "Name":
objRef = rdr.Value;
break;
}
}
// create reference object
IADOTabularObjectReference reference = new ADOTabularObjectReference("", objRef);
parent.FolderItems.Add(reference);
var column = table.Columns.GetByPropertyRef(objRef);
if (column != null)
{
column.IsInDisplayFolder = true;
}
objRef = "";
rdr.Read();
}
if ((rdr.LocalName != "DisplayFolder" && rdr.LocalName != "PropertyRef" && rdr.LocalName != "DisplaFolders"))
{
if (rdr.NodeType != XmlNodeType.Element && rdr.NodeType != XmlNodeType.EndElement)
{
rdr.ReadToNextElement();
}
//else
// rdr.Read();
}
if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "DisplayFolders")
{
rdr.Read();
break;
}
//rdr.Read();
}
}
/// <summary>
/// Convert the parameter xml to TestSettings
/// </summary>
/// <param name="reader">Reader to load the settings from.</param>
/// <returns>An instance of the <see cref="MSTestSettings"/> class</returns>
private static MSTestSettings ToSettings(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Expected format of the xml is: -
//
// <MSTestV2>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// <MapInconclusiveToFailed>false</MapInconclusiveToFailed>
// <MapNotRunnableToFailed>false</MapNotRunnableToFailed>
// <EnableBaseClassTestMethodsFromOtherAssemblies>false</EnableBaseClassTestMethodsFromOtherAssemblies>
// <TestTimeout>5000</TestTimeout>
// <TreatClassAndAssemblyCleanupWarningsAsErrors>false</TreatClassAndAssemblyCleanupWarningsAsErrors>
// <Parallelize>
// <Workers>4</Workers>
// <Scope>TestClass</Scope>
// </Parallelize>
// </MSTestV2>
//
// (or)
//
// <MSTest>
// <ForcedLegacyMode>true</ForcedLegacyMode>
// <SettingsFile>..\..\Local.testsettings</SettingsFile>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// </MSTest>
MSTestSettings settings = new MSTestSettings();
// Read the first element in the section which is either "MSTest"/"MSTestV2"
reader.ReadToNextElement();
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.NodeType == XmlNodeType.Element)
{
bool result;
string elementName = reader.Name.ToUpperInvariant();
switch (elementName)
{
case "CAPTURETRACEOUTPUT":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.CaptureDebugTraces = result;
}
break;
}
case "ENABLEBASECLASSTESTMETHODSFROMOTHERASSEMBLIES":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.EnableBaseClassTestMethodsFromOtherAssemblies = result;
}
break;
}
case "CLASSCLEANUPLIFECYCLE":
{
var value = reader.ReadInnerXml();
if (TryParseEnum(value, out ClassCleanupBehavior lifecycle))
{
settings.ClassCleanupLifecycle = lifecycle;
}
else
{
throw new AdapterSettingsException(
string.Format(
CultureInfo.CurrentCulture,
Resource.InvalidClassCleanupLifecycleValue,
value,
string.Join(", ", Enum.GetNames(typeof(ClassCleanupBehavior)))));
}
break;
}
case "FORCEDLEGACYMODE":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.ForcedLegacyMode = result;
}
break;
}
case "MAPINCONCLUSIVETOFAILED":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.MapInconclusiveToFailed = result;
}
break;
}
case "MAPNOTRUNNABLETOFAILED":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.MapNotRunnableToFailed = result;
}
break;
}
case "SETTINGSFILE":
{
string fileName = reader.ReadInnerXml();
if (!string.IsNullOrEmpty(fileName))
{
settings.TestSettingsFile = fileName;
}
break;
}
case "PARALLELIZE":
{
SetParallelSettings(reader.ReadSubtree(), settings);
reader.SkipToNextElement();
break;
}
case "TESTTIMEOUT":
{
if (int.TryParse(reader.ReadInnerXml(), out int testTimeout) && testTimeout > 0)
{
settings.TestTimeout = testTimeout;
}
break;
}
case "TREATCLASSANDASSEMBLYCLEANUPWARNINGSASERRORS":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.TreatClassAndAssemblyCleanupWarningsAsErrors = result;
}
break;
}
default:
{
PlatformServiceProvider.Instance.SettingsProvider.Load(reader.ReadSubtree());
reader.SkipToNextElement();
break;
}
}
}
}
return(settings);
}
/// <summary>
/// Convert the parameter xml to TestSettings
/// </summary>
/// <param name="reader">Reader to load the settings from.</param>
/// <returns>An instance of the <see cref="MSTestSettings"/> class</returns>
private static MSTestSettings ToSettings(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Expected format of the xml is: -
//
// <MSTestV2>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// <MapInconclusiveToFailed>false</MapInconclusiveToFailed>
// <EnableBaseClassTestMethodsFromOtherAssemblies>false</EnableBaseClassTestMethodsFromOtherAssemblies>
// <Parallelize>
// <Workers>4</Workers>
// <Scope>TestClass</Scope>
// </Parallelize>
// </MSTestV2>
//
// (or)
//
// <MSTest>
// <ForcedLegacyMode>true</ForcedLegacyMode>
// <SettingsFile>..\..\Local.testsettings</SettingsFile>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// </MSTest>
MSTestSettings settings = new MSTestSettings();
// Read the first element in the section which is either "MSTest"/"MSTestV2"
reader.ReadToNextElement();
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.NodeType == XmlNodeType.Element)
{
bool result;
string elementName = reader.Name.ToUpperInvariant();
switch (elementName)
{
case "CAPTURETRACEOUTPUT":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.CaptureDebugTraces = result;
}
break;
}
case "ENABLEBASECLASSTESTMETHODSFROMOTHERASSEMBLIES":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.EnableBaseClassTestMethodsFromOtherAssemblies = result;
}
break;
}
case "FORCEDLEGACYMODE":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.ForcedLegacyMode = result;
}
break;
}
case "MAPINCONCLUSIVETOFAILED":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.MapInconclusiveToFailed = result;
}
break;
}
case "SETTINGSFILE":
{
string fileName = reader.ReadInnerXml();
if (!string.IsNullOrEmpty(fileName))
{
settings.TestSettingsFile = fileName;
}
break;
}
case "PARALLELIZE":
{
SetParallelSettings(reader.ReadSubtree(), settings);
reader.SkipToNextElement();
break;
}
default:
{
PlatformServiceProvider.Instance.SettingsProvider.Load(reader.ReadSubtree());
reader.SkipToNextElement();
break;
}
}
}
}
return(settings);
}
/// <summary>
/// Convert the parameter xml to TestSettings
/// </summary>
/// <param name="reader">Reader to load the settings from.</param>
/// <returns>An instance of the <see cref="MSTestSettings"/> class</returns>
private static MSTestSettings ToSettings(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Expected format of the xml is: -
//
// <MSTestV2>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// <MapInconclusiveToFailed>false</MapInconclusiveToFailed>
// </MSTestV2>
//
// (or)
//
// <MSTest>
// <ForcedLegacyMode>true</ForcedLegacyMode>
// <SettingsFile>..\..\Local.testsettings</SettingsFile>
// <CaptureTraceOutput>true</CaptureTraceOutput>
// </MSTest>
MSTestSettings settings = new MSTestSettings();
// Read the first element in the section which is either "MSTest"/"MSTestV2"
reader.ReadToNextElement();
if (!reader.IsEmptyElement)
{
reader.Read();
while (reader.NodeType == XmlNodeType.Element)
{
bool result;
string elementName = reader.Name.ToUpperInvariant();
switch (elementName)
{
case "MAPINCONCLUSIVETOFAILED":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.MapInconclusiveToFailed = result;
}
break;
}
case "FORCEDLEGACYMODE":
{
if (bool.TryParse(reader.ReadInnerXml(), out result))
{
settings.ForcedLegacyMode = result;
}
break;
}
case "SETTINGSFILE":
{
string fileName = reader.ReadInnerXml();
if (!string.IsNullOrEmpty(fileName))
{
settings.TestSettingsFile = fileName;
}
break;
}
default:
{
PlatformServiceProvider.Instance.SettingsProvider.Load(reader.ReadSubtree());
reader.SkipToNextElement();
break;
}
}
}
}
return(settings);
}
