public void TestValue ()
{
XmlTextReader xtr = new XmlTextReader ("<!DOCTYPE x:foo [<!ENTITY foo 'fooent'><!ENTITY bar 'test &foo;'>]><x:foo xmlns:x='hoge' />", XmlNodeType.Document, null);
document.Load (xtr);
xtr.Close ();
docType = document.DocumentType;
AssertEquals (2, docType.Entities.Count);
XmlEntity foo = docType.Entities.Item (0) as XmlEntity;
XmlEntity bar = docType.Entities.Item (1) as XmlEntity;
AssertEquals ("foo", foo.Name);
AssertNull (bar.Value);
AssertEquals (1, foo.ChildNodes.Count);
AssertEquals ("bar", bar.Name);
AssertNull (bar.Value);
AssertEquals (1, foo.ChildNodes.Count);
}
private void LoadDocumentType(IDtdInfo dtdInfo, XmlDocumentType dtNode)
{
SchemaInfo schInfo = dtdInfo as SchemaInfo;
if (schInfo == null)
{
throw new XmlException(SR.Xml_InternalError, string.Empty);
}
dtNode.DtdSchemaInfo = schInfo;
if (schInfo != null)
{
//set the schema information into the document
_doc.DtdSchemaInfo = schInfo;
// Notation hashtable
if (schInfo.Notations != null)
{
foreach (SchemaNotation scNot in schInfo.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, _doc));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.GeneralEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
if (schInfo.ParameterEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.ParameterEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
_doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
IDictionaryEnumerator elementDecls = schInfo.ElementDecls.GetEnumerator();
if (elementDecls != null)
{
elementDecls.Reset();
while (elementDecls.MoveNext())
{
SchemaElementDecl elementDecl = (SchemaElementDecl)elementDecls.Value;
if (elementDecl.AttDefs != null)
{
IDictionaryEnumerator attDefs = elementDecl.AttDefs.GetEnumerator();
while (attDefs.MoveNext())
{
SchemaAttDef attdef = (SchemaAttDef)attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID)
{
//we only register the XmlElement based on their Prefix/LocalName and skip the namespace
_doc.AddIdInfo(
_doc.AddXmlName(elementDecl.Prefix, elementDecl.Name.Name, string.Empty, null),
_doc.AddAttrXmlName(attdef.Prefix, attdef.Name.Name, string.Empty, null));
break;
}
}
}
}
}
}
}
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver)
{
_doc = dtNode.OwnerDocument;
XmlParserContext pc = new XmlParserContext(null, new XmlNamespaceManager(_doc.NameTable), null, null, null, null, _doc.BaseURI, string.Empty, XmlSpace.None);
XmlTextReaderImpl tr = new XmlTextReaderImpl("", XmlNodeType.Element, pc);
tr.Namespaces = dtNode.ParseWithNamespaces;
if (bUseResolver)
{
tr.XmlResolver = resolver;
}
IDtdParser dtdParser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr);
IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(_doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, proxy);
LoadDocumentType(dtdInfo, dtNode);
}
public void GetReady ()
{
document = new XmlDocument ();
docType = document.CreateDocumentType ("book", null, null, "<!ELEMENT book ANY>");
document.AppendChild (docType);
}
public String GetDocumentTypeAttr ( XmlDocumentType docType, String name ) {
//PreCondition: nav is pointing at DocumentType node or one of its virtual attributes
if ( name == strPublicID )
return docType.PublicId;
if ( name == strSystemID )
return docType.SystemId;
return null;
}
private void LoadDocumentType(SchemaInfo schInfo, XmlDocumentType dtNode)
{
dtNode.DtdSchemaInfo = schInfo;
if (schInfo != null)
{
//set the schema information into the document
doc.DtdSchemaInfo = schInfo;
// Notation hashtable
if (schInfo.Notations != null)
{
foreach (SchemaNotation scNot in schInfo.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, doc));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.GeneralEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
if (schInfo.ParameterEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.ParameterEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
IDictionaryEnumerator elementDecls = schInfo.ElementDecls.GetEnumerator();
if (elementDecls != null)
{
elementDecls.Reset();
while (elementDecls.MoveNext())
{
SchemaElementDecl elementDecl = (SchemaElementDecl)elementDecls.Value;
if (elementDecl.AttDefs != null)
{
IDictionaryEnumerator attDefs = elementDecl.AttDefs.GetEnumerator();
while (attDefs.MoveNext())
{
SchemaAttDef attdef = (SchemaAttDef)attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID)
{
//we only register the XmlElement based on their Prefix/LocalName and skip the namespace
doc.AddIdInfo(
doc.AddXmlName(elementDecl.Prefix, elementDecl.Name.Name, string.Empty, null),
doc.AddAttrXmlName(attdef.Prefix, attdef.Name.Name, string.Empty, null));
break;
}
}
}
}
}
}
}
internal void ParseDocumentType(XmlDocumentType dtNode)
{
XmlDocument ownerDocument = dtNode.OwnerDocument;
if (ownerDocument.HasSetResolver)
{
this.ParseDocumentType(dtNode, true, ownerDocument.GetResolver());
}
else
{
this.ParseDocumentType(dtNode, false, null);
}
}
private void ParseDocumentType ( XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver ) {
this.doc = dtNode.OwnerDocument;
XmlNameTable nt = this.doc.NameTable;
XmlNamespaceManager mgr = new XmlNamespaceManager( nt );
XmlParserContext pc = new XmlParserContext( nt,
mgr,
dtNode.Name,
dtNode.PublicId,
dtNode.SystemId,
dtNode.InternalSubset,
this.doc.BaseURI,
String.Empty,
XmlSpace.None
);
XmlValidatingReader vr = new XmlValidatingReader( "", XmlNodeType.Element, pc );
vr.Namespaces = dtNode.ParseWithNamespaces;
if ( bUseResolver )
vr.XmlResolver = resolver;
vr.ValidationType = ValidationType.None;
vr.Read();
LoadDocumentType( vr, dtNode );
vr.Close();
}
public override string GetAttribute(int attributeIndex)
{
if (NodeType == XmlNodeType.XmlDeclaration)
{
XmlDeclaration decl = current as XmlDeclaration;
if (attributeIndex == 0)
{
return(decl.Version);
}
else if (attributeIndex == 1)
{
if (decl.Encoding != String.Empty)
{
return(decl.Encoding);
}
else if (decl.Standalone != String.Empty)
{
return(decl.Standalone);
}
}
else if (attributeIndex == 2 &&
decl.Encoding != String.Empty && decl.Standalone != null)
{
return(decl.Standalone);
}
throw new ArgumentOutOfRangeException("Index out of range.");
}
else if (NodeType == XmlNodeType.DocumentType)
{
XmlDocumentType doctype = current as XmlDocumentType;
if (attributeIndex == 0)
{
if (doctype.PublicId != "")
{
return(doctype.PublicId);
}
else if (doctype.SystemId != "")
{
return(doctype.SystemId);
}
}
else if (attributeIndex == 1)
{
if (doctype.PublicId == "" && doctype.SystemId != "")
{
return(doctype.SystemId);
}
}
throw new ArgumentOutOfRangeException("Index out of range.");
}
// This is MS.NET bug which returns attributes in spite of EndElement.
if (isEndElement || current == null)
{
return(null);
}
if (attributeIndex < 0 || attributeIndex > AttributeCount)
{
throw new ArgumentOutOfRangeException("Index out of range.");
}
return(ownerLinkedNode.Attributes [attributeIndex].Value);
}
private void LoadDocumentType(IDtdInfo dtdInfo, XmlDocumentType dtNode)
{
SchemaInfo info = dtdInfo as SchemaInfo;
if (info == null)
{
throw new XmlException("Xml_InternalError", string.Empty);
}
dtNode.DtdSchemaInfo = info;
if (info != null)
{
this.doc.DtdSchemaInfo = info;
if (info.Notations != null)
{
foreach (SchemaNotation notation in info.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(notation.Name.Name, notation.Pubid, notation.SystemLiteral, this.doc));
}
}
if (info.GeneralEntities != null)
{
foreach (SchemaEntity entity in info.GeneralEntities.Values)
{
XmlEntity node = new XmlEntity(entity.Name.Name, entity.Text, entity.Pubid, entity.Url, entity.NData.IsEmpty ? null : entity.NData.Name, this.doc);
node.SetBaseURI(entity.DeclaredURI);
dtNode.Entities.SetNamedItem(node);
}
}
if (info.ParameterEntities != null)
{
foreach (SchemaEntity entity3 in info.ParameterEntities.Values)
{
XmlEntity entity4 = new XmlEntity(entity3.Name.Name, entity3.Text, entity3.Pubid, entity3.Url, entity3.NData.IsEmpty ? null : entity3.NData.Name, this.doc);
entity4.SetBaseURI(entity3.DeclaredURI);
dtNode.Entities.SetNamedItem(entity4);
}
}
this.doc.Entities = dtNode.Entities;
IDictionaryEnumerator enumerator = info.ElementDecls.GetEnumerator();
if (enumerator != null)
{
enumerator.Reset();
while (enumerator.MoveNext())
{
SchemaElementDecl decl = (SchemaElementDecl) enumerator.Value;
if (decl.AttDefs != null)
{
IDictionaryEnumerator enumerator2 = decl.AttDefs.GetEnumerator();
while (enumerator2.MoveNext())
{
SchemaAttDef def = (SchemaAttDef) enumerator2.Value;
if (def.Datatype.TokenizedType == XmlTokenizedType.ID)
{
this.doc.AddIdInfo(this.doc.AddXmlName(decl.Prefix, decl.Name.Name, string.Empty, null), this.doc.AddAttrXmlName(def.Prefix, def.Name.Name, string.Empty, null));
continue;
}
}
}
}
}
}
}
private void LoadDocumentType(IDtdInfo dtdInfo, XmlDocumentType dtNode)
{
SchemaInfo?schInfo = dtdInfo as SchemaInfo;
if (schInfo == null)
{
throw new XmlException(SR.Xml_InternalError, string.Empty);
}
dtNode.DtdSchemaInfo = schInfo;
if (schInfo != null)
{
//set the schema information into the document
_doc !.DtdSchemaInfo = schInfo;
// Notation hashtable
if (schInfo.Notations != null)
{
foreach (SchemaNotation scNot in schInfo.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, _doc));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.GeneralEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
if (schInfo.ParameterEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.ParameterEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
_doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
foreach (KeyValuePair <XmlQualifiedName, SchemaElementDecl> elementDecls in schInfo.ElementDecls)
{
SchemaElementDecl elementDecl = elementDecls.Value;
if (elementDecl.AttDefs != null)
{
foreach (KeyValuePair <XmlQualifiedName, SchemaAttDef> attDefs in elementDecl.AttDefs)
{
SchemaAttDef attdef = attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID)
{
//we only register the XmlElement based on their Prefix/LocalName and skip the namespace
_doc.AddIdInfo(
_doc.AddXmlName(elementDecl.Prefix, elementDecl.Name.Name, string.Empty, null),
_doc.AddAttrXmlName(attdef.Prefix, attdef.Name.Name, string.Empty, null));
break;
}
}
}
}
}
}
private XmlNode ImportNodeInternal(XmlNode node, bool deep)
{
XmlNode newNode = null;
if (node == null)
{
throw new InvalidOperationException(SR.Xdom_Import_NullNode);
}
else
{
switch (node.NodeType)
{
case XmlNodeType.Element:
newNode = CreateElement(node.Prefix, node.LocalName, node.NamespaceURI);
ImportAttributes(node, newNode);
if (deep)
{
ImportChildren(node, newNode, deep);
}
break;
case XmlNodeType.Attribute:
Debug.Assert(((XmlAttribute)node).Specified);
newNode = CreateAttribute(node.Prefix, node.LocalName, node.NamespaceURI);
ImportChildren(node, newNode, true);
break;
case XmlNodeType.Text:
newNode = CreateTextNode(node.Value);
break;
case XmlNodeType.Comment:
newNode = CreateComment(node.Value);
break;
case XmlNodeType.ProcessingInstruction:
newNode = CreateProcessingInstruction(node.Name, node.Value);
break;
case XmlNodeType.XmlDeclaration:
XmlDeclaration decl = (XmlDeclaration)node;
newNode = CreateXmlDeclaration(decl.Version, decl.Encoding, decl.Standalone);
break;
case XmlNodeType.CDATA:
newNode = CreateCDataSection(node.Value);
break;
case XmlNodeType.DocumentType:
XmlDocumentType docType = (XmlDocumentType)node;
newNode = CreateDocumentType(docType.Name, docType.PublicId, docType.SystemId, docType.InternalSubset);
break;
case XmlNodeType.DocumentFragment:
newNode = CreateDocumentFragment();
if (deep)
{
ImportChildren(node, newNode, deep);
}
break;
case XmlNodeType.EntityReference:
newNode = CreateEntityReference(node.Name);
// we don't import the children of entity reference because they might result in different
// children nodes given different namespace context in the new document.
break;
case XmlNodeType.Whitespace:
newNode = CreateWhitespace(node.Value);
break;
case XmlNodeType.SignificantWhitespace:
newNode = CreateSignificantWhitespace(node.Value);
break;
default:
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, SR.Xdom_Import, node.NodeType.ToString()));
}
}
return(newNode);
}
#pragma warning restore 618
private XmlParserContext GetContext(XmlNode node)
{
String lang = null;
XmlSpace spaceMode = XmlSpace.None;
XmlDocumentType docType = this.doc.DocumentType;
String baseURI = this.doc.BaseURI;
//constructing xmlnamespace
Hashtable prefixes = new Hashtable();
XmlNameTable nt = this.doc.NameTable;
XmlNamespaceManager mgr = new XmlNamespaceManager(nt);
bool bHasDefXmlnsAttr = false;
// Process all xmlns, xmlns:prefix, xml:space and xml:lang attributes
while (node != null && node != doc)
{
if (node is XmlElement && ((XmlElement)node).HasAttributes)
{
mgr.PushScope();
foreach (XmlAttribute attr in ((XmlElement)node).Attributes)
{
if (attr.Prefix == doc.strXmlns && prefixes.Contains(attr.LocalName) == false)
{
// Make sure the next time we will not add this prefix
prefixes.Add(attr.LocalName, attr.LocalName);
mgr.AddNamespace(attr.LocalName, attr.Value);
}
else if (!bHasDefXmlnsAttr && attr.Prefix.Length == 0 && attr.LocalName == doc.strXmlns)
{
// Save the case xmlns="..." where xmlns is the LocalName
mgr.AddNamespace(String.Empty, attr.Value);
bHasDefXmlnsAttr = true;
}
else if (spaceMode == XmlSpace.None && attr.Prefix == doc.strXml && attr.LocalName == doc.strSpace)
{
// Save xml:space context
if (attr.Value == "default")
{
spaceMode = XmlSpace.Default;
}
else if (attr.Value == "preserve")
{
spaceMode = XmlSpace.Preserve;
}
}
else if (lang == null && attr.Prefix == doc.strXml && attr.LocalName == doc.strLang)
{
// Save xml:lag context
lang = attr.Value;
}
}
}
node = node.ParentNode;
}
return(new XmlParserContext(
nt,
mgr,
(docType == null) ? null : docType.Name,
(docType == null) ? null : docType.PublicId,
(docType == null) ? null : docType.SystemId,
(docType == null) ? null : docType.InternalSubset,
baseURI,
lang,
spaceMode
));
}
public string GetDocumentTypeAttr(XmlDocumentType docType, string name)
{
if (name == "PUBLIC")
{
return docType.PublicId;
}
if (name == "SYSTEM")
{
return docType.SystemId;
}
return null;
}
private void ParseDocumentType(XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver)
{
this.doc = dtNode.OwnerDocument;
XmlParserContext context = new XmlParserContext(null, new XmlNamespaceManager(this.doc.NameTable), null, null, null, null, this.doc.BaseURI, string.Empty, XmlSpace.None);
XmlTextReaderImpl reader = new XmlTextReaderImpl("", XmlNodeType.Element, context) {
Namespaces = dtNode.ParseWithNamespaces
};
if (bUseResolver)
{
reader.XmlResolver = resolver;
}
IDtdParser parser = DtdParser.Create();
XmlTextReaderImpl.DtdParserProxy adapter = new XmlTextReaderImpl.DtdParserProxy(reader);
IDtdInfo dtdInfo = parser.ParseFreeFloatingDtd(this.doc.BaseURI, dtNode.Name, dtNode.PublicId, dtNode.SystemId, dtNode.InternalSubset, adapter);
this.LoadDocumentType(dtdInfo, dtNode);
}
internal void ParseDocumentType ( XmlDocumentType dtNode ) {
XmlDocument doc = dtNode.OwnerDocument;
//if xmlresolver is set on doc, use that one, otherwise use the default one being created by xmlvalidatingreader
if ( doc.HasSetResolver )
ParseDocumentType( dtNode, true, doc.GetResolver() );
else
ParseDocumentType( dtNode, false, null );
}
internal DOMDocumentType(XmlDocumentType/*!*/ xmlDocumentType)
: base(ScriptContext.CurrentContext, true)
{
this.XmlDocumentType = xmlDocumentType;
}
private void LoadDocumentType( XmlValidatingReader vr , XmlDocumentType dtNode ) {
SchemaInfo schInfo = vr.GetSchemaInfo();
if (schInfo != null) {
//set the schema information into the document
doc.SchemaInformation = schInfo;
// Notation hashtable
if (schInfo.Notations != null) {
foreach( SchemaNotation scNot in schInfo.Notations.Values ) {
dtNode.Notations.SetNamedItem(new XmlNotation( scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, doc ));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null) {
foreach( SchemaEntity scEnt in schInfo.GeneralEntities.Values ) {
XmlEntity ent = new XmlEntity( scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc );
ent.SetBaseURI( scEnt.DeclaredURI );
dtNode.Entities.SetNamedItem( ent );
}
}
if (schInfo.ParameterEntities != null) {
foreach( SchemaEntity scEnt in schInfo.ParameterEntities.Values ) {
XmlEntity ent = new XmlEntity( scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc );
ent.SetBaseURI( scEnt.DeclaredURI );
dtNode.Entities.SetNamedItem( ent );
}
}
doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
IDictionaryEnumerator elementDecls = schInfo.ElementDecls.GetEnumerator();
if (elementDecls != null) {
elementDecls.Reset();
while (elementDecls.MoveNext()) {
SchemaElementDecl elementDecl = (SchemaElementDecl)elementDecls.Value;
if (elementDecl.AttDefs != null) {
IDictionaryEnumerator attDefs = elementDecl.AttDefs.GetEnumerator();
while (attDefs.MoveNext()) {
SchemaAttDef attdef = (SchemaAttDef)attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID) {
doc.AddIdInfo(
doc.GetXmlName(elementDecl.Name.Name, elementDecl.Name.Namespace),
doc.GetXmlName(attdef.Name.Name, attdef.Name.Namespace));
break;
}
}
}
}
}
}
}
private void ParseDocumentType ( XmlDocumentType dtNode, bool bUseResolver, XmlResolver resolver ) {
this.doc = dtNode.OwnerDocument;
XmlNameTable nt = this.doc.NameTable;
XmlNamespaceManager mgr = new XmlNamespaceManager( nt );
SchemaInfo schemaInfo = DtdParser.Parse( nt, mgr, dtNode.ParseWithNamespaces, this.doc.BaseURI, dtNode.Name, dtNode.PublicId,
dtNode.SystemId, dtNode.InternalSubset, bUseResolver, resolver );
LoadDocumentType( schemaInfo, dtNode );
}
public XmlDocumentTypeWrapper(XmlDocumentType documentType)
: base(documentType)
{
_documentType = documentType;
}
/// <summary>
/// Compares properties of the doctype declaration.
/// </summary>
private ComparisonResult CompareDocTypes(XmlDocumentType control,
XPathContext controlContext,
XmlDocumentType test,
XPathContext testContext)
{
ComparisonResult lastResult =
Compare(new Comparison(ComparisonType.DOCTYPE_NAME,
control, GetXPath(controlContext),
control.Name,
test, GetXPath(testContext),
test.Name));
if (lastResult == ComparisonResult.CRITICAL) {
return lastResult;
}
lastResult =
Compare(new Comparison(ComparisonType.DOCTYPE_PUBLIC_ID,
control, GetXPath(controlContext),
control.PublicId,
test, GetXPath(testContext),
test.PublicId));
if (lastResult == ComparisonResult.CRITICAL) {
return lastResult;
}
return Compare(new Comparison(ComparisonType.DOCTYPE_SYSTEM_ID,
control, GetXPath(controlContext),
control.SystemId,
test, GetXPath(testContext),
test.SystemId));
}
