using System.Xml;\r
using System.Xml.Schema;\r
using System.Xml.XPath;\r
+#if NET_4_5\r
+using System.Threading;\r
+using System.Threading.Tasks;\r
+#endif\r
\r
using NUnit.Framework;\r
\r
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XmlReaderTests : Assertion\r
+ public class XmlReaderTests\r
{\r
[SetUp]\r
public void GetReady ()\r
// copy from XmlTextReaderTests\r
private void AssertStartDocument (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.ReadState == ReadState.Initial);\r
- Assert (xmlReader.NodeType == XmlNodeType.None);\r
- Assert (xmlReader.Depth == 0);\r
- Assert (!xmlReader.EOF);\r
+ Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);\r
+ Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);\r
+ Assert.IsTrue (xmlReader.Depth == 0);\r
+ Assert.IsTrue (!xmlReader.EOF);\r
}\r
\r
private void AssertNode (\r
string value,\r
int attributeCount)\r
{\r
- Assert (label + " Read() return value", xmlReader.Read ());\r
- Assert (label + " ReadState", xmlReader.ReadState == ReadState.Interactive);\r
- Assert (label + " !EOF", !xmlReader.EOF);\r
+ Assert.IsTrue (xmlReader.Read (), label + " Read() return value");\r
+ Assert.IsTrue (xmlReader.ReadState == ReadState.Interactive, label + " ReadState");\r
+ Assert.IsTrue (!xmlReader.EOF, label + " !EOF");\r
AssertNodeValues (label, xmlReader, nodeType, depth,\r
isEmptyElement, name, prefix, localName,\r
namespaceURI, value, value != String.Empty,\r
bool hasAttributes)\r
{\r
label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");\r
- AssertEquals (label + ": NodeType", nodeType, xmlReader.NodeType);\r
- AssertEquals (label + ": IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);\r
+ Assert.AreEqual (nodeType, xmlReader.NodeType, label + ": NodeType");\r
+ Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, label + ": IsEmptyElement");\r
\r
- AssertEquals (label + ": name", name, xmlReader.Name);\r
+ Assert.AreEqual (name, xmlReader.Name, label + ": name");\r
\r
- AssertEquals (label + ": prefix", prefix, xmlReader.Prefix);\r
+ Assert.AreEqual (prefix, xmlReader.Prefix, label + ": prefix");\r
\r
- AssertEquals (label + ": localName", localName, xmlReader.LocalName);\r
+ Assert.AreEqual (localName, xmlReader.LocalName, label + ": localName");\r
\r
- AssertEquals (label + ": namespaceURI", namespaceURI, xmlReader.NamespaceURI);\r
+ Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, label + ": namespaceURI");\r
\r
- AssertEquals (label + ": Depth", depth, xmlReader.Depth);\r
+ Assert.AreEqual (depth, xmlReader.Depth, label + ": Depth");\r
\r
- AssertEquals (label + ": hasValue", hasValue, xmlReader.HasValue);\r
+ Assert.AreEqual (hasValue, xmlReader.HasValue, label + ": hasValue");\r
\r
- AssertEquals (label + ": Value", value, xmlReader.Value);\r
+ Assert.AreEqual (value, xmlReader.Value, label + ": Value");\r
\r
- AssertEquals (label + ": hasAttributes", hasAttributes, xmlReader.HasAttributes);\r
+ Assert.AreEqual (hasAttributes, xmlReader.HasAttributes, label + ": hasAttributes");\r
\r
- AssertEquals (label + ": attributeCount", attributeCount, xmlReader.AttributeCount);\r
+ Assert.AreEqual (attributeCount, xmlReader.AttributeCount, label + ": attributeCount");\r
}\r
\r
private void AssertAttribute (\r
string namespaceURI,\r
string value)\r
{\r
- AssertEquals ("value", value, xmlReader [name]);\r
+ Assert.AreEqual (value, xmlReader [name], "value");\r
\r
- Assert (xmlReader.GetAttribute (name) == value);\r
+ Assert.IsTrue (xmlReader.GetAttribute (name) == value);\r
\r
if (namespaceURI != String.Empty) {\r
- Assert (xmlReader[localName, namespaceURI] == value);\r
- Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
+ Assert.IsTrue (xmlReader[localName, namespaceURI] == value);\r
+ Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
}\r
}\r
\r
private void AssertEndDocument (XmlReader xmlReader)\r
{\r
- Assert ("could read", !xmlReader.Read ());\r
- AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);\r
- AssertEquals ("Depth is not 0", 0, xmlReader.Depth);\r
- AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);\r
- Assert ("not EOF", xmlReader.EOF);\r
+ Assert.IsTrue (!xmlReader.Read (), "could read");\r
+ Assert.AreEqual (XmlNodeType.None, xmlReader.NodeType, "NodeType is not XmlNodeType.None");\r
+ Assert.AreEqual (0, xmlReader.Depth, "Depth is not 0");\r
+ Assert.AreEqual (ReadState.EndOfFile, xmlReader.ReadState, "ReadState is not ReadState.EndOfFile");\r
+ Assert.IsTrue (xmlReader.EOF, "not EOF");\r
\r
xmlReader.Close ();\r
- AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);\r
+ Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");\r
}\r
\r
private delegate void TestMethod (XmlReader reader);\r
\r
private void InitialState (XmlReader reader)\r
{\r
- AssertEquals ("Depth", 0, reader.Depth);\r
- AssertEquals ("EOF", false, reader.EOF);\r
- AssertEquals ("HasValue", false, reader.HasValue);\r
- AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);\r
- AssertEquals ("LocalName", String.Empty, reader.LocalName);\r
- AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);\r
- AssertEquals ("ReadState", ReadState.Initial, reader.ReadState);\r
+ Assert.AreEqual (0, reader.Depth, "Depth");\r
+ Assert.AreEqual (false, reader.EOF, "EOF");\r
+ Assert.AreEqual (false, reader.HasValue, "HasValue");\r
+ Assert.AreEqual (false, reader.IsEmptyElement, "IsEmptyElement");\r
+ Assert.AreEqual (String.Empty, reader.LocalName, "LocalName");\r
+ Assert.AreEqual (XmlNodeType.None, reader.NodeType, "NodeType");\r
+ Assert.AreEqual (ReadState.Initial, reader.ReadState, "ReadState");\r
}\r
\r
[Test]\r
public void Read (XmlReader reader)\r
{\r
reader.Read ();\r
- AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);\r
- AssertEquals ("<root>.Name", "root", reader.Name);\r
- AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);\r
- AssertEquals ("<root>.Depth", 0, reader.Depth);\r
+ Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<root>.NodeType");\r
+ Assert.AreEqual ("root", reader.Name, "<root>.Name");\r
+ Assert.AreEqual (ReadState.Interactive, reader.ReadState, "<root>.ReadState");\r
+ Assert.AreEqual (0, reader.Depth, "<root>.Depth");\r
\r
// move to 'child'\r
reader.Read ();\r
- AssertEquals ("<child/>.Depth", 1, reader.Depth);\r
- AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);\r
- AssertEquals ("<child/>.Name", "child", reader.Name);\r
+ Assert.AreEqual (1, reader.Depth, "<child/>.Depth");\r
+ Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<child/>.NodeType");\r
+ Assert.AreEqual ("child", reader.Name, "<child/>.Name");\r
\r
reader.Read ();\r
- AssertEquals ("</root>.Depth", 0, reader.Depth);\r
- AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
- AssertEquals ("</root>.Name", "root", reader.Name);\r
+ Assert.AreEqual (0, reader.Depth, "</root>.Depth");\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "</root>.NodeType");\r
+ Assert.AreEqual ("root", reader.Name, "</root>.Name");\r
\r
reader.Read ();\r
- AssertEquals ("end.EOF", true, reader.EOF);\r
- AssertEquals ("end.NodeType", XmlNodeType.None, reader.NodeType);\r
+ Assert.AreEqual (true, reader.EOF, "end.EOF");\r
+ Assert.AreEqual (XmlNodeType.None, reader.NodeType, "end.NodeType");\r
}\r
\r
[Test]\r
public void ReadAttributeValue (XmlReader reader)\r
{\r
reader.Read (); // root\r
- Assert (reader.MoveToFirstAttribute ());\r
+ Assert.IsTrue (reader.MoveToFirstAttribute ());\r
// It looks like that MS.NET shows AttributeCount and\r
// HasAttributes as the same as element node!\r
this.AssertNodeValues ("#1",\r
reader, XmlNodeType.Attribute,\r
1, false, "attr", "", "attr", "", "", true, 1, true);\r
- Assert (reader.ReadAttributeValue ());\r
+ Assert.IsTrue (reader.ReadAttributeValue ());\r
// MS.NET XmlTextReader fails. Its Prefix returns \r
// null instead of "". It is fixed in MS.NET 2.0.\r
this.AssertNodeValues ("#2",\r
reader, XmlNodeType.Text,\r
2, false, "", "", "", "", "", true, 1, true);\r
- Assert (reader.MoveToElement ());\r
+ Assert.IsTrue (reader.MoveToElement ());\r
this.AssertNodeValues ("#3",\r
reader, XmlNodeType.Element,\r
0, true, "root", "", "root", "", "", false, 1, true);\r
public void ReadEmptyElement (XmlReader reader)\r
{\r
reader.Read (); // root\r
- AssertEquals (false, reader.IsEmptyElement);\r
+ Assert.AreEqual (false, reader.IsEmptyElement);\r
reader.Read (); // foo\r
- AssertEquals ("foo", reader.Name);\r
- AssertEquals (true, reader.IsEmptyElement);\r
+ Assert.AreEqual ("foo", reader.Name);\r
+ Assert.AreEqual (true, reader.IsEmptyElement);\r
reader.Read (); // bar\r
- AssertEquals ("bar", reader.Name);\r
- AssertEquals (false, reader.IsEmptyElement);\r
+ Assert.AreEqual ("bar", reader.Name);\r
+ Assert.AreEqual (false, reader.IsEmptyElement);\r
}\r
\r
[Test]\r
\r
reader.Read ();\r
string s = reader.ReadString ();\r
- AssertEquals ("readString.1.ret_val", " test of ", s);\r
- AssertEquals ("readString.1.Name", "b", reader.Name);\r
+ Assert.AreEqual (" test of ", s, "readString.1.ret_val");\r
+ Assert.AreEqual ("b", reader.Name, "readString.1.Name");\r
s = reader.ReadString ();\r
- AssertEquals ("readString.2.ret_val", "mixed", s);\r
- AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
+ Assert.AreEqual ("mixed", s, "readString.2.ret_val");\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.2.NodeType");\r
s = reader.ReadString (); // never proceeds.\r
- AssertEquals ("readString.3.ret_val", String.Empty, s);\r
- AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
+ Assert.AreEqual (String.Empty, s, "readString.3.ret_val");\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.3.NodeType");\r
reader.Read ();\r
- AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);\r
- AssertEquals ("readString.4.Value", " string.", reader.Value);\r
+ Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "readString.4.NodeType");\r
+ Assert.AreEqual (" string.", reader.Value, "readString.4.Value");\r
s = reader.ReadString (); // reads the same Text node.\r
- AssertEquals ("readString.5.ret_val", " string. cdata string.", s);\r
- AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
+ Assert.AreEqual (" string. cdata string.", s, "readString.5.ret_val");\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.5.NodeType");\r
}\r
\r
[Test]\r
{\r
reader.Read ();\r
reader.Read ();\r
- AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);\r
- AssertEquals ("initial.EOF", false, reader.EOF);\r
- AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);\r
+ Assert.AreEqual (ReadState.Interactive, reader.ReadState, "initial.ReadState");\r
+ Assert.AreEqual (false, reader.EOF, "initial.EOF");\r
+ Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "initial.NodeType");\r
string s = reader.ReadInnerXml ();\r
- AssertEquals ("read_all", "test of <b>mixed</b> string.", s);\r
- AssertEquals ("after.Name", "bar", reader.Name);\r
- AssertEquals ("after.NodeType", XmlNodeType.Element, reader.NodeType);\r
+ Assert.AreEqual ("test of <b>mixed</b> string.", s, "read_all");\r
+ Assert.AreEqual ("bar", reader.Name, "after.Name");\r
+ Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "after.NodeType");\r
}\r
\r
\r
"http://foo/" // value\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace (String.Empty));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace (String.Empty));\r
\r
AssertEndDocument (xmlReader);\r
}\r
"http://foo/" // value\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
\r
AssertNode (\r
xmlReader, // xmlReader\r
"http://baz/" // value\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
- AssertEquals ("http://baz/", xmlReader.LookupNamespace ("baz"));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace ("baz"));\r
\r
AssertNode (\r
xmlReader, // xmlReader\r
0 // attributeCount\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
- AssertNull (xmlReader.LookupNamespace ("baz"));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.IsNull (xmlReader.LookupNamespace ("baz"));\r
\r
AssertEndDocument (xmlReader);\r
}\r
"http://foo/" // value\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
\r
AssertNode (\r
xmlReader, // xmlReader\r
"http://baz/" // value\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
- AssertEquals ("http://baz/", xmlReader.LookupNamespace (String.Empty));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace (String.Empty));\r
\r
AssertNode (\r
xmlReader, // xmlReader\r
0 // attributeCount\r
);\r
\r
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
\r
AssertEndDocument (xmlReader);\r
}\r
"http://bar/" // value\r
);\r
\r
- AssertEquals ("http://bar/", xmlReader.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("http://bar/", xmlReader.LookupNamespace ("bar"));\r
\r
AssertEndDocument (xmlReader);\r
}\r
\r
public void MoveToElementFromAttribute (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- Assert (xmlReader.MoveToFirstAttribute ());\r
- AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);\r
- Assert (xmlReader.MoveToElement ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
+ Assert.AreEqual (XmlNodeType.Attribute, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.MoveToElement ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
}\r
\r
[Test]\r
\r
public void MoveToElementFromElement (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- Assert (!xmlReader.MoveToElement ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (!xmlReader.MoveToElement ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
}\r
\r
[Test]\r
\r
public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- Assert (!xmlReader.MoveToFirstAttribute ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (!xmlReader.MoveToFirstAttribute ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
}\r
\r
[Test]\r
\r
public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- Assert (!xmlReader.MoveToNextAttribute ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
}\r
\r
[Test]\r
"quuux" // value\r
);\r
\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("bar", xmlReader.Name);\r
- AssertEquals ("baz", xmlReader.Value);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", xmlReader.Name);\r
+ Assert.AreEqual ("baz", xmlReader.Value);\r
\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("quux", xmlReader.Name);\r
- AssertEquals ("quuux", xmlReader.Value);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("quux", xmlReader.Name);\r
+ Assert.AreEqual ("quuux", xmlReader.Value);\r
\r
- Assert (!xmlReader.MoveToNextAttribute ());\r
+ Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
\r
- Assert (xmlReader.MoveToElement ());\r
+ Assert.IsTrue (xmlReader.MoveToElement ());\r
\r
AssertNodeValues (\r
"#1",\r
String.Empty,\r
"version=\"1.0\" standalone=\"yes\"",\r
2);\r
- Assert ("MoveToFirstAttribute",\r
- xmlReader.MoveToFirstAttribute ());\r
+ Assert.IsTrue (xmlReader.MoveToFirstAttribute (), "MoveToFirstAttribute");\r
this.AssertNodeValues ("#2", xmlReader, \r
XmlNodeType.Attribute,\r
0, // FIXME: might be 1\r
\r
public void AttributeOrder (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
\r
- Assert (xmlReader.MoveToFirstAttribute ());\r
- AssertEquals ("_1", xmlReader.Name);\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("_2", xmlReader.Name);\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("_3", xmlReader.Name);\r
+ Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("_1", xmlReader.Name);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("_2", xmlReader.Name);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("_3", xmlReader.Name);\r
\r
- Assert (!xmlReader.MoveToNextAttribute ());\r
+ Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
}\r
\r
[Test]\r
\r
public void IndexerAndAttributes (XmlReader xmlReader)\r
{\r
- Assert (xmlReader.Read ());\r
- AssertEquals ("1.0", xmlReader ["version"]);\r
- AssertEquals ("1.0", xmlReader.GetAttribute ("version"));\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual ("1.0", xmlReader ["version"]);\r
+ Assert.AreEqual ("1.0", xmlReader.GetAttribute ("version"));\r
// .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".\r
- AssertEquals (null, xmlReader ["encoding"]);\r
- AssertEquals (null, xmlReader.GetAttribute ("encoding"));\r
- AssertEquals ("no", xmlReader ["standalone"]);\r
- AssertEquals ("no", xmlReader.GetAttribute ("standalone"));\r
- AssertEquals ("1.0", xmlReader [0]);\r
- AssertEquals ("1.0", xmlReader.GetAttribute (0));\r
- AssertEquals ("no", xmlReader [1]);\r
- AssertEquals ("no", xmlReader.GetAttribute (1));\r
-\r
- Assert (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- AssertEquals ("1", xmlReader ["_1"]);\r
-\r
- Assert (xmlReader.MoveToFirstAttribute ());\r
- AssertEquals ("_1", xmlReader.Name);\r
- AssertEquals ("1", xmlReader ["_1"]);\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("_2", xmlReader.Name);\r
- AssertEquals ("1", xmlReader ["_1"]);\r
- Assert (xmlReader.MoveToNextAttribute ());\r
- AssertEquals ("_3", xmlReader.Name);\r
- AssertEquals ("1", xmlReader ["_1"]);\r
-\r
- Assert (!xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual (null, xmlReader ["encoding"]);\r
+ Assert.AreEqual (null, xmlReader.GetAttribute ("encoding"));\r
+ Assert.AreEqual ("no", xmlReader ["standalone"]);\r
+ Assert.AreEqual ("no", xmlReader.GetAttribute ("standalone"));\r
+ Assert.AreEqual ("1.0", xmlReader [0]);\r
+ Assert.AreEqual ("1.0", xmlReader.GetAttribute (0));\r
+ Assert.AreEqual ("no", xmlReader [1]);\r
+ Assert.AreEqual ("no", xmlReader.GetAttribute (1));\r
+\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.AreEqual ("1", xmlReader ["_1"]);\r
+\r
+ Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("_1", xmlReader.Name);\r
+ Assert.AreEqual ("1", xmlReader ["_1"]);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("_2", xmlReader.Name);\r
+ Assert.AreEqual ("1", xmlReader ["_1"]);\r
+ Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
+ Assert.AreEqual ("_3", xmlReader.Name);\r
+ Assert.AreEqual ("1", xmlReader ["_1"]);\r
+\r
+ Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
}\r
\r
[Test]\r
public void SurrogatePairContent (XmlReader xmlReader)\r
{\r
xmlReader.Read ();\r
- AssertEquals (true, xmlReader.MoveToAttribute ("xmlns"));\r
- AssertEquals ("xmlns", xmlReader.Name);\r
- AssertEquals (2, xmlReader.Value.Length);\r
- AssertEquals (0xD800, (int) xmlReader.Value [0]);\r
- AssertEquals (0xDD00, (int) xmlReader.Value [1]);\r
+ Assert.AreEqual (true, xmlReader.MoveToAttribute ("xmlns"));\r
+ Assert.AreEqual ("xmlns", xmlReader.Name);\r
+ Assert.AreEqual (2, xmlReader.Value.Length);\r
+ Assert.AreEqual (0xD800, (int) xmlReader.Value [0]);\r
+ Assert.AreEqual (0xDD00, (int) xmlReader.Value [1]);\r
}\r
\r
[Test]\r
xmlReader.Read ();\r
xmlReader.Read ();\r
xmlReader.Read ();\r
- AssertEquals (String.Empty, xmlReader.ReadOuterXml ());\r
+ Assert.AreEqual (String.Empty, xmlReader.ReadOuterXml ());\r
}\r
\r
[Test]\r
xmlReader.Read ();\r
xmlReader.Read ();\r
xmlReader.Read ();\r
- AssertEquals (String.Empty, xmlReader.ReadInnerXml ());\r
+ Assert.AreEqual (String.Empty, xmlReader.ReadInnerXml ());\r
}\r
\r
[Test]\r
void LookupEmptyPrefix (XmlReader xmlReader)\r
{\r
xmlReader.Read ();\r
- AssertNull (xmlReader.LookupNamespace (String.Empty));\r
+ Assert.IsNull (xmlReader.LookupNamespace (String.Empty));\r
}\r
\r
[Test]\r
xr.Read ();\r
xr.ReadStartElement ();\r
// consume Element node.\r
- AssertEquals (XmlNodeType.Text, xr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.Text, xr.NodeType);\r
}\r
\r
[Test]\r
void LookupNamespaceAtEndElement (XmlReader reader)\r
{\r
reader.Read ();\r
- AssertEquals ("#1", "urn:foo", reader.LookupNamespace ("x"));\r
+ Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#1");\r
+ reader.Read ();\r
+ Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2");\r
reader.Read ();\r
- AssertEquals ("#2", "urn:foo", reader.LookupNamespace ("x"));\r
+ Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadClosedReader ()\r
+ {\r
+ string xml = "<fin>aaa</fin>";\r
+ RunTest (xml, new TestMethod (ReadClosedReader));\r
+ }\r
+\r
+ void ReadClosedReader (XmlReader reader)\r
+ {\r
reader.Read ();\r
- AssertEquals ("#3", "urn:foo", reader.LookupNamespace ("x"));\r
+ reader.Close();\r
+ reader.Read (); // silently returns false\r
}\r
\r
#if NET_2_0\r
s.ProhibitDtd = false;\r
XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
xr.Read ();\r
- AssertEquals ("#1", XmlNodeType.DocumentType, xr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.DocumentType, xr.NodeType, "#1");\r
xr.Read ();\r
- AssertEquals ("#2", XmlNodeType.Whitespace, xr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.Whitespace, xr.NodeType, "#2");\r
xr.Read ();\r
- AssertEquals ("#3", XmlNodeType.Element, xr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#3");\r
}\r
\r
[Test]\r
// a bit revised version of bug #78706\r
public void CreateFromUrlClose ()\r
{\r
- string file = "Test/XmlFiles/78706.xml";\r
+ string file = Path.Combine (Path.GetTempPath (), "78706.xml");\r
try {\r
if (!File.Exists (file))\r
File.Create (file).Close ();\r
}\r
}\r
\r
+ [Test]\r
+ // a bit revised version of bug #385638\r
+ public void CreateFromUrlClose2 ()\r
+ {\r
+ string file = Path.Combine (Path.GetTempPath (), "385638.xml");\r
+ try {\r
+ if (File.Exists (file))\r
+ File.Delete (file);\r
+ using (TextWriter tw = File.CreateText (file))\r
+ tw.Write ("<xml />");\r
+ XmlReaderSettings s = new XmlReaderSettings ();\r
+ s.IgnoreWhitespace = true; // this results in XmlFilterReader, which is the key for this bug.\r
+ XmlReader r = XmlReader.Create (file, s);\r
+ r.Close ();\r
+ XmlTextWriter w = new XmlTextWriter (file, null);\r
+ w.Close ();\r
+ } finally {\r
+ if (File.Exists (file))\r
+ File.Delete (file);\r
+ }\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException (typeof (ArgumentException))]\r
+ public void Create_String_Empty ()\r
+ {\r
+ XmlReader.Create (String.Empty);\r
+ }\r
+\r
[Test]\r
public void ReadToDescendant ()\r
{\r
void ReadToDescendant (XmlReader xmlReader)\r
{\r
// move to first <bar/>\r
- Assert ("#1", xmlReader.ReadToDescendant ("bar"));\r
+ Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#1");\r
// no children in <bar/>. It is empty.\r
- Assert ("#2", !xmlReader.ReadToDescendant ("bar"));\r
- AssertEquals ("#2-2", "bar", xmlReader.Name);\r
+ Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#2");\r
+ Assert.AreEqual ("bar", xmlReader.Name, "#2-2");\r
\r
// move to the second <foo>\r
xmlReader.Read ();\r
// move to the second <bar>\r
- Assert ("#3", xmlReader.ReadToDescendant ("bar"));\r
+ Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#3");\r
// move to <bar> inside <bar>...</bar>\r
- Assert ("#4", xmlReader.ReadToDescendant ("bar"));\r
+ Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#4");\r
// the next is EndElement of </bar>, so no move.\r
- Assert ("#5", !xmlReader.ReadToDescendant ("bar"));\r
- AssertEquals ("#5-2", XmlNodeType.EndElement, xmlReader.NodeType);\r
+ Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#5");\r
+ Assert.AreEqual (XmlNodeType.EndElement, xmlReader.NodeType, "#5-2");\r
}\r
\r
[Test]\r
void ReadToDescendant2 (XmlReader xmlReader)\r
{\r
// make sure that it works when the reader is at Initial state.\r
- Assert (xmlReader.ReadToDescendant ("root"));\r
+ Assert.IsTrue (xmlReader.ReadToDescendant ("root"));\r
}\r
\r
[Test]\r
\r
public void ReadToFollowing (XmlReader xmlReader)\r
{\r
- Assert ("#1", xmlReader.ReadToFollowing ("bar"));\r
- Assert ("#2", xmlReader.ReadToFollowing ("bar"));\r
- AssertEquals ("#2-2", 2, xmlReader.Depth);\r
- Assert ("#3", xmlReader.ReadToFollowing ("bar"));\r
- AssertEquals ("#3-2", 3, xmlReader.Depth);\r
- Assert ("#4", !xmlReader.ReadToFollowing ("bar"));\r
+ Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#1");\r
+ Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#2");\r
+ Assert.AreEqual (2, xmlReader.Depth, "#2-2");\r
+ Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#3");\r
+ Assert.AreEqual (3, xmlReader.Depth, "#3-2");\r
+ Assert.IsTrue (!xmlReader.ReadToFollowing ("bar"), "#4");\r
}\r
\r
[Test]\r
\r
void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
{\r
- Assert ("#1", !xmlReader.ReadToNextSibling ("bar"));\r
- Assert ("#2", !xmlReader.ReadToNextSibling ("root"));\r
+ Assert.IsTrue (!xmlReader.ReadToNextSibling ("bar"), "#1");\r
+ Assert.IsTrue (!xmlReader.ReadToNextSibling ("root"), "#2");\r
}\r
\r
[Test]\r
xmlReader.Read (); // root\r
\r
xmlReader.Read (); // foo\r
- Assert ("#3", xmlReader.ReadToNextSibling ("bar"));\r
+ Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#3");\r
\r
- AssertEquals ("#3-2", "value", xmlReader.GetAttribute ("attr"));\r
+ Assert.AreEqual ("value", xmlReader.GetAttribute ("attr"), "#3-2");\r
xmlReader.Read (); // foo\r
xmlReader.Read (); // pooh\r
- Assert ("#4", xmlReader.ReadToNextSibling ("bar"));\r
- Assert ("#4-2", !xmlReader.IsEmptyElement);\r
- Assert ("#5", xmlReader.ReadToNextSibling ("bar"));\r
- Assert ("#5-2", xmlReader.IsEmptyElement);\r
- Assert ("#6", xmlReader.Read ()); // /foo\r
+ Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#4");\r
+ Assert.IsTrue (!xmlReader.IsEmptyElement, "#4-2");\r
+ Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#5");\r
+ Assert.IsTrue (xmlReader.IsEmptyElement, "#5-2");\r
+ Assert.IsTrue (xmlReader.Read (), "#6"); // /foo\r
\r
AssertNodeValues ("#7", xmlReader,\r
XmlNodeType.EndElement,\r
false); // HasAttributes\r
}\r
\r
+ // bug #81451\r
+ [Test]\r
+ public void ReadToNextSibling2 ()\r
+ {\r
+ string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";\r
+ RunTest (xml, new TestMethod (ReadToNextSibling2));\r
+ }\r
+\r
+ void ReadToNextSibling2 (XmlReader r)\r
+ {\r
+ r.MoveToContent (); // ->root\r
+ r.Read (); // root->baz\r
+ r.Read (); // baz->bar\r
+ Assert.IsTrue (r.ReadToNextSibling ("foo"), "#1");\r
+ Assert.AreEqual ("value2", r.GetAttribute ("attr"), "#2");\r
+ r.Read (); // foo[@value='value2']->bar\r
+ Assert.IsTrue (!r.ReadToNextSibling ("foo"), "#3");\r
+ Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#4");\r
+ Assert.AreEqual ("foo", r.LocalName, "#5");\r
+ }\r
+\r
+ // bug #347768\r
+ [Test]\r
+ public void ReadToNextSibling3 ()\r
+ {\r
+ string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";\r
+ XmlReader reader = XmlReader.Create (new StringReader (xml));\r
+\r
+ reader.MoveToContent ();\r
+\r
+ while (reader.Read ())\r
+ reader.ReadToNextSibling ("book"); // should not result in an infinite loop\r
+ }\r
+\r
+ // bug #676020\r
+ [Test]\r
+ public void ReadToNextSibling4 ()\r
+ {\r
+ string xml = @"<SerializableStringDictionary>\r
+<SerializableStringDictionary>\r
+<DictionaryEntry Key=""Key1"" Value=""Value1""/>\r
+<DictionaryEntry Key=""Key2"" Value=""Value2""/>\r
+<DictionaryEntry Key=""Key3"" Value=""Value3""/>\r
+</SerializableStringDictionary>\r
+</SerializableStringDictionary>";\r
+\r
+ var reader = XmlReader.Create (new StringReader (xml));\r
+\r
+ Assert.IsTrue (reader.ReadToDescendant ("SerializableStringDictionary"), "#1");\r
+ Assert.IsTrue (reader.ReadToDescendant ("DictionaryEntry"), "#2");\r
+\r
+ int count = 0;\r
+ do {\r
+ reader.MoveToAttribute ("Key");\r
+ var key = reader.ReadContentAsString ();\r
+ reader.MoveToAttribute ("Value");\r
+ var value = reader.ReadContentAsString ();\r
+ count++;\r
+ }\r
+ while (reader.ReadToNextSibling ("DictionaryEntry"));\r
+ Assert.AreEqual (3, count, "#3");\r
+ }\r
+\r
[Test]\r
public void ReadSubtree ()\r
{\r
0, // AttributeCount\r
false); // HasAttributes\r
*/\r
- AssertEquals ("#1", XmlNodeType.None, st.NodeType);\r
+ Assert.AreEqual (XmlNodeType.None, st.NodeType, "#1");\r
\r
st.Read ();\r
AssertNodeValues ("#2", st,\r
0, // AttributeCount\r
false); // HasAttributes\r
\r
- Assert ("#3", !st.Read ());\r
+ Assert.IsTrue (!st.Read (), "#3");\r
\r
// At this state, reader is not positioned on <bar> yet\r
AssertNodeValues ("#3-2", reader,\r
0, // AttributeCount\r
false); // HasAttributes\r
\r
- Assert ("#7", !st.Read ());\r
+ Assert.IsTrue (!st.Read (), "#7");\r
}\r
\r
[Test]\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
- AssertEquals ("#1", "1", xr.ReadElementContentAsString ());\r
+ Assert.AreEqual ("1", xr.ReadElementContentAsString (), "#1");\r
\r
AssertNodeValues ("#1-2", xr,\r
XmlNodeType.None,\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
// this XmlReader has no schema, thus the value is untyped\r
- AssertEquals ("#2", "1", xr.ReadElementContentAsObject ());\r
+ Assert.AreEqual ("1", xr.ReadElementContentAsObject (), "#2");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
xr.Read ();\r
- AssertEquals ("#3", "1", xr.ReadContentAsString ());\r
+ Assert.AreEqual ("1", xr.ReadContentAsString (), "#3");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
- AssertEquals ("#4", 1, xr.ReadElementContentAsInt ());\r
+ Assert.AreEqual (1, xr.ReadElementContentAsInt (), "#4");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
- AssertEquals ("#5", 1, xr.ReadElementContentAs (typeof (int), null));\r
+ Assert.AreEqual (1, xr.ReadElementContentAs (typeof (int), null), "#5");\r
}\r
\r
[Test]\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
// this XmlReader has no schema, thus the value is untyped\r
- AssertEquals ("#1", "2006-01-02T03:04:56",\r
- xr.ReadElementContentAsString ());\r
+ Assert.AreEqual ("2006-01-02T03:04:56", xr.ReadElementContentAsString (), "#1");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
xr.Read ();\r
- AssertEquals ("#2", time, xr.ReadContentAsDateTime ());\r
+ Assert.AreEqual (time, xr.ReadContentAsDateTime (), "#2");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
- AssertEquals ("#3", time, xr.ReadElementContentAsDateTime ());\r
+ Assert.AreEqual (time, xr.ReadElementContentAsDateTime (), "#3");\r
\r
xr = XmlReader.Create (new StringReader (xml1));\r
xr.Read ();\r
- AssertEquals ("#4", time, xr.ReadElementContentAs (typeof (DateTime), null));\r
+ Assert.AreEqual (time, xr.ReadElementContentAs (typeof (DateTime), null), "#4");\r
}\r
\r
[Test]\r
typeof (XmlQualifiedName), null);\r
// without IXmlNamespaceResolver, it still resolves\r
// x:el as valid QName.\r
- AssertNotNull ("#1", o);\r
+ Assert.IsNotNull (o, "#1");\r
XmlQualifiedName q = o as XmlQualifiedName;\r
- AssertEquals ("#2 : " + o.GetType (),\r
- new XmlQualifiedName ("el", "urn:foo"), q);\r
+ Assert.AreEqual (new XmlQualifiedName ("el", "urn:foo"), q, "#2 : " + o.GetType ());\r
}\r
\r
[Test]\r
xr.ReadContentAsString ();\r
}\r
\r
+ [Test]\r
+ public void ReadContentStringOnEndElement ()\r
+ {\r
+ XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
+ xr.Read ();\r
+ xr.Read ();\r
+ xr.Read ();\r
+ Assert.AreEqual (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
+ }\r
+\r
+ [Test]\r
+ public void ReadContentStringOnPI ()\r
+ {\r
+ XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
+ xr.Read ();\r
+ Assert.AreEqual (String.Empty, xr.ReadContentAsString ());\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException (typeof (InvalidOperationException))] // unlike ReadContentAsString()\r
+ public void ReadElementContentStringOnPI ()\r
+ {\r
+ XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
+ xr.Read ();\r
+ Assert.AreEqual (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
+ xr.ReadElementContentAsString ();\r
+ }\r
+\r
[Test]\r
[ExpectedException (typeof (XmlException))]\r
public void ReadElementContentStringMixedContent ()\r
xr.Read ();\r
xr.Read (); // from Text "123"\r
string s = xr.ReadContentAsString ();\r
- AssertEquals ("#1", "123", s);\r
- AssertEquals ("#2", XmlNodeType.Element, xr.NodeType);\r
+ Assert.AreEqual ("123", s, "#1");\r
+ Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#2");\r
}\r
\r
[Test]\r
XmlTextReader r = new XmlTextReader (\r
"<root/>", XmlNodeType.Document, null);\r
r.Read ();\r
- AssertEquals ("#1",\r
- String.Empty, r.ReadElementContentAsString ());\r
- AssertEquals ("#2",\r
- XmlNodeType.None, r.NodeType);\r
+ Assert.AreEqual (String.Empty, r.ReadElementContentAsString (), "#1");\r
+ Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
}\r
\r
[Test]\r
XmlTextReader r = new XmlTextReader (\r
"<root/>", XmlNodeType.Document, null);\r
r.Read ();\r
- AssertEquals ("#1",\r
- String.Empty, r.ReadElementContentAs (typeof (object), null));\r
- AssertEquals ("#2",\r
- XmlNodeType.None, r.NodeType);\r
+ Assert.AreEqual (String.Empty, r.ReadElementContentAs (typeof (object), null), "#1");\r
+ Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
\r
// regardless of its value, the return value is string.\r
r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
r.Read ();\r
- AssertEquals ("#3",\r
- "1", r.ReadElementContentAs (typeof (object), null));\r
- AssertEquals ("#4",\r
- XmlNodeType.None, r.NodeType);\r
+ Assert.AreEqual ("1", r.ReadElementContentAs (typeof (object), null), "#3");\r
+ Assert.AreEqual (XmlNodeType.None, r.NodeType, "#4");\r
}\r
\r
[Test]\r
void ReadContentStringOnAttribute (XmlReader reader)\r
{\r
reader.Read ();\r
- Assert (reader.MoveToAttribute ("id"));\r
- AssertEquals ("myId", reader.ReadContentAsString ());\r
+ Assert.IsTrue (reader.MoveToAttribute ("id"));\r
+ Assert.AreEqual ("myId", reader.ReadContentAsString ());\r
+ }\r
+\r
+ [Test]\r
+ public void ReadElementContentAsStringEmpty ()\r
+ {\r
+ string xml = "<root><sample/></root>";\r
+ RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));\r
}\r
+\r
+ void ReadElementContentAsStringEmpty (XmlReader reader)\r
+ {\r
+ reader.MoveToContent ();\r
+ reader.Read ();\r
+ Assert.AreEqual (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType);\r
+ }\r
+\r
+ [Test]\r
+ public void ReadSubtreeClose ()\r
+ {\r
+ // bug #334752\r
+ string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";\r
+ RunTest (xml, new TestMethod (ReadSubtreeClose));\r
+ }\r
+\r
+ void ReadSubtreeClose (XmlReader reader)\r
+ {\r
+ reader.ReadToFollowing ("item-list");\r
+ XmlReader sub = reader.ReadSubtree ();\r
+ sub.ReadToDescendant ("item");\r
+ sub.Close ();\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#1");\r
+ Assert.AreEqual ("item-list", reader.Name, "#2");\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException (typeof (InvalidOperationException))]\r
+ public void ReadSubtreeOnNonElement ()\r
+ {\r
+ string xml = @"<x> <y/></x>";\r
+ XmlReader r = XmlReader.Create (new StringReader (xml));\r
+ r.Read (); // x\r
+ r.Read (); // ws\r
+ r.ReadSubtree ();\r
+ }\r
+\r
+ [Test]\r
+ [ExpectedException (typeof (InvalidOperationException))]\r
+ public void ReadSubtreeOnNonElement2 ()\r
+ {\r
+ string xml = @"<x> <y/></x>";\r
+ XmlReader r = XmlReader.Create (new StringReader (xml));\r
+ r.ReadSubtree ();\r
+ }\r
+\r
+ [Test]\r
+ public void ReadSubtreeEmptyElement ()\r
+ {\r
+ string xml = @"<x/>";\r
+ XmlReader r = XmlReader.Create (new StringReader (xml));\r
+ r.Read ();\r
+ XmlReader s = r.ReadSubtree ();\r
+ Assert.IsTrue (s.Read (), "#1");\r
+ Assert.AreEqual (XmlNodeType.Element, s.NodeType, "#2");\r
+ Assert.IsTrue (!s.Read (), "#3");\r
+ Assert.AreEqual (XmlNodeType.None, s.NodeType, "#4");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadSubtreeEmptyElementWithAttribute ()\r
+ {\r
+ string xml = @"<root><x a='b'/></root>";\r
+ XmlReader r = XmlReader.Create (new StringReader (xml));\r
+ r.Read ();\r
+ r.Read ();\r
+ XmlReader r2 = r.ReadSubtree ();\r
+ Console.WriteLine ("X");\r
+ r2.Read ();\r
+ XmlReader r3 = r2.ReadSubtree ();\r
+ r2.MoveToFirstAttribute ();\r
+ Assert.IsTrue (!r.IsEmptyElement, "#1");\r
+ Assert.IsTrue (!r2.IsEmptyElement, "#2");\r
+ r3.Close ();\r
+ Assert.IsTrue (r.IsEmptyElement, "#3");\r
+ Assert.IsTrue (r2.IsEmptyElement, "#4");\r
+ r2.Close ();\r
+ Assert.IsTrue (r.IsEmptyElement, "#5");\r
+ Assert.IsTrue (r2.IsEmptyElement, "#6");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadContentAsBase64 ()\r
+ {\r
+ byte[] randomData = new byte[24];\r
+ for (int i = 0; i < randomData.Length; i++)\r
+ randomData [i] = (byte) i;\r
+\r
+ string xmlString = "<?xml version=\"1.0\"?><data>" +\r
+ Convert.ToBase64String (randomData) + "</data>";\r
+ TextReader textReader = new StringReader (xmlString);\r
+ XmlReader xmlReader = XmlReader.Create (textReader);\r
+ xmlReader.ReadToFollowing ("data");\r
+\r
+ int readBytes = 0;\r
+ byte[] buffer = new byte [24];\r
+\r
+ xmlReader.ReadStartElement ();\r
+ readBytes = xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length);\r
+ Assert.AreEqual (24, readBytes, "#1");\r
+ Assert.AreEqual (0, xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length), "#2");\r
+ StringWriter sw = new StringWriter ();\r
+ foreach (byte b in buffer) sw.Write ("{0:X02}", b);\r
+ Assert.AreEqual ("000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString (), "#3");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadContentAsBase64_2 () // bug #480066\r
+ {\r
+ StringReader readerString = new StringReader ("<root><b64>TWFu</b64><b64>TWFu</b64>\r\n\t<b64>TWFu</b64><b64>TWFu</b64></root>");\r
+ XmlReaderSettings settingsXml = new XmlReaderSettings ();\r
+ settingsXml.XmlResolver = null;\r
+ using (var readerXml = XmlReader.Create (readerString, settingsXml)) {\r
+ readerXml.MoveToContent ();\r
+ readerXml.Read ();\r
+ readerXml.ReadStartElement ("b64");\r
+ const int bufferLength = 1024;\r
+ byte [] buffer = new byte [bufferLength];\r
+ readerXml.ReadContentAsBase64 (buffer, 0, bufferLength);\r
+ Assert.AreEqual (XmlNodeType.EndElement, readerXml.NodeType, "#1");\r
+ readerXml.Read ();\r
+ Assert.AreEqual (XmlNodeType.Element, readerXml.NodeType, "#2");\r
+ }\r
+ }\r
+ \r
+ [Test]\r
+ public void ReadContentAsBase64_3 () // bug #543332 \r
+ {\r
+ byte [] fakeState = new byte[25];\r
+ byte [] fixedSizeBuffer = new byte [25];\r
+ byte [] readDataBuffer = new byte [25];\r
+ var ms = new MemoryStream ();\r
+ var xw = XmlWriter.Create (ms);\r
+ xw.WriteStartElement ("root");\r
+ xw.WriteBase64 (fakeState, 0, fakeState.Length);\r
+ xw.WriteEndElement ();\r
+ xw.Close ();\r
+ var reader = XmlReader.Create (new MemoryStream (ms.ToArray ()));\r
+ reader.MoveToContent ();\r
+ // we cannot completely trust the length read to indicate the end.\r
+ int bytesRead;\r
+ bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
+ Assert.AreEqual (25, bytesRead, "#1");\r
+ Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2");\r
+ bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
+ Assert.AreEqual (0, bytesRead, "#3");\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadElementContentAsQNameDefaultNS ()\r
+ {\r
+ var sw = new StringWriter ();\r
+ var xw = XmlWriter.Create (sw);\r
+ xw.WriteStartElement ("", "foo", "urn:foo");\r
+ xw.WriteValue (new XmlQualifiedName ("x", "urn:foo"));\r
+ xw.WriteEndElement ();\r
+ xw.Close ();\r
+ var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
+ xr.MoveToContent ();\r
+ var q = (XmlQualifiedName) xr.ReadElementContentAs (typeof (XmlQualifiedName), xr as IXmlNamespaceResolver);\r
+ Assert.AreEqual ("urn:foo", q.Namespace, "#1");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadElementContentAsArray ()\r
+ {\r
+ var sw = new StringWriter ();\r
+ var xw = XmlWriter.Create (sw);\r
+ xw.WriteStartElement ("root");\r
+ xw.WriteAttributeString ("xmlns", "b", "http://www.w3.org/2000/xmlns/", "urn:bar");\r
+ var arr = new XmlQualifiedName [] { new XmlQualifiedName ("foo"), new XmlQualifiedName ("bar", "urn:bar") };\r
+ xw.WriteValue (arr);\r
+ xw.Close ();\r
+ var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
+ xr.MoveToContent ();\r
+ var ret = xr.ReadElementContentAs (typeof (XmlQualifiedName []), null) as XmlQualifiedName [];\r
+ Assert.IsNotNull (ret, "#1");\r
+ Assert.AreEqual (arr [0], ret [0], "#2");\r
+ Assert.AreEqual (arr [1], ret [1], "#3");\r
+ }\r
+\r
+ [Test]\r
+ public void ReadContentAs ()\r
+ {\r
+ var xr = XmlReader.Create (new StringReader ("<doc a=' 1 '/>"));\r
+ xr.Read ();\r
+ xr.MoveToAttribute ("a");\r
+\r
+ Assert.AreEqual ((Byte) 1, xr.ReadContentAs (typeof (Byte), null), "#1");\r
+ Assert.AreEqual ((SByte) 1, xr.ReadContentAs (typeof (SByte), null), "#2");\r
+ Assert.AreEqual ((Int16) 1, xr.ReadContentAs (typeof (Int16), null), "#3");\r
+ Assert.AreEqual ((UInt16) 1, xr.ReadContentAs (typeof (UInt16), null), "#4");\r
+ Assert.AreEqual ((Int32) 1, xr.ReadContentAs (typeof (Int32), null), "#5");\r
+ Assert.AreEqual ((UInt32) 1, xr.ReadContentAs (typeof (UInt32), null), "#6");\r
+ Assert.AreEqual ((Int64) 1, xr.ReadContentAs (typeof (Int64), null), "#7");\r
+ Assert.AreEqual ((UInt64) 1, xr.ReadContentAs (typeof (UInt64), null), "#8");\r
+ }\r
+\r
+#if NET_4_5\r
+ [Test]\r
+ [ExpectedException(typeof(InvalidOperationException))]\r
+ public void MustSetAsyncFlag ()\r
+ {\r
+ var r = XmlReader.Create (new StringReader ("<root/>"));\r
+ r.ReadAsync ();\r
+ }\r
+\r
+ Exception RunAsync (Action action)\r
+ {\r
+ var task = Task<Exception>.Run (async () => {\r
+ try {\r
+ action ();\r
+ return null;\r
+ } catch (Exception ex) {\r
+ return ex;\r
+ }\r
+ });\r
+ task.Wait ();\r
+ Assert.That (task.IsCompleted);\r
+ return task.Result;\r
+ }\r
+\r
+ [Test]\r
+ public void SimpleAsync ()\r
+ {\r
+ var xml = "<root test=\"monkey\"/>";\r
+ var task = Task<Exception>.Run (async () => {\r
+ try {\r
+ var s = new XmlReaderSettings ();\r
+ s.Async = true;\r
+ var r = XmlReader.Create (new StringReader (xml), s);\r
+\r
+ Assert.That (await r.ReadAsync ());\r
+ Assert.That (r.MoveToFirstAttribute ());\r
+\r
+ Assert.AreEqual (await r.GetValueAsync (), "monkey");\r
+ r.Close ();\r
+ return null;\r
+ } catch (Exception ex) {\r
+ return ex;\r
+ }\r
+ });\r
+ task.Wait ();\r
+ Assert.That (task.IsCompleted);\r
+ if (task.Result != null)\r
+ throw task.Result;\r
+ }\r
+#endif\r
#endif\r
}\r
}\r
projects / mono.git / blobdiff