+2002-11-14 Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
+
+ * XmlDocument.cs : unified all constructors, added ConventionalParser,
+ implemented CloneNode() and CreateEntityReference(),
+ * XmlEntityReference.cs : set_Value, WriteContentTo, WriteTo
+ set BaseURI to MonoTODO
+ * XmlNode.cs : implemented PrependChild, modified ConstructDOM,
+ bugfix InsertAfter (incorrect prepending) and InsertBefore
+ (more than one DocumentElements hadn't caused errors)
+ * XmlTextReader.cs : unified all constructors,
+ added internal SetReaderContext(), SetReaderFragment()
+ bugfix (syntax check of PUBLIC / getting internal subset)
+
2002-11-13 Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
XmlAttribute.cs : set_InnerText, set_InnerXml, some check for set_Prefix
// Jason Diamond <jason@injektilo.org>
// Miguel de Icaza (miguel@ximian.com)
// Duncan Mak (duncan@ximian.com)
+// Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
//
// (C) 2001 Daniel Weber
-// (C) 2002 Kral Ferch, Jason Diamond, Miguel de Icaza, Duncan Mak
+// (C) 2002 Kral Ferch, Jason Diamond, Miguel de Icaza, Duncan Mak,
+// Atsushi Enomoto
//
using System;
string baseURI = String.Empty;
XmlImplementation implementation;
bool preserveWhitespace = true; // Its true initial value is false.
+ WeakReference conventionalXmlTextReader;
#endregion
#region Constructors
- public XmlDocument () : base (null)
+ public XmlDocument () : this (null, null)
{
- implementation = new XmlImplementation();
- nameTable = implementation.internalNameTable;
- AddDefaultNameTableKeys();
}
- protected internal XmlDocument (XmlImplementation imp) : base (null)
+ protected internal XmlDocument (XmlImplementation imp) : this (imp, null)
{
- implementation = imp;
- nameTable = imp.internalNameTable;
- AddDefaultNameTableKeys();
}
- public XmlDocument (XmlNameTable nt) : base (null)
+ public XmlDocument (XmlNameTable nt) : this (null, nt)
{
- implementation = new XmlImplementation();
- implementation.internalNameTable = nt;
- nameTable = nt;
- AddDefaultNameTableKeys();
}
+ XmlDocument (XmlImplementation impl, XmlNameTable nt) : base (null)
+ {
+ implementation = (impl != null) ? impl : new XmlImplementation ();
+ nameTable = (nt != null) ? nt : implementation.internalNameTable;
+ AddDefaultNameTableKeys ();
+ }
#endregion
#region Events
}
}
+ // Used to read 'InnerXml's for its descendants at any place.
+ internal XmlTextReader ConventionalParser {
+ get {
+ if(conventionalXmlTextReader == null)
+ conventionalXmlTextReader = new WeakReference (null);
+ if(!conventionalXmlTextReader.IsAlive) {
+ XmlTextReader reader = new XmlTextReader ((TextReader)null);
+ conventionalXmlTextReader.Target = reader;
+ }
+ return (XmlTextReader)conventionalXmlTextReader.Target;
+ }
+ }
+
public XmlElement DocumentElement {
get {
XmlNode node = FirstChild;
return base.InnerXml;
}
set { // reason for overriding
- this.LoadXml(value);
+ this.LoadXml (value);
}
}
[MonoTODO]
public virtual XmlResolver XmlResolver {
- set { throw new NotImplementedException(); }
+ set { throw new NotImplementedException (); }
}
#endregion
#region Methods
- [MonoTODO]
+ [MonoTODO("Should BaseURI be cloned?")]
public override XmlNode CloneNode (bool deep)
{
- throw new NotImplementedException ();
+ XmlDocument doc = implementation.CreateDocument ();
+ doc.PreserveWhitespace = PreserveWhitespace; // required?
+ if(deep)
+ {
+ foreach(XmlNode n in ChildNodes)
+ doc.AppendChild (doc.ImportNode (n, deep));
+ }
+ return doc;
}
public XmlAttribute CreateAttribute (string name)
public virtual XmlComment CreateComment (string data)
{
- return new XmlComment(data, this);
+ return new XmlComment (data, this);
}
[MonoTODO]
public virtual XmlDocumentFragment CreateDocumentFragment ()
{
- return new XmlDocumentFragment(this);
+ return new XmlDocumentFragment (this);
}
public virtual XmlDocumentType CreateDocumentType (string name, string publicId,
return new XmlElement (prefix != null ? prefix : String.Empty, localName, namespaceURI != null ? namespaceURI : String.Empty, this);
}
- [MonoTODO]
public virtual XmlEntityReference CreateEntityReference (string name)
{
- throw new NotImplementedException ();
+ return new XmlEntityReference (name, this);
}
[MonoTODO]
case XmlNodeType.Attribute:
{
XmlAttribute src_att = node as XmlAttribute;
- XmlAttribute dst_att = this.CreateAttribute(src_att.Prefix, src_att.LocalName, src_att.NamespaceURI);
+ XmlAttribute dst_att = this.CreateAttribute (src_att.Prefix, src_att.LocalName, src_att.NamespaceURI);
dst_att.Value = src_att.Value; // always explicitly specified (whether source is specified or not)
return dst_att;
}
case XmlNodeType.CDATA:
- return this.CreateCDataSection(node.Value);
+ return this.CreateCDataSection (node.Value);
case XmlNodeType.Comment:
- return this.CreateComment(node.Value);
+ return this.CreateComment (node.Value);
case XmlNodeType.Document:
- throw new XmlException("Document cannot be imported.");
+ throw new XmlException ("Document cannot be imported.");
case XmlNodeType.DocumentFragment:
{
- XmlDocumentFragment df = this.CreateDocumentFragment();
+ XmlDocumentFragment df = this.CreateDocumentFragment ();
if(deep)
{
foreach(XmlNode n in node.ChildNodes)
{
- df.AppendChild(this.ImportNode(n, deep));
+ df.AppendChild (this.ImportNode (n, deep));
}
}
return df;
}
case XmlNodeType.DocumentType:
- throw new XmlException("DocumentType cannot be imported.");
+ throw new XmlException ("DocumentType cannot be imported.");
case XmlNodeType.Element:
{
XmlElement src = (XmlElement)node;
- XmlElement dst = this.CreateElement(src.Prefix, src.LocalName, src.NamespaceURI);
+ XmlElement dst = this.CreateElement (src.Prefix, src.LocalName, src.NamespaceURI);
foreach(XmlAttribute attr in src.Attributes)
{
if(attr.Specified) // copies only specified attributes
- dst.SetAttributeNode((XmlAttribute)this.ImportNode(attr, deep));
+ dst.SetAttributeNode ((XmlAttribute)this.ImportNode (attr, deep));
if(DocumentType != null)
{
// TODO: create default attribute values
if(deep)
{
foreach(XmlNode n in src.ChildNodes)
- dst.AppendChild(this.ImportNode(n, deep));
+ dst.AppendChild (this.ImportNode (n, deep));
}
return dst;
}
case XmlNodeType.Entity:
throw new NotImplementedException (); // TODO
- // [2002.10.14] CreateEntityReference not implemented.
case XmlNodeType.EntityReference:
- throw new NotImplementedException("ImportNode of EntityReference not implemented mainly because CreateEntityReference was implemented in the meantime.");
-// return this.CreateEntityReference(node.Name);
+ return this.CreateEntityReference (node.Name);
case XmlNodeType.None:
throw new XmlException ("Illegal ImportNode call for NodeType.None");
case XmlNodeType.ProcessingInstruction:
XmlProcessingInstruction pi = node as XmlProcessingInstruction;
- return this.CreateProcessingInstruction(pi.Target, pi.Data);
+ return this.CreateProcessingInstruction (pi.Target, pi.Data);
case XmlNodeType.SignificantWhitespace:
- return this.CreateSignificantWhitespace(node.Value);
+ return this.CreateSignificantWhitespace (node.Value);
case XmlNodeType.Text:
- return this.CreateTextNode(node.Value);
+ return this.CreateTextNode (node.Value);
case XmlNodeType.Whitespace:
- return this.CreateWhitespace(node.Value);
+ return this.CreateWhitespace (node.Value);
case XmlNodeType.XmlDeclaration:
XmlDeclaration srcDecl = node as XmlDeclaration;
- return this.CreateXmlDeclaration(srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone);
+ return this.CreateXmlDeclaration (srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone);
default:
throw new NotImplementedException ();
throw new NotImplementedException ();
}
- [MonoTODO ("Verify what encoding is used by default; Should use PreserveWhiteSpace")]
public virtual void Save(Stream outStream)
{
- // To implementor: utf-8 is OK, at least for (ginga's) Japanese environment.
XmlTextWriter xmlWriter = new XmlTextWriter (outStream, Encoding.UTF8);
WriteContentTo (xmlWriter);
xmlWriter.Close ();
}
- [MonoTODO ("Verify what encoding is used by default; Should use PreseveWhiteSpace")]
public virtual void Save (string filename)
{
- // To implementor: utf-8 is OK, at least for (ginga's) Japanese environment.
XmlTextWriter xmlWriter = new XmlTextWriter (filename, Encoding.UTF8);
WriteContentTo (xmlWriter);
xmlWriter.Close ();
xmlWriter.Flush ();
}
- [MonoTODO ("Should preserve white space if PreserveWhisspace is set")]
public virtual void Save (XmlWriter xmlWriter)
{
//
public override void WriteContentTo (XmlWriter w)
{
- foreach(XmlNode childNode in ChildNodes)
- childNode.WriteTo(w);
+ foreach(XmlNode childNode in ChildNodes) {
+ childNode.WriteTo (w);
+ if(!PreserveWhitespace) {
+ w.WriteRaw ("\n");
+ }
+ }
}
public override void WriteTo (XmlWriter w)
{
- WriteContentTo(w);
+ WriteContentTo (w);
}
- private void AddDefaultNameTableKeys()
+ private void AddDefaultNameTableKeys ()
{
// The following keys are default of MS .NET Framework
- nameTable.Add("#text");
- nameTable.Add("xml");
- nameTable.Add("xmlns");
- nameTable.Add("#entity");
- nameTable.Add("#document-fragment");
- nameTable.Add("#comment");
- nameTable.Add("space");
- nameTable.Add("id");
- nameTable.Add("#whitespace");
- nameTable.Add("http://www.w3.org/2000/xmlns/");
- nameTable.Add("#cdata-section");
- nameTable.Add("lang");
- nameTable.Add("#document");
- nameTable.Add("#significant-whitespace");
+ nameTable.Add ("#text");
+ nameTable.Add ("xml");
+ nameTable.Add ("xmlns");
+ nameTable.Add ("#entity");
+ nameTable.Add ("#document-fragment");
+ nameTable.Add ("#comment");
+ nameTable.Add ("space");
+ nameTable.Add ("id");
+ nameTable.Add ("#whitespace");
+ nameTable.Add ("http://www.w3.org/2000/xmlns/");
+ nameTable.Add ("#cdata-section");
+ nameTable.Add ("lang");
+ nameTable.Add ("#document");
+ nameTable.Add ("#significant-whitespace");
}
#endregion
}
// Properties\r
[MonoTODO]\r
public override string BaseURI {\r
- get { return null; }\r
+ get { throw new NotImplementedException (); }\r
}\r
\r
public override bool IsReadOnly {\r
\r
public override string Value {\r
get { return null; } // always return null here.\r
- [MonoTODO]\r
- set { throw new NotImplementedException (); }\r
+ set {\r
+ throw new XmlException ("entity reference cannot be set value.");\r
+ }\r
}\r
\r
// Methods\r
return new XmlEntityReference ("", OwnerDocument);\r
}\r
\r
- [MonoTODO]\r
public override void WriteContentTo (XmlWriter w)\r
{\r
- throw new NotImplementedException();\r
+ // nothing to write for this object.\r
}\r
\r
- [MonoTODO]\r
public override void WriteTo (XmlWriter w)\r
{\r
- throw new NotImplementedException();\r
+ w.WriteRaw("&");\r
+ w.WriteName(Name);\r
+ w.WriteRaw(";");\r
}\r
}\r
}\r
#region Properties
- public virtual XmlAttributeCollection Attributes
- {
+ public virtual XmlAttributeCollection Attributes {
get { return null; }
}
- public virtual string BaseURI
- {
+ public virtual string BaseURI {
get { return ParentNode.BaseURI; }
}
public virtual XmlNodeList ChildNodes {
get {
- return new XmlNodeListChildren(this);
+ return new XmlNodeListChildren (this);
}
}
get { return LastChild != null; }
}
- [MonoTODO]
+ [MonoTODO("confirm whether this way is right for each not-overriden types.")]
public virtual string InnerText {
get {
StringBuilder builder = new StringBuilder ();
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
- WriteContentTo(xtw);
+ WriteContentTo (xtw);
- return sw.GetStringBuilder().ToString();
+ return sw.GetStringBuilder ().ToString ();
}
set { throw new NotImplementedException (); }
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
- WriteTo(xtw);
+ WriteTo (xtw);
- return sw.GetStringBuilder().ToString();
+ return sw.GetStringBuilder ().ToString ();
}
}
public virtual XmlNode AppendChild (XmlNode newChild)
{
// I assume that AppendChild(n) equals to InsertAfter(n, this.LastChild) or InsertBefore(n, null)
- return InsertBefore(newChild, null);
+ return InsertBefore (newChild, null);
// Below are formerly used logic.
/* XmlDocument ownerDoc = (NodeType == XmlNodeType.Document) ? (XmlDocument)this : OwnerDocument;
for(int i=0; i<x; i++)
{
// When this logic became to remove children in order, then index will have never to increments.
- XmlNode n = newChild.ChildNodes[0];
+ XmlNode n = newChild.ChildNodes [0];
this.AppendChild(n); // recursively invokes events. (It is compatible with MS implementation.)
}
}
public virtual XmlNode Clone ()
{
// By MS document, it is equivalent to CloneNode(true).
- return this.CloneNode(true);
+ return this.CloneNode (true);
}
public abstract XmlNode CloneNode (bool deep);
[MonoTODO]
public XPathNavigator CreateNavigator ()
{
- return new XmlDocumentNavigator(this);
+ return new XmlDocumentNavigator (this);
}
public IEnumerator GetEnumerator ()
{
- return new XmlNodeListChildren(this).GetEnumerator();
+ return new XmlNodeListChildren (this).GetEnumerator ();
}
-// [MonoTODO]
+ [MonoTODO("performance problem.")]
public virtual string GetNamespaceOfPrefix (string prefix)
{
- XmlNamespaceManager nsmgr = ConstructNamespaceManager();
- return nsmgr.LookupNamespace(prefix);
-// throw new NotImplementedException ();
+ XmlNamespaceManager nsmgr = ConstructNamespaceManager ();
+ return nsmgr.LookupNamespace (prefix);
}
-// [MonoTODO]
+ [MonoTODO("performance problem.")]
public virtual string GetPrefixOfNamespace (string namespaceURI)
{
- XmlNamespaceManager nsmgr = ConstructNamespaceManager();
- return nsmgr.LookupPrefix(namespaceURI);
-// throw new NotImplementedException ();
+ XmlNamespaceManager nsmgr = ConstructNamespaceManager ();
+ return nsmgr.LookupPrefix (namespaceURI);
}
object ICloneable.Clone ()
return GetEnumerator ();
}
- [MonoTODO]
public virtual XmlNode InsertAfter (XmlNode newChild, XmlNode refChild)
{
// I assume that insertAfter(n1, n2) equals to InsertBefore(n1, n2.PreviousSibling).
// I took this way because rather than calling InsertAfter() from InsertBefore()
// because current implementation of 'NextSibling' looks faster than 'PreviousSibling'.
- XmlNode argNode = (refChild == null) ? null : refChild.NextSibling;
- return InsertBefore(newChild, argNode);
+ XmlNode argNode = null;
+ if(refChild != null)
+ argNode = refChild.NextSibling;
+ else if(ChildNodes.Count > 0)
+ argNode = FirstChild;
+ return InsertBefore (newChild, argNode);
}
- [MonoTODO]
public virtual XmlNode InsertBefore (XmlNode newChild, XmlNode refChild)
{
XmlDocument ownerDoc = (NodeType == XmlNodeType.Document) ? (XmlDocument)this : OwnerDocument;
- if (NodeType == XmlNodeType.Document || NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Attribute || NodeType == XmlNodeType.DocumentFragment)
- {
+ if (NodeType == XmlNodeType.Document || NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Attribute || NodeType == XmlNodeType.DocumentFragment) {
if (IsReadOnly)
throw new ArgumentException ("The specified node is readonly.");
if (newChild.OwnerDocument != ownerDoc)
throw new ArgumentException ("Can't append a node created by another document.");
- if(refChild != null)
- {
+ if(refChild != null) {
if(newChild.OwnerDocument != refChild.OwnerDocument)
throw new ArgumentException ("argument nodes are on the different documents.");
- if(refChild == ownerDoc.DocumentElement && (newChild is XmlElement || newChild is XmlCharacterData || newChild is XmlEntityReference))
- throw new XmlException("cannot insert this node to this position.");
}
+ if(this == ownerDoc && ownerDoc.DocumentElement != null && (newChild is XmlElement || newChild is XmlCharacterData || newChild is XmlEntityReference))
+ throw new XmlException ("cannot insert this node to this position.");
// checking validity finished. then appending...
ownerDoc.onNodeInserting (newChild, this);
if(newChild.ParentNode != null)
- newChild.ParentNode.RemoveChild(newChild);
+ newChild.ParentNode.RemoveChild (newChild);
- if(newChild.NodeType == XmlNodeType.DocumentFragment)
- {
+ if(newChild.NodeType == XmlNodeType.DocumentFragment) {
int x = newChild.ChildNodes.Count;
- for(int i=0; i<x; i++)
- {
- // When this logic became to remove children in order, then index will have never to increments.
- XmlNode n = newChild.ChildNodes[0];
- this.InsertBefore(n, refChild); // recursively invokes events. (It is compatible with MS implementation.)
+ for(int i=0; i<x; i++) {
+ XmlNode n = newChild.ChildNodes [0];
+ this.InsertBefore (n, refChild); // recursively invokes events. (It is compatible with MS implementation.)
}
}
- else
- {
+ else {
XmlLinkedNode newLinkedChild = (XmlLinkedNode) newChild;
XmlLinkedNode lastLinkedChild = LastLinkedChild;
newLinkedChild.parentNode = this;
- if(refChild == null)
- {
+ if(refChild == null) {
// append last, so:
// * set nextSibling of previous lastchild to newChild
// * set lastchild = newChild
// * set next of newChild to firstChild
- if(LastLinkedChild != null)
- {
+ if(LastLinkedChild != null) {
XmlLinkedNode formerFirst = FirstChild as XmlLinkedNode;
LastLinkedChild.NextLinkedSibling = newLinkedChild;
LastLinkedChild = newLinkedChild;
newLinkedChild.NextLinkedSibling = formerFirst;
}
- else
- {
+ else {
LastLinkedChild = newLinkedChild;
LastLinkedChild.NextLinkedSibling = newLinkedChild; // FirstChild
}
}
- else
- {
+ else {
// append not last, so:
// * if newchild is first, then set next of lastchild is newChild.
// otherwise, set next of previous sibling to newChild
return newChild;
}
else
- throw new InvalidOperationException();
+ throw new InvalidOperationException ();
}
[MonoTODO]
throw new NotImplementedException ();
}
- [MonoTODO]
public virtual XmlNode PrependChild (XmlNode newChild)
{
- throw new NotImplementedException ();
+ return InsertAfter (newChild, null);
}
public virtual void RemoveAll ()
public virtual XmlNode RemoveChild (XmlNode oldChild)
{
if(oldChild.ParentNode != this)
- throw new XmlException("specified child is not child of this node.");
+ throw new XmlException ("specified child is not child of this node.");
OwnerDocument.onNodeRemoving (oldChild, oldChild.ParentNode);
- if (NodeType == XmlNodeType.Document || NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Attribute || NodeType == XmlNodeType.DocumentFragment)
- {
+ if (NodeType == XmlNodeType.Document || NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Attribute || NodeType == XmlNodeType.DocumentFragment) {
if (IsReadOnly)
- throw new ArgumentException();
+ throw new ArgumentException ();
- if (Object.ReferenceEquals(LastLinkedChild, LastLinkedChild.NextLinkedSibling) && Object.ReferenceEquals(LastLinkedChild, oldChild))
+ if (Object.ReferenceEquals (LastLinkedChild, LastLinkedChild.NextLinkedSibling) && Object.ReferenceEquals (LastLinkedChild, oldChild))
LastLinkedChild = null;
else {
XmlLinkedNode oldLinkedChild = (XmlLinkedNode)oldChild;
XmlLinkedNode beforeLinkedChild = LastLinkedChild;
- while (!Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, LastLinkedChild) && !Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, oldLinkedChild))
+ while (!Object.ReferenceEquals (beforeLinkedChild.NextLinkedSibling, LastLinkedChild) && !Object.ReferenceEquals (beforeLinkedChild.NextLinkedSibling, oldLinkedChild))
beforeLinkedChild = beforeLinkedChild.NextLinkedSibling;
- if (!Object.ReferenceEquals(beforeLinkedChild.NextLinkedSibling, oldLinkedChild))
- throw new ArgumentException();
+ if (!Object.ReferenceEquals (beforeLinkedChild.NextLinkedSibling, oldLinkedChild))
+ throw new ArgumentException ();
beforeLinkedChild.NextLinkedSibling = oldLinkedChild.NextLinkedSibling;
oldLinkedChild.NextLinkedSibling = null;
return oldChild;
}
else
- throw new ArgumentException();
+ throw new ArgumentException ();
}
[MonoTODO]
public abstract void WriteTo (XmlWriter w);
// It parses with XmlReader and then construct DOM of the parsed contents.
- internal void ConstructDOM(XmlReader xmlReader, XmlNode currentNode)
+ internal void ConstructDOM (XmlReader xmlReader, XmlNode currentNode)
{
// I am not confident whether this method should be placed in this class or not...
// Please verify its validity and then erase this comment;-)
XmlNode newNode;
XmlDocument doc = currentNode is XmlDocument ? (XmlDocument)currentNode : currentNode.OwnerDocument;
// Below are 'almost' copied from XmlDocument.Load(XmlReader xmlReader)
- while (xmlReader.Read ())
- {
- switch (xmlReader.NodeType)
- {
- case XmlNodeType.CDATA:
- newNode = doc.CreateCDataSection(xmlReader.Value);
- currentNode.AppendChild (newNode);
- break;
+ while (xmlReader.Read ()) {
+ switch (xmlReader.NodeType) {
+ case XmlNodeType.CDATA:
+ newNode = doc.CreateCDataSection (xmlReader.Value);
+ currentNode.AppendChild (newNode);
+ break;
- case XmlNodeType.Comment:
- newNode = doc.CreateComment (xmlReader.Value);
- currentNode.AppendChild (newNode);
- break;
-
- case XmlNodeType.Element:
- XmlElement element = doc.CreateElement (xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
- currentNode.AppendChild (element);
-
- // set the element's attributes.
- while (xmlReader.MoveToNextAttribute ())
- {
- XmlAttribute attribute = doc.CreateAttribute (xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
- attribute.Value = xmlReader.Value;
- element.SetAttributeNode (attribute);
- }
+ case XmlNodeType.Comment:
+ newNode = doc.CreateComment (xmlReader.Value);
+ currentNode.AppendChild (newNode);
+ break;
- xmlReader.MoveToElement ();
+ case XmlNodeType.Element:
+ XmlElement element = doc.CreateElement (xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
+ element.IsEmpty = xmlReader.IsEmptyElement;
+ currentNode.AppendChild (element);
+
+ // set the element's attributes.
+ while (xmlReader.MoveToNextAttribute ()) {
+ XmlAttribute attribute = doc.CreateAttribute (xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI);
+ attribute.Value = xmlReader.Value;
+ element.SetAttributeNode (attribute);
+ }
- // if this element isn't empty, push it onto our "stack".
- if (!xmlReader.IsEmptyElement)
- currentNode = element;
+ xmlReader.MoveToElement ();
- break;
+ // if this element isn't empty, push it onto our "stack".
+ if (!xmlReader.IsEmptyElement)
+ currentNode = element;
- case XmlNodeType.EndElement:
- currentNode = currentNode.ParentNode;
- break;
+ break;
- case XmlNodeType.ProcessingInstruction:
- newNode = doc.CreateProcessingInstruction (xmlReader.Name, xmlReader.Value);
- currentNode.AppendChild (newNode);
- break;
+ case XmlNodeType.EndElement:
+ currentNode = currentNode.ParentNode;
+ break;
+
+ case XmlNodeType.ProcessingInstruction:
+ newNode = doc.CreateProcessingInstruction (xmlReader.Name, xmlReader.Value);
+ currentNode.AppendChild (newNode);
+ break;
+
+ case XmlNodeType.Text:
+ newNode = doc.CreateTextNode (xmlReader.Value);
+ currentNode.AppendChild (newNode);
+ break;
+
+ case XmlNodeType.XmlDeclaration:
+ // empty strings are dummy, then gives over setting value contents to setter.
+ newNode = doc.CreateXmlDeclaration ("1.0" , String.Empty, String.Empty);
+ ((XmlDeclaration)newNode).Value = xmlReader.Value;
+ this.AppendChild (newNode);
+ break;
+
+ case XmlNodeType.DocumentType:
+ XmlTextReader xmlTextReader = xmlReader as XmlTextReader;
+ if(xmlTextReader != null) {
+ XmlDocumentType dtdNode = doc.CreateDocumentType (xmlTextReader.Name, xmlTextReader.publicId, xmlTextReader.systemId, xmlTextReader.Value);
+ this.AppendChild (dtdNode);
+ }
+ else
+ throw new XmlException ("construction of DocumentType node from this XmlReader is not supported.");
+ break;
+
+ case XmlNodeType.EntityReference:
+ newNode = doc.CreateEntityReference (xmlReader.Name);
+ currentNode.AppendChild (newNode);
+ break;
- case XmlNodeType.Text:
- newNode = doc.CreateTextNode (xmlReader.Value);
+ case XmlNodeType.SignificantWhitespace:
+ newNode = doc.CreateSignificantWhitespace (xmlReader.Value);
+ currentNode.AppendChild (newNode);
+ break;
+
+ case XmlNodeType.Whitespace:
+ if(doc.PreserveWhitespace) {
+ newNode = doc.CreateWhitespace (xmlReader.Value);
currentNode.AppendChild (newNode);
- break;
-
- case XmlNodeType.XmlDeclaration:
- // empty strings are dummy, then gives over setting value contents to setter.
- newNode = doc.CreateXmlDeclaration("1.0" , String.Empty, String.Empty);
- ((XmlDeclaration)newNode).Value = xmlReader.Value;
- this.AppendChild(newNode);
- break;
-
- case XmlNodeType.DocumentType:
- XmlTextReader xmlTextReader = xmlReader as XmlTextReader;
- if(xmlTextReader != null)
- {
- XmlDocumentType dtdNode = doc.CreateDocumentType(xmlTextReader.Name, xmlTextReader.publicId, xmlTextReader.systemId, xmlTextReader.Value);
- this.AppendChild(dtdNode);
- }
- else
- throw new XmlException("construction of DocumentType node from this XmlReader is not supported.");
- break;
-
- case XmlNodeType.EntityReference:
- newNode = doc.CreateEntityReference(xmlReader.Name);
- currentNode.AppendChild(newNode);
- break;
-
- case XmlNodeType.SignificantWhitespace:
- newNode = doc.CreateSignificantWhitespace(xmlReader.Value);
- currentNode.AppendChild(newNode);
- break;
-
- case XmlNodeType.Whitespace:
- if(doc.PreserveWhitespace)
- {
- newNode = doc.CreateWhitespace(xmlReader.Value);
- currentNode.AppendChild(newNode);
- }
- break;
+ }
+ break;
}
}
}
// It parses this and all the ancestor elements,
// find 'xmlns' declarations, stores and then return them.
// TODO: tests
- internal XmlNamespaceManager ConstructNamespaceManager()
+ internal XmlNamespaceManager ConstructNamespaceManager ()
{
XmlDocument doc = this is XmlDocument ? (XmlDocument)this : this.OwnerDocument;
- XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
+ XmlNamespaceManager nsmgr = new XmlNamespaceManager (doc.NameTable);
XmlElement el = null;
- switch(this.NodeType)
- {
- case XmlNodeType.Attribute:
- el = ((XmlAttribute)this).OwnerElement;
- break;
- case XmlNodeType.Element:
- el = this as XmlElement;
- break;
- default:
- el = this.ParentNode as XmlElement;
- break;
+ switch(this.NodeType) {
+ case XmlNodeType.Attribute:
+ el = ((XmlAttribute)this).OwnerElement;
+ break;
+ case XmlNodeType.Element:
+ el = this as XmlElement;
+ break;
+ default:
+ el = this.ParentNode as XmlElement;
+ break;
}
- while(el != null)
- {
- foreach(XmlAttribute attr in el.Attributes)
- {
- if(attr.Prefix == "xmlns" || (attr.Name == "xmlns" && attr.Prefix == String.Empty))
- {
- if(nsmgr.LookupNamespace(attr.LocalName) == null )
- {
- nsmgr.AddNamespace(attr.LocalName, attr.Value);
- }
+ while(el != null) {
+ foreach(XmlAttribute attr in el.Attributes) {
+ if(attr.Prefix == "xmlns" || (attr.Name == "xmlns" && attr.Prefix == String.Empty)) {
+ if(nsmgr.LookupNamespace (attr.LocalName) == null )
+ nsmgr.AddNamespace (attr.LocalName, attr.Value);
}
}
// When reached to document, then it will set null value :)
{
}
- [MonoTODO]
public XmlTextReader (Stream input)
+ : this (new StreamReader (input))
{
- // We can share some code in the constructors (at least for this one and next 2)
- XmlNameTable nt = new NameTable ();
- XmlNamespaceManager nsMgr = new XmlNamespaceManager (nt);
- parserContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
- Init ();
- reader = new StreamReader (input);
- can_seek = input.CanSeek;
}
- [MonoTODO]
public XmlTextReader (string url)
+ : this(url, new NameTable ())
{
- XmlNameTable nt = new NameTable ();
- XmlNamespaceManager nsMgr = new XmlNamespaceManager (nt);
- parserContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
- Init ();
- // StreamReader does not support url, only filepath;-)
- reader = new StreamReader(url);
- can_seek = reader.Peek () != -1;
}
- [MonoTODO]
public XmlTextReader (TextReader input)
+ : this (input, new NameTable ())
{
- XmlNameTable nt = new NameTable ();
- XmlNamespaceManager nsMgr = new XmlNamespaceManager (nt);
- parserContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
- Init ();
- reader = input;
- can_seek = input.Peek () != -1;
}
- [MonoTODO]
protected XmlTextReader (XmlNameTable nt)
+ : this (String.Empty, null, XmlNodeType.None, null)
{
- throw new NotImplementedException ();
}
- [MonoTODO]
public XmlTextReader (Stream input, XmlNameTable nt)
+ : this(new StreamReader (input), nt)
{
- XmlNamespaceManager nsMgr = new XmlNamespaceManager (nt);
- parserContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
- Init ();
- reader = new StreamReader (input);
- can_seek = input.CanSeek;
}
- [MonoTODO]
public XmlTextReader (string url, Stream input)
+ : this (url, new StreamReader (input))
{
- throw new NotImplementedException ();
}
- [MonoTODO]
public XmlTextReader (string url, TextReader input)
+ : this (url, input, new NameTable ())
{
- throw new NotImplementedException ();
}
- [MonoTODO]
+ [MonoTODO("Non-filename-url must be supported. Waiting for WebClient")]
public XmlTextReader (string url, XmlNameTable nt)
+ // : this(url, new StreamReader ((Stream)new XmlUrlResolver ().GetEntity (new Uri (url), null, typeof(Stream))), nt)
+ : this (url, new StreamReader (url), nt)
{
- throw new NotImplementedException ();
}
- [MonoTODO]
public XmlTextReader (TextReader input, XmlNameTable nt)
+ : this(String.Empty, input, nt)
{
- XmlNamespaceManager nsMgr = new XmlNamespaceManager (nt);
- parserContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);
- Init ();
- reader = input;
- can_seek = input.Peek () != -1;
}
- [MonoTODO]
public XmlTextReader (Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
+ : this (String.Empty, new StreamReader (xmlFragment), fragType, context)
{
- parserContext = context;
- reader = new StreamReader(xmlFragment);
- can_seek = xmlFragment.CanSeek;
- Init();
-// throw new NotImplementedException ();
}
- [MonoTODO]
public XmlTextReader (string url, Stream input, XmlNameTable nt)
+ : this (url, new StreamReader (input), nt)
{
- throw new NotImplementedException ();
}
- [MonoTODO]
public XmlTextReader (string url, TextReader input, XmlNameTable nt)
+ : this (url, input, XmlNodeType.Document, new XmlParserContext (nt, new XmlNamespaceManager (nt), null, XmlSpace.None))
{
- throw new NotImplementedException ();
}
- [MonoTODO]
+ [MonoTODO("TODO as same as private XmlTextReader(TextReader, XmlNodeType, XmlParserContext)")]
public XmlTextReader (string xmlFragment, XmlNodeType fragType, XmlParserContext context)
+ : this (String.Empty, new StringReader (xmlFragment), fragType, context)
{
- //Waiting for Validating reader for fragType rules.
- parserContext = context;
- Init ();
- reader = new StringReader(xmlFragment);
- can_seek = true;
+ }
+
+ // TODO still remains as described at head of this file,
+ // but it might not be TODO of the constructors...
+ XmlTextReader (string url, TextReader fragment, XmlNodeType fragType, XmlParserContext context)
+ {
+ this.SetReaderContext(url, context);
+ this.SetReaderFragment(fragment, fragType);
}
#endregion
endname = this.Name;
}
- xmlBuffer.Replace(currentTag.ToString (), "");
+ xmlBuffer.Replace (currentTag.ToString (), "");
saveToXmlBuffer = false;
string InnerXml = xmlBuffer.ToString ();
xmlBuffer.Length = 0;
public override string ReadOuterXml ()
{
if (NodeType == XmlNodeType.Attribute) {
- return Name+"=\""+Value+"\"";
+ return Name + "=\"" + Value + "\"";
} else {
saveToXmlBuffer = true;
- xmlBuffer.Append(currentTag.ToString ());
+ xmlBuffer.Append (currentTag.ToString ());
string startname = this.Name;
string endname = string.Empty;
readState = ReadState.Interactive;
internal string publicId;
internal string systemId;
+ internal void SetReaderContext (string url, XmlParserContext context)
+ {
+ parserContext = context;
+ parserContext.BaseURI = url;
+ Init ();
+ }
+
+ internal void SetReaderFragment(TextReader fragment, XmlNodeType fragType)
+ {
+ this.reader = fragment;
+ can_seek = fragment != null && fragment.Peek () != -1;
+/* for future use
+ switch(fragType)
+ {
+ case XmlNodeType.Attribute: // attribute content
+ parserContext.InputState = XmlParserInputState.AttributeValue;
+ break;
+ case XmlNodeType.DocumentFragment: // element content
+ parserContext.InputState = XmlParserInputState.Content;
+ break;
+ case XmlNodeType.Element: // one element
+ parserContext.InputState = XmlParserInputState.StartTag;
+ break;
+ case XmlNodeType.Document: // document content
+ parserContext.InputState = XmlParserInputState.Start;
+ break;
+ default:
+ throw new InvalidOperationException("setting this xml node type not allowed.");
+ }
+*/
+ }
+
private void Init ()
{
readState = ReadState.Initial;
AppendValueChar ((char)ch);
}
+/* for future use
+ if(target == "xml") && parserContext.InputState != XmlParserInputState.Start)
+ throw new XmlException("Xml declaration is not allowed here.");
+ else {
+ parserContext.InputState = XmlParserInputState.DTD; //for future use
+ }
+*/
SetProperties (
target == "xml" ?
XmlNodeType.XmlDeclaration :
string doctypeName = null;
string publicId = String.Empty;
string systemId = String.Empty;
- string internalSubset = String.Empty;
- SkipWhitespace();
- doctypeName = ReadName();
- SkipWhitespace();
+ SkipWhitespace ();
+ doctypeName = ReadName ();
+ SkipWhitespace ();
xmlBuffer.Length = 0;
- switch(PeekChar())
+ switch(PeekChar ())
{
case 'S':
- systemId = ReadSystemLiteral();
+ systemId = ReadSystemLiteral (true);
break;
case 'P':
-/*
- Expect("PUBLIC");
- SkipWhitespace();
- int quoteChar = ReadChar();
- int c = 0;
- while(c != quoteChar)
- {
- c = ReadChar();
- if(c < 0)
- throw new XmlException("Unexpected end of stream in ExternalID.");
- if(c != quoteChar)
- {
- if(XmlChar.IsPubidChar(c)) xmlBuffer.Append((char)c);
- else
- throw new XmlException("character '" + (char)c + "' not allowed for PUBLIC ID");
- }
- }
- publicId = xmlBuffer.ToString();
- */
- publicId = ReadPubidLiteral();
- SkipWhitespace();
- systemId = ReadSystemLiteral();
+ publicId = ReadPubidLiteral ();
+ SkipWhitespace ();
+ systemId = ReadSystemLiteral (false);
break;
}
- SkipWhitespace();
+ SkipWhitespace ();
- if(PeekChar() == '[')
+ if(PeekChar () == '[')
{
// read markupdecl etc. or end of decl
- ReadChar();
+ ReadChar ();
+ xmlBuffer.Length = 0;
saveToXmlBuffer = true;
- do
- {
- ReadDTDInternalSubset();
+ do {
+ ReadDTDInternalSubset ();
} while(nodeType != XmlNodeType.None);
- xmlBuffer.Remove(xmlBuffer.Length -1, 1); // cut off ']'
+ xmlBuffer.Remove (xmlBuffer.Length - 1, 1); // cut off ']'
saveToXmlBuffer = false;
}
// end of DOCTYPE decl.
- SkipWhitespace();
- Expect('>');
+ SkipWhitespace ();
+ Expect ('>');
- internalSubset = xmlBuffer.ToString();
+ parserContext.InternalSubset = xmlBuffer.ToString ();
// set properties for <!DOCTYPE> node
SetProperties (
XmlNodeType.DocumentType, // nodeType
doctypeName, // name
false, // isEmptyElement
- internalSubset, // value
+ parserContext.InternalSubset, // value
true // clearAttributes
);
}
// (if None then ']' was found.)
private void ReadDTDInternalSubset()
{
- SkipWhitespace();
- switch(ReadChar())
+ SkipWhitespace ();
+ switch(ReadChar ())
{
case ']':
nodeType = XmlNodeType.None;
break;
case '%':
- string peName = ReadName();
- Expect(';');
+ string peName = ReadName ();
+ Expect (';');
nodeType = XmlNodeType.EntityReference; // It's chating a bit;-)
break;
case '<':
- switch(ReadChar())
+ switch(ReadChar ())
{
case '?':
- ReadProcessingInstruction();
+ ReadProcessingInstruction ();
break;
case '!':
- switch(ReadChar())
+ switch(ReadChar ())
{
case '-':
- Expect('-');
- ReadComment();
+ Expect ('-');
+ ReadComment ();
break;
case 'E':
- switch(ReadChar())
+ switch(ReadChar ())
{
case 'N':
- Expect("TITY");
- ReadEntityDecl();
+ Expect ("TITY");
+ ReadEntityDecl ();
break;
case 'L':
- Expect("EMENT");
- ReadElementDecl();
+ Expect ("EMENT");
+ ReadElementDecl ();
break;
default:
- throw new XmlException("Syntax Error after '<!E' (ELEMENT or ENTITY must be found)");
+ throw new XmlException ("Syntax Error after '<!E' (ELEMENT or ENTITY must be found)");
}
break;
case 'A':
- Expect("TTLIST");
- ReadAttListDecl();
+ Expect ("TTLIST");
+ ReadAttListDecl ();
break;
case 'N':
- Expect("OTATION");
- ReadNotationDecl();
+ Expect ("OTATION");
+ ReadNotationDecl ();
break;
default:
- throw new XmlException("Syntax Error after '<!' characters.");
+ throw new XmlException ("Syntax Error after '<!' characters.");
}
break;
default:
- throw new XmlException("Syntax Error after '<' character.");
+ throw new XmlException ("Syntax Error after '<' character.");
}
break;
default:
- throw new XmlException("Syntax Error inside doctypedecl markup.");
+ throw new XmlException ("Syntax Error inside doctypedecl markup.");
}
}
// The reader is positioned on the head of the name.
private void ReadElementDecl()
{
- while(ReadChar() != '>');
+ while(ReadChar () != '>');
}
private void ReadEntityDecl()
{
- while(ReadChar() != '>');
+ while(ReadChar () != '>');
}
private void ReadAttListDecl()
{
- while(ReadChar() != '>');
+ while(ReadChar () != '>');
}
private void ReadNotationDecl()
{
- while(ReadChar() != '>');
+ while(ReadChar () != '>');
}
// The reader is positioned on the first 'S' of "SYSTEM".
- private string ReadSystemLiteral ()
+ private string ReadSystemLiteral (bool expectSYSTEM)
{
- Expect("SYSTEM");
- SkipWhitespace();
- int quoteChar = ReadChar(); // apos or quot
+ if(expectSYSTEM)
+ Expect ("SYSTEM");
+ SkipWhitespace ();
+ int quoteChar = ReadChar (); // apos or quot
xmlBuffer.Length = 0;
saveToXmlBuffer = true;
int c = 0;
- while(c != quoteChar)
- {
- c = ReadChar();
- if(c < 0) throw new XmlException("Unexpected end of stream in ExternalID.");
+ while(c != quoteChar) {
+ c = ReadChar ();
+ if(c < 0) throw new XmlException ("Unexpected end of stream in ExternalID.");
}
saveToXmlBuffer = false;
- xmlBuffer.Remove(xmlBuffer.Length-1, 1); // cut quoteChar
- return xmlBuffer.ToString();
+ xmlBuffer.Remove (xmlBuffer.Length-1, 1); // cut quoteChar
+ return xmlBuffer.ToString ();
}
private string ReadPubidLiteral()
{
- Expect("PUBLIC");
- SkipWhitespace();
- int quoteChar = ReadChar();
+ Expect ("PUBLIC");
+ SkipWhitespace ();
+ int quoteChar = ReadChar ();
xmlBuffer.Length = 0;
saveToXmlBuffer = true;
int c = 0;
while(c != quoteChar)
{
- c = ReadChar();
- if(c < 0) throw new XmlException("Unexpected end of stream in ExternalID.");
- if(c != quoteChar && !XmlChar.IsPubidChar(c))
+ c = ReadChar ();
+ if(c < 0) throw new XmlException ("Unexpected end of stream in ExternalID.");
+ if(c != quoteChar && !XmlChar.IsPubidChar (c))
throw new XmlException("character '" + (char)c + "' not allowed for PUBLIC ID");
}
- xmlBuffer.Remove(xmlBuffer.Length-1, 1); // cut quoteChar
+ ReadChar(); // skips quoteChar
+ xmlBuffer.Remove (xmlBuffer.Length-1, 1); // cut quoteChar
saveToXmlBuffer = false;
- return xmlBuffer.ToString();
+ return xmlBuffer.ToString ();
}
// The reader is positioned on the first character
{
int len = expected.Length;
for(int i=0; i< len; i++)
- Expect(expected[i]);
+ Expect (expected[i]);
}
// Does not consume the first non-whitespace character.
suite.AddTest (new TestSuite (typeof (XmlDocumentFragmentTests)));
suite.AddTest (new TestSuite (typeof (NameTableTests)));
suite.AddTest (new TestSuite (typeof (XmlElementTests)));
+ suite.AddTest (new TestSuite (typeof (XmlEntityReferenceTests)));
suite.AddTest (new TestSuite (typeof (XmlNodeTests)));
suite.AddTest (new TestSuite (typeof (XmlNodeListTests)));
suite.AddTest (new TestSuite (typeof (XmlCharacterDataTests)));
+2002-11-13 Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
+
+ * AllTests.cs : added XmlEntityReferenceTests
+ * XmlDocumentTests.cs : TestCloneNode, TestDocumentWithDoctypeDecl
+ * XmlDocumentFragmentTests.cs : TestSetInnerXml
+ * XmlEntityReferenceTests.cs : created
+ * XmlTextWriterTests.cs : TestWriteAttributes() bugfix (reusing ctx)
+ * XmlNodeTests.cs : bugfix TestInsertAfter(when refChild = null),
+ added TestPrependChild
+
2002-11-13 Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
* XmlAttributeTests.cs : TestSetInnerAndOuterXml
XmlDocument document;
XmlDocumentFragment fragment;
- public XmlDocumentFragmentTests(string name)
+ public XmlDocumentFragmentTests (string name)
: base (name)
{
}
- protected override void SetUp()
+ protected override void SetUp ()
{
}
- public void TestConstructor()
+ public void TestConstructor ()
{
- XmlDocument d = new XmlDocument();
- XmlDocumentFragment df = d.CreateDocumentFragment();
- AssertEquals("#Constructor.NodeName", "#document-fragment", df.Name);
- AssertEquals("#Constructor.NodeType", XmlNodeType.DocumentFragment, df.NodeType);
+ XmlDocument d = new XmlDocument ();
+ XmlDocumentFragment df = d.CreateDocumentFragment ();
+ AssertEquals ("#Constructor.NodeName", "#document-fragment", df.Name);
+ AssertEquals ("#Constructor.NodeType", XmlNodeType.DocumentFragment, df.NodeType);
}
- public void TestAppendChildToFragment()
+ public void TestAppendChildToFragment ()
{
- document = new XmlDocument();
- fragment = document.CreateDocumentFragment();
- document.LoadXml("<html><head></head><body></body></html>");
- XmlElement el = document.CreateElement("p");
+ document = new XmlDocument ();
+ fragment = document.CreateDocumentFragment ();
+ document.LoadXml ("<html><head></head><body></body></html>");
+ XmlElement el = document.CreateElement ("p");
el.InnerXml = "Test Paragraph";
// appending element to fragment
- fragment.AppendChild(el);
- AssertNotNull("#AppendChildToFragment.Element", fragment.FirstChild);
- AssertNotNull("#AppendChildToFragment.Element.Children", fragment.FirstChild.FirstChild);
- AssertEquals("#AppendChildToFragment.Element.Child.Text", "Test Paragraph", fragment.FirstChild.FirstChild.Value);
+ fragment.AppendChild (el);
+ AssertNotNull ("#AppendChildToFragment.Element", fragment.FirstChild);
+ AssertNotNull ("#AppendChildToFragment.Element.Children", fragment.FirstChild.FirstChild);
+ AssertEquals ("#AppendChildToFragment.Element.Child.Text", "Test Paragraph", fragment.FirstChild.FirstChild.Value);
}
- public void TestAppendFragmentToElement()
+ public void TestAppendFragmentToElement ()
{
- document = new XmlDocument();
- fragment = document.CreateDocumentFragment();
- document.LoadXml("<html><head></head><body></body></html>");
+ document = new XmlDocument ();
+ fragment = document.CreateDocumentFragment ();
+ document.LoadXml ("<html><head></head><body></body></html>");
XmlElement body = document.DocumentElement.LastChild as XmlElement;
- fragment.AppendChild(document.CreateElement("p"));
- fragment.AppendChild(document.CreateElement("div"));
+ fragment.AppendChild (document.CreateElement ("p"));
+ fragment.AppendChild (document.CreateElement ("div"));
// appending fragment to element
- body.AppendChild(fragment);
- AssertNotNull("#AppendFragmentToElement.Exist", body.FirstChild);
- AssertEquals("#AppendFragmentToElement.ChildIsElement", XmlNodeType.Element, body.FirstChild.NodeType);
- AssertEquals("#AppendFragmentToElement.FirstChild", "p", body.FirstChild.Name);
- AssertEquals("#AppendFragmentToElement.LastChild", "div", body.LastChild.Name);
+ body.AppendChild (fragment);
+ AssertNotNull ("#AppendFragmentToElement.Exist", body.FirstChild);
+ AssertEquals ("#AppendFragmentToElement.ChildIsElement", XmlNodeType.Element, body.FirstChild.NodeType);
+ AssertEquals ("#AppendFragmentToElement.FirstChild", "p", body.FirstChild.Name);
+ AssertEquals ("#AppendFragmentToElement.LastChild", "div", body.LastChild.Name);
}
- public void TestGetInnerXml()
+ public void TestGetInnerXml ()
{
- // this will be of TestWriteTo/TestWriteContentTo
+ // this will be also tests of TestWriteTo()/TestWriteContentTo()
- document = new XmlDocument();
- fragment = document.CreateDocumentFragment();
- fragment.AppendChild(document.CreateElement("foo"));
- fragment.AppendChild(document.CreateElement("bar"));
- fragment.AppendChild(document.CreateElement("baz"));
- AssertEquals("#Simple", "<foo /><bar /><baz />", fragment.InnerXml);
+ document = new XmlDocument ();
+ fragment = document.CreateDocumentFragment ();
+ fragment.AppendChild (document.CreateElement ("foo"));
+ fragment.AppendChild (document.CreateElement ("bar"));
+ fragment.AppendChild (document.CreateElement ("baz"));
+ AssertEquals ("#Simple", "<foo /><bar /><baz />", fragment.InnerXml);
+ }
+
+ public void TestSetInnerXml ()
+ {
+ document = new XmlDocument ();
+ fragment = document.CreateDocumentFragment ();
+ fragment.InnerXml = "<foo /><bar><child /></bar><baz />";
+ AssertEquals ("foo", fragment.FirstChild.Name);
+ AssertEquals ("bar", fragment.FirstChild.NextSibling.Name);
+ AssertEquals ("child", fragment.FirstChild.NextSibling.FirstChild.Name);
+ AssertEquals ("baz", fragment.LastChild.Name);
}
}
}
AssertNotNull(doc.DocumentElement);
}
- public void TestDocumentWithDoctypeDecl()
+ public void TestDocumentWithDoctypeDecl ()
{
- XmlDocument doc = new XmlDocument();
+ XmlDocument doc = new XmlDocument ();
try {
- doc.LoadXml("<!DOCTYPE test><root />");
- } catch(XmlException) {
- Fail("#DoctypeDecl.OnlyName");
+ doc.LoadXml ("<!DOCTYPE test><root />");
+ } catch (XmlException) {
+ Fail ("#DoctypeDecl.OnlyName");
}
try \r
{
- doc.LoadXml("<!DOCTYPE test SYSTEM 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
- } \r
- catch(XmlException) \r
- {
+ doc.LoadXml ("<!DOCTYPE test SYSTEM 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
+ } catch (XmlException) {
Fail("#DoctypeDecl.System");
}
- try \r
- {
- doc.LoadXml("<!DOCTYPE test PUBLIC '-//test' SYSTEM 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
- } \r
- catch(XmlException) \r
- {
- Fail("#DoctypeDecl.Public");
+ try {
+ doc.LoadXml ("<!DOCTYPE test PUBLIC '-//test' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
+ } catch (XmlException) {
+ Fail ("#DoctypeDecl.Public");
}
// Should this be commented out?
-// try \r
-// {
-// doc.LoadXml("<!DOCTYPE test [<!ELEMENT foo >]><root />");
-// } \r
-// catch(XmlException) \r
-// {
+// try {
+// doc.LoadXml ("<!DOCTYPE test [<!ELEMENT foo >]><root />");
+// } catch (XmlException) {
// Fail("#DoctypeDecl.ElementDecl");
// }
}
+
+ public void TestCloneNode ()
+ {
+ XmlDocument doc = new XmlDocument ();
+ doc.LoadXml ("<foo><bar /><baz hoge='fuga'>TEST Text</baz></foo>");
+ XmlDocument doc2 = (XmlDocument)doc.CloneNode (false);
+ AssertEquals ("ShallowCopy", 0, doc2.ChildNodes.Count);
+ doc2 = (XmlDocument)doc.CloneNode (true);
+ AssertEquals ("DeepCopy", "foo", doc2.DocumentElement.Name);
+ }
}
}
--- /dev/null
+//
+// System.Xml.XmlEntityReference.cs
+//
+// Author:
+// Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
+//
+// (C) 2002 Atsushi Enomoto
+//
+
+using System;
+using System.Xml;
+using NUnit.Framework;
+
+namespace MonoTests.System.Xml
+{
+ public class XmlEntityReferenceTests : TestCase
+ {
+ public XmlEntityReferenceTests () : base ("MonoTests.System.Xml.XmlEntityReferenceTests testsuite") {}
+ public XmlEntityReferenceTests (string name) : base (name) {}
+
+ protected override void SetUp ()
+ {
+ }
+
+ public void TestWriteTo ()
+ {
+ XmlDocument doc = new XmlDocument();
+ doc.LoadXml("<root/>");
+ XmlEntityReference er = doc.CreateEntityReference("foo");
+ doc.DocumentElement.AppendChild(er);
+ AssertEquals ("Name", "foo", er.Name);
+ AssertEquals ("WriteTo", "<root>&foo;</root>", doc.DocumentElement.OuterXml);
+ }
+ }
+}
AssertEquals("InsertAfter.Next", "good_child", docelem.LastChild.PreviousSibling.Name);
try
{
- document.InsertBefore(document.CreateElement("BAD_MAN"), docelem);
- Fail("#InsertBefore.BadPositionButNoError.1");
+ document.InsertAfter(document.CreateElement("BAD_MAN"), docelem);
+ Fail("#InsertAfter.BadPositionButNoError.1");
}
catch(XmlException) {}
}
+ public void TestPrependChild()
+ {
+ document = new XmlDocument();
+ document.LoadXml("<root><sub1 /><sub2 /></root>");
+ XmlElement docelem = document.DocumentElement;
+ docelem.PrependChild(document.CreateElement("prepender"));
+ AssertEquals("PrependChild", "prepender", docelem.FirstChild.Name);
+ }
+
public void saveTestRemoveAll ()
{
// TODO: put this test back in when AttributeCollection.RemoveAll() is implemented.
AssertEquals("#WriteAttributes.XmlDecl.1", "version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"", sw.ToString().Trim());
sb.Remove(0, sb.Length); // init
+ ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default);
xtr = new XmlTextReader("<?xml version='1.0' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx);
xtr.Read(); // read XMLDecl
wr.WriteAttributes(xtr, false);
projects / mono.git / commitdiff