public void writeNode_XmlReader8(XmlWriterUtils utils)
{
XmlReader xr = CreateReaderIgnoreWS("XmlReader.xml");
while (xr.Read())
{
if (xr.LocalName == "EmptyElement")
{
xr.Read();
break;
}
}
using (XmlWriter w = utils.CreateWriter())
{
w.WriteNode(xr, false);
}
// check reader position
CError.Compare(xr.NodeType, XmlNodeType.EndElement, "Error");
CError.Compare(xr.Name, "EmptyElement", "Error");
xr.Dispose();
Assert.True(utils.CompareReader("<node1 />"));
}
public void XmlDecl_7(XmlWriterUtils utils)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.CloseOutput = false;
wSettings.OmitXmlDeclaration = false;
wSettings.ConformanceLevel = ConformanceLevel.Document;
string strxml = "<?xml version=\"1.0\"?><root>blah</root>";
XmlReader xr = ReaderHelper.Create(new StringReader(strxml));
xr.Read();
XmlWriter w = utils.CreateWriter(wSettings);
w.WriteNode(xr, false);
w.WriteStartElement("root");
w.WriteString("blah");
w.WriteEndElement();
xr.Dispose();
w.Dispose();
Assert.True(utils.CompareReader(strxml));
}
public void document_6(XmlWriterUtils utils)
{
using (XmlWriter w = utils.CreateWriter())
{
try
{
w.WriteStartDocument();
w.WriteStartElement("Root");
w.WriteEndElement();
w.WriteEndDocument();
w.WriteStartDocument();
w.WriteEndDocument();
}
catch (InvalidOperationException e)
{
CError.WriteLineIgnore("Exception: " + e.ToString());
CError.Compare(w.WriteState, WriteState.Error, "WriteState should be Error");
return;
}
}
CError.WriteLine("Did not throw exception");
Assert.True(false);
}
public void writeAttributes_9(XmlWriterUtils utils, string tokenType)
{
string strxml = "";
switch (tokenType)
{
case "DocumentType":
if (IsXPathDataModelReader())
{
CError.WriteLine("{0} does not support DocumentType node", readerType);
return;
}
strxml = "<!DOCTYPE Root[]><Root/>";
break;
case "CDATA":
if (IsXPathDataModelReader())
{
CError.WriteLine("{0} does not support CDATA node", readerType);
return;
}
strxml = "<root><![CDATA[Test]]></root>";
break;
case "Text":
strxml = "<root>Test</root>";
break;
case "ProcessingInstruction":
strxml = "<root><?pi test?></root>";
break;
case "Comment":
strxml = "<root><!-- comment --></root>";
break;
case "EntityReference":
if (!ReaderSupportsEntityRef())
{
CError.WriteLine("{0} does not support EntityRef node", readerType);
return;
}
strxml = "<!DOCTYPE root[<!ENTITY e \"Test Entity\"> ]><root>&e;</root>";
break;
case "SignificantWhitespace":
strxml = "<root xml:space=\"preserve\"> </root>";
break;
case "Whitespace":
if (ReaderStripsWhitespace())
{
CError.WriteLine("{0} strips whitespace nodes by default", readerType);
return;
}
strxml = "<root> </root>";
break;
}
XmlReader xr;
xr = CreateReader(new StringReader(strxml));
do
{
xr.Read();
}while ((xr.NodeType.ToString() != tokenType) && (xr.ReadState != ReadState.EndOfFile));
if (xr.ReadState == ReadState.EndOfFile || xr.NodeType.ToString() != tokenType)
{
xr.Dispose();
CError.WriteLine("Reader not positioned on correct node");
CError.WriteLine("ReadState: {0}", xr.ReadState);
CError.WriteLine("NodeType: {0}", xr.NodeType);
Assert.True(false);
}
using (XmlWriter w = utils.CreateWriter())
{
try
{
if (tokenType != "DocumentType")
{
w.WriteStartElement("root");
}
w.WriteAttributes(xr, false);
}
catch (XmlException e)
{
CError.WriteLineIgnore(e.ToString());
CError.Compare(w.WriteState, (tokenType == "DocumentType") ? WriteState.Start : WriteState.Element, "WriteState should be Element");
return;
}
finally
{
xr.Dispose();
}
}
CError.WriteLine("Did not throw exception");
Assert.True(false);
}
private XmlWriter CreateMemWriter(XmlWriterUtils utils, XmlWriterSettings settings)
{
XmlWriterSettings wSettings = settings.Clone();
wSettings.CloseOutput = false;
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = false;
XmlWriter w = null;
switch (utils.WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.WrappedWriter:
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
XmlWriter ww = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
w = WriterHelper.Create(ww, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.CharCheckingWriter:
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
XmlWriter cw = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
XmlWriterSettings cws = settings.Clone();
cws.CheckCharacters = true;
w = WriterHelper.Create(cw, cws, overrideAsync: true, async: utils.Async);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
wSettings.Indent = true;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
wSettings.Indent = true;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings, overrideAsync: true, async: utils.Async);
break;
default:
throw new Exception("Unknown writer type");
}
return(w);
}
public void checkChars_1(XmlWriterUtils utils, string tokenType)
{
char[] invalidXML = { '\u0000', '\u0008', '\u000B', '\u000C', '\u000E', '\u001F', '\uFFFE', '\uFFFF' };
XmlWriter w = utils.CreateWriter(ConformanceLevel.Auto);
try
{
switch (tokenType)
{
case "WriteDocTypeName":
w.WriteDocType(":badname", "sysid", "pubid", "subset");
break;
case "WriteDocTypeSysid":
w.WriteDocType("name", invalidXML[1].ToString(), "pubid", "subset");
break;
case "WriteDocTypePubid":
w.WriteDocType("name", "sysid", invalidXML[1].ToString(), "subset");
break;
case "String":
w.WriteString(invalidXML[0].ToString());
break;
case "CData":
w.WriteCData(invalidXML[1].ToString());
break;
case "Comment":
w.WriteComment(invalidXML[2].ToString());
break;
case "CharEntity":
w.WriteCharEntity(invalidXML[3]);
break;
case "EntityRef":
w.WriteEntityRef(invalidXML[4].ToString());
break;
case "SurrogateCharEntity":
w.WriteSurrogateCharEntity(invalidXML[5], invalidXML[1]);
break;
case "PI":
w.WriteProcessingInstruction("pi", invalidXML[6].ToString());
break;
case "Whitespace":
w.WriteWhitespace(invalidXML[7].ToString());
break;
case "Chars":
w.WriteChars(invalidXML, 1, 5);
break;
case "RawString":
w.WriteRaw(invalidXML[4].ToString());
break;
case "RawChars":
w.WriteRaw(invalidXML, 6, 2);
break;
case "WriteValue":
w.WriteValue(invalidXML[3].ToString());
break;
default:
CError.Compare(false, "Invalid param value");
break;
}
}
catch (XmlException e1)
{
CError.WriteLineIgnore("Exception: " + e1.ToString());
CError.Compare(w.WriteState, WriteState.Error, "WriteState should be Error");
return;
}
catch (ArgumentException e2)
{
CError.WriteLineIgnore("Exception: " + e2.ToString());
CError.Compare(w.WriteState, WriteState.Error, "WriteState should be Error");
return;
}
finally
{
w.Dispose();
}
Assert.True(false);
}
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);
}
public void checkChars_2(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 = false;
XmlWriter w = utils.CreateWriter(wSettings);
CError.Compare(w.Settings.CheckCharacters, false, "Mismatch in CheckCharacters");
try
{
w.WriteStartElement("Root");
switch (tokenType)
{
case "String":
w.WriteString(invalidXML[0].ToString());
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareReader("<Root>�</Root>"));
return;
case "CharEntity":
w.WriteCharEntity(invalidXML[3]);
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareReader("<Root></Root>"));
return;
case "Chars":
w.WriteChars(invalidXML, 1, 5);
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareReader("<Root></Root>"));
return;
case "WriteValue":
w.WriteValue(invalidXML[3].ToString());
w.WriteEndElement();
w.Dispose();
Assert.True(utils.CompareReader("<Root></Root>"));
return;
default:
CError.Compare(false, "Invalid param value");
break;
}
}
catch (ArgumentException e)
{
CError.WriteLineIgnore("Exception: " + e.ToString());
Assert.True(false);
}
finally
{
w.Dispose();
}
Assert.True(false);
}
public void flush_1(XmlWriterUtils utils, bool closeOutput)
{
Stream writerStream = new MemoryStream();
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.NewLineChars = "\r\n";
XmlWriter w = null;
long expectedLength = 0;
wSettings.CloseOutput = closeOutput;
switch (utils.WriterType)
{
case WriterType.WrappedWriter:
expectedLength = 113;
XmlWriter ww = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
w = WriterHelper.Create(ww, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.CharCheckingWriter:
expectedLength = 113;
XmlWriter w1 = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
XmlWriterSettings ws1 = new XmlWriterSettings();
ws1.CheckCharacters = true;
w = WriterHelper.Create(w1, ws1, overrideAsync: true, async: utils.Async);
break;
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
expectedLength = 113;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
expectedLength = 224;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
expectedLength = 125;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
expectedLength = 248;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
default:
Assert.True(false, "unknown writer");
break;
}
wSettings.CloseOutput = closeOutput;
var beginning = writerStream.Length;
try
{
w.WriteStartElement("root");
w.WriteStartElement("OneChar");
w.WriteAttributeString("a", "myAttribute");
w.WriteString("a");
w.WriteEndElement();
w.WriteStartElement("twoChars");
w.WriteString("ab");
w.WriteEndElement();
w.WriteEndElement();
Assert.Equal(writerStream.Length, beginning);
w.Flush();
Assert.Equal(expectedLength, writerStream.Length);
}
finally
{
w.Dispose();
writerStream.Dispose();
}
}
public void close_1(XmlWriterUtils utils)
{
Stream writerStream = new MemoryStream();
XmlWriterSettings wSettings = new XmlWriterSettings();
long expectedLength1 = 0;
long expectedLength2 = 0;
switch (utils.WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
expectedLength1 = 83;
expectedLength2 = 113;
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
expectedLength1 = 164;
expectedLength2 = 224;
break;
}
wSettings.CloseOutput = false;
XmlWriter w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
try
{
var beginning = writerStream.Length;
w.WriteStartElement("root");
w.WriteStartElement("OneChar");
w.WriteAttributeString("a", "myAttribute");
w.WriteString("a");
w.WriteEndElement();
CError.WriteLine("File Size Before Flush: {0}", writerStream.Length);
CError.Compare(writerStream.Length, beginning, "Before Flush");
// Flush mid-way
w.Flush();
CError.WriteLine("File Size After Flush: {0}", writerStream.Length);
CError.Compare(writerStream.Length, expectedLength1, "After Flush");
w.WriteStartElement("twoChars");
w.WriteString("ab");
w.WriteEndElement();
w.WriteEndElement();
w.Dispose();
// Now check that Close() called Flush()
CError.WriteLine("File Size After Writer.Close: {0}", writerStream.Length);
CError.Compare(writerStream.Length, expectedLength2, "After Writer.Close");
// Finally, close the underlying stream, it should be flushed now
writerStream.Flush();
CError.WriteLine("File Size After Stream.Close: {0}", writerStream.Length);
CError.Compare(writerStream.Length, expectedLength2, "After Stream.Close");
}
catch (XmlException)
{
Assert.True(false);
}
finally
{
if (writerStream != null)
{
writerStream.Dispose();
}
if (w != null)
{
w.Dispose();
}
}
return;
}
public void element_12(XmlWriterUtils utils, int param)
{
XmlWriter w = utils.CreateWriter();
w.WriteStartElement("Root");
string exp = "";
switch (param)
{
case 1:
exp = "<Root xml:xmlns=\"default \" />";
break;
case 2:
exp = "<Root xml:space=\"default\" />";
break;
case 3:
exp = "<Root xml:lang=\"default \" />";
break;
case 4:
exp = "<Root p1:xml=\"default \" xmlns:p1=\"xmlns\" />";
break;
case 5:
exp = "<Root p1:xml=\"default \" xmlns:p1=\"space\" />";
break;
case 6:
exp = "<Root p1:xml=\"default \" xmlns:p1=\"lang\" />";
break;
}
switch (param)
{
case 1:
w.WriteStartAttribute("xml", "xmlns", null);
break;
case 2:
w.WriteStartAttribute("xml", "space", null);
break;
case 3:
w.WriteStartAttribute("xml", "lang", null);
break;
case 4:
w.WriteStartAttribute("xml", "xmlns");
break;
case 5:
w.WriteStartAttribute("xml", "space");
break;
case 6:
w.WriteStartAttribute("xml", "lang");
break;
}
w.WriteValue("default");
try
{
w.WriteWhitespace(" ");
w.WriteEndAttribute();
w.WriteEndElement();
w.Dispose();
}
catch (InvalidOperationException e)
{
CError.WriteLine(e);
Assert.True(false);
}
Assert.True(utils.CompareString(exp));
}
