private XmlWriter CreateMemWriter(XmlWriterSettings settings)
{
XmlWriterSettings wSettings = settings.Clone();
wSettings.CloseOutput = false;
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = false;
XmlWriter w = null;
switch (WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.WrappedWriter:
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
XmlWriter ww = WriterHelper.Create(_strWriter, wSettings);
w = WriterHelper.Create(ww, wSettings);
break;
case WriterType.CharCheckingWriter:
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
XmlWriter cw = WriterHelper.Create(_strWriter, wSettings);
XmlWriterSettings cws = settings.Clone();
cws.CheckCharacters = true;
w = WriterHelper.Create(cw, cws);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
wSettings.Indent = true;
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
wSettings.Indent = true;
if (_strWriter != null) _strWriter.Dispose();
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
default:
throw new Exception("Unknown writer type");
}
return w;
}
public XmlWriter CreateMemWriter(XmlWriterUtils utils, Stream writerStream, 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;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.WrappedWriter:
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:
XmlWriter cw = WriterHelper.Create(writerStream, 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.CustomWriter:
wSettings.Async = utils.Async;
w = new CustomWriter(writerStream, wSettings);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
default:
throw new Exception("Unknown writer type");
}
return(w);
}
public static XmlWriterSettings Override(this XmlWriterSettings settings, Action <XmlWriterSettings> overrider)
{
var overriddenSettings = settings.Clone();
overrider(overriddenSettings);
return(overriddenSettings);
}
public static Binding WithSolidHttpTransport(this Binding binding, TestingServer server, XmlWriterSettings writerSettings = null)
{
var settings = writerSettings?.Clone() ?? new XmlWriterSettings();
settings.CloseOutput = false;
var custom = binding as CustomBinding;
if (custom == null)
{
custom = new CustomBinding(binding);
}
var http = custom
.Elements
.OfType <HttpTransportBindingElement>()
.Where(e => e.Scheme == "http" || e.Scheme == "https")
.FirstOrDefault()
;
if (http != null)
{
var solid = new SolidHttpTransportBindingElement(server, settings);
custom.Elements.Remove(http);
custom.Elements.Add(solid);
}
return(custom);
}
public void Clone_1()
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.Encoding = Encoding.UTF8;
wSettings.OmitXmlDeclaration = true;
wSettings.NewLineHandling = NewLineHandling.Entitize;
wSettings.NewLineChars = "\n";
wSettings.IndentChars = " ";
wSettings.NewLineOnAttributes = true;
wSettings.CloseOutput = true;
wSettings.CheckCharacters = false;
wSettings.ConformanceLevel = ConformanceLevel.Document;
wSettings.WriteEndDocumentOnClose = false;
XmlWriterSettings newSettings = wSettings.Clone();
CError.Equals(wSettings.Encoding, newSettings.Encoding, "Encoding");
CError.Equals(wSettings.OmitXmlDeclaration, newSettings.OmitXmlDeclaration, "OmitXmlDeclaration");
CError.Equals(wSettings.NewLineHandling, newSettings.NewLineHandling, "NewLineHandling");
CError.Equals(wSettings.NewLineChars, newSettings.NewLineChars, "NewLineChars");
CError.Equals(wSettings.Indent, newSettings.Indent, "Indent");
CError.Equals(wSettings.IndentChars, newSettings.IndentChars, "IndentChars");
CError.Equals(wSettings.NewLineOnAttributes, newSettings.NewLineOnAttributes, "NewLineOnAttributes");
CError.Equals(wSettings.CloseOutput, newSettings.CloseOutput, "CloseOutput");
CError.Equals(wSettings.CheckCharacters, newSettings.CheckCharacters, "CheckCharacters");
CError.Equals(wSettings.ConformanceLevel, newSettings.ConformanceLevel, "ConformanceLevel");
CError.Equals(wSettings.WriteEndDocumentOnClose, newSettings.WriteEndDocumentOnClose, "WriteEndDocumentOnClose");
}
public AtomFormatter(IEnumerable <ISyndicationAttribute> knownAttributes, XmlWriterSettings settings)
{
_buffer = new StringBuilder();
_writer = XmlUtils.CreateXmlWriter(settings?.Clone() ?? new XmlWriterSettings(),
EnsureAtomNs(knownAttributes ?? Enumerable.Empty <ISyndicationAttribute>()),
_buffer);
}
private static XmlWriterSettings GetWriterSettings(TextWriter writer)
{
var result = _writer_settings.Clone();
result.Encoding = writer.Encoding;
result.NewLineChars = writer.NewLine;
return(result);
}
public object transformToDoc(IXmlDomNode node)
{
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
using (MemoryStream stream = new MemoryStream())
{
XmlWriterSettings settings = GetOutputSettings();
if (settings.Encoding is UTF8Encoding)
{
// no BOM in UTF-8 please!
settings = settings.Clone();
settings.Encoding = new UTF8Encoding(false);
}
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
// transform the document
try
{
TransformToWriter(node.UnderlyingObject, xsltArgumentList, writer);
}
catch (XsltException e)
{
if (e.InnerException != null)
{
// ScriptDiedException etc.
throw e.InnerException;
}
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
catch (InvalidOperationException e)
{
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
}
stream.Seek(0, SeekOrigin.Begin);
// build the resulting XML document
try
{
doc.Load(stream);
}
catch (XmlException e)
{
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
}
return(new DOMDocument(doc));
}
public string GetXML()
{
var s = new StringBuilder();
var x = new XmlWriterSettings();
x.Indent = true;
x.OmitXmlDeclaration = true;
var w = XmlWriter.Create(s, x);
WriteXMLContents(w);
w.Flush();
x.Clone();
return(s.ToString());
}
public LiveLogXMLWriter(Stream output, XmlWriterSettings baseSettings, long maxSizeInBytes)
{
if (maxSizeInBytes > 0 && maxSizeInBytes % 4 != 0)
{
throw new ArgumentException("Max size must be multiple of 4", nameof(maxSizeInBytes));
}
this.output = output;
this.closeOutput = baseSettings.CloseOutput;
this.settings = baseSettings.Clone();
this.settings.CloseOutput = false;
this.settings.Encoding = unicodeEncodingNoBOM;
this.maxSize = maxSizeInBytes;
}
private XmlWriterSettings ToXmlStringSettingsCore(XmlWriterSettings settings)
{
// To support document fragments, lower the conformance level
if (settings == null)
{
return(new XmlWriterSettings {
OmitXmlDeclaration = true,
ConformanceLevel = ConformanceLevel.Auto,
});
}
var result = settings.Clone();
result.ConformanceLevel = ConformanceLevel.Auto;
return(settings);
}
public static XmlWriterSettings Override(this XmlWriterSettings settings, Action <XmlWriterSettings> overrider)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (overrider == null)
{
throw new ArgumentNullException(nameof(overrider));
}
var overriddenSettings = settings.Clone();
overrider(overriddenSettings);
return(overriddenSettings);
}
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);
}
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'Entitize'", Param = NewLineHandling.Entitize, Priority = 2)]
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'Replace'", Param = NewLineHandling.Replace, Priority = 2)]
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'None'", Param = NewLineHandling.None, Priority = 2)]
public int EOF_Handling_19()
{
if (WriterType == WriterType.UTF8WriterIndent || WriterType == WriterType.UnicodeWriterIndent)
{
CError.Skip("skipped");
}
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.NewLineHandling = (NewLineHandling)CurVariation.Param;
wSettings.CheckCharacters = false;
XmlWriter ww = CreateMemWriter(wSettings);
XmlWriterSettings ws = wSettings.Clone();
ws.NewLineHandling = NewLineHandling.Replace;
ws.CheckCharacters = true;
XmlWriter w = WriterHelper.Create(ww, ws);
string NewLines = "\r \n " + nl;
w.WriteStartElement("root");
w.WriteCData(NewLines);
w.WriteChars(NewLines.ToCharArray(), 0, NewLines.Length);
w.WriteEndElement();
w.WriteProcessingInstruction("pi", NewLines);
w.WriteWhitespace(NewLines);
w.WriteComment(NewLines);
w.Dispose();
string expOut;
if ((NewLineHandling)CurVariation.Param == NewLineHandling.Entitize)
{
expOut = "<root><![CDATA[" + NewLines + "]]>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "</root>" + "<?pi " + NewLines + "?>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "<!--" + NewLines + "-->";
}
else
{
expOut = ExpectedOutput("<root><![CDATA[" + NewLines + "]]>" + NewLines + "</root><?pi " + NewLines + "?>" + NewLines + "<!--" + NewLines + "-->", NewLineHandling.Replace, false);
}
VerifyOutput(expOut);
return(TEST_PASS);
}
void DoCloseOutputTest(bool close)
{
XmlWriterSettings tmp = testSettings.Clone();
tmp.CloseOutput = close;
MyStream output = new MyStream();
using (LiveLogXMLWriter livewriter = new LiveLogXMLWriter(output, tmp, 1000))
{
livewriter.BeginWriteMessage(false).WriteString("aaa");
livewriter.EndWriteMessage();
livewriter.BeginWriteMessage(false).WriteString("bbb");
livewriter.EndWriteMessage();
livewriter.BeginWriteMessage(true).WriteString("ccc");
livewriter.EndWriteMessage();
}
Assert.AreEqual(close, output.IsDisposed);
}
public string GetXML()
{
var s = new StringBuilder();
var x = new XmlWriterSettings();
//x.ConformanceLevel= ConformanceLevel.Fragment;
x.Indent = true;
x.OmitXmlDeclaration = true;
var w = XmlWriter.Create(s, x);
WriteXMLContents(w);
w.Flush();
x.Clone();
//#if DEBUG
// System.Diagnostics.Debug.WriteLine(s.ToString());
//#endif
return(s.ToString());
}
public object transformToXml(DOMDocument doc)
{
// writing to a StringWriter would result in forcing UTF-16 encoding
using (MemoryStream stream = new MemoryStream())
{
XmlWriterSettings settings = GetOutputSettings();
if (settings.Encoding is UTF8Encoding)
{
// no BOM in UTF-8 please!
settings = settings.Clone();
settings.Encoding = new UTF8Encoding(false);
}
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
// transform the document
try
{
TransformToWriter(doc.XmlNode, xsltArgumentList, writer);
}
catch (XsltException e)
{
if (e.InnerException != null)
{
// ScriptDiedException etc.
throw e.InnerException;
}
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
catch (InvalidOperationException e)
{
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
}
return(new PhpBytes(stream.ToArray()));
}
}
public IServiceRepository Get(IServiceRepository parameter)
=> parameter.RegisterInstance(Encoding.UTF8)
.RegisterInstance(_names)
.RegisterInstance(_reader.Clone())
.RegisterInstance(_writer.Clone())
.RegisterInstance <IIdentifierFormatter>(IdentifierFormatter.Default)
.RegisterInstance <IReaderFormatter>(ReaderFormatter.Default)
.RegisterInstance <IFormattedContentSpecification>(FormattedContentSpecification.Default)
.RegisterInstance <IListContentsSpecification>(
new ListContentsSpecification(
IsTypeSpecification <
IListInnerContent>
.Default
.And(ElementSpecification
.Default)))
.Register <IInnerContentActivation, XmlInnerContentActivation>()
.Register <IFormatReaderContexts, FormatReaderContexts>()
.Register <IFormatWriters <System.Xml.XmlWriter>, FormatWriters>()
.Register <IXmlReaderFactory, XmlReaderFactory>()
.Register <IFormatReaders <System.Xml.XmlReader>, FormatReaders>()
.Register <IExtendedXmlSerializer, ExtendedXmlSerializer>();
public void EOF_Handling_19(XmlWriterUtils utils, NewLineHandling nlHandling)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.NewLineHandling = nlHandling;
wSettings.CheckCharacters = false;
XmlWriter ww = CreateMemWriter(utils, wSettings);
XmlWriterSettings ws = wSettings.Clone();
ws.NewLineHandling = NewLineHandling.Replace;
ws.CheckCharacters = true;
XmlWriter w = WriterHelper.Create(ww, ws, overrideAsync: true, async: utils.Async);
string NewLines = "\r \n " + Environment.NewLine;
w.WriteStartElement("root");
w.WriteCData(NewLines);
w.WriteChars(NewLines.ToCharArray(), 0, NewLines.Length);
w.WriteEndElement();
w.WriteProcessingInstruction("pi", NewLines);
w.WriteWhitespace(NewLines);
w.WriteComment(NewLines);
w.Dispose();
string expOut;
if (nlHandling == NewLineHandling.Entitize)
{
expOut = "<root><![CDATA[" + NewLines + "]]>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "</root>" + "<?pi " + NewLines + "?>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "<!--" + NewLines + "-->";
}
else
{
expOut = ExpectedOutput("<root><![CDATA[" + NewLines + "]]>" + NewLines + "</root><?pi " + NewLines + "?>" + NewLines + "<!--" + NewLines + "-->", NewLineHandling.Replace, false);
}
VerifyOutput(expOut);
return;
}
private bool TransformInternal(IXPathNavigable input, Stream stream)
{
XmlWriterSettings settings = GetOutputSettings();
if (settings.Encoding is UTF8Encoding)
{
// no BOM in UTF-8 please!
settings = settings.Clone();
settings.Encoding = new UTF8Encoding(false);
}
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
// transform the document
try
{
TransformToWriter(input, xsltArgumentList, writer);
}
catch (XsltException e)
{
if (e.InnerException != null)
{
// ScriptDiedException etc.
throw e.InnerException;
}
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
catch (InvalidOperationException e)
{
PhpException.Throw(PhpError.Warning, e.Message);
return(false);
}
}
return(true);
}
//[Variation(Desc = "NamespaceHandling wrap with OmitDuplicates.Default", Param = NamespaceHandling.Default)]
//[Variation(Desc = "NamespaceHandling wrap with OmitDuplicates.OmitDuplicates", Param = NamespaceHandling.OmitDuplicates)]
public int NS_Handling_4b()
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.NamespaceHandling = (NamespaceHandling)this.CurVariation.Param;
using (XmlWriter ww = CreateMemWriter(wSettings))
{
XmlWriterSettings ws = wSettings.Clone();
ws.NamespaceHandling = NamespaceHandling.OmitDuplicates;
ws.CheckCharacters = true;
using (XmlWriter w = WriterHelper.Create(ww, ws))
{
CError.Compare(w != null, "XmlWriter creation failed");
CError.Compare(w.Settings.NamespaceHandling, (NamespaceHandling)this.CurVariation.Param, "Invalid NamespaceHandling assignment");
}
}
return TEST_PASS;
}
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'Entitize'", Param = NewLineHandling.Entitize, Priority = 2)]
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'Replace'", Param = NewLineHandling.Replace, Priority = 2)]
//[Variation(Desc = "Wrapped writer tests for various types of nodes with 'None'", Param = NewLineHandling.None, Priority = 2)]
public int EOF_Handling_19()
{
if (WriterType == WriterType.UTF8WriterIndent || WriterType == WriterType.UnicodeWriterIndent)
CError.Skip("skipped");
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.NewLineHandling = (NewLineHandling)CurVariation.Param;
wSettings.CheckCharacters = false;
XmlWriter ww = CreateMemWriter(wSettings);
XmlWriterSettings ws = wSettings.Clone();
ws.NewLineHandling = NewLineHandling.Replace;
ws.CheckCharacters = true;
XmlWriter w = WriterHelper.Create(ww, ws);
string NewLines = "\r \n " + nl;
w.WriteStartElement("root");
w.WriteCData(NewLines);
w.WriteChars(NewLines.ToCharArray(), 0, NewLines.Length);
w.WriteEndElement();
w.WriteProcessingInstruction("pi", NewLines);
w.WriteWhitespace(NewLines);
w.WriteComment(NewLines);
w.Dispose();
string expOut;
if ((NewLineHandling)CurVariation.Param == NewLineHandling.Entitize)
expOut = "<root><![CDATA[" + NewLines + "]]>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "</root>" + "<?pi " + NewLines + "?>" + ExpectedOutput(NewLines, NewLineHandling.Entitize, false) + "<!--" + NewLines + "-->";
else
expOut = ExpectedOutput("<root><![CDATA[" + NewLines + "]]>" + NewLines + "</root><?pi " + NewLines + "?>" + NewLines + "<!--" + NewLines + "-->", NewLineHandling.Replace, false);
VerifyOutput(expOut);
return TEST_PASS;
}
private XmlWriter CreateMemWriter(XmlWriterSettings settings)
{
XmlWriterSettings wSettings = settings.Clone();
wSettings.CloseOutput = false;
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = false;
XmlWriter w = null;
switch (WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.WrappedWriter:
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
XmlWriter ww = WriterHelper.Create(_strWriter, wSettings);
w = WriterHelper.Create(ww, wSettings);
break;
case WriterType.CharCheckingWriter:
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
XmlWriter cw = WriterHelper.Create(_strWriter, wSettings);
XmlWriterSettings cws = settings.Clone();
cws.CheckCharacters = true;
w = WriterHelper.Create(cw, cws);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
wSettings.Indent = true;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
wSettings.Indent = true;
if (_strWriter != null)
{
_strWriter.Dispose();
}
_strWriter = new StringWriter();
w = WriterHelper.Create(_strWriter, wSettings);
break;
default:
throw new Exception("Unknown writer type");
}
return(w);
}
public XmlWriter CreateMemWriter(Stream writerStream, XmlWriterSettings settings)
{
XmlWriterSettings wSettings = settings.Clone();
wSettings.CloseOutput = false;
wSettings.OmitXmlDeclaration = true;
wSettings.CheckCharacters = false;
XmlWriter w = null;
switch (WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
w = WriterHelper.Create(writerStream, wSettings);
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
w = WriterHelper.Create(writerStream, wSettings);
break;
case WriterType.WrappedWriter:
XmlWriter ww = WriterHelper.Create(writerStream, wSettings);
w = WriterHelper.Create(ww, wSettings);
break;
case WriterType.CharCheckingWriter:
XmlWriter cw = WriterHelper.Create(writerStream, wSettings);
XmlWriterSettings cws = settings.Clone();
cws.CheckCharacters = true;
w = WriterHelper.Create(cw, cws);
break;
case WriterType.CustomWriter:
w = new CustomWriter(writerStream, wSettings);
break;
case WriterType.UTF8WriterIndent:
wSettings.Encoding = Encoding.UTF8;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings);
break;
case WriterType.UnicodeWriterIndent:
wSettings.Encoding = Encoding.Unicode;
wSettings.Indent = true;
w = WriterHelper.Create(writerStream, wSettings);
break;
default:
throw new Exception("Unknown writer type");
}
return w;
}
//[Variation(id=2, Desc="Test for Clone()", Pri=0)]
public int Clone_1()
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.Encoding = Encoding.UTF8;
wSettings.OmitXmlDeclaration = true;
wSettings.NewLineHandling = NewLineHandling.Entitize;
wSettings.NewLineChars = "\n";
wSettings.IndentChars = " ";
wSettings.NewLineOnAttributes = true;
wSettings.CloseOutput = true;
wSettings.CheckCharacters = false;
wSettings.ConformanceLevel = ConformanceLevel.Document;
wSettings.WriteEndDocumentOnClose = false;
XmlWriterSettings newSettings = wSettings.Clone();
CError.Equals(wSettings.Encoding, newSettings.Encoding, "Encoding");
CError.Equals(wSettings.OmitXmlDeclaration, newSettings.OmitXmlDeclaration, "OmitXmlDeclaration");
CError.Equals(wSettings.NewLineHandling, newSettings.NewLineHandling, "NewLineHandling");
CError.Equals(wSettings.NewLineChars, newSettings.NewLineChars, "NewLineChars");
CError.Equals(wSettings.Indent, newSettings.Indent, "Indent");
CError.Equals(wSettings.IndentChars, newSettings.IndentChars, "IndentChars");
CError.Equals(wSettings.NewLineOnAttributes, newSettings.NewLineOnAttributes, "NewLineOnAttributes");
CError.Equals(wSettings.CloseOutput, newSettings.CloseOutput, "CloseOutput");
CError.Equals(wSettings.CheckCharacters, newSettings.CheckCharacters, "CheckCharacters");
CError.Equals(wSettings.ConformanceLevel, newSettings.ConformanceLevel, "ConformanceLevel");
CError.Equals(wSettings.WriteEndDocumentOnClose, newSettings.WriteEndDocumentOnClose, "WriteEndDocumentOnClose");
return TEST_PASS;
}
XmlWriter CreateWriterImpl()
{
this.CleanUp();
switch (writerType1)
{
case WriterType.UTF8Writer:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
_wSettings.Encoding = Encoding.UTF8;
_wSettings.NamespaceHandling = NamespaceHandling.Default;
_xmlWriter = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
break;
case WriterType.UnicodeWriter:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
_wSettings.Encoding = Encoding.Unicode;
_wSettings.NamespaceHandling = NamespaceHandling.OmitDuplicates;
_xmlWriter = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
break;
case WriterType.CustomWriter:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
if (_overrideAsync)
{
_wSettings.Async = _async;
}
_xmlWriter = new CustomWriter(_writerStream, _wSettings);
FilePathUtil.addStream(_fileName, _writerStream);
break;
case WriterType.UTF8WriterIndent:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
_wSettings.Encoding = Encoding.UTF8;
_wSettings.Indent = true;
_xmlWriter = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
break;
case WriterType.UnicodeWriterIndent:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
_wSettings.Encoding = Encoding.Unicode;
_wSettings.Indent = true;
_xmlWriter = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
break;
case WriterType.CharCheckingWriter:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
_wSettings.CheckCharacters = false;
XmlWriter ww = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
XmlWriterSettings ws = _wSettings.Clone();
ws.CheckCharacters = true;
_xmlWriter = WriterHelper.Create(ww, ws, _overrideAsync, _async);
break;
case WriterType.WrappedWriter:
_writerStream = new MemoryStream();
_wSettings.CloseOutput = false;
XmlWriter w = WriterHelper.Create(_writerStream, _wSettings, _overrideAsync, _async);
FilePathUtil.addStream(_fileName, _writerStream);
_xmlWriter = WriterHelper.Create(w, _wSettings, _overrideAsync, _async);
break;
default:
throw new Exception("Incorrect writer type");
}
return(_xmlWriter);
}
public RssFormatter(IEnumerable <ISyndicationAttribute> knownAttributes, XmlWriterSettings settings)
{
_buffer = new StringBuilder();
_writer = XmlUtils.CreateXmlWriter(settings?.Clone() ?? new XmlWriterSettings(), knownAttributes, _buffer);
}
