* *.cs: Upgrade to new NUnit style.
svn path=/trunk/mcs/; revision=137010
+2009-06-26 Robert Jordan <robertj@gmx.net>
+
+ * *.cs: Upgrade to new NUnit style.
+
2009-05-22 Gert Driesen <drieseng@users.sourceforge.net>
* XmlResolverTest.cs: Fix ResolveUri test on Windows when current
namespace MonoTests.System.Xml
{
[TestFixture]
- public class NameTableTests : Assertion
+ public class NameTableTests
{
NameTable table;
{
string add = "add1";
string testAdd = table.Add (add);
- AssertEquals ("#1", add, testAdd);
- AssertSame ("#2", add, testAdd);
+ Assert.AreEqual (add, testAdd, "#1");
+ Assert.AreSame (add, testAdd, "#2");
testAdd = table.Add ("");
- AssertEquals ("#3", string.Empty, testAdd);
- AssertSame ("#4", string.Empty, testAdd);
+ Assert.AreEqual (string.Empty, testAdd, "#3");
+ Assert.AreSame (string.Empty, testAdd, "#4");
}
[Test]
int length = 3; // "add"
string testAdd = table.Add (test, index, length);
- AssertEquals ("#1", "add", testAdd);
+ Assert.AreEqual ("add", testAdd, "#1");
testAdd = table.Add ((char[]) null, 0, 0);
- AssertEquals ("#2", string.Empty, testAdd);
- AssertSame ("#3", string.Empty, testAdd);
+ Assert.AreEqual (string.Empty, testAdd, "#2");
+ Assert.AreSame (string.Empty, testAdd, "#3");
testAdd = table.Add (new char[0], 0, 0);
- AssertEquals ("#4", string.Empty, testAdd);
- AssertSame ("#5", string.Empty, testAdd);
+ Assert.AreEqual (string.Empty, testAdd, "#4");
+ Assert.AreSame (string.Empty, testAdd, "#5");
}
[Test]
{
string get1 = "get1";
string testGet = table.Add (get1);
- AssertEquals ("#1", "get1", testGet);
+ Assert.AreEqual ("get1", testGet, "#1");
- AssertEquals ("#2", testGet, table.Get (get1));
- AssertSame ("#3", get1, testGet );
+ Assert.AreEqual (testGet, table.Get (get1), "#2");
+ Assert.AreSame (get1, testGet, "#3");
testGet = table.Get ("");
- AssertEquals ("#1", string.Empty, testGet);
- AssertSame ("#2", string.Empty, testGet);
+ Assert.AreEqual (string.Empty, testGet, "#1");
+ Assert.AreSame (string.Empty, testGet, "#2");
}
[Test]
int length = 3; // "get"
string testGet = table.Add (test, index, length);
- AssertEquals ("#1", "get", testGet);
+ Assert.AreEqual ("get", testGet, "#1");
- AssertEquals ("#2", testGet, table.Get ("get"));
- AssertEquals ("#3", testGet, table.Get (test, index, length));
+ Assert.AreEqual (testGet, table.Get ("get"), "#2");
+ Assert.AreEqual (testGet, table.Get (test, index, length), "#3");
}
[Test]
string testGet = null;
testGet = table.Get ((char[]) null, 10, 0);
- AssertEquals ("#1", string.Empty, testGet);
- AssertSame ("#2", string.Empty, testGet);
+ Assert.AreEqual (string.Empty, testGet, "#1");
+ Assert.AreSame (string.Empty, testGet, "#2");
testGet = table.Get (new char[0], 2, 0);
- AssertEquals ("#3", string.Empty, testGet);
- AssertSame ("#4", string.Empty, testGet);
+ Assert.AreEqual (string.Empty, testGet, "#3");
+ Assert.AreSame (string.Empty, testGet, "#4");
testGet = table.Get (new char[3] { 'a', 'b', 'c' }, 5, 0);
- AssertEquals ("#5", string.Empty, testGet);
- AssertSame ("#6", string.Empty, testGet);
+ Assert.AreEqual (string.Empty, testGet, "#5");
+ Assert.AreSame (string.Empty, testGet, "#6");
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlAttributeCollectionTests : Assertion
+ public class XmlAttributeCollectionTests
{
private XmlDocument document;
XmlElement xmlElement = xmlNode as XmlElement;
XmlAttributeCollection attributes = xmlElement.Attributes;
attributes.RemoveAll ();
- AssertEquals ("not all attributes removed.", false, xmlElement.HasAttribute ("type"));
+ Assert.AreEqual (false, xmlElement.HasAttribute ("type"), "not all attributes removed.");
}
[Test]
XmlAttribute xmlAttribute3 = xmlNode as XmlAttribute;
XmlAttributeCollection attributeCol = xmlEl.Attributes;
xmlAttribute3 = attributeCol.Append (xmlAttribute3);
- AssertEquals ("attribute name not properly created.", true, xmlAttribute3.Name.Equals ("attr3"));
- AssertEquals ("attribute namespace not properly created.", true, xmlAttribute3.NamespaceURI.Equals ("namespace1"));
+ Assert.AreEqual (true, xmlAttribute3.Name.Equals ("attr3"), "attribute name not properly created.");
+ Assert.AreEqual (true, xmlAttribute3.NamespaceURI.Equals ("namespace1"), "attribute namespace not properly created.");
}
[Test]
XmlAttributeCollection col = xmlDoc.DocumentElement.Attributes;
XmlAttribute[] array = new XmlAttribute[24];
col.CopyTo(array, 0);
- AssertEquals("garnet", array[0].Value);
- AssertEquals("moonstone", array[8].Value);
- AssertEquals("turquoize", array[11].Value);
+ Assert.AreEqual ("garnet", array[0].Value);
+ Assert.AreEqual ("moonstone", array[8].Value);
+ Assert.AreEqual ("turquoize", array[11].Value);
col.CopyTo(array, 12);
- AssertEquals("garnet", array[12].Value);
- AssertEquals("moonstone", array[20].Value);
- AssertEquals("turquoize", array[23].Value);
+ Assert.AreEqual ("garnet", array[12].Value);
+ Assert.AreEqual ("moonstone", array[20].Value);
+ Assert.AreEqual ("turquoize", array[23].Value);
}
[Test]
XmlAttribute attr = xmlDoc.CreateAttribute("b3");
attr.Value = "bloodstone";
col.SetNamedItem(attr);
- AssertEquals("SetNamedItem.Normal", "bloodstone", el.GetAttribute("b3"));
+ Assert.AreEqual ("bloodstone", el.GetAttribute("b3"), "SetNamedItem.Normal");
attr = xmlDoc.CreateAttribute("b3");
attr.Value = "aquamaline";
col.SetNamedItem(attr);
- AssertEquals("SetNamedItem.Override", "aquamaline", el.GetAttribute("b3"));
- AssertEquals("SetNamedItem.Override.Count.1", 1, el.Attributes.Count);
- AssertEquals("SetNamedItem.Override.Count.2", 1, col.Count);
+ Assert.AreEqual ("aquamaline", el.GetAttribute("b3"), "SetNamedItem.Override");
+ Assert.AreEqual (1, el.Attributes.Count, "SetNamedItem.Override.Count.1");
+ Assert.AreEqual (1, col.Count, "SetNamedItem.Override.Count.2");
}
[Test]
XmlAttribute attr = xmlDoc.CreateAttribute("b1");
attr.Value = "garnet";
col.InsertAfter(attr, null);
- AssertEquals("InsertAfterNull", "garnet", el.GetAttributeNode("b1").Value);
- AssertEquals("InsertAfterNull.Pos", el.GetAttribute("b1"), col[0].Value);
+ Assert.AreEqual ("garnet", el.GetAttributeNode("b1").Value, "InsertAfterNull");
+ Assert.AreEqual (el.GetAttribute("b1"), col[0].Value, "InsertAfterNull.Pos");
attr = xmlDoc.CreateAttribute("b3");
attr.Value = "bloodstone";
col.InsertAfter(attr, el.GetAttributeNode("b2"));
- AssertEquals("InsertAfterAttr", "bloodstone", el.GetAttributeNode("b3").Value);
- AssertEquals("InsertAfterAttr.Pos", el.GetAttribute("b3"), col[2].Value);
+ Assert.AreEqual ("bloodstone", el.GetAttributeNode("b3").Value, "InsertAfterAttr");
+ Assert.AreEqual (el.GetAttribute("b3"), col[2].Value, "InsertAfterAttr.Pos");
attr = xmlDoc.CreateAttribute("b4");
attr.Value = "diamond";
col.InsertBefore(attr, null);
- AssertEquals("InsertBeforeNull", "diamond", el.GetAttributeNode("b4").Value);
- AssertEquals("InsertBeforeNull.Pos", el.GetAttribute("b4"), col[3].Value);
+ Assert.AreEqual ("diamond", el.GetAttributeNode("b4").Value, "InsertBeforeNull");
+ Assert.AreEqual (el.GetAttribute("b4"), col[3].Value, "InsertBeforeNull.Pos");
attr = xmlDoc.CreateAttribute("warning");
attr.Value = "mixed modern and traditional;-)";
col.InsertBefore(attr, el.GetAttributeNode("b1"));
- AssertEquals("InsertBeforeAttr", "mixed modern and traditional;-)", el.GetAttributeNode("warning").Value);
- AssertEquals("InsertBeforeAttr.Pos", el.GetAttributeNode("warning").Value, col[0].Value);
+ Assert.AreEqual ("mixed modern and traditional;-)", el.GetAttributeNode("warning").Value, "InsertBeforeAttr");
+ Assert.AreEqual (el.GetAttributeNode("warning").Value, col[0].Value, "InsertBeforeAttr.Pos");
attr = xmlDoc.CreateAttribute("about");
attr.Value = "lists of birthstone.";
col.Prepend(attr);
- AssertEquals("Prepend", "lists of birthstone.", col[0].Value);
+ Assert.AreEqual ("lists of birthstone.", col[0].Value, "Prepend");
}
[Test]
outOfOrder.Value = "Should still be second attribute";
testElement.Attributes.InsertAfter (outOfOrder, testElement.Attributes [0]);
- AssertEquals ("First attribute", testElement.Attributes [0].Value);
- AssertEquals ("Should still be second attribute", testElement.Attributes [1].Value);
- AssertEquals ("Third attribute", testElement.Attributes [2].Value);
+ Assert.AreEqual ("First attribute", testElement.Attributes [0].Value);
+ Assert.AreEqual ("Should still be second attribute", testElement.Attributes [1].Value);
+ Assert.AreEqual ("Third attribute", testElement.Attributes [2].Value);
}
[Test]
// Remove
XmlAttribute attr = col.Remove(el.GetAttributeNode("a12"));
- AssertEquals("Remove", 11, col.Count);
- AssertEquals("Remove.Removed", "a12", attr.Name);
+ Assert.AreEqual (11, col.Count, "Remove");
+ Assert.AreEqual ("a12", attr.Name, "Remove.Removed");
// RemoveAt
attr = col.RemoveAt(5);
- AssertEquals("RemoveAt", null, el.GetAttributeNode("a6"));
- AssertEquals("Remove.Removed", "pearl", attr.Value);
+ Assert.AreEqual (null, el.GetAttributeNode("a6"), "RemoveAt");
+ Assert.AreEqual ("pearl", attr.Value, "Remove.Removed");
}
[Test]
doc.DocumentElement.RemoveAttribute("attr");
XmlAttribute defAttr = doc.DocumentElement.Attributes ["attr"];
- AssertNotNull (defAttr);
- AssertEquals ("default", defAttr.Value);
+ Assert.IsNotNull (defAttr);
+ Assert.AreEqual ("default", defAttr.Value);
defAttr.Value = "default"; // same value as default
- AssertEquals (true, defAttr.Specified);
+ Assert.AreEqual (true, defAttr.Specified);
}
[Test]
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlCDataSectionTests : Assertion
+ public class XmlCDataSectionTests
{
XmlDocument document;
XmlCDataSection section;
internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
{
- // AssertEquals (original.nodetype + " was incorrectly cloned.",
- // original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
+ // Assert.AreEqual (// original.baseuri, cloned.baseuri, original.nodetype + " was incorrectly cloned.");
+ Assert.IsNull (cloned.ParentNode);
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
[Test]
public void XmlCDataSectionInnerAndOuterXml ()
{
section = document.CreateCDataSection ("foo");
- AssertEquals (String.Empty, section.InnerXml);
- AssertEquals ("<![CDATA[foo]]>", section.OuterXml);
+ Assert.AreEqual (String.Empty, section.InnerXml);
+ Assert.AreEqual ("<![CDATA[foo]]>", section.OuterXml);
}
[Test]
public void XmlCDataSectionName ()
{
- AssertEquals (section.NodeType + " Name property broken",
- section.Name, "#cdata-section");
+ Assert.AreEqual (section.Name, "#cdata-section", section.NodeType + " Name property broken");
}
[Test]
public void XmlCDataSectionLocalName ()
{
- AssertEquals (section.NodeType + " LocalName property broken",
- section.LocalName, "#cdata-section");
+ Assert.AreEqual (section.LocalName, "#cdata-section", section.NodeType + " LocalName property broken");
}
[Test]
public void XmlCDataSectionNodeType ()
{
- AssertEquals ("XmlCDataSection NodeType property broken",
- section.NodeType.ToString (), "CDATA");
+ Assert.AreEqual (section.NodeType.ToString (), "CDATA", "XmlCDataSection NodeType property broken");
}
[Test]
public void XmlCDataSectionIsReadOnly ()
{
- AssertEquals ("XmlCDataSection IsReadOnly property broken",
- section.IsReadOnly, false);
+ Assert.AreEqual (section.IsReadOnly, false, "XmlCDataSection IsReadOnly property broken");
}
[Test]
shallow = section.CloneNode (false); // shallow
XmlNodeBaseProperties (original, shallow);
- AssertEquals ("Value incorrectly cloned",
- original.Value, shallow.Value);
+ Assert.AreEqual (original.Value, shallow.Value, "Value incorrectly cloned");
deep = section.CloneNode (true); // deep
XmlNodeBaseProperties (original, deep);
- AssertEquals ("Value incorrectly cloned",
- original.Value, deep.Value);
+ Assert.AreEqual (original.Value, deep.Value, "Value incorrectly cloned");
- AssertEquals ("deep cloning differs from shallow cloning",
- deep.OuterXml, shallow.OuterXml);
+ Assert.AreEqual (deep.OuterXml, shallow.OuterXml, "deep cloning differs from shallow cloning");
}
}
}
namespace MonoTests.System.Xml
{
- public class XmlCharTests : Assertion
+ [TestFixture]
+ public class XmlCharTests
{
#if false
public void IsFirstNameCharTest ()
{
for (int ch = 0; ch <= 0xFFFF; ++ch) {
- Assert (
- XmlChar.IsFirstNameChar (ch) ==
+ Assert.IsTrue (XmlChar.IsFirstNameChar (ch) ==
IsFirstNameChar (ch));
}
}
public void IsNameCharTest ()
{
for (int ch = 0; ch <= 0xFFFF; ++ch) {
- Assert (
- XmlChar.IsNameChar (ch) ==
+ Assert.IsTrue (XmlChar.IsNameChar (ch) ==
IsNameChar (ch));
}
}
}
#endif
}
-}
\ No newline at end of file
+}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlCharacterDataTests : Assertion
+ public class XmlCharacterDataTests
{
XmlDocument document;
XmlComment comment;
changed = false;
changing = false;
comment.AppendData ("bar");
- Assert (changed);
- Assert (changing);
- AssertEquals ("foobar", comment.Data);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (changing);
+ Assert.AreEqual ("foobar", comment.Data);
comment.Value = "foo";
comment.AppendData (null);
- AssertEquals ("foo", comment.Data);
+ Assert.AreEqual ("foo", comment.Data);
}
[Test]
changed = false;
changing = false;
comment.DeleteData (1, 1);
- Assert (changed);
- Assert (changing);
- AssertEquals ("br", comment.Data);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (changing);
+ Assert.AreEqual ("br", comment.Data);
try
{
comment.Value = "foo";
comment.DeleteData(-1, 1);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (ArgumentOutOfRangeException) {}
comment.Value = "foo";
comment.DeleteData(1, 5);
- AssertEquals("f", comment.Data);
+ Assert.AreEqual ("f", comment.Data);
comment.Value = "foo";
comment.DeleteData(3, 10);
- AssertEquals("foo", comment.Data);
+ Assert.AreEqual ("foo", comment.Data);
}
[Test]
changed = false;
changing = false;
comment.InsertData (3, "bar");
- Assert (changed);
- Assert (changing);
- AssertEquals ("foobarbaz", comment.Data);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (changing);
+ Assert.AreEqual ("foobarbaz", comment.Data);
try
{
comment.Value = "foo";
comment.InsertData (-1, "bar");
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (ArgumentOutOfRangeException) {}
comment.Value = "foo";
comment.InsertData (3, "bar");
- AssertEquals ("foobar", comment.Data);
+ Assert.AreEqual ("foobar", comment.Data);
try
{
comment.Value = "foo";
comment.InsertData (4, "bar");
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (ArgumentOutOfRangeException) {}
{
comment.Value = "foo";
comment.InsertData (1, null);
- Fail ("Expected an ArgumentNullException to be thrown.");
+ Assert.Fail ("Expected an ArgumentNullException to be thrown.");
}
catch (ArgumentNullException) {}
}
changed = false;
changing = false;
comment.ReplaceData (0, 3, "bar");
- Assert (changed);
- Assert (changing);
- AssertEquals ("bar", comment.Data);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (changing);
+ Assert.AreEqual ("bar", comment.Data);
comment.Value = "foo";
comment.ReplaceData (2, 3, "bar");
- AssertEquals ("fobar", comment.Data);
+ Assert.AreEqual ("fobar", comment.Data);
comment.Value = "foo";
comment.ReplaceData (3, 3, "bar");
- AssertEquals ("foobar", comment.Data);
+ Assert.AreEqual ("foobar", comment.Data);
try
{
comment.Value = "foo";
comment.ReplaceData (4, 3, "bar");
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (ArgumentOutOfRangeException) {}
{
comment.Value = "foo";
comment.ReplaceData (-1, 3, "bar");
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (ArgumentOutOfRangeException) {}
comment.Value = "foo";
comment.ReplaceData (0, 2, "bar");
- AssertEquals ("baro", comment.Data);
+ Assert.AreEqual ("baro", comment.Data);
comment.Value = "foo";
comment.ReplaceData (0, 5, "bar");
- AssertEquals ("bar", comment.Data);
+ Assert.AreEqual ("bar", comment.Data);
try
{
comment.Value = "foo";
comment.ReplaceData (1, 1, null);
- Fail ("Expected an ArgumentNullException to be thrown.");
+ Assert.Fail ("Expected an ArgumentNullException to be thrown.");
}
catch (ArgumentNullException) {}
}
public void Substring ()
{
comment.Value = "test string";
- AssertEquals ("test string", comment.Substring (0, 50));
+ Assert.AreEqual (comment.Substring (0, 50), "test string");
}
[Test]
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlCommentTests : Assertion
+ public class XmlCommentTests
{
XmlDocument document;
XmlComment comment;
deep = comment.CloneNode (true); // deep
XmlNodeBaseProperties (original, deep);
- AssertEquals ("Value incorrectly cloned",
- original.Value, deep.Value);
+ Assert.AreEqual (original.Value, deep.Value, "Value incorrectly cloned");
- AssertEquals ("deep cloning differs from shallow cloning",
- deep.OuterXml, shallow.OuterXml);
+ Assert.AreEqual (deep.OuterXml, shallow.OuterXml, "deep cloning differs from shallow cloning");
}
[Test]
public void XmlCommentInnerAndOuterXml ()
{
comment = document.CreateComment ("foo");
- AssertEquals (String.Empty, comment.InnerXml);
- AssertEquals ("<!--foo-->", comment.OuterXml);
+ Assert.AreEqual (String.Empty, comment.InnerXml);
+ Assert.AreEqual ("<!--foo-->", comment.OuterXml);
}
[Test]
{
document.LoadXml ("<root><foo></foo></root>");
comment = document.CreateComment ("Comment");
- AssertEquals ("XmlComment IsReadOnly property broken",
- comment.IsReadOnly, false);
+ Assert.AreEqual (comment.IsReadOnly, false, "XmlComment IsReadOnly property broken");
}
[Test]
{
document.LoadXml ("<root><foo></foo></root>");
comment = document.CreateComment ("Comment");
- AssertEquals (comment.NodeType + " LocalName property broken",
- comment.LocalName, "#comment");
+ Assert.AreEqual (comment.LocalName, "#comment", comment.NodeType + " LocalName property broken");
}
[Test]
{
document.LoadXml ("<root><foo></foo></root>");
comment = document.CreateComment ("Comment");
- AssertEquals (comment.NodeType + " Name property broken",
- comment.Name, "#comment");
+ Assert.AreEqual (comment.Name, "#comment", comment.NodeType + " Name property broken");
}
[Test]
{
document.LoadXml ("<root><foo></foo></root>");
comment = document.CreateComment ("Comment");
- AssertEquals ("XmlComment NodeType property broken",
- comment.NodeType.ToString (), "Comment");
+ Assert.AreEqual (comment.NodeType.ToString (), "Comment", "XmlComment NodeType property broken");
}
internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
// assertequals (original.nodetype + " was incorrectly cloned.",
// original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
- AssertEquals ("Value incorrectly cloned",
- original.Value, cloned.Value);
+ Assert.IsNull (cloned.ParentNode);
+ Assert.AreEqual (original.Value, cloned.Value, "Value incorrectly cloned");
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
}
using System.Xml;
using NUnit.Framework;
-using AssertType = NUnit.Framework.Assert;
-
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlConvertTests : Assertion
+ public class XmlConvertTests
{
private void AssertName (string result, string source)
{
- AssertEquals (result,
+ Assert.AreEqual (result,
XmlConvert.EncodeName (source));
}
private void AssertNmToken (string result, string source)
{
- AssertEquals (result,
+ Assert.AreEqual (result,
XmlConvert.EncodeNmToken (source));
}
[Test]
public void DecodeName ()
{
- AssertEquals (null, XmlConvert.DecodeName (null));
- AssertEquals ("", XmlConvert.DecodeName (""));
- AssertEquals ("Test", XmlConvert.DecodeName ("Test"));
- AssertEquals ("_Test", XmlConvert.DecodeName ("_Test"));
- AssertEquals ("_hello_friends", XmlConvert.DecodeName ("_hello_friends"));
- AssertEquals ("_hello friends", XmlConvert.DecodeName ("_hello friends"));
- AssertEquals (" ", XmlConvert.DecodeName ("_x0020_"));
+ Assert.AreEqual (null, XmlConvert.DecodeName (null));
+ Assert.AreEqual ("", XmlConvert.DecodeName (""));
+ Assert.AreEqual ("Test", XmlConvert.DecodeName ("Test"));
+ Assert.AreEqual ("_Test", XmlConvert.DecodeName ("_Test"));
+ Assert.AreEqual ("_hello_friends", XmlConvert.DecodeName ("_hello_friends"));
+ Assert.AreEqual ("_hello friends", XmlConvert.DecodeName ("_hello friends"));
+ Assert.AreEqual (" ", XmlConvert.DecodeName ("_x0020_"));
}
[Test]
public void EncodeLocalName ()
{
- AssertNull (XmlConvert.EncodeLocalName (null));
- AssertEquals (String.Empty, XmlConvert.EncodeLocalName (String.Empty));
- AssertEquals ("Hello_x003A__x0020_", XmlConvert.EncodeLocalName ("Hello: "));
- AssertEquals ("Hello", XmlConvert.EncodeLocalName ("Hello"));
+ Assert.IsNull (XmlConvert.EncodeLocalName (null));
+ Assert.AreEqual (String.Empty, XmlConvert.EncodeLocalName (String.Empty));
+ Assert.AreEqual ("Hello_x003A__x0020_", XmlConvert.EncodeLocalName ("Hello: "));
+ Assert.AreEqual ("Hello", XmlConvert.EncodeLocalName ("Hello"));
}
[Test]
public void EncodeName ()
{
- AssertNull (XmlConvert.EncodeName (null));
- AssertEquals (String.Empty, XmlConvert.EncodeName (String.Empty));
+ Assert.IsNull (XmlConvert.EncodeName (null));
+ Assert.AreEqual (String.Empty, XmlConvert.EncodeName (String.Empty));
AssertName ("Test", "Test");
AssertName ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
AssertName ("_x0031_23", "123");
[Test]
public void EncodeNmToken ()
{
- AssertNull (XmlConvert.EncodeNmToken (null));
+ Assert.IsNull (XmlConvert.EncodeNmToken (null));
AssertNmToken ("Test", "Test");
AssertNmToken ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
AssertNmToken ("123", "123");
[Test]
public void ToBoolean ()
{
- AssertEquals (true, XmlConvert.ToBoolean (" 1 "));
- AssertEquals (true, XmlConvert.ToBoolean (" true "));
- AssertEquals (false, XmlConvert.ToBoolean (" 0 "));
- AssertEquals (false, XmlConvert.ToBoolean (" false "));
+ Assert.AreEqual (true, XmlConvert.ToBoolean (" 1 "));
+ Assert.AreEqual (true, XmlConvert.ToBoolean (" true "));
+ Assert.AreEqual (false, XmlConvert.ToBoolean (" 0 "));
+ Assert.AreEqual (false, XmlConvert.ToBoolean (" false "));
try
{
- AssertEquals (false, XmlConvert.ToBoolean (" invalid "));
+ Assert.AreEqual (false, XmlConvert.ToBoolean (" invalid "));
}
catch (FormatException)
{
[Test]
public void ToByte ()
{
- AssertEquals (255, XmlConvert.ToByte ("255"));
+ Assert.AreEqual (255, XmlConvert.ToByte ("255"));
}
[Test]
public void ToChar ()
{
- AssertEquals ('x', XmlConvert.ToChar ("x"));
+ Assert.AreEqual ('x', XmlConvert.ToChar ("x"));
}
[Test]
public void ToDateTime ()
{
//dateTime
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000").Ticks);
- AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000").Ticks);
+ Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000").Ticks);
/*
// These tests also failed on MS.NET
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000+13:00").Ticks);
- AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000+13:00").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000Z").Ticks);
- AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000Z").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000+13:00").Ticks);
+ Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000+13:00").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000Z").Ticks);
+ Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000Z").Ticks);
*/
//time
DateTime t1 = new DateTime (DateTime.Today.Year, 1, 1);
t1 = DateTime.Today + new TimeSpan (12,0,0);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00000").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000000").Ticks);
- AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000000").Ticks);
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.f+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffff+13:00").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00Z").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffffZ").Ticks);//doesn't work on .NET
- //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffffZ").Ticks);//doesn't work on .NET
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00000").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000000").Ticks);
+ Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000000").Ticks);
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.f+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffff+13:00").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00Z").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffffZ").Ticks);//doesn't work on .NET
+ //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffffZ").Ticks);//doesn't work on .NET
//date
- AssertEquals (632001312000000000L, XmlConvert.ToDateTime ("2003-09-26").Ticks);
-// AssertEquals (632000664000000000L, XmlConvert.ToDateTime ("2003-09-26+13:00").Ticks);
-// AssertEquals (632001132000000000L, XmlConvert.ToDateTime ("2003-09-26Z").Ticks);
+ Assert.AreEqual (632001312000000000L, XmlConvert.ToDateTime ("2003-09-26").Ticks);
+// Assert.AreEqual (632000664000000000L, XmlConvert.ToDateTime ("2003-09-26+13:00").Ticks);
+// Assert.AreEqual (632001132000000000L, XmlConvert.ToDateTime ("2003-09-26Z").Ticks);
//gYearMonth
- AssertEquals (631979712000000000L, XmlConvert.ToDateTime ("2003-09").Ticks);
-// AssertEquals (631979064000000000L, XmlConvert.ToDateTime ("2003-09+13:00").Ticks);
-// AssertEquals (631979532000000000L, XmlConvert.ToDateTime ("2003-09Z").Ticks);
+ Assert.AreEqual (631979712000000000L, XmlConvert.ToDateTime ("2003-09").Ticks);
+// Assert.AreEqual (631979064000000000L, XmlConvert.ToDateTime ("2003-09+13:00").Ticks);
+// Assert.AreEqual (631979532000000000L, XmlConvert.ToDateTime ("2003-09Z").Ticks);
//gYear
- AssertEquals (631769760000000000L, XmlConvert.ToDateTime ("2003").Ticks);
-// AssertEquals (631769076000000000L, XmlConvert.ToDateTime ("2003+13:00").Ticks);
-// AssertEquals (631769544000000000L, XmlConvert.ToDateTime ("2003Z").Ticks);
+ Assert.AreEqual (631769760000000000L, XmlConvert.ToDateTime ("2003").Ticks);
+// Assert.AreEqual (631769076000000000L, XmlConvert.ToDateTime ("2003+13:00").Ticks);
+// Assert.AreEqual (631769544000000000L, XmlConvert.ToDateTime ("2003Z").Ticks);
//gMonthDay
// Don't try locale-dependent test
-// AssertEquals (632001312000000000L, XmlConvert.ToDateTime ("--09-26").Ticks);//shouldn't have a hardcoded value
-// AssertEquals (632000664000000000L, XmlConvert.ToDateTime ("--09-26+13:00").Ticks);//shouldn't have a hardcoded value
-// AssertEquals (632001132000000000L, XmlConvert.ToDateTime ("--09-26Z").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (632001312000000000L, XmlConvert.ToDateTime ("--09-26").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (632000664000000000L, XmlConvert.ToDateTime ("--09-26+13:00").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (632001132000000000L, XmlConvert.ToDateTime ("--09-26Z").Ticks);//shouldn't have a hardcoded value
//gDay
// Don't try locale-dependent test
-// AssertEquals (631791360000000000L, XmlConvert.ToDateTime ("---26").Ticks);//shouldn't have a hardcoded value
-// AssertEquals (631790676000000000L, XmlConvert.ToDateTime ("---26+13:00").Ticks);//shouldn't have a hardcoded value
-// AssertEquals (631791144000000000L, XmlConvert.ToDateTime ("---26Z").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (631791360000000000L, XmlConvert.ToDateTime ("---26").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (631790676000000000L, XmlConvert.ToDateTime ("---26+13:00").Ticks);//shouldn't have a hardcoded value
+// Assert.AreEqual (631791144000000000L, XmlConvert.ToDateTime ("---26Z").Ticks);//shouldn't have a hardcoded value
try
{
- AssertEquals (45L, XmlConvert.ToDateTime (";ljdfas;kl").Ticks);
+ Assert.AreEqual (45L, XmlConvert.ToDateTime (";ljdfas;kl").Ticks);
}
catch (Exception)
{
[Test]
public void ToDecimal ()
{
- AssertEquals (1.987, XmlConvert.ToDecimal ("1.987"));
+ Assert.AreEqual (1.987, XmlConvert.ToDecimal ("1.987"));
}
[Test]
public void ToDouble ()
{
- AssertEquals (1.0d/0.0d, XmlConvert.ToDouble ("INF"));
- AssertEquals (-1.0d/0.0d, XmlConvert.ToDouble ("-INF"));
- AssertEquals (0.0d/0.0d, XmlConvert.ToDouble ("NaN"));
- AssertEquals (789324, XmlConvert.ToDouble ("789324"));
+ Assert.AreEqual (1.0d/0.0d, XmlConvert.ToDouble ("INF"));
+ Assert.AreEqual (-1.0d/0.0d, XmlConvert.ToDouble ("-INF"));
+ Assert.AreEqual (0.0d/0.0d, XmlConvert.ToDouble ("NaN"));
+ Assert.AreEqual (789324, XmlConvert.ToDouble ("789324"));
}
[Test]
{
// bug #320424
string s = XmlConvert.ToString (double.MaxValue);
- AssertEquals (double.MaxValue, XmlConvert.ToDouble (s));
+ Assert.AreEqual (double.MaxValue, XmlConvert.ToDouble (s));
}
[Test]
public void ToGuid ()
{
- AssertEquals (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
+ Assert.AreEqual (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
}
[Test]
public void ToInt16 ()
{
- AssertType.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
- AssertType.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
- AssertType.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
- AssertType.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
- AssertType.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
+ Assert.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
+ Assert.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
+ Assert.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
+ Assert.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
+ Assert.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
try {
XmlConvert.ToInt16 ("32768");
- AssertType.Fail ("32768");
+ Assert.Fail ("32768");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt16 ("-32769");
- AssertType.Fail ("-32769");
+ Assert.Fail ("-32769");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt16 ("0x100");
- AssertType.Fail ("0x100");
+ Assert.Fail ("0x100");
} catch (FormatException) {
}
}
[Test]
public void ToInt32 ()
{
- AssertType.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
- AssertType.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
- AssertType.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
- AssertType.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
- AssertType.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
+ Assert.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
+ Assert.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
+ Assert.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
+ Assert.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
+ Assert.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
try {
int.Parse ("2147483648", CultureInfo.CurrentCulture);
- AssertType.Fail ("int.Parse(current culture)");
+ Assert.Fail ("int.Parse(current culture)");
} catch (OverflowException) {
}
try {
int.Parse ("2147483648", CultureInfo.InvariantCulture);
- AssertType.Fail ("int.Parse(invariant culture)");
+ Assert.Fail ("int.Parse(invariant culture)");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt32 ("2147483648");
- AssertType.Fail ("2147483648");
+ Assert.Fail ("2147483648");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt32 ("-2147483649");
- AssertType.Fail ("-2147483649");
+ Assert.Fail ("-2147483649");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt32 ("0x10000");
- AssertType.Fail ("0x10000");
+ Assert.Fail ("0x10000");
} catch (FormatException) {
}
}
[Test]
public void ToInt64 ()
{
- AssertType.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
- AssertType.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
- AssertType.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
- AssertType.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
- AssertType.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
+ Assert.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
+ Assert.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
+ Assert.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
+ Assert.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
+ Assert.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
try {
XmlConvert.ToInt64 ("9223372036854775808");
- AssertType.Fail ("9223372036854775808");
+ Assert.Fail ("9223372036854775808");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt64 ("-9223372036854775809");
- AssertType.Fail ("-9223372036854775809");
+ Assert.Fail ("-9223372036854775809");
} catch (OverflowException) {
}
try {
XmlConvert.ToInt64 ("0x10000");
- AssertType.Fail ("0x10000");
+ Assert.Fail ("0x10000");
} catch (FormatException) {
}
}
[Test]
public void ToSByte ()
{
- AssertType.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
- AssertType.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
- AssertType.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
- AssertType.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
- AssertType.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
+ Assert.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
+ Assert.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
+ Assert.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
+ Assert.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
+ Assert.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
try {
XmlConvert.ToSByte ("128");
- AssertType.Fail ("128");
+ Assert.Fail ("128");
} catch (OverflowException) {
}
try {
XmlConvert.ToSByte ("-129");
- AssertType.Fail ("-129");
+ Assert.Fail ("-129");
} catch (OverflowException) {
}
try {
XmlConvert.ToSByte ("0x80");
- AssertType.Fail ("0x80");
+ Assert.Fail ("0x80");
} catch (FormatException) {
}
}
// Don't include TimeZone value for test value.
string dateString =
XmlConvert.ToString (new DateTime (2003, 5, 5));
- AssertEquals (33, dateString.Length);
- AssertEquals ("2003-05-05T00:00:00.0000000", dateString.Substring (0, 27));
+ Assert.AreEqual (33, dateString.Length);
+ Assert.AreEqual (dateString.Substring (0, 27), "2003-05-05T00:00:00.0000000");
}
[Test]
// bug #77252
TimeSpan t1 = TimeSpan.FromTicks (
TimeSpan.TicksPerSecond + 1);
- AssertEquals ("PT1.0000001S", XmlConvert.ToString (t1));
+ Assert.AreEqual ("PT1.0000001S", XmlConvert.ToString (t1));
}
[Test]
public void ToTimeSpan ()
{
- AssertEquals ("#1", new TimeSpan (0, 0, 0, 0, 1),
- XmlConvert.ToTimeSpan ("PT0.001S"));
+ Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 1), XmlConvert.ToTimeSpan ("PT0.001S"), "#1");
// bug #76328
- AssertEquals ("#2", new TimeSpan (0, 0, 0, 0, 100),
- XmlConvert.ToTimeSpan ("PT0.1S"));
- AssertEquals ("#3", new TimeSpan (0, 0, 0, 0, 100),
- XmlConvert.ToTimeSpan ("PT0.100S"));
- AssertEquals ("#4", new TimeSpan (0, 0, 0, 0, 10),
- XmlConvert.ToTimeSpan ("PT0.010S"));
- AssertEquals ("#5", new TimeSpan (0, 0, 0, 0, 10),
- XmlConvert.ToTimeSpan ("PT0.01S"));
+ Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.1S"), "#2");
+ Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.100S"), "#3");
+ Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.010S"), "#4");
+ Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.01S"), "#5");
// bug #77252
- AssertEquals ("#6",
- TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1),
- XmlConvert.ToTimeSpan ("PT1.0000001S"));
+ Assert.AreEqual (TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1), XmlConvert.ToTimeSpan ("PT1.0000001S"), "#6");
- AssertEquals ("#7",
- TimeSpan.MinValue,
- XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"));
+ Assert.AreEqual (TimeSpan.MinValue, XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"), "#7");
- AssertEquals ("#8",
- TimeSpan.MaxValue,
- XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"));
+ Assert.AreEqual (TimeSpan.MaxValue, XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"), "#8");
}
[Test]
public void ToUInt16 ()
{
- AssertType.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
- AssertType.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
- AssertType.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
+ Assert.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
+ Assert.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
+ Assert.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
try {
ushort.Parse ("65536", CultureInfo.CurrentCulture);
- AssertType.Fail ("ushort.Parse(current culture)");
+ Assert.Fail ("ushort.Parse(current culture)");
} catch (OverflowException) {
}
try {
ushort.Parse ("65536", CultureInfo.InvariantCulture);
- AssertType.Fail ("ushort.Parse(invariant culture)");
+ Assert.Fail ("ushort.Parse(invariant culture)");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt16 ("65536");
- AssertType.Fail ("65536");
+ Assert.Fail ("65536");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt16 ("0x10000");
- AssertType.Fail ("0x10000");
+ Assert.Fail ("0x10000");
} catch (FormatException) {
}
}
[Test]
public void ToUInt32 ()
{
- AssertType.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
- AssertType.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
- AssertType.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
+ Assert.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
+ Assert.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
+ Assert.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
try {
uint.Parse ("4294967296", CultureInfo.CurrentCulture);
- AssertType.Fail ("uint.Parse(current culture)");
+ Assert.Fail ("uint.Parse(current culture)");
} catch (OverflowException) {
}
try {
uint.Parse ("4294967296", CultureInfo.InvariantCulture);
- AssertType.Fail ("uint.Parse(invariant culture)");
+ Assert.Fail ("uint.Parse(invariant culture)");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt32 ("4294967296");
- AssertType.Fail ("4294967296");
+ Assert.Fail ("4294967296");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt32 ("0x10000");
- AssertType.Fail ("0x10000");
+ Assert.Fail ("0x10000");
} catch (FormatException) {
}
}
[Test]
public void ToUInt64 ()
{
- AssertType.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
- AssertType.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
- AssertType.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
+ Assert.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
+ Assert.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
+ Assert.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
try {
ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
- AssertType.Fail ("ulong.Parse(current culture)");
+ Assert.Fail ("ulong.Parse(current culture)");
} catch (OverflowException) {
}
try {
ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
- AssertType.Fail ("ulong.Parse(invariant culture)");
+ Assert.Fail ("ulong.Parse(invariant culture)");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt64 ("18446744073709551616");
- AssertType.Fail ("18446744073709551616");
+ Assert.Fail ("18446744073709551616");
} catch (OverflowException) {
}
try {
XmlConvert.ToUInt64 ("0x10000");
- AssertType.Fail ("0x10000");
+ Assert.Fail ("0x10000");
} catch (FormatException) {
}
}
try {
XmlConvert.VerifyName (value);
} catch (XmlException) {
- AssertType.Fail (String.Format ("'{0}'", value));
+ Assert.Fail (String.Format ("'{0}'", value));
}
}
{
try {
XmlConvert.VerifyName (value);
- AssertType.Fail (value);
+ Assert.Fail (value);
} catch (XmlException) {
}
}
[Test]
public void VerifyNCName ()
{
- AssertEquals ("foo", XmlConvert.VerifyNCName ("foo"));
+ Assert.AreEqual ("foo", XmlConvert.VerifyNCName ("foo"));
try {
XmlConvert.VerifyNCName ("?foo");
- Fail ();
+ Assert.Fail ();
} catch (XmlException) {}
try {
XmlConvert.VerifyNCName (":foo");
- Fail ();
+ Assert.Fail ();
} catch (XmlException) {}
try {
XmlConvert.VerifyNCName ("foo:bar");
- Fail ();
+ Assert.Fail ();
} catch (XmlException) {}
try {
XmlConvert.VerifyNCName ("foo:bar:baz");
- Fail ();
+ Assert.Fail ();
} catch (XmlException) {}
}
[Test]
public void DurationZero () // bug #77350
{
- AssertEquals ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
+ Assert.AreEqual ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
}
#if NET_2_0
XmlConvert.VerifyTOKEN (s);
if (success)
return;
- AssertType.Fail (s + "should fail");
+ Assert.Fail (s + "should fail");
} catch (XmlException ex) {
if (success)
- AssertType.Fail (s + "should not fail");
+ Assert.Fail (s + "should not fail");
}
}
[Test]
public void XmlDateTimeSerializationModeAndMaxValue ()
{
- AssertEquals ("#1", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Unspecified).Substring (0, 27));
- AssertEquals ("#2", "9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Utc));
- AssertEquals ("#3", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.RoundtripKind));
- AssertEquals ("#4", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Local).Substring (0, 27));
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Unspecified).Substring (0, 27), "#1");
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Utc), "#2");
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.RoundtripKind), "#3");
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Local).Substring (0, 27), "#4");
// direct formatting string - no difference
- AssertEquals ("#5", "9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ"));
- AssertEquals ("#6", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz").Substring (0, 27));
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ"), "#5");
+ Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz").Substring (0, 27), "#6");
}
[Test]
{
string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
string s = XmlConvert.ToString (DateTime.UtcNow, format);
- AssertType.AreEqual ('Z', s [s.Length -1], "#1-1");
+ Assert.AreEqual ('Z', s [s.Length -1], "#1-1");
// LAMESPEC: .NET has a bug here that 'K' in format string does not reflect 'Z' as Utc Kind.
// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=307694
- //AssertType.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, format).Kind, "#1-2");
+ //Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, format).Kind, "#1-2");
s = XmlConvert.ToString (DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind);
- AssertType.AreEqual ('Z', s [s.Length -1], "#2-1");
- AssertType.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, XmlDateTimeSerializationMode.RoundtripKind).Kind, "#2-2");
+ Assert.AreEqual ('Z', s [s.Length -1], "#2-1");
+ Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, XmlDateTimeSerializationMode.RoundtripKind).Kind, "#2-2");
}
[Test]
public void XmlDateTimeSerializationModeUnspecified ()
{
- AssertEquals ("#1", 27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length);
+ Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Unspecified);
DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Unspecified);
- AssertEquals ("#2", false, dt1 == dt2);
+ Assert.AreEqual (false, dt1 == dt2, "#2");
XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Unspecified);
string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
XmlConvert.ToDateTime (XmlConvert.ToString (DateTime.UtcNow, format), XmlDateTimeSerializationMode.Unspecified);
[Test]
public void XmlDateTimeSerializationModeUtc ()
{
- AssertEquals ("#1", 27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length);
+ Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Utc);
DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Utc);
- AssertEquals ("#2", false, dt1 == dt2);
+ Assert.AreEqual (false, dt1 == dt2, "#2");
XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Utc);
XmlConvert.ToDateTime ("2006-05-30T09:48:32.0+02:00", XmlDateTimeSerializationMode.Utc);
XmlConvert.ToDateTime ("2008-06-11T11:09:47.125Z", XmlDateTimeSerializationMode.Utc);
try {
XmlConvert.ToDateTime ("0001-02-03T", m);
- AssertType.Fail ("#1");
+ Assert.Fail ("#1");
} catch (FormatException) {
}
try {
XmlConvert.ToDateTime ("0001-02-03T10:20", m);
- AssertType.Fail ("#2");
+ Assert.Fail ("#2");
} catch (FormatException) {
}
try {
XmlConvert.ToDateTime ("0001-02-03T10:20:30.", m);
- AssertType.Fail ("#3");
+ Assert.Fail ("#3");
} catch (FormatException) {
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlDeclarationTests : Assertion
+ public class XmlDeclarationTests
{
XmlDocument document;
XmlDeclaration declaration;
public void InnerAndOuterXml ()
{
declaration = document.CreateXmlDeclaration ("1.0", null, null);
- AssertEquals (String.Empty, declaration.InnerXml);
- AssertEquals ("<?xml version=\"1.0\"?>", declaration.OuterXml);
+ Assert.AreEqual (String.Empty, declaration.InnerXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?>", declaration.OuterXml);
declaration = document.CreateXmlDeclaration ("1.0", "doesn't check", null);
- AssertEquals (String.Empty, declaration.InnerXml);
- AssertEquals ("<?xml version=\"1.0\" encoding=\"doesn't check\"?>", declaration.OuterXml);
+ Assert.AreEqual (String.Empty, declaration.InnerXml);
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"doesn't check\"?>", declaration.OuterXml);
declaration = document.CreateXmlDeclaration ("1.0", null, "yes");
- AssertEquals (String.Empty, declaration.InnerXml);
- AssertEquals ("<?xml version=\"1.0\" standalone=\"yes\"?>", declaration.OuterXml);
+ Assert.AreEqual (String.Empty, declaration.InnerXml);
+ Assert.AreEqual ("<?xml version=\"1.0\" standalone=\"yes\"?>", declaration.OuterXml);
declaration = document.CreateXmlDeclaration ("1.0", "foo", "no");
- AssertEquals (String.Empty, declaration.InnerXml);
- AssertEquals ("<?xml version=\"1.0\" encoding=\"foo\" standalone=\"no\"?>", declaration.OuterXml);
+ Assert.AreEqual (String.Empty, declaration.InnerXml);
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"foo\" standalone=\"no\"?>", declaration.OuterXml);
}
internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
{
// assertequals (original.nodetype + " was incorrectly cloned.",
// original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
+ Assert.IsNull (cloned.ParentNode);
- AssertEquals ("Value incorrectly cloned",
- original.Value, cloned.Value);
+ Assert.AreEqual (original.Value, cloned.Value, "Value incorrectly cloned");
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
[Test]
return;
} catch (Exception e) {
- Fail("first arg null, wrong exception: " + e.ToString());
+ Assert.Fail ("first arg null, wrong exception: " + e.ToString());
}
}
[Test]
public void NodeType ()
{
- AssertEquals ("incorrect NodeType returned", XmlNodeType.XmlDeclaration, declaration.NodeType);
+ Assert.AreEqual (XmlNodeType.XmlDeclaration, declaration.NodeType, "incorrect NodeType returned");
}
[Test]
public void Names ()
{
- AssertEquals ("Name is incorrect", "xml", declaration.Name);
- AssertEquals ("LocalName is incorrect", "xml", declaration.LocalName);
+ Assert.AreEqual ("xml", declaration.Name, "Name is incorrect");
+ Assert.AreEqual ("xml", declaration.LocalName, "LocalName is incorrect");
}
[Test]
public void EncodingProperty ()
{
XmlDeclaration d1 = document.CreateXmlDeclaration ("1.0", "foo", null);
- AssertEquals ("Encoding property", "foo", d1.Encoding);
+ Assert.AreEqual ("foo", d1.Encoding, "Encoding property");
XmlDeclaration d2 = document.CreateXmlDeclaration ("1.0", null, null);
- AssertEquals ("null Encoding property", String.Empty, d2.Encoding);
+ Assert.AreEqual (String.Empty, d2.Encoding, "null Encoding property");
}
[Test]
public void StandaloneProperty ()
{
XmlDeclaration d1 = document.CreateXmlDeclaration ("1.0", null, "yes");
- AssertEquals ("Yes standalone property", "yes", d1.Standalone);
+ Assert.AreEqual ("yes", d1.Standalone, "Yes standalone property");
XmlDeclaration d2 = document.CreateXmlDeclaration ("1.0", null, "no");
- AssertEquals ("No standalone property", "no", d2.Standalone);
+ Assert.AreEqual ("no", d2.Standalone, "No standalone property");
XmlDeclaration d3 = document.CreateXmlDeclaration ("1.0", null, null);
- AssertEquals ("null Standalone property", String.Empty, d3.Standalone);
+ Assert.AreEqual (String.Empty, d3.Standalone, "null Standalone property");
}
[Test]
string expected = "version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"yes\"" ;
XmlDeclaration d = document.CreateXmlDeclaration ("1.0", "ISO-8859-1", "yes");
- AssertEquals ("Value property", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value property");
d.Value = expected;
- AssertEquals ("Value round-trip", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip");
d.Value = " " + expected;
- AssertEquals ("Value round-trip (padded)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip (padded)");
d.Value = "version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"yes\"" ;
- AssertEquals ("Value round-trip (padded 2)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip (padded 2)");
d.Value = "version=\"1.0\"\tencoding=\"ISO-8859-1\" standalone=\"yes\"" ;
- AssertEquals ("Value round-trip (\\t)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip (\\t)");
d.Value = "version=\"1.0\"\n encoding=\"ISO-8859-1\" standalone=\"yes\"" ;
- AssertEquals ("Value round-trip (\\n)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip (\\n)");
d.Value = "version=\"1.0\" encoding = \"ISO-8859-1\" standalone = \"yes\"" ;
- AssertEquals ("Value round-trip (spaces)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip (spaces)");
d.Value = "version='1.0' encoding='ISO-8859-1' standalone='yes'" ;
- AssertEquals ("Value round-trip ('s)", expected, d.Value);
+ Assert.AreEqual (expected, d.Value, "Value round-trip ('s)");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (sw.ToString ());
- Assert
Equals ("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?><person />", doc.OuterXml);
+ Assert
.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?><person />", doc.OuterXml);
}
[Test]
XmlNode deep = declaration.CloneNode (true); // deep
XmlNodeBaseProperties (original, deep);
- AssertEquals ("deep cloning differs from shallow cloning",
- deep.OuterXml, shallow.OuterXml);
+ Assert.AreEqual (deep.OuterXml, shallow.OuterXml, "deep cloning differs from shallow cloning");
}
}
}
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XmlDocumentEventTests : Assertion\r
+ public class XmlDocumentEventTests\r
{\r
public static void Main ()\r
{\r
XmlElement el = document.CreateElement ("root");\r
el.AppendChild (document.CreateTextNode ("simple text node."));\r
document.AppendChild (el);\r
- AssertEquals (\r
- "Inserting: Text into Element.\n" +\r
+ Assert.AreEqual ("Inserting: Text into Element.\n" +\r
"Inserted: Text into Element.\n" +\r
"Inserting: Element into Document.\n" +\r
"Inserted: Element into Document.\n",\r
doc.LoadXml ("<!DOCTYPE root [<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def'>]><root></root>");\r
SetEvents (doc);\r
doc.DocumentElement.RemoveAll ();\r
- AssertEquals (\r
- "Removing: Attribute from Element.\n" +\r
+ Assert.AreEqual ("Removing: Attribute from Element.\n" +\r
"Removed: Attribute from Element.\n" +\r
"Inserting: Text into Attribute.\n" +\r
"Inserted: Text into Attribute.\n" +\r
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlDocumentFragmentTests : Assertion
+ public class XmlDocumentFragmentTests
{
XmlDocument document;
XmlDocumentFragment fragment;
{
XmlDocument d = new XmlDocument ();
XmlDocumentFragment df = d.CreateDocumentFragment ();
- AssertEquals ("#Constructor.NodeName", "#document-fragment", df.Name);
- AssertEquals ("#Constructor.NodeType", XmlNodeType.DocumentFragment, df.NodeType);
+ Assert.AreEqual ("#document-fragment", df.Name, "#Constructor.NodeName");
+ Assert.AreEqual (XmlNodeType.DocumentFragment, df.NodeType, "#Constructor.NodeType");
}
[Test]
// 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);
+ Assert.IsNotNull (fragment.FirstChild, "#AppendChildToFragment.Element");
+ Assert.IsNotNull (fragment.FirstChild.FirstChild, "#AppendChildToFragment.Element.Children");
+ Assert.AreEqual ("Test Paragraph", fragment.FirstChild.FirstChild.Value, "#AppendChildToFragment.Element.Child.Text");
}
[Test]
// 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);
+ Assert.IsNotNull (body.FirstChild, "#AppendFragmentToElement.Exist");
+ Assert.AreEqual (XmlNodeType.Element, body.FirstChild.NodeType, "#AppendFragmentToElement.ChildIsElement");
+ Assert.AreEqual ("p", body.FirstChild.Name, "#AppendFragmentToElement.FirstChild");
+ Assert.AreEqual ("div", body.LastChild.Name, "#AppendFragmentToElement.LastChild");
}
[Test]
fragment.AppendChild (document.CreateElement ("foo"));
fragment.AppendChild (document.CreateElement ("bar"));
fragment.AppendChild (document.CreateElement ("baz"));
- AssertEquals ("#Simple", "<foo /><bar /><baz />", fragment.InnerXml);
+ Assert.AreEqual ("<foo /><bar /><baz />", fragment.InnerXml, "#Simple");
}
[Test]
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);
+ Assert.AreEqual ("foo", fragment.FirstChild.Name);
+ Assert.AreEqual ("bar", fragment.FirstChild.NextSibling.Name);
+ Assert.AreEqual ("child", fragment.FirstChild.NextSibling.FirstChild.Name);
+ Assert.AreEqual ("baz", fragment.LastChild.Name);
}
[Test]
fragment = document.CreateDocumentFragment ();
string text = "<foo /><bar><child /></bar><baz />";
fragment.InnerText = text;
- AssertEquals (text, fragment.InnerText);
+ Assert.AreEqual (text, fragment.InnerText);
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlDocumentTests : Assertion
+ public class XmlDocumentTests
{
private XmlDocument document;
private ArrayList eventStrings = new ArrayList();
{
try {
document.CreateNode (null, null, null);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
} catch (ArgumentException) {}
try {
document.CreateNode ("attribute", null, null);
- Fail ("Expected a NullReferenceException to be thrown.");
+ Assert.Fail ("Expected a NullReferenceException to be thrown.");
} catch (NullReferenceException) {}
try {
document.CreateNode ("attribute", "", null);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
} catch (ArgumentException) {}
try {
document.CreateNode ("element", null, null);
- Fail ("Expected a NullReferenceException to be thrown.");
+ Assert.Fail ("Expected a NullReferenceException to be thrown.");
} catch (NullReferenceException) {}
try {
document.CreateNode ("element", "", null);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
} catch (ArgumentException) {}
try {
document.CreateNode ("entityreference", null, null);
- Fail ("Expected a NullReferenceException to be thrown.");
+ Assert.Fail ("Expected a NullReferenceException to be thrown.");
} catch (NullReferenceException) {}
}
try {
node = document.CreateNode (XmlNodeType.EndElement, null, null);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
} catch (InvalidNodeTypeArgException) {}
try {
node = document.CreateNode (XmlNodeType.EndEntity, null, null);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
} catch (InvalidNodeTypeArgException) {}
try {
node = document.CreateNode (XmlNodeType.Entity, null, null);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
} catch (InvalidNodeTypeArgException) {}
try {
node = document.CreateNode (XmlNodeType.None, null, null);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
} catch (InvalidNodeTypeArgException) {}
try {
node = document.CreateNode (XmlNodeType.Notation, null, null);
- Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
} catch (InvalidNodeTypeArgException) {}
// TODO: undocumented allowable type.
node = document.CreateNode (XmlNodeType.XmlDeclaration, null, null);
- AssertEquals (XmlNodeType.XmlDeclaration, node.NodeType);
+ Assert.AreEqual (XmlNodeType.XmlDeclaration, node.NodeType);
}
[Test]
// No constructor params for Document, DocumentFragment.
node = document.CreateNode (XmlNodeType.CDATA, "a", "b", "c");
- AssertEquals (String.Empty, ((XmlCDataSection)node).Value);
+ Assert.AreEqual (String.Empty, ((XmlCDataSection)node).Value);
node = document.CreateNode (XmlNodeType.Comment, "a", "b", "c");
- AssertEquals (String.Empty, ((XmlComment)node).Value);
+ Assert.AreEqual (String.Empty, ((XmlComment)node).Value);
node = document.CreateNode (XmlNodeType.DocumentType, "a", "b", "c");
- AssertNull (((XmlDocumentType)node).Value);
+ Assert.IsNull (((XmlDocumentType)node).Value);
// TODO: add this back in to test when it's implemented.
// node = document.CreateNode (XmlNodeType.EntityReference, "a", "b", "c");
-// AssertNull (((XmlEntityReference)node).Value);
+// Assert.IsNull (((XmlEntityReference)node).Value);
// TODO: add this back in to test when it's implemented.
// node = document.CreateNode (XmlNodeType.ProcessingInstruction, "a", "b", "c");
-// AssertEquals (String.Empty, ((XmlProcessingInstruction)node).Value);
+// Assert.AreEqual (String.Empty, ((XmlProcessingInstruction)node).Value);
node = document.CreateNode (XmlNodeType.SignificantWhitespace, "a", "b", "c");
- AssertEquals (String.Empty, ((XmlSignificantWhitespace)node).Value);
+ Assert.AreEqual (String.Empty, ((XmlSignificantWhitespace)node).Value);
node = document.CreateNode (XmlNodeType.Text, "a", "b", "c");
- AssertEquals (String.Empty, ((XmlText)node).Value);
+ Assert.AreEqual (String.Empty, ((XmlText)node).Value);
node = document.CreateNode (XmlNodeType.Whitespace, "a", "b", "c");
- AssertEquals (String.Empty, ((XmlWhitespace)node).Value);
+ Assert.AreEqual (String.Empty, ((XmlWhitespace)node).Value);
node = document.CreateNode (XmlNodeType.XmlDeclaration, "a", "b", "c");
- AssertEquals ("version=\"1.0\"", ((XmlDeclaration)node).Value);
+ Assert.AreEqual ("version=\"1.0\"", ((XmlDeclaration)node).Value);
}
[Test]
try {
node = document.CreateNode ("foo", null, null);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
} catch (ArgumentException) {}
// .NET 2.0 fails here.
node = document.CreateNode("attribute", "foo", null);
- AssertEquals (XmlNodeType.Attribute, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, node.NodeType);
node = document.CreateNode("cdatasection", null, null);
- AssertEquals (XmlNodeType.CDATA, node.NodeType);
+ Assert.AreEqual (XmlNodeType.CDATA, node.NodeType);
node = document.CreateNode("comment", null, null);
- AssertEquals (XmlNodeType.Comment, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Comment, node.NodeType);
node = document.CreateNode("document", null, null);
- AssertEquals (XmlNodeType.Document, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Document, node.NodeType);
// TODO: test which constructor this ended up calling,
// i.e. reuse underlying NameTable or not?
node = document.CreateNode("documentfragment", null, null);
- AssertEquals (XmlNodeType.DocumentFragment, node.NodeType);
+ Assert.AreEqual (XmlNodeType.DocumentFragment, node.NodeType);
node = document.CreateNode("documenttype", null, null);
- AssertEquals (XmlNodeType.DocumentType, node.NodeType);
+ Assert.AreEqual (XmlNodeType.DocumentType, node.NodeType);
node = document.CreateNode("element", "foo", null);
- AssertEquals (XmlNodeType.Element, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Element, node.NodeType);
// TODO: add this back in to test when it's implemented.
// ---> It is implemented, but it is LAMESPEC that allows null entity reference name.
// node = document.CreateNode("entityreference", "foo", null);
-// AssertEquals (XmlNodeType.EntityReference, node.NodeType);
+// Assert.AreEqual (XmlNodeType.EntityReference, node.NodeType);
// LAMESPEC: null PI name is silly.
// node = document.CreateNode("processinginstruction", null, null);
-// AssertEquals (XmlNodeType.ProcessingInstruction, node.NodeType);
+// Assert.AreEqual (XmlNodeType.ProcessingInstruction, node.NodeType);
node = document.CreateNode("significantwhitespace", null, null);
- AssertEquals (XmlNodeType.SignificantWhitespace, node.NodeType);
+ Assert.AreEqual (XmlNodeType.SignificantWhitespace, node.NodeType);
node = document.CreateNode("text", null, null);
- AssertEquals (XmlNodeType.Text, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Text, node.NodeType);
node = document.CreateNode("whitespace", null, null);
- AssertEquals (XmlNodeType.Whitespace, node.NodeType);
+ Assert.AreEqual (XmlNodeType.Whitespace, node.NodeType);
}
[Test]
public void DocumentElement ()
{
- AssertNull (document.DocumentElement);
+ Assert.IsNull (document.DocumentElement);
XmlElement element = document.CreateElement ("foo", "bar", "http://foo/");
- AssertNotNull (element);
+ Assert.IsNotNull (element);
- AssertEquals ("foo", element.Prefix);
- AssertEquals ("bar", element.LocalName);
- AssertEquals ("http://foo/", element.NamespaceURI);
+ Assert.AreEqual ("foo", element.Prefix);
+ Assert.AreEqual ("bar", element.LocalName);
+ Assert.AreEqual ("http://foo/", element.NamespaceURI);
- AssertEquals ("foo:bar", element.Name);
+ Assert.AreEqual ("foo:bar", element.Name);
- AssertSame (element, document.AppendChild (element));
+ Assert.AreSame (element, document.AppendChild (element));
- AssertSame (element, document.DocumentElement);
+ Assert.AreSame (element, document.DocumentElement);
}
[Test]
public void DocumentEmpty()
{
- AssertEquals ("Incorrect output for empty document.", "", document.OuterXml);
+ Assert.AreEqual ("", document.OuterXml, "Incorrect output for empty document.");
}
[Test]
document.AppendChild (document.CreateElement ("foo"));
comment = document.CreateComment ("bar");
document.DocumentElement.AppendChild (comment);
- AssertEquals ("<!--bar-->", document.DocumentElement.InnerXml);
+ Assert.AreEqual ("<!--bar-->", document.DocumentElement.InnerXml);
comment.Value = "baz";
- Assert (eventStrings.Contains ("NodeChanged, Change, <!--baz-->, foo, foo"));
- AssertEquals ("<!--baz-->", document.DocumentElement.InnerXml);
+ Assert.IsTrue (eventStrings.Contains ("NodeChanged, Change, <!--baz-->, foo, foo"));
+ Assert.AreEqual ("<!--baz-->", document.DocumentElement.InnerXml);
// Node that isn't part of the document but created by the document.
element = document.CreateElement ("foo");
comment = document.CreateComment ("bar");
element.AppendChild (comment);
- AssertEquals ("<!--bar-->", element.InnerXml);
+ Assert.AreEqual ("<!--bar-->", element.InnerXml);
comment.Value = "baz";
- Assert (eventStrings.Contains ("NodeChanged, Change, <!--baz-->, foo, foo"));
- AssertEquals ("<!--baz-->", element.InnerXml);
+ Assert.IsTrue (eventStrings.Contains ("NodeChanged, Change, <!--baz-->, foo, foo"));
+ Assert.AreEqual ("<!--baz-->", element.InnerXml);
/*
TODO: Insert this when XmlNode.InnerText() and XmlNode.InnerXml() have been implemented.
element.InnerText = "bar";
document.AppendChild(element);
element.InnerText = "baz";
- Assert(eventStrings.Contains("NodeChanged, Change, baz, foo, foo"));
+ Assert.IsTrue (eventStrings.Contains("NodeChanged, Change, baz, foo, foo"));
// Node that isn't part of the document but created by the document.
element = document.CreateElement("qux");
element.InnerText = "quux";
element.InnerText = "quuux";
- Assert(eventStrings.Contains("NodeChanged, Change, quuux, qux, qux"));
+ Assert.IsTrue (eventStrings.Contains("NodeChanged, Change, quuux, qux, qux"));
*/
}
document.AppendChild (document.CreateElement ("foo"));
comment = document.CreateComment ("bar");
document.DocumentElement.AppendChild (comment);
- AssertEquals ("<!--bar-->", document.DocumentElement.InnerXml);
+ Assert.AreEqual ("<!--bar-->", document.DocumentElement.InnerXml);
comment.Value = "baz";
- Assert (eventStrings.Contains ("NodeChanging, Change, <!--bar-->, foo, foo"));
- AssertEquals ("<!--baz-->", document.DocumentElement.InnerXml);
+ Assert.IsTrue (eventStrings.Contains ("NodeChanging, Change, <!--bar-->, foo, foo"));
+ Assert.AreEqual ("<!--baz-->", document.DocumentElement.InnerXml);
// Node that isn't part of the document but created by the document.
element = document.CreateElement ("foo");
comment = document.CreateComment ("bar");
element.AppendChild (comment);
- AssertEquals ("<!--bar-->", element.InnerXml);
+ Assert.AreEqual ("<!--bar-->", element.InnerXml);
comment.Value = "baz";
- Assert (eventStrings.Contains ("NodeChanging, Change, <!--bar-->, foo, foo"));
- AssertEquals ("<!--baz-->", element.InnerXml);
+ Assert.IsTrue (eventStrings.Contains ("NodeChanging, Change, <!--bar-->, foo, foo"));
+ Assert.AreEqual ("<!--baz-->", element.InnerXml);
// If an exception is thrown the Document returns to original state.
document.NodeChanging += new XmlNodeChangedEventHandler (this.EventNodeChangingException);
element = document.CreateElement("foo");
comment = document.CreateComment ("bar");
element.AppendChild (comment);
- AssertEquals ("<!--bar-->", element.InnerXml);
+ Assert.AreEqual ("<!--bar-->", element.InnerXml);
try
{
comment.Value = "baz";
- Fail("Expected an exception to be thrown by the NodeChanging event handler method EventNodeChangingException().");
+ Assert.Fail ("Expected an exception to be thrown by the NodeChanging event handler method EventNodeChangingException().");
} catch (Exception) {}
- AssertEquals ("<!--bar-->", element.InnerXml);
+ Assert.AreEqual ("<!--bar-->", element.InnerXml);
// Yes it's a bit anal but this tests whether the node changing event exception fires before the
// ArgumentOutOfRangeException. Turns out it does so that means our implementation needs to raise
try
{
comment.ReplaceData(-1, 0, "qux");
- Fail("Expected an ArgumentOutOfRangeException to be thrown.");
+ Assert.Fail ("Expected an ArgumentOutOfRangeException to be thrown.");
}
catch (Exception) {}
element.InnerText = "bar";
document.AppendChild(element);
element.InnerText = "baz";
- Assert(eventStrings.Contains("NodeChanging, Change, bar, foo, foo"));
+ Assert.IsTrue (eventStrings.Contains("NodeChanging, Change, bar, foo, foo"));
// Node that isn't part of the document but created by the document.
element = document.CreateElement("foo");
element.InnerText = "bar";
element.InnerText = "baz";
- Assert(eventStrings.Contains("NodeChanging, Change, bar, foo, foo"));
+ Assert.IsTrue (eventStrings.Contains("NodeChanging, Change, bar, foo, foo"));
// If an exception is thrown the Document returns to original state.
document.NodeChanging += new XmlNodeChangedEventHandler (this.EventNodeChangingException);
element.InnerText = "bar";
try {
element.InnerText = "baz";
- Fail("Expected an exception to be thrown by the NodeChanging event handler method EventNodeChangingException().");
+ Assert.Fail ("Expected an exception to be thrown by the NodeChanging event handler method EventNodeChangingException().");
} catch (Exception) {}
- AssertEquals("bar", element.InnerText);
+ Assert.AreEqual ("bar", element.InnerText);
*/
}
// Inserted 'foo' element to the document.
element = document.CreateElement ("foo");
document.AppendChild (element);
- Assert (eventStrings.Contains ("NodeInserted, Insert, <foo />, <none>, #document"));
+ Assert.IsTrue (eventStrings.Contains ("NodeInserted, Insert, <foo />, <none>, #document"));
// Append child on node in document
element = document.CreateElement ("foo");
document.DocumentElement.AppendChild (element);
- Assert (eventStrings.Contains ("NodeInserted, Insert, <foo />, <none>, foo"));
+ Assert.IsTrue (eventStrings.Contains ("NodeInserted, Insert, <foo />, <none>, foo"));
// Append child on node not in document but created by document
element = document.CreateElement ("bar");
element.AppendChild(document.CreateElement ("bar"));
- Assert(eventStrings.Contains("NodeInserted, Insert, <bar />, <none>, bar"));
+ Assert.IsTrue (eventStrings.Contains("NodeInserted, Insert, <bar />, <none>, bar"));
}
[Test]
// Inserting 'foo' element to the document.
element = document.CreateElement ("foo");
document.AppendChild (element);
- Assert (eventStrings.Contains ("NodeInserting, Insert, <foo />, <none>, #document"));
+ Assert.IsTrue (eventStrings.Contains ("NodeInserting, Insert, <foo />, <none>, #document"));
// Append child on node in document
element = document.CreateElement ("foo");
document.DocumentElement.AppendChild (element);
- Assert(eventStrings.Contains ("NodeInserting, Insert, <foo />, <none>, foo"));
+ Assert.IsTrue (eventStrings.Contains ("NodeInserting, Insert, <foo />, <none>, foo"));
// Append child on node not in document but created by document
element = document.CreateElement ("bar");
- AssertEquals (0, element.ChildNodes.Count);
+ Assert.AreEqual (0, element.ChildNodes.Count);
element.AppendChild (document.CreateElement ("bar"));
- Assert (eventStrings.Contains ("NodeInserting, Insert, <bar />, <none>, bar"));
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeInserting, Insert, <bar />, <none>, bar"));
+ Assert.AreEqual (1, element.ChildNodes.Count);
// If an exception is thrown the Document returns to original state.
document.NodeInserting += new XmlNodeChangedEventHandler (this.EventNodeInsertingException);
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
try
{
element.AppendChild (document.CreateElement("baz"));
- Fail ("Expected an exception to be thrown by the NodeInserting event handler method EventNodeInsertingException().");
+ Assert.Fail ("Expected an exception to be thrown by the NodeInserting event handler method EventNodeInsertingException().");
}
catch (Exception) {}
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
}
[Test]
element = document.CreateElement ("foo");
element2 = document.CreateElement ("bar");
element.AppendChild (element2);
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
element.RemoveChild (element2);
- Assert (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
- AssertEquals (0, element.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, element.ChildNodes.Count);
/*
* TODO: put this test back in when AttributeCollection.RemoveAll() is implemented.
element = document.CreateElement ("foo");
element2 = document.CreateElement ("bar");
element.AppendChild(element2);
- AssertEquals(1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
element.RemoveAll();
- Assert (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
- AssertEquals(0, element.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, element.ChildNodes.Count);
*/
// Removed 'bar' element from 'foo' inside document.
document.AppendChild (element);
element = document.CreateElement ("bar");
document.DocumentElement.AppendChild (element);
- AssertEquals (1, document.DocumentElement.ChildNodes.Count);
+ Assert.AreEqual (1, document.DocumentElement.ChildNodes.Count);
document.DocumentElement.RemoveChild (element);
- Assert (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
- AssertEquals (0, document.DocumentElement.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoved, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, document.DocumentElement.ChildNodes.Count);
}
[Test]
element = document.CreateElement ("foo");
element2 = document.CreateElement ("bar");
element.AppendChild (element2);
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
element.RemoveChild (element2);
- Assert (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
- AssertEquals (0, element.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, element.ChildNodes.Count);
/*
* TODO: put this test back in when AttributeCollection.RemoveAll() is implemented.
element = document.CreateElement ("foo");
element2 = document.CreateElement ("bar");
element.AppendChild(element2);
- AssertEquals(1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
element.RemoveAll();
- Assert (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
- AssertEquals(0, element.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, element.ChildNodes.Count);
*/
// Removing 'bar' element from 'foo' inside document.
document.AppendChild (element);
element = document.CreateElement ("bar");
document.DocumentElement.AppendChild (element);
- AssertEquals (1, document.DocumentElement.ChildNodes.Count);
+ Assert.AreEqual (1, document.DocumentElement.ChildNodes.Count);
document.DocumentElement.RemoveChild (element);
- Assert (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
- AssertEquals (0, document.DocumentElement.ChildNodes.Count);
+ Assert.IsTrue (eventStrings.Contains ("NodeRemoving, Remove, <bar />, foo, <none>"));
+ Assert.AreEqual (0, document.DocumentElement.ChildNodes.Count);
// If an exception is thrown the Document returns to original state.
document.NodeRemoving += new XmlNodeChangedEventHandler (this.EventNodeRemovingException);
element.AppendChild (element2);
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
try
{
element.RemoveChild(element2);
- Fail ("Expected an exception to be thrown by the NodeRemoving event handler method EventNodeRemovingException().");
+ Assert.Fail ("Expected an exception to be thrown by the NodeRemoving event handler method EventNodeRemovingException().");
}
catch (Exception) {}
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
}
[Test]
document = new XmlDocument ();
document.Load (memoryStream);
XmlNodeList bookList = document.GetElementsByTagName ("book");
- AssertEquals ("GetElementsByTagName (string) returned incorrect count.", 4, bookList.Count);
+ Assert.AreEqual (4, bookList.Count, "GetElementsByTagName (string) returned incorrect count.");
}
[Test]
document = new XmlDocument ();
document.Load (memoryStream);
XmlNodeList bookList = document.GetElementsByTagName ("book", "http://www.goo.com");
- AssertEquals ("GetElementsByTagName (string, uri) returned incorrect count.", 2, bookList.Count);
+ Assert.AreEqual (2, bookList.Count, "GetElementsByTagName (string, uri) returned incorrect count.");
}
[Test]
// id='b' has different prefix. Should not caught by (name),
// while should caught by (name, ns).
XmlNodeList nl = document.GetElementsByTagName ("x:a");
- AssertEquals (2, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("c", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual (2, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [1].Attributes ["id"].Value);
nl = document.GetElementsByTagName ("a", "urn:foo");
- AssertEquals (3, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual (3, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
// name wildcard
nl = document.GetElementsByTagName ("*");
- AssertEquals (6, nl.Count);
- AssertEquals ("root", nl [0].Name);
- AssertEquals ("a", nl [1].Attributes ["id"].Value);
- AssertEquals ("b", nl [2].Attributes ["id"].Value);
- AssertEquals ("c", nl [3].Attributes ["id"].Value);
- AssertEquals ("d", nl [4].Attributes ["id"].Value);
- AssertEquals ("e", nl [5].Attributes ["id"].Value);
+ Assert.AreEqual (6, nl.Count);
+ Assert.AreEqual ("root", nl [0].Name);
+ Assert.AreEqual ("a", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual ("d", nl [4].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [5].Attributes ["id"].Value);
// wildcard - local and ns
nl = document.GetElementsByTagName ("*", "*");
- AssertEquals (6, nl.Count);
- AssertEquals ("root", nl [0].Name);
- AssertEquals ("a", nl [1].Attributes ["id"].Value);
- AssertEquals ("b", nl [2].Attributes ["id"].Value);
- AssertEquals ("c", nl [3].Attributes ["id"].Value);
- AssertEquals ("d", nl [4].Attributes ["id"].Value);
- AssertEquals ("e", nl [5].Attributes ["id"].Value);
+ Assert.AreEqual (6, nl.Count);
+ Assert.AreEqual ("root", nl [0].Name);
+ Assert.AreEqual ("a", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual ("d", nl [4].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [5].Attributes ["id"].Value);
// namespace wildcard - namespace
nl = document.GetElementsByTagName ("*", "urn:foo");
- AssertEquals (4, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
- AssertEquals ("e", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual (4, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [3].Attributes ["id"].Value);
// namespace wildcard - local only. I dare say, such usage is not XML-ish!
nl = document.GetElementsByTagName ("a", "*");
- AssertEquals (3, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual (3, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
}
[Test]
public void Implementation ()
{
- AssertNotNull (new XmlDocument ().Implementation);
+ Assert.IsNotNull (new XmlDocument ().Implementation);
}
[Test]
public void InnerAndOuterXml ()
{
- AssertEquals (String.Empty, document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual (String.Empty, document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
XmlDeclaration declaration = document.CreateXmlDeclaration ("1.0", null, null);
document.AppendChild (declaration);
- AssertEquals ("<?xml version=\"1.0\"?>", document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?>", document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
XmlElement element = document.CreateElement ("foo");
document.AppendChild (element);
- AssertEquals ("<?xml version=\"1.0\"?><foo />", document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?><foo />", document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
XmlComment comment = document.CreateComment ("bar");
document.DocumentElement.AppendChild (comment);
- AssertEquals ("<?xml version=\"1.0\"?><foo><!--bar--></foo>", document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?><foo><!--bar--></foo>", document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
XmlText text = document.CreateTextNode ("baz");
document.DocumentElement.AppendChild (text);
- AssertEquals ("<?xml version=\"1.0\"?><foo><!--bar-->baz</foo>", document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?><foo><!--bar-->baz</foo>", document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
element = document.CreateElement ("quux");
element.SetAttribute ("quuux", "squonk");
document.DocumentElement.AppendChild (element);
- AssertEquals ("<?xml version=\"1.0\"?><foo><!--bar-->baz<quux quuux=\"squonk\" /></foo>", document.InnerXml);
- AssertEquals (document.InnerXml, document.OuterXml);
+ Assert.AreEqual ("<?xml version=\"1.0\"?><foo><!--bar-->baz<quux quuux=\"squonk\" /></foo>", document.InnerXml);
+ Assert.AreEqual (document.InnerXml, document.OuterXml);
}
[Test]
MemoryStream memoryStream = new MemoryStream (Encoding.UTF8.GetBytes (xml));
document = new XmlDocument ();
document.Load (memoryStream);
- AssertEquals ("Not Loaded From IOStream", true, document.HasChildNodes);
+ Assert.AreEqual (true, document.HasChildNodes, "Not Loaded From IOStream");
}
[Test]
public void LoadXmlCDATA ()
{
document.LoadXml ("<foo><![CDATA[bar]]></foo>");
- Assert (document.DocumentElement.FirstChild.NodeType == XmlNodeType.CDATA);
- AssertEquals ("bar", document.DocumentElement.FirstChild.Value);
+ Assert.IsTrue (document.DocumentElement.FirstChild.NodeType == XmlNodeType.CDATA);
+ Assert.AreEqual ("bar", document.DocumentElement.FirstChild.Value);
}
[Test]
// XmlTextReader needs to throw this exception
// try {
// document.LoadXml("<!--foo-->");
-// Fail("XmlException should have been thrown.");
+// Assert.Fail ("XmlException should have been thrown.");
// }
// catch (XmlException e) {
-// AssertEquals("Exception message doesn't match.", "The root element is missing.", e.Message);
+// Assert.AreEqual ("The root element is missing.", e.Message, "Exception message doesn't match.");
// }
document.LoadXml ("<foo><!--Comment--></foo>");
- Assert (document.DocumentElement.FirstChild.NodeType == XmlNodeType.Comment);
- AssertEquals ("Comment", document.DocumentElement.FirstChild.Value);
+ Assert.IsTrue (document.DocumentElement.FirstChild.NodeType == XmlNodeType.Comment);
+ Assert.AreEqual ("Comment", document.DocumentElement.FirstChild.Value);
document.LoadXml (@"<foo><!--bar--></foo>");
- AssertEquals ("Incorrect target.", "bar", ((XmlComment)document.FirstChild.FirstChild).Data);
+ Assert.AreEqual ("bar", ((XmlComment)document.FirstChild.FirstChild).Data, "Incorrect target.");
}
[Test]
public void LoadXmlElementSingle ()
{
- AssertNull (document.DocumentElement);
+ Assert.IsNull (document.DocumentElement);
document.LoadXml ("<foo/>");
- AssertNotNull (document.DocumentElement);
- AssertSame (document.FirstChild, document.DocumentElement);
+ Assert.IsNotNull (document.DocumentElement);
+ Assert.AreSame (document.FirstChild, document.DocumentElement);
- AssertEquals (String.Empty, document.DocumentElement.Prefix);
- AssertEquals ("foo", document.DocumentElement.LocalName);
- AssertEquals (String.Empty, document.DocumentElement.NamespaceURI);
- AssertEquals ("foo", document.DocumentElement.Name);
+ Assert.AreEqual (String.Empty, document.DocumentElement.Prefix);
+ Assert.AreEqual ("foo", document.DocumentElement.LocalName);
+ Assert.AreEqual (String.Empty, document.DocumentElement.NamespaceURI);
+ Assert.AreEqual ("foo", document.DocumentElement.Name);
}
[Test]
public void LoadXmlElementWithAttributes ()
{
- AssertNull (document.DocumentElement);
+ Assert.IsNull (document.DocumentElement);
document.LoadXml ("<foo bar='baz' quux='quuux' hoge='hello & world' />");
XmlElement documentElement = document.DocumentElement;
- AssertEquals ("baz", documentElement.GetAttribute ("bar"));
- AssertEquals ("quuux", documentElement.GetAttribute ("quux"));
- AssertEquals ("hello & world", documentElement.GetAttribute ("hoge"));
- AssertEquals ("hello & world", documentElement.Attributes ["hoge"].Value);
- AssertEquals (1, documentElement.GetAttributeNode ("hoge").ChildNodes.Count);
+ Assert.AreEqual ("baz", documentElement.GetAttribute ("bar"));
+ Assert.AreEqual ("quuux", documentElement.GetAttribute ("quux"));
+ Assert.AreEqual ("hello & world", documentElement.GetAttribute ("hoge"));
+ Assert.AreEqual ("hello & world", documentElement.Attributes ["hoge"].Value);
+ Assert.AreEqual (1, documentElement.GetAttributeNode ("hoge").ChildNodes.Count);
}
[Test]
public void LoadXmlElementWithChildElement ()
{
document.LoadXml ("<foo><bar/></foo>");
- Assert (document.ChildNodes.Count == 1);
- Assert (document.FirstChild.ChildNodes.Count == 1);
- AssertEquals ("foo", document.DocumentElement.LocalName);
- AssertEquals ("bar", document.DocumentElement.FirstChild.LocalName);
+ Assert.IsTrue (document.ChildNodes.Count == 1);
+ Assert.IsTrue (document.FirstChild.ChildNodes.Count == 1);
+ Assert.AreEqual ("foo", document.DocumentElement.LocalName);
+ Assert.AreEqual ("bar", document.DocumentElement.FirstChild.LocalName);
}
[Test]
public void LoadXmlElementWithTextNode ()
{
document.LoadXml ("<foo>bar</foo>");
- Assert (document.DocumentElement.FirstChild.NodeType == XmlNodeType.Text);
- AssertEquals ("bar", document.DocumentElement.FirstChild.Value);
+ Assert.IsTrue (document.DocumentElement.FirstChild.NodeType == XmlNodeType.Text);
+ Assert.AreEqual ("bar", document.DocumentElement.FirstChild.Value);
}
[Test]
public void LoadXmlExceptionClearsDocument ()
{
document.LoadXml ("<foo/>");
- Assert (document.FirstChild != null);
+ Assert.IsTrue (document.FirstChild != null);
try {
document.LoadXml ("<123/>");
- Fail ("An XmlException should have been thrown.");
+ Assert.Fail ("An XmlException should have been thrown.");
} catch (XmlException) {}
- Assert (document.FirstChild == null);
+ Assert.IsTrue (document.FirstChild == null);
}
[Test]
public void LoadXmlProcessingInstruction ()
{
document.LoadXml (@"<?foo bar='baaz' quux='quuux'?><quuuux></quuuux>");
- AssertEquals ("Incorrect target.", "foo", ((XmlProcessingInstruction)document.FirstChild).Target);
- AssertEquals ("Incorrect data.", "bar='baaz' quux='quuux'", ((XmlProcessingInstruction)document.FirstChild).Data);
+ Assert.AreEqual ("foo", ((XmlProcessingInstruction)document.FirstChild).Target, "Incorrect target.");
+ Assert.AreEqual ("bar='baaz' quux='quuux'", ((XmlProcessingInstruction)document.FirstChild).Data, "Incorrect data.");
}
[Test]
xml = "<root><![CDATA[foo]]></root>";
document.LoadXml (xml);
- AssertEquals("XmlDocument with cdata OuterXml is incorrect.", xml, document.OuterXml);
+ Assert.AreEqual (xml, document.OuterXml, "XmlDocument with cdata OuterXml is incorrect.");
xml = "<root><!--foo--></root>";
document.LoadXml (xml);
- AssertEquals("XmlDocument with comment OuterXml is incorrect.", xml, document.OuterXml);
+ Assert.AreEqual (xml, document.OuterXml, "XmlDocument with comment OuterXml is incorrect.");
xml = "<root><?foo bar?></root>";
document.LoadXml (xml);
- AssertEquals("XmlDocument with processing instruction OuterXml is incorrect.", xml, document.OuterXml);
+ Assert.AreEqual (xml, document.OuterXml, "XmlDocument with processing instruction OuterXml is incorrect.");
}
[Test]
{
document.LoadXml ("<foo><bar><baz/></bar></foo>");
XmlNode node = document.FirstChild.FirstChild.FirstChild;
- AssertEquals ("Wrong child found.", "baz", node.LocalName);
- AssertEquals ("Wrong parent.", "bar", node.ParentNode.LocalName);
- AssertEquals ("Wrong parent.", "foo", node.ParentNode.ParentNode.LocalName);
- AssertEquals ("Wrong parent.", "#document", node.ParentNode.ParentNode.ParentNode.LocalName);
- AssertNull ("Expected parent to be null.", node.ParentNode.ParentNode.ParentNode.ParentNode);
+ Assert.AreEqual ("baz", node.LocalName, "Wrong child found.");
+ Assert.AreEqual ("bar", node.ParentNode.LocalName, "Wrong parent.");
+ Assert.AreEqual ("foo", node.ParentNode.ParentNode.LocalName, "Wrong parent.");
+ Assert.AreEqual ("#document", node.ParentNode.ParentNode.ParentNode.LocalName, "Wrong parent.");
+ Assert.IsNull (node.ParentNode.ParentNode.ParentNode.ParentNode, "Expected parent to be null.");
}
[Test]
node = document.DocumentElement.FirstChild;
document.DocumentElement.RemoveChild (node);
nextSibling = node.NextSibling;
- AssertNull ("Expected removed node's next sibling to be null.", nextSibling);
+ Assert.IsNull (nextSibling, "Expected removed node's next sibling to be null.");
}
// ImportNode
// Attribute
n = newDoc.ImportNode(bar.GetAttributeNode("href", xlinkURI), true);
- AssertEquals("#ImportNode.Attr.NS.LocalName", "href", n.LocalName);
- AssertEquals("#ImportNode.Attr.NS.NSURI", xlinkURI, n.NamespaceURI);
- AssertEquals("#ImportNode.Attr.NS.Value", "#foo", n.Value);
+ Assert.AreEqual ("href", n.LocalName, "#ImportNode.Attr.NS.LocalName");
+ Assert.AreEqual (xlinkURI, n.NamespaceURI, "#ImportNode.Attr.NS.NSURI");
+ Assert.AreEqual ("#foo", n.Value, "#ImportNode.Attr.NS.Value");
// CDATA
n = newDoc.ImportNode(bar.FirstChild.FirstChild, true);
- AssertEquals("#ImportNode.CDATA", "cdata section.\n\titem 1\n\titem 2\n", n.Value);
+ Assert.AreEqual ("cdata section.\n\titem 1\n\titem 2\n", n.Value, "#ImportNode.CDATA");
// Element
XmlElement e = newDoc.ImportNode(bar, true) as XmlElement;
- AssertEquals("#ImportNode.Element.Name", "bar", e.Name);
- AssertEquals("#ImportNode.Element.Attr", "#foo", e.GetAttribute("href", xlinkURI));
- AssertEquals("#ImportNode.Element.deep", "baz", e.FirstChild.Name);
+ Assert.AreEqual ("bar", e.Name, "#ImportNode.Element.Name");
+ Assert.AreEqual ("#foo", e.GetAttribute("href", xlinkURI), "#ImportNode.Element.Attr");
+ Assert.AreEqual ("baz", e.FirstChild.Name, "#ImportNode.Element.deep");
// Entity Reference:
// [2002/10/14] CreateEntityReference was not implemented.
// document.LoadXml("<!DOCTYPE test PUBLIC 'dummy' [<!ENTITY FOOENT 'foo'>]><root>&FOOENT;</root>");
// n = newDoc.ImportNode(document.DocumentElement.FirstChild);
-// AssertEquals("#ImportNode.EntityReference", "FOOENT", n.Name);
-// AssertEquals("#ImportNode.EntityReference", "foo_", n.Value);
+// Assert.AreEqual ("FOOENT", n.Name, "#ImportNode.EntityReference");
+// Assert.AreEqual ("foo_", n.Value, "#ImportNode.EntityReference");
// Processing Instruction
document.LoadXml("<foo><?xml-stylesheet href='foo.xsl' ?></foo>");
XmlProcessingInstruction pi = (XmlProcessingInstruction)newDoc.ImportNode(document.DocumentElement.FirstChild, false);
- AssertEquals("#ImportNode.ProcessingInstruction.Name", "xml-stylesheet", pi.Name);
- AssertEquals("#ImportNode.ProcessingInstruction.Data", "href='foo.xsl'", pi.Data.Trim());
+ Assert.AreEqual ("xml-stylesheet", pi.Name, "#ImportNode.ProcessingInstruction.Name");
+ Assert.AreEqual ("href='foo.xsl'", pi.Data.Trim(), "#ImportNode.ProcessingInstruction.Data");
// Text
document.LoadXml(xml1);
n = newDoc.ImportNode((XmlText)bar.FirstChild.ChildNodes[1], true);
- AssertEquals("#ImportNode.Text", "From here, simple text node.", n.Value);
+ Assert.AreEqual ("From here, simple text node.", n.Value, "#ImportNode.Text");
// XmlDeclaration
document.LoadXml(xml1);
XmlDeclaration decl = (XmlDeclaration)newDoc.ImportNode(document.FirstChild, false);
- AssertEquals("#ImportNode.XmlDeclaration.Type", XmlNodeType.XmlDeclaration, decl.NodeType);
- AssertEquals("#ImportNode.XmlDeclaration.Encoding", "utf-8", decl.Encoding);
+ Assert.AreEqual (XmlNodeType.XmlDeclaration, decl.NodeType, "#ImportNode.XmlDeclaration.Type");
+ Assert.AreEqual ("utf-8", decl.Encoding, "#ImportNode.XmlDeclaration.Encoding");
}
[Test]
public void NameTable()
{
XmlDocument doc = new XmlDocument();
- AssertNotNull(doc.NameTable);
+ Assert.IsNotNull (doc.NameTable);
}
[Test]
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<root />");
- AssertNotNull(doc.DocumentElement);
+ Assert.IsNotNull (doc.DocumentElement);
}
[Test]
XmlDocument doc = new XmlDocument ();
// In fact it is invalid, but it doesn't fail with MS.NET 1.0.
doc.LoadXml ("<!DOCTYPE test><root />");
- AssertNotNull (doc.DocumentType);
+ Assert.IsNotNull (doc.DocumentType);
#if NetworkEnabled
try
{
doc.LoadXml ("<!DOCTYPE test SYSTEM 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
} catch (XmlException) {
- Fail("#DoctypeDecl.System");
+ Assert.Fail ("#DoctypeDecl.System");
}
try {
doc.LoadXml ("<!DOCTYPE test PUBLIC '-//test' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'><root />");
} catch (XmlException) {
- Fail ("#DoctypeDecl.Public");
+ Assert.Fail ("#DoctypeDecl.Public");
}
#endif
// Should this be commented out?
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);
+ Assert.AreEqual (0, doc2.ChildNodes.Count, "ShallowCopy");
doc2 = (XmlDocument)doc.CloneNode (true);
- AssertEquals ("DeepCopy", "foo", doc2.DocumentElement.Name);
+ Assert.AreEqual ("foo", doc2.DocumentElement.Name, "DeepCopy");
}
[Test]
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<iq type=\"get\" id=\"ATECLIENT_1\"><query xmlns=\"jabber:iq:auth\"><username></username></query></iq>");
- AssertEquals ("<iq type=\"get\" id=\"ATECLIENT_1\"><query xmlns=\"jabber:iq:auth\"><username></username></query></iq>", doc.OuterXml);
+ Assert.AreEqual ("<iq type=\"get\" id=\"ATECLIENT_1\"><query xmlns=\"jabber:iq:auth\"><username></username></query></iq>", doc.OuterXml);
}
[Test]
XmlTextReader reader = new XmlTextReader (new StringReader (input));
dom.Load (reader);
- AssertEquals (XmlNodeType.Element, dom.FirstChild.NextSibling.NextSibling.NodeType);
+ Assert.AreEqual (XmlNodeType.Element, dom.FirstChild.NextSibling.NextSibling.NodeType);
}
[Test]
public void PreserveWhitespace2 ()
{
XmlDocument doc = new XmlDocument ();
- Assert (!doc.PreserveWhitespace);
+ Assert.IsTrue (!doc.PreserveWhitespace);
doc.PreserveWhitespace = true;
XmlDocument d2 = doc.Clone () as XmlDocument;
- Assert (!d2.PreserveWhitespace); // i.e. not cloned
+ Assert.IsTrue (!d2.PreserveWhitespace); // i.e. not cloned
d2.AppendChild (d2.CreateElement ("root"));
d2.DocumentElement.AppendChild (d2.CreateWhitespace (" "));
StringWriter sw = new StringWriter ();
d2.WriteTo (new XmlTextWriter (sw));
- AssertEquals ("<root> </root>", sw.ToString ());
+ Assert.AreEqual ("<root> </root>", sw.ToString ());
}
[Test]
// Check that null prefix and namespace are allowed and
// equivalent to ""
XmlAttribute attr = dom.CreateAttribute (null, "FOO", null);
- AssertEquals (attr.Prefix, "");
- AssertEquals (attr.NamespaceURI, "");
+ Assert.AreEqual (attr.Prefix, "");
+ Assert.AreEqual (attr.NamespaceURI, "");
}
[Test]
string xml = dtd + "<root>&foo;</root>";
XmlValidatingReader xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
- AssertNotNull (document.DocumentType);
- AssertEquals (1, document.DocumentType.Entities.Count);
+ Assert.IsNotNull (document.DocumentType);
+ Assert.AreEqual (1, document.DocumentType.Entities.Count);
XmlEntity foo = document.DocumentType.Entities.GetNamedItem ("foo") as XmlEntity;
- AssertNotNull (foo);
- AssertNotNull (document.DocumentType.Entities.GetNamedItem ("foo", ""));
- AssertEquals ("foo", foo.Name);
- AssertNull (foo.Value);
- AssertEquals ("foo-ent", foo.InnerText);
+ Assert.IsNotNull (foo);
+ Assert.IsNotNull (document.DocumentType.Entities.GetNamedItem ("foo", ""));
+ Assert.AreEqual ("foo", foo.Name);
+ Assert.IsNull (foo.Value);
+ Assert.AreEqual ("foo-ent", foo.InnerText);
}
[Test]
xvr.ValidationType = ValidationType.None;
document.Load (xvr);
// Don't include default attributes here.
- AssertEquals (xml, document.OuterXml);
- AssertEquals ("hoge-def", document.DocumentElement.GetAttribute ("hoge"));
+ Assert.AreEqual (xml, document.OuterXml);
+ Assert.AreEqual ("hoge-def", document.DocumentElement.GetAttribute ("hoge"));
}
// [Test] Comment out in the meantime.
XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
XmlDocument doc = new XmlDocument ();
doc.Load (xtr);
- AssertEquals ("#text node", XmlNodeType.EntityReference,
- doc.DocumentElement.FirstChild.NodeType);
- AssertEquals ("#attribute", XmlNodeType.EntityReference,
- doc.DocumentElement.Attributes [0].ChildNodes [1].NodeType);
+ Assert.AreEqual (XmlNodeType.EntityReference, doc.DocumentElement.FirstChild.NodeType, "#text node");
+ Assert.AreEqual (XmlNodeType.EntityReference, doc.DocumentElement.Attributes [0].ChildNodes [1].NodeType, "#attribute");
}
[Test]
xr.Read ();
Console.WriteLine (xr.NodeType);
XmlNode n = document.ReadNode (xr);
- AssertNull (n);
+ Assert.IsNull (n);
}
[Test]
Console.WriteLine (xr.NodeType);
document.PreserveWhitespace = false; // Note this line.
XmlNode n = document.ReadNode (xr);
- AssertNotNull (n);
- AssertEquals (XmlNodeType.Whitespace, n.NodeType);
+ Assert.IsNotNull (n);
+ Assert.AreEqual (XmlNodeType.Whitespace, n.NodeType);
}
[Test]
doc.LoadXml (xml);
StringWriter sw = new StringWriter ();
doc.Save (sw);
- AssertEquals ("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + xml, sw.ToString ());
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>" + xml, sw.ToString ());
doc.PreserveWhitespace = false;
sw = new StringWriter ();
doc.Save (sw);
string NEL = Environment.NewLine;
- AssertEquals ("<?xml version=\"1.0\" encoding=\"utf-16\"?>"
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>"
+ NEL + "<root> <element>text"
+ "\n</element></root>",
sw.ToString ());
XmlDocument doc = new XmlDocument ();
doc.Load (reader);
- AssertEquals (1,
+ Assert.AreEqual (1,
doc.DocumentElement.FirstChild.ChildNodes.Count);
}
string xml = @"<!DOCTYPE foo [<!ELEMENT foo EMPTY><!ATTLIST foo xmlns CDATA #FIXED 'urn:foo'>]><foo />";
XmlDocument doc = new XmlDocument ();
doc.Load (new StringReader (xml));
- AssertEquals ("urn:foo", doc.DocumentElement.NamespaceURI);
+ Assert.AreEqual ("urn:foo", doc.DocumentElement.NamespaceURI);
}
[Test]
{
XmlDocument doc = new MyXmlDocument ();
doc.LoadXml ("<root a='sane' />");
- AssertNotNull (doc.DocumentElement.GetAttributeNode ("hijacked"));
- AssertNull (doc.DocumentElement.GetAttributeNode ("a"));
+ Assert.IsNotNull (doc.DocumentElement.GetAttributeNode ("hijacked"));
+ Assert.IsNull (doc.DocumentElement.GetAttributeNode ("a"));
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlDocumentTypeTests : Assertion
+ public class XmlDocumentTypeTests
{
XmlDocument document;
XmlDocumentType docType;
// assertequals (original.nodetype + " was incorrectly cloned.",
// original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
- AssertEquals ("Value incorrectly cloned",
- original.Value, cloned.Value);
+ Assert.IsNull (cloned.ParentNode);
+ Assert.AreEqual (original.Value, cloned.Value, "Value incorrectly cloned");
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original, cloned));
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
[Test]
public void Name ()
{
- AssertEquals ("Getting Name property", "book", docType.Name);
+ Assert.AreEqual ("book", docType.Name, "Getting Name property");
}
[Test]
public void LocalName ()
{
- AssertEquals ("Getting LocalName property", "book", docType.LocalName);
+ Assert.AreEqual ("book", docType.LocalName, "Getting LocalName property");
}
[Test]
public void InternalSubset ()
{
- AssertEquals ("Getting Internal Subset property",
- "<!ELEMENT book ANY>", docType.InternalSubset);
+ Assert.AreEqual ("<!ELEMENT book ANY>", docType.InternalSubset, "Getting Internal Subset property");
}
[Test]
return;
} catch (Exception) {
- Fail ("Incorrect Exception thrown.");
+ Assert.Fail ("Incorrect Exception thrown.");
}
}
[Test]
public void NodeType ()
{
- AssertEquals ("NodeType property broken",
- docType.NodeType.ToString (), "DocumentType");
+ Assert.AreEqual (docType.NodeType.ToString (), "DocumentType", "NodeType property broken");
}
[Test]
public void IsReadOnly ()
{
- AssertEquals ("IsReadOnly property", "True", docType.IsReadOnly.ToString ());
+ Assert.AreEqual ("True", docType.IsReadOnly.ToString (), "IsReadOnly property");
}
[Test]
XmlNode cloned2 = docType.CloneNode (false);
XmlNodeBaseProperties (original, cloned2);
- AssertEquals ("Deep and shallow cloning", cloned1.Value, cloned2.Value);
+ Assert.AreEqual (cloned1.Value, cloned2.Value, "Deep and shallow cloning");
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlElementTests : Assertion
+ public class XmlElementTests
{
private XmlDocument document;
string localName, string namespaceURI,
int attributesCount)
{
- AssertEquals (prefix != String.Empty ? prefix + ":" + localName : localName, element.Name);
- AssertEquals (prefix, element.Prefix);
- AssertEquals (localName, element.LocalName);
- AssertEquals (namespaceURI, element.NamespaceURI);
- //AssertEquals (attributesCount, element.Attributes.Count);
+ Assert.AreEqual (prefix != String.Empty ? prefix + ":" + localName : localName, element.Name);
+ Assert.AreEqual (prefix, element.Prefix);
+ Assert.AreEqual (localName, element.LocalName);
+ Assert.AreEqual (namespaceURI, element.NamespaceURI);
+ //Assert.AreEqual (attributesCount, element.Attributes.Count);
}
// for NodeInserted Event
document.AppendChild (element);
XmlNode deep = element.CloneNode (true);
- // AssertEquals ("These should be the same", deep.OuterXml, element.OuterXml);
- AssertNull ("This is not null", deep.ParentNode);
- Assert ("Copies, not pointers", !Object.ReferenceEquals (element,deep));
+ // Assert.AreEqual (deep.OuterXml, element.OuterXml, "These should be the same");
+ Assert.IsNull (deep.ParentNode, "This is not null");
+ Assert.IsTrue (!Object.ReferenceEquals (element, deep), "Copies, not pointers");
XmlNode shallow = element.CloneNode (false);
- AssertNull ("This is not null", shallow.ParentNode);
- Assert ("Copies, not pointers", !Object.ReferenceEquals (element,shallow));
- AssertEquals ("Shallow clones shalt have no children!", false, shallow.HasChildNodes);
+ Assert.IsNull (shallow.ParentNode, "This is not null");
+ Assert.IsTrue (!Object.ReferenceEquals (element, shallow), "Copies, not pointers");
+ Assert.AreEqual (false, shallow.HasChildNodes, "Shallow clones shalt have no children!");
}
[Test]
XmlComment comment;
element = document.CreateElement ("foo");
- AssertEquals (String.Empty, element.InnerXml);
- AssertEquals ("<foo />", element.OuterXml);
+ Assert.AreEqual (String.Empty, element.InnerXml);
+ Assert.AreEqual ("<foo />", element.OuterXml);
text = document.CreateTextNode ("bar");
element.AppendChild (text);
- AssertEquals ("bar", element.InnerXml);
- AssertEquals ("<foo>bar</foo>", element.OuterXml);
+ Assert.AreEqual ("bar", element.InnerXml);
+ Assert.AreEqual ("<foo>bar</foo>", element.OuterXml);
element.SetAttribute ("baz", "quux");
- AssertEquals ("bar", element.InnerXml);
- AssertEquals ("<foo baz=\"quux\">bar</foo>", element.OuterXml);
+ Assert.AreEqual ("bar", element.InnerXml);
+ Assert.AreEqual ("<foo baz=\"quux\">bar</foo>", element.OuterXml);
comment = document.CreateComment ("squonk");
element.AppendChild (comment);
- AssertEquals ("bar<!--squonk-->", element.InnerXml);
- AssertEquals ("<foo baz=\"quux\">bar<!--squonk--></foo>", element.OuterXml);
+ Assert.AreEqual ("bar<!--squonk-->", element.InnerXml);
+ Assert.AreEqual ("<foo baz=\"quux\">bar<!--squonk--></foo>", element.OuterXml);
element.RemoveAll();
element.AppendChild(document.CreateElement("hoge"));
- AssertEquals ("<hoge />", element.InnerXml);
+ Assert.AreEqual ("<hoge />", element.InnerXml);
}
[Test]
XmlElement element = document.CreateElement ("foo");
element.SetAttribute ("attr1", "val1");
element.SetAttribute ("attr2", "val2");
- AssertEquals ("val1", element.GetAttribute ("attr1"));
- AssertEquals ("val2", element.GetAttribute ("attr2"));
+ Assert.AreEqual ("val1", element.GetAttribute ("attr1"));
+ Assert.AreEqual ("val2", element.GetAttribute ("attr2"));
}
[Test]
XmlNode xmlNode = libraryList.Item (0);
XmlElement xmlElement = xmlNode as XmlElement;
XmlNodeList bookList = xmlElement.GetElementsByTagName ("book");
- AssertEquals ("GetElementsByTagName (string) returned incorrect count.", 4, bookList.Count);
+ Assert.AreEqual (4, bookList.Count, "GetElementsByTagName (string) returned incorrect count.");
}
[Test]
XmlNode xmlNode = libraryList.Item (0);
XmlElement xmlElement = xmlNode as XmlElement;
XmlNodeList bookList = xmlElement.GetElementsByTagName ("book", "http://www.foo.com");
- AssertEquals ("GetElementsByTagName (string, uri) returned incorrect count.", 1, bookList.Count);
+ Assert.AreEqual (1, bookList.Count, "GetElementsByTagName (string, uri) returned incorrect count.");
}
[Test]
// id='b' has different prefix. Should not caught by (name),
// while should caught by (name, ns).
XmlNodeList nl = document.DocumentElement.GetElementsByTagName ("x:a");
- AssertEquals (2, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("c", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual (2, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [1].Attributes ["id"].Value);
nl = document.DocumentElement.GetElementsByTagName ("a", "urn:foo");
- AssertEquals (3, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual (3, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
// name wildcard
nl = document.DocumentElement.GetElementsByTagName ("*");
- AssertEquals (5, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
- AssertEquals ("d", nl [3].Attributes ["id"].Value);
- AssertEquals ("e", nl [4].Attributes ["id"].Value);
+ Assert.AreEqual (5, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("d", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [4].Attributes ["id"].Value);
// wildcard - local and ns
nl = document.DocumentElement.GetElementsByTagName ("*", "*");
- AssertEquals (5, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
- AssertEquals ("d", nl [3].Attributes ["id"].Value);
- AssertEquals ("e", nl [4].Attributes ["id"].Value);
+ Assert.AreEqual (5, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("d", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [4].Attributes ["id"].Value);
// namespace wildcard - namespace
nl = document.DocumentElement.GetElementsByTagName ("*", "urn:foo");
- AssertEquals (4, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
- AssertEquals ("e", nl [3].Attributes ["id"].Value);
+ Assert.AreEqual (4, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual ("e", nl [3].Attributes ["id"].Value);
// namespace wildcard - local only. I dare say, such usage is not XML-ish!
nl = document.DocumentElement.GetElementsByTagName ("a", "*");
- AssertEquals (3, nl.Count);
- AssertEquals ("a", nl [0].Attributes ["id"].Value);
- AssertEquals ("b", nl [1].Attributes ["id"].Value);
- AssertEquals ("c", nl [2].Attributes ["id"].Value);
+ Assert.AreEqual (3, nl.Count);
+ Assert.AreEqual ("a", nl [0].Attributes ["id"].Value);
+ Assert.AreEqual ("b", nl [1].Attributes ["id"].Value);
+ Assert.AreEqual ("c", nl [2].Attributes ["id"].Value);
}
[Test]
public void OuterXmlWithNamespace ()
{
XmlElement element = document.CreateElement ("foo", "bar", "#foo");
- AssertEquals ("<foo:bar xmlns:foo=\"#foo\" />", element.OuterXml);
+ Assert.AreEqual ("<foo:bar xmlns:foo=\"#foo\" />", element.OuterXml);
}
[Test]
XmlNode xmlNode = bookList.Item (0);
XmlElement xmlElement = xmlNode as XmlElement;
xmlElement.RemoveAllAttributes ();
- AssertEquals ("attributes not properly removed.", false, xmlElement.HasAttribute ("type"));
+ Assert.AreEqual (false, xmlElement.HasAttribute ("type"), "attributes not properly removed.");
}
[Test]
XmlValidatingReader xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
// RemoveAll
- AssertNotNull (document.DocumentElement);
- AssertEquals ("attrCount #01", 2, document.DocumentElement.Attributes.Count);
- AssertEquals ("baz", document.DocumentElement.GetAttribute ("bar"));
- AssertEquals ("def", document.DocumentElement.GetAttribute ("foo"));
- AssertEquals (false, document.DocumentElement.GetAttributeNode ("foo").Specified);
+ Assert.IsNotNull (document.DocumentElement);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #01");
+ Assert.AreEqual ("baz", document.DocumentElement.GetAttribute ("bar"));
+ Assert.AreEqual ("def", document.DocumentElement.GetAttribute ("foo"));
+ Assert.AreEqual (false, document.DocumentElement.GetAttributeNode ("foo").Specified);
document.DocumentElement.RemoveAll ();
- AssertEquals ("attrCount #02", 1, document.DocumentElement.Attributes.Count);
- AssertEquals ("def", document.DocumentElement.GetAttribute ("foo"));
- AssertEquals (String.Empty, document.DocumentElement.GetAttribute ("bar"));
+ Assert.AreEqual (1, document.DocumentElement.Attributes.Count, "attrCount #02");
+ Assert.AreEqual ("def", document.DocumentElement.GetAttribute ("foo"));
+ Assert.AreEqual (String.Empty, document.DocumentElement.GetAttribute ("bar"));
// RemoveAllAttributes
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAllAttributes ();
- AssertEquals ("attrCount #03", 1, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (1, document.DocumentElement.Attributes.Count, "attrCount #03");
// RemoveAttribute(name)
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAttribute ("foo");
- AssertEquals ("attrCount #04", 2, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #04");
// RemoveAttribute(name, ns)
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAttribute ("foo", String.Empty);
- AssertEquals ("attrCount #05", 2, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #05");
// RemoveAttributeAt
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAttributeAt (1);
- AssertEquals ("attrCount #06", 2, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #06");
// RemoveAttributeNode
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAttributeNode (document.DocumentElement.Attributes [1]);
- AssertEquals ("attrCount #07", 2, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #07");
// RemoveAttributeNode(name, ns)
xvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
document.Load (xvr);
document.DocumentElement.RemoveAttributeNode ("foo", String.Empty);
- AssertEquals ("attrCount #08", 2, document.DocumentElement.Attributes.Count);
+ Assert.AreEqual (2, document.DocumentElement.Attributes.Count, "attrCount #08");
}
[Test]
XmlElement xmlEl = xmlDoc.CreateElement ("TestElement");
XmlAttribute xmlAttribute = xmlEl.SetAttributeNode ("attr1", "namespace1");
XmlAttribute xmlAttribute2 = xmlEl.SetAttributeNode ("attr2", "namespace2");
- AssertEquals ("attribute name not properly created.", true, xmlAttribute.Name.Equals ("attr1"));
- AssertEquals ("attribute namespace not properly created.", true, xmlAttribute.NamespaceURI.Equals ("namespace1"));
+ Assert.AreEqual (true, xmlAttribute.Name.Equals ("attr1"), "attribute name not properly created.");
+ Assert.AreEqual (true, xmlAttribute.NamespaceURI.Equals ("namespace1"), "attribute namespace not properly created.");
}
[Test]
// should not affect Element node's xmlns
XmlElement el = document.CreateElement ("root");
el.SetAttribute ("xmlns", "urn:foo");
- AssertEquals (String.Empty, el.NamespaceURI);
+ Assert.AreEqual (String.Empty, el.NamespaceURI);
}
[Test]
// If only one child of the element is Text node,
// then no events are fired.
doc.DocumentElement.FirstChild.InnerText = "no events fired.";
- AssertEquals ("NoInsertEventFired", false, Inserted);
- AssertEquals ("NoRemoveEventFired", false, Removed);
- AssertEquals ("SetInnerTextToSingleText", "no events fired.", doc.DocumentElement.FirstChild.InnerText);
+ Assert.AreEqual (false, Inserted, "NoInsertEventFired");
+ Assert.AreEqual (false, Removed, "NoRemoveEventFired");
+ Assert.AreEqual ("no events fired.", doc.DocumentElement.FirstChild.InnerText, "SetInnerTextToSingleText");
Inserted = false;
Removed = false;
// if only one child of the element is CDataSection,
// then events are fired.
doc.DocumentElement.LastChild.InnerText = "events are fired.";
- AssertEquals ("InsertedEventFired", true, Inserted);
- AssertEquals ("RemovedEventFired", true, Removed);
- AssertEquals ("SetInnerTextToCDataSection", "events are fired.", doc.DocumentElement.LastChild.InnerText);
+ Assert.AreEqual (true, Inserted, "InsertedEventFired");
+ Assert.AreEqual (true, Removed, "RemovedEventFired");
+ Assert.AreEqual ("events are fired.", doc.DocumentElement.LastChild.InnerText, "SetInnerTextToCDataSection");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<root/>");
XmlElement el = doc.DocumentElement;
- AssertNull ("#Simple", el.FirstChild);
+ Assert.IsNull (el.FirstChild, "#Simple");
el.InnerXml = "<foo><bar att='baz'/></foo>";
XmlElement child = el.FirstChild as XmlElement;
- AssertNotNull ("#Simple.Child", child);
- AssertEquals ("#Simple.Child.Name", "foo", child.LocalName);
+ Assert.IsNotNull (child, "#Simple.Child");
+ Assert.AreEqual ("foo", child.LocalName, "#Simple.Child.Name");
XmlElement grandchild = child.FirstChild as XmlElement;
- AssertNotNull ("#Simple.GrandChild", grandchild);
- AssertEquals ("#Simple.GrandChild.Name", "bar", grandchild.LocalName);
- AssertEquals ("#Simple.GrandChild.Attr", "baz", grandchild.GetAttribute ("att"));
+ Assert.IsNotNull (grandchild, "#Simple.GrandChild");
+ Assert.AreEqual ("bar", grandchild.LocalName, "#Simple.GrandChild.Name");
+ Assert.AreEqual ("baz", grandchild.GetAttribute ("att"), "#Simple.GrandChild.Attr");
doc.LoadXml ("<root xmlns='NS0' xmlns:ns1='NS1'><foo/><ns1:bar/><ns2:bar xmlns:ns2='NS2' /></root>");
el = doc.DocumentElement.FirstChild.NextSibling as XmlElement; // ns1:bar
- AssertNull ("#Namespaced.Prepare", el.FirstChild);
+ Assert.IsNull (el.FirstChild, "#Namespaced.Prepare");
el.InnerXml = "<ns1:baz />";
- AssertNotNull ("#Namespaced.Child", el.FirstChild);
- AssertEquals ("#Namespaced.Child.Name", "baz", el.FirstChild.LocalName);
- AssertEquals ("#Namespaced.Child.NSURI", "NS1", el.FirstChild.NamespaceURI); // important!
+ Assert.IsNotNull (el.FirstChild, "#Namespaced.Child");
+ Assert.AreEqual ("baz", el.FirstChild.LocalName, "#Namespaced.Child.Name");
+ Assert.AreEqual ("NS1", el.FirstChild.NamespaceURI, "#Namespaced.Child.NSURI"); // important!
el.InnerXml = "<hoge />";
- AssertEquals ("#Namespaced.VerifyPreviousCleared", "hoge", el.FirstChild.Name);
+ Assert.AreEqual ("hoge", el.FirstChild.Name, "#Namespaced.VerifyPreviousCleared");
}
[Test]
</type>");
XmlElement typeNode = doc.DocumentElement;
typeNode.InnerText = "QPair<QString, int>";
- AssertEquals ("QPair<QString, int>", typeNode.InnerText);
+ Assert.AreEqual ("QPair<QString, int>", typeNode.InnerText);
}
[Test]
public void IsEmpty ()
{
document.LoadXml ("<root><foo/><bar></bar></root>");
- Assertion.AssertEquals ("Empty", true, ((XmlElement) document.DocumentElement.FirstChild).IsEmpty);
- Assertion.AssertEquals ("Empty", false, ((XmlElement) document.DocumentElement.LastChild).IsEmpty);
+ Assert.AreEqual (true, ((XmlElement) document.DocumentElement.FirstChild).IsEmpty, "Empty");
+ Assert.AreEqual (false, ((XmlElement) document.DocumentElement.LastChild).IsEmpty, "Empty");
}
[Test]
XmlElement el = doc.DocumentElement;
el.RemoveAttribute ("a1");
- AssertNull ("RemoveAttribute", el.GetAttributeNode ("a1"));
+ Assert.IsNull (el.GetAttributeNode ("a1"), "RemoveAttribute");
el.RemoveAttribute ("xlink:href");
- AssertNull ("RemoveAttribute", el.GetAttributeNode ("href", xlinkURI));
+ Assert.IsNull (el.GetAttributeNode ("href", xlinkURI), "RemoveAttribute");
el.RemoveAllAttributes ();
- AssertNull ("RemoveAllAttributes", el.GetAttributeNode ("a2"));
+ Assert.IsNull (el.GetAttributeNode ("a2"), "RemoveAllAttributes");
}
[Test]
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
doc.DocumentElement.WriteTo (xtw);
- AssertEquals ("<RetrievalElement URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", sw.ToString());
+ Assert.AreEqual ("<RetrievalElement URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", sw.ToString());
}
[Test]
x.AppendChild (b);
XmlElement b2 = d.CreateElement ("p2", "b2", "");
b.AppendChild (b2);
- Assert
Equals ("<root><a /><b xmlns=\"probe\"><b2 /></b></root>", d.OuterXml);
+ Assert
.AreEqual ("<root><a /><b xmlns=\"probe\"><b2 /></b></root>", d.OuterXml);
}
[Test]
doc.LoadXml ("<root xmlns:foo='urn:dummy'><foo foo:bar='baz' /></root>");
doc.DocumentElement.RemoveAllAttributes ();
- Assert (doc.DocumentElement.FirstChild.OuterXml.IndexOf("xmlns:foo") > 0);
+ Assert.IsTrue (doc.DocumentElement.FirstChild.OuterXml.IndexOf("xmlns:foo") > 0);
}
[Test]
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<root xmlns:foo='urn:dummy' xmlns:html='http://www.w3.org/1999/xhtml' html:style='font-size: 1em'></root>");
- Assert (doc.OuterXml.IndexOf ("xmlns:html=\"http://www.w3.org/1999/xhtml\"") > 0);
+ Assert.IsTrue (doc.OuterXml.IndexOf ("xmlns:html=\"http://www.w3.org/1999/xhtml\"") > 0);
}
[Test]
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
document.DocumentElement.WriteTo (xtw);
- AssertEquals ("<root>&foo;</root>", sw.ToString ());
+ Assert.AreEqual ("<root>&foo;</root>", sw.ToString ());
}
[Test]
doc.DocumentElement.Prefix = null;
#if NET_2_0
- AssertEquals ("#1", string.Empty, doc.DocumentElement.Prefix);
+ Assert.AreEqual (string.Empty, doc.DocumentElement.Prefix, "#1");
AssertClearPrefix ((string) null);
#endif
}
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<root />");
doc.DocumentElement.Prefix = String.Empty;
- AssertEquals ("#1", string.Empty, doc.DocumentElement.Prefix);
+ Assert.AreEqual (string.Empty, doc.DocumentElement.Prefix, "#1");
AssertClearPrefix (string.Empty);
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<x:root xmlns:x=\"http://somenamespace.com\" />");
- AssertEquals ("#Clear1", "<x:root xmlns:x=\"http://somenamespace.com\" />",
- doc.OuterXml);
- AssertEquals ("#Clear2", "<x:root xmlns:x=\"http://somenamespace.com\" />",
- doc.DocumentElement.OuterXml);
- AssertEquals ("#Clear3", "x", doc.DocumentElement.Prefix);
+ Assert.AreEqual ("<x:root xmlns:x=\"http://somenamespace.com\" />", doc.OuterXml, "#Clear1");
+ Assert.AreEqual ("<x:root xmlns:x=\"http://somenamespace.com\" />", doc.DocumentElement.OuterXml, "#Clear2");
+ Assert.AreEqual ("x", doc.DocumentElement.Prefix, "#Clear3");
doc.DocumentElement.Prefix = newPrefix;
- AssertEquals ("#Clear4", "<root xmlns:x=\"http://somenamespace.com\" xmlns=\"http://somenamespace.com\" />",
- doc.OuterXml);
- AssertEquals ("#Clear5", "<root xmlns:x=\"http://somenamespace.com\" xmlns=\"http://somenamespace.com\" />",
- doc.DocumentElement.OuterXml);
- AssertEquals ("#Clear6", string.Empty, doc.DocumentElement.Prefix);
+ Assert.AreEqual ("<root xmlns:x=\"http://somenamespace.com\" xmlns=\"http://somenamespace.com\" />", doc.OuterXml, "#Clear4");
+ Assert.AreEqual ("<root xmlns:x=\"http://somenamespace.com\" xmlns=\"http://somenamespace.com\" />", doc.DocumentElement.OuterXml, "#Clear5");
+ Assert.AreEqual (string.Empty, doc.DocumentElement.Prefix, "#Clear6");
}
[Test]
changed = true;
};
doc.DocumentElement.SetAttribute ("Key", "");
- Assert (changed);
+ Assert.IsTrue (changed);
}
class MyXmlElement : XmlElement
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlEntityReferenceTests : Assertion
+ public class XmlEntityReferenceTests
{
[Test]
public void WriteTo ()
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);
+ Assert.AreEqual ("foo", er.Name, "Name");
+ Assert.AreEqual ("<root>&foo;</root>", doc.DocumentElement.OuterXml, "WriteTo");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.Load (xtr);
XmlEntity ent = (XmlEntity) doc.DocumentType.Entities.GetNamedItem ("ent2");
- AssertEquals ("ent2", ent.Name);
- AssertEquals ("my ", ent.FirstChild.Value);
- AssertNotNull (ent.FirstChild.NextSibling.FirstChild);
- AssertEquals ("value", ent.FirstChild.NextSibling.FirstChild.Value);
+ Assert.AreEqual ("ent2", ent.Name);
+ Assert.AreEqual ("my ", ent.FirstChild.Value);
+ Assert.IsNotNull (ent.FirstChild.NextSibling.FirstChild);
+ Assert.AreEqual ("value", ent.FirstChild.NextSibling.FirstChild.Value);
}
[Test]
doc.Load (xtr);
XmlEntityReference ent = doc.CreateEntityReference ("ent");
// ChildNodes are not added yet.
- AssertNull (ent.FirstChild);
+ Assert.IsNull (ent.FirstChild);
doc.DocumentElement.AppendChild (ent);
// ChildNodes are added here.
- AssertNotNull (ent.FirstChild);
+ Assert.IsNotNull (ent.FirstChild);
ent = doc.CreateEntityReference ("foo");
- AssertNull (ent.FirstChild);
+ Assert.IsNull (ent.FirstChild);
// Entity value is empty when the matching DTD entity
// node does not exist.
doc.DocumentElement.AppendChild (ent);
- AssertNotNull (ent.FirstChild);
+ Assert.IsNotNull (ent.FirstChild);
- AssertEquals (String.Empty, ent.FirstChild.Value);
+ Assert.AreEqual (String.Empty, ent.FirstChild.Value);
ent = doc.CreateEntityReference ("el");
- AssertEquals ("", ent.InnerText);
+ Assert.AreEqual ("", ent.InnerText);
doc.DocumentElement.AppendChild (ent);
- AssertEquals ("<foo>hoge</foo><bar />", ent.InnerXml);
- AssertEquals ("hoge", ent.InnerText);
- AssertEquals (XmlNodeType.Element, ent.FirstChild.NodeType);
+ Assert.AreEqual ("<foo>hoge</foo><bar />", ent.InnerXml);
+ Assert.AreEqual ("hoge", ent.InnerText);
+ Assert.AreEqual (XmlNodeType.Element, ent.FirstChild.NodeType);
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlEntityTests : Assertion
+ public class XmlEntityTests
{
XmlDocument document;
XmlDocumentType docType;
document.Load (xtr);
xtr.Close ();
docType = document.DocumentType;
- AssertEquals (2, docType.Entities.Count);
+ Assert.AreEqual (2, docType.Entities.Count);
XmlEntity foo = docType.Entities.Item (0) as XmlEntity;
XmlEntity bar = docType.Entities.Item (1) as XmlEntity;
- AssertEquals ("foo", foo.Name);
- AssertNull (bar.Value);
- AssertEquals (1, foo.ChildNodes.Count);
- AssertEquals ("bar", bar.Name);
- AssertNull (bar.Value);
- AssertEquals (1, foo.ChildNodes.Count);
+ Assert.AreEqual ("foo", foo.Name);
+ Assert.IsNull (bar.Value);
+ Assert.AreEqual (1, foo.ChildNodes.Count);
+ Assert.AreEqual ("bar", bar.Name);
+ Assert.IsNull (bar.Value);
+ Assert.AreEqual (1, foo.ChildNodes.Count);
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlNamespaceManagerTests : Assertion
+ public class XmlNamespaceManagerTests
{
private XmlNameTable nameTable;
private XmlNamespaceManager namespaceManager;
public void NewNamespaceManager ()
{
// make sure that you can call PopScope when there aren't any to pop.
- Assert (!namespaceManager.PopScope ());
+ Assert.IsTrue (!namespaceManager.PopScope ());
// the following strings should have been added to the name table by the
// namespace manager.
string xmlNamespace = "http://www.w3.org/XML/1998/namespace";
// none of them should be null.
- AssertNotNull (xmlnsPrefix);
- AssertNotNull (xmlPrefix);
- AssertNotNull (stringEmpty);
- AssertNotNull (xmlnsNamespace);
- AssertNotNull (xmlNamespace);
+ Assert.IsNotNull (xmlnsPrefix);
+ Assert.IsNotNull (xmlPrefix);
+ Assert.IsNotNull (stringEmpty);
+ Assert.IsNotNull (xmlnsNamespace);
+ Assert.IsNotNull (xmlNamespace);
// Microsoft's XmlNamespaceManager reports that these three
// namespaces aren't declared for some reason.
- Assert (!namespaceManager.HasNamespace ("xmlns"));
- Assert (!namespaceManager.HasNamespace ("xml"));
- Assert (!namespaceManager.HasNamespace (String.Empty));
+ Assert.IsTrue (!namespaceManager.HasNamespace ("xmlns"));
+ Assert.IsTrue (!namespaceManager.HasNamespace ("xml"));
+ Assert.IsTrue (!namespaceManager.HasNamespace (String.Empty));
// these three namespaces are declared by default.
- AssertEquals ("http://www.w3.org/2000/xmlns/", namespaceManager.LookupNamespace ("xmlns"));
- AssertEquals ("http://www.w3.org/XML/1998/namespace", namespaceManager.LookupNamespace ("xml"));
- AssertEquals (String.Empty, namespaceManager.LookupNamespace (String.Empty));
+ Assert.AreEqual ("http://www.w3.org/2000/xmlns/", namespaceManager.LookupNamespace ("xmlns"));
+ Assert.AreEqual ("http://www.w3.org/XML/1998/namespace", namespaceManager.LookupNamespace ("xml"));
+ Assert.AreEqual (String.Empty, namespaceManager.LookupNamespace (String.Empty));
// the namespaces should be the same references found in the name table.
- AssertSame (xmlnsNamespace, namespaceManager.LookupNamespace ("xmlns"));
- AssertSame (xmlNamespace, namespaceManager.LookupNamespace ("xml"));
- AssertSame (stringEmpty, namespaceManager.LookupNamespace (String.Empty));
+ Assert.AreSame (xmlnsNamespace, namespaceManager.LookupNamespace ("xmlns"));
+ Assert.AreSame (xmlNamespace, namespaceManager.LookupNamespace ("xml"));
+ Assert.AreSame (stringEmpty, namespaceManager.LookupNamespace (String.Empty));
// looking up undeclared namespaces should return null.
- AssertNull (namespaceManager.LookupNamespace ("foo"));
+ Assert.IsNull (namespaceManager.LookupNamespace ("foo"));
}
[Test]
// add a new namespace.
namespaceManager.AddNamespace ("foo", "http://foo/");
// make sure the new namespace is there.
- Assert (namespaceManager.HasNamespace ("foo"));
- AssertEquals ("http://foo/", namespaceManager.LookupNamespace ("foo"));
+ Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
+ Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// adding a different namespace with the same prefix
// is allowed.
namespaceManager.AddNamespace ("foo", "http://foo1/");
- AssertEquals ("http://foo1/", namespaceManager.LookupNamespace ("foo"));
+ Assert.AreEqual ("http://foo1/", namespaceManager.LookupNamespace ("foo"));
}
[Test]
fooNamespace2 += "foo/";
// the references must be different in order for this test to prove anything.
- Assert (!Object.ReferenceEquals (fooNamespace, fooNamespace2));
+ Assert.IsTrue (!Object.ReferenceEquals (fooNamespace, fooNamespace2));
// add the namespace with the reference that's not in the name table.
namespaceManager.AddNamespace ("foo", fooNamespace2);
// the returned reference should be the same one that's in the name table.
- AssertSame (fooNamespace, namespaceManager.LookupNamespace ("foo"));
+ Assert.AreSame (fooNamespace, namespaceManager.LookupNamespace ("foo"));
}
[Test]
// add a new namespace.
namespaceManager.AddNamespace ("foo", "http://foo/");
// make sure the new namespace is there.
- Assert (namespaceManager.HasNamespace ("foo"));
- AssertEquals ("http://foo/", namespaceManager.LookupNamespace ("foo"));
+ Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
+ Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// push a new scope.
namespaceManager.PushScope ();
// add a new namespace.
namespaceManager.AddNamespace ("bar", "http://bar/");
// make sure the old namespace is not in this new scope.
- Assert (!namespaceManager.HasNamespace ("foo"));
+ Assert.IsTrue (!namespaceManager.HasNamespace ("foo"));
// but we're still supposed to be able to lookup the old namespace.
- AssertEquals ("http://foo/", namespaceManager.LookupNamespace ("foo"));
+ Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// make sure the new namespace is there.
- Assert (namespaceManager.HasNamespace ("bar"));
- AssertEquals ("http://bar/", namespaceManager.LookupNamespace ("bar"));
+ Assert.IsTrue (namespaceManager.HasNamespace ("bar"));
+ Assert.AreEqual ("http://bar/", namespaceManager.LookupNamespace ("bar"));
}
[Test]
// add some namespaces and a scope.
PushScope ();
// pop the scope.
- Assert (namespaceManager.PopScope ());
+ Assert.IsTrue (namespaceManager.PopScope ());
// make sure the first namespace is still there.
- Assert (namespaceManager.HasNamespace ("foo"));
- AssertEquals ("http://foo/", namespaceManager.LookupNamespace ("foo"));
+ Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
+ Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// make sure the second namespace is no longer there.
- Assert (!namespaceManager.HasNamespace ("bar"));
- AssertNull (namespaceManager.LookupNamespace ("bar"));
+ Assert.IsTrue (!namespaceManager.HasNamespace ("bar"));
+ Assert.IsNull (namespaceManager.LookupNamespace ("bar"));
// make sure there are no more scopes to pop.
- Assert (!namespaceManager.PopScope ());
+ Assert.IsTrue (!namespaceManager.PopScope ());
// make sure that popping again doesn't cause an exception.
- Assert (!namespaceManager.PopScope ());
+ Assert.IsTrue (!namespaceManager.PopScope ());
}
[Test]
namespaceManager .PopScope (); // 2
namespaceManager .PopScope (); // 1
namespaceManager .PopScope (); // 0
- AssertEquals ("urn:foo", namespaceManager.LookupNamespace ("foo"));
- AssertEquals ("urn:bar", namespaceManager.LookupNamespace ("bar"));
+ Assert.AreEqual ("urn:foo", namespaceManager.LookupNamespace ("foo"));
+ Assert.AreEqual ("urn:bar", namespaceManager.LookupNamespace ("bar"));
}
[Test]
new XmlNamespaceManager (new NameTable ());
string ns = nsmgr.NameTable.Add ("urn:foo");
nsmgr.AddNamespace ("foo", ns);
- AssertEquals ("foo", nsmgr.LookupPrefix (ns));
+ Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.PushScope ();
- AssertEquals ("foo", nsmgr.LookupPrefix (ns));
+ Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.PopScope ();
- AssertEquals ("foo", nsmgr.LookupPrefix (ns));
+ Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.RemoveNamespace ("foo", ns);
- AssertNull (nsmgr.LookupPrefix (ns));
+ Assert.IsNull (nsmgr.LookupPrefix (ns));
}
[Test]
nsmgr.NameTable.Add ("urn:hoge");
nsmgr.NameTable.Add ("urn:fuga");
nsmgr.AddNamespace (string.Empty, "urn:hoge");
- AssertNull (nsmgr.LookupPrefix ("urn:fuga"));
- AssertEquals (String.Empty, nsmgr.LookupPrefix ("urn:hoge"));
+ Assert.IsNull (nsmgr.LookupPrefix ("urn:fuga"));
+ Assert.AreEqual (String.Empty, nsmgr.LookupPrefix ("urn:hoge"));
}
string suffix = "oo";
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
nsmgr.AddNamespace ("foo", "urn:foo");
- AssertNotNull (nsmgr.LookupPrefix ("urn:foo"));
+ Assert.IsNotNull (nsmgr.LookupPrefix ("urn:foo"));
// FIXME: This returns registered URI inconsistently.
-// AssertNull ("It is not atomized and thus should be failed", nsmgr.LookupPrefix ("urn:f" + suffix));
+// Assert.IsNull (nsmgr.LookupPrefix ("urn:f" + suffix), "It is not atomized and thus should be failed");
}
#if NET_2_0
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
- AssertEquals ("#1", 0, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#2", 0, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#3", 1, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (0, nsmgr.GetNamespacesInScope (l).Count, "#1");
+ Assert.AreEqual (0, nsmgr.GetNamespacesInScope (x).Count, "#2");
+ Assert.AreEqual (1, nsmgr.GetNamespacesInScope (a).Count, "#3");
nsmgr.AddNamespace ("foo", "urn:foo");
- AssertEquals ("#4", 1, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#5", 1, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#6", 2, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (1, nsmgr.GetNamespacesInScope (l).Count, "#4");
+ Assert.AreEqual (1, nsmgr.GetNamespacesInScope (x).Count, "#5");
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (a).Count, "#6");
// default namespace
nsmgr.AddNamespace ("", "urn:empty");
- AssertEquals ("#7", 2, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#8", 2, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#9", 3, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (l).Count, "#7");
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#8");
+ Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#9");
// PushScope
nsmgr.AddNamespace ("foo", "urn:foo");
nsmgr.PushScope ();
- AssertEquals ("#10", 0, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#11", 2, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#12", 3, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (0, nsmgr.GetNamespacesInScope (l).Count, "#10");
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#11");
+ Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#12");
// PopScope
nsmgr.PopScope ();
- AssertEquals ("#13", 2, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#14", 2, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#15", 3, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (l).Count, "#13");
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#14");
+ Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#15");
nsmgr.AddNamespace ("", "");
// MS bug - it should return 1 for .Local but it returns 2 instead.
- AssertEquals ("#16", 1, nsmgr.GetNamespacesInScope (l).Count);
- AssertEquals ("#17", 1, nsmgr.GetNamespacesInScope (x).Count);
- AssertEquals ("#18", 2, nsmgr.GetNamespacesInScope (a).Count);
+ Assert.AreEqual (1, nsmgr.GetNamespacesInScope (l).Count, "#16");
+ Assert.AreEqual (1, nsmgr.GetNamespacesInScope (x).Count, "#17");
+ Assert.AreEqual (2, nsmgr.GetNamespacesInScope (a).Count, "#18");
}
#endif
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlNodeListTests : Assertion
+ public class XmlNodeListTests
{
XmlDocument document;
XmlElement documentElement;
document.LoadXml ("<foo>bar</foo>");
documentElement = document.DocumentElement;
node = documentElement.FirstChild;
- AssertEquals ("Expected a text node.", node.NodeType, XmlNodeType.Text);
- AssertEquals ("Shouldn't have children.", node.HasChildNodes, false);
- AssertEquals ("Should be empty node list.", node.ChildNodes.Count, 0);
- AssertEquals ("Should be empty node list.", node.GetEnumerator().MoveNext(), false);
+ Assert.AreEqual (node.NodeType, XmlNodeType.Text, "Expected a text node.");
+ Assert.AreEqual (node.HasChildNodes, false, "Shouldn't have children.");
+ Assert.AreEqual (node.ChildNodes.Count, 0, "Should be empty node list.");
+ Assert.AreEqual (node.GetEnumerator().MoveNext(), false, "Should be empty node list.");
}
[Test]
{
document.LoadXml ("<foo/>");
documentElement = document.DocumentElement;
- AssertEquals ("Should be empty node list.", documentElement.GetEnumerator().MoveNext(), false);
+ Assert.AreEqual (documentElement.GetEnumerator().MoveNext(), false, "Should be empty node list.");
}
[Test]
{
document.LoadXml ("<foo><child1/></foo>");
documentElement = document.DocumentElement;
- AssertEquals ("Incorrect number of children returned from Count property.", documentElement.ChildNodes.Count, 1);
+ Assert.AreEqual (documentElement.ChildNodes.Count, 1, "Incorrect number of children returned from Count property.");
index = 1;
foreach (XmlNode childNode in documentElement.ChildNodes)
{
- AssertEquals ("Enumerator didn't return correct node.", "child" + index.ToString(), childNode.LocalName);
+ Assert.AreEqual ("child" + index.ToString(), childNode.LocalName, "Enumerator didn't return correct node.");
index++;
}
- AssertEquals ("foreach didn't loop over all children correctly.", index, 2);
+ Assert.AreEqual (index, 2, "foreach didn't loop over all children correctly.");
}
[Test]
{
document.LoadXml ("<foo><child1/><child2/><child3/></foo>");
element = document.DocumentElement;
- AssertEquals ("Incorrect number of children returned from Count property.", element.ChildNodes.Count, 3);
- AssertNull ("Index less than zero should have returned null.", element.ChildNodes [-1]);
- AssertNull ("Index greater than or equal to Count should have returned null.", element.ChildNodes [3]);
- AssertEquals ("Didn't return the correct child.", element.FirstChild, element.ChildNodes[0]);
- AssertEquals ("Didn't return the correct child.", "child1", element.ChildNodes[0].LocalName);
- AssertEquals ("Didn't return the correct child.", "child2", element.ChildNodes[1].LocalName);
- AssertEquals ("Didn't return the correct child.", "child3", element.ChildNodes[2].LocalName);
+ Assert.AreEqual (element.ChildNodes.Count, 3, "Incorrect number of children returned from Count property.");
+ Assert.IsNull (element.ChildNodes [-1], "Index less than zero should have returned null.");
+ Assert.IsNull (element.ChildNodes [3], "Index greater than or equal to Count should have returned null.");
+ Assert.AreEqual (element.FirstChild, element.ChildNodes[0], "Didn't return the correct child.");
+ Assert.AreEqual ("child1", element.ChildNodes[0].LocalName, "Didn't return the correct child.");
+ Assert.AreEqual ("child2", element.ChildNodes[1].LocalName, "Didn't return the correct child.");
+ Assert.AreEqual ("child3", element.ChildNodes[2].LocalName, "Didn't return the correct child.");
index = 1;
foreach (XmlNode childNode in element.ChildNodes)
{
- AssertEquals ("Enumerator didn't return correct node.", "child" + index.ToString(), childNode.LocalName);
+ Assert.AreEqual ("child" + index.ToString(), childNode.LocalName, "Enumerator didn't return correct node.");
index++;
}
- AssertEquals ("foreach didn't loop over all children correctly.", index, 4);
+ Assert.AreEqual (index, 4, "foreach didn't loop over all children correctly.");
}
[Test]
document.LoadXml ("<foo><child1/></foo>");
element = document.DocumentElement;
enumerator = element.GetEnumerator();
- AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
- AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
+ Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
+ Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
enumerator.Reset();
- AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
+ Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
element.AppendChild(document.CreateElement("child2"));
- AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
- AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
+ Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
+ Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
}
[Test]
enumerator = element.GetEnumerator();
element.RemoveChild(element.FirstChild);
enumerator.MoveNext();
- AssertEquals ("Expected child2 element.", ((XmlElement)enumerator.Current).LocalName, "child2");
+ Assert.AreEqual (((XmlElement)enumerator.Current).LocalName, "child2", "Expected child2 element.");
}
[Test]
enumerator = element.GetEnumerator ();
enumerator.MoveNext ();
enumerator.MoveNext ();
- AssertEquals ("Expected child2 element.", "child2", ((XmlElement)enumerator.Current).LocalName);
- AssertEquals ("Expected child2 element.", "child2", element.FirstChild.NextSibling.LocalName);
+ Assert.AreEqual ("child2", ((XmlElement)enumerator.Current).LocalName, "Expected child2 element.");
+ Assert.AreEqual ("child2", element.FirstChild.NextSibling.LocalName, "Expected child2 element.");
element.RemoveChild (element.FirstChild.NextSibling);
enumerator.MoveNext ();
try {
element = (XmlElement) enumerator.Current;
- Fail ("Expected an InvalidOperationException.");
+ Assert.Fail ("Expected an InvalidOperationException.");
} catch (InvalidOperationException) { }
}
element = document.DocumentElement;
node = document.CreateElement("child3");
enumerator = element.GetEnumerator();
- AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
+ Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
element.ReplaceChild(node, element.LastChild);
enumerator.MoveNext();
- AssertEquals ("Expected child3 element.", ((XmlElement)enumerator.Current).LocalName, "child3");
- AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
+ Assert.AreEqual (((XmlElement)enumerator.Current).LocalName, "child3", "Expected child3 element.");
+ Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
}
[Test]
element = document.DocumentElement;
enumerator = element.GetEnumerator();
element.RemoveChild(element.FirstChild);
- AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
+ Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
}
// TODO: Take the word save off front of this method when XmlNode.RemoveAll() is fully implemented.
document.LoadXml ("<foo><child1/><child2/><child3/></foo>");
element = document.DocumentElement;
enumerator = element.GetEnumerator();
- AssertEquals ("Expected 3 children.", element.ChildNodes.Count, 3);
- AssertEquals ("MoveNext should have succeeded.", enumerator.MoveNext(), true);
+ Assert.AreEqual (element.ChildNodes.Count, 3, "Expected 3 children.");
+ Assert.AreEqual (enumerator.MoveNext(), true, "MoveNext should have succeeded.");
element.RemoveAll();
- AssertEquals ("MoveNext should have failed.", enumerator.MoveNext(), false);
+ Assert.AreEqual (enumerator.MoveNext(), false, "MoveNext should have failed.");
}
[Test]
try
{
obj = enumerator.Current;
- Fail ("Calling Current property before first node in list should have thrown InvalidOperationException.");
+ Assert.Fail ("Calling Current property before first node in list should have thrown InvalidOperationException.");
} catch (InvalidOperationException) { }
}
try
{
obj = enumerator.Current;
- Fail ("Calling Current property after last node in list should have thrown InvalidOperationException.");
+ Assert.Fail ("Calling Current property after last node in list should have thrown InvalidOperationException.");
}
catch (InvalidOperationException) { }
}
element = document.DocumentElement;
enumerator = element.GetEnumerator();
enumerator.MoveNext();
- AssertEquals("Consecutive calls to Current property should yield same reference.", Object.ReferenceEquals(enumerator.Current, enumerator.Current), true);
+ Assert.AreEqual (Object.ReferenceEquals(enumerator.Current, enumerator.Current), true, "Consecutive calls to Current property should yield same reference.");
}
[Test]
enumerator = element.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
- AssertEquals("Expected child2.", ((XmlElement)enumerator.Current).LocalName, "child2");
+ Assert.AreEqual (((XmlElement)enumerator.Current).LocalName, "child2", "Expected child2.");
enumerator.Reset();
enumerator.MoveNext();
- AssertEquals("Expected child1.", ((XmlElement)enumerator.Current).LocalName, "child1");
+ Assert.AreEqual (((XmlElement)enumerator.Current).LocalName, "child1", "Expected child1.");
}
[Test]
{
document.LoadXml ("<root><foo/></root>");
XmlNodeList nl = document.DocumentElement.GetElementsByTagName ("bar");
- AssertEquals ("empty list. count", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "empty list. count");
try {
- AssertNull ("index 0", nl [0]);
- AssertNull ("index 1", nl [1]);
- AssertNull ("index -1", nl [-1]);
+ Assert.IsNull (nl [0], "index 0");
+ Assert.IsNull (nl [1], "index 1");
+ Assert.IsNull (nl [-1], "index -1");
} catch (ArgumentOutOfRangeException) {
- Fail ("don't throw index out of range.");
+ Assert.Fail ("don't throw index out of range.");
}
}
}
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XmlNodeReaderTests : Assertion\r
+ public class XmlNodeReaderTests\r
{\r
[SetUp]\r
public void GetReady ()\r
XmlNodeReader nrdr;\r
try {\r
nrdr = new XmlNodeReader (null);\r
- Fail ("null reference exception is preferable.");\r
+ Assert.Fail ("null reference exception is preferable.");\r
} catch (NullReferenceException) {\r
}\r
nrdr = new XmlNodeReader (new XmlDocument ());\r
nrdr.Read ();\r
- AssertEquals ("newDoc.ReadState", ReadState.Error, nrdr.ReadState);\r
- AssertEquals ("newDoc.EOF", true, nrdr.EOF);\r
- AssertEquals ("newDoc.NodeType", XmlNodeType.None, nrdr.NodeType);\r
+ Assert.AreEqual (ReadState.Error, nrdr.ReadState, "newDoc.ReadState");\r
+ Assert.AreEqual (true, nrdr.EOF, "newDoc.EOF");\r
+ Assert.AreEqual (XmlNodeType.None, nrdr.NodeType, "newDoc.NodeType");\r
nrdr = new XmlNodeReader (document.CreateDocumentFragment ());\r
nrdr.Read ();\r
- AssertEquals ("Fragment.ReadState", ReadState.Error, nrdr.ReadState);\r
- AssertEquals ("Fragment.EOF", true, nrdr.EOF);\r
- AssertEquals ("Fragment.NodeType", XmlNodeType.None, nrdr.NodeType);\r
+ Assert.AreEqual (ReadState.Error, nrdr.ReadState, "Fragment.ReadState");\r
+ Assert.AreEqual (true, nrdr.EOF, "Fragment.EOF");\r
+ Assert.AreEqual (XmlNodeType.None, nrdr.NodeType, "Fragment.NodeType");\r
}\r
\r
[Test]\r
{\r
XmlNodeReader nrdr = new XmlNodeReader (document.DocumentElement);\r
nrdr.Read ();\r
- AssertEquals ("<root>.NodeType", XmlNodeType.Element, nrdr.NodeType);\r
- AssertEquals ("<root>.Name", "root", nrdr.Name);\r
- AssertEquals ("<root>.ReadState", ReadState.Interactive, nrdr.ReadState);\r
- AssertEquals ("<root>.Depth", 0, nrdr.Depth);\r
+ Assert.AreEqual (XmlNodeType.Element, nrdr.NodeType, "<root>.NodeType");\r
+ Assert.AreEqual ("root", nrdr.Name, "<root>.Name");\r
+ Assert.AreEqual (ReadState.Interactive, nrdr.ReadState, "<root>.ReadState");\r
+ Assert.AreEqual (0, nrdr.Depth, "<root>.Depth");\r
}\r
\r
\r
document.LoadXml ("<root>test of <b>mixed</b> string.</root>");\r
XmlNodeReader nrdr = new XmlNodeReader (document);\r
nrdr.ReadInnerXml ();\r
- AssertEquals ("initial.ReadState", ReadState.Initial, nrdr.ReadState);\r
- AssertEquals ("initial.EOF", false, nrdr.EOF);\r
- AssertEquals ("initial.NodeType", XmlNodeType.None, nrdr.NodeType);\r
+ Assert.AreEqual (ReadState.Initial, nrdr.ReadState, "initial.ReadState");\r
+ Assert.AreEqual (false, nrdr.EOF, "initial.EOF");\r
+ Assert.AreEqual (XmlNodeType.None, nrdr.NodeType, "initial.NodeType");\r
}\r
\r
[Test]\r
string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;\r
string xml = dtd + "<root>&ent;&ent2;</root>";\r
document.LoadXml (xml);\r
- AssertEquals (xml, document.OuterXml);\r
+ Assert.AreEqual (xml, document.OuterXml);\r
XmlNodeReader nr = new XmlNodeReader (document);\r
nr.Read (); // DTD\r
nr.Read (); // root\r
nr.Read (); // &ent;\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
- AssertEquals ("depth#1", 1, nr.Depth);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (1, nr.Depth, "depth#1");\r
nr.ResolveEntity ();\r
// It is still entity reference.\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
nr.Read ();\r
- AssertEquals (XmlNodeType.Text, nr.NodeType);\r
- AssertEquals ("depth#2", 2, nr.Depth);\r
- AssertEquals ("entity string", nr.Value);\r
+ Assert.AreEqual (XmlNodeType.Text, nr.NodeType);\r
+ Assert.AreEqual (2, nr.Depth, "depth#2");\r
+ Assert.AreEqual ("entity string", nr.Value);\r
nr.Read ();\r
- AssertEquals (XmlNodeType.EndEntity, nr.NodeType);\r
- AssertEquals ("depth#3", 1, nr.Depth);\r
- AssertEquals ("", nr.Value);\r
+ Assert.AreEqual (XmlNodeType.EndEntity, nr.NodeType);\r
+ Assert.AreEqual (1, nr.Depth, "depth#3");\r
+ Assert.AreEqual ("", nr.Value);\r
\r
nr.Read (); // &ent2;\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
- AssertEquals ("depth#4", 1, nr.Depth);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (1, nr.Depth, "depth#4");\r
nr.ResolveEntity ();\r
- AssertEquals (xml, document.OuterXml);\r
+ Assert.AreEqual (xml, document.OuterXml);\r
// It is still entity reference.\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
// It now became element node.\r
nr.Read ();\r
- AssertEquals (XmlNodeType.Element, nr.NodeType);\r
- AssertEquals ("depth#5", 2, nr.Depth);\r
+ Assert.AreEqual (XmlNodeType.Element, nr.NodeType);\r
+ Assert.AreEqual (2, nr.Depth, "depth#5");\r
\r
- AssertEquals (xml, document.OuterXml);\r
+ Assert.AreEqual (xml, document.OuterXml);\r
}\r
\r
[Test]\r
document.AppendChild (document.ReadNode (xtr));\r
document.AppendChild (document.ReadNode (xtr));\r
xtr.Close ();\r
- AssertEquals (xml, document.OuterXml);\r
+ Assert.AreEqual (xml, document.OuterXml);\r
XmlNodeReader nr = new XmlNodeReader (document);\r
nr.Read (); // DTD\r
nr.Read (); // root\r
nr.Read (); // &ent3;\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
// ent3 does not exists in this dtd.\r
nr.ResolveEntity ();\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
nr.Read ();\r
#if false\r
// Hmm... MS.NET returned as it is a Text node.\r
- AssertEquals (XmlNodeType.Text, nr.NodeType);\r
- AssertEquals (String.Empty, nr.Value);\r
+ Assert.AreEqual (XmlNodeType.Text, nr.NodeType);\r
+ Assert.AreEqual (String.Empty, nr.Value);\r
nr.Read ();\r
// Really!?\r
- AssertEquals (XmlNodeType.EndEntity, nr.NodeType);\r
- AssertEquals (String.Empty, nr.Value);\r
+ Assert.AreEqual (XmlNodeType.EndEntity, nr.NodeType);\r
+ Assert.AreEqual (String.Empty, nr.Value);\r
#endif\r
}\r
\r
xtr.Read ();\r
document.AppendChild (document.ReadNode (xtr));\r
xtr.Close ();\r
- AssertEquals (xml, document.OuterXml);\r
+ Assert.AreEqual (xml, document.OuterXml);\r
XmlNodeReader nr = new XmlNodeReader (document);\r
nr.Read (); // root\r
nr.Read (); // &ent;\r
- AssertEquals (XmlNodeType.EntityReference, nr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, nr.NodeType);\r
// ent does not exists in this dtd.\r
nr.ResolveEntity ();\r
}\r
XmlNodeReader nr = new XmlNodeReader (\r
document.DocumentElement.FirstChild);\r
nr.Read ();\r
- AssertEquals ("#0", true, nr.IsEmptyElement);\r
- Assert ("#1", !nr.Read ());\r
+ Assert.AreEqual (true, nr.IsEmptyElement, "#0");\r
+ Assert.IsTrue (!nr.Read (), "#1");\r
\r
document.LoadXml ("<root><child></child></root>");\r
nr = new XmlNodeReader (\r
document.DocumentElement.FirstChild);\r
nr.Read ();\r
- Assert ("#2", nr.Read ());\r
- AssertEquals ("#2.2", false, nr.IsEmptyElement);\r
- Assert ("#3", !nr.Read ());\r
+ Assert.IsTrue (nr.Read (), "#2");\r
+ Assert.AreEqual (false, nr.IsEmptyElement, "#2.2");\r
+ Assert.IsTrue (!nr.Read (), "#3");\r
}\r
}\r
\r
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlNodeTests : Assertion
+ public class XmlNodeTests
{
XmlDocument document;
XmlElement element;
inserted = false;
inserting = false;
element.AppendChild (element2);
- Assert (inserted);
- Assert (inserting);
+ Assert.IsTrue (inserted);
+ Assert.IsTrue (inserting);
// Can only append to elements, documents, and attributes
try
{
comment = document.CreateComment ("baz");
comment.AppendChild (element2);
- Fail ("Expected an InvalidOperationException to be thrown.");
+ Assert.Fail ("Expected an InvalidOperationException to be thrown.");
}
catch (InvalidOperationException) {}
// Can't append a node from one document into another document.
XmlDocument document2 = new XmlDocument();
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
try
{
element2 = document2.CreateElement ("qux");
element.AppendChild (element2);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
}
catch (ArgumentException) {}
- AssertEquals (1, element.ChildNodes.Count);
+ Assert.AreEqual (1, element.ChildNodes.Count);
// Can't append to a readonly node.
/* TODO put this in when I figure out how to create a read-only node.
try
{
XmlElement element3 = (XmlElement)element.CloneNode (false);
- Assert (!element.IsReadOnly);
- Assert (element3.IsReadOnly);
+ Assert.IsTrue (!element.IsReadOnly);
+ Assert.IsTrue (element3.IsReadOnly);
element2 = document.CreateElement ("quux");
element3.AppendChild (element2);
- Fail ("Expected an ArgumentException to be thrown.");
+ Assert.Fail ("Expected an ArgumentException to be thrown.");
}
catch (ArgumentException) {}
*/
document.LoadXml ("<root xmlns='urn:default' attr='value' "
+ "xml:lang='en' xmlns:foo='urn:foo' foo:att='fooatt'>text node</root>");
XmlNode n = document.DocumentElement;
- AssertEquals ("#1", "urn:default", n.GetNamespaceOfPrefix (String.Empty));
- AssertEquals ("#2", "urn:foo", n.GetNamespaceOfPrefix ("foo"));
- AssertEquals ("#3", String.Empty, n.GetNamespaceOfPrefix ("bar"));
+ Assert.AreEqual ("urn:default", n.GetNamespaceOfPrefix (String.Empty), "#1");
+ Assert.AreEqual ("urn:foo", n.GetNamespaceOfPrefix ("foo"), "#2");
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("bar"), "#3");
#if NET_2_0
- AssertEquals ("#4", "http://www.w3.org/XML/1998/namespace", n.GetNamespaceOfPrefix ("xml"));
- AssertEquals ("#5", "http://www.w3.org/2000/xmlns/", n.GetNamespaceOfPrefix ("xmlns"));
+ Assert.AreEqual ("http://www.w3.org/XML/1998/namespace", n.GetNamespaceOfPrefix ("xml"), "#4");
+ Assert.AreEqual ("http://www.w3.org/2000/xmlns/", n.GetNamespaceOfPrefix ("xmlns"), "#5");
#else
- AssertEquals ("#4", String.Empty, n.GetNamespaceOfPrefix ("xml"));
- AssertEquals ("#5", String.Empty, n.GetNamespaceOfPrefix ("xmlns"));
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("xml"), "#4");
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("xmlns"), "#5");
#endif
n = document.DocumentElement.FirstChild;
- AssertEquals ("#6", "urn:default", n.GetNamespaceOfPrefix (String.Empty));
- AssertEquals ("#7", "urn:foo", n.GetNamespaceOfPrefix ("foo"));
- AssertEquals ("#8", String.Empty, n.GetNamespaceOfPrefix ("bar"));
+ Assert.AreEqual ("urn:default", n.GetNamespaceOfPrefix (String.Empty), "#6");
+ Assert.AreEqual ("urn:foo", n.GetNamespaceOfPrefix ("foo"), "#7");
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("bar"), "#8");
#if NET_2_0
- AssertEquals ("#9", "http://www.w3.org/XML/1998/namespace", n.GetNamespaceOfPrefix ("xml"));
- AssertEquals ("#10", "http://www.w3.org/2000/xmlns/", n.GetNamespaceOfPrefix ("xmlns"));
+ Assert.AreEqual ("http://www.w3.org/XML/1998/namespace", n.GetNamespaceOfPrefix ("xml"), "#9");
+ Assert.AreEqual ("http://www.w3.org/2000/xmlns/", n.GetNamespaceOfPrefix ("xmlns"), "#10");
#else
- AssertEquals ("#9", String.Empty, n.GetNamespaceOfPrefix ("xml"));
- AssertEquals ("#10", String.Empty, n.GetNamespaceOfPrefix ("xmlns"));
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("xml"), "#9");
+ Assert.AreEqual (String.Empty, n.GetNamespaceOfPrefix ("xmlns"), "#10");
#endif
}
document.LoadXml("<root><sub /></root>");
XmlElement docelem = document.DocumentElement;
docelem.InsertBefore(document.CreateElement("good_child"), docelem.FirstChild);
- AssertEquals("InsertBefore.Normal", "good_child", docelem.FirstChild.Name);
+ Assert.AreEqual ("good_child", docelem.FirstChild.Name, "InsertBefore.Normal");
// These are required for .NET 1.0 but not for .NET 1.1.
try {
document.InsertBefore (document.CreateElement ("BAD_MAN"), docelem);
- Fail ("#InsertBefore.BadPositionButNoError.1");
+ Assert.Fail ("#InsertBefore.BadPositionButNoError.1");
}
catch (Exception) {}
}
XmlElement docelem = document.DocumentElement;
XmlElement newelem = document.CreateElement("good_child");
docelem.InsertAfter(newelem, docelem.FirstChild);
- AssertEquals("InsertAfter.Normal", 3, docelem.ChildNodes.Count);
- AssertEquals("InsertAfter.First", "sub1", docelem.FirstChild.Name);
- AssertEquals("InsertAfter.Last", "sub2", docelem.LastChild.Name);
- AssertEquals("InsertAfter.Prev", "good_child", docelem.FirstChild.NextSibling.Name);
- AssertEquals("InsertAfter.Next", "good_child", docelem.LastChild.PreviousSibling.Name);
+ Assert.AreEqual (3, docelem.ChildNodes.Count, "InsertAfter.Normal");
+ Assert.AreEqual ("sub1", docelem.FirstChild.Name, "InsertAfter.First");
+ Assert.AreEqual ("sub2", docelem.LastChild.Name, "InsertAfter.Last");
+ Assert.AreEqual ("good_child", docelem.FirstChild.NextSibling.Name, "InsertAfter.Prev");
+ Assert.AreEqual ("good_child", docelem.LastChild.PreviousSibling.Name, "InsertAfter.Next");
// this doesn't throw any exception *only on .NET 1.1*
// .NET 1.0 throws an exception.
try {
document.InsertAfter(document.CreateElement("BAD_MAN"), docelem);
#if USE_VERSION_1_1
- AssertEquals("InsertAfter with bad location",
- "<root><sub1 /><good_child /><sub2 /></root><BAD_MAN />",
- document.InnerXml);
+ Assert.AreEqual ("<root><sub1 /><good_child /><sub2 /></root><BAD_MAN />", document.InnerXml, "InsertAfter with bad location");
} catch (XmlException ex) {
throw ex;
}
doc.NodeChanged += new XmlNodeChangedEventHandler (EventNodeChanged);
doc.NodeRemoved += new XmlNodeChangedEventHandler (EventNodeRemoved);
- AssertEquals (3, doc.DocumentElement.ChildNodes.Count);
+ Assert.AreEqual (3, doc.DocumentElement.ChildNodes.Count);
doc.DocumentElement.Normalize ();
- AssertEquals (3, doc.DocumentElement.ChildNodes.Count);
- Assert (changed);
+ Assert.AreEqual (3, doc.DocumentElement.ChildNodes.Count);
+ Assert.IsTrue (changed);
inserted = changed = removed = false;
doc.DocumentElement.AppendChild (doc.CreateTextNode ("Addendum."));
- AssertEquals (4, doc.DocumentElement.ChildNodes.Count);
+ Assert.AreEqual (4, doc.DocumentElement.ChildNodes.Count);
inserted = changed = removed = false;
doc.DocumentElement.Normalize ();
- AssertEquals (3, doc.DocumentElement.ChildNodes.Count);
- Assert (changed);
- Assert (removed);
+ Assert.AreEqual (3, doc.DocumentElement.ChildNodes.Count);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (removed);
inserted = changed = removed = false;
doc.DocumentElement.SetAttribute ("attr", "");
XmlAttribute attr = doc.DocumentElement.Attributes [0] as XmlAttribute;
- AssertEquals (1, attr.ChildNodes.Count);
+ Assert.AreEqual (1, attr.ChildNodes.Count);
inserted = changed = removed = false;
attr.Normalize ();
// Such behavior violates DOM Level 2 Node#normalize(),
// but MS DOM is designed as such.
- AssertEquals (1, attr.ChildNodes.Count);
+ Assert.AreEqual (1, attr.ChildNodes.Count);
}
[Test]
doc.NodeInserted += new XmlNodeChangedEventHandler (OnChange);
doc.NodeChanged += new XmlNodeChangedEventHandler (OnChange);
doc.NodeRemoved += new XmlNodeChangedEventHandler (OnChange);
- AssertEquals ("Before Normalize()", 5, root.ChildNodes.Count);
+ Assert.AreEqual (5, root.ChildNodes.Count, "Before Normalize()");
root.Normalize ();
- AssertEquals ("<root> foobar baz</root>", root.OuterXml);
- AssertEquals ("After Normalize()", 1, root.ChildNodes.Count);
+ Assert.AreEqual ("<root> foobar baz</root>", root.OuterXml);
+ Assert.AreEqual (1, root.ChildNodes.Count, "After Normalize()");
}
int normalize2Count;
{
switch (normalize2Count) {
case 0:
- AssertEquals ("Action0", XmlNodeChangedAction.Remove, e.Action);
- AssertEquals ("Value0", " ", e.Node.Value);
+ Assert.AreEqual (XmlNodeChangedAction.Remove, e.Action, "Action0");
+ Assert.AreEqual (" ", e.Node.Value, "Value0");
break;
case 1:
- AssertEquals ("Action1", XmlNodeChangedAction.Remove, e.Action);
- AssertEquals ("Value1", "bar", e.Node.Value);
+ Assert.AreEqual (XmlNodeChangedAction.Remove, e.Action, "Action1");
+ Assert.AreEqual ("bar", e.Node.Value, "Value1");
break;
case 2:
- AssertEquals ("Action2", XmlNodeChangedAction.Remove, e.Action);
- AssertEquals ("Value2", " ", e.Node.Value);
+ Assert.AreEqual (XmlNodeChangedAction.Remove, e.Action, "Action2");
+ Assert.AreEqual (" ", e.Node.Value, "Value2");
break;
case 3:
- AssertEquals ("Action3", XmlNodeChangedAction.Remove, e.Action);
- AssertEquals ("Value3", "baz", e.Node.Value);
+ Assert.AreEqual (XmlNodeChangedAction.Remove, e.Action, "Action3");
+ Assert.AreEqual ("baz", e.Node.Value, "Value3");
break;
case 4:
- AssertEquals ("Action4", XmlNodeChangedAction.Change, e.Action);
- AssertEquals ("Value4", " foobar baz", e.Node.Value);
+ Assert.AreEqual (XmlNodeChangedAction.Change, e.Action, "Action4");
+ Assert.AreEqual (" foobar baz", e.Node.Value, "Value4");
break;
default:
- Fail (String.Format ("Unexpected event. Action = {0}, node type = {1}, node name = {2}, node value = {3}", e.Action, e.Node.NodeType, e.Node.Name, e.Node.Value));
+ Assert.Fail (String.Format ("Unexpected event. Action = {0}, node type = {1}, node name = {2}, node value = {3}", e.Action, e.Node.NodeType, e.Node.Name, e.Node.Value));
break;
}
normalize2Count++;
document.LoadXml("<root><sub1 /><sub2 /></root>");
XmlElement docelem = document.DocumentElement;
docelem.PrependChild(document.CreateElement("prepender"));
- AssertEquals("PrependChild", "prepender", docelem.FirstChild.Name);
+ Assert.AreEqual ("prepender", docelem.FirstChild.Name, "PrependChild");
}
public void saveTestRemoveAll ()
removed = false;
removing = false;
element.RemoveAll ();
- Assert (removed);
- Assert (removing);
+ Assert.IsTrue (removed);
+ Assert.IsTrue (removing);
}
[Test]
removed = false;
removing = false;
element.RemoveChild (element2);
- Assert (removed);
- Assert (removing);
+ Assert.IsTrue (removed);
+ Assert.IsTrue (removing);
}
[Test]
{
element.InnerXml = "<foo/><bar/><baz/>";
element.RemoveChild (element.LastChild);
- AssertNotNull (element.FirstChild);
+ Assert.IsNotNull (element.FirstChild);
}
[Test]
public void GetPrefixOfNamespace ()
{
document.LoadXml ("<root><c1 xmlns='urn:foo'><c2 xmlns:foo='urn:foo' xmlns='urn:bar'><c3 xmlns=''/></c2></c1></root>");
- AssertEquals ("root", String.Empty, document.DocumentElement.GetPrefixOfNamespace ("urn:foo"));
- AssertEquals ("c1", String.Empty, document.DocumentElement.GetPrefixOfNamespace ("urn:foo"));
- AssertEquals ("c2", String.Empty, document.DocumentElement.FirstChild.GetPrefixOfNamespace ("urn:foo"));
- AssertEquals ("c3", "foo", document.DocumentElement.FirstChild.FirstChild.GetPrefixOfNamespace ("urn:foo"));
+ Assert.AreEqual (String.Empty, document.DocumentElement.GetPrefixOfNamespace ("urn:foo"), "root");
+ Assert.AreEqual (String.Empty, document.DocumentElement.GetPrefixOfNamespace ("urn:foo"), "c1");
+ Assert.AreEqual (String.Empty, document.DocumentElement.FirstChild.GetPrefixOfNamespace ("urn:foo"), "c2");
+ Assert.AreEqual ("foo", document.DocumentElement.FirstChild.FirstChild.GetPrefixOfNamespace ("urn:foo"), "c3");
// disconnected nodes.
XmlNode n = document.CreateElement ("foo");
- AssertEquals (String.Empty, n.GetPrefixOfNamespace ("foo"));
+ Assert.AreEqual (String.Empty, n.GetPrefixOfNamespace ("foo"));
n = document.CreateTextNode ("text"); // does not have Attributes
- AssertEquals (String.Empty, n.GetPrefixOfNamespace ("foo"));
+ Assert.AreEqual (String.Empty, n.GetPrefixOfNamespace ("foo"));
n = document.CreateXmlDeclaration ("1.0", null, null); // does not have Attributes
- AssertEquals (String.Empty, n.GetPrefixOfNamespace ("foo"));
+ Assert.AreEqual (String.Empty, n.GetPrefixOfNamespace ("foo"));
}
[Test]
doc.DocumentElement.Attributes [0].Value = "urn:foo";
XmlElement el = doc.CreateElement ("bar");
doc.DocumentElement.AppendChild (el);
- AssertEquals ("u", el.GetPrefixOfNamespace ("urn:foo"));
+ Assert.AreEqual ("u", el.GetPrefixOfNamespace ("urn:foo"));
}
[Test]
inserted = changed = removed = false;
XmlElement el = document.CreateElement("root2");
document.ReplaceChild (el, document.DocumentElement);
- AssertEquals ("root2", document.DocumentElement.Name);
- AssertEquals (1, document.ChildNodes.Count);
- Assert (inserted && removed && !changed);
+ Assert.AreEqual ("root2", document.DocumentElement.Name);
+ Assert.AreEqual (1, document.ChildNodes.Count);
+ Assert.IsTrue (inserted && removed && !changed);
}
[Test]
document.LoadXml ("<root>This is <b>mixed</b> content. Also includes <![CDATA[CDATA section]]>.<!-- Should be ignored --></root>");
string total = "This is mixed content. Also includes CDATA section.";
XmlNode elemB = document.DocumentElement.ChildNodes [1];
- AssertEquals ("mixed", elemB.FirstChild.InnerText); // text node
- AssertEquals ("mixed", elemB.InnerText); // element b
- AssertEquals (total, document.DocumentElement.InnerText); // element root
- AssertEquals (total, document.InnerText); // whole document
+ Assert.AreEqual ("mixed", elemB.FirstChild.InnerText); // text node
+ Assert.AreEqual ("mixed", elemB.InnerText); // element b
+ Assert.AreEqual (total, document.DocumentElement.InnerText); // element root
+ Assert.AreEqual (total, document.InnerText); // whole document
}
[Test]
xel.SetAttribute ("xmlns", "http://www.w3.org/2000/09/xmldsig#");
xel.InnerXml = "<DSAKeyValue>blablabla</DSAKeyValue>";
string expected = "<KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><DSAKeyValue>blablabla</DSAKeyValue></KeyValue>";
- AssertEquals (expected, xel.OuterXml);
+ Assert.AreEqual (expected, xel.OuterXml);
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<element xmlns='urn:foo'><foo><bar>test</bar></foo></element>");
XmlNodeList nl = doc.SelectNodes (xpath);
- AssertEquals (6, nl.Count);
+ Assert.AreEqual (6, nl.Count);
// BTW, as for namespace nodes, Node does not exist
// in the tree, so the return value should be
// implementation dependent.
- AssertEquals ("#1", XmlNodeType.Attribute, nl [0].NodeType);
- AssertEquals ("#2", XmlNodeType.Attribute, nl [1].NodeType);
- AssertEquals ("#3", XmlNodeType.Attribute, nl [2].NodeType);
- AssertEquals ("#4", XmlNodeType.Attribute, nl [3].NodeType);
- AssertEquals ("#5", XmlNodeType.Attribute, nl [4].NodeType);
- AssertEquals ("#6", XmlNodeType.Attribute, nl [5].NodeType);
- AssertEquals ("xmlns", nl [0].LocalName);
- AssertEquals ("xml", nl [1].LocalName);
- AssertEquals ("xmlns", nl [2].LocalName);
- AssertEquals ("xml", nl [3].LocalName);
- AssertEquals ("xmlns", nl [4].LocalName);
- AssertEquals ("xml", nl [5].LocalName);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [0].NodeType, "#1");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [1].NodeType, "#2");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [2].NodeType, "#3");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [3].NodeType, "#4");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [4].NodeType, "#5");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [5].NodeType, "#6");
+ Assert.AreEqual ("xmlns", nl [0].LocalName);
+ Assert.AreEqual ("xml", nl [1].LocalName);
+ Assert.AreEqual ("xmlns", nl [2].LocalName);
+ Assert.AreEqual ("xml", nl [3].LocalName);
+ Assert.AreEqual ("xmlns", nl [4].LocalName);
+ Assert.AreEqual ("xml", nl [5].LocalName);
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<element xmlns='urn:foo'><foo><bar>test</bar></foo></element>");
XmlNodeList nl = doc.SelectNodes (xpath);
- AssertEquals (9, nl.Count);
- AssertEquals (XmlNodeType.Element, nl [0].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [1].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [2].NodeType);
- AssertEquals (XmlNodeType.Element, nl [3].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [4].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [5].NodeType);
- AssertEquals (XmlNodeType.Element, nl [6].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [7].NodeType);
- AssertEquals (XmlNodeType.Attribute, nl [8].NodeType);
- AssertEquals ("element", nl [0].LocalName);
- AssertEquals ("xmlns", nl [1].LocalName);
- AssertEquals ("xml", nl [2].LocalName);
- AssertEquals ("foo", nl [3].LocalName);
- AssertEquals ("xmlns", nl [4].LocalName);
- AssertEquals ("xml", nl [5].LocalName);
- AssertEquals ("bar", nl [6].LocalName);
- AssertEquals ("xmlns", nl [7].LocalName);
- AssertEquals ("xml", nl [8].LocalName);
+ Assert.AreEqual (9, nl.Count);
+ Assert.AreEqual (XmlNodeType.Element, nl [0].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [1].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [2].NodeType);
+ Assert.AreEqual (XmlNodeType.Element, nl [3].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [4].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [5].NodeType);
+ Assert.AreEqual (XmlNodeType.Element, nl [6].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [7].NodeType);
+ Assert.AreEqual (XmlNodeType.Attribute, nl [8].NodeType);
+ Assert.AreEqual ("element", nl [0].LocalName);
+ Assert.AreEqual ("xmlns", nl [1].LocalName);
+ Assert.AreEqual ("xml", nl [2].LocalName);
+ Assert.AreEqual ("foo", nl [3].LocalName);
+ Assert.AreEqual ("xmlns", nl [4].LocalName);
+ Assert.AreEqual ("xml", nl [5].LocalName);
+ Assert.AreEqual ("bar", nl [6].LocalName);
+ Assert.AreEqual ("xmlns", nl [7].LocalName);
+ Assert.AreEqual ("xml", nl [8].LocalName);
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.Load ("Test/XmlFiles/simple.xml");
XmlElement el = doc.CreateElement ("foo");
- AssertEquals (String.Empty, el.BaseURI);
+ Assert.AreEqual (String.Empty, el.BaseURI);
doc.DocumentElement.AppendChild (el);
- Assert (String.Empty != el.BaseURI);
+ Assert.IsTrue (String.Empty != el.BaseURI);
XmlAttribute attr = doc.CreateAttribute ("attr");
- AssertEquals (String.Empty, attr.BaseURI);
+ Assert.AreEqual (String.Empty, attr.BaseURI);
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (xml);
XmlNode n = doc.DocumentElement.FirstChild.FirstChild;
- Assert ("#1", n.IsReadOnly);
- Assert ("#2", !n.CloneNode (true).IsReadOnly);
+ Assert.IsTrue (n.IsReadOnly, "#1");
+ Assert.IsTrue (!n.CloneNode (true).IsReadOnly, "#2");
}
[Test] // bug #80233
{
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<a><!--xx--></a>");
- AssertEquals (String.Empty, doc.InnerText);
+ Assert.AreEqual (String.Empty, doc.InnerText);
}
[Test] // part of bug #80331
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlProcessingInstructionTests : Assertion
+ public class XmlProcessingInstructionTests
{
XmlDocument document;
XmlProcessingInstruction pi;
public void InnerAndOuterXml ()
{
pi = document.CreateProcessingInstruction ("foo", "bar");
- AssertEquals (String.Empty, pi.InnerXml);
- AssertEquals ("<?foo bar?>", pi.OuterXml);
+ Assert.AreEqual (String.Empty, pi.InnerXml);
+ Assert.AreEqual ("<?foo bar?>", pi.OuterXml);
}
}
}
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
+ 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 (xmlReader.Read ());\r
- AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
- AssertEquals ("1", xmlReader ["_1"]);\r
+ Assert.IsTrue (xmlReader.Read ());\r
+ Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
+ Assert.AreEqual ("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
+ 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 (!xmlReader.MoveToNextAttribute ());\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
- AssertEquals ("#2", "urn:foo", reader.LookupNamespace ("x"));\r
+ Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2");\r
reader.Read ();\r
- AssertEquals ("#3", "urn:foo", reader.LookupNamespace ("x"));\r
+ Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3");\r
}\r
\r
[Test]\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
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
r.MoveToContent (); // ->root\r
r.Read (); // root->baz\r
r.Read (); // baz->bar\r
- Assert ("#1", r.ReadToNextSibling ("foo"));\r
- AssertEquals ("#2", "value2", r.GetAttribute ("attr"));\r
+ Assert.IsTrue (r.ReadToNextSibling ("foo"), "#1");\r
+ Assert.AreEqual ("value2", r.GetAttribute ("attr"), "#2");\r
r.Read (); // foo[@value='value2']->bar\r
- Assert ("#3", !r.ReadToNextSibling ("foo"));\r
- AssertEquals ("#4", XmlNodeType.EndElement, r.NodeType);\r
- AssertEquals ("#5", "foo", r.LocalName);\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
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.Read ();\r
xr.Read ();\r
xr.Read ();\r
- AssertEquals (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
+ Assert.AreEqual (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
}\r
\r
[Test]\r
{\r
XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
xr.Read ();\r
- AssertEquals (String.Empty, xr.ReadContentAsString ());\r
+ Assert.AreEqual (String.Empty, xr.ReadContentAsString ());\r
}\r
\r
[Test]\r
{\r
XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
xr.Read ();\r
- AssertEquals (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
xr.ReadElementContentAsString ();\r
}\r
\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
{\r
reader.MoveToContent ();\r
reader.Read ();\r
- AssertEquals (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
- AssertEquals (XmlNodeType.EndElement, reader.NodeType);\r
+ Assert.AreEqual (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType);\r
}\r
\r
[Test]\r
XmlReader sub = reader.ReadSubtree ();\r
sub.ReadToDescendant ("item");\r
sub.Close ();\r
- AssertEquals ("#1", XmlNodeType.EndElement, reader.NodeType);\r
- AssertEquals ("#2", "item-list", reader.Name);\r
+ Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#1");\r
+ Assert.AreEqual ("item-list", reader.Name, "#2");\r
}\r
\r
[Test]\r
XmlReader r = XmlReader.Create (new StringReader (xml));\r
r.Read ();\r
XmlReader s = r.ReadSubtree ();\r
- Assert ("#1", s.Read ());\r
- AssertEquals ("#2", XmlNodeType.Element, s.NodeType);\r
- Assert ("#3", !s.Read ());\r
- AssertEquals ("#4", XmlNodeType.None, s.NodeType);\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
r2.Read ();\r
XmlReader r3 = r2.ReadSubtree ();\r
r2.MoveToFirstAttribute ();\r
- Assert ("#1", !r.IsEmptyElement);\r
- Assert ("#2", !r2.IsEmptyElement);\r
+ Assert.IsTrue (!r.IsEmptyElement, "#1");\r
+ Assert.IsTrue (!r2.IsEmptyElement, "#2");\r
r3.Close ();\r
- Assert ("#3", r.IsEmptyElement);\r
- Assert ("#4", r2.IsEmptyElement);\r
+ Assert.IsTrue (r.IsEmptyElement, "#3");\r
+ Assert.IsTrue (r2.IsEmptyElement, "#4");\r
r2.Close ();\r
- Assert ("#5", r.IsEmptyElement);\r
- Assert ("#6", r2.IsEmptyElement);\r
+ Assert.IsTrue (r.IsEmptyElement, "#5");\r
+ Assert.IsTrue (r2.IsEmptyElement, "#6");\r
}\r
\r
[Test]\r
\r
xmlReader.ReadStartElement ();\r
readBytes = xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length);\r
- AssertEquals ("#1", 24, readBytes);\r
- AssertEquals ("#2", 0, 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
- AssertEquals ("#3", "000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString ());\r
+ Assert.AreEqual ("000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString (), "#3");\r
}\r
\r
[Test]\r
const int bufferLength = 1024;\r
byte [] buffer = new byte [bufferLength];\r
readerXml.ReadContentAsBase64 (buffer, 0, bufferLength);\r
- AssertEquals ("#1", XmlNodeType.EndElement, readerXml.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EndElement, readerXml.NodeType, "#1");\r
readerXml.Read ();\r
- AssertEquals ("#2", XmlNodeType.Element, readerXml.NodeType);\r
+ Assert.AreEqual (XmlNodeType.Element, readerXml.NodeType, "#2");\r
}\r
}\r
#endif\r
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlReaderSettingsTests : Assertion
+ public class XmlReaderSettingsTests
{
public Stream CreateStream (string xml)
{
public void DefaultValue ()
{
XmlReaderSettings s = new XmlReaderSettings ();
- AssertEquals ("CheckCharacters", true, s.CheckCharacters);
- AssertEquals ("ConformanceLevel", ConformanceLevel.Document,
- s.ConformanceLevel);
- AssertEquals ("ValidationType", ValidationType.None, s.ValidationType);
- AssertEquals ("IgnoreComments", false, s.IgnoreComments);
- Assert ("ProcessInlineSchema", 0 == (s.ValidationFlags &
- ValidationFlags.ProcessInlineSchema));
- AssertEquals ("IgnorePI", false, s.IgnoreProcessingInstructions);
- Assert ("ProcessSchemaLocation", 0 == (s.ValidationFlags &
- ValidationFlags.ProcessSchemaLocation));
- Assert ("ReportValidationWarnings", 0 == (s.ValidationFlags &
- ValidationFlags.ReportValidationWarnings));
- Assert ("ProcessIdentityConstraints", 0 != (s.ValidationFlags &
- ValidationFlags.ProcessIdentityConstraints));
+ Assert.AreEqual (true, s.CheckCharacters, "CheckCharacters");
+ Assert.AreEqual (ConformanceLevel.Document, s.ConformanceLevel, "ConformanceLevel");
+ Assert.AreEqual (ValidationType.None, s.ValidationType, "ValidationType");
+ Assert.AreEqual (false, s.IgnoreComments, "IgnoreComments");
+ Assert.IsTrue (0 == (s.ValidationFlags &
+ ValidationFlags.ProcessInlineSchema), "ProcessInlineSchema");
+ Assert.AreEqual (false, s.IgnoreProcessingInstructions, "IgnorePI");
+ Assert.IsTrue (0 == (s.ValidationFlags &
+ ValidationFlags.ProcessSchemaLocation), "ProcessSchemaLocation");
+ Assert.IsTrue (0 == (s.ValidationFlags &
+ ValidationFlags.ReportValidationWarnings), "ReportValidationWarnings");
+ Assert.IsTrue (0 != (s.ValidationFlags &
+ ValidationFlags.ProcessIdentityConstraints), "ProcessIdentityConstraints");
// No one should use this flag BTW if someone wants
// code to be conformant to W3C XML Schema standard.
- Assert ("AllowXmlAttributes", 0 != (s.ValidationFlags &
- ValidationFlags.AllowXmlAttributes));
- AssertEquals ("IgnoreWhitespace", false, s.IgnoreWhitespace);
- AssertEquals ("LineNumberOffset", 0, s.LineNumberOffset);
- AssertEquals ("LinePositionOffset", 0, s.LinePositionOffset);
- AssertNull ("NameTable", s.NameTable);
- AssertEquals ("Schemas.Count", 0, s.Schemas.Count);
+ Assert.IsTrue (0 != (s.ValidationFlags &
+ ValidationFlags.AllowXmlAttributes), "AllowXmlAttributes");
+ Assert.AreEqual (false, s.IgnoreWhitespace, "IgnoreWhitespace");
+ Assert.AreEqual (0, s.LineNumberOffset, "LineNumberOffset");
+ Assert.AreEqual (0, s.LinePositionOffset, "LinePositionOffset");
+ Assert.IsNull (s.NameTable, "NameTable");
+ Assert.AreEqual (0, s.Schemas.Count, "Schemas.Count");
}
[Test]
sr, settings);
xtr.Read ();
xtr.MoveToFirstAttribute ();
- AssertEquals (" value ", xtr.Value);
+ Assert.AreEqual (" value ", xtr.Value);
xtr.Read ();
// Text string is normalized
- AssertEquals ("test\nstring", xtr.Value);
+ Assert.AreEqual ("test\nstring", xtr.Value);
}
[Test]
settings.CheckCharacters = false;
xtr.Read ();
xtr.MoveToFirstAttribute ();
- AssertEquals ("\0", xtr.Value);
+ Assert.AreEqual ("\0", xtr.Value);
xtr.Read ();
- AssertEquals ("\0", xtr.Value);
+ Assert.AreEqual ("\0", xtr.Value);
}
// Hmm, does it really make sense? :-/
// But it won't work against XmlNodeReader.
xr.Read ();
xr.MoveToFirstAttribute ();
- AssertEquals ("\0", xr.Value);
+ Assert.AreEqual ("\0", xr.Value);
xr.Read ();
- AssertEquals ("\0", xr.Value);
+ Assert.AreEqual ("\0", xr.Value);
}
[Test]
public void CreateAndSettings ()
{
- AssertNotNull (XmlReader.Create (CreateStream ("<xml/>")).Settings);
- AssertNotNull (XmlReader.Create ("Test/XmlFiles/simple.xml").Settings);
+ Assert.IsNotNull (XmlReader.Create (CreateStream ("<xml/>")).Settings);
+ Assert.IsNotNull (XmlReader.Create ("Test/XmlFiles/simple.xml").Settings);
}
[Test]
r.Read ();
r.Read ();
// not EntityReference but Text
- AssertEquals ("#1", XmlNodeType.Text, r.NodeType);
+ Assert.AreEqual (XmlNodeType.Text, r.NodeType, "#1");
r.Read ();
- AssertEquals ("#2", XmlNodeType.EndElement, r.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#2");
}
public class XmlResolver81000 : XmlResolver
XmlReader r = XmlReader.Create (new StringReader (xml), s);
r.Read ();
r.Read ();
- AssertEquals (String.Empty, r.Value); // should not be at the comment node.
+ Assert.AreEqual (String.Empty, r.Value); // should not be at the comment node.
}
[Test]
public void CreateSetsBaseUri () // bug #392385
{
XmlReader r = XmlReader.Create (new StringReader ("<x/>"), new XmlReaderSettings (), "urn:foo");
- AssertEquals ("urn:foo", r.BaseURI);
+ Assert.AreEqual ("urn:foo", r.BaseURI);
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlSignificantWhitespaceTests : Assertion
+ public class XmlSignificantWhitespaceTests
{
XmlDocument document;
XmlDocument doc2;
public void InnerAndOuterXml ()
{
whitespace = doc2.CreateSignificantWhitespace ("\r\n\t ");
- AssertEquals (String.Empty, whitespace.InnerXml);
- AssertEquals ("\r\n\t ", whitespace.OuterXml);
+ Assert.AreEqual (String.Empty, whitespace.InnerXml);
+ Assert.AreEqual ("\r\n\t ", whitespace.OuterXml);
}
[Test]
{
string val = "\t\t\r\n ";
whitespace = doc2.CreateSignificantWhitespace (val);
- AssertEquals ("#DataValue.1", val, whitespace.Data);
- AssertEquals ("#DataValue.2", val, whitespace.Value);
+ Assert.AreEqual (val, whitespace.Data, "#DataValue.1");
+ Assert.AreEqual (val, whitespace.Value, "#DataValue.2");
whitespace.Value = val + "\t";
- AssertEquals ("#DataValue.3", val + "\t", whitespace.Data);
+ Assert.AreEqual (val + "\t", whitespace.Data, "#DataValue.3");
}
internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
{
// assertequals (original.nodetype + " was incorrectly cloned.",
// original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
- AssertEquals ("Value incorrectly cloned",
- cloned.Value, original.Value);
+ Assert.IsNull (cloned.ParentNode);
+ Assert.AreEqual (cloned.Value, original.Value, "Value incorrectly cloned");
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
[Test]
return;
} catch (Exception) {
- Fail ("Incorrect Exception thrown.");
+ Assert.Fail ("Incorrect Exception thrown.");
}
}
[Test]
public void XmlSignificantWhitespaceConstructor ()
{
- AssertEquals ("whitespace char didn't get copied right",
- "\r\n", whitespace.Data);
+ Assert.AreEqual ("\r\n", whitespace.Data, "whitespace char didn't get copied right");
}
[Test]
public void XmlSignificantWhitespaceName ()
{
- AssertEquals (whitespace.NodeType + " Name property broken",
- whitespace.Name, "#significant-whitespace");
+ Assert.AreEqual (whitespace.Name, "#significant-whitespace", whitespace.NodeType + " Name property broken");
}
[Test]
public void XmlSignificantWhitespaceLocalName ()
{
- AssertEquals (whitespace.NodeType + " LocalName property broken",
- whitespace.LocalName, "#significant-whitespace");
+ Assert.AreEqual (whitespace.LocalName, "#significant-whitespace", whitespace.NodeType + " LocalName property broken");
}
[Test]
public void XmlSignificantWhitespaceNodeType ()
{
- AssertEquals ("XmlSignificantWhitespace NodeType property broken",
- whitespace.NodeType.ToString (), "SignificantWhitespace");
+ Assert.AreEqual (whitespace.NodeType.ToString (), "SignificantWhitespace", "XmlSignificantWhitespace NodeType property broken");
}
[Test]
public void XmlSignificantWhitespaceIsReadOnly ()
{
- AssertEquals ("XmlSignificantWhitespace IsReadOnly property broken",
- whitespace.IsReadOnly, false);
+ Assert.AreEqual (whitespace.IsReadOnly, false, "XmlSignificantWhitespace IsReadOnly property broken");
}
[Test]
deep = whitespace.CloneNode (true); // deep
XmlNodeBaseProperties (original, deep);
- AssertEquals ("deep cloning differs from shallow cloning",
- deep.OuterXml, shallow.OuterXml);
+ Assert.AreEqual (deep.OuterXml, shallow.OuterXml, "deep cloning differs from shallow cloning");
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlTextReaderTests : Assertion
+ public class XmlTextReaderTests
{
private void AssertStartDocument (XmlReader xmlReader)
{
- Assert (xmlReader.ReadState == ReadState.Initial);
- Assert (xmlReader.NodeType == XmlNodeType.None);
- Assert (xmlReader.Depth == 0);
- Assert (!xmlReader.EOF);
+ Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);
+ Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);
+ Assert.IsTrue (xmlReader.Depth == 0);
+ Assert.IsTrue (!xmlReader.EOF);
}
private void AssertNode (
string value,
int attributeCount)
{
- Assert ("#Read", xmlReader.Read ());
- Assert ("#ReadState", xmlReader.ReadState == ReadState.Interactive);
- Assert (!xmlReader.EOF);
+ Assert.IsTrue (xmlReader.Read (), "#Read");
+ Assert.IsTrue (xmlReader.ReadState == ReadState.Interactive, "#ReadState");
+ Assert.IsTrue (!xmlReader.EOF);
AssertNodeValues (xmlReader, nodeType, depth, isEmptyElement, name, prefix, localName, namespaceURI, value, attributeCount);
}
string value,
int attributeCount)
{
- AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
- AssertEquals ("Depth", depth, xmlReader.Depth);
- AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);
+ Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
+ Assert.AreEqual (depth, xmlReader.Depth, "Depth");
+ Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");
- AssertEquals ("name", name, xmlReader.Name);
+ Assert.AreEqual (name, xmlReader.Name, "name");
- AssertEquals ("prefix", prefix, xmlReader.Prefix);
+ Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");
- AssertEquals ("localName", localName, xmlReader.LocalName);
+ Assert.AreEqual (localName, xmlReader.LocalName, "localName");
- AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);
+ Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");
- AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);
+ Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");
- AssertEquals ("Value", value, xmlReader.Value);
+ Assert.AreEqual (value, xmlReader.Value, "Value");
- AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);
+ Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");
- AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
+ Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
}
private void AssertAttribute (
string namespaceURI,
string value)
{
- AssertEquals ("value.Indexer", value, xmlReader [name]);
+ Assert.AreEqual (value, xmlReader [name], "value.Indexer");
- AssertEquals ("value.GetAttribute", value, xmlReader.GetAttribute (name));
+ Assert.AreEqual (value, xmlReader.GetAttribute (name), "value.GetAttribute");
if (namespaceURI != String.Empty) {
- Assert (xmlReader[localName, namespaceURI] == value);
- Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);
+ Assert.IsTrue (xmlReader[localName, namespaceURI] == value);
+ Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);
}
}
private void AssertEndDocument (XmlReader xmlReader)
{
- Assert ("could read", !xmlReader.Read ());
- AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);
- AssertEquals ("Depth is not 0", 0, xmlReader.Depth);
- AssertEquals ("ReadState is not ReadState.EndOfFile", ReadState.EndOfFile, xmlReader.ReadState);
- Assert ("not EOF", xmlReader.EOF);
+ Assert.IsTrue (!xmlReader.Read (), "could read");
+ Assert.AreEqual (XmlNodeType.None, xmlReader.NodeType, "NodeType is not XmlNodeType.None");
+ Assert.AreEqual (0, xmlReader.Depth, "Depth is not 0");
+ Assert.AreEqual (ReadState.EndOfFile, xmlReader.ReadState, "ReadState is not ReadState.EndOfFile");
+ Assert.IsTrue (xmlReader.EOF, "not EOF");
xmlReader.Close ();
- AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);
+ Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");
}
[Test]
caughtXmlException = true;
}
- Assert(caughtXmlException);
+ Assert.IsTrue (caughtXmlException);
}
[Test]
"http://foo/" // value
);
- AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));
+ Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));
AssertEndDocument (xmlReader);
}
[Test]
public void IsName ()
{
- Assert (XmlReader.IsName ("foo"));
- Assert (!XmlReader.IsName ("1foo"));
- Assert (!XmlReader.IsName (" foo"));
+ Assert.IsTrue (XmlReader.IsName ("foo"));
+ Assert.IsTrue (!XmlReader.IsName ("1foo"));
+ Assert.IsTrue (!XmlReader.IsName (" foo"));
}
[Test]
public void IsNameToken ()
{
- Assert (XmlReader.IsNameToken ("foo"));
- Assert (XmlReader.IsNameToken ("1foo"));
- Assert (!XmlReader.IsNameToken (" foo"));
+ Assert.IsTrue (XmlReader.IsNameToken ("foo"));
+ Assert.IsTrue (XmlReader.IsNameToken ("1foo"));
+ Assert.IsTrue (!XmlReader.IsNameToken (" foo"));
}
[Test]
XmlReader xmlReader =
new XmlTextReader (new StringReader (xml));
xmlReader.Read ();
- AssertEquals ("hello & world", xmlReader ["value"]);
+ Assert.AreEqual ("hello & world", xmlReader ["value"]);
}
[Test]
xmlReader.Read ();
xmlReader.MoveToFirstAttribute ();
xmlReader.ReadAttributeValue ();
- AssertEquals ("hello ", xmlReader.Value);
- Assert (xmlReader.ReadAttributeValue ());
- AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
- AssertEquals ("ent", xmlReader.Name);
- AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
- Assert (xmlReader.ReadAttributeValue ());
- AssertEquals (" world", xmlReader.Value);
- AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
- Assert (!xmlReader.ReadAttributeValue ());
- AssertEquals (" world", xmlReader.Value); // remains
- AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
+ Assert.AreEqual ("hello ", xmlReader.Value);
+ Assert.IsTrue (xmlReader.ReadAttributeValue ());
+ Assert.AreEqual (XmlNodeType.EntityReference, xmlReader.NodeType);
+ Assert.AreEqual ("ent", xmlReader.Name);
+ Assert.AreEqual (XmlNodeType.EntityReference, xmlReader.NodeType);
+ Assert.IsTrue (xmlReader.ReadAttributeValue ());
+ Assert.AreEqual (" world", xmlReader.Value);
+ Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
+ Assert.IsTrue (!xmlReader.ReadAttributeValue ());
+ Assert.AreEqual (" world", xmlReader.Value); // remains
+ Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
xmlReader.ReadAttributeValue ();
- AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
+ Assert.AreEqual (XmlNodeType.Text, xmlReader.NodeType);
}
[Test]
new XmlTextReader (new StringReader (xml));
xmlReader.Read ();
xmlReader.MoveToFirstAttribute ();
- AssertEquals ("First", '\'', xmlReader.QuoteChar);
+ Assert.AreEqual ('\'', xmlReader.QuoteChar, "First");
xmlReader.MoveToNextAttribute ();
- AssertEquals ("Next", '"', xmlReader.QuoteChar);
+ Assert.AreEqual ('"', xmlReader.QuoteChar, "Next");
xmlReader.MoveToFirstAttribute ();
- AssertEquals ("First.Again", '\'', xmlReader.QuoteChar);
+ Assert.AreEqual ('\'', xmlReader.QuoteChar, "First.Again");
}
[Test]
// This behavior is different from XmlNodeReader.
XmlReader reader = new XmlTextReader (new StringReader ("<root>test of <b>mixed</b> string.</root>"));
reader.ReadInnerXml ();
- AssertEquals ("initial.ReadState", ReadState.Initial, reader.ReadState);
- AssertEquals ("initial.EOF", false, reader.EOF);
- AssertEquals ("initial.NodeType", XmlNodeType.None, reader.NodeType);
+ Assert.AreEqual (ReadState.Initial, reader.ReadState, "initial.ReadState");
+ Assert.AreEqual (false, reader.EOF, "initial.EOF");
+ Assert.AreEqual (XmlNodeType.None, reader.NodeType, "initial.NodeType");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (xml);
XmlEntity foo = doc.DocumentType.Entities.GetNamedItem ("foo") as XmlEntity;
- AssertNotNull (foo);
- AssertEquals ("foo-def", foo.InnerText);
+ Assert.IsNotNull (foo);
+ Assert.AreEqual ("foo-def", foo.InnerText);
}
[Test]
xtr.Read (); // foo
this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
"foo", String.Empty, String.Empty, 0);
- AssertEquals (6, xtr.ReadBase64 (bytes2, 0, 10));
+ Assert.AreEqual (6, xtr.ReadBase64 (bytes2, 0, 10));
this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
"root", String.Empty, String.Empty, 0);
- Assert (!xtr.Read ());
- AssertEquals (4, bytes2 [0]);
- AssertEquals (14, bytes2 [1]);
- AssertEquals (54, bytes2 [2]);
- AssertEquals (114, bytes2 [3]);
- AssertEquals (134, bytes2 [4]);
- AssertEquals (184, bytes2 [5]);
- AssertEquals (0, bytes2 [6]);
+ Assert.IsTrue (!xtr.Read ());
+ Assert.AreEqual (4, bytes2 [0]);
+ Assert.AreEqual (14, bytes2 [1]);
+ Assert.AreEqual (54, bytes2 [2]);
+ Assert.AreEqual (114, bytes2 [3]);
+ Assert.AreEqual (134, bytes2 [4]);
+ Assert.AreEqual (184, bytes2 [5]);
+ Assert.AreEqual (0, bytes2 [6]);
xtr.Close ();
xtr = new XmlTextReader (base64, XmlNodeType.Document, null);
"foo", String.Empty, String.Empty, 0);
// Read less than 4 (i.e. one Base64 block)
- AssertEquals (1, xtr.ReadBase64 (bytes2, 0, 1));
+ Assert.AreEqual (1, xtr.ReadBase64 (bytes2, 0, 1));
this.AssertNodeValues (xtr, XmlNodeType.Element, 1, false, "foo", String.Empty,
"foo", String.Empty, String.Empty, 0);
- AssertEquals (4, bytes2 [0]);
+ Assert.AreEqual (4, bytes2 [0]);
- AssertEquals (5, xtr.ReadBase64 (bytes2, 0, 10));
+ Assert.AreEqual (5, xtr.ReadBase64 (bytes2, 0, 10));
this.AssertNodeValues (xtr, XmlNodeType.EndElement, 0, false, "root", String.Empty,
"root", String.Empty, String.Empty, 0);
- Assert (!xtr.Read ());
- AssertEquals (14, bytes2 [0]);
- AssertEquals (54, bytes2 [1]);
- AssertEquals (114, bytes2 [2]);
- AssertEquals (134, bytes2 [3]);
- AssertEquals (184, bytes2 [4]);
- AssertEquals (0, bytes2 [5]);
+ Assert.IsTrue (!xtr.Read ());
+ Assert.AreEqual (14, bytes2 [0]);
+ Assert.AreEqual (54, bytes2 [1]);
+ Assert.AreEqual (114, bytes2 [2]);
+ Assert.AreEqual (134, bytes2 [3]);
+ Assert.AreEqual (184, bytes2 [4]);
+ Assert.AreEqual (0, bytes2 [5]);
while (!xtr.EOF)
xtr.Read ();
xtr.Close ();
r.Normalization = true;
s = r.ReadElementString ("hi");
- AssertEquals ("One\ntwo\nthree\nfour", s);
+ Assert.AreEqual ("One\ntwo\nthree\nfour", s);
}
[Test]
xtr.Read ();
xtr.Read ();
xtr.MoveToFirstAttribute ();
- AssertEquals (" value ", xtr.Value);
+ Assert.AreEqual (" value ", xtr.Value);
}
[Test]
XmlTextReader xtr = new XmlTextReader (
new StringReader ("<a></a><b></b>"));
xtr.Close ();
- Assert (!xtr.EOF); // Close() != EOF
+ Assert.IsTrue (!xtr.EOF); // Close() != EOF
}
[Test]
{
XmlTextReader xtr = new XmlTextReader ("Test/XmlFiles/simple.xml");
xtr.Close ();
- Assert (!xtr.EOF); // Close() != EOF
+ Assert.IsTrue (!xtr.EOF); // Close() != EOF
}
[Test]
// See bug #63507
XmlTextReader aux = new XmlTextReader (
new StringReader ("<all><hello></hello><bug></bug></all>"));
- AssertEquals (0, aux.LineNumber);
- AssertEquals (0, aux.LinePosition);
+ Assert.AreEqual (0, aux.LineNumber);
+ Assert.AreEqual (0, aux.LinePosition);
aux.MoveToContent();
- AssertEquals (1, aux.LineNumber);
- AssertEquals (2, aux.LinePosition);
+ Assert.AreEqual (1, aux.LineNumber);
+ Assert.AreEqual (2, aux.LinePosition);
aux.Read();
- AssertEquals (1, aux.LineNumber);
- AssertEquals (7, aux.LinePosition);
+ Assert.AreEqual (1, aux.LineNumber);
+ Assert.AreEqual (7, aux.LinePosition);
aux.ReadOuterXml();
- AssertEquals (1, aux.LineNumber);
- AssertEquals (22, aux.LinePosition);
+ Assert.AreEqual (1, aux.LineNumber);
+ Assert.AreEqual (22, aux.LinePosition);
aux.ReadInnerXml();
- AssertEquals (1, aux.LineNumber);
- AssertEquals (34, aux.LinePosition);
+ Assert.AreEqual (1, aux.LineNumber);
+ Assert.AreEqual (34, aux.LinePosition);
aux.Read();
- AssertEquals (1, aux.LineNumber);
- AssertEquals (38, aux.LinePosition);
+ Assert.AreEqual (1, aux.LineNumber);
+ Assert.AreEqual (38, aux.LinePosition);
aux.Close();
- AssertEquals (0, aux.LineNumber);
- AssertEquals (0, aux.LinePosition);
+ Assert.AreEqual (0, aux.LineNumber);
+ Assert.AreEqual (0, aux.LinePosition);
}
[Test]
XmlValidatingReader xvr = new XmlValidatingReader (xtr);
xvr.Read ();
xvr.MoveToFirstAttribute ();
- AssertEquals (" value string", xvr.Value);
+ Assert.AreEqual (" value string", xvr.Value);
}
[Test]
public void Settings ()
{
XmlTextReader xtr = new XmlTextReader ("<root/>", XmlNodeType.Document, null);
- AssertNull (xtr.Settings);
+ Assert.IsNull (xtr.Settings);
}
// Copied from XmlValidatingReaderTests.cs
dvr.EntityHandling = EntityHandling.ExpandEntities;
dvr.Read (); // DTD
dvr.Read ();
- AssertEquals (XmlNodeType.Element, dvr.NodeType);
- AssertEquals ("root", dvr.Name);
- Assert (dvr.MoveToFirstAttribute ());
- AssertEquals ("foo", dvr.Name);
- AssertEquals ("entity string", dvr.Value);
- Assert (dvr.MoveToNextAttribute ());
- AssertEquals ("bar", dvr.Name);
- AssertEquals ("internal entity string value", dvr.Value);
- AssertEquals ("entity string", dvr.ReadString ());
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
+ Assert.AreEqual ("root", dvr.Name);
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());
+ Assert.AreEqual ("foo", dvr.Name);
+ Assert.AreEqual ("entity string", dvr.Value);
+ Assert.IsTrue (dvr.MoveToNextAttribute ());
+ Assert.AreEqual ("bar", dvr.Name);
+ Assert.AreEqual ("internal entity string value", dvr.Value);
+ Assert.AreEqual ("entity string", dvr.ReadString ());
}
[Test]
dvr.EntityHandling = EntityHandling.ExpandCharEntities;
dvr.Read (); // DTD
dvr.Read ();
- AssertEquals (XmlNodeType.Element, dvr.NodeType);
- AssertEquals ("root", dvr.Name);
- Assert (dvr.MoveToFirstAttribute ());
- AssertEquals ("foo", dvr.Name);
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
+ Assert.AreEqual ("root", dvr.Name);
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());
+ Assert.AreEqual ("foo", dvr.Name);
// MS BUG: it returns "entity string", however, entity should not be exanded.
- AssertEquals ("&ent;", dvr.Value);
+ Assert.AreEqual ("&ent;", dvr.Value);
// ReadAttributeValue()
- Assert (dvr.ReadAttributeValue ());
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
- AssertEquals ("ent", dvr.Name);
- AssertEquals ("", dvr.Value);
- Assert (!dvr.ReadAttributeValue ());
+ Assert.IsTrue (dvr.ReadAttributeValue ());
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual ("ent", dvr.Name);
+ Assert.AreEqual ("", dvr.Value);
+ Assert.IsTrue (!dvr.ReadAttributeValue ());
// bar
- Assert (dvr.MoveToNextAttribute ());
- AssertEquals ("bar", dvr.Name);
- AssertEquals ("internal &ent; value", dvr.Value);
+ Assert.IsTrue (dvr.MoveToNextAttribute ());
+ Assert.AreEqual ("bar", dvr.Name);
+ Assert.AreEqual ("internal &ent; value", dvr.Value);
// ReadAttributeValue()
- Assert (dvr.ReadAttributeValue ());
- AssertEquals (XmlNodeType.Text, dvr.NodeType);
- AssertEquals ("", dvr.Name);
- AssertEquals ("internal ", dvr.Value);
- Assert (dvr.ReadAttributeValue ());
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
- AssertEquals ("ent", dvr.Name);
- AssertEquals ("", dvr.Value);
- Assert (dvr.ReadAttributeValue ());
- AssertEquals (XmlNodeType.Text, dvr.NodeType);
- AssertEquals ("", dvr.Name);
- AssertEquals (" value", dvr.Value);
+ Assert.IsTrue (dvr.ReadAttributeValue ());
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
+ Assert.AreEqual ("", dvr.Name);
+ Assert.AreEqual ("internal ", dvr.Value);
+ Assert.IsTrue (dvr.ReadAttributeValue ());
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual ("ent", dvr.Name);
+ Assert.AreEqual ("", dvr.Value);
+ Assert.IsTrue (dvr.ReadAttributeValue ());
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
+ Assert.AreEqual ("", dvr.Name);
+ Assert.AreEqual (" value", dvr.Value);
}
dvr.Read (); // DTD
dvr.Read (); // root
dvr.Read (); // &ent;
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
- AssertEquals (1, dvr.Depth);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (1, dvr.Depth);
dvr.ResolveEntity ();
// It is still entity reference.
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
dvr.Read ();
- AssertEquals (XmlNodeType.Text, dvr.NodeType);
- AssertEquals (2, dvr.Depth);
- AssertEquals ("entity string", dvr.Value);
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);
+ Assert.AreEqual (2, dvr.Depth);
+ Assert.AreEqual ("entity string", dvr.Value);
dvr.Read ();
- AssertEquals (XmlNodeType.EndEntity, dvr.NodeType);
- AssertEquals (1, dvr.Depth);
- AssertEquals ("", dvr.Value);
+ Assert.AreEqual (XmlNodeType.EndEntity, dvr.NodeType);
+ Assert.AreEqual (1, dvr.Depth);
+ Assert.AreEqual ("", dvr.Value);
dvr.Read (); // &ent2;
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
- AssertEquals (1, dvr.Depth);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (1, dvr.Depth);
dvr.ResolveEntity ();
// It is still entity reference.
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
// It now became element node.
dvr.Read ();
- AssertEquals (XmlNodeType.Element, dvr.NodeType);
- AssertEquals (2, dvr.Depth);
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);
+ Assert.AreEqual (2, dvr.Depth);
}
// mostly copied from XmlValidatingReaderTests.
dvr.Read (); // DTD
dvr.Read (); // root
dvr.Read (); // &ent3;
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
// ent3 does not exists in this dtd.
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);
try {
dvr.ResolveEntity ();
- Fail ("Attempt to resolve undeclared entity should fail.");
+ Assert.Fail ("Attempt to resolve undeclared entity should fail.");
} catch (XmlException) {
}
}
r.Read ();
r.Read ();
r.Read ();
- AssertEquals ("#1", 0xf090, (int) r.Value [0]);
- AssertEquals ("#1", 0x8080, (int) r.Value [1]);
+ Assert.AreEqual (0xf090, (int) r.Value [0], "#1");
+ Assert.AreEqual (0x8080, (int) r.Value [1], "#1");
}
[Test]
int [] arr = new int [line.Length];
for (int i = 0; i < line.Length; i++)
arr [i] = (int) line [i];
- AssertEquals (new int [] {0xd862, 0xddc0}, arr);
+ Assert.AreEqual (new int [] {0xd862, 0xddc0}, arr);
}
[Test]
{
string xml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n<root>\n<node>\nvalue\n</node>\n</root>";
XmlTextReader xr = new XmlTextReader (xml, XmlNodeType.Document, null);
- AssertNull ("#1", xr.Encoding);
+ Assert.IsNull (xr.Encoding, "#1");
xr.Read ();
- AssertEquals ("#2", Encoding.Unicode, xr.Encoding);
+ Assert.AreEqual (Encoding.Unicode, xr.Encoding, "#2");
}
[Test]
xtr.Read (); // root
xtr.Read (); // child. skip whitespaces
- AssertEquals ("#1", XmlNodeType.Element, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
xtr.Read (); // significant whitespaces
- AssertEquals ("#2", XmlNodeType.SignificantWhitespace, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#2");
xtr.Read ();
- AssertEquals ("#3", "descendant", xtr.LocalName);
+ Assert.AreEqual ("descendant", xtr.LocalName, "#3");
xtr.Read (); // end of descendant. skip whitespaces
- AssertEquals ("#4", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#4");
xtr.Read (); // significant whitespaces
- AssertEquals ("#5", XmlNodeType.SignificantWhitespace, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.SignificantWhitespace, xtr.NodeType, "#5");
xtr.Read (); // end of child
xtr.Read (); // child
xtr.Read (); // end of child. skip whitespaces
- AssertEquals ("#6", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
xtr.Read (); // end of root. skip whitespaces
- AssertEquals ("#7", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
}
[Test]
xtr.Read (); // root
xtr.Read (); // child. skip whitespaces
- AssertEquals ("#1", XmlNodeType.Element, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.Element, xtr.NodeType, "#1");
xtr.Read (); // descendant. skip significant whitespaces
- AssertEquals ("#2", "descendant", xtr.LocalName);
+ Assert.AreEqual ("descendant", xtr.LocalName, "#2");
xtr.Read (); // end of descendant. skip whitespaces
- AssertEquals ("#3", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#3");
xtr.Read (); // end of child. skip significant whitespaces
xtr.Read (); // child
xtr.Read (); // end of child. skip whitespaces
- AssertEquals ("#6", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#6");
xtr.Read (); // end of root. skip whitespaces
- AssertEquals ("#7", XmlNodeType.EndElement, xtr.NodeType);
+ Assert.AreEqual (XmlNodeType.EndElement, xtr.NodeType, "#7");
}
[Test]
XmlNodeType.Element,
null);
xtr.Read ();
- AssertEquals ("#1", XmlNodeType.Whitespace, xtr.NodeType);
- AssertEquals ("#2", " ", xtr.Value);
+ Assert.AreEqual (XmlNodeType.Whitespace, xtr.NodeType, "#1");
+ Assert.AreEqual (" ", xtr.Value, "#2");
}
// bug #79683
while (r.Read ())
if (r.NodeType == XmlNodeType.Element)
while ((c = r.ReadChars (buf, 0, buf.Length)) > 0)
- AssertEquals ("at " + n,
- strings [n++],
- new string (buf, 0, c));
- AssertEquals ("total lines", 5, n);
+ Assert.AreEqual (strings [n++], new string (buf, 0, c), "at " + n);
+ Assert.AreEqual (5, n, "total lines");
}
[Test] // bug #81294
string s = "<Verifier id='SimpleIntVerifier'/>";
MemoryStream stream = new MemoryStream (Encoding.UTF8.GetBytes(s));
XmlParserContext ctx = new XmlParserContext (null, null, null, XmlSpace.Default);
- AssertNull ("#1", ctx.NamespaceManager);
- AssertNull ("#2", ctx.NameTable);
+ Assert.IsNull (ctx.NamespaceManager, "#1");
+ Assert.IsNull (ctx.NameTable, "#2");
XmlReader reader = new XmlTextReader (stream, XmlNodeType.Element, ctx);
- AssertNull ("#1", ctx.NamespaceManager);
+ Assert.IsNull (ctx.NamespaceManager, "#1");
reader.Read (); // should not raise NRE.
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlTextTests : Assertion
+ public class XmlTextTests
{
XmlDocument document;
XmlText text;
public void InnerAndOuterXml ()
{
text = document.CreateTextNode ("&<>\"'");
- AssertEquals (String.Empty, text.InnerXml);
- AssertEquals ("&<>\"'", text.OuterXml);
+ Assert.AreEqual (String.Empty, text.InnerXml);
+ Assert.AreEqual ("&<>\"'", text.OuterXml);
}
[Test]
document.NodeRemoved += new XmlNodeChangedEventHandler(EventNodeRemoved);
XmlText t = document.DocumentElement.FirstChild as XmlText;
t.SplitText (5);
- AssertNotNull (t.NextSibling);
- AssertEquals ("test ", t.Value);
- AssertEquals ("text.", t.NextSibling.Value);
- Assert (changed);
- Assert (inserted);
- Assert (!removed);
+ Assert.IsNotNull (t.NextSibling);
+ Assert.AreEqual ("test ", t.Value);
+ Assert.AreEqual ("text.", t.NextSibling.Value);
+ Assert.IsTrue (changed);
+ Assert.IsTrue (inserted);
+ Assert.IsTrue (!removed);
}
}
}
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XmlUrlResolverTests : Assertion\r
+ public class XmlUrlResolverTests\r
{\r
XmlUrlResolver resolver;\r
\r
public void FileUri ()\r
{\r
Uri resolved = resolver.ResolveUri (null, "Test/XmlFiles/xsd/xml.xsd");\r
- AssertEquals ("file", resolved.Scheme);\r
+ Assert.AreEqual ("file", resolved.Scheme);\r
Stream s = resolver.GetEntity (resolved, null, typeof (Stream)) as Stream;\r
}\r
\r
[Category ("NotDotNet")]\r
public void FileUri2 ()\r
{\r
- AssertEquals ("file://usr/local/src", resolver.ResolveUri (new Uri ("file://usr/local/src"), null).ToString ());\r
+ Assert.AreEqual (resolver.ResolveUri (new Uri ("file://usr/local/src"), null).ToString (), "file://usr/local/src");\r
// MS.NET returns the Uri.ToString() as \r
// file://usr/local/src, but it is apparently \r
// incorrect in the context of Unix path.\r
- AssertEquals ("file:///usr/local/src", resolver.ResolveUri (new Uri ("file:///usr/local/src"), null).ToString ());\r
+ Assert.AreEqual (resolver.ResolveUri (new Uri ("file:///usr/local/src"), null).ToString (), "file:///usr/local/src");\r
}\r
\r
[Test]\r
public void HttpUri ()\r
{\r
- AssertEquals ("http://test.xml/", resolver.ResolveUri (null, "http://test.xml").ToString ());\r
+ Assert.AreEqual (resolver.ResolveUri (null, "http://test.xml").ToString (), "http://test.xml/");\r
}\r
\r
[Test]\r
public void HttpUri2 ()\r
{\r
- AssertEquals ("http://go-mono.com/", resolver.ResolveUri (new Uri ("http://go-mono.com"), null).ToString ());\r
+ Assert.AreEqual (resolver.ResolveUri (new Uri ("http://go-mono.com"), null).ToString (), "http://go-mono.com/");\r
}\r
\r
[Test]\r
public void ResolveUriWithNullArgs ()\r
{\r
resolver.ResolveUri (null, null);\r
- Fail ("Should be error (MS.NET throws ArgumentException here).");\r
+ Assert.Fail ("Should be error (MS.NET throws ArgumentException here).");\r
}\r
\r
// [Test] Uncomment if you want to test.\r
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XmlValidatingReaderTests : Assertion\r
+ public class XmlValidatingReaderTests\r
{\r
public XmlValidatingReaderTests ()\r
{\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // invalid element.\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // invalid text\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // invalid child\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // root: invalid end\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // invalid end\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // invalid element\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // valid #PCDATA\r
try {\r
dvr.Read (); // invalid element\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // foo\r
try {\r
dvr.Read (); // invalid end root\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // invalid element bar\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // foo\r
try {\r
dvr.Read (); // invalid element bar\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // foo\r
try {\r
dvr.Read (); // invalid text\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // root\r
try {\r
dvr.Read (); // bar: invalid (undeclared) element\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // missing attributes\r
- Fail ("should be failed."); // MS.NET fails to fail this test.\r
+ Assert.Fail ("should be failed."); // MS.NET fails to fail this test.\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // missing attributes\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // undeclared attribute baz\r
- Fail ("should be failed.");\r
+ Assert.Fail ("should be failed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
{\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
- AssertEquals (2, dvr.AttributeCount);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
+ Assert.AreEqual (2, dvr.AttributeCount);\r
// foo\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("foo-def", dvr ["foo"]);\r
- AssertNotNull (dvr ["bar"]);\r
- AssertEquals ("foo-def", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("foo-def", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("foo-def", dvr ["foo"]);\r
+ Assert.IsNotNull (dvr ["bar"]);\r
+ Assert.AreEqual ("foo-def", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("foo-def", dvr.Value);\r
// bar\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("foo-def", dvr ["foo"]);\r
- AssertNotNull (dvr ["bar"]);\r
- AssertEquals ("bar-def", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("bar-def", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("foo-def", dvr ["foo"]);\r
+ Assert.IsNotNull (dvr ["bar"]);\r
+ Assert.AreEqual ("bar-def", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("bar-def", dvr.Value);\r
}\r
\r
[Test]\r
dvr.EntityHandling = EntityHandling.ExpandEntities;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("entity string", dvr.Value);\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("internal entity string value", dvr.Value);\r
- AssertEquals ("entity string", dvr.ReadString ());\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("entity string", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("internal entity string value", dvr.Value);\r
+ Assert.AreEqual ("entity string", dvr.ReadString ());\r
\r
// ValidationType = None\r
\r
dvr.ValidationType = ValidationType.None;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("entity string", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("entity string", dvr.Value);\r
\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("internal entity string value", dvr.Value);\r
- AssertEquals ("entity string", dvr.ReadString ());\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("internal entity string value", dvr.Value);\r
+ Assert.AreEqual ("entity string", dvr.ReadString ());\r
}\r
\r
[Test]\r
dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
// MS BUG: it returns "entity string", however, entity should not be exanded.\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (!dvr.ReadAttributeValue ());\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (!dvr.ReadAttributeValue ());\r
\r
// bar\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("internal ", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals (" value", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("internal ", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual (" value", dvr.Value);\r
\r
// ValidationType = None\r
\r
dvr.ValidationType = ValidationType.None;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
\r
// foo\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (!dvr.ReadAttributeValue ());\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (!dvr.ReadAttributeValue ());\r
\r
// bar\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("internal ", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals (" value", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("internal ", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual (" value", dvr.Value);\r
}\r
\r
[Test]\r
dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("entity string", dvr.Value);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("entity string", dvr.Value);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (!dvr.ReadAttributeValue ());\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (!dvr.ReadAttributeValue ());\r
\r
// bar\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("internal entity string value", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("internal entity string value", dvr.Value);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("internal ", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals (" value", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("internal ", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual (" value", dvr.Value);\r
\r
// ValidationType = None\r
\r
dvr.ValidationType = ValidationType.None;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
\r
// foo\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("entity string", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("entity string", dvr.Value);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (!dvr.ReadAttributeValue ());\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (!dvr.ReadAttributeValue ());\r
\r
// bar\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("internal entity string value", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("internal entity string value", dvr.Value);\r
// ReadAttributeValue()\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals ("internal ", dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals ("ent", dvr.Name);\r
- AssertEquals (String.Empty, dvr.Value);\r
- Assert (dvr.ReadAttributeValue ());\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (String.Empty, dvr.Name);\r
- AssertEquals (" value", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual ("internal ", dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual ("ent", dvr.Name);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
+ Assert.IsTrue (dvr.ReadAttributeValue ());\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (String.Empty, dvr.Name);\r
+ Assert.AreEqual (" value", dvr.Value);\r
}\r
\r
[Test]\r
dvr.EntityHandling = EntityHandling.ExpandEntities;\r
dvr.Read (); // DTD\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals ("root", dvr.Name);\r
- Assert (dvr.MoveToFirstAttribute ());\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals ("id1", dvr.Value);\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("bar", dvr.Name);\r
- AssertEquals ("nameToken", dvr.Value);\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("baz", dvr.Name);\r
- AssertEquals ("list of name token", dvr.Value);\r
- Assert (dvr.MoveToNextAttribute ());\r
- AssertEquals ("quux", dvr.Name);\r
- AssertEquals (" quuux quuux ", dvr.Value);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual ("root", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual ("id1", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.AreEqual ("nameToken", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("baz", dvr.Name);\r
+ Assert.AreEqual ("list of name token", dvr.Value);\r
+ Assert.IsTrue (dvr.MoveToNextAttribute ());\r
+ Assert.AreEqual ("quux", dvr.Name);\r
+ Assert.AreEqual (" quuux quuux ", dvr.Value);\r
}\r
\r
[Test]\r
dvr.ValidationEventHandler += new ValidationEventHandler (OnInvalidityFound);\r
dvr.ValidationType = ValidationType.DTD;\r
dvr.Read (); // DTD\r
- Assert (dvr.Read ()); // invalid foo\r
- Assert (eventFired);\r
- AssertEquals ("foo", dvr.Name);\r
- Assert (dvr.Read ()); // invalid bar\r
- AssertEquals ("bar", dvr.Name);\r
- Assert (dvr.MoveToFirstAttribute ()); // att\r
- AssertEquals ("att", dvr.Name);\r
- Assert (dvr.Read ()); // invalid end foo\r
- AssertEquals ("foo", dvr.Name);\r
- AssertEquals (XmlNodeType.EndElement, dvr.NodeType);\r
- Assert (!dvr.Read ());\r
+ Assert.IsTrue (dvr.Read ()); // invalid foo\r
+ Assert.IsTrue (eventFired);\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.IsTrue (dvr.Read ()); // invalid bar\r
+ Assert.AreEqual ("bar", dvr.Name);\r
+ Assert.IsTrue (dvr.MoveToFirstAttribute ()); // att\r
+ Assert.AreEqual ("att", dvr.Name);\r
+ Assert.IsTrue (dvr.Read ()); // invalid end foo\r
+ Assert.AreEqual ("foo", dvr.Name);\r
+ Assert.AreEqual (XmlNodeType.EndElement, dvr.NodeType);\r
+ Assert.IsTrue (!dvr.Read ());\r
\r
// When ValidationType is None, event should not be fired,\r
eventFired = false;\r
dvr.ValidationEventHandler += new ValidationEventHandler (OnInvalidityFound);\r
dvr.ValidationType = ValidationType.None;\r
dvr.Read (); // DTD\r
- Assert (dvr.Read ()); // invalid foo\r
- Assert (!eventFired);\r
+ Assert.IsTrue (dvr.Read ()); // invalid foo\r
+ Assert.IsTrue (!eventFired);\r
}\r
\r
private bool eventFired;\r
dvr.Read (); // DTD\r
try {\r
dvr.Read (); // root misses attribute foo\r
- Fail ();\r
+ Assert.Fail ();\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // c[1]\r
try {\r
dvr.Read (); // c[2]\r
- Fail ();\r
+ Assert.Fail ();\r
} catch (XmlSchemaException) {\r
}\r
\r
dvr.Read (); // c[1]\r
try {\r
dvr.Read (); // c[2]\r
- Fail ();\r
+ Assert.Fail ();\r
} catch (XmlSchemaException) {\r
}\r
}\r
dvr.Read (); // DTD\r
dvr.Read (); // root\r
dvr.Read (); // &ent;\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals (1, dvr.Depth);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (1, dvr.Depth);\r
dvr.ResolveEntity ();\r
// It is still entity reference.\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
- AssertEquals (2, dvr.Depth);\r
- AssertEquals ("entity string", dvr.Value);\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
+ Assert.AreEqual (2, dvr.Depth);\r
+ Assert.AreEqual ("entity string", dvr.Value);\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.EndEntity, dvr.NodeType);\r
- AssertEquals (1, dvr.Depth);\r
- AssertEquals (String.Empty, dvr.Value);\r
+ Assert.AreEqual (XmlNodeType.EndEntity, dvr.NodeType);\r
+ Assert.AreEqual (1, dvr.Depth);\r
+ Assert.AreEqual (String.Empty, dvr.Value);\r
\r
dvr.Read (); // &ent2;\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
- AssertEquals (1, dvr.Depth);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (1, dvr.Depth);\r
dvr.ResolveEntity ();\r
// It is still entity reference.\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
// It now became element node.\r
dvr.Read ();\r
- AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
- AssertEquals (2, dvr.Depth);\r
+ Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
+ Assert.AreEqual (2, dvr.Depth);\r
}\r
\r
[Test]\r
dvr.Read (); // DTD\r
dvr.Read (); // root\r
dvr.Read (); // &ent3;\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
#if NET_2_0\r
// under .NET 2.0, an error is raised here.\r
// under .NET 1.1, the error is thrown on the next read.\r
try {\r
dvr.ResolveEntity ();\r
- Fail ("Attempt to resolve undeclared entity should fail.");\r
+ Assert.Fail ("Attempt to resolve undeclared entity should fail.");\r
} catch (XmlException) {\r
}\r
#else\r
// ent3 does not exist in this dtd.\r
dvr.ResolveEntity ();\r
- AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
+ Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
try {\r
dvr.Read ();\r
- Fail ("Attempt to resolve undeclared entity should fail.");\r
+ Assert.Fail ("Attempt to resolve undeclared entity should fail.");\r
} catch (XmlException) {\r
}\r
#endif\r
dvr.Read (); // doctype\r
dvr.Read (); // root\r
dvr.MoveToAttribute (0); // attr\r
- Assert (dvr.ReadAttributeValue ()); // Should read expanded text\r
- AssertEquals (XmlNodeType.Text, dvr.NodeType); // not EntityReference\r
- AssertEquals ("entity string text", dvr.Value);\r
- Assert (!dvr.ReadAttributeValue ());\r
+ Assert.IsTrue (dvr.ReadAttributeValue ()); // Should read expanded text\r
+ Assert.AreEqual (XmlNodeType.Text, dvr.NodeType); // not EntityReference\r
+ Assert.AreEqual ("entity string text", dvr.Value);\r
+ Assert.IsTrue (!dvr.ReadAttributeValue ());\r
}\r
\r
[Test]\r
r.Read ();\r
r.Read ();\r
r.Read ();\r
- AssertEquals (refOut, r.ReadOuterXml ());\r
+ Assert.AreEqual (refOut, r.ReadOuterXml ());\r
}\r
\r
[Test]\r
xvr.Read (); // DTD\r
xvr.Read (); // whitespace\r
xvr.Read ();\r
- AssertEquals ("#1-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#1-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#1-1");\r
+ Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#1-2");\r
\r
- AssertEquals ("#1-a", "urn:baz", xvr.LookupNamespace ("baz"));\r
- Assert ("#1-b", xvr.MoveToAttribute ("baz:dummy"));\r
- AssertEquals ("#1-c", "urn:baz", xvr.NamespaceURI);\r
+ Assert.AreEqual ("urn:baz", xvr.LookupNamespace ("baz"), "#1-a");\r
+ Assert.IsTrue (xvr.MoveToAttribute ("baz:dummy"), "#1-b");\r
+ Assert.AreEqual ("urn:baz", xvr.NamespaceURI, "#1-c");\r
\r
- Assert ("#1-d", xvr.MoveToAttribute ("dummy"));\r
- AssertEquals ("#1-e", String.Empty, xvr.NamespaceURI);\r
+ Assert.IsTrue (xvr.MoveToAttribute ("dummy"), "#1-d");\r
+ Assert.AreEqual (String.Empty, xvr.NamespaceURI, "#1-e");\r
\r
xvr.Read (); // first Y, empty element\r
- AssertEquals ("#2-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#2-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#2-1");\r
+ Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#2-2");\r
xvr.Read (); // second Y, start element\r
- AssertEquals ("#3-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#3-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#3-1");\r
+ Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#3-2");\r
xvr.Read (); // inside normal Y. Check inheritance\r
- AssertEquals ("#4-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#4-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#4-1");\r
+ Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#4-2");\r
xvr.Read (); // second Y, end element\r
- AssertEquals ("#5-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#5-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#5-1");\r
+ Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#5-2");\r
xvr.Read (); // third Y, suppresses default namespaces\r
- AssertEquals ("#6-1", null, xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#6-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#6-1");\r
+ Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#6-2");\r
xvr.Read (); // inside suppressing Y. Check inheritance\r
- AssertEquals ("#7-1", null, xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#7-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#7-1");\r
+ Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#7-2");\r
xvr.Read (); // end of suppressing element\r
- AssertEquals ("#8-1", null, xvr.LookupNamespace (String.Empty));\r
- AssertEquals ("#8-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
+ Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#8-1");\r
+ Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#8-2");\r
}\r
\r
#if NET_2_0\r
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlWhiteSpaceTests : Assertion
+ public class XmlWhiteSpaceTests
{
XmlDocument document;
XmlDocument doc2;
public void InnerAndOuterXml ()
{
whitespace = doc2.CreateWhitespace ("\r\n\t ");
- AssertEquals (String.Empty, whitespace.InnerXml);
- AssertEquals ("\r\n\t ", whitespace.OuterXml);
+ Assert.AreEqual (String.Empty, whitespace.InnerXml);
+ Assert.AreEqual ("\r\n\t ", whitespace.OuterXml);
}
internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
{
// assertequals (original.nodetype + " was incorrectly cloned.",
// original.baseuri, cloned.baseuri);
- AssertNull (cloned.ParentNode);
- AssertEquals ("Value incorrectly cloned",
- cloned.Value, original.Value);
+ Assert.IsNull (cloned.ParentNode);
+ Assert.AreEqual (cloned.Value, original.Value, "Value incorrectly cloned");
- Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
+ Assert.IsTrue (!Object.ReferenceEquals (original, cloned), "Copies, not pointers");
}
[Test]
[Test]
public void XmlWhitespaceConstructor ()
{
- AssertEquals ("whitespace char didn't get copied right",
- "\r\n", whitespace.Data);
+ Assert.AreEqual ("\r\n", whitespace.Data, "whitespace char didn't get copied right");
}
[Test]
public void XmlWhitespaceName ()
{
- AssertEquals (whitespace.NodeType + " Name property broken",
- whitespace.Name, "#whitespace");
+ Assert.AreEqual (whitespace.Name, "#whitespace", whitespace.NodeType + " Name property broken");
}
[Test]
public void XmlWhitespaceLocalName ()
{
- AssertEquals (whitespace.NodeType + " LocalName property broken",
- whitespace.LocalName, "#whitespace");
+ Assert.AreEqual (whitespace.LocalName, "#whitespace", whitespace.NodeType + " LocalName property broken");
}
[Test]
public void XmlWhitespaceNodeType ()
{
- AssertEquals ("XmlWhitespace NodeType property broken",
- whitespace.NodeType.ToString (), "Whitespace");
+ Assert.AreEqual (whitespace.NodeType.ToString (), "Whitespace", "XmlWhitespace NodeType property broken");
}
[Test]
public void XmlWhitespaceIsReadOnly ()
{
- AssertEquals ("XmlWhitespace IsReadOnly property broken",
- whitespace.IsReadOnly, false);
+ Assert.AreEqual (whitespace.IsReadOnly, false, "XmlWhitespace IsReadOnly property broken");
}
[Test]
deep = whitespace.CloneNode (true); // deep
XmlNodeBaseProperties (original, deep);
- AssertEquals ("deep cloning differs from shallow cloning",
- deep.OuterXml, shallow.OuterXml);
+ Assert.AreEqual (deep.OuterXml, shallow.OuterXml, "deep cloning differs from shallow cloning");
}
}
}
namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlWriterSettingsTests : Assertion
+ public class XmlWriterSettingsTests
{
[Test]
public void DefaultValue ()
private void DefaultValue (XmlWriterSettings s)
{
- AssertEquals (true, s.CheckCharacters);
- AssertEquals (false, s.CloseOutput);
- AssertEquals (ConformanceLevel.Document, s.ConformanceLevel);
- AssertEquals (Encoding.UTF8, s.Encoding);
- AssertEquals (false, s.Indent);
- AssertEquals (" ", s.IndentChars);
- AssertEquals (Environment.NewLine, s.NewLineChars);
- AssertEquals (false, s.NewLineOnAttributes);
- AssertEquals (false, s.OmitXmlDeclaration);
+ Assert.AreEqual (true, s.CheckCharacters);
+ Assert.AreEqual (false, s.CloseOutput);
+ Assert.AreEqual (ConformanceLevel.Document, s.ConformanceLevel);
+ Assert.AreEqual (Encoding.UTF8, s.Encoding);
+ Assert.AreEqual (false, s.Indent);
+ Assert.AreEqual (" ", s.IndentChars);
+ Assert.AreEqual (Environment.NewLine, s.NewLineChars);
+ Assert.AreEqual (false, s.NewLineOnAttributes);
+ Assert.AreEqual (false, s.OmitXmlDeclaration);
}
[Test]
w.WriteEndElement ();
w.Close ();
byte [] data = ms.ToArray ();
- Assert (data.Length != 0);
+ Assert.IsTrue (data.Length != 0);
string str = s.Encoding.GetString (data);
- AssertEquals ("<?xml version=\"1.0\" encoding=\"shift_jis\"?><root />", str);
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"shift_jis\"?><root />", str);
// For TextWriter it does not make sense
StringWriter sw = new StringWriter ();
w.WriteStartElement ("root");
w.WriteEndElement ();
w.Close ();
- AssertEquals ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root />", sw.ToString ());
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root />", sw.ToString ());
}
[Test]
XmlWriter w = XmlWriter.Create (sw, s);
w.WriteElementString ("foo", "");
w.Close ();
- AssertEquals ("<foo />", sw.ToString ());
+ Assert.AreEqual ("<foo />", sw.ToString ());
}
[Test]
w.WriteStartDocument ();
w.WriteElementString ("foo", "");
w.Close ();
- AssertEquals ("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo />", sw.ToString ());
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo />", sw.ToString ());
}
[Test]
w.WriteStartDocument ();
w.WriteElementString ("foo", "");
w.Close ();
- AssertEquals ("<foo />", sw.ToString ());
+ Assert.AreEqual ("<foo />", sw.ToString ());
}
[Test]
XmlWriter w = XmlWriter.Create (sw, s);
w.WriteElementString ("foo", "");
w.Close ();
- AssertEquals ("<foo />", sw.ToString ());
+ Assert.AreEqual ("<foo />", sw.ToString ());
}
[Test]
w.WriteEndElement ();
w.WriteEndElement ();
w.Close ();
- AssertEquals (output, sw.ToString ());
+ Assert.AreEqual (output, sw.ToString ());
}
[Test]
w.WriteStartElement ("root");
w.WriteEndElement ();
w.Flush ();
- AssertEquals ("<root />", sb.ToString ());
+ Assert.AreEqual ("<root />", sb.ToString ());
}
[Test]
w.WriteString ("some string");
w.WriteEndElement ();
w.Close ();
- AssertEquals ("#1", "<root a=\"v\" b=\"x\">some string</root>", sw.ToString ());
+ Assert.AreEqual ("<root a=\"v\" b=\"x\">some string</root>", sw.ToString (), "#1");
// mixed content: bug #81770
string expected = "<root>some string<mixed\n a=\"v\"\n b=\"x\">some string</mixed></root>";
w.WriteEndElement ();
w.WriteEndElement ();
w.Close ();
- AssertEquals ("#2", expected, sw.ToString ().Replace ("\r\n", "\n"));
+ Assert.AreEqual (expected, sw.ToString ().Replace ("\r\n", "\n"), "#2");
}
[Test]
doc.Save (xw);
}
// no heading newline.
- AssertEquals ("<root />", sw.ToString ());
+ Assert.AreEqual ("<root />", sw.ToString ());
}
}
}
// using XmlValidatingReader = XmlTextReader;\r
\r
[TestFixture]\r
- public class XsdParticleValidationTests : Assertion\r
+ public class XsdParticleValidationTests\r
{\r
XmlSchema schema;\r
XmlReader xr;\r
namespace MonoTests.System.Xml\r
{\r
[TestFixture]\r
- public class XsdValidatingReaderTests : Assertion\r
+ public class XsdValidatingReaderTests\r
{\r
public XsdValidatingReaderTests ()\r
{\r
{\r
string xml = "<root/>";\r
xvr = PrepareXmlReader (xml);\r
- AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
+ Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);\r
XmlSchema schema = new XmlSchema ();\r
XmlSchemaElement elem = new XmlSchemaElement ();\r
elem.Name = "root";\r
schema.Items.Add (elem);\r
xvr.Schemas.Add (schema);\r
xvr.Read (); // root\r
- AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
+ Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);\r
xvr.Read (); // EOF\r
\r
xml = "<hoge/>";\r
xvr.Schemas.Add (schema);\r
try {\r
xvr.Read ();\r
- Fail ("element mismatch is incorrectly allowed");\r
+ Assert.Fail ("element mismatch is incorrectly allowed");\r
} catch (XmlSchemaException) {\r
}\r
\r
xvr.Schemas.Add (schema);\r
try {\r
xvr.Read ();\r
- Fail ("Element in different namespace is incorrectly allowed.");\r
+ Assert.Fail ("Element in different namespace is incorrectly allowed.");\r
} catch (XmlSchemaException) {\r
}\r
}\r
xvr.Schemas.Add (schema);\r
// Read directly from root.\r
object o = xvr.ReadTypedValue ();\r
- AssertEquals (ReadState.Initial, xvr.ReadState);\r
- AssertNull (o);\r
+ Assert.AreEqual (ReadState.Initial, xvr.ReadState);\r
+ Assert.IsNull (o);\r
\r
xvr.Read (); // element root\r
- AssertEquals (XmlNodeType.Element, xvr.NodeType);\r
- AssertNotNull (xvr.SchemaType);\r
- Assert (xvr.SchemaType is XmlSchemaDatatype);\r
+ Assert.AreEqual (XmlNodeType.Element, xvr.NodeType);\r
+ Assert.IsNotNull (xvr.SchemaType);\r
+ Assert.IsTrue (xvr.SchemaType is XmlSchemaDatatype);\r
o = xvr.ReadTypedValue (); // read "12"\r
- AssertEquals (XmlNodeType.EndElement, xvr.NodeType);\r
- AssertNotNull (o);\r
- AssertEquals (typeof (decimal), o.GetType ());\r
+ Assert.AreEqual (XmlNodeType.EndElement, xvr.NodeType);\r
+ Assert.IsNotNull (o);\r
+ Assert.AreEqual (typeof (decimal), o.GetType ());\r
decimal n = (decimal) o;\r
- AssertEquals (12, n);\r
- Assert (!xvr.EOF);\r
- AssertEquals ("root", xvr.Name);\r
- AssertNull (xvr.SchemaType); // EndElement's type\r
+ Assert.AreEqual (12, n);\r
+ Assert.IsTrue (!xvr.EOF);\r
+ Assert.AreEqual ("root", xvr.Name);\r
+ Assert.IsNull (xvr.SchemaType); // EndElement's type\r
\r
// Lap 2:\r
\r
xvr.Schemas.Add (schema);\r
xvr.Read (); // root\r
XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;\r
- AssertNotNull (dt);\r
- AssertEquals (typeof (decimal), dt.ValueType);\r
- AssertEquals (XmlTokenizedType.None, dt.TokenizedType);\r
+ Assert.IsNotNull (dt);\r
+ Assert.AreEqual (typeof (decimal), dt.ValueType);\r
+ Assert.AreEqual (XmlTokenizedType.None, dt.TokenizedType);\r
xvr.Read (); // text "12"\r
- AssertNull (xvr.SchemaType);\r
+ Assert.IsNull (xvr.SchemaType);\r
o = xvr.ReadTypedValue ();\r
// ReadTypedValue is different from ReadString().\r
- AssertNull (o);\r
+ Assert.IsNull (o);\r
}\r
\r
[Test]\r
string xml = "<x:root xmlns:x='urn:foo' />";\r
xvr = PrepareXmlReader (xml);\r
xvr.Namespaces = false;\r
- AssertEquals (ValidationType.Auto, xvr.ValidationType);\r
+ Assert.AreEqual (ValidationType.Auto, xvr.ValidationType);\r
XmlSchema schema = new XmlSchema ();\r
schema.TargetNamespace = "urn:foo";\r
XmlSchemaElement elem = new XmlSchemaElement ();\r
schema.Items.Add (elem);\r
xvr.Schemas.Add (schema);\r
xvr.Read (); // root\r
- Assert (!xvr.Namespaces);\r
- AssertEquals ("x:root", xvr.Name);\r
+ Assert.IsTrue (!xvr.Namespaces);\r
+ Assert.AreEqual ("x:root", xvr.Name);\r
// LocalName may contain colons.\r
- AssertEquals ("x:root", xvr.LocalName);\r
+ Assert.AreEqual ("x:root", xvr.LocalName);\r
// NamespaceURI is not supplied.\r
- AssertEquals ("", xvr.NamespaceURI);\r
+ Assert.AreEqual ("", xvr.NamespaceURI);\r
}\r
\r
[Test]\r
xvr = PrepareXmlReader (xml);\r
xvr.Schemas.Add (schema);\r
xvr.Read ();\r
- AssertEquals ("root", xvr.Name);\r
- Assert (xvr.MoveToNextAttribute ()); // attr\r
- AssertEquals ("attr", xvr.Name);\r
+ Assert.AreEqual ("root", xvr.Name);\r
+ Assert.IsTrue (xvr.MoveToNextAttribute ()); // attr\r
+ Assert.AreEqual ("attr", xvr.Name);\r
XmlSchemaDatatype dt = xvr.SchemaType as XmlSchemaDatatype;\r
- AssertNotNull (dt);\r
- AssertEquals (typeof (int), dt.ValueType);\r
- AssertEquals (XmlTokenizedType.None, dt.TokenizedType);\r
+ Assert.IsNotNull (dt);\r
+ Assert.AreEqual (typeof (int), dt.ValueType);\r
+ Assert.AreEqual (XmlTokenizedType.None, dt.TokenizedType);\r
object o = xvr.ReadTypedValue ();\r
- AssertEquals (XmlNodeType.Attribute, xvr.NodeType);\r
- AssertEquals (typeof (int), o.GetType ());\r
+ Assert.AreEqual (XmlNodeType.Attribute, xvr.NodeType);\r
+ Assert.AreEqual (typeof (int), o.GetType ());\r
int n = (int) o;\r
- AssertEquals (12, n);\r
- Assert (xvr.ReadAttributeValue ()); // can read = seems not proceed.\r
+ Assert.AreEqual (12, n);\r
+ Assert.IsTrue (xvr.ReadAttributeValue ()); // can read = seems not proceed.\r
}\r
\r
[Test]\r
xml, XmlNodeType.Document, null);\r
vr.Read ();\r
vr.Read (); // whitespace\r
- AssertEquals ("#1", String.Empty, vr.NamespaceURI);\r
+ Assert.AreEqual (String.Empty, vr.NamespaceURI, "#1");\r
vr.Read (); // foo\r
- AssertEquals ("#2", "urn:a", vr.NamespaceURI);\r
+ Assert.AreEqual ("urn:a", vr.NamespaceURI, "#2");\r
vr.Read (); // whitespace\r
vr.Read (); // a:bar\r
- AssertEquals ("#3", "urn:a", vr.NamespaceURI);\r
+ Assert.AreEqual ("urn:a", vr.NamespaceURI, "#3");\r
vr.Read (); // whitespace\r
vr.Read (); // bug\r
- AssertEquals ("#4", "urn:a", vr.NamespaceURI);\r
+ Assert.AreEqual ("urn:a", vr.NamespaceURI, "#4");\r
}\r
\r
[Test]\r
XmlValidatingReader vr = new XmlValidatingReader (xir);\r
vr.Schemas.Add (XmlSchema.Read (xsr, null));\r
vr.Read (); // root\r
- AssertEquals ("xx", vr.ReadTypedValue ());\r
- AssertEquals (XmlNodeType.EndElement, vr.NodeType);\r
+ Assert.AreEqual ("xx", vr.ReadTypedValue ());\r
+ Assert.AreEqual (XmlNodeType.EndElement, vr.NodeType);\r
}\r
\r
// If we normalize string before validating with facets,\r
XmlValidatingReader vr = new XmlValidatingReader (xir);\r
vr.Schemas.Add (XmlSchema.Read (xsr, null));\r
vr.Read (); // root\r
- AssertEquals (" ", vr.ReadTypedValue ());\r
- AssertEquals (XmlNodeType.EndElement, vr.NodeType);\r
+ Assert.AreEqual (" ", vr.ReadTypedValue ());\r
+ Assert.AreEqual (XmlNodeType.EndElement, vr.NodeType);\r
}\r
\r
[Test] // bug #77241\r
XmlReader r = XmlReader.Create (new StringReader (xml), s);\r
r.Read ();\r
r.MoveToFirstAttribute (); // default attribute\r
- AssertEquals (String.Empty, r.Prefix);\r
+ Assert.AreEqual (String.Empty, r.Prefix);\r
}\r
#endif\r
\r
namespace nist_dom.fundamental\r
{
[TestFixture]\r
- public class AttrTest : Assertion//, ITest\r
+ public class AttrTest//, ITest\r
{\r
public static int i = 1;\r
/*\r
results.expected = (expectedValue == null).ToString();
results.actual = (computedValue == null).ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = (expectedValue == null).ToString();
results.actual = (computedValue == null).ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = (expectedValue == null).ToString();
results.actual = (computedValue == null).ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.actual = computedValue;
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
// return results;
}
//------------------------ End test case core-0014A --------------------------
namespace nist_dom.fundamental
{
[TestFixture]
- public class CharacterDataTest : Assertion//,ITest
+ public class CharacterDataTest//,ITest
{
public static int i = 2;
/*
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0001C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0002C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0003C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0004C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0005C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0006C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0007C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0008C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0009C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0010C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0011C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0012C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0013C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0014C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0015C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0016C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0017C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0018C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0019C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0020C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0021C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0022C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0023C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0024C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0025C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0026C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0027C --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0028C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0029C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0030C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0031C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0032C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0033C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0034C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0035C --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0036C --------------------------
/// Summary description for Comment.\r
/// </summary>\r
[TestFixture]\r
- public class CommentTest : Assertion//,ITest\r
+ public class CommentTest//,ITest\r
{\r
public static int i = 1;\r
/*\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0001CO --------------------------\r
/// Summary description for Comment.
/// </summary>
[TestFixture]
- public class DOMImplementationTest : Assertion
+ public class DOMImplementationTest
{
public static int i = 2;
/*
results.expected = expectedValue.ToString();
results.actual = computedValue.ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0001DI --------------------------
//
results.expected = expectedValue.ToString();
results.actual = computedValue.ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0002DI --------------------------
//
results.expected = expectedValue.ToString();
results.actual = computedValue.ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0003DI --------------------------
//
results.expected = expectedValue.ToString();
results.actual = computedValue.ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0004DI --------------------------
//
results.expected = expectedValue.ToString();
results.actual = computedValue.ToString();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0005DI --------------------------
}
namespace nist_dom.fundamental\r
{\r
[TestFixture]\r
- public class DocumentTest : Assertion\r
+ public class DocumentTest\r
{\r
public static int i = 2;\r
/*\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0001D --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0002D --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0003D --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0004D --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0005D --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0006D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0007D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0008D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0009D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0010D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0011D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0012D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0013D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0014D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0015D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0016D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0017D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0018D --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0019D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0020D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0021D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0022D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0023D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0024D -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0025D -------------------------\r
namespace nist_dom.fundamental\r
{\r
[TestFixture]\r
- public class ElementTest : Assertion\r
+ public class ElementTest\r
{\r
public static int i = 2;\r
/*\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
//------------------------ End test case core-0001E --------------------------\r
//\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0002E --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0003E --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0004E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0005E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0006E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0007E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0008E --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0009E --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0010E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0011E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0012E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0013E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0014E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0015E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0016E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0017E --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0018E --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0019E --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0020E --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0021E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0022E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0023E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0024E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0025E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0026E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0027E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0028E --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0029E -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0030E --------------------------\r
namespace nist_dom.fundamental\r
{\r
[TestFixture]\r
- public class NamedNodeMapTest : Assertion\r
+ public class NamedNodeMapTest\r
{\r
public static int i = 2;\r
/*\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0001M --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0002M --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0003M --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0004M --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0005M --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0006M --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0007M --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0008M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0009M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0010M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0011M --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0012M --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0013M --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0014M --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0015M --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0016M --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0017M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0018M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0019M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0020M --------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0021M --------------------------\r
namespace nist_dom.fundamental\r
{\r
[TestFixture]\r
- public class NodeTest : Assertion\r
+ public class NodeTest\r
{\r
public static int i = 2;\r
/*\r
//\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0001NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0002NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0003NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0004NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0005NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0006NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0007NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0008NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0009NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0010NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0011NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0012NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0013NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0014NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0015NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0016NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
//------------------------ End test case core-0017NO --------------------------\r
//\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0018NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0019NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0020NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0021NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0022NO ------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0023NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0024NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0025NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0026NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0027NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0028NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0029NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0030NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0031NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0032NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0033NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0034NO ------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0035NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0036NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0037NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0038NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0039NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0040NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
//------------------------ End test case core-0041NO --------------------------\r
//\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0042NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0043NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0044NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0045NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0046NO ------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0047NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0048NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0049NO --------------------------\r
results.actual = (computedValue == null).ToString();\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0050NO --------------------------\r
results.actual = (computedValue == null).ToString();\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0051NO --------------------------\r
results.expected = expectedValue.ToString();\r
results.actual = computedValue.ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0052NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0053NO --------------------------\r
results.actual = computedValue.ToString();\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0054NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0055NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0056NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0057NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0058NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0059NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0060NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0061NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0062NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0063NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0064NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0065NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0066NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0067NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0068NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0069NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0070NO ------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0071NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0072NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0073NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0074NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0075NO ------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0076NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0077NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0078NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0079NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0080NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0081NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0082NO --------------------------\r
results.actual = (computedValue == null).ToString();\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0083NO --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0084NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0085NO --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0086NO --------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0087NO -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0088NO -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0089NO -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0090NO -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0091NO -------------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0092NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0093NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0094NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0095NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0096NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0097NO -------------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0098NO -----------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0099NO -----------------------\r
\r
util.resetData();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0100NO -----------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0101NO -----------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0102NO -----------------------\r
results.actual = computedValue;\r
\r
util.resetData();\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0103NO -----------------------\r
namespace nist_dom.fundamental\r
{\r
[TestFixture]\r
- public class NodeListTest : Assertion\r
+ public class NodeListTest\r
{\r
public static int i = 2;\r
/*\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0001N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0002N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0003N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0004N --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0005N --------------------------\r
results.expected = (expectedValue == null).ToString();\r
results.actual = (computedValue == null).ToString();\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0006N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0007N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0008N --------------------------\r
results.expected = expectedValue;\r
results.actual = computedValue;\r
\r
- AssertEquals (results.expected, results.actual);\r
+ Assert.AreEqual (results.expected, results.actual);\r
}\r
\r
//------------------------ End test case core-0009N --------------------------\r
namespace nist_dom.fundamental
{
[TestFixture]
- public class TextTest : Assertion
+ public class TextTest
{
public static int i = 2;
/*
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0001T --------------------------
results.expected = expectedValue;
results.actual = computedValue;
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0002 --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0003T --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0004T --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0005T --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0006T --------------------------
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0007T --------------------------
//
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0008T --------------------------
//
util.resetData();
- AssertEquals (results.expected, results.actual);
+ Assert.AreEqual (results.expected, results.actual);
}
//------------------------ End test case core-0009T --------------------------
projects / mono.git / commitdiff