//[Variation(Desc = "XElement: Settings after Close()", Priority = 1)] public void var_4() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); w.Dispose(); TestLog.Equals(w.Settings.Encoding.ToString(), "System.Text.UTF8Encoding", "Incorrect default value of Encoding"); TestLog.Equals(w.Settings.OmitXmlDeclaration, false, "Incorrect default value of OmitXmlDeclaration"); TestLog.Equals(w.Settings.NewLineHandling, NewLineHandling.Replace, "Incorrect default value of NewLineHandling"); TestLog.Equals(w.Settings.NewLineChars, Environment.NewLine, "Incorrect default value of NewLineChars"); TestLog.Equals(w.Settings.Indent, false, "Incorrect default value of Indent"); TestLog.Equals(w.Settings.IndentChars, " ", "Incorrect default value of IndentChars"); TestLog.Equals(w.Settings.NewLineOnAttributes, false, "Incorrect default value of NewLineOnAttributes"); TestLog.Equals(w.Settings.CloseOutput, false, "Incorrect default value of CloseOutput"); TestLog.Equals(w.Settings.CheckCharacters, true, "Incorrect default value of CheckCharacters"); TestLog.Equals(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Incorrect default value of ConformanceLevel"); }
XDocument Serialize() { var x = new XDocument(); var e = new XElement("root"); x.Add(e); var l1 = new TestEventListener(); var l2 = new TestEventListener(); using (var w = e.CreateWriter()) { w.WriteWhitespace(""); var s = new EventTargetState(); s.registrations.Add(new EventListenerRegistration("event1", l1, false)); s.registrations.Add(new EventListenerRegistration("event2", l1, true)); s.registrations.Add(new EventListenerRegistration("event1", l2, false)); s.registrations.Add(new EventListenerRegistration("event2", l2, true)); new XmlSerializer(s.GetType()).Serialize(w, s); } return x; }
//[Variation(Id = 6, Desc = "Change to CL Fragment for WriteString at top level", Priority = 1, Param = "String")] //[Variation(Id = 7, Desc = "Change to CL Fragment for WriteCData at top level", Priority = 1, Param = "CData")] //[Variation(Id = 9, Desc = "Change to CL Fragment for WriteCharEntity at top level", Priority = 1, Param = "CharEntity")] //[Variation(Id = 10, Desc = "Change to CL Fragment for WriteSurrogateCharEntity at top level", Priority = 1, Param = "SurrogateCharEntity")] //[Variation(Id = 11, Desc = "Change to CL Fragment for WriteChars at top level", Priority = 1, Param = "Chars")] //[Variation(Id = 12, Desc = "Change to CL Fragment for WriteRaw at top level", Priority = 1, Param = "Raw")] //[Variation(Id = 14, Desc = "Change to CL Fragment for WriteBinHex at top level", Priority = 1, Param = "BinHex")] public void auto_5() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); byte[] buffer = new byte[10]; switch (Variation.Param.ToString()) { case "String": w.WriteString("text"); break; case "CData": w.WriteCData("cdata text"); break; case "CharEntity": w.WriteCharEntity('\uD23E'); break; case "SurrogateCharEntity": w.WriteSurrogateCharEntity('\uDF41', '\uD920'); break; case "Chars": string s = "test"; char[] buf = s.ToCharArray(); w.WriteChars(buf, 0, 1); break; case "Raw": w.WriteRaw("<Root />"); break; case "BinHex": w.WriteBinHex(buffer, 0, 1); break; default: TestLog.Compare(false, "Invalid param in testcase"); break; } TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Error"); w.Dispose(); }
//[Variation(Id = 5, Desc = "Change to CL Fragment when you write a root element", Priority = 1)] public void auto_4() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); w.WriteStartElement("root"); TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Error"); w.WriteEndElement(); TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Error"); w.WriteStartElement("root"); w.WriteEndElement(); w.Dispose(); }
//[Variation(Id = 2, Desc = "WriteStartDocument() should error when CL=fragment", Priority = 1)] public void frag_2() { XElement d = new XElement("a"); using (XmlWriter w = d.CreateWriter()) { try { w.WriteStartDocument(); } catch (InvalidOperationException) { TestLog.Compare(w.WriteState, WriteState.Error, "WriteState should be Error"); return; } } TestLog.WriteLine("Did not throw exception"); throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 1, Desc = "WriteDocType should error when CL=fragment", Priority = 1)] public void frag_1() { XElement d = new XElement("a"); using (XmlWriter w = d.CreateWriter()) { try { w.WriteDocType("ROOT", "publicid", "sysid", "<!ENTITY e 'abc'>"); } catch (InvalidOperationException) { TestLog.Compare(w.WriteState, WriteState.Error, "WriteState should be Error"); return; } } TestLog.WriteLine("Did not throw exception"); throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 1, Desc = "CheckChars=true, invalid XML test WriteEntityRef", Priority = 1, Param = "EntityRef")] //[Variation(Id = 2, Desc = "CheckChars=true, invalid XML test WriteSurrogateCharEntity", Priority = 1, Param = "SurrogateCharEntity")] //[Variation(Id = 3, Desc = "CheckChars=true, invalid XML test WriteWhitespace", Priority = 1, Param = "Whitespace")] //[Variation(Id = 4, Desc = "CheckChars=true, invalid name chars WriteDocType(name)", Priority = 1, Param = "WriteDocTypeName")] public void checkChars_1() { char[] invalidXML = { '\u0000', '\u0008', '\u000B', '\u000C', '\u000E', '\u001F', '\uFFFE', '\uFFFF' }; XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); try { switch (Variation.Param.ToString()) { 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: TestLog.Compare(false, "Invalid param value"); break; } } catch (XmlException) { TestLog.Compare(w.WriteState, WriteState.Error, "WriteState should be Error"); return; } catch (ArgumentException) { TestLog.Compare(w.WriteState, WriteState.Error, "WriteState should be Error"); return; } finally { w.Dispose(); } throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 40, Desc = "CheckChars=false, invalid XML characters in WriteWhitespace should error", Priority = 1, Params = new object[] { "Whitespace", false })] //[Variation(Id = 41, Desc = "CheckChars=false, invalid XML characters in WriteSurrogateCharEntity should error", Priority = 1, Params = new object[] { "Surrogate", false })] //[Variation(Id = 42, Desc = "CheckChars=false, invalid XML characters in WriteEntityRef should error", Priority = 1, Params = new object[] { "EntityRef", false })] //[Variation(Id = 43, Desc = "CheckChars=false, invalid XML characters in WriteQualifiedName should error", Priority = 1, Params = new object[] { "QName", false })] //[Variation(Id = 44, Desc = "CheckChars=true, invalid XML characters in WriteWhitespace should error", Priority = 1, Params = new object[] { "Whitespace", true })] //[Variation(Id = 45, Desc = "CheckChars=true, invalid XML characters in WriteSurrogateCharEntity should error", Priority = 1, Params = new object[] { "Surrogate", true })] //[Variation(Id = 46, Desc = "CheckChars=true, invalid XML characters in WriteEntityRef should error", Priority = 1, Params = new object[] { "EntityRef", true })] //[Variation(Id = 47, Desc = "CheckChars=true, invalid XML characters in WriteQualifiedName should error", Priority = 1, Params = new object[] { "QName", true })] public void checkChars_4() { char[] invalidXML = { '\u0000', '\u0008', '\u000B', '\u000C', '\u000E', '\u001F', '\uFFFE', '\uFFFF' }; XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); try { w.WriteStartElement("Root"); switch (Variation.Params[0].ToString()) { 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: TestLog.Compare(false, "Invalid param value"); break; } } catch (ArgumentException) { TestLog.Compare(w.WriteState, WriteState.Error, "WriteState should be Error"); return; } finally { w.Dispose(); } throw new TestException(TestResult.Failed, ""); }
/// <summary> /// Check integrity of phoneme-based natural classes (PhNCSegments) /// when there are phonological features /// </summary> public void WriteDataIssues(XElement elem) { if (!m_cache.LangProject.PhFeatureSystemOA.FeaturesOC.Any()) return; // no phonological features so nothing to check using (XmlWriter writer = elem.CreateWriter()) { writer.WriteStartElement("DataIssues"); foreach (IPhNCSegments natClass in m_cache.LangProject.PhonologicalDataOA.NaturalClassesOS.OfType<IPhNCSegments>()) { HashSet<IFsSymFeatVal> feats = GetImpliedPhonologicalFeatures(natClass); var predictedPhonemes = new HashSet<IPhPhoneme>(m_cache.LangProject.PhonologicalDataOA.PhonemeSetsOS.SelectMany(ps => ps.PhonemesOC).Where(p => GetFeatures(p) != null && feats.IsSubsetOf(GetFeatures(p)))); if (!predictedPhonemes.SetEquals(natClass.SegmentsRC)) { writer.WriteStartElement("NatClassPhonemeMismatch"); writer.WriteElementString("ClassName", natClass.Name.BestAnalysisAlternative.Text); writer.WriteElementString("ClassAbbeviation", natClass.Abbreviation.BestAnalysisAlternative.Text); writer.WriteElementString("ImpliedPhonologicalFeatures", feats.Count == 0 ? "" : string.Format("[{0}]", string.Join(" ", feats.Select(v => string.Format("{0}:{1}", GetFeatureString(v), GetValueString(v)))))); writer.WriteElementString("PredictedPhonemes", string.Join(" ", predictedPhonemes.Select(p => p.Name.BestVernacularAlternative.Text))); writer.WriteElementString("ActualPhonemes", string.Join(" ", natClass.SegmentsRC.Select(p => p.Name.BestVernacularAlternative.Text))); writer.WriteEndElement(); } } writer.WriteEndElement(); } }
/// <summary> /// Returns a <see cref="XElement"/> of a serialized <see cref="IEventListener"/> instance. /// </summary> /// <param name="listener"></param> /// <returns></returns> XElement SerializeListener(IEventListener listener) { Contract.Requires<ArgumentNullException>(listener != null); // generate listener element var element = new XElement("listener", new XAttribute("type", listener.GetType().FullName + ", " + listener.GetType().Assembly.GetName().Name)); // serialize listener into element using (var w = element.CreateWriter()) { w.WriteWhitespace(""); new XmlSerializer(listener.GetType()) .Serialize(w, listener); } return element; }
//[Variation(Id = 13, Desc = "WritePI with invalid surrogate pair", Priority = 1)] public void pi_13() { XProcessingInstruction xa = new XProcessingInstruction("pi", "\uD812"); XElement doc = new XElement("root"); doc.Add(xa); XmlWriter w = doc.CreateWriter(); w.Dispose(); try { doc.Save(new MemoryStream()); } catch (ArgumentException) { CheckClosedState(w.WriteState); return; } TestLog.WriteLine("Did not throw exception"); throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 5, Desc = "WriteComment with invalid surrogate pair", Priority = 1)] public void comment_5() { XComment xa = new XComment("\uD812"); XElement doc = new XElement("root"); doc.Add(xa); XmlWriter w = doc.CreateWriter(); w.Dispose(); try { doc.Save(new MemoryStream()); } catch (ArgumentException) { CheckClosedState(w.WriteState); return; } TestLog.WriteLine("Did not throw error"); throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 29, Desc = "442897: WriteAttributeString doesn't fail on invalid surrogate pair sequences")] public void attribute_29() { XAttribute xa = new XAttribute("attribute", "\ud800\ud800"); XElement doc = new XElement("root"); doc.Add(xa); XmlWriter w = doc.CreateWriter(); w.Dispose(); try { doc.Save(new MemoryStream()); } catch (ArgumentException) { return; } finally { w.Dispose(); } throw new TestException(TestResult.Failed, ""); }
//[Variation(Desc = "WriteEntityRef")] public void Variation42() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); try { w.WriteEntityRef("ent"); } catch (NotSupportedException) { TestLog.Compare(w.WriteState, WriteState.Error, "Error"); return; } throw new TestException(TestResult.Failed, ""); }
//[Variation(Id = 18, Desc = "WritePI at top level, followed by text, expected CL = Fragment", Priority = 2, Param = "PI")] //[Variation(Id = 19, Desc = "WriteComment at top level, followed by text, expected CL = Fragment", Priority = 2, Param = "Comment")] //[Variation(Id = 20, Desc = "WriteWhitespace at top level, followed by text, expected CL = Fragment", Priority = 2, Param = "WS")] public void auto_7() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); w.WriteProcessingInstruction("pi", "text"); w.WriteString("text"); TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Error"); w.Dispose(); }
/// <summary> /// Serializes the annotation as XML to the body of hte given element. /// </summary> /// <param name="obj"></param> /// <param name="annotation"></param> /// <param name="element"></param> XElement SerializeToXml(XObject obj, object annotation, XElement element) { Contract.Requires<ArgumentNullException>(obj != null); Contract.Requires<ArgumentNullException>(annotation != null); Contract.Requires<ArgumentNullException>(element != null); // configure element element.SetAttributeValue(NX_FORMAT, NX_FORMAT_XML); element.SetAttributeValue(NX_TYPE, annotation.GetType().FullName + ", " + annotation.GetType().Assembly.GetName().Name); element.RemoveNodes(); // serialize anntation into body using (var wrt = element.CreateWriter()) { wrt.WriteWhitespace(""); // fixes a bug in XmlSerializer that tries to WriteStartDocument if (annotation is ISerializableAnnotation) { element.Add(((ISerializableAnnotation)annotation).Serialize(this)); } else if (annotation is IXmlSerializable) { var srs = GetXmlSerializer(annotation.GetType()); var ens = new XmlSerializerNamespaces(); ens.Add("", ""); srs.Serialize(wrt, annotation, ens); } else if (annotation.GetType().GetCustomAttribute<XmlRootAttribute>() != null) { var srs = GetXmlSerializer(annotation.GetType()); var ens = new XmlSerializerNamespaces(); ens.Add("", ""); srs.Serialize(wrt, annotation, ens); } else return null; } return element; }
//[Variation(Id = 22, Desc = "WriteNode(XmlReader) when reader positioned on text node, expected CL = Fragment", Priority = 2)] public void auto_10() { XElement d = new XElement("a"); XmlWriter w = d.CreateWriter(); string strxml = "<Root>text</Root>"; XmlReader xr = GetReaderStr(strxml); xr.Read(); xr.Read(); TestLog.Compare(xr.NodeType.ToString(), "Text", "Error"); w.WriteNode(xr, false); TestLog.Compare(w.Settings.ConformanceLevel, ConformanceLevel.Fragment, "Error"); w.Dispose(); xr.Dispose(); }
protected override XElement Write(string name, Allomorph allomorph) { XElement elem = Write(name, (HCObject)allomorph); string formIdsStr = allomorph.GetProperty("FormID"); string msaId = allomorph.GetProperty("MsaID"); if (!String.IsNullOrEmpty(formIdsStr) || !String.IsNullOrEmpty(msaId)) { var morphElem = new XElement("Morph"); string firstFormId = null; string firstWordType = null; string featDesc = allomorph.GetProperty("FeatureDescriptors"); if (!String.IsNullOrEmpty(formIdsStr)) { string[] formIds = formIdsStr.Split(' '); string[] wordTypes = allomorph.GetProperty("WordCategory").Split(' '); for (int i = 0; i < formIds.Length; i++) { int wordTypeIndex = WordTypeIndex(i, wordTypes.Length); string wordType = wordTypes[wordTypeIndex]; morphElem.Add(new XElement("MoForm", new XAttribute("DbRef", formIds[i]), new XAttribute("wordType", wordType))); morphElem.Add(string.IsNullOrEmpty(featDesc) ? new XElement("props") : new XElement("props", featDesc)); if (i == 0) { firstFormId = formIds[i]; firstWordType = wordType; } } } if (!String.IsNullOrEmpty(msaId)) { var msiElement = new XElement("MSI", new XAttribute("DbRef", msaId)); using (XmlWriter writer = msiElement.CreateWriter()) writer.WriteMsaElement(m_cache, firstFormId, msaId, null, firstWordType); morphElem.Add(msiElement); } using (XmlWriter writer = morphElem.CreateWriter()) writer.WriteMorphInfoElements(m_cache, firstFormId, msaId, firstWordType, featDesc); elem.Add(morphElem); } return elem; }