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)); }