< Summary - SonghayCore

Information

Class:	Songhay.Xml.XmlUtility
Assembly:	SonghayCore
File(s):	File 1: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.CombineNavigableDocuments.cs File 2: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInstance.cs File 3: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessage.cs File 4: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessage.XmlTextWriter.cs File 5: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessageDocument.cs File 6: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNamespaceManager.cs File 7: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNavigableDocument.cs File 8: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNavigableNode.cs File 9: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNodeValue.cs File 10: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetText.cs File 11: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetXslResult.cs File 12: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetXslString.cs File 13: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.InputAs.cs File 14: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.IsNodeValue.cs File 15: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.IsXml.cs File 16: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.LoadXslTransform.cs File 17: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.OutputAs.cs File 18: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.StripNamespaces.cs File 19: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.StripNamespaces.IXPathNavigable.cs File 20: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.ValidateNavigableNode.cs File 21: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.Write.cs File 22: /home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.XmlDecode.cs

Line coverage

Covered lines:	48
Uncovered lines:	450
Coverable lines:	498
Total lines:	1531
Line coverage:	9.6%

Branch coverage

Covered branches:	11
Total branches:	192
Branch coverage:	5.7%

Method coverage

Method coverage is only available for sponsors.

Upgrade to PRO version

Metrics

Method	Branch coverage	Cyclomatic complexity	Line coverage
File 1: CombineNavigableDocuments(...)	100%	1	0%
File 1: CombineNavigableDocuments(...)	0%	16	0%
File 2: GetInstance(...)	100%	1	0%
File 2: GetInstanceRaw(...)	100%	1	0%
File 3: GetInternalMessage(...)	100%	1	0%
File 3: GetInternalMessage(...)	100%	1	0%
File 3: GetInternalMessage(...)	100%	1	0%
File 3: GetInternalMessage(...)	0%	6	0%
File 4: GetInternalMessage(...)	100%	1	0%
File 4: GetInternalMessage(...)	100%	1	0%
File 4: GetInternalMessage(...)	100%	1	0%
File 4: GetInternalMessage(...)	0%	12	0%
File 5: GetInternalMessageDocument(...)	100%	1	0%
File 5: GetInternalMessageDocument(...)	100%	1	0%
File 6: GetNamespaceManager(...)	0%	8	0%
File 7: GetNavigableDocument(...)	0%	2	0%
File 7: GetNavigableDocument(...)	0%	4	0%
File 7: GetNavigableDocument(...)	75%	4	100%
File 8: GetNavigableNode(...)	0%	6	0%
File 8: GetNavigableNode(...)	0%	6	0%
File 8: GetNavigableNodes(...)	0%	6	0%
File 8: GetNavigableNodes(...)	0%	6	0%
File 9: GetNodeValue(...)	100%	1	0%
File 9: GetNodeValue(...)	100%	1	0%
File 9: GetNodeValue(...)	0%	6	0%
File 9: GetNodeValueAndParse(...)	100%	1	0%
File 9: GetNodeValueAndParse(...)	0%	42	0%
File 10: GetText(...)	0%	4	0%
File 11: GetXslResult(...)	100%	1	0%
File 11: GetXslResult(...)	100%	1	0%
File 12: GetXslString(...)	100%	1	0%
File 12: GetXslString(...)	100%	1	0%
File 12: GetXslString(...)	0%	2	0%
File 13: InputAs(...)	0%	8	0%
File 14: IsNodeValue(...)	100%	1	0%
File 14: IsNodeValue(...)	100%	1	0%
File 14: IsNodeValue(...)	100%	1	0%
File 14: IsNodeValue(...)	100%	1	0%
File 14: IsNoNodeValue(...)	100%	1	0%
File 14: IsYesNodeValue(...)	100%	1	0%
File 15: IsXml(...)	0%	4	0%
File 16: LoadXslTransform(...)	100%	1	0%
File 16: LoadXslTransform(...)	100%	1	0%
File 16: LoadXslTransform(...)	0%	2	0%
File 16: LoadXslTransformForMemoryInput(...)	100%	1	0%
File 16: LoadXslTransformForMemoryInput(...)	100%	1	0%
File 16: LoadXslTransformForMemoryInput(...)	0%	2	0%
File 16: GetXsltArgumentList(...)	0%	2	0%
File 17: OutputAs(...)	0%	2	0%
File 17: OutputAs(...)	0%	10	0%
File 18: StripNamespaces(...)	100%	1	0%
File 18: StripNamespaces(...)	0%	10	0%
File 19: StripNamespaces(...)	100%	1	0%
File 19: StripNamespaces(...)	0%	4	0%
File 20: GetXmlSchema(...)	0%	2	0%
File 20: LoadXmlSchema(...)	0%	2	0%
File 20: ValidateNavigableNode(...)	0%	2	0%
File 21: Write(...)	100%	1	100%
File 21: WriteReader(...)	0%	4	0%
File 21: WriteXslTransform(...)	100%	1	0%
File 21: WriteXslTransform(...)	100%	1	0%
File 22: .cctor()	100%	1	100%
File 22: XmlEncode(...)	100%	4	100%
File 22: XmlDecode(...)	100%	4	100%

File(s)

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.CombineNavigableDocuments.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Combines two <see cref="IXPathNavigable"/> documents.`
	`7`	`/// </summary>`
	`8`	`/// <param name="parentDocument">The <see cref="IXPathNavigable"/> “hosting” document.</param>`
	`9`	`/// <param name="childDocument">The <see cref="IXPathNavigable"/> child document.</param>`
	`10`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`11`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`12`	`public static XPathDocument? CombineNavigableDocuments(IXPathNavigable? parentDocument,`
0	`13`	`IXPathNavigable? childDocument) => CombineNavigableDocuments(parentDocument, childDocument, null);`
	`14`
	`15`	`/// <summary>`
	`16`	`/// Combines two <see cref="IXPathNavigable"/> documents.`
	`17`	`/// </summary>`
	`18`	`/// <param name="parentDocument">The <see cref="IXPathNavigable"/> “hosting” document.</param>`
	`19`	`/// <param name="childDocument">The <see cref="IXPathNavigable"/> child document.</param>`
	`20`	`/// <param name="nodeQuery">The XPath query to the child document location in the “hosting” document. </param>`
	`21`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`22`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`23`	`public static XPathDocument? CombineNavigableDocuments(IXPathNavigable? parentDocument,`
	`24`	`IXPathNavigable? childDocument, string? nodeQuery)`
0	`25`	`{`
0	`26`	`if (parentDocument == null \|\| childDocument == null) return null;`
	`27`
0	`28`	`var dom = new XmlDocument();`
0	`29`	`XPathNavigator? domNavigator = dom.CreateNavigator();`
0	`30`	`if (domNavigator == null) return null;`
	`31`
0	`32`	`var navigator = parentDocument.CreateNavigator();`
0	`33`	`if (navigator == null) return null;`
	`34`
0	`35`	`dom.LoadXml(navigator.OuterXml);`
	`36`
0	`37`	`if (string.IsNullOrWhiteSpace(nodeQuery))`
0	`38`	`{`
0	`39`	`domNavigator.MoveToFirstChild();`
	`40`
0	`41`	`XPathNavigator? childNavigator = childDocument.CreateNavigator();`
0	`42`	`if (childNavigator != null) domNavigator.AppendChild(childNavigator.OuterXml);`
0	`43`	`domNavigator.MoveToRoot();`
0	`44`	`}`
	`45`	`else`
0	`46`	`{`
0	`47`	`XPathNodeIterator nodes = domNavigator.Select(nodeQuery);`
0	`48`	`foreach (XPathNavigator n in nodes)`
0	`49`	`{`
0	`50`	`XPathNavigator? childNavigator = childDocument.CreateNavigator();`
0	`51`	`if (childNavigator != null) n.AppendChild(childNavigator.OuterXml);`
0	`52`	`break;`
	`53`	`}`
0	`54`	`}`
	`55`
0	`56`	`using var reader = new StringReader(domNavigator.OuterXml);`
0	`57`	`var combinedDocument = new XPathDocument(reader);`
	`58`
0	`59`	`return combinedDocument;`
0	`60`	`}`
	`61`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInstance.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Deserializes based on the specified XML file.`
	`7`	`/// </summary>`
	`8`	`/// <typeparam name="T">`
	`9`	`/// The specified type to deserialize.`
	`10`	`/// </typeparam>`
	`11`	`/// <param name="xmlPath">The XML file path.</param>`
	`12`	`public static T? GetInstance<T>(string? xmlPath) where T : class`
0	`13`	`{`
0	`14`	`var serializer = new XmlSerializer(typeof(T));`
	`15`
0	`16`	`using XmlReader reader = XmlReader.Create(xmlPath!);`
0	`17`	`T? instance = serializer.Deserialize(reader) as T;`
	`18`
0	`19`	`return instance;`
0	`20`	`}`
	`21`
	`22`	`/// <summary>`
	`23`	`/// Deserializes based on the specified raw XML.`
	`24`	`/// </summary>`
	`25`	`/// <typeparam name="T">`
	`26`	`/// The specified type to deserialize.`
	`27`	`/// </typeparam>`
	`28`	`/// <param name="xmlFragment">The raw XML.</param>`
	`29`	`public static T? GetInstanceRaw<T>(string? xmlFragment) where T : class`
0	`30`	`{`
0	`31`	`xmlFragment.ThrowWhenNullOrWhiteSpace();`
	`32`
0	`33`	`var serializer = new XmlSerializer(typeof(T));`
	`34`
0	`35`	`using var reader = new StringReader(xmlFragment);`
0	`36`	`var instance = serializer.Deserialize(reader) as T;`
	`37`
0	`38`	`return instance;`
0	`39`	`}`
	`40`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessage.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an XML <see cref="string"/>`
	`7`	`/// based on the specified header and lines.`
	`8`	`/// </summary>`
	`9`	`/// <param name="messageHeader">Message header.</param>`
	`10`	`public static string GetInternalMessage(string messageHeader) =>`
0	`11`	`GetInternalMessage(messageHeader, string.Empty, null);`
	`12`
	`13`	`/// <summary>`
	`14`	`/// Returns an XML <see cref="string"/>`
	`15`	`/// based on the specified header and lines.`
	`16`	`/// </summary>`
	`17`	`/// <param name="messageHeader">Message header.</param>`
	`18`	`/// <param name="messageLines">Message lines.</param>`
	`19`	`public static string GetInternalMessage(string messageHeader, string[] messageLines) =>`
0	`20`	`GetInternalMessage(messageHeader, string.Empty, messageLines);`
	`21`
	`22`	`/// <summary>`
	`23`	`/// Returns an XML <see cref="string"/>`
	`24`	`/// based on the specified header and lines.`
	`25`	`/// </summary>`
	`26`	`/// <param name="messageHeader">Message header.</param>`
	`27`	`/// <param name="messageLines">Message lines.</param>`
	`28`	`public static string GetInternalMessage(string messageHeader, ReadOnlyCollection<string>? messageLines) =>`
0	`29`	`GetInternalMessage(messageHeader, string.Empty, messageLines);`
	`30`
	`31`	`/// <summary>`
	`32`	`/// Returns an XML <see cref="string"/>`
	`33`	`/// based on the specified header and lines.`
	`34`	`/// </summary>`
	`35`	`/// <param name="messageHeader">Message header.</param>`
	`36`	`/// <param name="messageCode">Message code for errors, exceptions or faults.</param>`
	`37`	`/// <param name="messageLines">Message lines.</param>`
	`38`	`public static string GetInternalMessage(string? messageHeader, string? messageCode,`
	`39`	`IEnumerable<string>? messageLines)`
0	`40`	`{`
0	`41`	`var sb = new StringBuilder();`
0	`42`	`sb.AppendLine("<InternalMessage>");`
	`43`
0	`44`	`sb.AppendLine(CultureInfo.InvariantCulture, $"<Header>{messageHeader}</Header>");`
0	`45`	`if (!string.IsNullOrWhiteSpace(messageCode))`
0	`46`	`sb.AppendLine(CultureInfo.InvariantCulture, $"<Code>{messageCode}</Code>");`
	`47`
0	`48`	`if (messageLines is not null)`
0	`49`	`{`
0	`50`	`foreach (string line in messageLines)`
0	`51`	`{`
0	`52`	`sb.AppendLine(CultureInfo.InvariantCulture, $"<Line>{line}</Line>");`
0	`53`	`}`
0	`54`	`}`
	`55`
0	`56`	`sb.AppendLine("</InternalMessage>");`
	`57`
0	`58`	`return sb.ToString();`
0	`59`	`}`
	`60`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessage.XmlTextWriter.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Gets the conventional, XML <c><InternalMessage></c>.`
	`7`	`/// </summary>`
	`8`	`/// <param name="messageHeader">Message header.</param>`
	`9`	`/// <param name="messageLines">Message lines.</param>`
	`10`	`/// <param name="xmlDataWriter">The <see cref="XmlWriter"/>.</param>`
	`11`	`public static void GetInternalMessage(string? messageHeader, string[]? messageLines, XmlWriter? xmlDataWriter) =>`
0	`12`	`GetInternalMessage(messageHeader, string.Empty, messageLines, xmlDataWriter, false);`
	`13`
	`14`	`/// <summary>`
	`15`	`/// Gets the conventional, XML <c><InternalMessage></c>.`
	`16`	`/// </summary>`
	`17`	`/// <param name="messageHeader">Message header.</param>`
	`18`	`/// <param name="messageCode">Message code for errors, exceptions or faults.</param>`
	`19`	`/// <param name="messageLines">Message lines.</param>`
	`20`	`/// <param name="xmlDataWriter">The <see cref="XmlTextWriter"/>.</param>`
	`21`	`public static void GetInternalMessage(string? messageHeader, string? messageCode, string[]? messageLines,`
0	`22`	`XmlWriter xmlDataWriter) => GetInternalMessage(messageHeader, messageCode, messageLines, xmlDataWriter, false);`
	`23`
	`24`	`/// <summary>`
	`25`	`/// Gets the conventional, XML <c><InternalMessage></c>.`
	`26`	`/// </summary>`
	`27`	`/// <param name="messageHeader">Message header.</param>`
	`28`	`/// <param name="messageLines">Message lines.</param>`
	`29`	`/// <param name="xmlDataWriter">The <see cref="XmlWriter"/>.</param>`
	`30`	`/// <param name="isFragment">When <c>false</c> a new document is started.</param>`
	`31`	`public static void GetInternalMessage(string? messageHeader, string[]? messageLines, XmlWriter? xmlDataWriter,`
0	`32`	`bool isFragment) => GetInternalMessage(messageHeader, string.Empty, messageLines, xmlDataWriter, isFragment);`
	`33`
	`34`	`/// <summary>`
	`35`	`/// Gets the conventional, XML <c><InternalMessage></c>.`
	`36`	`/// </summary>`
	`37`	`/// <param name="messageHeader">Message header.</param>`
	`38`	`/// <param name="messageCode">Message code for errors, exceptions or faults.</param>`
	`39`	`/// <param name="messageLines">Message lines.</param>`
	`40`	`/// <param name="xmlDataWriter">The <see cref="XmlWriter"/>.</param>`
	`41`	`/// <param name="isFragment">When <c>false</c> a new document is started.</param>`
	`42`	`public static void GetInternalMessage(string? messageHeader, string? messageCode, string[]? messageLines,`
	`43`	`XmlWriter? xmlDataWriter, bool isFragment)`
0	`44`	`{`
0	`45`	`ArgumentNullException.ThrowIfNull(xmlDataWriter);`
	`46`
0	`47`	`if (!isFragment) xmlDataWriter.WriteStartDocument();`
0	`48`	`xmlDataWriter.WriteStartElement("InternalMessage");`
	`49`
0	`50`	`xmlDataWriter.WriteElementString("Header", messageHeader);`
0	`51`	`if (!string.IsNullOrWhiteSpace(messageCode)) xmlDataWriter.WriteElementString("Code", messageCode);`
	`52`
0	`53`	`if (messageLines is {Length: > 0})`
0	`54`	`{`
0	`55`	`foreach (string line in messageLines)`
0	`56`	`{`
0	`57`	`xmlDataWriter.WriteElementString("Line", line);`
0	`58`	`}`
0	`59`	`}`
	`60`
0	`61`	`xmlDataWriter.WriteFullEndElement();`
0	`62`	`if (!isFragment) xmlDataWriter.WriteEndDocument();`
0	`63`	`}`
	`64`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetInternalMessageDocument.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an <see cref="XPathDocument"/>`
	`7`	`/// based on the specified header and lines.`
	`8`	`/// </summary>`
	`9`	`/// <param name="messageHeader">Message header.</param>`
	`10`	`/// <param name="messageLines">Message lines.</param>`
	`11`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`12`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`13`	`public static XPathDocument? GetInternalMessageDocument(string? messageHeader, string[]? messageLines) =>`
0	`14`	`GetInternalMessageDocument(messageHeader, string.Empty, messageLines);`
	`15`
	`16`
	`17`	`/// <summary>`
	`18`	`/// Returns an <see cref="XPathDocument"/>`
	`19`	`/// based on the specified header and lines.`
	`20`	`/// </summary>`
	`21`	`/// <param name="messageHeader">Message header.</param>`
	`22`	`/// <param name="messageCode">Message code for errors, exceptions or faults</param>`
	`23`	`/// <param name="messageLines">Message lines.</param>`
	`24`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`25`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`26`	`public static XPathDocument? GetInternalMessageDocument(string? messageHeader, string? messageCode,`
	`27`	`string[]? messageLines)`
0	`28`	`{`
0	`29`	`string s = GetInternalMessage(messageHeader, messageCode, messageLines);`
	`30`
0	`31`	`return GetNavigableDocument(s);`
0	`32`	`}`
	`33`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNamespaceManager.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns a <see cref="XmlNamespaceManager"/>`
	`7`	`/// with respect to the document element of the specified`
	`8`	`/// <see cref="IXPathNavigable"/> document.`
	`9`	`/// </summary>`
	`10`	`/// <param name="navigable">`
	`11`	`/// The <see cref="IXPathNavigable"/> document.`
	`12`	`/// </param>`
	`13`	`public static XmlNamespaceManager? GetNamespaceManager(IXPathNavigable? navigable)`
0	`14`	`{`
0	`15`	`XmlNamespaceManager? nsman = null;`
0	`16`	`if (navigable == null) return nsman;`
	`17`
0	`18`	`XPathNavigator? navigator = navigable.CreateNavigator();`
0	`19`	`XPathExpression xpath = XPathExpression.Compile("//*[1]");`
0	`20`	`var root = navigator?.SelectSingleNode(xpath);`
	`21`
0	`22`	`if (root == null) throw new NullReferenceException("The expected XPath Navigator is not here.");`
	`23`
0	`24`	`nsman = new XmlNamespaceManager(root.NameTable);`
	`25`
0	`26`	`IDictionary<string, string> names = root.GetNamespacesInScope(XmlNamespaceScope.Local);`
0	`27`	`foreach (KeyValuePair<string, string> kv in names)`
0	`28`	`{`
0	`29`	`nsman.AddNamespace(kv.Key, kv.Value);`
0	`30`	`}`
	`31`
0	`32`	`return nsman;`
0	`33`	`}`
	`34`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNavigableDocument.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an <see cref="XPathDocument"/>`
	`7`	`/// based on the specified <see cref="string"/>.`
	`8`	`/// </summary>`
	`9`	`/// <param name="xmlFragment">`
	`10`	`/// A well-formed XML <see cref="string"/>.`
	`11`	`/// </param>`
	`12`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`13`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`14`	`public static XPathDocument? GetNavigableDocument(string? xmlFragment)`
0	`15`	`{`
0	`16`	`if (string.IsNullOrWhiteSpace(xmlFragment)) return null;`
	`17`
0	`18`	`using StringReader reader = new StringReader(xmlFragment);`
0	`19`	`var d = new XPathDocument(reader);`
	`20`
0	`21`	`return d;`
0	`22`	`}`
	`23`
	`24`	`/// <summary>`
	`25`	`/// Returns an <see cref="XPathDocument"/>`
	`26`	`/// based on the specified <see cref="XmlNode"/>.`
	`27`	`/// </summary>`
	`28`	`/// <param name="navigable">`
	`29`	`/// The source <see cref="IXPathNavigable"/> document.`
	`30`	`/// </param>`
	`31`	`/// <remarks>`
	`32`	`/// Use this member to convert <see cref="XmlDocument"/> documents.`
	`33`	`/// </remarks>`
	`34`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`35`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`36`	`public static XPathDocument? GetNavigableDocument(IXPathNavigable? navigable)`
0	`37`	`{`
0	`38`	`var navigator = navigable?.CreateNavigator();`
0	`39`	`if (navigator == null) return null;`
	`40`
0	`41`	`using StringReader reader = new StringReader(navigator.OuterXml);`
0	`42`	`var d = new XPathDocument(reader);`
	`43`
0	`44`	`return d;`
0	`45`	`}`
	`46`
	`47`	`/// <summary>`
	`48`	`/// Returns an <see cref="XPathDocument"/>`
	`49`	`/// based on the specified <see cref="Stream"/>.`
	`50`	`/// </summary>`
	`51`	`/// <param name="stream">The stream.</param>`
	`52`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`53`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`54`	`public static XPathDocument? GetNavigableDocument(Stream? stream)`
1	`55`	`{`
1	`56`	`if (stream == null) return null;`
2	`57`	`if (stream.Position != 0) stream.Position = 0;`
	`58`
1	`59`	`XPathDocument d = new XPathDocument(stream);`
	`60`
1	`61`	`return d;`
1	`62`	`}`
	`63`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNavigableNode.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an <see cref="XPathNavigator"/>`
	`7`	`/// based on the nodeQuery Expression toward the source document.`
	`8`	`/// </summary>`
	`9`	`/// <param name="navigable">`
	`10`	`/// The source <see cref="IXPathNavigable"/> document.`
	`11`	`/// </param>`
	`12`	`/// <param name="nodeQuery">`
	`13`	`/// The value to be compiled`
	`14`	`/// into an <see cref="XPathExpression"/>.`
	`15`	`/// </param>`
	`16`	`public static XPathNavigator? GetNavigableNode(IXPathNavigable? navigable, string? nodeQuery)`
0	`17`	`{`
0	`18`	`if (navigable == null) return null;`
0	`19`	`if (string.IsNullOrWhiteSpace(nodeQuery)) return null;`
	`20`
0	`21`	`XPathNavigator? navigator = navigable.CreateNavigator();`
0	`22`	`XPathExpression xpath = XPathExpression.Compile(nodeQuery);`
0	`23`	`var node = navigator?.SelectSingleNode(xpath);`
	`24`
0	`25`	`return node;`
0	`26`	`}`
	`27`
	`28`	`/// <summary>`
	`29`	`/// Returns an <see cref="XPathNavigator"/>`
	`30`	`/// based on the nodeQuery Expression toward the source document.`
	`31`	`/// </summary>`
	`32`	`/// <param name="navigable">`
	`33`	`/// The source <see cref="IXPathNavigable"/> document.`
	`34`	`/// </param>`
	`35`	`/// <param name="nodeQuery">`
	`36`	`/// The value to be compiled`
	`37`	`/// into an <see cref="XPathExpression"/>.`
	`38`	`/// </param>`
	`39`	`/// <param name="nsMan">`
	`40`	`/// The <see cref="XmlNamespaceManager"/>`
	`41`	`/// to use to resolve prefixes.`
	`42`	`/// </param>`
	`43`	`public static XPathNavigator? GetNavigableNode(IXPathNavigable? navigable, string? nodeQuery,`
	`44`	`XmlNamespaceManager? nsMan)`
0	`45`	`{`
0	`46`	`if (navigable == null) return null;`
0	`47`	`if (string.IsNullOrWhiteSpace(nodeQuery)) return null;`
	`48`
0	`49`	`XPathNavigator? navigator = navigable.CreateNavigator();`
0	`50`	`XPathExpression xpath = XPathExpression.Compile(nodeQuery, nsMan);`
0	`51`	`var node = navigator?.SelectSingleNode(xpath);`
	`52`
0	`53`	`return node;`
0	`54`	`}`
	`55`
	`56`	`/// <summary>`
	`57`	`/// Returns an <see cref="XPathNodeIterator"/>`
	`58`	`/// based on the nodeQuery Expression toward the source document.`
	`59`	`/// </summary>`
	`60`	`/// <param name="navigable">`
	`61`	`/// The source <see cref="IXPathNavigable"/> document.`
	`62`	`/// </param>`
	`63`	`/// <param name="nodeQuery">`
	`64`	`/// The value to be compiled`
	`65`	`/// into an <see cref="XPathExpression"/>.`
	`66`	`/// </param>`
	`67`	`public static XPathNodeIterator? GetNavigableNodes(IXPathNavigable? navigable, string? nodeQuery)`
0	`68`	`{`
0	`69`	`if (navigable == null) return null;`
0	`70`	`if (string.IsNullOrWhiteSpace(nodeQuery)) return null;`
	`71`
0	`72`	`XPathNavigator? navigator = navigable.CreateNavigator();`
	`73`
0	`74`	`XPathExpression xpath = XPathExpression.Compile(nodeQuery);`
0	`75`	`var nodes = navigator?.Select(xpath);`
	`76`
0	`77`	`return nodes;`
0	`78`	`}`
	`79`
	`80`	`/// <summary>`
	`81`	`/// Returns an <see cref="XPathNodeIterator"/>`
	`82`	`/// based on the nodeQuery Expression toward the source document.`
	`83`	`/// </summary>`
	`84`	`/// <param name="navigable">`
	`85`	`/// The source <see cref="IXPathNavigable"/> document.`
	`86`	`/// </param>`
	`87`	`/// <param name="nodeQuery">`
	`88`	`/// The value to be compiled`
	`89`	`/// into an <see cref="XPathExpression"/>.`
	`90`	`/// </param>`
	`91`	`/// <param name="nsMan">`
	`92`	`/// The <see cref="XmlNamespaceManager"/>`
	`93`	`/// to use to resolve prefixes.`
	`94`	`/// </param>`
	`95`	`public static XPathNodeIterator? GetNavigableNodes(IXPathNavigable? navigable, string? nodeQuery,`
	`96`	`XmlNamespaceManager nsMan)`
0	`97`	`{`
0	`98`	`if (navigable == null) return null;`
0	`99`	`if (string.IsNullOrWhiteSpace(nodeQuery)) return null;`
	`100`
0	`101`	`XPathNavigator? navigator = navigable.CreateNavigator();`
	`102`
0	`103`	`XPathExpression xpath = XPathExpression.Compile(nodeQuery, nsMan);`
0	`104`	`var nodes = navigator?.Select(xpath);`
	`105`
0	`106`	`return nodes;`
0	`107`	`}`
	`108`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetNodeValue.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an object for parsing`
	`7`	`/// and adding to a list of parameters for data access.`
	`8`	`/// </summary>`
	`9`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`10`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`11`	`/// <param name="throwException">When <c>true</c>, throw an exception for null nodes.</param>`
	`12`	`public static object? GetNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException) =>`
0	`13`	`GetNodeValue(node, nodeQuery, throwException, null);`
	`14`
	`15`	`/// <summary>`
	`16`	`/// Returns an object for parsing`
	`17`	`/// and adding to a list of parameters for data access.`
	`18`	`/// </summary>`
	`19`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`20`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`21`	`/// <param name="throwException">When <c>true</c>, throw an exception for null nodes.</param>`
	`22`	`/// <param name="defaultValue">Return the specified default value for “zero-length” text nodes.</param>`
	`23`	`public static object? GetNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException,`
0	`24`	`object? defaultValue) => GetNodeValue(node, nodeQuery, throwException, defaultValue, null);`
	`25`
	`26`	`/// <summary>`
	`27`	`/// Returns an object for parsing`
	`28`	`/// and adding to a list of parameters for data access.`
	`29`	`/// </summary>`
	`30`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`31`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`32`	`/// <param name="throwException">When <c>true</c>, throw an exception for null nodes.</param>`
	`33`	`/// <param name="defaultValue">Return the specified default value for “zero-length” text nodes.</param>`
	`34`	`/// <param name="nsMan">`
	`35`	`/// The <see cref="XmlNamespaceManager"/>`
	`36`	`/// to use to resolve prefixes.`
	`37`	`/// </param>`
	`38`	`public static object? GetNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException,`
	`39`	`object? defaultValue,`
	`40`	`XmlNamespaceManager? nsMan)`
0	`41`	`{`
0	`42`	`XPathNavigator? n = GetNavigableNode(node, nodeQuery, nsMan);`
0	`43`	`object? p = defaultValue;`
	`44`
0	`45`	`if (n != null)`
0	`46`	`{`
0	`47`	`if (n.Value.Trim().Length > 0) p = n.Value.Trim();`
0	`48`	`}`
0	`49`	`else if (throwException)`
0	`50`	`{`
0	`51`	`throw new XmlException($"Element at “{nodeQuery}” was not found.");`
	`52`	`}`
	`53`
0	`54`	`return p;`
0	`55`	`}`
	`56`
	`57`	`/// <summary>`
	`58`	`/// Returns an object for parsing`
	`59`	`/// and adding to a list of parameters for data access.`
	`60`	`/// </summary>`
	`61`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`62`	`/// <param name="nodeQuery">The XPath <see cref="string"/>.</param>`
	`63`	`/// <param name="throwException">When <c>true</c>, throw an exception for null nodes and nodes that do not parse int`
	`64`	`/// <param name="defaultValue">Return a boxing <see cref="Object"/> for “zero-length” text nodes.</param>`
	`65`	`/// <typeparam name="T">The type to parse from the node value.</typeparam>`
	`66`	`public static object? GetNodeValueAndParse<T>(IXPathNavigable? node, string? nodeQuery, bool throwException,`
0	`67`	`T defaultValue) => GetNodeValueAndParse(node, nodeQuery, throwException, defaultValue, null);`
	`68`
	`69`	`/// <summary>`
	`70`	`/// Returns an object for parsing`
	`71`	`/// and adding to a list of parameters for data access.`
	`72`	`/// </summary>`
	`73`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`74`	`/// <param name="nodeQuery">The XPath <see cref="string"/>.</param>`
	`75`	`/// <param name="throwException">When <c>true</c>, throw an exception for null nodes and nodes that do not parse int`
	`76`	`/// <param name="defaultValue">Return a boxing <see cref="Object"/> for “zero-length” text nodes.</param>`
	`77`	`/// <param name="nsMan">`
	`78`	`/// The <see cref="XmlNamespaceManager"/>`
	`79`	`/// to use to resolve prefixes.`
	`80`	`/// </param>`
	`81`	`/// <typeparam name="T">The type to parse from the node value.</typeparam>`
	`82`	`public static object? GetNodeValueAndParse<T>(IXPathNavigable? node, string? nodeQuery, bool throwException,`
	`83`	`T? defaultValue, XmlNamespaceManager? nsMan)`
0	`84`	`{`
0	`85`	`object? p = GetNodeValue(node, nodeQuery, throwException, nsMan);`
	`86`
	`87`	`try`
0	`88`	`{`
0	`89`	`T? stronglyOfT = default(T);`
	`90`
0	`91`	`if (p == null \|\| string.IsNullOrWhiteSpace(p.ToString()?.Trim()))`
0	`92`	`{`
0	`93`	`p = defaultValue;`
0	`94`	`}`
	`95`	`else`
0	`96`	`switch (stronglyOfT)`
	`97`	`{`
	`98`	`case bool:`
0	`99`	`p = bool.Parse(p.ToString() ?? string.Empty);`
0	`100`	`break;`
	`101`	`case byte:`
0	`102`	`p = Byte.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`103`	`break;`
	`104`	`case DateTime:`
0	`105`	`p = DateTime.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`106`	`break;`
	`107`	`case decimal:`
0	`108`	`p = Decimal.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`109`	`break;`
	`110`	`case double:`
0	`111`	`p = Double.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`112`	`break;`
	`113`	`case short:`
0	`114`	`p = Int16.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`115`	`break;`
	`116`	`case int:`
0	`117`	`p = Int32.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`118`	`break;`
	`119`	`case long:`
0	`120`	`p = Int64.Parse(p.ToString() ?? string.Empty, CultureInfo.CurrentCulture);`
0	`121`	`break;`
	`122`	`default:`
0	`123`	`{`
0	`124`	`if (typeof(T).IsAssignableFrom(typeof(string)))`
0	`125`	`{`
0	`126`	`p = p.ToString();`
0	`127`	`}`
	`128`	`else`
0	`129`	`{`
0	`130`	`Type t = typeof(T);`
0	`131`	`throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,`
0	`132`	`"The specified type, “{0},” is not supported.", t.FullName));`
	`133`	`}`
	`134`
0	`135`	`break;`
	`136`	`}`
	`137`	`}`
0	`138`	`}`
0	`139`	`catch (Exception ex)`
0	`140`	`{`
0	`141`	`Type t = typeof(T);`
0	`142`	`var errMsg =`
0	`143`	`$"Parse for “{t.FullName}” fails for element in “{nodeQuery}.” Value to parse: “{((p == null) ? "Null" :`
0	`144`	`throw new XmlException(errMsg);`
	`145`	`}`
	`146`
0	`147`	`return p;`
0	`148`	`}`
	`149`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetText.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// “Cleans” XML data returning`
	`7`	`/// in a <see cref="MemoryStream"/>.`
	`8`	`/// </summary>`
	`9`	`/// <param name="ramStream"><see cref="MemoryStream"/></param>`
	`10`	`public static string? GetText(MemoryStream? ramStream)`
0	`11`	`{`
0	`12`	`if (ramStream == null) return null;`
	`13`
0	`14`	`var s = Encoding.UTF8.GetString(ramStream.ToArray());`
	`15`
0	`16`	`if (!string.IsNullOrWhiteSpace(s))`
0	`17`	`s = s.Trim().Replace("\0", string.Empty);`
	`18`
0	`19`	`return s;`
0	`20`	`}`
	`21`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetXslResult.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns a <see cref="XPathDocument"/>`
	`7`	`/// for the transformation of the XSLT document`
	`8`	`/// and the XML document.`
	`9`	`/// </summary>`
	`10`	`/// <param name="navigableXsl">`
	`11`	`/// The source <see cref="IXPathNavigable"/> XSL document.`
	`12`	`/// </param>`
	`13`	`/// <param name="navigableSet">`
	`14`	`/// The source <see cref="IXPathNavigable"/> XML document.`
	`15`	`/// </param>`
	`16`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`17`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`18`	`public static XPathDocument GetXslResult(IXPathNavigable? navigableXsl, IXPathNavigable? navigableSet) =>`
0	`19`	`GetXslResult(navigableXsl, null, navigableSet);`
	`20`
	`21`	`/// <summary>`
	`22`	`/// Returns a <see cref="XPathDocument"/>`
	`23`	`/// for the transformation of the XSLT document`
	`24`	`/// and the XML document.`
	`25`	`/// </summary>`
	`26`	`/// <param name="navigableXsl">`
	`27`	`/// The source <see cref="IXPathNavigable"/> XSL document.`
	`28`	`/// </param>`
	`29`	`/// <param name="xslArgs">`
	`30`	`/// The <see cref="XsltArgumentList"/>.`
	`31`	`/// </param>`
	`32`	`/// <param name="navigableXml">`
	`33`	`/// The source <see cref="IXPathNavigable"/> XML document.`
	`34`	`/// </param>`
	`35`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`36`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`37`	`public static XPathDocument GetXslResult(IXPathNavigable? navigableXsl, XsltArgumentList? xslArgs,`
	`38`	`IXPathNavigable? navigableXml)`
0	`39`	`{`
0	`40`	`ArgumentNullException.ThrowIfNull(navigableXsl);`
0	`41`	`ArgumentNullException.ThrowIfNull(navigableXml);`
	`42`
0	`43`	`XslCompiledTransform xslt = new XslCompiledTransform(false);`
0	`44`	`xslt.Load(navigableXsl);`
	`45`
0	`46`	`var navigator = navigableXml.CreateNavigator().ToReferenceTypeValueOrThrow();`
	`47`
0	`48`	`using MemoryStream ms = new MemoryStream();`
0	`49`	`using (StringReader sr = new StringReader(navigator.OuterXml))`
0	`50`	`{`
0	`51`	`XmlReader reader = XmlReader.Create(sr);`
0	`52`	`XmlWriter writer = XmlWriter.Create(ms);`
0	`53`	`xslt.Transform(reader, xslArgs, writer, null);`
	`54`	`//FUNKYKB: Setting documentResolver to null prevents namespace URI calls (document() resolution).`
0	`55`	`}`
	`56`
0	`57`	`ms.Position = 0;`
0	`58`	`var ret = new XPathDocument(ms);`
	`59`
0	`60`	`return ret;`
0	`61`	`}`
	`62`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.GetXslString.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns a <see cref="string"/>`
	`7`	`/// for the transformation of the XSLT document`
	`8`	`/// and the XML document.`
	`9`	`/// </summary>`
	`10`	`/// <param name="navigableXsl">The source <see cref="IXPathNavigable"/> XSL document.</param>`
	`11`	`/// <param name="navigableSet">The source <see cref="IXPathNavigable"/> XML document.</param>`
	`12`	`public static string? GetXslString(IXPathNavigable? navigableXsl, IXPathNavigable? navigableSet) =>`
0	`13`	`GetXslString(navigableXsl, null, navigableSet, null);`
	`14`
	`15`	`/// <summary>`
	`16`	`/// Returns a <see cref="string"/>`
	`17`	`/// for the transformation of the XSLT document`
	`18`	`/// and the XML document.`
	`19`	`/// </summary>`
	`20`	`/// <param name="navigableXsl">`
	`21`	`/// The source <see cref="IXPathNavigable"/> XSL document.`
	`22`	`/// </param>`
	`23`	`/// <param name="xslArgs">`
	`24`	`/// The <see cref="XsltArgumentList"/>.`
	`25`	`/// </param>`
	`26`	`/// <param name="navigableXml">`
	`27`	`/// The source <see cref="IXPathNavigable"/> XML document.`
	`28`	`/// </param>`
	`29`	`public static string?`
	`30`	`GetXslString(IXPathNavigable? navigableXsl, XsltArgumentList? xslArgs, IXPathNavigable? navigableXml) =>`
0	`31`	`GetXslString(navigableXsl, xslArgs, navigableXml, null);`
	`32`
	`33`	`/// <summary>`
	`34`	`/// Returns a <see cref="string"/>`
	`35`	`/// for the transformation of the XSLT document`
	`36`	`/// and the XML document.`
	`37`	`/// </summary>`
	`38`	`/// <param name="navigableXsl">The source <see cref="IXPathNavigable"/> XSL document.</param>`
	`39`	`/// <param name="xslArgs">The <see cref="XsltArgumentList"/>.</param>`
	`40`	`/// <param name="navigableXml">The source <see cref="IXPathNavigable"/> XML document.</param>`
	`41`	`/// <param name="settings">The settings.</param>`
	`42`	`public static string? GetXslString(IXPathNavigable? navigableXsl, XsltArgumentList? xslArgs,`
	`43`	`IXPathNavigable? navigableXml,`
	`44`	`XmlWriterSettings? settings)`
0	`45`	`{`
0	`46`	`ArgumentNullException.ThrowIfNull(navigableXsl);`
0	`47`	`ArgumentNullException.ThrowIfNull(navigableXml);`
	`48`
0	`49`	`var navigator = navigableXml.CreateNavigator().ToReferenceTypeValueOrThrow();`
0	`50`	`XslCompiledTransform xslt = new XslCompiledTransform(false);`
0	`51`	`xslt.Load(navigableXsl);`
	`52`
0	`53`	`using MemoryStream ms = new MemoryStream();`
0	`54`	`using (StringReader sr = new StringReader(navigator.OuterXml))`
0	`55`	`{`
0	`56`	`XmlReader reader = XmlReader.Create(sr);`
0	`57`	`XmlWriter writer = (settings != null) ? XmlWriter.Create(ms, settings) : XmlWriter.Create(ms);`
0	`58`	`xslt.Transform(reader, xslArgs, writer, null);`
0	`59`	`}`
	`60`
0	`61`	`ms.Position = 0;`
	`62`
0	`63`	`var ret = GetText(ms);`
	`64`
0	`65`	`return ret;`
0	`66`	`}`
	`67`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.InputAs.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns an <see cref="XPathDocument"/>,`
	`7`	`/// converted from the specified input.`
	`8`	`/// </summary>`
	`9`	`/// <typeparam name="TIn">The <see cref="Type"/> of the input.</typeparam>`
	`10`	`/// <param name="input">The input.</param>`
	`11`	`/// <returns>Returns an <see cref="XPathDocument"/>.</returns>`
	`12`	`/// <remarks>`
	`13`	`/// This member only supports <c>TIn</c> as`
	`14`	`/// <see cref="string"/>, <see cref="XmlDocument"/> or <see cref="XPathDocument"/>.`
	`15`	`/// </remarks>`
	`16`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`17`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`18`	`public static XPathDocument? InputAs<TIn>(TIn? input) where TIn: class`
0	`19`	`{`
0	`20`	`if (input == null) return null;`
	`21`
0	`22`	`TIn? stronglyOfTIn = default(TIn);`
0	`23`	`switch (stronglyOfTIn)`
	`24`	`{`
	`25`	`case XmlDocument:`
0	`26`	`return GetNavigableDocument(input as XmlDocument);`
	`27`	`case XPathDocument:`
0	`28`	`return input as XPathDocument;`
	`29`	`default:`
0	`30`	`if (!typeof(TIn).IsAssignableFrom(typeof(string))) return null;`
	`31`
0	`32`	`string? s = input as string;`
0	`33`	`s = HtmlUtility.ConvertToXml(s);`
0	`34`	`s = LatinGlyphsUtility.Condense(s, basicLatinOnly: false);`
	`35`
0	`36`	`return GetNavigableDocument(s);`
	`37`	`}`
0	`38`	`}`
	`39`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.IsNodeValue.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns true when the node has the specified value.`
	`7`	`/// </summary>`
	`8`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`9`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`10`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`11`	`/// <param name="testValue">The specified value to test with the node value.</param>`
	`12`	`public static bool IsNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException, string? testValue)`
0	`13`	`{`
0	`14`	`string? s = GetNodeValue(node, nodeQuery, throwException) as string;`
	`15`
0	`16`	`return string.Equals(s, testValue, StringComparison.OrdinalIgnoreCase);`
0	`17`	`}`
	`18`
	`19`	`/// <summary>`
	`20`	`/// Returns true when the node has the specified value.`
	`21`	`/// </summary>`
	`22`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`23`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`24`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`25`	`/// <param name="testValue">The specified value to test with the node value.</param>`
	`26`	`/// <param name="comparisonType">The <see cref="StringComparison"/> type.</param>`
	`27`	`public static bool IsNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException, string? testValue,`
	`28`	`StringComparison comparisonType)`
0	`29`	`{`
0	`30`	`string? s = GetNodeValue(node, nodeQuery, throwException) as string;`
	`31`
0	`32`	`return string.Equals(s, testValue, comparisonType);`
0	`33`	`}`
	`34`
	`35`	`/// <summary>`
	`36`	`/// Returns true when the node has the specified value.`
	`37`	`/// </summary>`
	`38`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`39`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`40`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`41`	`/// <param name="testValue">The specified value to test with the node value.</param>`
	`42`	`/// <param name="nsMan">`
	`43`	`/// The <see cref="XmlNamespaceManager"/>`
	`44`	`/// to use to resolve prefixes.`
	`45`	`/// </param>`
	`46`	`public static bool IsNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException, string? testValue,`
	`47`	`XmlNamespaceManager nsMan)`
0	`48`	`{`
0	`49`	`string? s = GetNodeValue(node, nodeQuery, throwException, null, nsMan) as string;`
	`50`
0	`51`	`return string.Equals(s, testValue);`
0	`52`	`}`
	`53`
	`54`	`/// <summary>`
	`55`	`/// Returns true when the node has the specified value.`
	`56`	`/// </summary>`
	`57`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`58`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`59`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`60`	`/// <param name="testValue">The specified value to test with the node value.</param>`
	`61`	`/// <param name="nsMan">`
	`62`	`/// The <see cref="XmlNamespaceManager"/>`
	`63`	`/// to use to resolve prefixes.`
	`64`	`/// </param>`
	`65`	`/// <param name="comparisonType">The <see cref="StringComparison"/> type.</param>`
	`66`	`public static bool IsNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException, string? testValue,`
	`67`	`XmlNamespaceManager nsMan, StringComparison comparisonType)`
0	`68`	`{`
0	`69`	`string? s = GetNodeValue(node, nodeQuery, throwException, null, nsMan) as string;`
	`70`
0	`71`	`return string.Equals(s, testValue, comparisonType);`
0	`72`	`}`
	`73`
	`74`	`/// <summary>`
	`75`	`/// Returns true when the node has the value “no”.`
	`76`	`/// </summary>`
	`77`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`78`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`79`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`80`	`public static bool IsNoNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException) =>`
0	`81`	`IsNodeValue(node, nodeQuery, throwException, "no", StringComparison.OrdinalIgnoreCase);`
	`82`
	`83`	`/// <summary>`
	`84`	`/// Returns true when the node has the value “yes”.`
	`85`	`/// </summary>`
	`86`	`/// <param name="node">The <see cref="IXPathNavigable"/> node.</param>`
	`87`	`/// <param name="nodeQuery">The node query <see cref="string"/>.</param>`
	`88`	`/// <param name="throwException">When <code>true</code>, throw an exception for null nodes.</param>`
	`89`	`public static bool IsYesNodeValue(IXPathNavigable? node, string? nodeQuery, bool throwException) =>`
0	`90`	`IsNodeValue(node, nodeQuery, throwException, "yes", StringComparison.OrdinalIgnoreCase);`
	`91`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.IsXml.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns <c>true</c> when the fragment is XML-like.`
	`7`	`/// </summary>`
	`8`	`/// <param name="fragment">The fragment to test.</param>`
	`9`	`public static bool IsXml(string? fragment)`
0	`10`	`{`
0	`11`	`if (string.IsNullOrWhiteSpace(fragment)) return false;`
	`12`
0	`13`	`Match xmlMatch = Regex.Match(fragment, @"<([^>]+)>(.?</(\1)>\|[^>]/>)");`
0	`14`	`Match xmlMatchMinimized = Regex.Match(fragment, @"<([^>]+)/>");`
	`15`
0	`16`	`return xmlMatch.Success \|\| xmlMatchMinimized.Success;`
0	`17`	`}`
	`18`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.LoadXslTransform.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns a <see cref="string"/>`
	`7`	`/// for the transformation of the XSLT file`
	`8`	`/// and the XML file.`
	`9`	`/// </summary>`
	`10`	`/// <param name="xslPath">`
	`11`	`/// Output path to the XSLT file.`
	`12`	`/// </param>`
	`13`	`/// <param name="xmlPath">`
	`14`	`/// Output path to the XML file.`
	`15`	`/// </param>`
	`16`	`public static string? LoadXslTransform(string? xslPath, string? xmlPath) =>`
0	`17`	`LoadXslTransform(xslPath, xslArgs: null, xmlPath);`
	`18`
	`19`	`/// <summary>`
	`20`	`/// Returns a <see cref="string"/>`
	`21`	`/// for the transformation of the XSLT file`
	`22`	`/// and the XML file.`
	`23`	`/// </summary>`
	`24`	`/// <param name="xslPath">`
	`25`	`/// Output path to the XSLT file.`
	`26`	`/// </param>`
	`27`	`/// <param name="commandName">`
	`28`	`/// The value for the <code>cmd</code>-parameter convention.`
	`29`	`/// </param>`
	`30`	`/// <param name="xmlPath">`
	`31`	`/// Output path to the XML file.`
	`32`	`/// </param>`
	`33`	`public static string? LoadXslTransform(string? xslPath, string? commandName, string? xmlPath)`
0	`34`	`{`
0	`35`	`var xslArgs = GetXsltArgumentList(commandName);`
	`36`
0	`37`	`return LoadXslTransform(xslPath, xslArgs, xmlPath);`
0	`38`	`}`
	`39`
	`40`	`/// <summary>`
	`41`	`/// Returns a <see cref="string"/>`
	`42`	`/// for the transformation of the XSLT file`
	`43`	`/// and the XML file.`
	`44`	`/// </summary>`
	`45`	`/// <param name="xslPath">`
	`46`	`/// Output path to the XSLT file.`
	`47`	`/// </param>`
	`48`	`/// <param name="xslArgs">`
	`49`	`/// The <see cref="XsltArgumentList"/>.`
	`50`	`/// </param>`
	`51`	`/// <param name="xmlPath">`
	`52`	`/// Output path to the XML file.`
	`53`	`/// </param>`
	`54`	`public static string? LoadXslTransform(string? xslPath, XsltArgumentList? xslArgs, string? xmlPath)`
0	`55`	`{`
0	`56`	`xslPath.ThrowWhenNullOrWhiteSpace();`
0	`57`	`xmlPath.ThrowWhenNullOrWhiteSpace();`
	`58`
0	`59`	`xslArgs ??= new XsltArgumentList();`
	`60`
0	`61`	`XslCompiledTransform xslt = new XslCompiledTransform(false);`
0	`62`	`xslt.Load(xslPath);`
	`63`
0	`64`	`using MemoryStream ms = new MemoryStream();`
0	`65`	`using (XmlReader reader = XmlReader.Create(xmlPath))`
0	`66`	`{`
0	`67`	`XmlWriter writer = XmlWriter.Create(ms);`
0	`68`	`xslt.Transform(reader, xslArgs, writer, null);`
0	`69`	`}`
	`70`
0	`71`	`var ret = GetText(ms);`
	`72`
0	`73`	`return ret;`
0	`74`	`}`
	`75`
	`76`	`/// <summary>`
	`77`	`/// Returns a <see cref="string"/>`
	`78`	`/// for the transformation of the XSLT file`
	`79`	`/// and the specified <see cref="IXPathNavigable"/> in memory.`
	`80`	`/// </summary>`
	`81`	`/// <param name="xslPath">`
	`82`	`/// Output path to the XSLT file.`
	`83`	`/// </param>`
	`84`	`/// <param name="commandName">`
	`85`	`/// The value for the <code>cmd</code>-parameter convention.`
	`86`	`/// </param>`
	`87`	`/// <param name="xmlFragment">`
	`88`	`/// A well-formed XML <see cref="string"/>.`
	`89`	`/// </param>`
	`90`	`/// <remarks>`
	`91`	`/// This convention is used in ASP.NET Web applications.`
	`92`	`/// </remarks>`
	`93`	`public static string? LoadXslTransformForMemoryInput(string? xslPath, string? commandName,`
	`94`	`string? xmlFragment)`
0	`95`	`{`
0	`96`	`var xslArgs = GetXsltArgumentList(commandName);`
	`97`
0	`98`	`return LoadXslTransformForMemoryInput(xslPath, xslArgs, xmlFragment);`
0	`99`	`}`
	`100`
	`101`	`/// <summary>`
	`102`	`/// Returns a <see cref="string"/>`
	`103`	`/// for the transformation of the XSLT file`
	`104`	`/// and the specified <see cref="IXPathNavigable"/> in memory.`
	`105`	`/// </summary>`
	`106`	`/// <param name="xslPath">`
	`107`	`/// Output path to the XSLT file.`
	`108`	`/// </param>`
	`109`	`/// <param name="commandName">`
	`110`	`/// The value for the <code>cmd</code>-parameter convention.`
	`111`	`/// </param>`
	`112`	`/// <param name="navigableXml">`
	`113`	`/// The <see cref="IXPathNavigable"/> in memory.`
	`114`	`/// </param>`
	`115`	`/// <remarks>`
	`116`	`/// This convention is used in ASP.NET Web applications.`
	`117`	`/// </remarks>`
	`118`	`public static string? LoadXslTransformForMemoryInput(string? xslPath, string? commandName,`
	`119`	`IXPathNavigable navigableXml)`
0	`120`	`{`
0	`121`	`ArgumentNullException.ThrowIfNull(navigableXml);`
	`122`
0	`123`	`var navigator = navigableXml.CreateNavigator().ToReferenceTypeValueOrThrow();`
0	`124`	`var xmlFragment = navigator.OuterXml;`
0	`125`	`var xslArgs = GetXsltArgumentList(commandName);`
	`126`
0	`127`	`return LoadXslTransformForMemoryInput(xslPath, xslArgs, xmlFragment);`
0	`128`	`}`
	`129`
	`130`	`/// <summary>`
	`131`	`/// Returns a <see cref="string"/>`
	`132`	`/// for the transformation of the XSLT file`
	`133`	`/// and the XML in-memory fragment.`
	`134`	`/// </summary>`
	`135`	`/// <param name="xslPath">`
	`136`	`/// Output path to the XSLT file.`
	`137`	`/// </param>`
	`138`	`/// <param name="xslArgs">`
	`139`	`/// The <see cref="XsltArgumentList"/>.`
	`140`	`/// </param>`
	`141`	`/// <param name="xmlFragment">`
	`142`	`/// A well-formed XML <see cref="string"/>.`
	`143`	`/// </param>`
	`144`	`/// <remarks>`
	`145`	`/// This convention is used in ASP.NET Web applications.`
	`146`	`/// </remarks>`
	`147`	`public static string? LoadXslTransformForMemoryInput(string? xslPath, XsltArgumentList? xslArgs,`
	`148`	`string? xmlFragment)`
0	`149`	`{`
0	`150`	`xslPath.ThrowWhenNullOrWhiteSpace();`
0	`151`	`xmlFragment.ThrowWhenNullOrWhiteSpace();`
	`152`
0	`153`	`xslArgs ??= new XsltArgumentList();`
	`154`
0	`155`	`var xslt = new XslCompiledTransform(false);`
0	`156`	`xslt.Load(xslPath);`
	`157`
0	`158`	`using MemoryStream ms = new MemoryStream();`
0	`159`	`using (StringReader sr = new StringReader(xmlFragment))`
0	`160`	`{`
0	`161`	`XmlReader reader = XmlReader.Create(sr);`
0	`162`	`XmlWriter writer = XmlWriter.Create(ms);`
0	`163`	`xslt.Transform(reader, xslArgs, writer, null);`
0	`164`	`}`
	`165`
0	`166`	`var ret = GetText(ms);`
	`167`
0	`168`	`return ret;`
0	`169`	`}`
	`170`
	`171`	`static XsltArgumentList GetXsltArgumentList(string? commandName)`
0	`172`	`{`
0	`173`	`XsltArgumentList xslArgs = new XsltArgumentList();`
	`174`
0	`175`	`if (!string.IsNullOrWhiteSpace(commandName))`
	`176`	`//CONVENTION: XSL templates use a parameter called “cmd”:`
0	`177`	`xslArgs.AddParam("cmd", string.Empty, commandName);`
	`178`
0	`179`	`return xslArgs;`
0	`180`	`}`
	`181`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.OutputAs.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Returns strongly typed output, converting the XML fragment.`
	`7`	`/// </summary>`
	`8`	`/// <typeparam name="TOut">The <see cref="Type"/> of output to return (constrained to <c>class</c>).</typeparam>`
	`9`	`/// <param name="xmlFragment">An XML fragment or document as a well-formed <see cref="string"/>.</param>`
	`10`	`/// <returns>Returns the specified <see cref="Type"/>.</returns>`
	`11`	`/// <remarks>`
	`12`	`/// This member only supports <c>TIn</c> as`
	`13`	`/// <see cref="string"/>, <see cref="XmlDocument"/> or <see cref="XPathDocument"/>.`
	`14`	`/// </remarks>`
	`15`	`public static TOut? OutputAs<TOut>(string xmlFragment) where TOut : class`
0	`16`	`{`
0	`17`	`if (typeof(TOut).IsAssignableFrom(typeof(string)))`
0	`18`	`{`
0	`19`	`return xmlFragment as TOut;`
	`20`	`}`
	`21`
0	`22`	`XPathDocument? d = GetNavigableDocument(xmlFragment);`
	`23`
0	`24`	`return OutputAs<TOut>(d);`
0	`25`	`}`
	`26`
	`27`	`/// <summary>`
	`28`	`/// Returns strongly typed output, converting the Navigable document.`
	`29`	`/// </summary>`
	`30`	`/// <typeparam name="TOut">The <see cref="Type"/> of output to return (constrained to <c>class</c>).</typeparam>`
	`31`	`/// <param name="navigableDocument">An <see cref="IXPathNavigable"/>.</param>`
	`32`	`/// <returns>Returns the specified <see cref="Type"/>.</returns>`
	`33`	`/// <remarks>`
	`34`	`/// This member only supports <c>TIn</c> as`
	`35`	`/// <see cref="string"/>, <see cref="XmlDocument"/> or <see cref="XPathDocument"/>.`
	`36`	`/// </remarks>`
	`37`	`public static TOut? OutputAs<TOut>(IXPathNavigable? navigableDocument) where TOut : class`
0	`38`	`{`
0	`39`	`if (navigableDocument == null) return default;`
	`40`
0	`41`	`if (typeof(TOut).IsAssignableFrom(typeof(string)))`
0	`42`	`{`
0	`43`	`return navigableDocument.CreateNavigator()?.OuterXml as TOut;`
	`44`	`}`
	`45`
0	`46`	`TOut? stronglyOfTOut = default(TOut);`
0	`47`	`switch (stronglyOfTOut)`
	`48`	`{`
	`49`	`case XmlDocument:`
0	`50`	`XmlDocument dom = new XmlDocument();`
0	`51`	`dom.LoadXml(navigableDocument.ToString()!);`
	`52`
0	`53`	`return dom as TOut;`
	`54`
	`55`	`case XPathDocument:`
0	`56`	`return navigableDocument as TOut;`
	`57`	`}`
	`58`
0	`59`	`return default;`
0	`60`	`}`
	`61`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.StripNamespaces.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Strip the namespaces from specified <see cref="string"/>.`
	`7`	`/// </summary>`
	`8`	`/// <param name="xml">`
	`9`	`/// The source <see cref="string"/>.`
	`10`	`/// </param>`
	`11`	`/// <remarks>`
	`12`	`/// WARNING: Stripping namespaces “flattens” the document`
	`13`	`/// and can cause local-name collisions.`
	`14`	`///`
	`15`	`/// This routine does not remove namespace prefixes.`
	`16`	`///`
	`17`	`/// </remarks>`
0	`18`	`public static string? StripNamespaces(string xml) => StripNamespaces(xml, false);`
	`19`
	`20`	`/// <summary>`
	`21`	`/// Strip the namespaces from specified <see cref="string"/>.`
	`22`	`/// </summary>`
	`23`	`/// <param name="xml">`
	`24`	`/// The source <see cref="string"/>.`
	`25`	`/// </param>`
	`26`	`/// <param name="removeDocType">`
	`27`	`/// When <c>true</c>, removes any DOCTYPE preambles.`
	`28`	`/// </param>`
	`29`	`/// <remarks>`
	`30`	`/// WARNING: Stripping namespaces “flattens” the document`
	`31`	`/// and can cause local-name collisions.`
	`32`	`///`
	`33`	`/// This routine does not remove namespace prefixes.`
	`34`	`///`
	`35`	`/// </remarks>`
	`36`	`public static string? StripNamespaces(string? xml, bool removeDocType)`
0	`37`	`{`
0	`38`	`if (string.IsNullOrWhiteSpace(xml)) return null;`
	`39`
0	`40`	`if (removeDocType)`
0	`41`	`{`
0	`42`	`xml = Regex.Replace(xml,`
0	`43`	`@"\<\!DOCTYPE [^<]+\>", string.Empty,`
0	`44`	`RegexOptions.IgnoreCase);`
0	`45`	`}`
	`46`
	`47`	`//Attempt to remove all namespace prefixes:`
0	`48`	`foreach (Match m in Regex.Matches(xml,`
0	`49`	`@"\sxmlns:?([^=])=[""][^""][""]\s", RegexOptions.IgnoreCase \| RegexOptions.Multiline))`
0	`50`	`{`
0	`51`	`if (m.Groups.Count != 2) continue;`
	`52`
	`53`	`string pattern;`
	`54`
0	`55`	`pattern = m.Groups[1].Value;`
0	`56`	`pattern = string.Concat("<", pattern, ":");`
0	`57`	`xml = xml.Replace(pattern, "<");`
	`58`
0	`59`	`pattern = m.Groups[1].Value;`
0	`60`	`pattern = string.Concat("</", pattern, ":");`
0	`61`	`xml = xml.Replace(pattern, "</");`
0	`62`	`}`
	`63`
	`64`	`//Attempt to remove namespace declarations:`
0	`65`	`xml = Regex.Replace(xml,`
0	`66`	`@"\s(xmlns:?[^=]=[""][^""][""])\s", string.Empty,`
0	`67`	`RegexOptions.IgnoreCase);`
	`68`
	`69`	`//Attempt to remove schemaLocation attribute:`
0	`70`	`xml = Regex.Replace(xml,`
0	`71`	`@"\s([a-zA-z0-9:]schemaLocation\s=[""][^""][""])\s*", string.Empty,`
0	`72`	`RegexOptions.IgnoreCase);`
	`73`
0	`74`	`return !string.IsNullOrWhiteSpace(xml) ? xml.Trim() : null;`
0	`75`	`}`
	`76`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.StripNamespaces.IXPathNavigable.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Strip the namespaces from specified document.`
	`7`	`/// </summary>`
	`8`	`/// <param name="navigable">`
	`9`	`/// The source <see cref="IXPathNavigable"/> document.`
	`10`	`/// </param>`
	`11`	`/// <remarks>`
	`12`	`/// WARNING: Stripping namespaces “flattens” the document`
	`13`	`/// and can cause local-name collisions.`
	`14`	`///`
	`15`	`/// This routine does not remove namespace prefixes.`
	`16`	`///`
	`17`	`/// </remarks>`
	`18`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`19`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
0	`20`	`public static XPathDocument? StripNamespaces(IXPathNavigable? navigable) => StripNamespaces(navigable, false);`
	`21`
	`22`	`/// <summary>`
	`23`	`/// Strip the namespaces from specified document.`
	`24`	`/// </summary>`
	`25`	`/// <param name="navigable">`
	`26`	`/// The source <see cref="IXPathNavigable"/> document.`
	`27`	`/// </param>`
	`28`	`/// <param name="removeDocType">`
	`29`	`/// When <c>true</c>, removes any DOCTYPE preambles.`
	`30`	`/// </param>`
	`31`	`/// <remarks>`
	`32`	`/// WARNING: Stripping namespaces “flattens” the document`
	`33`	`/// and can cause local-name collisions.`
	`34`	`///`
	`35`	`/// This routine does not remove namespace prefixes.`
	`36`	`///`
	`37`	`/// </remarks>`
	`38`	`[SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes",`
	`39`	`Justification = "Specific functionality provided by the concrete type may be required.")]`
	`40`	`public static XPathDocument? StripNamespaces(IXPathNavigable? navigable, bool removeDocType)`
0	`41`	`{`
0	`42`	`if (navigable == null) return null;`
	`43`
0	`44`	`XPathNavigator? navigator = navigable.CreateNavigator();`
	`45`
0	`46`	`string? xmlString = StripNamespaces(navigator?.OuterXml, removeDocType);`
	`47`
0	`48`	`using StringReader s = new StringReader(xmlString!);`
	`49`
0	`50`	`var newXml = new XPathDocument(s);`
	`51`
0	`52`	`return newXml;`
0	`53`	`}`
	`54`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.ValidateNavigableNode.cs

#	Line	Line coverage
	`1`	`using System.Xml.Schema;`
	`2`
	`3`	`namespace Songhay.Xml;`
	`4`
	`5`	`public static partial class XmlUtility`
	`6`	`{`
	`7`	`/// <summary>`
	`8`	`/// Returns an <see cref="XmlSchema"/> based`
	`9`	`/// on the specified navigable set and validation event handler.`
	`10`	`/// </summary>`
	`11`	`/// <param name="navigable">`
	`12`	`/// The source <see cref="IXPathNavigable"/> document.`
	`13`	`/// </param>`
	`14`	`/// <param name="eventHandler">`
	`15`	`/// The <see cref="ValidationEventHandler"/>`
	`16`	`/// with signature MyHandler(object sender, ValidationEventArgs args).`
	`17`	`/// </param>`
	`18`	`public static XmlSchema? GetXmlSchema(IXPathNavigable navigable, ValidationEventHandler eventHandler)`
0	`19`	`{`
0	`20`	`ArgumentNullException.ThrowIfNull(navigable);`
0	`21`	`ArgumentNullException.ThrowIfNull(eventHandler);`
	`22`
0	`23`	`XPathNavigator? navigator = navigable.CreateNavigator();`
0	`24`	`if (navigator == null) throw new NullReferenceException("The expected XPath Navigator is not here.");`
	`25`
0	`26`	`using StringReader s = new StringReader(navigator.OuterXml);`
0	`27`	`var schema = XmlSchema.Read(s, eventHandler);`
	`28`
0	`29`	`return schema;`
0	`30`	`}`
	`31`
	`32`	`/// <summary>`
	`33`	`/// Loads an <see cref="XmlSchema"/> based`
	`34`	`/// on the specified navigable set and validation event handler.`
	`35`	`/// </summary>`
	`36`	`/// <param name="pathToSchema">`
	`37`	`/// The valid path to an XML Schema file.`
	`38`	`/// </param>`
	`39`	`/// <param name="eventHandler">`
	`40`	`/// The <see cref="ValidationEventHandler"/>`
	`41`	`/// with signature MyHandler(object sender, ValidationEventArgs args).`
	`42`	`/// </param>`
	`43`	`public static XmlSchema? LoadXmlSchema(string? pathToSchema, ValidationEventHandler? eventHandler)`
0	`44`	`{`
0	`45`	`pathToSchema.ThrowWhenNullOrWhiteSpace();`
	`46`
0	`47`	`if (!File.Exists(pathToSchema)) throw new FileNotFoundException(nameof(pathToSchema));`
	`48`
0	`49`	`ArgumentNullException.ThrowIfNull(eventHandler);`
	`50`
0	`51`	`using XmlTextReader x = new XmlTextReader(pathToSchema);`
0	`52`	`var schema = XmlSchema.Read(x, eventHandler);`
	`53`
0	`54`	`return schema;`
0	`55`	`}`
	`56`
	`57`	`/// <summary>`
	`58`	`/// Validates the specified navigable set`
	`59`	`/// with the specified schema and validation event handler.`
	`60`	`/// </summary>`
	`61`	`/// <param name="navigable">`
	`62`	`/// The source <see cref="IXPathNavigable"/> document.`
	`63`	`/// </param>`
	`64`	`/// <param name="schema">`
	`65`	`/// The <see cref="XmlSchema"/>.`
	`66`	`/// </param>`
	`67`	`/// <param name="eventHandler">`
	`68`	`/// The <see cref="ValidationEventHandler"/>`
	`69`	`/// with signature MyHandler(object sender, ValidationEventArgs args).`
	`70`	`/// </param>`
	`71`	`public static void ValidateNavigableNode(IXPathNavigable? navigable, XmlSchema? schema,`
	`72`	`ValidationEventHandler? eventHandler)`
0	`73`	`{`
0	`74`	`ArgumentNullException.ThrowIfNull(navigable);`
0	`75`	`ArgumentNullException.ThrowIfNull(schema);`
0	`76`	`ArgumentNullException.ThrowIfNull(eventHandler);`
	`77`
0	`78`	`XmlReaderSettings settings = new XmlReaderSettings();`
0	`79`	`settings.Schemas.Add(schema);`
0	`80`	`settings.ValidationType = ValidationType.Schema;`
0	`81`	`settings.ValidationEventHandler += eventHandler;`
	`82`
0	`83`	`XPathNavigator? navigator = navigable.CreateNavigator();`
0	`84`	`if (navigator == null) throw new NullReferenceException("The expected XPath Navigator is not here.");`
	`85`
0	`86`	`using var s = new StringReader(navigator.OuterXml);`
	`87`
0	`88`	`XmlReader.Create(s, settings);`
0	`89`	`}`
	`90`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.Write.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// Serializes and writes to the specified path.`
	`7`	`/// </summary>`
	`8`	`/// <typeparam name="T">The type of the instance.</typeparam>`
	`9`	`/// <param name="instance">The instance.</param>`
	`10`	`/// <param name="path">The path.</param>`
	`11`	`public static void Write<T>(T? instance, string? path) where T : class`
1	`12`	`{`
1	`13`	`ArgumentNullException.ThrowIfNull(instance);`
	`14`
1	`15`	`path.ThrowWhenNullOrWhiteSpace();`
	`16`
1	`17`	`var serializer = new XmlSerializer(typeof(T));`
	`18`
1	`19`	`XmlWriterSettings settings = new XmlWriterSettings`
1	`20`	`{`
1	`21`	`Encoding = Encoding.UTF8,`
1	`22`	`Indent = true,`
1	`23`	`IndentChars = " ",`
1	`24`	`NewLineOnAttributes = false,`
1	`25`	`OmitXmlDeclaration = false`
1	`26`	`};`
	`27`
1	`28`	`using var writer = XmlWriter.Create(path, settings);`
	`29`
1	`30`	`serializer.Serialize(writer, instance);`
2	`31`	`}`
	`32`
	`33`	`/// <summary>`
	`34`	`/// Transfers the data in the Source to the Destination.`
	`35`	`/// </summary>`
	`36`	`/// <param name="readerSource">The <see cref="XmlReader"/>.</param>`
	`37`	`/// <param name="writerDestination">The <see cref="XmlWriter"/>.</param>`
	`38`	`public static void WriteReader(XmlReader? readerSource, XmlWriter? writerDestination)`
0	`39`	`{`
0	`40`	`ArgumentNullException.ThrowIfNull(readerSource);`
0	`41`	`ArgumentNullException.ThrowIfNull(writerDestination);`
	`42`
0	`43`	`while (readerSource is {EOF: false}) writerDestination.WriteNode(readerSource, false);`
0	`44`	`}`
	`45`
	`46`	`/// <summary>`
	`47`	`/// Transforms the specified navigable documents`
	`48`	`/// and writes to disk with the specified path.`
	`49`	`/// </summary>`
	`50`	`/// <param name="xmlInput">The specified input.</param>`
	`51`	`/// <param name="navigableXsl">`
	`52`	`/// The source <see cref="IXPathNavigable"/> document.`
	`53`	`/// </param>`
	`54`	`/// <param name="outputPath">`
	`55`	`/// The file-system, target path.`
	`56`	`/// </param>`
	`57`	`public static void WriteXslTransform(IXPathNavigable? xmlInput,`
	`58`	`IXPathNavigable? navigableXsl, string? outputPath)`
0	`59`	`{`
0	`60`	`ArgumentNullException.ThrowIfNull(xmlInput);`
0	`61`	`ArgumentNullException.ThrowIfNull(navigableXsl);`
0	`62`	`ArgumentNullException.ThrowIfNull(outputPath);`
	`63`
0	`64`	`using var fs = new FileStream(outputPath, FileMode.Create);`
	`65`
0	`66`	`var xslt = new XslCompiledTransform(false);`
0	`67`	`xslt.Load(navigableXsl);`
	`68`
0	`69`	`using var sr = new StringReader(xmlInput.CreateNavigator().ToReferenceTypeValueOrThrow().OuterXml);`
0	`70`	`XmlReader reader = XmlReader.Create(sr);`
0	`71`	`XmlWriter writer = XmlWriter.Create(fs);`
	`72`
0	`73`	`xslt.Transform(reader, null, writer, null);`
0	`74`	`}`
	`75`
	`76`	`/// <summary>`
	`77`	`/// Transforms the specified input and writes to disk.`
	`78`	`/// </summary>`
	`79`	`/// <param name="xmlInput">The specified input.</param>`
	`80`	`/// <param name="navigableXsl">`
	`81`	`/// The source <see cref="IXPathNavigable"/> document.`
	`82`	`/// </param>`
	`83`	`/// <param name="outputPath">`
	`84`	`/// The file-system, target path.`
	`85`	`/// </param>`
	`86`	`public static void WriteXslTransform(XmlReader? xmlInput,`
	`87`	`IXPathNavigable? navigableXsl, string? outputPath)`
0	`88`	`{`
0	`89`	`ArgumentNullException.ThrowIfNull(xmlInput);`
0	`90`	`ArgumentNullException.ThrowIfNull(navigableXsl);`
0	`91`	`outputPath.ThrowWhenNullOrWhiteSpace();`
	`92`
0	`93`	`using var fs = new FileStream(outputPath, FileMode.Create);`
	`94`
0	`95`	`var xslt = new XslCompiledTransform(false);`
0	`96`	`xslt.Load(navigableXsl);`
0	`97`	`XmlWriter writer = XmlWriter.Create(fs);`
	`98`
0	`99`	`xslt.Transform(xmlInput, null, writer, null);`
0	`100`	`}`
	`101`	`}`

/home/rasx/sourceRoot/SonghayCore/SonghayCore/Xml/XmlUtility.XmlDecode.cs

#	Line	Line coverage
	`1`	`namespace Songhay.Xml;`
	`2`
	`3`	`public static partial class XmlUtility`
	`4`	`{`
	`5`	`/// <summary>`
	`6`	`/// The conventional HTML entities mapped to their respective glyphs.`
	`7`	`/// </summary>`
1	`8`	`public static readonly Dictionary<string, string> ConventionalHtmlEntities = new()`
1	`9`	`{`
1	`10`	`{ "&", "&" },`
1	`11`	`{ "<", "<" },`
1	`12`	`{ ">", ">" },`
1	`13`	`{ """, "\"" },`
1	`14`	`{ "'", "'" },`
1	`15`	`};`
	`16`
	`17`	`/// <summary>`
	`18`	`/// Transforms selected XML glyphs`
	`19`	`/// into their respective HTML entities.`
	`20`	`/// </summary>`
	`21`	`/// <param name="value">The value.</param>`
	`22`	`/// <seealso cref="LatinGlyphsUtility.Expand"/>`
	`23`	`/// <remarks>This member will preserve HTML comments.</remarks>`
	`24`	`public static string? XmlEncode(string? value)`
3	`25`	`{`
5	`26`	`if (string.IsNullOrWhiteSpace(value)) return value;`
	`27`
13	`28`	`foreach (var pair in ConventionalHtmlEntities)`
5	`29`	`{`
5	`30`	`value = value.Replace(pair.Value, pair.Key);`
5	`31`	`}`
	`32`
	`33`	`//Preserve comments:`
1	`34`	`value = value`
1	`35`	`.Replace("-->", "-->")`
1	`36`	`.Replace("<!--", "<!--");`
	`37`
1	`38`	`return value;`
3	`39`	`}`
	`40`
	`41`	`/// <summary>`
	`42`	`/// Transforms selected HTML entities`
	`43`	`/// into their respective glyphs.`
	`44`	`/// </summary>`
	`45`	`/// <param name="value">The value.</param>`
	`46`	`/// <seealso cref="LatinGlyphsUtility.Condense"/>`
	`47`	`public static string? XmlDecode(string? value)`
3	`48`	`{`
5	`49`	`if (string.IsNullOrWhiteSpace(value)) return value;`
	`50`
13	`51`	`foreach (var pair in ConventionalHtmlEntities)`
5	`52`	`{`
5	`53`	`value = value.Replace(pair.Key, pair.Value);`
5	`54`	`}`
	`55`
1	`56`	`return value;`
3	`57`	`}`
	`58`	`}`

Methods/Properties