mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
It is not simply replacement because we have to workaround dynamic codegen for Xamarin.iOS. Also there were several tests failing with MS implementation (e.g. for W3C DOM conformance), so we had to disable them. There is one regression that rather needs to be fixed in Reflection.Emit. Also, some WCF tests fail with this implementation. They need to be investigated, reviewed and appropriately fixed.
2355 lines
75 KiB
C#
2355 lines
75 KiB
C#
//
|
|
// System.Xml.XmlTextWriterTests
|
|
//
|
|
// Authors:
|
|
// Kral Ferch <[email protected]>
|
|
// Martin Willemoes Hansen <[email protected]>
|
|
//
|
|
// (C) 2002 Kral Ferch
|
|
// (C) 2003 Martin Willemoes Hansen
|
|
//
|
|
|
|
using System;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.Xml
|
|
{
|
|
[TestFixture]
|
|
public class XmlTextWriterTests
|
|
{
|
|
StringWriter sw;
|
|
XmlTextWriter xtw;
|
|
|
|
[SetUp]
|
|
public void GetReady ()
|
|
{
|
|
sw = new StringWriter ();
|
|
CreateXmlTextWriter ();
|
|
}
|
|
|
|
private void CreateXmlTextWriter ()
|
|
{
|
|
xtw = new XmlTextWriter (sw);
|
|
xtw.QuoteChar = '\'';
|
|
}
|
|
|
|
private string StringWriterText
|
|
{
|
|
get { return sw.GetStringBuilder ().ToString (); }
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesNonNamespaceAttributeBefore ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString("bar", "baz");
|
|
xtw.WriteAttributeString ("xmlns", "abc", null, "http://abc.def");
|
|
Assert.AreEqual ("<foo bar='baz' xmlns:abc='http://abc.def'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesNonNamespaceAttributeAfter ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
|
|
xtw.WriteAttributeString ("xmlns", "abc", null, "http://abc.def");
|
|
xtw.WriteAttributeString("bar", "baz");
|
|
Assert.AreEqual ("<foo xmlns:abc='http://abc.def' bar='baz'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesThreeParamWithNullInNamespaceParam ()
|
|
{
|
|
xtw.WriteAttributeString ("xmlns", null, "http://abc.def");
|
|
Assert.AreEqual ("xmlns='http://abc.def'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeString_XmlNs_Valid ()
|
|
{
|
|
xtw.WriteAttributeString ("xmlns", null, "http://abc.def");
|
|
Assert.AreEqual ("xmlns='http://abc.def'", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("xmlns", "http://www.w3.org/2000/xmlns/", "http://abc.def");
|
|
Assert.AreEqual ("xmlns='http://abc.def'", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString (null, "test", "http://www.w3.org/2000/xmlns/", "http://abc.def");
|
|
Assert.AreEqual ("xmlns:test='http://abc.def'", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("", "test", "http://www.w3.org/2000/xmlns/", "http://abc.def");
|
|
Assert.AreEqual ("xmlns:test='http://abc.def'", StringWriterText, "#4");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("person");
|
|
xtw.WriteAttributeString ("", "test", "http://www.w3.org/2000/xmlns/", "http://abc.def");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<person xmlns:test='http://abc.def' />", StringWriterText, "#5");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteAttributeString_XmlNs_Invalid1 ()
|
|
{
|
|
// The 'xmlns' attribute is bound to the reserved namespace 'http://www.w3.org/2000/xmlns/'
|
|
xtw.WriteAttributeString ("xmlns", "http://somenamespace.com", "http://abc.def");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteAttributeString_XmlNs_Invalid2 ()
|
|
{
|
|
// The 'xmlns' attribute is bound to the reserved namespace 'http://www.w3.org/2000/xmlns/'
|
|
xtw.WriteAttributeString (null, "xmlns", "http://somenamespace.com", "http://abc.def");
|
|
}
|
|
|
|
[Test]
|
|
public void XmlSpace_Valid () // bug #77084
|
|
{
|
|
xtw.WriteAttributeString ("xml", "space", null, "preserve");
|
|
Assert.AreEqual ("xml:space='preserve'", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("xml", "space", "whatever", "default");
|
|
Assert.AreEqual ("xml:space='default'", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("person");
|
|
xtw.WriteAttributeString ("xml", "space", "whatever", "default");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<person xml:space='default' />", StringWriterText, "#3");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeString_XmlPrefix_Valid ()
|
|
{
|
|
xtw.WriteAttributeString ("xml", "something", "whatever", "default");
|
|
Assert.AreEqual ("xml:something='default'", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("xml", "else", null, "whatever");
|
|
Assert.AreEqual ("xml:else='whatever'", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("person");
|
|
xtw.WriteAttributeString ("xml", "something", "whatever", "default");
|
|
xtw.WriteAttributeString ("xml", "else", null, "whatever");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<person xml:something='default' xml:else='whatever' />",
|
|
StringWriterText, "#3");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteAttributeString_XmlSpace_Invalid ()
|
|
{
|
|
// only preserve and default are valid values for xml:space
|
|
xtw.WriteAttributeString ("xml", "space", null, "something");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesThreeParamWithTextInNamespaceParam ()
|
|
{
|
|
xtw.WriteAttributeString ("a", "http://somenamespace.com", "http://abc.def");
|
|
Assert.AreEqual ("d0p1:a='http://abc.def'", StringWriterText, "#1");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void AttributeNamespacesWithNullInNamespaceParam ()
|
|
{
|
|
// you cannot use prefix with an empty namespace
|
|
xtw.WriteAttributeString ("a", "abc", null, "http://abc.def");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesWithTextInNamespaceParam ()
|
|
{
|
|
xtw.WriteAttributeString ("a", "abc", "http://somenamespace.com", "http://abc.def");
|
|
Assert.AreEqual ("a:abc='http://abc.def'", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("", "abc", "http://somenamespace.com", "http://abc.def");
|
|
Assert.AreEqual ("d0p1:abc='http://abc.def'", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString (null, "abc", "http://somenamespace.com", "http://abc.def");
|
|
Assert.AreEqual ("d0p1:abc='http://abc.def'", StringWriterText, "#3");
|
|
}
|
|
|
|
[Test]
|
|
[Ignore ("Due to the (silly) dependency on bug #77088, this test will not be fixed. The test could be rewritten but it depends on the original test author.")]
|
|
public void AutoCreatePrefixes ()
|
|
{
|
|
xtw.WriteStartElement ("root");
|
|
xtw.WriteAttributeString (null, "abc", "http://somenamespace.com", "http://abc.def");
|
|
xtw.WriteAttributeString (null, "def", "http://somenamespace.com", "http://def.ghi");
|
|
xtw.WriteAttributeString (null, "ghi", "http://othernamespace.com", "http://ghi.jkl");
|
|
xtw.WriteEndElement ();
|
|
|
|
Assert.AreEqual ("<root d1p1:abc='http://abc.def' d1p1:def='http://def.ghi' d1p2:ghi='http://ghi.jkl' xmlns:d1p2='http://othernamespace.com' xmlns:d1p1='http://somenamespace.com' />", StringWriterText, "#1");
|
|
}
|
|
|
|
[Test]
|
|
[Ignore ("Due to the (silly) dependency on bug #77088, this test will not be fixed. The test could be rewritten but it depends on the original test author.")]
|
|
public void AutoCreatePrefixes2 ()
|
|
{
|
|
xtw.WriteStartElement ("person");
|
|
xtw.WriteAttributeString (null, "name", "http://somenamespace.com", "Driesen");
|
|
xtw.WriteAttributeString (null, "initials", "http://othernamespace.com", "GD");
|
|
xtw.WriteAttributeString (null, "firstName", "http://somenamespace.com", "Gert");
|
|
xtw.WriteStartElement ("address");
|
|
xtw.WriteAttributeString (null, "street", "http://somenamespace.com", "Campus");
|
|
xtw.WriteAttributeString (null, "number", "http://othernamespace.com", "1");
|
|
xtw.WriteAttributeString (null, "zip", "http://newnamespace.com", "3000");
|
|
xtw.WriteAttributeString (null, "box", "http://othernamespace.com", "a");
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
|
|
Assert.AreEqual (
|
|
"<person" +
|
|
" d1p1:name='Driesen'" +
|
|
" d1p2:initials='GD'" +
|
|
" d1p1:firstName='Gert'" +
|
|
" xmlns:d1p2='http://othernamespace.com'" +
|
|
" xmlns:d1p1='http://somenamespace.com'>" +
|
|
"<address" +
|
|
" d1p1:street='Campus'" +
|
|
" d1p2:number='1'" +
|
|
" d2p1:zip='3000'" +
|
|
" d1p2:box='a'" +
|
|
" xmlns:d2p1='http://newnamespace.com' />" +
|
|
"</person>", StringWriterText, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesXmlnsXmlns ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
// If XmlTextWriter conforms to "Namespaces in XML"
|
|
// when namespaceURI argument is null, then this
|
|
// is not allowed (http://www.w3.org/TR/REC-xml-names/
|
|
// Namespace Constraint: Prefix Declared), but seems
|
|
// like XmlTextWriter just ignores XML namespace
|
|
// constraints when namespaceURI argument is null.
|
|
xtw.WriteAttributeString ("xmlns", "xmlns", null, "http://abc.def");
|
|
//Assert.Fail ("A prefix must not start with \"xml\".");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeNamespacesXmlnsXmlns2 ()
|
|
{
|
|
// It is split from AttributeNamespacesXmlnsXmlns()
|
|
// because depending on XmlWriter it is likely to cause
|
|
// duplicate attribute error (XmlTextWriter is pretty
|
|
// hacky, so it does not raise such errors).
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("", "xmlns", null, "http://abc.def");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeString_EmptyLocalName ()
|
|
{
|
|
xtw.WriteAttributeString ("", "something");
|
|
Assert.AreEqual ("='something'", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("", "", "something");
|
|
Assert.AreEqual ("='something'", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("", "http://somenamespace.com", "something");
|
|
Assert.AreEqual ("d0p1:='something'", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("x", "", "http://somenamespace.com", "something");
|
|
Assert.AreEqual ("x:='something'", StringWriterText, "#4");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString (null, "something");
|
|
Assert.AreEqual ("='something'", StringWriterText, "#5");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString (null, "", "something");
|
|
Assert.AreEqual ("='something'", StringWriterText, "#6");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString (null, "http://somenamespace.com", "something");
|
|
Assert.AreEqual ("d0p1:='something'", StringWriterText, "#7");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteAttributeString ("x", null, "http://somenamespace.com", "something");
|
|
Assert.AreEqual ("x:='something'", StringWriterText, "#8");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStartAttribute_EmptyLocalName ()
|
|
{
|
|
xtw.WriteStartAttribute ("", "");
|
|
Assert.AreEqual ("='", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("", "", "");
|
|
Assert.AreEqual ("='", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("", "", "http://somenamespace.com");
|
|
Assert.AreEqual ("d0p1:='", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("x", "", "http://somenamespace.com");
|
|
Assert.AreEqual ("x:='", StringWriterText, "#4");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("", null);
|
|
Assert.AreEqual ("='", StringWriterText, "#5");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("", null, "");
|
|
Assert.AreEqual ("='", StringWriterText, "#6");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("d0p1:='", StringWriterText, "#7");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartAttribute ("x", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("x:='", StringWriterText, "#8");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeWriteAttributeString ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
|
|
xtw.WriteAttributeString ("foo", "bar");
|
|
Assert.AreEqual ("<foo foo='bar'", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("bar", "");
|
|
Assert.AreEqual ("<foo foo='bar' bar=''", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("baz", null);
|
|
Assert.AreEqual ("<foo foo='bar' bar='' baz=''", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("hoge", "a\nb");
|
|
Assert.AreEqual ("<foo foo='bar' bar='' baz='' hoge='a
b'", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("fuga", " a\t\r\nb\t");
|
|
Assert.AreEqual ("<foo foo='bar' bar='' baz='' hoge='a
b' fuga=' a\t
b\t'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void AttributeWriteAttributeStringNotInsideOpenStartElement ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteString ("bar");
|
|
|
|
xtw.WriteAttributeString ("baz", "quux");
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeWriteAttributeStringWithoutParentElement ()
|
|
{
|
|
xtw.WriteAttributeString ("foo", "bar");
|
|
Assert.AreEqual ("foo='bar'", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("baz", "quux");
|
|
Assert.AreEqual ("foo='bar' baz='quux'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStartElement_EmptyLocalName ()
|
|
{
|
|
xtw.WriteStartElement ("", "");
|
|
Assert.AreEqual ("<", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("", "", "");
|
|
Assert.AreEqual ("<", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("", "", "http://somenamespace.com");
|
|
Assert.AreEqual ("<", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("x", "", "http://somenamespace.com");
|
|
Assert.AreEqual ("<x:", StringWriterText, "#4");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("", null);
|
|
Assert.AreEqual ("<", StringWriterText, "#5");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("", null, "");
|
|
Assert.AreEqual ("<", StringWriterText, "#6");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("<", StringWriterText, "#7");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("x", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("<x:", StringWriterText, "#8");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteElementString_EmptyLocalName ()
|
|
{
|
|
xtw.WriteElementString ("", "");
|
|
Assert.AreEqual ("< />", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString ("", "", "");
|
|
Assert.AreEqual ("< />", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString ("", "http://somenamespace.com", "whatever");
|
|
Assert.AreEqual ("< xmlns='http://somenamespace.com'>whatever</>", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString ("", "http://somenamespace.com", "");
|
|
Assert.AreEqual ("< xmlns='http://somenamespace.com' />", StringWriterText, "#4");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString (null, null);
|
|
Assert.AreEqual ("< />", StringWriterText, "#5");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString (null, null, null);
|
|
Assert.AreEqual ("< />", StringWriterText, "#6");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString (null, "http://somenamespace.com", "whatever");
|
|
Assert.AreEqual ("< xmlns='http://somenamespace.com'>whatever</>", StringWriterText, "#7");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteElementString (null, "http://somenamespace.com", null);
|
|
Assert.AreEqual ("< xmlns='http://somenamespace.com' />", StringWriterText, "#8");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStartElement_Prefix_EmptyNamespace ()
|
|
{
|
|
xtw.WriteStartElement ("x", "whatever", "");
|
|
Assert.AreEqual ("<whatever", StringWriterText, "#1");
|
|
|
|
xtw.WriteEndElement ();
|
|
|
|
Assert.AreEqual ("<whatever />", StringWriterText, "#2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteStartElement_Prefix_NullNamespace ()
|
|
{
|
|
xtw.WriteStartElement ("x", "whatever", null);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStartElement_XmlPrefix ()
|
|
{
|
|
xtw.WriteStartElement ("xml", "something", "http://www.w3.org/XML/1998/namespace");
|
|
Assert.AreEqual ("<xml:something", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("XmL", null, "http://www.w3.org/XML/1998/namespace");
|
|
Assert.AreEqual ("<XmL:", StringWriterText, "#2");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("xmlsomething", "name", "http://www.w3.org/XML/1998/namespace");
|
|
Assert.AreEqual ("<xmlsomething:name", StringWriterText, "#3");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteStartElement_XmlPrefix_Invalid1 ()
|
|
{
|
|
xtw.WriteStartElement ("xml", null, "http://somenamespace.com");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteStartElement_XmlPrefix_Invalid2 ()
|
|
{
|
|
xtw.WriteStartElement ("XmL", null, "http://somenamespace.com");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStartElement_XmlPrefix_Invalid3 ()
|
|
{
|
|
// from XML 1.0 (third edition) specification:
|
|
//
|
|
// [Definition: A Name is a token beginning with a letter or one of a
|
|
// few punctuation characters, and continuing with letters, digits,
|
|
// hyphens, underscores, colons, or full stops, together known as name
|
|
// characters.] Names beginning with the string "xml", or with any string
|
|
// which would match (('X'|'x') ('M'|'m') ('L'|'l')), are reserved for
|
|
// standardization in this or future versions of this specification.
|
|
//
|
|
// from the Namespaces in XML 1.0 specification:
|
|
//
|
|
// Prefixes beginning with the three-letter sequence x, m, l, in any case
|
|
// combination, are reserved for use by XML and XML-related specifications.
|
|
//
|
|
// should this prefix then not be considered invalid ?
|
|
//
|
|
// both Mono and MS.NET 1.x/2.0 accept it though
|
|
|
|
xtw.WriteStartElement ("xmlsomething", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("<xmlsomething:", StringWriterText, "#1");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
CreateXmlTextWriter ();
|
|
|
|
xtw.WriteStartElement ("XmLsomething", null, "http://somenamespace.com");
|
|
Assert.AreEqual ("<XmLsomething:", StringWriterText, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void CDataValid ()
|
|
{
|
|
xtw.WriteCData ("foo");
|
|
Assert.AreEqual ("<![CDATA[foo]]>", StringWriterText, "WriteCData had incorrect output.");
|
|
}
|
|
|
|
[Test]
|
|
public void CDataNull ()
|
|
{
|
|
xtw.WriteCData (null);
|
|
Assert.AreEqual ("<![CDATA[]]>", StringWriterText, "WriteCData had incorrect output.");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void CDataInvalid ()
|
|
{
|
|
xtw.WriteCData("foo]]>bar");
|
|
}
|
|
|
|
[Test]
|
|
public void CloseOpenElements ()
|
|
{
|
|
xtw.WriteStartElement("foo");
|
|
xtw.WriteStartElement("bar");
|
|
xtw.WriteStartElement("baz");
|
|
xtw.Close();
|
|
Assert.AreEqual ("<foo><bar><baz /></bar></foo>", StringWriterText,
|
|
"Close didn't write out end elements properly.");
|
|
}
|
|
|
|
[Test]
|
|
public void CloseWriteAfter ()
|
|
{
|
|
xtw.WriteElementString ("foo", "bar");
|
|
xtw.Close ();
|
|
|
|
// WriteEndElement and WriteStartDocument aren't tested here because
|
|
// they will always throw different exceptions besides 'The Writer is closed.'
|
|
// and there are already tests for those exceptions.
|
|
|
|
try {
|
|
xtw.WriteCData ("foo");
|
|
Assert.Fail ("WriteCData after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Don't rely on English message assertion.
|
|
// It is enough to check an exception occurs.
|
|
// Assert.AreEqual ("The Writer is closed.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
|
|
try {
|
|
xtw.WriteComment ("foo");
|
|
Assert.Fail ("WriteComment after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Assert.AreEqual ("The Writer is closed.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
|
|
try {
|
|
xtw.WriteProcessingInstruction ("foo", "bar");
|
|
Assert.Fail ("WriteProcessingInstruction after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Assert.AreEqual ("The Writer is closed.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
|
|
try {
|
|
xtw.WriteStartElement ("foo", "bar", "baz");
|
|
Assert.Fail ("WriteStartElement after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Assert.AreEqual ("The Writer is closed.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
|
|
try {
|
|
xtw.WriteAttributeString ("foo", "bar");
|
|
Assert.Fail ("WriteAttributeString after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
|
|
}
|
|
|
|
try {
|
|
xtw.WriteString ("foo");
|
|
Assert.Fail ("WriteString after Close Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Assert.AreEqual ("The Writer is closed.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CommentValid ()
|
|
{
|
|
xtw.WriteComment ("foo");
|
|
Assert.AreEqual ("<!--foo-->", StringWriterText, "WriteComment had incorrect output.");
|
|
}
|
|
|
|
[Test]
|
|
public void CommentInvalid ()
|
|
{
|
|
try {
|
|
xtw.WriteComment("foo-");
|
|
Assert.Fail("Should have thrown an ArgumentException.");
|
|
} catch (ArgumentException) { }
|
|
|
|
try {
|
|
xtw.WriteComment("foo-->bar");
|
|
Assert.Fail("Should have thrown an ArgumentException.");
|
|
} catch (ArgumentException) { }
|
|
}
|
|
|
|
[Test]
|
|
public void ConstructorsAndBaseStream ()
|
|
{
|
|
Assert.IsTrue (Object.ReferenceEquals (null, this.xtw.BaseStream), "BaseStream property returned wrong value.");
|
|
|
|
MemoryStream ms;
|
|
StreamReader sr;
|
|
XmlTextWriter xtw;
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, new UnicodeEncoding ());
|
|
xtw.WriteStartDocument ();
|
|
xtw.Flush ();
|
|
ms.Seek (0, SeekOrigin.Begin);
|
|
sr = new StreamReader (ms, Encoding.Unicode);
|
|
string expectedXmlDeclaration = "<?xml version=\"1.0\" encoding=\"utf-16\"?>";
|
|
string actualXmlDeclaration = sr.ReadToEnd();
|
|
Assert.AreEqual (expectedXmlDeclaration, actualXmlDeclaration);
|
|
Assert.IsTrue (Object.ReferenceEquals (ms, xtw.BaseStream), "BaseStream property returned wrong value.");
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, new UnicodeEncoding ());
|
|
xtw.WriteStartDocument (true);
|
|
xtw.Flush ();
|
|
ms.Seek (0, SeekOrigin.Begin);
|
|
sr = new StreamReader (ms, Encoding.Unicode);
|
|
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>", sr.ReadToEnd ());
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, new UTF8Encoding ());
|
|
xtw.WriteStartDocument ();
|
|
xtw.Flush ();
|
|
ms.Seek (0, SeekOrigin.Begin);
|
|
sr = new StreamReader (ms, Encoding.UTF8);
|
|
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-8\"?>", sr.ReadToEnd ());
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, null);
|
|
xtw.WriteStartDocument ();
|
|
xtw.Flush ();
|
|
ms.Seek (0, SeekOrigin.Begin);
|
|
sr = new StreamReader (ms, Encoding.UTF8);
|
|
Assert.AreEqual ("<?xml version=\"1.0\"?>", sr.ReadToEnd ());
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, null);
|
|
xtw.WriteStartDocument (true);
|
|
xtw.Flush ();
|
|
ms.Seek (0, SeekOrigin.Begin);
|
|
sr = new StreamReader (ms, Encoding.UTF8);
|
|
Assert.AreEqual ("<?xml version=\"1.0\" standalone=\"yes\"?>", sr.ReadToEnd ());
|
|
Assert.IsTrue (Object.ReferenceEquals (ms, xtw.BaseStream), "BaseStream property returned wrong value.");
|
|
}
|
|
|
|
[Test]
|
|
public void DocumentStart ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?>", StringWriterText,
|
|
"XmlDeclaration is incorrect.");
|
|
|
|
try {
|
|
xtw.WriteStartDocument ();
|
|
Assert.Fail("Should have thrown an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {
|
|
// Don't rely on English message assertion.
|
|
// It is enough to check an exception occurs.
|
|
// Assert.AreEqual ("WriteStartDocument should be the first call.", e.Message, "Exception message is incorrect.");
|
|
}
|
|
|
|
xtw = new XmlTextWriter (sw = new StringWriter ());
|
|
xtw.QuoteChar = '\'';
|
|
xtw.WriteStartDocument (true);
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16' standalone='yes'?>", StringWriterText);
|
|
|
|
xtw = new XmlTextWriter (sw = new StringWriter ());
|
|
xtw.QuoteChar = '\'';
|
|
xtw.WriteStartDocument (false);
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16' standalone='no'?>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void ElementAndAttributeSameXmlns ()
|
|
{
|
|
xtw.WriteStartElement ("ped", "foo", "urn:foo");
|
|
xtw.WriteStartAttribute ("ped", "foo", "urn:foo");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<ped:foo ped:foo='' xmlns:ped='urn:foo' />", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotDotNet")]
|
|
public void ElementXmlnsNeedEscape ()
|
|
{
|
|
xtw.WriteStartElement ("test", "foo", "'");
|
|
xtw.WriteEndElement ();
|
|
// MS.NET output is : xmlns:test='''
|
|
Assert.AreEqual ("<test:foo xmlns:test=''' />", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void ElementEmpty ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<foo />", StringWriterText, "Incorrect output.");
|
|
}
|
|
|
|
[Test]
|
|
public void ElementWriteElementString ()
|
|
{
|
|
xtw.WriteElementString ("foo", "bar");
|
|
Assert.AreEqual ("<foo>bar</foo>", StringWriterText, "WriteElementString has incorrect output.");
|
|
|
|
xtw.WriteElementString ("baz", "");
|
|
Assert.AreEqual ("<foo>bar</foo><baz />", StringWriterText, "#2");
|
|
|
|
xtw.WriteElementString ("quux", null);
|
|
Assert.AreEqual ("<foo>bar</foo><baz /><quux />", StringWriterText, "#3");
|
|
|
|
xtw.WriteElementString ("", "quuux");
|
|
Assert.AreEqual ("<foo>bar</foo><baz /><quux /><>quuux</>", StringWriterText, "#4");
|
|
|
|
xtw.WriteElementString (null, "quuuux");
|
|
Assert.AreEqual ("<foo>bar</foo><baz /><quux /><>quuux</><>quuuux</>", StringWriterText, "#5");
|
|
}
|
|
|
|
[Test]
|
|
public void FormattingTest ()
|
|
{
|
|
xtw.Formatting = Formatting.Indented;
|
|
xtw.WriteStartDocument ();
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteElementString ("bar", "");
|
|
xtw.Close ();
|
|
Assert.AreEqual (String.Format ("<?xml version='1.0' encoding='utf-16'?>{0}<foo>{0} <bar />{0}</foo>", Environment.NewLine), StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void FormattingInvalidXmlForFun ()
|
|
{
|
|
xtw.Formatting = Formatting.Indented;
|
|
xtw.IndentChar = 'x';
|
|
xtw.WriteStartDocument ();
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteStartElement ("bar");
|
|
xtw.WriteElementString ("baz", "");
|
|
xtw.Close ();
|
|
Assert.AreEqual (String.Format ("<?xml version='1.0' encoding='utf-16'?>{0}<foo>{0}xx<bar>{0}xxxx<baz />{0}xx</bar>{0}</foo>", Environment.NewLine), StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void FormattingFromRemarks ()
|
|
{
|
|
// Remarks section of on-line help for XmlTextWriter.Formatting suggests this test.
|
|
xtw.Formatting = Formatting.Indented;
|
|
xtw.WriteStartElement ("ol");
|
|
xtw.WriteStartElement ("li");
|
|
xtw.WriteString ("The big "); // This means "li" now has a mixed content model.
|
|
xtw.WriteElementString ("b", "E");
|
|
xtw.WriteElementString ("i", "lephant");
|
|
xtw.WriteString (" walks slowly.");
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual (String.Format ("<ol>{0} <li>The big <b>E</b><i>lephant</i> walks slowly.</li>{0}</ol>", Environment.NewLine), StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void LookupPrefix ()
|
|
{
|
|
xtw.WriteStartElement ("root");
|
|
|
|
xtw.WriteStartElement ("one");
|
|
xtw.WriteAttributeString ("xmlns", "foo", null, "http://abc.def");
|
|
xtw.WriteAttributeString ("xmlns", "bar", null, "http://ghi.jkl");
|
|
Assert.AreEqual ("foo", xtw.LookupPrefix ("http://abc.def"), "#1");
|
|
Assert.AreEqual ("bar", xtw.LookupPrefix ("http://ghi.jkl"), "#2");
|
|
xtw.WriteEndElement ();
|
|
|
|
xtw.WriteStartElement ("two");
|
|
xtw.WriteAttributeString ("xmlns", "baz", null, "http://mno.pqr");
|
|
xtw.WriteString("quux");
|
|
Assert.AreEqual ("baz", xtw.LookupPrefix ("http://mno.pqr"), "#3");
|
|
Assert.IsNull (xtw.LookupPrefix ("http://abc.def"), "#4");
|
|
Assert.IsNull (xtw.LookupPrefix ("http://ghi.jkl"), "#5");
|
|
|
|
Assert.IsNull (xtw.LookupPrefix ("http://bogus"), "#6");
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesAttributesPassingInNamespaces ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo");
|
|
|
|
// These shouldn't throw any exceptions since they don't pass in
|
|
// a namespace.
|
|
xtw.WriteAttributeString ("bar", "baz");
|
|
xtw.WriteAttributeString ("", "a", "", "b");
|
|
xtw.WriteAttributeString (null, "c", "", "d");
|
|
xtw.WriteAttributeString ("", "e", null, "f");
|
|
xtw.WriteAttributeString (null, "g", null, "h");
|
|
|
|
Assert.AreEqual ("<foo bar='baz' a='b' c='d' e='f' g='h'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesElementsPassingInNamespaces ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
|
|
// These shouldn't throw any exceptions since they don't pass in
|
|
// a namespace.
|
|
xtw.WriteElementString ("foo", "bar");
|
|
xtw.WriteStartElement ("baz");
|
|
xtw.WriteStartElement ("quux", "");
|
|
xtw.WriteStartElement ("quuux", null);
|
|
xtw.WriteStartElement (null, "a", null);
|
|
xtw.WriteStartElement (null, "b", "");
|
|
xtw.WriteStartElement ("", "c", null);
|
|
xtw.WriteStartElement ("", "d", "");
|
|
|
|
Assert.AreEqual ("<foo>bar</foo><baz><quux><quuux><a><b><c><d", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid1 ()
|
|
{
|
|
// These should throw ArgumentException because they pass in a
|
|
// namespace when Namespaces = false.
|
|
xtw.Namespaces = false;
|
|
xtw.WriteElementString ("qux", "http://netsack.com/", String.Empty);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid2 ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo", "http://netsack.com/");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid3 ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo", "bar", "http://netsack.com/");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid4 ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo", "bar", null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid5 ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo", "bar", "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesElementsPassingInNamespacesInvalid6 ()
|
|
{
|
|
xtw.Namespaces = false;
|
|
xtw.WriteStartElement ("foo", "", "");
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesNoNamespaceClearsDefaultNamespace ()
|
|
{
|
|
xtw.WriteStartElement(String.Empty, "foo", "http://netsack.com/");
|
|
xtw.WriteStartElement(String.Empty, "bar", String.Empty);
|
|
xtw.WriteElementString("baz", String.Empty, String.Empty);
|
|
xtw.WriteEndElement();
|
|
xtw.WriteEndElement();
|
|
Assert.AreEqual ("<foo xmlns='http://netsack.com/'><bar xmlns=''><baz /></bar></foo>",
|
|
StringWriterText, "XmlTextWriter is incorrectly outputting namespaces.");
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesPrefix ()
|
|
{
|
|
xtw.WriteStartElement ("foo", "bar", "http://netsack.com/");
|
|
xtw.WriteStartElement ("foo", "baz", "http://netsack.com/");
|
|
xtw.WriteElementString ("qux", "http://netsack.com/", String.Empty);
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<foo:bar xmlns:foo='http://netsack.com/'><foo:baz><foo:qux /></foo:baz></foo:bar>",
|
|
StringWriterText, "XmlTextWriter is incorrectly outputting prefixes.");
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesPrefixWithEmptyAndNullNamespaceEmpty ()
|
|
{
|
|
xtw.WriteStartElement ("foo", "bar", "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void NamespacesPrefixWithEmptyAndNullNamespaceNull ()
|
|
{
|
|
xtw.WriteStartElement ("foo", "bar", null);
|
|
}
|
|
|
|
[Test]
|
|
public void NamespacesSettingWhenWriteStateNotStart ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
try {
|
|
xtw.Namespaces = false;
|
|
Assert.Fail ("Expected an InvalidOperationException.");
|
|
} catch (InvalidOperationException) {}
|
|
Assert.IsTrue (xtw.Namespaces);
|
|
}
|
|
|
|
[Test]
|
|
public void ProcessingInstructionValid ()
|
|
{
|
|
xtw.WriteProcessingInstruction("foo", "bar");
|
|
Assert.AreEqual ("<?foo bar?>", StringWriterText, "WriteProcessingInstruction had incorrect output.");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void ProcessingInstructionInvalid1 ()
|
|
{
|
|
xtw.WriteProcessingInstruction("fo?>o", "bar");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void ProcessingInstructionInvalid2 ()
|
|
{
|
|
xtw.WriteProcessingInstruction("foo", "ba?>r");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void ProcessingInstructionInvalid3 ()
|
|
{
|
|
xtw.WriteProcessingInstruction("", "bar");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void ProcessingInstructionInvalid4 ()
|
|
{
|
|
xtw.WriteProcessingInstruction(null, "bar");
|
|
}
|
|
|
|
[Test]
|
|
public void QuoteCharDoubleQuote ()
|
|
{
|
|
xtw.QuoteChar = '"';
|
|
|
|
// version, encoding, standalone
|
|
xtw.WriteStartDocument (true);
|
|
|
|
// namespace declaration
|
|
xtw.WriteElementString ("foo", "http://netsack.com", "bar");
|
|
|
|
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?><foo xmlns=\"http://netsack.com\">bar</foo>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void QuoteCharInvalid ()
|
|
{
|
|
xtw.QuoteChar = 'x';
|
|
}
|
|
|
|
[Test]
|
|
public void WriteBase64 ()
|
|
{
|
|
UTF8Encoding encoding = new UTF8Encoding();
|
|
byte[] fooBar = encoding.GetBytes("foobar");
|
|
xtw.WriteBase64 (fooBar, 0, 6);
|
|
Assert.AreEqual ("Zm9vYmFy", StringWriterText);
|
|
|
|
try {
|
|
xtw.WriteBase64 (fooBar, 3, 6);
|
|
Assert.Fail ("Expected an Argument Exception to be thrown.");
|
|
} catch (ArgumentException) {}
|
|
|
|
try {
|
|
xtw.WriteBase64 (fooBar, -1, 6);
|
|
Assert.Fail ("Expected an Argument Exception to be thrown.");
|
|
} catch (ArgumentOutOfRangeException) {}
|
|
|
|
try {
|
|
xtw.WriteBase64 (fooBar, 3, -1);
|
|
Assert.Fail ("Expected an Argument Exception to be thrown.");
|
|
} catch (ArgumentOutOfRangeException) {}
|
|
|
|
try {
|
|
xtw.WriteBase64 (null, 0, 6);
|
|
Assert.Fail ("Expected an Argument Exception to be thrown.");
|
|
} catch (ArgumentNullException) {}
|
|
}
|
|
|
|
[Test]
|
|
public void WriteBinHex ()
|
|
{
|
|
byte [] bytes = new byte [] {4,14,34, 54,94,114, 134,194,255, 0,5};
|
|
xtw.WriteBinHex (bytes, 0, 11);
|
|
Assert.AreEqual ("040E22365E7286C2FF0005", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteCharEntity ()
|
|
{
|
|
xtw.WriteCharEntity ('a');
|
|
Assert.AreEqual ("a", StringWriterText);
|
|
|
|
xtw.WriteCharEntity ('A');
|
|
Assert.AreEqual ("aA", StringWriterText);
|
|
|
|
xtw.WriteCharEntity ('1');
|
|
Assert.AreEqual ("aA1", StringWriterText);
|
|
|
|
xtw.WriteCharEntity ('K');
|
|
Assert.AreEqual ("aA1K", StringWriterText);
|
|
|
|
try {
|
|
xtw.WriteCharEntity ((char)0xd800);
|
|
} catch (ArgumentException) {}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void WriteEndAttribute ()
|
|
{
|
|
xtw.WriteEndAttribute ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteEndDocument ()
|
|
{
|
|
try {
|
|
xtw.WriteEndDocument ();
|
|
Assert.Fail ("Expected an Exception.");
|
|
// in .NET 2.0 it is InvalidOperationException.
|
|
// in .NET 1,1 it is ArgumentException.
|
|
} catch (Exception) {}
|
|
}
|
|
|
|
[Test]
|
|
public void WriteEndDocument2 ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
try
|
|
{
|
|
xtw.WriteEndDocument ();
|
|
Assert.Fail ("Expected an Exception.");
|
|
// in .NET 2.0 it is InvalidOperationException.
|
|
// in .NET 1,1 it is ArgumentException.
|
|
} catch (Exception) {}
|
|
}
|
|
|
|
[Test]
|
|
public void WriteEndDocument3 ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteStartAttribute ("bar", null);
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo bar='", StringWriterText);
|
|
|
|
xtw.WriteEndDocument ();
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo bar='' />", StringWriterText);
|
|
Assert.AreEqual (WriteState.Start, xtw.WriteState);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void WriteEndElement ()
|
|
{
|
|
// no matching StartElement
|
|
xtw.WriteEndElement ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteEndElement2 ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<foo />", StringWriterText);
|
|
|
|
xtw.WriteStartElement ("bar");
|
|
xtw.WriteStartAttribute ("baz", null);
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<foo /><bar baz='' />", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void FullEndElement ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteFullEndElement ();
|
|
Assert.AreEqual ("<foo></foo>", StringWriterText);
|
|
|
|
xtw.WriteStartElement ("bar");
|
|
xtw.WriteAttributeString ("foo", "bar");
|
|
xtw.WriteFullEndElement ();
|
|
Assert.AreEqual ("<foo></foo><bar foo='bar'></bar>", StringWriterText);
|
|
|
|
xtw.WriteStartElement ("baz");
|
|
xtw.WriteStartAttribute ("bar", null);
|
|
xtw.WriteFullEndElement ();
|
|
Assert.AreEqual ("<foo></foo><bar foo='bar'></bar><baz bar=''></baz>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteQualifiedName ()
|
|
{
|
|
xtw.WriteStartElement (null, "test", null);
|
|
xtw.WriteAttributeString ("xmlns", "me", null, "http://localhost/");
|
|
xtw.WriteQualifiedName ("bob", "http://localhost/");
|
|
xtw.WriteEndElement ();
|
|
|
|
Assert.AreEqual ("<test xmlns:me='http://localhost/'>me:bob</test>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteQualifiedNameNonDeclaredAttribute ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteStartAttribute ("a", "");
|
|
xtw.WriteQualifiedName ("attr", "urn:a");
|
|
xtw.WriteWhitespace (" ");
|
|
xtw.WriteQualifiedName ("attr", "urn:b");
|
|
xtw.WriteEndAttribute ();
|
|
xtw.WriteEndElement ();
|
|
string xml = sw.ToString ();
|
|
Assert.IsTrue (xml.IndexOf ("<foo ") >= 0, "foo");
|
|
Assert.IsTrue (xml.IndexOf ("a='d1p1:attr d1p2:attr'") > 0, "qnames");
|
|
Assert.IsTrue (xml.IndexOf (" xmlns:d1p1='urn:a'") > 0, "xmlns:a");
|
|
Assert.IsTrue (xml.IndexOf (" xmlns:d1p2='urn:b'") > 0, "xmlns:b");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteQualifiedNameNonNamespacedName ()
|
|
{
|
|
xtw.WriteStartElement ("root");
|
|
xtw.WriteQualifiedName ("foo", "");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<root>foo</root>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteQualifiedNameNonDeclaredContent ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteQualifiedName ("abc", "urn:abc");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteQualifiedNameNonNCName ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xmlns", "urn:default");
|
|
xtw.WriteStartElement ("child");
|
|
xtw.WriteStartAttribute ("a", "");
|
|
xtw.WriteQualifiedName ("x:def", "urn:def");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteRaw ()
|
|
{
|
|
xtw.WriteRaw("&<>\"'");
|
|
Assert.AreEqual ("&<>\"'", StringWriterText);
|
|
|
|
xtw.WriteRaw(null);
|
|
Assert.AreEqual ("&<>\"'", StringWriterText);
|
|
|
|
xtw.WriteRaw("");
|
|
Assert.AreEqual ("&<>\"'", StringWriterText);
|
|
|
|
// bug #77623
|
|
xtw.WriteRaw ("{0}{1}");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteRawInvalidInAttribute ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteStartAttribute ("bar", null);
|
|
xtw.WriteRaw ("&<>\"'");
|
|
xtw.WriteEndAttribute ();
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<foo bar='&<>\"'' />", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStateTest ()
|
|
{
|
|
Assert.AreEqual (WriteState.Start, xtw.WriteState);
|
|
xtw.WriteStartDocument ();
|
|
Assert.AreEqual (WriteState.Prolog, xtw.WriteState);
|
|
xtw.WriteStartElement ("root");
|
|
Assert.AreEqual (WriteState.Element, xtw.WriteState);
|
|
xtw.WriteElementString ("foo", "bar");
|
|
Assert.AreEqual (WriteState.Content, xtw.WriteState);
|
|
xtw.Close ();
|
|
Assert.AreEqual (WriteState.Closed, xtw.WriteState);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteString ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
try {
|
|
xtw.WriteString("foo");
|
|
Assert.Fail ("should raise an error.");
|
|
} catch (InvalidOperationException) {}
|
|
}
|
|
|
|
[Test]
|
|
public void WriteString2 ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
// Testing attribute values
|
|
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("bar", "&<>");
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo bar='&<>'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeStringSingleQuoteChar()
|
|
{
|
|
// When QuoteChar is single quote then replaces single quotes within attributes
|
|
// but not double quotes.
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("bar", "\"baz\"");
|
|
xtw.WriteAttributeString ("quux", "'baz'");
|
|
Assert.AreEqual ("<foo bar='\"baz\"' quux=''baz''", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeStringDoubleQuoteChar()
|
|
{
|
|
// When QuoteChar is double quote then replaces double quotes within attributes
|
|
// but not single quotes.
|
|
xtw.QuoteChar = '"';
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("bar", "\"baz\"");
|
|
xtw.WriteAttributeString ("quux", "'baz'");
|
|
Assert.AreEqual ("<foo bar=\""baz"\" quux=\"'baz'\"", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStringWithEntities()
|
|
{
|
|
// Testing element values
|
|
xtw.QuoteChar = '\'';
|
|
xtw.WriteElementString ("foo", "&<>\"'");
|
|
Assert.AreEqual ("<foo>&<>\"'</foo>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void XmlLang ()
|
|
{
|
|
Assert.IsNull (xtw.XmlLang);
|
|
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xml", "lang", null, "langfoo");
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo'", StringWriterText);
|
|
|
|
xtw.WriteAttributeString ("boo", "yah");
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'", StringWriterText);
|
|
|
|
xtw.WriteElementString("bar", "baz");
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>", StringWriterText);
|
|
|
|
xtw.WriteString("baz");
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz", StringWriterText);
|
|
|
|
xtw.WriteStartElement ("quux");
|
|
xtw.WriteStartAttribute ("xml", "lang", null);
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='", StringWriterText);
|
|
|
|
xtw.WriteString("langbar");
|
|
// Commented out there: it is implementation-dependent.
|
|
// and incompatible between .NET 1.0 and 1.1
|
|
// Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
// Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='", StringWriterText);
|
|
|
|
xtw.WriteEndAttribute ();
|
|
// Commented out there: it is implementation-dependent.
|
|
// and incompatible between .NET 1.0 and 1.1
|
|
// Assert.AreEqual ("langbar", xtw.XmlLang);
|
|
// Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='langbar'", StringWriterText);
|
|
|
|
// check if xml:lang repeats output even if same as current scope.
|
|
xtw.WriteStartElement ("joe");
|
|
xtw.WriteAttributeString ("xml", "lang", null, "langbar");
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='langbar'><joe xml:lang='langbar'", StringWriterText);
|
|
|
|
|
|
xtw.WriteElementString ("quuux", "squonk");
|
|
Assert.AreEqual ("langbar", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='langbar'><joe xml:lang='langbar'><quuux>squonk</quuux>", StringWriterText);
|
|
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("langfoo", xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='langbar'><joe xml:lang='langbar'><quuux>squonk</quuux></joe></quux>", StringWriterText);
|
|
|
|
xtw.WriteEndElement ();
|
|
Assert.IsNull (xtw.XmlLang);
|
|
Assert.AreEqual ("<foo xml:lang='langfoo' boo='yah'><bar>baz</bar>baz<quux xml:lang='langbar'><joe xml:lang='langbar'><quuux>squonk</quuux></joe></quux></foo>", StringWriterText);
|
|
|
|
xtw.Close ();
|
|
Assert.IsNull (xtw.XmlLang);
|
|
}
|
|
|
|
// TODO: test operational aspects
|
|
[Test]
|
|
public void XmlSpaceTest ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
Assert.AreEqual (XmlSpace.None, xtw.XmlSpace, "#1");
|
|
|
|
xtw.WriteStartElement ("bar");
|
|
xtw.WriteAttributeString ("xml", "space", null, "preserve");
|
|
Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace, "#2");
|
|
Assert.AreEqual ("<foo><bar xml:space='preserve'", StringWriterText, "#3");
|
|
|
|
xtw.WriteStartElement ("baz");
|
|
xtw.WriteAttributeString ("xml", "space", null, "preserve");
|
|
Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace, "#4");
|
|
Assert.AreEqual ("<foo><bar xml:space='preserve'><baz xml:space='preserve'", StringWriterText, "#5");
|
|
|
|
xtw.WriteStartElement ("quux");
|
|
xtw.WriteStartAttribute ("xml", "space", null);
|
|
Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace, "#6");
|
|
Assert.AreEqual ("<foo><bar xml:space='preserve'><baz xml:space='preserve'><quux xml:space='", StringWriterText, "#7");
|
|
|
|
// Commented out there: it is implementation-dependent
|
|
// and incompatible between .NET 1.0 and 1.1
|
|
xtw.WriteString ("default");
|
|
// Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace);
|
|
// Assert.AreEqual ("<foo><bar xml:space='preserve'><baz xml:space='preserve'><quux xml:space='", StringWriterText);
|
|
|
|
xtw.WriteEndAttribute ();
|
|
Assert.AreEqual (XmlSpace.Default, xtw.XmlSpace, "#8");
|
|
Assert.AreEqual ("<foo><bar xml:space='preserve'><baz xml:space='preserve'><quux xml:space='default'", StringWriterText, "#9");
|
|
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace, "#10");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual (XmlSpace.Preserve, xtw.XmlSpace, "#11");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual (XmlSpace.None, xtw.XmlSpace, "#12");
|
|
|
|
xtw.WriteStartElement ("quux");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void XmlSpaceTestInvalidValue1 ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xml", "space", null, "bubba");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void XmlSpaceTestInvalidValue2 ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xml", "space", null, "PRESERVE");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void XmlSpaceTestInvalidValue3 ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xml", "space", null, "Default");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void XmlSpaceTestInvalidValue4 ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xml", "space", null, "bubba");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteWhitespaceNonWhitespace ()
|
|
{
|
|
xtw.WriteWhitespace ("x");
|
|
}
|
|
|
|
[Test]
|
|
//[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteWhitespace_Null ()
|
|
{
|
|
xtw.WriteWhitespace ((string) null);
|
|
}
|
|
|
|
[Test]
|
|
//[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteWhitespace_Empty ()
|
|
{
|
|
xtw.WriteWhitespace (string.Empty);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteNmToken_Null ()
|
|
{
|
|
xtw.WriteNmToken ((string) null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteNmToken_Empty ()
|
|
{
|
|
xtw.WriteNmToken (string.Empty);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteNmToken_InvalidChars ()
|
|
{
|
|
xtw.WriteNmToken ("\uFFFF");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNmToken ()
|
|
{
|
|
xtw.WriteNmToken ("some:name");
|
|
Assert.AreEqual ("some:name", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void XmlSpaceRaw ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteStartAttribute ("xml", "space", null);
|
|
Assert.AreEqual (XmlSpace.None, xtw.XmlSpace);
|
|
Assert.AreEqual ("<foo xml:space='", StringWriterText);
|
|
|
|
xtw.WriteString ("default");
|
|
// Commented out there: it is implementation-dependent
|
|
// and incompatible between .NET 1.0 and 1.1
|
|
// Assert.AreEqual (XmlSpace.None, xtw.XmlSpace);
|
|
// Assert.AreEqual ("<foo xml:space='", StringWriterText);
|
|
|
|
xtw.WriteEndAttribute ();
|
|
Assert.AreEqual (XmlSpace.Default, xtw.XmlSpace);
|
|
Assert.AreEqual ("<foo xml:space='default'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributes ()
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
StringWriter sw = new StringWriter();
|
|
XmlWriter wr = new XmlTextWriter(sw);
|
|
StringBuilder sb = sw.GetStringBuilder();
|
|
XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default);
|
|
XmlTextReader xtr = new XmlTextReader("<?xml version='1.0' encoding='utf-8' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx);
|
|
|
|
xtr.Read(); // read XMLDecl
|
|
wr.WriteAttributes(xtr, false);
|
|
// This method don't always have to take this double-quoted style...
|
|
Assert.AreEqual ("version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"", sw.ToString ().Trim (),
|
|
"#WriteAttributes.XmlDecl.1");
|
|
|
|
sb.Remove(0, sb.Length); // init
|
|
ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default);
|
|
xtr = new XmlTextReader("<?xml version='1.0' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx);
|
|
xtr.Read(); // read XMLDecl
|
|
Assert.AreEqual (XmlNodeType.XmlDeclaration, xtr.NodeType);
|
|
sw = new StringWriter ();
|
|
wr = new XmlTextWriter (sw);
|
|
|
|
// This block raises an error on MS.NET 1.0.
|
|
wr.WriteAttributes(xtr, false);
|
|
// This method don't always have to take this double-quoted style...
|
|
Assert.AreEqual ("version=\"1.0\" standalone=\"no\"", sw.ToString ().Trim (),
|
|
"#WriteAttributes.XmlDecl.2");
|
|
|
|
sw = new StringWriter ();
|
|
wr = new XmlTextWriter (sw);
|
|
sb.Remove(0, sb.Length); // init
|
|
|
|
xtr.Read(); // read root
|
|
Assert.AreEqual (XmlNodeType.Element, xtr.NodeType);
|
|
wr.WriteStartElement(xtr.LocalName, xtr.NamespaceURI);
|
|
wr.WriteAttributes(xtr, false);
|
|
wr.WriteEndElement();
|
|
wr.Close();
|
|
// This method don't always have to take this double-quoted style...
|
|
Assert.AreEqual ("<root a1=\"A\" b2=\"B\" c3=\"C\" />", sw.ToString ().Trim (),
|
|
"#WriteAttributes.Element");
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteWhitespace ()
|
|
{
|
|
xtw.WriteStartElement ("a");
|
|
xtw.WriteWhitespace ("\n\t");
|
|
xtw.WriteStartElement ("b");
|
|
xtw.WriteWhitespace ("\n\t");
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteWhitespace ("\n");
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteWhitespace ("\n");
|
|
xtw.Flush ();
|
|
Assert.AreEqual ("<a>\n\t<b>\n\t</b>\n</a>\n", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void FlushDoesntCloseTag ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("bar", "baz");
|
|
xtw.Flush ();
|
|
Assert.AreEqual ("<foo bar='baz'", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteWhitespaceClosesTag ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("bar", "baz");
|
|
xtw.WriteWhitespace (" ");
|
|
Assert.AreEqual ("<foo bar='baz'> ", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void DontOutputMultipleXmlns ()
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml("<a xmlns:dt=\"b\" dt:dt=\"c\"/>");
|
|
XmlDocument doc2 = new XmlDocument();
|
|
doc2.LoadXml(doc.InnerXml);
|
|
Assert.AreEqual ("<a xmlns:dt=\"b\" dt:dt=\"c\" />",
|
|
doc2.OuterXml);
|
|
}
|
|
|
|
[Test]
|
|
public void DontOutputNonDeclaredXmlns ()
|
|
{
|
|
string xml = "<x:a foo='foo' xmlns:x='urn:foo'><b /></x:a>";
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.LoadXml(xml);
|
|
XmlDocument doc2 = new XmlDocument();
|
|
doc2.LoadXml(doc.InnerXml);
|
|
Assert.AreEqual (xml.Replace ('\'', '"'), doc2.OuterXml);
|
|
}
|
|
|
|
[Test]
|
|
public void DontOutputRemovalDefaultNSDeclaration ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteAttributeString ("xmlns", "probe");
|
|
Assert.AreEqual (String.Empty, xtw.LookupPrefix ("probe"), "#1");
|
|
xtw.WriteStartElement ("b");
|
|
Assert.AreEqual (String.Empty, xtw.LookupPrefix ("probe"), "#2");
|
|
xtw.WriteStartElement (null, "b2", null); // *Don't* output xmlns=""
|
|
xtw.WriteEndElement (); // b2
|
|
xtw.WriteStartElement (null, "b2", ""); // *Do* output xmlns=""
|
|
xtw.WriteEndElement (); // b2
|
|
xtw.WriteEndElement (); // b
|
|
xtw.WriteEndElement (); // foo
|
|
xtw.WriteEndDocument ();
|
|
xtw.Close ();
|
|
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo xmlns='probe'><b><b2 /><b2 xmlns='' /></b></foo>", StringWriterText, "#3");
|
|
}
|
|
|
|
[Test]
|
|
public void DontOutputRemovalDefaultNSDeclaration2 ()
|
|
{
|
|
xtw.WriteStartDocument ();
|
|
// IMPORTANT DIFFERENCE!! ns = "", not null
|
|
xtw.WriteStartElement ("foo", "");
|
|
xtw.WriteAttributeString ("xmlns", "probe");
|
|
Assert.IsNull (xtw.LookupPrefix ("probe"), "#1");
|
|
xtw.WriteStartElement ("b");
|
|
Assert.IsNull (xtw.LookupPrefix ("probe"), "#2");
|
|
xtw.WriteStartElement (null, "b2", null); // *Don't* output xmlns=""
|
|
xtw.WriteEndElement (); // b2
|
|
xtw.WriteStartElement (null, "b2", ""); // *Don't* output xmlns=""
|
|
xtw.WriteEndElement (); // b2
|
|
xtw.WriteEndElement (); // b
|
|
xtw.WriteEndElement (); // foo
|
|
xtw.WriteEndDocument ();
|
|
xtw.Close ();
|
|
|
|
Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo xmlns='probe'><b><b2 /><b2 /></b></foo>", StringWriterText, "#3");
|
|
}
|
|
|
|
[Test]
|
|
public void DoOutputRemovalDefaultNSDeclaration ()
|
|
{
|
|
xtw.WriteStartElement ("docelem", "a-namespace");
|
|
|
|
XmlDocument doc = new XmlDocument ();
|
|
doc.CreateElement ("hola").WriteTo (xtw);
|
|
// This means, WriteTo never passes null NamespaceURI argument to XmlWriter.
|
|
xtw.WriteEndElement ();
|
|
xtw.Close ();
|
|
|
|
Assert.AreEqual ("<docelem xmlns='a-namespace'><hola xmlns='' /></docelem>", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributeTakePrecedenceOnXmlns ()
|
|
{
|
|
xtw.WriteStartElement ("root", "urn:foo");
|
|
xtw.WriteAttributeString ("xmlns", "urn:bar");
|
|
xtw.WriteEndElement ();
|
|
xtw.Close ();
|
|
Assert.AreEqual ("<root xmlns='urn:bar' />", StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void LookupPrefixNull ()
|
|
{
|
|
xtw.LookupPrefix (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void LookupPrefixEmpty ()
|
|
{
|
|
xtw.LookupPrefix (String.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void LookupPrefixIgnoresXmlnsAttribute ()
|
|
{
|
|
Assert.IsNull (xtw.LookupPrefix ("urn:foo"));
|
|
xtw.WriteStartElement ("root");
|
|
Assert.IsNull (xtw.LookupPrefix ("urn:foo"));
|
|
xtw.WriteAttributeString ("xmlns", "urn:foo");
|
|
// Surprisingly to say, it is ignored!!
|
|
Assert.AreEqual (String.Empty, xtw.LookupPrefix ("urn:foo"));
|
|
xtw.WriteStartElement ("hoge");
|
|
// (still after flushing previous start element.)
|
|
Assert.AreEqual (String.Empty, xtw.LookupPrefix ("urn:foo"));
|
|
xtw.WriteStartElement ("fuga", "urn:foo");
|
|
// Is this testing on the correct way? Yes, here it is.
|
|
Assert.AreEqual (String.Empty, xtw.LookupPrefix ("urn:foo"));
|
|
}
|
|
|
|
[Test]
|
|
public void WriteInvalidNames ()
|
|
{
|
|
xtw.WriteStartElement ("foo<>");
|
|
xtw.WriteAttributeString ("ho<>ge", "value");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void AttributeWriteStartAttributePrefixWithoutNS ()
|
|
{
|
|
xtw.WriteStartAttribute ("some", "foo", null);
|
|
}
|
|
|
|
[Test]
|
|
public void AttributeWriteStartAttributeXmlnsNullNS ()
|
|
{
|
|
xtw.WriteStartAttribute ("xmlns", "foo", null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void AttributeWriteEndAttributeXmlnsNullNs ()
|
|
{
|
|
// This test checks if the specified namespace URI is
|
|
// incorrectly empty or not. Compare it with
|
|
// AttributeWriteStartAttributeXmlnsNullNS().
|
|
xtw.WriteStartAttribute ("xmlns", "foo", null);
|
|
xtw.WriteEndAttribute ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void AttributeWriteStartAttributePrefixXmlnsNonW3CNS ()
|
|
{
|
|
xtw.WriteStartAttribute ("xmlns", "foo", "urn:foo");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void AttributeWriteStartAttributeLocalXmlnsNonW3CNS ()
|
|
{
|
|
xtw.WriteStartAttribute ("", "xmlns", "urn:foo");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteRawProceedToProlog ()
|
|
{
|
|
XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());
|
|
xtw.WriteRaw ("");
|
|
Assert.AreEqual (WriteState.Prolog, xtw.WriteState);
|
|
}
|
|
|
|
[Test]
|
|
public void Indent ()
|
|
{
|
|
XmlDocument doc = new XmlDocument ();
|
|
doc.LoadXml ("<root><test>test<foo></foo>string</test><test>string</test></root>");
|
|
StringWriter sw = new StringWriter ();
|
|
sw.NewLine = "_";
|
|
XmlTextWriter xtw = new XmlTextWriter (sw);
|
|
xtw.Formatting = Formatting.Indented;
|
|
doc.WriteContentTo (xtw);
|
|
Assert.AreEqual (@"<root>_ <test>test<foo></foo>string</test>_ <test>string</test>_</root>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void Indent2 ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlTextWriter xtw = new XmlTextWriter (sw);
|
|
xtw.Formatting = Formatting.Indented;
|
|
// sadly, this silly usage of this method is actually
|
|
// used in WriteNode() in MS.NET.
|
|
xtw.WriteProcessingInstruction ("xml",
|
|
"version=\"1.0\"");
|
|
xtw.WriteComment ("sample XML fragment");
|
|
Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
|
|
@"<?xml version=""1.0""?>{0}" +
|
|
"<!--sample XML fragment-->", Environment.NewLine),
|
|
sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void Indent3 ()
|
|
{
|
|
XmlDocument doc = new XmlDocument ();
|
|
doc.PreserveWhitespace = true;
|
|
string s;
|
|
|
|
doc.LoadXml ("<root><element></element><!-- comment indented --><element>sample <!-- comment non-indented --></element></root>");
|
|
s = GetIndentedOutput (doc.DocumentElement);
|
|
Assert.AreEqual (s, String.Format ("<root>{0} <element>{0} </element>{0} <!-- comment indented -->{0} <element>sample <!-- comment non-indented --></element>{0}</root>", "\n"), "#1");
|
|
|
|
doc.LoadXml ("<root> \n<mid> \n<mid> \n<child attr='value'>sample <nested attr='value' /> string</child> <child2 attr='value'>sample string</child2> <empty attr='value'/>\n<a>test</a> \n</mid> <returnValue> <returnType>System.String</returnType> </returnValue> </mid> </root>");
|
|
s = GetIndentedOutput (doc.DocumentElement);
|
|
Assert.AreEqual (s, String.Format ("<root> {0}<mid> {0}<mid> {0}<child attr='value'>sample <nested attr='value' /> string</child> <child2 attr='value'>sample string</child2> <empty attr='value' />{0}<a>test</a> {0}</mid> <returnValue> <returnType>System.String</returnType> </returnValue> </mid> </root>", "\n"), "#2");
|
|
|
|
doc.LoadXml ("<!-- after /MemberType and after /returnValue --><root><MemberType>blah</MemberType>\n <returnValue><returnType>System.String</returnType></returnValue>\n <Docs><summary>text</summary><value>text<see cref='ttt' /></value><remarks/></Docs></root>");
|
|
s = GetIndentedOutput (doc.DocumentElement);
|
|
Assert.AreEqual (s, String.Format ("<root>{0} <MemberType>blah</MemberType>{0} <returnValue><returnType>System.String</returnType></returnValue>{0} <Docs><summary>text</summary><value>text<see cref='ttt' /></value><remarks /></Docs></root>", "\n"), "#3");
|
|
}
|
|
|
|
string GetIndentedOutput (XmlNode n)
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
sw.NewLine = "\n";
|
|
XmlTextWriter xtw = new XmlTextWriter (sw);
|
|
xtw.QuoteChar = '\'';
|
|
xtw.Formatting = Formatting.Indented;
|
|
n.WriteTo (xtw);
|
|
return sw.ToString ();
|
|
}
|
|
|
|
[Test]
|
|
public void CloseTwice ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlTextWriter writer = new XmlTextWriter (sw);
|
|
writer.Close ();
|
|
// should not result in an exception
|
|
writer.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteRawWriteString ()
|
|
{
|
|
// WriteRaw () -> WriteString ().
|
|
xtw.WriteRaw ("");
|
|
xtw.WriteString ("foo");
|
|
Assert.AreEqual (WriteState.Content, xtw.WriteState);
|
|
}
|
|
|
|
[Test]
|
|
public void LookupOverridenPrefix ()
|
|
{
|
|
xtw.WriteStartElement ("out");
|
|
xtw.WriteAttributeString ("xmlns", "baz", "http://www.w3.org/2000/xmlns/", "xyz");
|
|
xtw.WriteStartElement ("baz", "foo", "abc");
|
|
Assert.IsNull (xtw.LookupPrefix ("xyz"));
|
|
}
|
|
|
|
[Test]
|
|
public void DuplicatingNamespaceMappingInAttributes ()
|
|
{
|
|
xtw.WriteStartElement ("out");
|
|
xtw.WriteAttributeString ("p", "foo", "urn:foo", "xyz");
|
|
xtw.WriteAttributeString ("p", "bar", "urn:bar", "xyz");
|
|
xtw.WriteAttributeString ("p", "baz", "urn:baz", "xyz");
|
|
xtw.WriteStartElement ("out");
|
|
xtw.WriteAttributeString ("p", "foo", "urn:foo", "xyz");
|
|
xtw.WriteStartElement ("out");
|
|
xtw.WriteAttributeString ("p", "foo", "urn:foo", "xyz");
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
xtw.WriteEndElement ();
|
|
string xml = sw.ToString ();
|
|
Assert.IsTrue (xml.IndexOf ("p:foo='xyz'") > 0, "p:foo" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("d1p1:bar='xyz'") > 0, "d1p1:bar" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("d1p2:baz='xyz'") > 0, "d1p1:baz" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("xmlns:d1p2='urn:baz'") > 0, "xmlns:d1p2" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("xmlns:d1p1='urn:bar'") > 0, "xmlns:d1p1" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("xmlns:p='urn:foo'") > 0, "xmlns:p" + ". output is " + xml);
|
|
Assert.IsTrue (xml.IndexOf ("<out p:foo='xyz'><out p:foo='xyz' /></out></out>") > 0, "remaining" + ". output is " + xml);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteXmlSpaceIgnoresNS ()
|
|
{
|
|
xtw.WriteStartElement ("root");
|
|
xtw.WriteAttributeString ("xml", "space", "abc", "preserve");
|
|
xtw.WriteEndElement ();
|
|
Assert.AreEqual ("<root xml:space='preserve' />", sw.ToString ());
|
|
}
|
|
|
|
[Test] // bug #75546
|
|
public void WriteEmptyNSQNameInAttribute ()
|
|
{
|
|
XmlTextWriter xtw = new XmlTextWriter (TextWriter.Null);
|
|
xtw.WriteStartElement ("foo", "urn:goo");
|
|
xtw.WriteAttributeString ("xmlns:bar", "urn:bar");
|
|
xtw.WriteStartAttribute ("foo", "");
|
|
xtw.WriteQualifiedName ("n1", "urn:bar");
|
|
xtw.WriteEndAttribute ();
|
|
xtw.WriteStartAttribute ("foo", "");
|
|
xtw.WriteQualifiedName ("n2", "");
|
|
xtw.WriteEndAttribute ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
// cannot bind any prefix to "http://www.w3.org/2000/xmlns/".
|
|
public void WriteQualifiedNameXmlnsError ()
|
|
{
|
|
xtw.WriteStartElement ("foo");
|
|
xtw.WriteQualifiedName ("", "http://www.w3.org/2000/xmlns/");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteDocType ()
|
|
{
|
|
// we have the following test matrix:
|
|
//
|
|
// | name | publicid | systemid | subset|
|
|
// |------------------------------------|
|
|
// | X | X | X | X | #01
|
|
// | X | E | X | X | #02
|
|
// | X | X | E | X | #03
|
|
// | X | X | X | E | #04
|
|
// | X | E | E | X | #05
|
|
// | X | X | E | E | #06
|
|
// | X | E | X | E | #07
|
|
// | X | E | E | E | #08
|
|
// | X | N | X | X | #09
|
|
// | X | X | N | X | #10
|
|
// | X | X | X | N | #11
|
|
// | X | N | N | X | #12
|
|
// | X | X | N | N | #13
|
|
// | X | N | X | N | #14
|
|
// | X | N | N | N | #15
|
|
//
|
|
// Legend:
|
|
// -------
|
|
// X = Has value
|
|
// E = Zero-length string
|
|
// N = Null
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN'" +
|
|
" 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'[sub]>",
|
|
sw.ToString (), "#01");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", string.Empty,
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"\"" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"[sub]>",
|
|
sw.ToString (), "#02");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
string.Empty, "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"\"[sub]>",
|
|
sw.ToString (), "#03");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", string.Empty);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"[]>",
|
|
sw.ToString (), "#04");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", string.Empty, string.Empty, "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"\" \"\"[sub]>",
|
|
sw.ToString (), "#05");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
string.Empty, string.Empty);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"\"[]>",
|
|
sw.ToString (), "#06");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", string.Empty,
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", string.Empty);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"\"" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"[]>",
|
|
sw.ToString (), "#07");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", string.Empty, string.Empty, string.Empty);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"\" \"\"[]>",
|
|
sw.ToString (), "#08");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", (string) null,
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test SYSTEM" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"[sub]>",
|
|
sw.ToString (), "#09");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
(string) null, "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"\"[sub]>",
|
|
sw.ToString (), "#10");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", (string) null);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">",
|
|
sw.ToString (), "#11");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", (string) null, (string) null, "sub");
|
|
Assert.AreEqual ("<!DOCTYPE test[sub]>",
|
|
sw.ToString (), "#12");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
(string) null, (string) null);
|
|
Assert.AreEqual ("<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
|
|
" \"\">",
|
|
sw.ToString (), "#13");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", (string) null,
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", (string) null);
|
|
Assert.AreEqual ("<!DOCTYPE test SYSTEM" +
|
|
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">",
|
|
sw.ToString (), "#14");
|
|
|
|
sw.GetStringBuilder ().Length = 0;
|
|
xtw = new XmlTextWriter (sw);
|
|
|
|
xtw.WriteDocType ("test", (string) null, (string) null, (string) null);
|
|
Assert.AreEqual ("<!DOCTYPE test>",
|
|
sw.ToString (), "#15");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteDocType_EmptyName ()
|
|
{
|
|
xtw.WriteDocType (string.Empty, "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "sub");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void WriteDocType_NullName ()
|
|
{
|
|
xtw.WriteDocType ((string) null, "-//W3C//DTD XHTML 1.0 Strict//EN",
|
|
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "sub");
|
|
}
|
|
|
|
[Test] // bug #76095
|
|
public void SurrogatePairsInWriteString ()
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
XmlWriter writer = new XmlTextWriter(ms, null);
|
|
writer.WriteElementString("a", "\ud800\udf39");
|
|
writer.Close();
|
|
byte [] referent = new byte [] {0x3c, 0x61, 0x3e, 0xf0,
|
|
0x90, 0x8c, 0xb9, 0x3c, 0x2f, 0x61, 0x3e};
|
|
NUnit.Framework.Assert.AreEqual (referent, ms.ToArray ());
|
|
}
|
|
|
|
[Test]
|
|
public void InvalidCharIsWrittenAsSillyReferences ()
|
|
{
|
|
// I can't say how MS XmlTextWriter is silly.
|
|
// The expected output is *not* well-formed XML.
|
|
// Everyone have to make sure that he or she does
|
|
// not write invalid characters directly so that
|
|
// the output XML string can be fed by other XML
|
|
// processors.
|
|
|
|
// The funny thing is that XmlTextWriter spends
|
|
// significant performance on checking invalid
|
|
// characters, but results in nothing.
|
|
xtw.WriteElementString ("a", "\x0");
|
|
NUnit.Framework.Assert.AreEqual ("<a>�</a>",
|
|
StringWriterText);
|
|
}
|
|
|
|
[Test] // see also bug #77082
|
|
public void WriteDocTypeIndent ()
|
|
{
|
|
string expected = String.Format (@"<?xml version='1.0'?>{0}<!DOCTYPE root PUBLIC '' 'urn:foo'[]>{0}<root />", Environment.NewLine);
|
|
xtw.Formatting = Formatting.Indented;
|
|
xtw.WriteProcessingInstruction ("xml", "version='1.0'");
|
|
xtw.WriteDocType ("root", "", "urn:foo", "");
|
|
xtw.WriteStartElement ("root");
|
|
xtw.WriteEndElement ();
|
|
xtw.Close ();
|
|
Assert.AreEqual (expected, StringWriterText);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void WriteDocTypeTwice ()
|
|
{
|
|
xtw.WriteDocType ("root", "", "urn:foo", "");
|
|
xtw.WriteDocType ("root", "", "urn:foo", "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlDeclAfterDocType ()
|
|
{
|
|
xtw.WriteDocType ("root", "", "urn:foo", "");
|
|
xtw.WriteStartDocument ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlDeclAfterWhitespace ()
|
|
{
|
|
xtw.WriteWhitespace (" ");
|
|
xtw.WriteStartDocument ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void XmlDeclAfterPI ()
|
|
{
|
|
xtw.WriteProcessingInstruction ("pi", "");
|
|
xtw.WriteStartDocument ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteRawEmptyCloseStartTag ()
|
|
{
|
|
xtw.WriteStartElement ("stream", "stream","http://etherx.jabber.org/streams");
|
|
xtw.WriteAttributeString ("version", "1.0");
|
|
xtw.WriteAttributeString ("to", "[email protected]");
|
|
xtw.WriteAttributeString ("from", "server");
|
|
xtw.WriteAttributeString ("xmlns", "jabber:client");
|
|
xtw.WriteRaw ("");// Ensure that the tag is closed
|
|
xtw.Flush ();
|
|
|
|
Assert.AreEqual ("<stream:stream version='1.0' to='[email protected]' from='server' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>", StringWriterText);
|
|
}
|
|
|
|
[Test] // bug #78148
|
|
public void UpdateFormattingOnTheFly ()
|
|
{
|
|
XmlTextWriter w = new XmlTextWriter (TextWriter.Null);
|
|
w.WriteStartElement ("test");
|
|
w.Formatting = Formatting.Indented;
|
|
}
|
|
|
|
[Test] // bug #78598
|
|
public void WriteGlobalAttributeInDefaultNS ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlTextWriter tw = new XmlTextWriter (sw);
|
|
string ns = "http://schemas.xmlsoap.org/soap/envelope/";
|
|
tw.WriteStartElement ("Envelope");
|
|
tw.WriteAttributeString ("xmlns", ns);
|
|
int start = sw.ToString ().Length;
|
|
tw.WriteStartElement ("UserInfo");
|
|
tw.WriteStartAttribute ("actor", ns);
|
|
tw.WriteEndAttribute ();
|
|
tw.WriteEndElement ();
|
|
tw.WriteEndElement ();
|
|
Assert.IsTrue (sw.ToString ().IndexOf (ns, start) > 0);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteCommentPIAndIndent ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlTextWriter w = new XmlTextWriter (sw);
|
|
w.Formatting = Formatting.Indented;
|
|
w.WriteStartElement ("foo");
|
|
w.WriteComment ("test");
|
|
w.WriteProcessingInstruction ("PI", "");
|
|
w.WriteStartElement ("child");
|
|
w.WriteEndElement ();
|
|
w.WriteComment ("test");
|
|
w.WriteString ("STRING");
|
|
w.WriteEndElement ();
|
|
Assert.AreEqual (String.Format (@"<foo>{0} <!--test-->{0} <?PI ?>{0} <child />{0} <!--test-->STRING</foo>", Environment.NewLine), sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteBinHexAttribute () // for bug #79019
|
|
{
|
|
XmlWriter writer = new XmlTextWriter (TextWriter.Null);
|
|
writer.WriteStartElement ("test");
|
|
byte [] buffer1 = new byte [] {200, 155};
|
|
writer.WriteStartAttribute ("key", "");
|
|
writer.WriteBinHex (buffer1, 0, buffer1.Length);
|
|
writer.WriteEndAttribute ();
|
|
writer.WriteEndElement ();
|
|
}
|
|
|
|
[Test]
|
|
public void LookupNamespace ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlTextWriter xw = new XmlTextWriter (sw);
|
|
xw.Formatting = Formatting.Indented;
|
|
string q1 = "urn:test";
|
|
|
|
string q1prefix_first= "q1";
|
|
// Ensure we get a different reference for the string "q1"
|
|
string q1prefix_second = ("q1" + "a").Substring(0,2);
|
|
|
|
xw.WriteStartElement("document");
|
|
xw.WriteStartElement("item");
|
|
xw.WriteStartElement (q1prefix_first, "addMedia", q1);
|
|
xw.WriteEndElement();
|
|
xw.WriteEndElement();
|
|
xw.WriteStartElement("item");
|
|
xw.WriteStartElement (q1prefix_second, "addMedia", q1);
|
|
xw.WriteEndElement();
|
|
xw.WriteEndElement();
|
|
xw.WriteEndElement();
|
|
string xml = sw.ToString ();
|
|
int first = xml.IndexOf ("xmlns");
|
|
Assert.IsTrue (xml.IndexOf ("xmlns", first + 5) > 0);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributePrefixedNullNamespace ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter xw = new XmlTextWriter (sw);
|
|
xw.WriteStartElement ("root");
|
|
xw.WriteAttributeString ("xmlns", "abc", null, "uri:abcnamespace");
|
|
xw.WriteAttributeString ("abc", "def", null, "value");
|
|
xw.WriteEndElement ();
|
|
Assert.AreEqual ("<root xmlns:abc=\"uri:abcnamespace\" abc:def=\"value\" />", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteElementPrefixedNullNamespace ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter xw = new XmlTextWriter (sw);
|
|
xw.WriteStartElement ("root");
|
|
xw.WriteAttributeString ("xmlns", "abc", null, "uri:abcnamespace");
|
|
xw.WriteStartElement ("abc", "def", null);
|
|
xw.WriteEndElement ();
|
|
xw.WriteEndElement ();
|
|
Assert.AreEqual ("<root xmlns:abc=\"uri:abcnamespace\"><abc:def /></root>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void RejectWritingAtErrorState ()
|
|
{
|
|
try {
|
|
xtw.WriteEndElement ();
|
|
} catch (Exception) {
|
|
}
|
|
|
|
xtw.WriteStartElement ("foo");
|
|
}
|
|
}
|
|
}
|