namespace MonoTests.System.Xml
{
[TestFixture]
- public class XmlWriterSettingsTests : Assertion
+ public class XmlWriterSettingsTests
{
[Test]
public void DefaultValue ()
private void DefaultValue (XmlWriterSettings s)
{
- AssertEquals (true, s.CheckCharacters);
- AssertEquals (false, s.CloseOutput);
- AssertEquals (ConformanceLevel.Document, s.ConformanceLevel);
- AssertEquals (Encoding.UTF8, s.Encoding);
- AssertEquals (false, s.Indent);
- AssertEquals (" ", s.IndentChars);
- AssertEquals (Environment.NewLine, s.NewLineChars);
- AssertEquals (false, s.NewLineOnAttributes);
- AssertEquals (false, s.OmitXmlDeclaration);
+ Assert.AreEqual (true, s.CheckCharacters);
+ Assert.AreEqual (false, s.CloseOutput);
+ Assert.AreEqual (ConformanceLevel.Document, s.ConformanceLevel);
+ Assert.AreEqual (Encoding.UTF8, s.Encoding);
+ Assert.AreEqual (false, s.Indent);
+ Assert.AreEqual (" ", s.IndentChars);
+ Assert.AreEqual ("\r\n", s.NewLineChars);
+ Assert.AreEqual (false, s.NewLineOnAttributes);
+ Assert.AreEqual (false, s.OmitXmlDeclaration);
+ Assert.AreEqual (NewLineHandling.Replace, s.NewLineHandling);
+#if NET_4_5
+ Assert.IsFalse (s.Async);
+#endif
}
[Test]
w.WriteEndElement ();
w.Close ();
byte [] data = ms.ToArray ();
- Assert (data.Length != 0);
+ Assert.IsTrue (data.Length != 0);
string str = s.Encoding.GetString (data);
- AssertEquals ("<?xml version=\"1.0\" encoding=\"shift_jis\"?><root />", str);
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"shift_jis\"?><root />", str);
// For TextWriter it does not make sense
StringWriter sw = new StringWriter ();
w.WriteStartElement ("root");
w.WriteEndElement ();
w.Close ();
- AssertEquals ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root />", sw.ToString ());
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root />", sw.ToString ());
}
[Test]
}
[Test]
- [Ignore ("Write Test!")]
- public void ConformanceLevelTest ()
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void ConformanceLevelFragmentAndWriteStartDocument ()
+ {
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.ConformanceLevel = ConformanceLevel.Fragment;
+ s.OmitXmlDeclaration = true;
+ XmlWriter w = XmlWriter.Create (Console.Out, s);
+ w.WriteStartDocument ();
+ }
+
+ [Test]
+ public void ConformanceLevelAuto ()
+ {
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.ConformanceLevel = ConformanceLevel.Auto;
+ StringWriter sw = new StringWriter ();
+ XmlWriter w = XmlWriter.Create (sw, s);
+ w.WriteElementString ("foo", "");
+ w.Close ();
+ Assert.AreEqual ("<foo />", sw.ToString ());
+ }
+
+ [Test]
+ public void ConformanceLevelAuto_WriteStartDocument ()
+ {
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.ConformanceLevel = ConformanceLevel.Auto;
+ StringWriter sw = new StringWriter ();
+ XmlWriter w = XmlWriter.Create (sw, s);
+ w.WriteStartDocument ();
+ w.WriteElementString ("foo", "");
+ w.Close ();
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo />", sw.ToString ());
+ }
+
+ [Test]
+ public void ConformanceLevelAuto_OmitXmlDecl_WriteStartDocument ()
+ {
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.ConformanceLevel = ConformanceLevel.Auto;
+ s.OmitXmlDeclaration = true;
+ StringWriter sw = new StringWriter ();
+ XmlWriter w = XmlWriter.Create (sw, s);
+ w.WriteStartDocument ();
+ w.WriteElementString ("foo", "");
+ w.Close ();
+ Assert.AreEqual ("<foo />", sw.ToString ());
+ }
+
+ [Test]
+ public void ConformanceLevelDocument_OmitXmlDeclDeclaration ()
{
- throw new NotImplementedException ();
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.ConformanceLevel = ConformanceLevel.Document;
+ // LAMESPEC:
+ // On MSDN, XmlWriterSettings.OmitXmlDeclaration is documented as:
+ // "The XML declaration is always written if
+ // ConformanceLevel is set to Document, even
+ // if OmitXmlDeclaration is set to true. "
+ // but it is incorrect. It does consider
+ // OmitXmlDeclaration property.
+ s.OmitXmlDeclaration = true;
+ StringWriter sw = new StringWriter ();
+ XmlWriter w = XmlWriter.Create (sw, s);
+ w.WriteElementString ("foo", "");
+ w.Close ();
+ Assert.AreEqual ("<foo />", sw.ToString ());
}
[Test]
w.WriteEndElement ();
w.WriteEndElement ();
w.Close ();
- AssertEquals (output, sw.ToString ());
+ Assert.AreEqual (output, sw.ToString ());
}
[Test]
w.WriteStartElement ("root");
w.WriteEndElement ();
w.Flush ();
- AssertEquals ("<root />", sb.ToString ());
+ Assert.AreEqual ("<root />", sb.ToString ());
}
+
+ [Test]
+ public void NewLineOnAttributesMixedContent ()
+ {
+ StringWriter sw = new StringWriter ();
+ XmlWriterSettings s = new XmlWriterSettings ();
+ s.NewLineOnAttributes = true;
+ s.OmitXmlDeclaration = true;
+ XmlWriter w = XmlWriter.Create (sw, s);
+ w.WriteStartElement ("root");
+ w.WriteAttributeString ("a", "v");
+ w.WriteAttributeString ("b", "x");
+ w.WriteString ("some string");
+ w.WriteEndElement ();
+ w.Close ();
+ Assert.AreEqual ("<root a=\"v\" b=\"x\">some string</root>", sw.ToString (), "#1");
+
+ // mixed content: bug #81770
+ string expected = "<root>some string<mixed\n a=\"v\"\n b=\"x\">some string</mixed></root>";
+ s.Indent = true;
+ sw = new StringWriter ();
+ w = XmlWriter.Create (sw, s);
+ w.WriteStartElement ("root");
+ w.WriteString ("some string");
+ w.WriteStartElement ("mixed");
+ w.WriteAttributeString ("a", "v");
+ w.WriteAttributeString ("b", "x");
+ w.WriteString ("some string");
+ w.WriteEndElement ();
+ w.WriteEndElement ();
+ w.Close ();
+ Assert.AreEqual (expected, sw.ToString ().Replace ("\r\n", "\n"), "#2");
+ }
+
+ [Test]
+ public void OmitXmlDeclarationAndNewLine ()
+ {
+ XmlDocument doc = new XmlDocument ();
+ doc.LoadXml ("<root/>");
+ XmlWriterSettings settings = new XmlWriterSettings ();
+ settings.OmitXmlDeclaration = true;
+ settings.NewLineChars = "\r\n";
+ settings.NewLineHandling = NewLineHandling.Replace;
+ settings.Encoding = Encoding.UTF8;
+ settings.Indent = true;
+
+ StringWriter sw = new StringWriter ();
+ using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
+ doc.Save (xw);
+ }
+ // no heading newline.
+ Assert.AreEqual ("<root />", sw.ToString ());
+ }
+
+ [Test] // surprisingly niche behavior yet caused bug #3231.
+ public void IndentAndTopLevelWhitespaces ()
+ {
+ var sw = new StringWriter ();
+ var xw = XmlWriter.Create (sw, new XmlWriterSettings () { Indent = true });
+ xw.WriteProcessingInstruction ("xml", "version='1.0'");
+ xw.WriteWhitespace ("\n");
+ xw.WriteComment ("AAA");
+ xw.WriteWhitespace ("\n");
+ xw.WriteWhitespace ("\n");
+ xw.WriteStartElement ("root");
+ xw.Close ();
+ string xml = @"<?xml version='1.0'?>
+<!--AAA-->
+
+<root />";
+ Assert.AreEqual (xml, sw.ToString ().Replace ("\r\n", "\n"), "#1");
+ }
+
+ [Test]
+ public void NewlineHandlingNone ()
+ {
+ var sw = new StringWriter ();
+ var xw = XmlWriter.Create (sw, new XmlWriterSettings () { NewLineHandling = NewLineHandling.None });
+ xw.WriteStartElement("root");
+ xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteStartElement("element");
+ xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteEndElement();
+ xw.WriteEndElement();
+ xw.Close();
+ string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr\rcrlf\r\nht\t</element><element attr=\"lf\ncr\rcrlf\r\nht\t\" /></root>";
+ Assert.AreEqual (xml, sw.ToString ());
+ }
+
+ [Test]
+ public void NewlineHandlingReplace ()
+ {
+ var sw = new StringWriter ();
+ var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
+ NewLineHandling = NewLineHandling.Replace,
+ NewLineChars = "\n"
+ });
+ xw.WriteStartElement("root");
+ xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteStartElement("element");
+ xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteEndElement();
+ xw.WriteEndElement();
+ xw.Close();
+ string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr\ncrlf\nht\t</element><element attr=\"lf
cr
crlf
ht	\" /></root>";
+ Assert.AreEqual (xml, sw.ToString ());
+ }
+
+ [Test]
+ public void NewlineHandlingReplaceCRLF ()
+ {
+ var sw = new StringWriter ();
+ var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
+ NewLineHandling = NewLineHandling.Replace,
+ NewLineChars = "\r\n"
+ });
+ xw.WriteStartElement("root");
+ xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteStartElement("element");
+ xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteEndElement();
+ xw.WriteEndElement();
+ xw.Close();
+ string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\r\ncr\r\ncrlf\r\nht\t</element><element attr=\"lf
cr
crlf
ht	\" /></root>";
+ Assert.AreEqual (xml, sw.ToString ());
+ }
+
+ [Test]
+ public void NewlineHandlingEntitize ()
+ {
+ var sw = new StringWriter ();
+ var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
+ NewLineHandling = NewLineHandling.Entitize,
+ NewLineChars = "\n"
+ });
+ xw.WriteStartElement("root");
+ xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteStartElement("element");
+ xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
+ xw.WriteEndElement();
+ xw.WriteEndElement();
+ xw.Close();
+ string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr
crlf
\nht\t</element><element attr=\"lf
cr
crlf
ht	\" /></root>";
+ Assert.AreEqual (xml, sw.ToString ());
+ }
+
+#if NET_4_5
+ [Test]
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void ReadonlyAsync ()
+ {
+ var sw = new StringWriter ();
+ var s = new XmlWriterSettings ();
+ var w = XmlWriter.Create (sw, s);
+ w.Settings.Async = true;
+ }
+
+ [Test]
+ public void AsyncPropagation ()
+ {
+ var sw = new StringWriter ();
+ var s = new XmlWriterSettings ();
+ s.Async = true;
+ var w = XmlWriter.Create (sw, s);
+
+ var c = s.Clone ();
+ Assert.IsTrue (c.Async);
+ c.Reset ();
+ Assert.IsFalse (c.Async);
+
+ var w2 = XmlWriter.Create (w, c);
+ Assert.IsTrue (w2.Settings.Async);
+ }
+#endif
+
}
}
#endif
projects / mono.git / blobdiff