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.
983 lines
31 KiB
C#
983 lines
31 KiB
C#
//
|
|
// System.Xml.XmlTextWriterTests
|
|
//
|
|
// Authors:
|
|
// Atsushi Enomoto <[email protected]>
|
|
// Martin Willemoes Hansen <[email protected]>
|
|
//
|
|
// (C) 2003 Atsushi Enomoto
|
|
// (C) 2003 Martin Willemoes Hansen
|
|
//
|
|
//
|
|
// This class mainly checks inheritance and behaviors of XmlWriter.
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.XPath;
|
|
|
|
using NUnit.Framework;
|
|
|
|
using AssertType = NUnit.Framework.Assert;
|
|
|
|
namespace MonoTests.System.Xml
|
|
{
|
|
[TestFixture]
|
|
public class XmlWriterTests
|
|
{
|
|
StringWriter writer;
|
|
XmlTextWriter xtw;
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
writer = new StringWriter ();
|
|
xtw = new XmlTextWriter (writer);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeFullDocument ()
|
|
{
|
|
string xml = "<?xml version='1.0'?><root />";
|
|
XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
|
|
xtw.WriteNode (xtr, false);
|
|
Assert.AreEqual (xml, writer.ToString ());
|
|
|
|
writer.GetStringBuilder ().Length = 0;
|
|
|
|
// With encoding
|
|
xml = "<?xml version='1.0' encoding='iso-2022-jp'?><root />";
|
|
xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
|
|
xtw.WriteNode (xtr, false);
|
|
Assert.AreEqual (xml, writer.ToString ());
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeXmlDecl ()
|
|
{
|
|
string xml = "<?xml version='1.0'?><root />";
|
|
StringReader sr = new StringReader (xml);
|
|
XmlTextReader xtr = new XmlTextReader (sr);
|
|
xtr.Read ();
|
|
xtw.WriteNode (xtr, false);
|
|
Assert.AreEqual ("<?xml version='1.0'?>",
|
|
writer.ToString ());
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeEmptyElement ()
|
|
{
|
|
string xml = "<root attr='value' attr2='value' />";
|
|
StringReader sr = new StringReader (xml);
|
|
XmlTextReader xtr = new XmlTextReader (sr);
|
|
xtw.WriteNode (xtr, false);
|
|
Assert.AreEqual (xml.Replace ("'", "\""),
|
|
writer.ToString ());
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeNonEmptyElement ()
|
|
{
|
|
string xml = @"<foo><bar></bar></foo>";
|
|
xtw.WriteNode (new XmlTextReader (xml, XmlNodeType.Document, null), false);
|
|
Assert.AreEqual (xml, writer.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeSingleContentElement ()
|
|
{
|
|
string xml = "<root attr='value' attr2='value'><foo /></root>";
|
|
StringReader sr = new StringReader (xml);
|
|
XmlTextReader xtr = new XmlTextReader (sr);
|
|
xtw.WriteNode (xtr, false);
|
|
Assert.AreEqual (xml.Replace ("'", "\""),
|
|
writer.ToString ());
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeNone ()
|
|
{
|
|
XmlTextReader xtr = new XmlTextReader ("", XmlNodeType.Element, null);
|
|
xtr.Read ();
|
|
xtw.WriteNode (xtr, false); // does not report any errors
|
|
xtr.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotDotNet")] // enbugged in 2.0
|
|
[Ignore ("Bug in Microsoft referencesource")]
|
|
[ExpectedException (typeof (XmlException))]
|
|
public void WriteNodeError ()
|
|
{
|
|
XmlTextReader xtr = new XmlTextReader ("<root>", XmlNodeType.Document, null);
|
|
xtr.Read ();
|
|
try {
|
|
xtr.Read ();
|
|
} catch {
|
|
}
|
|
XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());
|
|
xtw.WriteNode (xtr, false);
|
|
}
|
|
|
|
[Test]
|
|
public void WriteSurrogateCharEntity ()
|
|
{
|
|
xtw.WriteSurrogateCharEntity ('\udfff', '\udb00');
|
|
Assert.AreEqual ("󐏿", writer.ToString ());
|
|
|
|
try {
|
|
xtw.WriteSurrogateCharEntity ('\ud800', '\udc00');
|
|
Assert.Fail ();
|
|
} catch {
|
|
}
|
|
try {
|
|
xtw.WriteSurrogateCharEntity ('\udbff', '\ud800');
|
|
Assert.Fail ();
|
|
} catch {
|
|
}
|
|
try {
|
|
xtw.WriteSurrogateCharEntity ('\ue000', '\ud800');
|
|
Assert.Fail ();
|
|
} catch {
|
|
}
|
|
try {
|
|
xtw.WriteSurrogateCharEntity ('\udfff', '\udc00');
|
|
Assert.Fail ();
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
// MS.NET's not-overriden XmlWriter.WriteStartElement(name)
|
|
// invokes WriteStartElement(null, name, null).
|
|
// WriteStartElement(name, ns) invokes (null, name, ns), too.
|
|
[Test]
|
|
public void StartElement ()
|
|
{
|
|
StartElementTestWriter xw = new StartElementTestWriter ();
|
|
xw.WriteStartDocument ();
|
|
xw.WriteStartElement ("test");
|
|
Assert.IsNull (xw.NS, "StartElementOverride.NS");
|
|
Assert.IsNull (xw.Prefix, "StartElementOverride.Prefix");
|
|
xw.NS = String.Empty;
|
|
xw.Prefix = String.Empty;
|
|
xw.WriteStartElement ("test", "urn:hoge");
|
|
Assert.AreEqual ("urn:hoge", xw.NS, "StartElementOverride.NS");
|
|
Assert.IsNull (null, xw.Prefix, "StartElementOverride.Prefix");
|
|
}
|
|
|
|
class StartElementTestWriter : DefaultXmlWriter
|
|
{
|
|
public StartElementTestWriter () : base () {}
|
|
public string NS = String.Empty;
|
|
public string Prefix = String.Empty;
|
|
|
|
public override void WriteStartElement (string prefix, string localName, string ns)
|
|
{
|
|
this.NS = ns;
|
|
this.Prefix = prefix;
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void WriteAttributes ()
|
|
{
|
|
string xml = "<root><test a='b' c='d' /><b /></root>";
|
|
XmlTextReader xtr = new XmlTextReader (xml,
|
|
XmlNodeType.Document, null);
|
|
xtw.QuoteChar = '\'';
|
|
xtr.Read ();
|
|
xtw.WriteStartElement ("root"); // <root
|
|
xtr.Read ();
|
|
xtw.WriteStartElement ("test"); // ><test
|
|
xtw.WriteAttributes (xtr, false); // a='b' c='d'
|
|
Assert.AreEqual (XmlNodeType.Element, xtr.NodeType);
|
|
xtw.WriteEndElement (); // />
|
|
xtw.WriteStartElement ("b"); // <b
|
|
xtw.WriteEndElement (); // />
|
|
xtw.WriteEndElement (); // </root>
|
|
xtw.Close ();
|
|
Assert.AreEqual (xml, writer.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void Create_File ()
|
|
{
|
|
string file = Path.GetTempFileName ();
|
|
XmlWriter writer = XmlWriter.Create (file);
|
|
Assert.IsNotNull (writer.Settings, "#A1");
|
|
//Assert.IsTrue (writer.Settings.CloseOutput, "#A2");
|
|
writer.Close ();
|
|
File.Delete (file);
|
|
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.CloseOutput = true;
|
|
writer = XmlWriter.Create (file, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");
|
|
Assert.IsTrue (settings.CloseOutput, "#B2");
|
|
writer.Close ();
|
|
File.Delete (file);
|
|
|
|
writer = XmlWriter.Create (file, (XmlWriterSettings) null);
|
|
Assert.IsNotNull (writer.Settings, "#C1");
|
|
//Assert.IsTrue (writer.Settings.CloseOutput, "#C2");
|
|
writer.Close ();
|
|
File.Delete (file);
|
|
|
|
settings = new XmlWriterSettings ();
|
|
writer = XmlWriter.Create (file, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#D1");
|
|
//Assert.IsTrue (writer.Settings.CloseOutput, "#D2");
|
|
writer.Close ();
|
|
File.Delete (file);
|
|
|
|
writer = XmlWriter.Create (file);
|
|
Assert.IsNotNull (writer.Settings, "#E1");
|
|
//Assert.IsTrue (writer.Settings.CloseOutput, "#E2");
|
|
writer.Close ();
|
|
File.Delete (file);
|
|
}
|
|
|
|
[Test]
|
|
public void Create_Stream ()
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
XmlWriter writer = XmlWriter.Create (ms);
|
|
Assert.IsNotNull (writer.Settings, "#A1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#A2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#A3");
|
|
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.CloseOutput = true;
|
|
writer = XmlWriter.Create (ms, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");
|
|
Assert.IsTrue (settings.CloseOutput, "#B2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#B3");
|
|
|
|
ms = new MemoryStream ();
|
|
settings = new XmlWriterSettings ();
|
|
writer = XmlWriter.Create (ms, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#C2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#C3");
|
|
|
|
ms = new MemoryStream ();
|
|
writer = XmlWriter.Create (ms, (XmlWriterSettings) null);
|
|
Assert.IsNotNull (writer.Settings, "#D1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#D2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#D3");
|
|
}
|
|
|
|
[Test]
|
|
public void Create_TextWriter ()
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
XmlWriter writer = XmlWriter.Create (new StreamWriter (ms));
|
|
Assert.IsNotNull (writer.Settings, "#A1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#A2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#A3");
|
|
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.CloseOutput = true;
|
|
writer = XmlWriter.Create (new StreamWriter (ms), settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");
|
|
Assert.IsTrue (settings.CloseOutput, "#B2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#B3");
|
|
|
|
ms = new MemoryStream ();
|
|
settings = new XmlWriterSettings ();
|
|
writer = XmlWriter.Create (new StreamWriter (ms), settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#C2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#C3");
|
|
|
|
ms = new MemoryStream ();
|
|
writer = XmlWriter.Create (new StreamWriter (ms), (XmlWriterSettings) null);
|
|
Assert.IsNotNull (writer.Settings, "#D1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#D2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#D3");
|
|
}
|
|
|
|
[Test]
|
|
public void Create_XmlWriter ()
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
XmlTextWriter xtw = new XmlTextWriter (ms, Encoding.UTF8);
|
|
XmlWriter writer = XmlWriter.Create (xtw);
|
|
Assert.IsNotNull (writer.Settings, "#A1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#A2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#A3");
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, Encoding.UTF8);
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.CloseOutput = true;
|
|
writer = XmlWriter.Create (xtw, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");
|
|
//Assert.IsFalse (writer.Settings.CloseOutput, "#B2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#B3");
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, Encoding.UTF8);
|
|
settings = new XmlWriterSettings ();
|
|
writer = XmlWriter.Create (xtw, settings);
|
|
//Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#C2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#C3");
|
|
|
|
ms = new MemoryStream ();
|
|
xtw = new XmlTextWriter (ms, Encoding.UTF8);
|
|
writer = XmlWriter.Create (xtw, (XmlWriterSettings) null);
|
|
Assert.IsNotNull (writer.Settings, "#D1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#D2");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#D3");
|
|
}
|
|
|
|
[Test]
|
|
public void Create_XmlWriter2 ()
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
XmlWriter xw = XmlWriter.Create (ms, settings);
|
|
XmlWriter writer = XmlWriter.Create (xw, new XmlWriterSettings ());
|
|
Assert.IsNotNull (writer.Settings, "#A1");
|
|
Assert.IsFalse (writer.Settings.CloseOutput, "#A2");
|
|
writer.Close ();
|
|
Assert.IsTrue (ms.CanWrite, "#A3");
|
|
|
|
ms = new MemoryStream ();
|
|
settings = new XmlWriterSettings ();
|
|
settings.CloseOutput = true;
|
|
settings.OmitXmlDeclaration = true;
|
|
xw = XmlWriter.Create (ms, settings);
|
|
writer = XmlWriter.Create (xw, new XmlWriterSettings ());
|
|
Assert.IsNotNull (writer.Settings, "#B1");
|
|
Assert.IsTrue (writer.Settings.CloseOutput, "#B2");
|
|
Assert.IsTrue (writer.Settings.OmitXmlDeclaration, "#B3");
|
|
writer.Close ();
|
|
Assert.IsFalse (ms.CanWrite, "#B3");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void CreateWriter_AttributeNamespacesXmlnsXmlns ()
|
|
{
|
|
// Unlike XmlTextWriter, null namespace is not ignored.
|
|
XmlWriter w = XmlWriter.Create (new StringWriter ());
|
|
w.WriteStartElement ("foo");
|
|
w.WriteAttributeString ("xmlns", "xmlns", null, "http://abc.def");
|
|
}
|
|
|
|
XmlWriter CreateWriter (TextWriter tw)
|
|
{
|
|
XmlWriterSettings s = new XmlWriterSettings ();
|
|
s.OmitXmlDeclaration = true;
|
|
XmlWriter w = XmlWriter.Create (tw, s);
|
|
w.WriteStartElement ("root");
|
|
return w;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void WriteValueNull ()
|
|
{
|
|
XmlWriter w = CreateWriter (TextWriter.Null);
|
|
w.WriteValue ((object) null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception
|
|
public void WriteValueNonExistentQName ()
|
|
{
|
|
XmlWriter w = CreateWriter (TextWriter.Null);
|
|
w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));
|
|
}
|
|
|
|
[Test]
|
|
public void WriteValueEmptyQName ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = CreateWriter (sw);
|
|
w.WriteValue (XmlQualifiedName.Empty);
|
|
w.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteValueQName ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = CreateWriter (sw);
|
|
w.WriteAttributeString ("xmlns", "x", "http://www.w3.org/2000/xmlns/", "urn:foo");
|
|
w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));
|
|
w.Close ();
|
|
Assert.AreEqual ("<root xmlns:x=\"urn:foo\">x:foo</root>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteValueTimeSpan ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = CreateWriter (sw);
|
|
w.WriteValue (TimeSpan.FromSeconds (5));
|
|
w.Close ();
|
|
Assert.AreEqual ("<root>PT5S</root>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteValueArray ()
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = CreateWriter (sw);
|
|
w.WriteValue (new int [] {1, 2, 3});
|
|
w.WriteValue (new int [] {4, 5, 6});
|
|
w.Close ();
|
|
Assert.AreEqual ("<root>1 2 34 5 6</root>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception
|
|
public void WriteValueTextReader ()
|
|
{
|
|
// it is documented as supported, but actually isn't.
|
|
XmlWriter w = CreateWriter (TextWriter.Null);
|
|
w.WriteValue (new StringReader ("foobar"));
|
|
}
|
|
|
|
XPathNavigator GetNavigator (string xml)
|
|
{
|
|
return new XPathDocument (XmlReader.Create (
|
|
new StringReader (xml))).CreateNavigator ();
|
|
}
|
|
|
|
string WriteNavigator (XPathNavigator nav, bool defattr)
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.OmitXmlDeclaration = true;
|
|
settings.ConformanceLevel = ConformanceLevel.Fragment;
|
|
using (XmlWriter w = XmlWriter.Create (sw, settings)) {
|
|
w.WriteNode (nav, defattr);
|
|
}
|
|
return sw.ToString ();
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeNavigator1 ()
|
|
{
|
|
XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");
|
|
// at Root
|
|
AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#1");
|
|
// at document element
|
|
nav.MoveToFirstChild ();
|
|
AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#2");
|
|
// at text
|
|
nav.MoveToFirstChild ();
|
|
AssertType.AreEqual ("test", WriteNavigator (nav, false), "#3");
|
|
|
|
// at comment
|
|
nav.MoveToNext ();
|
|
AssertType.AreEqual ("<!-- comment -->", WriteNavigator (nav, false), "#4");
|
|
}
|
|
|
|
string WriteSubtree (XPathNavigator nav)
|
|
{
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriterSettings settings = new XmlWriterSettings ();
|
|
settings.OmitXmlDeclaration = true;
|
|
settings.ConformanceLevel = ConformanceLevel.Fragment;
|
|
using (XmlWriter w = XmlWriter.Create (sw, settings)) {
|
|
nav.WriteSubtree(w);
|
|
}
|
|
return sw.ToString ();
|
|
}
|
|
|
|
[Test]
|
|
public void NavigatorWriteSubtree1 ()
|
|
{
|
|
XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");
|
|
// at Root
|
|
AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#1");
|
|
// at document element
|
|
nav.MoveToFirstChild ();
|
|
AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#2");
|
|
// at text
|
|
nav.MoveToFirstChild ();
|
|
AssertType.AreEqual ("test", WriteSubtree (nav), "#3");
|
|
|
|
// at comment
|
|
nav.MoveToNext ();
|
|
AssertType.AreEqual ("<!-- comment -->", WriteSubtree (nav), "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeXPathNavigator ()
|
|
{
|
|
string xml = "<A xmlns='urn:x'><B xmlns='urn:y' /></A>";
|
|
XPathNavigator nav = new XPathDocument (new StringReader(xml)).CreateNavigator ();
|
|
XmlWriterSettings s = new XmlWriterSettings ();
|
|
s.OmitXmlDeclaration = true;
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = XmlWriter.Create (sw, s);
|
|
w.WriteNode (nav, false);
|
|
w.Close ();
|
|
AssertType.AreEqual ("<A xmlns=\"urn:x\"><B xmlns=\"urn:y\" /></A>", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteNodeXPathNavigatorAttribute ()
|
|
{
|
|
string xml = "<!DOCTYPE root [<!ELEMENT root EMPTY> <!ATTLIST root implicit NMTOKEN 'nam'>]><root attr='val' />";
|
|
XPathNavigator nav = new XPathDocument (new StringReader (xml)).CreateNavigator ();
|
|
XmlWriterSettings s = new XmlWriterSettings ();
|
|
s.OmitXmlDeclaration = true;
|
|
StringWriter sw = new StringWriter ();
|
|
XmlWriter w = XmlWriter.Create (sw, s);
|
|
w.WriteStartElement ("hoge");
|
|
nav.MoveToFirstChild ();
|
|
nav.MoveToFirstAttribute ();
|
|
w.WriteNode (nav, false);
|
|
nav.MoveToNextAttribute ();
|
|
w.WriteNode (nav, false);
|
|
w.Close ();
|
|
AssertType.AreEqual ("<hoge />", sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteStringDifferentBehavior ()
|
|
{
|
|
// Messy implementation difference.
|
|
// from XmlTextWriter -> <foo />
|
|
// from XmlWriter.XCreate() -> <foo></foo>
|
|
var sw = new StringWriter ();
|
|
var xw = XmlWriter.Create (sw);
|
|
xw.WriteStartElement ("foo");
|
|
xw.WriteString ("");
|
|
xw.WriteEndElement ();
|
|
xw.Close ();
|
|
AssertType.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo></foo>".Replace ('\'', '"'), sw.ToString ());
|
|
}
|
|
|
|
// | | |returns the same reader
|
|
// source |wrapper|result| |checks state (and err)
|
|
// overrides|setting| | | |test name
|
|
// ---------+----------------------------
|
|
// - | -(Doc)| Doc | |x|0:CreateNOCL
|
|
// | Auto | Doc | |x|1:CreateNOCLSettingsCLAuto
|
|
// | Doc | Doc | |x|2:CreateNOCLSettingsCLDoc
|
|
// | Frag | Doc | |x|3:CreateNOCLSettingsCLFrag
|
|
// Auto | -(Doc)| Doc | | |4:CreateCLAuto
|
|
// | Auto | Auto |=|x|5:CreateCLAutoSettingsCLAuto
|
|
// | Doc | Doc | | |6:CreateCLAutoSettingsCLDoc
|
|
// | Frag | Frag | | |7:CreateCLAutoSettingsCLFrag
|
|
// Document | -(Doc)| Doc |=|x|8:CreateCLDoc
|
|
// | Auto | Doc |=|x|9:CreateCLDocSettingsCLAuto
|
|
// | Doc | Doc |=|x|A:CreateCLDocSettingsCLDoc
|
|
// | Frag | Frag | | |B:CreateCLDocSettingsCLFrag
|
|
// Fragment | -(Doc)| Doc | | |C:CreateCLFrag
|
|
// | Auto | Frag |=|x|D:CreateCLFragSettingsCLAuto
|
|
// | Doc | Doc | | |E:CreateCLFragSettingsCLDoc
|
|
// | Frag | Frag |=|x|F:CreateCLFragSettingsCLFrag
|
|
//
|
|
// What we can see from above:
|
|
// - default ConformanceLevel is Document. (0 4 8 C)
|
|
// - If wrapper is Auto, it delegates to source. (1 5 9 D)
|
|
// - Auto can happen only if both inputs are Auto (5)
|
|
// - If wrapper is Frag, all but default becomes Frag (7 B F)
|
|
// - with default it becomes Document (3)
|
|
// So a default value is likely stronger(!)
|
|
// - Basically, when there is no difference between the wrapper
|
|
// and the source settings, it does not create wrapper.
|
|
|
|
[Test]
|
|
public void CreateCLAuto ()
|
|
{
|
|
ConformanceLevelAuto cl = new ConformanceLevelAuto ();
|
|
XmlWriter xw = XmlWriter.Create (cl);
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLDoc ()
|
|
{
|
|
ConformanceLevelDocument cl = new ConformanceLevelDocument ();
|
|
XmlWriter xw = XmlWriter.Create (cl);
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
public void CreateCLFrag ()
|
|
{
|
|
ConformanceLevelFragment cl = new ConformanceLevelFragment ();
|
|
XmlWriter xw = XmlWriter.Create (cl);
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateNOCL ()
|
|
{
|
|
InvalidWriteState cl = new InvalidWriteState ();
|
|
Assert.IsNull (cl.Settings, "#0");
|
|
XmlWriter xw = XmlWriter.Create (cl);
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateNOCLSettingsCLAuto ()
|
|
{
|
|
InvalidWriteState cl = new InvalidWriteState ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateNOCLSettingsCLDoc ()
|
|
{
|
|
InvalidWriteState cl = new InvalidWriteState ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateNOCLSettingsCLFrag ()
|
|
{
|
|
InvalidWriteState cl = new InvalidWriteState ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLAutoSettingsCLAuto ()
|
|
{
|
|
ConformanceLevelAuto cl = new ConformanceLevelAuto ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });
|
|
Assert.AreEqual (ConformanceLevel.Auto, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
public void CreateCLAutoSettingsCLDoc ()
|
|
{
|
|
ConformanceLevelAuto cl = new ConformanceLevelAuto ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
public void CreateCLAutoSettingsCLFrag ()
|
|
{
|
|
ConformanceLevelAuto cl = new ConformanceLevelAuto ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });
|
|
Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLDocSettingsCLAuto ()
|
|
{
|
|
ConformanceLevelDocument cl = new ConformanceLevelDocument ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLDocSettingsCLDoc ()
|
|
{
|
|
ConformanceLevelDocument cl = new ConformanceLevelDocument ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
public void CreateCLDocSettingsCLFrag ()
|
|
{
|
|
ConformanceLevelDocument cl = new ConformanceLevelDocument ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });
|
|
Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLFragSettingsCLAuto ()
|
|
{
|
|
ConformanceLevelFragment cl = new ConformanceLevelFragment ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });
|
|
Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
public void CreateCLFragSettingsCLDoc ()
|
|
{
|
|
ConformanceLevelFragment cl = new ConformanceLevelFragment ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });
|
|
Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreNotEqual (xw, cl, "#2");
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void CreateCLFragSettingsCLFrag ()
|
|
{
|
|
ConformanceLevelFragment cl = new ConformanceLevelFragment ();
|
|
XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });
|
|
Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");
|
|
Assert.AreEqual (xw, cl, "#2"); // equal
|
|
WriteState state = xw.WriteState;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
internal class DefaultXmlWriter : XmlWriter
|
|
{
|
|
public DefaultXmlWriter () : base ()
|
|
{
|
|
}
|
|
|
|
public override void Close ()
|
|
{
|
|
}
|
|
|
|
public override void Flush ()
|
|
{
|
|
}
|
|
|
|
public override string LookupPrefix (string ns)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override void WriteBase64 (byte [] buffer, int index, int count)
|
|
{
|
|
}
|
|
|
|
public override void WriteBinHex (byte [] buffer, int index, int count)
|
|
{
|
|
}
|
|
|
|
public override void WriteCData (string text)
|
|
{
|
|
}
|
|
|
|
public override void WriteCharEntity (char ch)
|
|
{
|
|
}
|
|
|
|
public override void WriteChars (char [] buffer, int index, int count)
|
|
{
|
|
}
|
|
|
|
public override void WriteComment (string text)
|
|
{
|
|
}
|
|
|
|
public override void WriteDocType (string name, string pubid, string sysid, string subset)
|
|
{
|
|
}
|
|
|
|
public override void WriteEndAttribute ()
|
|
{
|
|
}
|
|
|
|
public override void WriteEndDocument ()
|
|
{
|
|
}
|
|
|
|
public override void WriteEndElement ()
|
|
{
|
|
}
|
|
|
|
public override void WriteEntityRef (string name)
|
|
{
|
|
}
|
|
|
|
public override void WriteFullEndElement ()
|
|
{
|
|
}
|
|
|
|
public override void WriteName (string name)
|
|
{
|
|
}
|
|
|
|
public override void WriteNmToken (string name)
|
|
{
|
|
}
|
|
|
|
public override void WriteNode (XmlReader reader, bool defattr)
|
|
{
|
|
}
|
|
|
|
public override void WriteProcessingInstruction (string name, string text)
|
|
{
|
|
}
|
|
|
|
public override void WriteQualifiedName (string localName, string ns)
|
|
{
|
|
}
|
|
|
|
public override void WriteRaw (string data)
|
|
{
|
|
}
|
|
|
|
public override void WriteRaw (char [] buffer, int index, int count)
|
|
{
|
|
}
|
|
|
|
public override void WriteStartAttribute (string prefix, string localName, string ns)
|
|
{
|
|
}
|
|
|
|
public override void WriteStartDocument (bool standalone)
|
|
{
|
|
}
|
|
|
|
public override void WriteStartDocument ()
|
|
{
|
|
}
|
|
|
|
public override void WriteStartElement (string prefix, string localName, string ns)
|
|
{
|
|
}
|
|
|
|
public override void WriteString (string text)
|
|
{
|
|
}
|
|
|
|
public override void WriteSurrogateCharEntity (char lowChar, char highChar)
|
|
{
|
|
}
|
|
|
|
public override void WriteWhitespace (string ws)
|
|
{
|
|
}
|
|
|
|
public override WriteState WriteState {
|
|
get {
|
|
return WriteState.Start;
|
|
}
|
|
}
|
|
|
|
public override string XmlLang {
|
|
get {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public override XmlSpace XmlSpace {
|
|
get {
|
|
return XmlSpace.None;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
class InvalidWriteState : XmlWriter {
|
|
public override void Close () { }
|
|
public override void Flush () { }
|
|
public override string LookupPrefix (string ns) { return null; }
|
|
public override void WriteBase64 (byte [] buffer, int index, int count) { }
|
|
public override void WriteCData (string text) { }
|
|
public override void WriteCharEntity (char ch) { }
|
|
public override void WriteChars (char [] buffer, int index, int count) { }
|
|
public override void WriteComment (string text) { }
|
|
public override void WriteDocType (string name, string pubid, string sysid, string subset) { }
|
|
public override void WriteEndAttribute () { }
|
|
public override void WriteEndDocument () { }
|
|
public override void WriteEndElement () { }
|
|
public override void WriteEntityRef (string name) { }
|
|
public override void WriteFullEndElement () { }
|
|
public override void WriteProcessingInstruction (string name, string text) {}
|
|
public override void WriteRaw (string data) {}
|
|
public override void WriteRaw (char [] buffer, int index, int count) {}
|
|
public override void WriteStartAttribute (string prefix, string localName, string ns) {}
|
|
public override void WriteStartDocument (bool standalone) {}
|
|
public override void WriteStartDocument () {}
|
|
public override void WriteStartElement (string prefix, string localName, string ns) {}
|
|
public override void WriteString (string text) {}
|
|
public override void WriteSurrogateCharEntity (char lowChar, char highChar) {}
|
|
public override void WriteWhitespace (string ws) {}
|
|
|
|
public override WriteState WriteState {
|
|
get { throw new InvalidOperationException (); }
|
|
}
|
|
}
|
|
|
|
class ConformanceLevelAuto : InvalidWriteState {
|
|
public override XmlWriterSettings Settings {
|
|
get {
|
|
return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto };
|
|
}
|
|
}
|
|
}
|
|
|
|
class ConformanceLevelDocument : InvalidWriteState {
|
|
public override XmlWriterSettings Settings {
|
|
get {
|
|
return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document };
|
|
}
|
|
}
|
|
}
|
|
|
|
class ConformanceLevelFragment : InvalidWriteState {
|
|
public override XmlWriterSettings Settings {
|
|
get {
|
|
return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment };
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|