2005-12-12 Atsushi Enomoto <atsushi@ximian.com>

	* XmlException.cs : added another .ctor() overload that takes both
	  IXmlLineInfo and innerException.
	* XmlQualifiedName.cs : added Parse() overload that takes XmlReader
	  (since XmlReader is not IXmlNamespaceResolver anymore).
	* XmlReader.cs : made several fixes on 2.0 ReadContentAs(),
	  ReadElementContentAs() and all of its variants.

	* XmlReaderCommonTests.cs : added several tests for 2.0 methods.


svn path=/trunk/mcs/; revision=54230

6 files changed, 495 insertions, 79 deletions

diff --git a/mcs/class/System.XML/System.Xml/ChangeLog b/mcs/class/System.XML/System.Xml/ChangeLog
index acc3baebe43..658a907d99f 100644
--- a/mcs/class/System.XML/System.Xml/ChangeLog
+++ b/mcs/class/System.XML/System.Xml/ChangeLog
@@ -1,3 +1,12 @@
+2005-12-12  Atsushi Enomoto <atsushi@ximian.com>
+
+	* XmlException.cs : added another .ctor() overload that takes both
+	  IXmlLineInfo and innerException.
+	* XmlQualifiedName.cs : added Parse() overload that takes XmlReader
+	  (since XmlReader is not IXmlNamespaceResolver anymore).
+	* XmlReader.cs : made several fixes on 2.0 ReadContentAs(),
+	  ReadElementContentAs() and all of its variants.
+
 2005-12-09  Atsushi Enomoto <atsushi@ximian.com>
 
 	* XmlInputStream.cs :
diff --git a/mcs/class/System.XML/System.Xml/XmlException.cs b/mcs/class/System.XML/System.Xml/XmlException.cs
index d17b9d4e558..0af78586c54 100644
--- a/mcs/class/System.XML/System.Xml/XmlException.cs
+++ b/mcs/class/System.XML/System.Xml/XmlException.cs
@@ -76,7 +76,18 @@ namespace System.Xml
 		{
 		}
 
-		internal XmlException (IXmlLineInfo li, string sourceUri, string message) : base (message)
+		internal XmlException (IXmlLineInfo li,
+			string sourceUri,
+			string message)
+			: this (li, null, sourceUri, message)
+		{
+		}
+
+		internal XmlException (IXmlLineInfo li,
+			Exception innerException,
+			string sourceUri,
+			string message)
+			: base (message, innerException)
 		{
 			if (li != null) {
 				this.lineNumber = li.LineNumber;
diff --git a/mcs/class/System.XML/System.Xml/XmlQualifiedName.cs b/mcs/class/System.XML/System.Xml/XmlQualifiedName.cs
index 22857ff868f..768f54a1c95 100644
--- a/mcs/class/System.XML/System.Xml/XmlQualifiedName.cs
+++ b/mcs/class/System.XML/System.Xml/XmlQualifiedName.cs
@@ -119,6 +119,17 @@ namespace System.Xml
 			return new XmlQualifiedName (name.Substring (index + 1), ns);
 		}
 
+		internal static XmlQualifiedName Parse (string name, XmlReader reader)
+		{
+			int index = name.IndexOf (':');
+			if (index < 0)
+				return new XmlQualifiedName (name);
+			string ns = reader.LookupNamespace (name.Substring (0, index));
+			if (ns == null)
+				throw new ArgumentException ("Invalid qualified name.");
+			return new XmlQualifiedName (name.Substring (index + 1), ns);
+		}
+
 		// Operators
 		public static bool operator == (XmlQualifiedName a, XmlQualifiedName b)
 		{
diff --git a/mcs/class/System.XML/System.Xml/XmlReader.cs b/mcs/class/System.XML/System.Xml/XmlReader.cs
index e384be73add..0f5ca8a8b1e 100644
--- a/mcs/class/System.XML/System.Xml/XmlReader.cs
+++ b/mcs/class/System.XML/System.Xml/XmlReader.cs
@@ -861,7 +861,6 @@ namespace System.Xml
 			return false;
 		}
 
-		[MonoTODO]
 		public virtual bool ReadToNextSibling (string name)
 		{
 			if (NodeType != XmlNodeType.Element || IsEmptyElement)
@@ -873,7 +872,6 @@ namespace System.Xml
 			return false;
 		}
 
-		[MonoTODO]
 		public virtual bool ReadToNextSibling (string localName, string namespaceURI)
 		{
 			if (NodeType != XmlNodeType.Element || IsEmptyElement)
@@ -885,7 +883,6 @@ namespace System.Xml
 			return false;
 		}
 
-		[MonoTODO]
 		public virtual XmlReader ReadSubtree ()
 		{
 			return new SubtreeXmlReader (this);
@@ -893,16 +890,22 @@ namespace System.Xml
 
 		private string ReadContentString ()
 		{
-			switch (NodeType) {
-			case XmlNodeType.Text:
-			case XmlNodeType.CDATA:
-			case XmlNodeType.SignificantWhitespace:
-			case XmlNodeType.Whitespace:
-				break;
-			default:
-				throw new InvalidOperationException (String.Format ("This method does not support node type {0}.", NodeType));
-			}
-			return ReadString ();
+			string value = String.Empty;
+			do {
+				switch (NodeType) {
+				case XmlNodeType.Element:
+					throw XmlError ("Child element is not expected in this operation.");
+				case XmlNodeType.EndElement:
+					return value;
+				case XmlNodeType.Text:
+				case XmlNodeType.CDATA:
+				case XmlNodeType.SignificantWhitespace:
+				case XmlNodeType.Whitespace:
+					value += Value;
+					break;
+				}
+			} while (Read ());
+			throw XmlError ("Unexpected end of document.");
 		}
 
 		[MonoTODO]
@@ -923,19 +926,22 @@ namespace System.Xml
 			return ReadContentAs (ValueType, null);
 		}
 
-		[MonoTODO]
 		public virtual object ReadElementContentAs (Type type, IXmlNamespaceResolver resolver)
 		{
-			return ValueAs (ReadElementString (), type, resolver);
+			ReadStartElement ();
+			object obj = ValueAs (ReadContentAsString (), type, resolver);
+			ReadEndElement ();
+			return obj;
 		}
 
-		[MonoTODO]
 		public virtual object ReadElementContentAs (Type type, IXmlNamespaceResolver resolver, string localName, string namespaceURI)
 		{
-			return ValueAs (ReadElementString (localName, namespaceURI), type, resolver);
+			ReadStartElement (localName, namespaceURI);
+			object obj = ReadContentAs (type, resolver);
+			ReadEndElement ();
+			return obj;
 		}
 
-		[MonoTODO]
 		public virtual object ReadContentAs (Type type, IXmlNamespaceResolver resolver)
 		{
 			return ValueAs (ReadContentString (), type, resolver);
@@ -944,172 +950,246 @@ namespace System.Xml
 		private object ValueAs (string text, Type type, IXmlNamespaceResolver resolver)
 		{
 			try {
-				if (type == typeof (XmlQualifiedName))
-					return XmlQualifiedName.Parse (text, resolver);
+				if (type == typeof (XmlQualifiedName)) {
+					if (resolver != null)
+						return XmlQualifiedName.Parse (text, resolver);
+					else
+						return XmlQualifiedName.Parse (text, this);
+				}
 
 				switch (Type.GetTypeCode (type)) {
 				case TypeCode.Boolean:
-					return ReadContentAsBoolean ();
+					return XQueryConvert.StringToBoolean (text);
 				case TypeCode.DateTime:
-					return ReadContentAsDateTime ();
+					return XQueryConvert.StringToDateTime (text);
 				case TypeCode.Decimal:
-					return ReadContentAsDecimal ();
+					return XQueryConvert.StringToDecimal (text);
 				case TypeCode.Double:
-					return ReadContentAsDouble ();
+					return XQueryConvert.StringToDouble (text);
 				case TypeCode.Int32:
-					return ReadContentAsInt ();
+					return XQueryConvert.StringToInt (text);
 				case TypeCode.Int64:
-					return ReadContentAsLong ();
+					return XQueryConvert.StringToInteger (text);
 				case TypeCode.Single:
-					return ReadContentAsFloat ();
+					return XQueryConvert.StringToFloat (text);
 				case TypeCode.String:
-					return ReadContentAsString ();
+					return text;
 				}
 			} catch (Exception ex) {
-				return new FormatException (String.Format ("Current text value '{0}' is not acceptable for specified type '{1}'.", text, type));
+				throw XmlError (String.Format ("Current text value '{0}' is not acceptable for specified type '{1}'. {2}", text, type, ex != null ? ex.Message : String.Empty), ex);
 			}
 			throw new ArgumentException (String.Format ("Specified type '{0}' is not supported.", type));
 		}
 
-		[MonoTODO]
 		public virtual bool ReadElementContentAsBoolean ()
 		{
-			return XQueryConvert.StringToBoolean (ReadElementString ());
+			try {
+				return XQueryConvert.StringToBoolean (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual DateTime ReadElementContentAsDateTime ()
 		{
-			return XQueryConvert.StringToDateTime (ReadElementString ());
+			try {
+				return XQueryConvert.StringToDateTime (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual decimal ReadElementContentAsDecimal ()
 		{
-			return XQueryConvert.StringToDecimal (ReadElementString ());
+			try {
+				return XQueryConvert.StringToDecimal (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual double ReadElementContentAsDouble ()
 		{
-			return XQueryConvert.StringToDouble (ReadElementString ());
+			try {
+				return XQueryConvert.StringToDouble (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual float ReadElementContentAsFloat ()
 		{
-			return XQueryConvert.StringToFloat (ReadElementString ());
+			try {
+				return XQueryConvert.StringToFloat (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual int ReadElementContentAsInt ()
 		{
-			return XQueryConvert.StringToInt (ReadElementString ());
+			try {
+				return XQueryConvert.StringToInt (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual long ReadElementContentAsLong ()
 		{
-			return XQueryConvert.StringToInteger (ReadElementString ());
+			try {
+				return XQueryConvert.StringToInteger (ReadElementContentAsString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual string ReadElementContentAsString ()
 		{
-			return ReadElementString ();
+			ReadStartElement ();
+			if (IsEmptyElement)
+				return String.Empty;
+			string s = ReadContentString ();
+			ReadEndElement ();
+			return s;
 		}
 
-		[MonoTODO]
 		public virtual bool ReadElementContentAsBoolean (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToBoolean (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToBoolean (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual DateTime ReadElementContentAsDateTime (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToDateTime (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToDateTime (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual decimal ReadElementContentAsDecimal (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToDecimal (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToDecimal (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual double ReadElementContentAsDouble (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToDouble (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToDouble (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual float ReadElementContentAsFloat (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToFloat (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToFloat (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual int ReadElementContentAsInt (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToInt (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToInt (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual long ReadElementContentAsLong (string localName, string namespaceURI)
 		{
-			return XQueryConvert.StringToInteger (ReadElementString (localName, namespaceURI));
+			try {
+				return XQueryConvert.StringToInteger (ReadElementContentAsString (localName, namespaceURI));
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual string ReadElementContentAsString (string localName, string namespaceURI)
 		{
-			return ReadElementString (localName, namespaceURI);
+			ReadStartElement (localName, namespaceURI);
+			if (IsEmptyElement)
+				return String.Empty;
+			string s = ReadContentString ();
+			ReadEndElement ();
+			return s;
 		}
 
-		[MonoTODO]
 		public virtual bool ReadContentAsBoolean ()
 		{
-			return XQueryConvert.StringToBoolean (ReadContentString ());
+			try {
+				return XQueryConvert.StringToBoolean (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual DateTime ReadContentAsDateTime ()
 		{
-			return XQueryConvert.StringToDateTime (ReadContentString ());
+			try {
+				return XQueryConvert.StringToDateTime (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual decimal ReadContentAsDecimal ()
 		{
-			return XQueryConvert.StringToDecimal (ReadContentString ());
+			try {
+				return XQueryConvert.StringToDecimal (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual double ReadContentAsDouble ()
 		{
-			return XQueryConvert.StringToDouble (ReadContentString ());
+			try {
+				return XQueryConvert.StringToDouble (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual float ReadContentAsFloat ()
 		{
-			return XQueryConvert.StringToFloat (ReadContentString ());
+			try {
+				return XQueryConvert.StringToFloat (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual int ReadContentAsInt ()
 		{
-			return XQueryConvert.StringToInt (ReadContentString ());
+			try {
+				return XQueryConvert.StringToInt (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual long ReadContentAsLong ()
 		{
-			return XQueryConvert.StringToInteger (ReadContentString ());
+			try {
+				return XQueryConvert.StringToInteger (ReadContentString ());
+			} catch (FormatException ex) {
+				throw XmlError ("Typed value is invalid.", ex);
+			}
 		}
 
-		[MonoTODO]
 		public virtual string ReadContentAsString ()
 		{
 			return ReadContentString ();
@@ -1197,6 +1277,11 @@ namespace System.Xml
 			return new XmlException (this as IXmlLineInfo, BaseURI, message);
 		}
 
+		private XmlException XmlError (string message, Exception innerException)
+		{
+			return new XmlException (this as IXmlLineInfo, BaseURI, message);
+		}
+
 		#endregion
 	}
 }
diff --git a/mcs/class/System.XML/Test/System.Xml/ChangeLog b/mcs/class/System.XML/Test/System.Xml/ChangeLog
index cf8fad11c0f..be787765a68 100644
--- a/mcs/class/System.XML/Test/System.Xml/ChangeLog
+++ b/mcs/class/System.XML/Test/System.Xml/ChangeLog
@@ -1,3 +1,7 @@
+2005-12-12  Atsushi Enomoto <atsushi@ximian.com>
+
+	* XmlReaderCommonTests.cs : added several tests for 2.0 methods.
+
 2005-12-09  Atsushi Enomoto <atsushi@ximian.com>
 
 	* XmlTextReaderTests.cs : added test for Encoding property.
diff --git a/mcs/class/System.XML/Test/System.Xml/XmlReaderCommonTests.cs b/mcs/class/System.XML/Test/System.Xml/XmlReaderCommonTests.cs
index 366bf76f4e2..bfb60acb97a 100644
--- a/mcs/class/System.XML/Test/System.Xml/XmlReaderCommonTests.cs
+++ b/mcs/class/System.XML/Test/System.Xml/XmlReaderCommonTests.cs
@@ -1443,6 +1443,38 @@ namespace MonoTests.System.Xml
 			AssertNull (xmlReader.LookupNamespace (String.Empty));

 		}

 

+		[Test]

+		public void ReadStartElement ()

+		{

+			string xml = "<root>test</root>";

+			RunTest (xml, new TestMethod (ReadStartElement));

+		}

+

+		void ReadStartElement (XmlReader xr)

+		{

+			xr.Read ();

+			xr.ReadStartElement ();

+			// consume Element node.

+			AssertEquals (XmlNodeType.Text, xr.NodeType);

+		}

+

+		[Test]

+		public void LookupNamespaceAtEndElement ()

+		{

+			string xml = "<root xmlns:x='urn:foo'><foo/></root>";

+			RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));

+		}

+

+		void LookupNamespaceAtEndElement (XmlReader reader)

+		{

+			reader.Read ();

+			AssertEquals ("#1", "urn:foo", reader.LookupNamespace ("x"));

+			reader.Read ();

+			AssertEquals ("#2", "urn:foo", reader.LookupNamespace ("x"));

+			reader.Read ();

+			AssertEquals ("#3", "urn:foo", reader.LookupNamespace ("x"));

+		}

+

 #if NET_2_0

 		[Test]

 		public void CreateSimple ()

@@ -1473,7 +1505,7 @@ namespace MonoTests.System.Xml
 			RunTest (xml, new TestMethod (ReadToDescendant));

 		}

 

-		public void ReadToDescendant (XmlReader xmlReader)

+		void ReadToDescendant (XmlReader xmlReader)

 		{

 			// move to first <bar/>

 			Assert ("#1", xmlReader.ReadToDescendant ("bar"));

@@ -1499,7 +1531,7 @@ namespace MonoTests.System.Xml
 			RunTest (xml, new TestMethod (ReadToDescendant2));

 		}

 

-		public void ReadToDescendant2 (XmlReader xmlReader)

+		void ReadToDescendant2 (XmlReader xmlReader)

 		{

 			// make sure that it works when the reader is at Initial state.

 			Assert (xmlReader.ReadToDescendant ("root"));

@@ -1521,6 +1553,270 @@ namespace MonoTests.System.Xml
 			AssertEquals ("#3-2", 3, xmlReader.Depth);

 			Assert ("#4", !xmlReader.ReadToFollowing ("bar"));

 		}

+

+/*

+		[Test]

+		public void ReadToNextSibling ()

+		{

+			string xml = @"<root><foo/><bar attr='value'/><foo><bar><bar></bar><foo></foo><bar/></bar></foo></root>";

+			RunTest (xml, new TestMethod (ReadToNextSibling));

+		}

+

+		void ReadToNextSibling (XmlReader xmlReader)

+		{

+			Assert ("#1", !xmlReader.ReadToNextSibling ("bar"));

+			Assert ("#2", !xmlReader.ReadToNextSibling ("root"));

+			xmlReader.Read (); // root

+			xmlReader.Read (); // foo

+			Assert ("#3", xmlReader.ReadToNextSibling ("bar"));

+			AssertEquals ("#3-2", "value", xmlReader.GetAttribute ("attr"));

+			xmlReader.Read (); // foo

+			xmlReader.Read (); // bar

+			Assert ("#4", xmlReader.ReadToNextSibling ("bar"));

+			Assert ("#4-2", !xmlReader.IsEmptyElement);

+			Assert ("#5", xmlReader.ReadToNextSibling ("bar"));

+			Assert ("#5-2", xmlReader.IsEmptyElement);

+			Assert ("#6", xmlReader.Read ()); // /bar

+

+			AssertNodeValues ("#7", xmlReader,

+				XmlNodeType.EndElement,

+				2,		// Depth

+				false,		// IsEmptyElement

+				"bar",		// Name

+				String.Empty,	// Prefix

+				"bar",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+		}

+*/

+

+		[Test]

+		public void ReadSubtree ()

+		{

+			string xml = @"<root><foo/><bar attr='value'></bar></root>";

+			RunTest (xml, new TestMethod (ReadSubtree));

+		}

+

+		void ReadSubtree (XmlReader reader)

+		{

+			reader.MoveToContent (); // root

+			reader.Read (); // foo

+			XmlReader st = reader.ReadSubtree (); // <foo/>

+

+			// MS bug: IsEmptyElement should be false here.

+			/*

+			AssertNodeValues ("#1", st,

+				XmlNodeType.None,

+				0,		// Depth

+				false,		// IsEmptyElement

+				String.Empty,	// Name

+				String.Empty,	// Prefix

+				String.Empty,	// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+			*/

+			AssertEquals ("#1", XmlNodeType.None, st.NodeType);

+

+			st.Read ();

+			AssertNodeValues ("#2", st,

+				XmlNodeType.Element,

+				0,

+				true,		// IsEmptyElement

+				"foo",		// Name

+				String.Empty,	// Prefix

+				"foo",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+

+			Assert ("#3", !st.Read ());

+

+			// At this state, reader is not positioned on <bar> yet

+			AssertNodeValues ("#3-2", reader,

+				XmlNodeType.Element,

+				1,		// Depth. It is 1 for main tree.

+				true,		// IsEmptyElement

+				"foo",		// Name

+				String.Empty,	// Prefix

+				"foo",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+

+			reader.Read ();

+

+			AssertNodeValues ("#4", reader,

+				XmlNodeType.Element,

+				1,		// Depth. It is 1 for main tree.

+				false,		// IsEmptyElement

+				"bar",		// Name

+				String.Empty,	// Prefix

+				"bar",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				1,		// AttributeCount

+				true);		// HasAttributes

+

+			st = reader.ReadSubtree ();

+			st.Read (); // Initial -> Interactive

+			AssertNodeValues ("#5", st,

+				XmlNodeType.Element,

+				0,		// Depth. It is 0 for subtree.

+				false,		// IsEmptyElement

+				"bar",		// Name

+				String.Empty,	// Prefix

+				"bar",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				1,		// AttributeCount

+				true);		// HasAttributes

+

+			st.Read ();

+			AssertNodeValues ("#6-1", st,

+				XmlNodeType.EndElement,

+				0,		// Depth. It is 0 for subtree.

+				false,		// IsEmptyElement

+				"bar",		// Name

+				String.Empty,	// Prefix

+				"bar",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+

+			AssertNodeValues ("#6-2", st,

+				XmlNodeType.EndElement,

+				0,		// Depth. It is 0 for subtree.

+				false,		// IsEmptyElement

+				"bar",		// Name

+				String.Empty,	// Prefix

+				"bar",		// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+

+			Assert ("#7", !st.Read ());

+		}

+

+		[Test]

+		public void ReadInteger ()

+		{

+			string xml1 = "<root>1</root>";

+			XmlReader xr;

+			

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			AssertEquals ("#1", "1", xr.ReadElementContentAsString ());

+

+			AssertNodeValues ("#1-2", xr,

+				XmlNodeType.None,

+				0,		// Depth. It is 0 for subtree.

+				false,		// IsEmptyElement

+				String.Empty,	// Name

+				String.Empty,	// Prefix

+				String.Empty,	// LocalName

+				String.Empty,	// NamespaceURI

+				String.Empty,	// Value

+				false,		// HasValue

+				0,		// AttributeCount

+				false);		// HasAttributes

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			// this XmlReader has no schema, thus the value is untyped

+			AssertEquals ("#2", "1", xr.ReadElementContentAsObject ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			xr.Read ();

+			AssertEquals ("#3", "1", xr.ReadContentAsString ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			AssertEquals ("#4", 1, xr.ReadElementContentAsInt ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			AssertEquals ("#5", 1, xr.ReadElementContentAs (typeof (int), null));

+		}

+

+		[Test]

+		[ExpectedException (typeof (XmlException))]

+		public void ReadContentAsIntFail ()

+		{

+			XmlReader xr = XmlReader.Create (

+				new StringReader ("<doc>1.0</doc>"));

+			xr.Read ();

+			xr.ReadElementContentAsInt ();

+		}

+

+		[Test]

+		public void ReadDateTime ()

+		{

+			DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);

+			string xml1 = "<root>2006-01-02T03:04:56</root>";

+			XmlReader xr;

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			// this XmlReader has no schema, thus the value is untyped

+			AssertEquals ("#1", "2006-01-02T03:04:56",

+				xr.ReadElementContentAsString ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			xr.Read ();

+			AssertEquals ("#2", time, xr.ReadContentAsDateTime ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			AssertEquals ("#3", time, xr.ReadElementContentAsDateTime ());

+

+			xr = XmlReader.Create (new StringReader (xml1));

+			xr.Read ();

+			AssertEquals ("#4", time, xr.ReadElementContentAs (typeof (DateTime), null));

+		}

+

+		[Test]

+		[ExpectedException (typeof (XmlException))]

+		public void ReadContentAsDateTimeFail ()

+		{

+			XmlReader xr = XmlReader.Create (

+				new StringReader ("<doc>P1Y2M3D</doc>"));

+			xr.Read ();

+			xr.ReadElementContentAsDateTime ();

+		}

+

+		[Test]

+		public void ReadContentAs_QNameEmptyNSResolver ()

+		{

+			XmlReader xr = XmlReader.Create (

+				new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));

+			xr.Read ();

+			object o = xr.ReadElementContentAs (

+				typeof (XmlQualifiedName), null);

+			// without IXmlNamespaceResolver, it still resolves

+			// x:el as valid QName.

+			AssertNotNull ("#1", o);

+			XmlQualifiedName q = o as XmlQualifiedName;

+			AssertEquals ("#2 : " + o.GetType (),

+				new XmlQualifiedName ("el", "urn:foo"), q);

+		}

 #endif

 	}

 }