public void NewLineOnAttributes_2(XmlWriterUtils utils)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            wSettings.OmitXmlDeclaration  = true;
            wSettings.Indent              = true;
            wSettings.NewLineOnAttributes = true;

            XmlWriter w = utils.CreateWriter(wSettings);

            CError.Compare(w.Settings.NewLineOnAttributes, true, "Mismatch in NewLineOnAttributes");

            w.WriteStartElement("root");
            w.WriteAttributeString("attr1", "value1");
            w.WriteAttributeString("attr2", "value2");
            w.WriteEndElement();
            w.Dispose();

            Assert.True(utils.CompareString("<root" + wSettings.NewLineChars + "  attr1=\"value1\"" + wSettings.NewLineChars + "  attr2=\"value2\" />"));
        }
Beispiel #2
0
        public override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
        {
            MemoryStream memoryStream = new MemoryStream();
            XmlWriter    xmlWriter    = XmlWriter.Create(memoryStream, this.xmlSettings);

            message.WriteMessage(xmlWriter);
            xmlWriter.Flush();
            xmlWriter.Dispose();
            byte[] buffer = memoryStream.GetBuffer();
            int    num    = (int)memoryStream.Position;

            memoryStream.Dispose();
            int bufferSize = num + messageOffset;

            byte[] array = bufferManager.TakeBuffer(bufferSize);
            Array.Copy(buffer, 0, array, messageOffset, num);
            ArraySegment <byte> result = new ArraySegment <byte>(array, messageOffset, num);

            return(result);
        }
Beispiel #3
0
        public void writeNode_XmlReader36(XmlWriterUtils utils, bool defattr)
        {
            string strxml = "<Ro\u00F6t \u00F6=\"\u00F6\" />";
            string exp    = strxml;

            XmlReader xr = CreateReader(new StringReader(strxml));

            XmlWriterSettings ws = new XmlWriterSettings();

            ws.OmitXmlDeclaration = true;
            XmlWriter w = utils.CreateWriter(ws);

            while (!xr.EOF)
            {
                w.WriteNode(xr, defattr);
            }
            xr.Dispose();
            w.Dispose();
            Assert.True(utils.CompareString(exp));
        }
Beispiel #4
0
        public void EOF_Handling_16(XmlWriterUtils utils, NewLineHandling nlHandling, string newLineChars)
        {
            XmlWriterSettings wSettings       = new XmlWriterSettings();
            string            PrototypeOutput = "<root&NewLine  foo=\"fooval\"&NewLine  bar=\"barval\" />";

            wSettings.NewLineHandling     = nlHandling;
            wSettings.Indent              = true;
            wSettings.NewLineChars        = newLineChars;
            wSettings.NewLineOnAttributes = true;

            XmlWriter w = CreateMemWriter(utils, wSettings);

            w.WriteStartElement("root");
            w.WriteAttributeString("foo", "fooval");
            w.WriteAttributeString("bar", "barval");
            w.WriteEndElement();
            w.Dispose();

            VerifyOutput(PrototypeOutput.Replace("&NewLine", newLineChars));
        }
Beispiel #5
0
        //[Variation(Desc = "16.Test fo proper indentation and newline handling when Indent = true, with custom NewLineChars and IndentChars; Entitize, '\uDE40\uDA72', '\uDE40\uDA72'", Params = new object[] { NewLineHandling.Entitize })]
        //[Variation(Desc = "17.Test fo proper indentation and newline handling when Indent = true, with custom NewLineChars and IndentChars; Replace, '\uDE40\uDA72', '\uDE40\uDA72'", Params = new object[] { NewLineHandling.Replace })]
        //[Variation(Desc = "18.Test fo proper indentation and newline handling when Indent = true, with custom NewLineChars and IndentChars; None, '\uDE40\uDA72', '\uDE40\uDA72'", Params = new object[] { NewLineHandling.None })]
        public int EOF_Handling_22()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            wSettings.NewLineHandling = (NewLineHandling)CurVariation.Params[0];
            wSettings.Indent          = true;
            wSettings.NewLineChars    = "\uDE40\uDA72";
            wSettings.IndentChars     = "\uDE40\uDA72";

            XmlWriter w = CreateMemWriter(wSettings);

            try
            {
                w.WriteStartElement("root");
                w.WriteStartElement("foo");
                w.Dispose();
            }
            catch (ArgumentException e) { CError.WriteLine(e.Message); return(TEST_PASS); }
            return(TEST_FAIL);
        }
Beispiel #6
0
        public void EOF_Handling_22(XmlWriterUtils utils, NewLineHandling nlHandling)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            wSettings.NewLineHandling = nlHandling;
            wSettings.Indent          = true;
            wSettings.NewLineChars    = "\uDE40\uDA72";
            wSettings.IndentChars     = "\uDE40\uDA72";

            XmlWriter w = CreateMemWriter(utils, wSettings);

            try
            {
                w.WriteStartElement("root");
                w.WriteStartElement("foo");
                w.Dispose();
            }
            catch (ArgumentException e) { CError.WriteLine(e.Message); return; }
            Assert.True(false);
        }
Beispiel #7
0
        //[Variation(Desc = "write start element and then close when the WriteEndDocumentOnClose = false", Pri = 1, Params = new object[] { false, "<root>" })]
        //[Variation(Desc = "write start element and then close when the WriteEndDocumentOnClose = true", Pri = 1, Params = new object[] { true, "<root />" })]
        public int TestWriteEndDocumentOnCoseForOneElement()
        {
            bool              writeEndDocument = (bool)CurVariation.Params[0];
            string            expected         = (string)CurVariation.Params[1];
            StringWriter      output           = new StringWriter();
            XmlWriterSettings ws = new XmlWriterSettings();

            ws.OmitXmlDeclaration      = true;
            ws.WriteEndDocumentOnClose = writeEndDocument;
            XmlWriter writer = XmlWriter.Create(output, ws);

            writer.WriteStartElement("root");
            writer.Dispose();

            string act = output.ToString();

            CError.Compare(act, expected, "FAILED: when one start element and WriteEndDocumentOnClose = " + ws.WriteEndDocumentOnClose + ", expected: " + expected + ", received: " + act);

            return(TEST_PASS);
        }
Beispiel #8
0
                //[Variation(Id = 3, Desc = "Attributes of nested elements", Priority = 1)]
                public void NewLineOnAttributes_3()
                {
                    XDocument d = new XDocument();
                    XmlWriter w = d.CreateWriter();

                    w.WriteStartElement("level1");
                    w.WriteAttributeString("attr1", "value1");
                    w.WriteAttributeString("attr2", "value2");
                    w.WriteStartElement("level2");
                    w.WriteAttributeString("attr1", "value1");
                    w.WriteAttributeString("attr2", "value2");
                    w.WriteEndElement();
                    w.WriteEndElement();
                    w.Dispose();

                    if (!CompareBaseline(d, "NewLineOnAttributes3.txt"))
                    {
                        throw new TestException(TestResult.Failed, "");
                    }
                }
Beispiel #9
0
        public void auto_8(XmlWriterUtils utils)
        {
            XmlWriter w = utils.CreateWriter(ConformanceLevel.Auto);

            string            strxml    = "<!DOCTYPE test [<!ENTITY e 'abc'>]><Root />";
            XmlReaderSettings rSettings = new XmlReaderSettings();

            rSettings.CloseInput    = true;
            rSettings.DtdProcessing = DtdProcessing.Parse;
            XmlReader xr = ReaderHelper.Create(new StringReader(strxml), rSettings, (string)null);

            CError.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Auto, "Error");
            xr.Read();
            CError.Compare(xr.NodeType.ToString(), "DocumentType", "Error");
            w.WriteNode(xr, false);
            CError.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
            w.Dispose();
            xr.Dispose();
            return;
        }
Beispiel #10
0
        public void Save <T>(T t)
        {
            XmlSerializer     xs       = new XmlSerializer(typeof(T));
            MemoryStream      stream   = new MemoryStream();
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent       = true;
            settings.NewLineChars = "\r\n";

            using (XmlWriter writer = XmlWriter.Create(_xml, settings))
            {
                var xns = new XmlSerializerNamespaces();

                xns.Add(string.Empty, string.Empty);
                //去除默认命名空间
                xs.Serialize(writer, t, xns);
                writer.Close();
                writer.Dispose();
            }
        }
Beispiel #11
0
        public void Dispose()
        {
            if (writer != null)
            {
#if !WINDOWS_UWP
                writer.Close();
#else
                writer.Dispose();
#endif
                writer = null;
            }
            if (stream != null)
            {
#if !WINDOWS_UWP
                stream.Close();
#endif
                stream.Dispose();
                stream = null;
            }
        }
Beispiel #12
0
        public void CloseOutput_1(XmlWriterUtils utils, string outputType)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            XmlWriter         w         = null;

            switch (utils.WriterType)
            {
            case WriterType.UTF8Writer:
                wSettings.Encoding = Encoding.UTF8;
                break;

            case WriterType.UnicodeWriter:
                wSettings.Encoding = Encoding.Unicode;
                break;
            }
            Stream writerStream = new MemoryStream();

            switch (outputType)
            {
            case "Stream":
                w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
                break;

            case "Textwriter":
                StreamWriter tw = new StreamWriter(writerStream, wSettings.Encoding);
                w = WriterHelper.Create(tw, wSettings, overrideAsync: true, async: utils.Async);
                break;
            }

            w.WriteStartElement("root");
            w.WriteEndElement();
            w.Dispose();

            if (writerStream.CanWrite)
            {
                writerStream.Dispose();
                return;
            }
            CError.WriteLine("Error: XmlWriter closed the stream when CloseOutput = false");
            Assert.True(false);
        }
Beispiel #13
0
                //[Variation(Id = 2, Desc = "Change to CL Document after WriteStartDocument(standalone = true)", Priority = 0, Param = "true")]
                //[Variation(Id = 3, Desc = "Change to CL Document after WriteStartDocument(standalone = false)", Priority = 0, Param = "false")]
                public void auto_2()
                {
                    XDocument d = new XDocument();
                    XmlWriter w = d.CreateWriter();

                    switch (Variation.Param.ToString())
                    {
                    case "true":
                        w.WriteStartDocument(true);
                        break;

                    case "false":
                        w.WriteStartDocument(false);
                        break;
                    }
                    // PROLOG
                    TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
                    w.WriteStartElement("root");
                    // ELEMENT CONTENT
                    TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
                    // Inside Attribute
                    w.WriteStartAttribute("attr");
                    TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Document, "Error");
                    w.WriteEndElement();

                    // Try writing another root element, should error
                    try
                    {
                        w.WriteStartElement("root");
                    }
                    catch (InvalidOperationException)
                    {
                        return;
                    }
                    finally
                    {
                        w.Dispose();
                    }
                    TestLog.WriteLine("Conformance level = Document did not take effect");
                    throw new TestException(TestResult.Failed, "");
                }
Beispiel #14
0
        public static CamlQuery CreateAllItemsQuery(int rowLimit, params string[] viewFields)
        {
            if (rowLimit <= 0)
            {
                throw new ArgumentOutOfRangeException("rowLimit");
            }
            if (viewFields == null)
            {
                throw new ArgumentNullException("viewFields");
            }
            CamlQuery     camlQuery     = new CamlQuery();
            StringBuilder stringBuilder = new StringBuilder();
            XmlWriter     xmlWriter     = XmlWriter.Create(stringBuilder, new XmlWriterSettings
            {
                OmitXmlDeclaration = true
            });

            xmlWriter.WriteStartElement("View");
            xmlWriter.WriteAttributeString("Scope", "RecursiveAll");
            if (viewFields.Length > 0)
            {
                xmlWriter.WriteStartElement("ViewFields");
                for (int i = 0; i < viewFields.Length; i++)
                {
                    string value = viewFields[i];
                    if (!string.IsNullOrEmpty(value))
                    {
                        xmlWriter.WriteStartElement("FieldRef");
                        xmlWriter.WriteAttributeString("Name", value);
                        xmlWriter.WriteEndElement();
                    }
                }
                xmlWriter.WriteEndElement();
            }
            xmlWriter.WriteElementString("RowLimit", rowLimit.ToString(CultureInfo.InvariantCulture));
            xmlWriter.WriteEndElement();
            //Edited for .NET Core
            xmlWriter.Dispose();//.Close();
            camlQuery.ViewXml = stringBuilder.ToString();
            return(camlQuery);
        }
        /// <summary>
        /// Returns the schema for the specified type (returns the entire schema if null).
        /// </summary>
        public override string GetSchema(string typeName)
        {
            XmlWriterSettings settings = Utils.DefaultXmlWriterSettings();

            MemoryStream ostrm  = new MemoryStream();
            XmlWriter    writer = XmlWriter.Create(ostrm, settings);

            try
            {
                if (typeName == null || m_schema.Elements.Values.Count == 0)
                {
                    m_schema.Write(writer);
                }
                else
                {
                    foreach (XmlSchemaObject current in m_schema.Elements.Values)
                    {
                        XmlSchemaElement element = current as XmlSchemaElement;

                        if (element != null)
                        {
                            if (element.Name == typeName)
                            {
                                XmlSchema schema = new XmlSchema();
                                schema.Items.Add(element.ElementSchemaType);
                                schema.Items.Add(element);
                                schema.Write(writer);
                                break;
                            }
                        }
                    }
                }
            }
            finally
            {
                writer.Flush();
                writer.Dispose();
            }

            return(new UTF8Encoding().GetString(ostrm.ToArray()));
        }
Beispiel #16
0
        public void CloseOutput_2(XmlWriterUtils utils, bool closeOutput)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            switch (utils.WriterType)
            {
            case WriterType.UTF8Writer:
                wSettings.Encoding = Encoding.UTF8;
                break;

            case WriterType.UnicodeWriter:
                wSettings.Encoding = Encoding.Unicode;
                break;
            }
            wSettings.CloseOutput = closeOutput;

            XmlWriter w = WriterHelper.Create("writer.out", wSettings, overrideAsync: true, async: utils.Async);

            w.WriteStartElement("root");
            w.WriteEndElement();
            w.Dispose();

            // Check if you can open the file in ReadWrite mode
            Stream fs = null;

            try
            {
                fs = FilePathUtil.getStream("writer.out");/*new FileStream("writer.out", FileMode.Open, FileAccess.ReadWrite);*/
            }
            catch (Exception e)
            {
                CError.WriteLineIgnore("Exception: " + e.ToString());
                CError.WriteLine("Uri stream is not closed by writer");
                Assert.True(false);
            }
            finally
            {
                fs.Dispose();
            }
            return;
        }
Beispiel #17
0
        public static string GetString(this XmlDocument xmlDocument)
        {
            if (xmlDocument == null)
            {
                throw new ArgumentNullException(nameof(xmlDocument));
            }

            var settings = new XmlWriterSettings
            {
                Encoding           = new UTF8Encoding(false, false),
                Indent             = true,
                OmitXmlDeclaration = false
            };

            string output;
            StringWriterExtended textWriter = null;
            XmlWriter            xmlWriter  = null;

            try
            {
                textWriter = new StringWriterExtended(Encoding.UTF8, CultureInfo.InvariantCulture);
                xmlWriter  = XmlWriter.Create(textWriter, settings);
                xmlDocument.Save(textWriter);
                output = textWriter.ToString();
            }
            finally
            {
                if (xmlWriter != null)
                {
#if NET45_OR_GREATER
                    xmlWriter.Dispose();
#endif
                }
                else
                {
                    textWriter?.Dispose();
                }
            }

            return(output);
        }
Beispiel #18
0
        /// <summary>
        /// Asynchronously creates the XML reader.
        /// </summary>
        /// <returns>
        /// A <see cref="Task"/> that represents the asynchronous create reader operation.
        /// </returns>
        private Task CreateXmlAsync()
        {
            _current = new XDocument();

            if (_reader != null)
            {
                _reader.Dispose();
            }
            if (_writer != null)
            {
                _writer.Dispose();
            }

            _reader = XmlReader.Create(_stream, new XmlReaderSettings()
            {
                Async                        = true,
                CheckCharacters              = true,
                CloseInput                   = false,
                ConformanceLevel             = ConformanceLevel.Document,
                DtdProcessing                = DtdProcessing.Prohibit,
                IgnoreComments               = true,
                IgnoreWhitespace             = true,
                IgnoreProcessingInstructions = true
            });

            _writer = XmlWriter.Create(_stream, new XmlWriterSettings()
            {
                Async                   = true,
                CheckCharacters         = true,
                CloseOutput             = false,
                ConformanceLevel        = ConformanceLevel.Document,
                Indent                  = false,
                NamespaceHandling       = NamespaceHandling.OmitDuplicates,
                NewLineOnAttributes     = false,
                OmitXmlDeclaration      = false,
                WriteEndDocumentOnClose = false,
                Encoding                = new UTF8Encoding(false)
            });

            return(_client.OnStreamResetAsync());
        }
        public static void Serialize <T>(string filePath, T obj, params Type[] additionalTypes)
        {
            XmlWriter writer = XmlWriter.Create(new FileStream(filePath, FileMode.Create, FileAccess.Write), WriteSettings);

            try
            {
                DataContractSerializer serializer =
                    new DataContractSerializer(typeof(T), additionalTypes);
                serializer.WriteObject(writer, obj);
            }
            catch (Exception e)
            {
                Log4NetService.Instance.GetLogger <MainWindow>().Error("An error occurred while saving the " +
                                                                       $"{typeof(T).FullName}", e);
                MessageBox.Show("Saving error", "Something went wrong", MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                writer.Dispose();
            }
        }
Beispiel #20
0
        public void indent_17(XmlWriterUtils utils)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            wSettings.OmitXmlDeclaration = true;
            wSettings.Indent             = true;

            XmlWriter w = utils.CreateWriter(wSettings);

            w.WriteStartElement("e1");
            w.WriteStartElement("e2");
            w.WriteStartElement("e3");
            w.WriteStartElement("e4");
            w.WriteFullEndElement();
            w.WriteFullEndElement();
            w.WriteFullEndElement();
            w.WriteFullEndElement();
            w.Dispose();
            CError.Compare(utils.CompareString("<e1>" + wSettings.NewLineChars + "  <e2>" + wSettings.NewLineChars + "    <e3>" + wSettings.NewLineChars + "      <e4></e4>" + wSettings.NewLineChars + "    </e3>" + wSettings.NewLineChars + "  </e2>" + wSettings.NewLineChars + "</e1>"), "");
            return;
        }
                //[Variation(Desc = "Check for tab character in attribute with 'Entitize'", Param = NewLineHandling.Entitize, Id = 26, Priority = 0)]
                //[Variation(Desc = "Check for tab character in attribute with 'Replace'", Param = NewLineHandling.Replace, Id = 27, Priority = 0)]
                //[Variation(Desc = "Check for tab character in attribute with 'None'", Param = NewLineHandling.None, Id = 28, Priority = 0)]
                public void EOF_Handling_10()
                {
                    string    Tabs = "foo\tbar&#x9;foo\n\tbar\t\n\t";
                    XDocument d    = new XDocument();
                    XmlWriter w    = CreateWriter(d);

                    w.WriteStartElement("root");
                    w.WriteStartAttribute("foo");

                    w.WriteString("foo\tbar");
                    w.WriteCharEntity('\t');
                    w.WriteString("foo\n\tbar\t\n\t");

                    w.WriteEndAttribute();
                    w.WriteEndElement();
                    w.Dispose();
                    if (!CompareReader(d, "<root foo=\"" + ExpectedOutput(Tabs, (NewLineHandling)Variation.Param, true) + "\" />"))
                    {
                        throw new TestException(TestResult.Failed, "");
                    }
                }
Beispiel #22
0
        public void Store(string FilePath)
        {
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent      = true;
            settings.IndentChars = "\t";
            XmlWriter writer = XmlWriter.Create(FilePath, settings);

            writer.WriteStartDocument();
            writer.WriteStartElement("ControlPresets");

            foreach (PresetGroup preset in Presets.Values)
            {
                preset.Store(writer);
            }

            writer.WriteEndElement();
            writer.WriteEndDocument();

            writer.Dispose();
        }
        public ClientActionSetProperty(ClientObject obj, string propName, object propValue) : base(ClientRuntimeContext.GetContextFromClientObject(obj), (obj == null) ? null : obj.Path, propName)
        {
            if (obj == null)
            {
                throw new ArgumentNullException("obj");
            }
            if (obj.Path == null || !obj.Path.IsValid)
            {
                throw new ClientRequestException(Resources.GetString("NoObjectPathAssociatedWithObject"));
            }
            ClientAction.CheckActionParameterInContext(obj.Context, propValue);
            this.m_propName             = propName;
            this.m_propValue            = propValue;
            this.m_serializationContext = new SerializationContext(obj.Context);
            this.m_sb = new ChunkStringBuilder();
            XmlWriter xmlWriter = this.m_sb.CreateXmlWriter();

            this.WriteToXmlPrivate(xmlWriter, this.m_serializationContext);
            xmlWriter.Dispose();//.Close();
            this.m_propValue = null;
        }
Beispiel #24
0
        public void element_10c(XmlWriterUtils utils)
        {
            XmlWriter w = utils.CreateWriter();

            w.WriteDocType("a", null, null, "<!ATTLIST Root a (val|value) \"val\">");
            w.WriteStartElement("Root");
            for (int i = 0; i < 200; i++)
            {
                w.WriteAttributeString("p", "a", "n" + i, "val");
            }
            try
            {
                w.WriteAttributeString("p", "a", "n" + 199, "val");
            }
            catch (XmlException) { return; }
            finally
            {
                w.Dispose();
            }
            Assert.True(false);
        }
 public override void Close()
 {
     if (_writer != null)
     {
         try
         {
             _writer.Flush();
         }
         finally
         {
             try
             {
                 _writer.Dispose();
             }
             finally
             {
                 _writer = null;
             }
         }
     }
 }
        public void EOF_Handling_11(XmlWriterUtils utils, NewLineHandling nlHandling)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();

            wSettings.NewLineHandling = nlHandling;
            wSettings.Indent          = true;

            XmlWriter w = CreateMemWriter(utils, wSettings);

            CError.Compare(w.Settings.NewLineChars, Environment.NewLine, "Incorrect default value for XmlWriter.Settings.NewLineChars");
            CError.Compare(w.Settings.IndentChars, "  ", "Incorrect default value for XmlWriter.Settings.IndentChars");

            w.WriteStartElement("root");
            w.WriteStartElement("foo");
            w.WriteElementString("bar", "");
            w.WriteEndElement();
            w.WriteEndElement();
            w.Dispose();

            VerifyOutput(string.Format("<root>{0}  <foo>{0}    <bar />{0}  </foo>{0}</root>", Environment.NewLine));
        }
Beispiel #27
0
        public async void Write(string path)
        {
            IFile file = await FileSystem.Current.LocalStorage.CreateFileAsync(path, CreationCollisionOption.ReplaceExisting);

            XmlWriterSettings settings = new XmlWriterSettings();

            settings.CloseOutput = true;
            XmlWriter writer = XmlWriter.Create(await file.OpenAsync(FileAccess.ReadAndWrite), settings);

            writer.WriteStartDocument();
            writer.WriteStartElement("Tasks");

            for (int i = 0; i < tasks.Count; i++)
            {
                tasks[i].WriteXML(writer);
            }

            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Dispose();
        }
        public void EOF_Handling_06(XmlWriterUtils utils, NewLineHandling nlHandling)
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            string            Tabs      = "foo\tbar&#x9;foo\n\tbar\t\n\t";

            wSettings.NewLineHandling = nlHandling;

            XmlWriter w = CreateMemWriter(utils, wSettings);

            w.WriteStartElement("root");

            w.WriteString("foo\tbar");
            w.WriteCharEntity('\t');
            w.WriteString("foo\n\tbar\t\n\t");

            w.WriteEndElement();
            w.Dispose();
            VerifyOutput("<root>" + ExpectedOutput(Tabs, nlHandling, false) + "</root>");

            return;
        }
        //[Variation(Desc = "Check for tab character in element with 'Entitize'", Param = NewLineHandling.Entitize, id = 14, Pri = 0)]
        //[Variation(Desc = "Check for tab character in element with 'Replace'", Param = NewLineHandling.Replace, id = 15, Pri = 0)]
        //[Variation(Desc = "Check for tab character in element with 'None'", Param = NewLineHandling.None, id = 16, Pri = 0)]
        public int EOF_Handling_06()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            string            Tabs      = "foo\tbar&#x9;foo\n\tbar\t\n\t";

            wSettings.NewLineHandling = (NewLineHandling)CurVariation.Param;

            XmlWriter w = CreateMemWriter(wSettings);

            w.WriteStartElement("root");

            w.WriteString("foo\tbar");
            w.WriteCharEntity('\t');
            w.WriteString("foo\n\tbar\t\n\t");

            w.WriteEndElement();
            w.Dispose();
            VerifyOutput("<root>" + ExpectedOutput(Tabs, (NewLineHandling)CurVariation.Param, false) + "</root>");

            return(TEST_PASS);
        }
Beispiel #30
0
        public NSAttributedString ToAttributedString()
        {
            xmlWriter.WriteEndElement();              // body
            xmlWriter.WriteEndElement();              // html
            xmlWriter.Flush();
            if (text == null || text.Length == 0)
            {
                return(new NSAttributedString(String.Empty));
            }

            NSDictionary docAttributes;

            try {
                return(CreateStringFromHTML(text.ToString(), out docAttributes));
            } finally {
                text = null;
                xmlWriter.Dispose();
                xmlWriter     = null;
                docAttributes = null;
            }
        }
Beispiel #31
0
        private bool Diff()
        {
            bool flag = false;
            XmlWriterSettings xws = new XmlWriterSettings();
            xws.ConformanceLevel = ConformanceLevel.Auto;
            xws.CheckCharacters = false;
            _Writer = XmlWriter.Create(new StringWriter(_Output), xws);
            _Writer.WriteStartElement(String.Empty, "Root", String.Empty);

            flag = CompareChildren(this._SourceDoc, this._TargetDoc);

            _Writer.WriteEndElement();
            _Writer.Dispose();
            return flag;
        }
Beispiel #32
0
 // base for following methods
 private static void WriteElement(XmlWriter writer, string prefix, string localName, string namespaceURI, string value)
 {
     writer.WriteStartElement(prefix, localName, namespaceURI);
     if (value != null)
     {
         writer.WriteString(value);
     }
     writer.WriteEndElement();
     writer.Dispose();
 }