public void checkChars_3(XmlWriterUtils utils, string tokenType)
{
char[] invalidXML = { '\u0000', '\u0008', '\u000B', '\u000C', '\u000E', '\u001F', '\uFFFE', '\uFFFF' };
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = false;
wSettings.CloseOutput = true;
XmlWriter w = utils.CreateWriter(wSettings);
CError.Compare(w.Settings.CheckCharacters, false, "Mismatch in CheckCharacters");
w.WriteStartElement("Root");
switch (tokenType)
{
case "Comment":
w.WriteComment(invalidXML[2].ToString());
w.WriteEndElement();
w.Dispose();
string exp = utils.IsIndent() ? "<Root>" + Environment.NewLine + " <!--\u000B-->" + Environment.NewLine + "</Root>" : "<Root><!--\u000B--></Root>";
Assert.True(utils.CompareString(exp));
break;
case "PI":
w.WriteProcessingInstruction("pi", invalidXML[6].ToString());
w.WriteEndElement();
w.Dispose();
exp = utils.IsIndent() ? "<Root>" + Environment.NewLine + " <?pi \uFFFE?>" + Environment.NewLine + "</Root>" : "<Root><?pi \uFFFE?></Root>";
Assert.True(utils.CompareString(exp));
break;
case "RawString":
w.WriteRaw(invalidXML[4].ToString());
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareString("<Root>\u000E</Root>"));
break;
case "RawChars":
w.WriteRaw(invalidXML, 6, 2);
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareString("<Root>\uFFFE\uFFFF</Root>"));
break;
case "CData":
w.WriteCData(invalidXML[1].ToString());
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareString("<Root><![CDATA[\u0008]]></Root>"));
break;
default:
CError.Compare(false, "Invalid param value");
Assert.True(false);
break;
}
}
public void writeNode_XmlReader28(XmlWriterUtils utils)
{
string strxml = "<?xml version=\"1.0\" standalone=\"yes\"?><Root />";
XmlReader xr = CreateReader(new StringReader(strxml));
xr.Read();
if (xr.NodeType != XmlNodeType.XmlDeclaration)
{
CError.WriteLine("Reader positioned on {0}", xr.NodeType);
xr.Dispose();
return;
}
XmlWriterSettings ws = new XmlWriterSettings();
ws.OmitXmlDeclaration = false;
XmlWriter w = utils.CreateWriter(ws);
w.WriteNode(xr, false);
w.WriteStartElement("Root");
w.WriteEndElement();
xr.Dispose();
w.Dispose();
strxml = utils.IsIndent() ? "<?xml version=\"1.0\" standalone=\"yes\"?>" + Environment.NewLine + "<Root />" : strxml;
Assert.True(utils.CompareString(strxml));
}
public void close_2(XmlWriterUtils utils)
{
XmlWriter w = utils.CreateWriter();
w.Dispose();
CError.Equals(w.Settings.Indent, utils.IsIndent(), "Incorrect default value of Indent");
CError.Equals(w.Settings.CheckCharacters, true, "Incorrect default value of CheckCharacters");
}
public void default_5(XmlWriterUtils utils)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
CError.Equals(wSettings.Indent, false, "Incorrect default value of wSettings.Indent");
XmlWriter w = utils.CreateWriter();
CError.Equals(w.Settings.Indent, utils.IsIndent(), "Incorrect default value of w.Settings.Indent");
w.Dispose();
return;
}
public void docType_2(XmlWriterUtils utils)
{
using (XmlWriter w = utils.CreateWriter())
{
w.WriteDocType("test", null, null, "<!ENTITY e 'abc'>");
w.WriteStartElement("Root");
w.WriteEndElement();
}
string exp = utils.IsIndent() ?
"<!DOCTYPE test [<!ENTITY e 'abc'>]>" + Environment.NewLine + "<Root />" :
"<!DOCTYPE test [<!ENTITY e 'abc'>]><Root />";
Assert.True(utils.CompareString(exp));
}
public void docType_5(XmlWriterUtils utils)
{
using (XmlWriter w = utils.CreateWriter())
{
String docName = "Root";
String docValue = "]>";
w.WriteDocType(docName, null, null, docValue);
w.WriteStartElement("Root");
w.WriteEndElement();
}
string exp = utils.IsIndent() ? "<!DOCTYPE Root []>]>" + Environment.NewLine + "<Root />" : "<!DOCTYPE Root []>]><Root />";
Assert.True(utils.CompareString(exp));
}
public void docType_1(XmlWriterUtils utils)
{
using (XmlWriter w = utils.CreateWriter())
{
w.WriteDocType("ROOT", "publicid", "sysid", "<!ENTITY e 'abc'>");
w.WriteStartElement("ROOT");
w.WriteEndElement();
}
string exp = utils.IsIndent() ?
"<!DOCTYPE ROOT PUBLIC \"publicid\" \"sysid\"[<!ENTITY e 'abc'>]>" + Environment.NewLine + "<ROOT />" :
"<!DOCTYPE ROOT PUBLIC \"publicid\" \"sysid\"[<!ENTITY e 'abc'>]><ROOT />";
Assert.True(utils.CompareString(exp));
}
public void writeNode_XmlReader39(XmlWriterUtils utils, bool defattr)
{
string strxml = "<!DOCTYPE root SYSTEM \"\uD812\uDD12\"><root/>";
string exp = utils.IsIndent() ?
"<!DOCTYPE root SYSTEM \"\uD812\uDD12\"[]>" + Environment.NewLine + "<root />" :
"<!DOCTYPE root SYSTEM \"\uD812\uDD12\"[]><root />";
using (XmlReader xr = CreateReader(new StringReader(strxml)))
{
using (XmlWriter w = utils.CreateWriter())
{
w.WriteNode(xr, defattr);
}
}
Assert.Equal(exp, utils.GetString());
}
public void attribute_22(XmlWriterUtils utils)
{
string exp = "<test ~f p a~:a1=\"v\" xmlns:~f p A~=\"ns1\"><base ~f p b~:a2=\"v\" ~a p4 ab~:a3=\"v\" xmlns:~a p4 AB~=\"ns2\" /></test>";
using (XmlWriter w = utils.CreateWriter())
{
w.WriteStartElement("test");
w.WriteAttributeString("p", "a1", "ns1", "v");
w.WriteStartElement("base");
w.WriteAttributeString("a2", "ns1", "v");
w.WriteAttributeString("p", "a3", "ns2", "v");
w.WriteEndElement();
w.WriteEndElement();
}
exp = utils.IsIndent() ?
"<test p:a1=\"v\" xmlns:p=\"ns1\">" + Environment.NewLine + " <base p:a2=\"v\" p4:a3=\"v\" xmlns:p4=\"ns2\" />" + Environment.NewLine + "</test>" : exp;
Assert.True(utils.CompareString(exp));
}
public void attribute_21(XmlWriterUtils utils)
{
using (XmlWriter w = utils.CreateWriter())
{
w.WriteStartElement("test");
w.WriteAttributeString("xmlns", "n1", null, "http://testbasens");
w.WriteStartElement("base");
w.WriteAttributeString("id", "http://testbasens", "5");
w.WriteAttributeString("lang", "http://common", "en");
w.WriteEndElement();
w.WriteEndElement();
}
string exp = utils.IsIndent() ?
"<test xmlns:n1=\"http://testbasens\">" + Environment.NewLine + " <base n1:id=\"5\" p4:lang=\"en\" xmlns:p4=\"http://common\" />" + Environment.NewLine + "</test>" :
"<test xmlns:~f n1 A~=\"http://testbasens\"><base ~f n1 a~:id=\"5\" ~a p4 a~:lang=\"en\" xmlns:~a p4 A~=\"http://common\" /></test>";
Assert.True(utils.CompareString(exp));
}
public void writeNode_XmlReader37(XmlWriterUtils utils, bool defattr)
{
string strxml = "<!DOCTYPE root PUBLIC \"\" \"#\"><root/>";
string exp = utils.IsIndent() ?
"<!DOCTYPE root PUBLIC \"\" \"#\"[]>" + Environment.NewLine + "<root />" :
"<!DOCTYPE root PUBLIC \"\" \"#\"[]><root />";
using (XmlReader xr = CreateReader(new StringReader(strxml)))
using (XmlWriter w = utils.CreateWriter())
{
while (!xr.EOF)
{
w.WriteNode(xr, defattr);
}
}
Assert.True(utils.CompareString(exp));
}
public void writeNode_XmlReader20(XmlWriterUtils utils)
{
string strxml = "<!DOCTYPE ROOT []><ROOT/>";
string exp = utils.IsIndent() ?
"<!DOCTYPE ROOT []>" + Environment.NewLine + "<ROOT />" :
"<!DOCTYPE ROOT []><ROOT />";
using (XmlReader xr = CreateReader(new StringReader(strxml)))
using (XmlWriter w = utils.CreateWriter())
{
while (xr.NodeType != XmlNodeType.DocumentType)
{
xr.Read();
}
w.WriteNode(xr, false);
w.WriteStartElement("ROOT");
w.WriteEndElement();
}
Assert.Equal(exp, utils.GetString());
}
public void checkChars_4(XmlWriterUtils utils, string tokenType, bool checkCharacters)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = checkCharacters;
wSettings.CloseOutput = true;
char[] invalidXML = { '\u0000', '\u0008', '\u000B', '\u000C', '\u000E', '\u001F', '\uFFFE', '\uFFFF' };
XmlWriter w = utils.CreateWriter(wSettings);
try
{
w.WriteStartElement("Root");
switch (tokenType)
{
case "Whitespace":
w.WriteWhitespace(invalidXML[7].ToString());
break;
case "Surrogate":
w.WriteSurrogateCharEntity(invalidXML[7], invalidXML[0]);
break;
case "EntityRef":
w.WriteEntityRef(invalidXML[4].ToString());
break;
case "Name":
w.WriteName(invalidXML[6].ToString());
break;
case "NmToken":
w.WriteNmToken(invalidXML[5].ToString());
break;
case "QName":
w.WriteQualifiedName(invalidXML[3].ToString(), "");
break;
default:
CError.Compare(false, "Invalid param value");
break;
}
}
catch (ArgumentException e)
{
CError.WriteLineIgnore("Exception: " + e.ToString());
//By design
if ((utils.WriterType == WriterType.UTF8Writer || utils.WriterType == WriterType.UnicodeWriter || utils.WriterType == WriterType.WrappedWriter || utils.IsIndent()) &&
(tokenType == "Name" || tokenType == "NmToken"))
{
CError.Compare(w.WriteState, WriteState.Element, "WriteState should be Element");
}
else
{
CError.Compare(w.WriteState, WriteState.Error, "WriteState should be Error");
}
return;
}
finally
{
w.Dispose();
}
Assert.True(false);
}