public void WhitespaceInsideElement() { XmlSchemaValidator val = CreateValidator(XSDFILE_VALIDATE_TEXT); CValidationEventHolder holder = new CValidationEventHolder(); XmlSchemaInfo info = new XmlSchemaInfo(); val.ValidationEventHandler += new ValidationEventHandler(holder.CallbackA); val.Initialize(); val.ValidateElement("ElementOnlyElement", "", info); val.ValidateEndOfAttributes(null); val.ValidateWhitespace(" \t\r\n"); val.ValidateElement("child", "", info); val.ValidateEndOfAttributes(null); val.ValidateEndElement(info); val.ValidateWhitespace(" \t\r\n"); val.ValidateEndElement(info); val.EndValidation(); Assert.True(!holder.IsCalledA); Assert.Equal(info.Validity, XmlSchemaValidity.Valid); Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly); return; }
public void SanityTestForSimpleType_MultipleCallInOneContext(String param) { XmlSchemaValidator val = CreateValidator(XSDFILE_VALIDATE_TEXT); CValidationEventHolder holder = new CValidationEventHolder(); XmlSchemaInfo info = new XmlSchemaInfo(); val.ValidationEventHandler += new ValidationEventHandler(holder.CallbackA); val.Initialize(); val.ValidateElement("PatternElement", "", info); val.ValidateEndOfAttributes(null); if (param == "single") val.ValidateText(StringGetter("foo123bar")); else { val.ValidateText(StringGetter("foo")); val.ValidateText(StringGetter("123")); val.ValidateText(StringGetter("bar")); } val.ValidateEndElement(info); val.EndValidation(); Assert.True(!holder.IsCalledA); Assert.Equal(info.Validity, XmlSchemaValidity.Valid); Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly); return; }
public void DefaultValueForXmlResolver_XmlUrlResolver() { XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable()); manager.AddNamespace("t", "uri:tempuri"); XmlSchemaValidator val = new XmlSchemaValidator(new NameTable(), CreateSchemaSetFromXml("<root />"), manager, AllFlags); XmlSchemaInfo info = new XmlSchemaInfo(); val.XmlResolver = new XmlUrlResolver(); //Adding this as the default resolver is null and not XmlUrlResolver anymore val.Initialize(); val.ValidateElement("foo", "", null, "t:type1", null, "uri:tempuri " + TestData + XSDFILE_TARGET_NAMESPACE, null); val.ValidateEndOfAttributes(null); val.ValidateElement("bar", "", null); val.ValidateEndOfAttributes(null); val.ValidateEndElement(null); val.ValidateEndElement(info); Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly); Assert.True(info.SchemaType != null); return; }
public void PassNull_LocalName_NamespaceUri_Invalid_First_Second_Overload(String type, String overload) { XmlSchemaValidator val = CreateValidator(CreateSchemaSetFromXml("<root />")); string name = "root"; string ns = ""; XmlSchemaInfo info = new XmlSchemaInfo(); if (type == "name") name = null; else ns = null; val.Initialize(); try { if (overload == "first") val.ValidateElement(name, ns, info); else val.ValidateElement(name, ns, info, null, null, null, null); } catch (ArgumentNullException) { return; } Assert.True(false); }
public void CallAtRootLevel_Without_With_PartialValidationSet(bool partialValidation) { XmlSchemaValidator val; XmlSchemaInfo info = new XmlSchemaInfo(); XmlSchemaSet schemas = CreateSchemaSet("", "<?xml version=\"1.0\"?>\n" + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n" + " <xs:attribute name=\"attr1\" />\n" + " <xs:attribute name=\"attr2\" />\n" + "</xs:schema>"); schemas.Compile(); val = CreateValidator(schemas); if (partialValidation) { val.Initialize(schemas.GlobalAttributes[new XmlQualifiedName("attr1")]); CheckExpectedAttributes(val.GetExpectedAttributes(), new XmlQualifiedName[] { new XmlQualifiedName("attr1") }); } else { val.Initialize(); CheckExpectedAttributes(val.GetExpectedAttributes(), new XmlQualifiedName[] { }); } return; }
public void CallForSequence_Between_After_ValidationAllSeqElements(String callOn) { XmlSchemaValidator val = CreateValidator(XSDFILE_GET_EXPECTED_PARTICLES); XmlSchemaInfo info = new XmlSchemaInfo(); XmlQualifiedName[] names; val.Initialize(); val.ValidateElement("SequenceElement", "", info); val.ValidateAttribute("attr1", "", StringGetter("foo"), info); val.ValidateAttribute("attr2", "", StringGetter("foo"), info); val.ValidateEndOfAttributes(null); val.ValidateElement("elem1", "", info); val.SkipToEndElement(info); if (callOn == "end") { val.ValidateElement("elem2", "", info); val.SkipToEndElement(info); names = new XmlQualifiedName[] { }; } else { names = new XmlQualifiedName[] { new XmlQualifiedName("elem2") }; } CheckExpectedElements(val.GetExpectedParticles(), names); return; }
public void SetXmlNameTableTo_Empty_Full(String nameTableStatus) { XmlSchemaValidator val; ObservedNameTable nt = new ObservedNameTable(); XmlSchemaInfo info = new XmlSchemaInfo(); XmlSchemaSet sch = CreateSchemaSetFromXml("<root />"); if (nameTableStatus == "full") { nt.Add("root"); nt.Add("foo"); nt.IsAddCalled = false; nt.IsGetCalled = false; } val = new XmlSchemaValidator(nt, sch, new XmlNamespaceManager(new NameTable()), AllFlags); Assert.NotEqual(val, null); val.Initialize(); val.ValidateElement("root", "", info); Assert.True(nt.IsAddCalled); Assert.Equal(nt.IsGetCalled, false); return; }
public void PassNullXmlSchemaInfo__Valid() { XmlSchemaValidator val = CreateValidator(XSDFILE_VALIDATE_ATTRIBUTE); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement("OneAttributeElement", "", null); val.ValidateAttribute("attr", "", StringGetter("foo"), null); return; }
private void ValidateAttribute(XAttribute a) { XmlSchemaInfo schemaInfo = this.addSchemaInfo ? new XmlSchemaInfo() : null; this.source = a; this.validator.ValidateAttribute(a.Name.LocalName, a.Name.NamespaceName, a.Value, schemaInfo); if (this.addSchemaInfo) { this.ReplaceSchemaInfo(a, schemaInfo); } }
public void CallOnElementWith_Required_Optional_Default_Fixed_FixedRequired_AttributesAfterValidateElement(String attrType) { XmlSchemaValidator val = CreateValidator(XSDFILE_GET_EXPECTED_ATTRIBUTES); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement(attrType + "AttributesElement", "", info); CheckExpectedAttributes(val.GetExpectedAttributes(), new XmlQualifiedName[] { new XmlQualifiedName("a1"), new XmlQualifiedName("a2") }); return; }
public void CallOnElementWithNoAttributesAfterValidateElement() { XmlSchemaValidator val = CreateValidator(XSDFILE_GET_EXPECTED_ATTRIBUTES); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement("NoAttributesElement", "", info); CheckExpectedAttributes(val.GetExpectedAttributes(), new XmlQualifiedName[] { }); return; }
void ValidateAttribute(XAttribute a) { IXmlLineInfo original = SaveLineInfo(a); XmlSchemaInfo si = addSchemaInfo ? new XmlSchemaInfo() : null; source = a; validator.ValidateAttribute(a.Name.LocalName, a.Name.NamespaceName, a.Value, si); if (addSchemaInfo) { ReplaceSchemaInfo(a, si); } RestoreLineInfo(original); }
public void XsdAnyToSkipAttributeValidation () { // bug #358408 XmlSchemaSet schemas = new XmlSchemaSet (); schemas.Add (null, "Test/XmlFiles/xsd/358408.xsd"); XmlSchemaValidator v = new XmlSchemaValidator ( new NameTable (), schemas, new XmlNamespaceManager (new NameTable ()), XmlSchemaValidationFlags.ProcessIdentityConstraints); v.Initialize (); v.ValidateWhitespace (" "); XmlSchemaInfo info = new XmlSchemaInfo (); ArrayList list = new ArrayList (); v.ValidateElement ("configuration", "", info, null, null, null, null); v.GetUnspecifiedDefaultAttributes (list); v.ValidateEndOfAttributes (info); v.ValidateWhitespace (" "); v.ValidateElement ("host", "", info, null, null, null, null); v.ValidateAttribute ("auto-start", "", "true", info); list.Clear (); v.GetUnspecifiedDefaultAttributes (list); v.ValidateEndOfAttributes (info); v.ValidateEndElement (null);//info); v.ValidateWhitespace (" "); v.ValidateElement ("service-managers", "", info, null, null, null, null); list.Clear (); v.GetUnspecifiedDefaultAttributes (list); v.ValidateEndOfAttributes (info); v.ValidateWhitespace (" "); v.ValidateElement ("service-manager", "", info, null, null, null, null); list.Clear (); v.GetUnspecifiedDefaultAttributes (list); v.ValidateEndOfAttributes (info); v.ValidateWhitespace (" "); v.ValidateElement ("foo", "", info, null, null, null, null); v.ValidateAttribute ("bar", "", "", info); }
public void PassNull_LocalName_NameSpace__Invalid(String localName, String nameSpace) { XmlSchemaValidator val = CreateValidator(XSDFILE_VALIDATE_ATTRIBUTE); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement("OneAttributeElement", "", null); try { val.ValidateAttribute(localName, nameSpace, StringGetter("foo"), info); } catch (ArgumentNullException) { return; } Assert.True(false); }
public void PassNullValueGetter__Invalid() { XmlSchemaValidator val = CreateValidator(XSDFILE_VALIDATE_ATTRIBUTE); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement("OneAttributeElement", "", null); try { val.ValidateAttribute("attr", "", (XmlValueGetter)null, info); } catch (ArgumentNullException) { return; } Assert.True(false); }
private void ReplaceSchemaInfo(XObject o, XmlSchemaInfo schemaInfo) { schemaInfos ??= new Dictionary <XmlSchemaInfo, XmlSchemaInfo>(new XmlSchemaInfoEqualityComparer()); XmlSchemaInfo?si = o.Annotation <XmlSchemaInfo>(); if (si != null) { if (!schemaInfos.ContainsKey(si)) { schemaInfos.Add(si, si); } o.RemoveAnnotations <XmlSchemaInfo>(); } if (!schemaInfos.TryGetValue(schemaInfo, out si)) { si = schemaInfo; schemaInfos.Add(si, si); } o.AddAnnotation(si); }
public void InitializeShouldResetIDConstraints() { XmlSchemaValidator val = CreateValidator(XSDFILE_IDENTITY_CONSTRAINS); XmlSchemaInfo info = new XmlSchemaInfo(); for (int i = 0; i < 2; i++) { val.Initialize(); val.ValidateElement("rootIDs", "", info); val.ValidateEndOfAttributes(null); val.ValidateElement("foo", "", info); val.ValidateAttribute("attr", "", StringGetter("a1"), info); val.ValidateEndOfAttributes(null); val.ValidateEndElement(info); val.ValidateEndElement(info); val.EndValidation(); } return; }
public void CallAfterValidate_Element_Attribute_EndOfAttributes_ForSequence(String after) { XmlSchemaValidator val = CreateValidator(XSDFILE_GET_EXPECTED_PARTICLES); XmlSchemaInfo info = new XmlSchemaInfo(); val.Initialize(); val.ValidateElement("SequenceElement", "", info); if (after == "attrib") val.ValidateAttribute("attr1", "", StringGetter("foo"), info); if (after == "endof") { val.ValidateAttribute("attr1", "", StringGetter("foo"), info); val.ValidateAttribute("attr2", "", StringGetter("foo"), info); val.ValidateEndOfAttributes(null); } CheckExpectedElements(val.GetExpectedParticles(), new XmlQualifiedName[] { new XmlQualifiedName("elem1") }); return; }
private XmlSchemaInfo GetDefaultAttributeSchemaInfo(XmlSchemaAttribute sa) { XmlSchemaInfo si = new XmlSchemaInfo(); si.IsDefault = true; si.IsNil = false; si.SchemaAttribute = sa; Debug.Assert(sa.AttributeSchemaType != null); XmlSchemaSimpleType st = sa.AttributeSchemaType; si.SchemaType = st; Debug.Assert(st.Datatype != null); if (st.Datatype.Variety == XmlSchemaDatatypeVariety.Union) { string?value = GetDefaultValue(sa); Debug.Assert(st.Content != null); foreach (XmlSchemaSimpleType mt in ((XmlSchemaSimpleTypeUnion)st.Content).BaseMemberTypes !) { object?typedValue = null; try { Debug.Assert(mt.Datatype != null); Debug.Assert(value != null); typedValue = mt.Datatype.ParseValue(value, schemas.NameTable, namespaceManager); } catch (XmlSchemaException) { } if (typedValue != null) { si.MemberType = mt; break; } } } si.Validity = XmlSchemaValidity.Valid; return(si); }
private void ReplaceSchemaInfo(XObject o, XmlSchemaInfo schemaInfo) { if (this.schemaInfos == null) { this.schemaInfos = new Dictionary <XmlSchemaInfo, XmlSchemaInfo>(new XmlSchemaInfoEqualityComparer()); } XmlSchemaInfo key = o.Annotation <XmlSchemaInfo>(); if (key != null) { if (!this.schemaInfos.ContainsKey(key)) { this.schemaInfos.Add(key, key); } o.RemoveAnnotations <XmlSchemaInfo>(); } if (!this.schemaInfos.TryGetValue(schemaInfo, out key)) { key = schemaInfo; this.schemaInfos.Add(key, key); } o.AddAnnotation(key); }
private void ValidateElement(XElement e) { XmlSchemaInfo schemaInfo = this.addSchemaInfo ? new XmlSchemaInfo() : null; string xsiType = null; string xsiNil = null; this.PushElement(e, ref xsiType, ref xsiNil); this.source = e; this.validator.ValidateElement(e.Name.LocalName, e.Name.NamespaceName, schemaInfo, xsiType, xsiNil, null, null); this.ValidateAttributes(e); this.validator.ValidateEndOfAttributes(schemaInfo); this.ValidateNodes(e); this.validator.ValidateEndElement(schemaInfo); if (this.addSchemaInfo) { if ((schemaInfo.Validity == XmlSchemaValidity.Valid) && schemaInfo.IsDefault) { e.Value = this.GetDefaultValue(schemaInfo.SchemaElement); } this.ReplaceSchemaInfo(e, schemaInfo); } this.namespaceManager.PopScope(); }
public void CallWith_Null_False_XsiNil(String xsiNil) { XmlSchemaValidator val; XmlSchemaInfo info = new XmlSchemaInfo(); val = CreateValidator(XSDFILE_VALIDATE_END_ELEMENT); val.Initialize(); val.ValidateElement("NillableElement", "", info, null, xsiNil, null, null); val.ValidateEndOfAttributes(null); try { val.ValidateEndElement(info); } catch (XmlSchemaValidationException) { //XmlExceptionVerifier.IsExceptionOk(e, new object[] { "Sch_IncompleteContentExpecting", // new object[] { "Sch_ElementName", "NillableElement" }, // new object[] { "Sch_ElementName", "foo" } }); return; } Assert.True(false); }
public void CheckNoNamespaceSchemaLocationIs_UsedWhenSpecified_NotUsedWhenFlagIsSet(XmlSchemaValidationFlags allFlags) { XmlSchemaValidator val; XmlSchemaSet schemas = new XmlSchemaSet(); XmlSchemaInfo info = new XmlSchemaInfo(); CValidationEventHolder holder = new CValidationEventHolder(); schemas.Add("", XmlReader.Create(new StringReader("<?xml version=\"1.0\" ?>\n" + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n" + " <xs:element name=\"root\" />\n" + "</xs:schema>"))); val = CreateValidator(schemas, allFlags); val.XmlResolver = new XmlUrlResolver(); val.ValidationEventHandler += new ValidationEventHandler(holder.CallbackA); val.Initialize(); val.ValidateElement("root", "", info, "type1", null, null, Path.Combine(TestData, XSDFILE_NO_TARGET_NAMESPACE)); if ((int)allFlags == (int)AllFlags) { Assert.True(!holder.IsCalledA); Assert.True(info.SchemaType is XmlSchemaComplexType); } else { Assert.True(holder.IsCalledA); //XmlExceptionVerifier.IsExceptionOk(holder.lastException); } return; }
public void SanityTestsForNestedElements() { XmlSchemaValidator val; XmlSchemaSet schemas = new XmlSchemaSet(); XmlSchemaInfo info = new XmlSchemaInfo(); schemas.Add("", Path.Combine(TestData, XSDFILE_VALIDATE_END_ELEMENT)); schemas.Compile(); val = CreateValidator(schemas); val.Initialize(); val.ValidateElement("NestedElement", "", info); val.ValidateEndOfAttributes(null); Assert.Equal(info.SchemaElement.QualifiedName, new XmlQualifiedName("NestedElement")); Assert.True(info.SchemaType is XmlSchemaComplexType); val.ValidateElement("foo", "", info); val.ValidateEndOfAttributes(null); Assert.Equal(info.SchemaElement.QualifiedName, new XmlQualifiedName("foo")); Assert.True(info.SchemaType is XmlSchemaComplexType); val.ValidateElement("bar", "", info); Assert.Equal(info.SchemaElement.QualifiedName, new XmlQualifiedName("bar")); Assert.True(info.SchemaType is XmlSchemaSimpleType); Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.String); return; }
public void CallValidateElementAndCHeckXmlSchemaInfoFOr_Simple_Complex_Empty_Mixed_Element_First_Second_Overload(String elemType, XmlSchemaContentType schemaContentType, String overload) { XmlSchemaValidator val; XmlSchemaSet schemas = new XmlSchemaSet(); XmlSchemaInfo info = new XmlSchemaInfo(); string name = elemType; schemas.Add("", Path.Combine(TestData, XSDFILE_VALIDATE_TEXT)); schemas.Compile(); val = CreateValidator(schemas); val.Initialize(); if (overload == "first") val.ValidateElement(name, "", info); else val.ValidateElement(name, "", info, null, null, null, null); Assert.Equal(info.ContentType, schemaContentType); Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown); Assert.Equal(info.SchemaElement, schemas.GlobalElements[new XmlQualifiedName(name)]); Assert.Equal(info.IsNil, false); Assert.Equal(info.IsDefault, false); if (name == "SimpleElement") Assert.True(info.SchemaType is XmlSchemaSimpleType); else Assert.True(info.SchemaType is XmlSchemaComplexType); return; }
XmlSchemaInfo GetInfo() { XmlSchemaInfo i = this.info; XmlSchemaInfo copy = new XmlSchemaInfo(); copy.ContentType = i.ContentType; copy.IsDefault = i.IsDefault; copy.IsNil = i.IsNil; copy.MemberType = i.MemberType; copy.SchemaAttribute = i.SchemaAttribute; copy.SchemaElement = i.SchemaElement; copy.SchemaType = i.SchemaType; copy.Validity = i.Validity; return copy; }
public void CheckThatWarningOccursWhenInvalidNoNamespaceSchemaLocationIsProvided() { XmlSchemaValidator val; XmlSchemaSet schemas = new XmlSchemaSet(); XmlSchemaInfo info = new XmlSchemaInfo(); CValidationEventHolder holder = new CValidationEventHolder(); schemas.Add("", XmlReader.Create(new StringReader("<?xml version=\"1.0\" ?>\n" + "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">\n" + " <xs:complexType name=\"rootType\">\n" + " <xs:sequence />\n" + " </xs:complexType>\n" + "</xs:schema>"))); val = CreateValidator(schemas); val.XmlResolver = new XmlUrlResolver(); val.ValidationEventHandler += new ValidationEventHandler(holder.CallbackA); val.Initialize(); val.ValidateElement("root", "", info, "rootType", null, null, Path.Combine(TestData, "__NonExistingFile__.xsd")); Assert.True(holder.IsCalledA); Assert.Equal(holder.lastSeverity, XmlSeverityType.Warning); //XmlExceptionVerifier.IsExceptionOk(holder.lastException, "Sch_CannotLoadSchema", new string[] { "", null }); return; }
public void CallWithXsiNilTrue() { XmlSchemaValidator val; XmlSchemaInfo info = new XmlSchemaInfo(); val = CreateValidator(XSDFILE_VALIDATE_END_ELEMENT); val.Initialize(); val.ValidateElement("NillableElement", "", info, null, "true", null, null); val.ValidateEndOfAttributes(null); val.ValidateEndElement(info); Assert.Equal(info.Validity, XmlSchemaValidity.Valid); return; }
public void ProvideValidXsiType() { XmlSchemaValidator val; XmlSchemaInfo info = new XmlSchemaInfo(); XmlNamespaceManager ns = new XmlNamespaceManager(new NameTable()); XmlSchemaSet schemas = new XmlSchemaSet(); schemas.Add("uri:tempuri", Path.Combine(TestData, XSDFILE_TARGET_NAMESPACE)); val = CreateValidator(schemas, ns, 0); ns.AddNamespace("t", "uri:tempuri"); val.Initialize(); val.ValidateElement("foo", "uri:tempuri", null, "t:type1", null, null, null); return; }
public object ValidateEndElement(XmlSchemaInfo schemaInfo, object typedValue) { if (typedValue == null) { throw new ArgumentNullException("typedValue"); } if (this.textValue.Length > 0) { throw new InvalidOperationException(Res.GetString("Sch_InvalidEndElementCall")); } return this.InternalValidateEndElement(schemaInfo, typedValue); }
public void ProvideInvalidXsiType() { XmlSchemaValidator val; XmlSchemaInfo info = new XmlSchemaInfo(); XmlNamespaceManager ns = new XmlNamespaceManager(new NameTable()); XmlSchemaSet schemas = new XmlSchemaSet(); schemas.Add("uri:tempuri", Path.Combine(TestData, XSDFILE_TARGET_NAMESPACE)); val = CreateValidator(schemas, ns, 0); ns.AddNamespace("t", "uri:tempuri"); val.Initialize(); try { val.ValidateElement("foo", "uri:tempuri", null, "type1", null, null, null); } catch (XmlSchemaValidationException) { //XmlExceptionVerifier.IsExceptionOk(e, "Sch_XsiTypeNotFound", new string[] { "type1" }); return; } Assert.True(false); }
public void ValidateEndOfAttributes(XmlSchemaInfo schemaInfo) { this.CheckStateTransition(ValidatorState.EndOfAttributes, MethodNames[6]); SchemaElementDecl elementDecl = this.context.ElementDecl; if ((elementDecl != null) && elementDecl.HasRequiredAttribute) { this.context.CheckRequiredAttribute = false; this.CheckRequiredAttributes(elementDecl); } if (schemaInfo != null) { schemaInfo.Validity = this.context.Validity; } }
public void StringPassedToValidateEndElementDoesNotSatisfyIdentityConstraints() { Initialize(); string xsd = "<xs:schema targetNamespace='http://tempuri.org/XMLSchema.xsd' elementFormDefault='qualified' xmlns='http://tempuri.org/XMLSchema.xsd' xmlns:mstns='http://tempuri.org/XMLSchema.xsd' xmlns:xs='http://www.w3.org/2001/XMLSchema'>" + "<xs:element name='root'>" + "<xs:complexType> <xs:sequence> <xs:element name='B' type='mstns:B'/> </xs:sequence> </xs:complexType>" + "<xs:unique name='pNumKey'><xs:selector xpath='mstns:B/mstns:part'/><xs:field xpath='.'/></xs:unique>" + "</xs:element>" + "<xs:complexType name='B'><xs:sequence><xs:element name='part' maxOccurs='unbounded' type='xs:string'></xs:element></xs:sequence></xs:complexType>" + "</xs:schema>"; XmlSchemaSet ss = new XmlSchemaSet(); ss.Add(XmlSchema.Read(new StringReader(xsd), ValidationCallback)); ss.Compile(); string ns = "http://tempuri.org/XMLSchema.xsd"; XmlNamespaceManager nsmgr = new XmlNamespaceManager(ss.NameTable); XmlSchemaValidator val = new XmlSchemaValidator(ss.NameTable, ss, nsmgr, XmlSchemaValidationFlags.ProcessIdentityConstraints); val.ValidationEventHandler += new ValidationEventHandler(ValidationCallback); val.Initialize(); XmlSchemaInfo si = new XmlSchemaInfo(); val.ValidateElement("root", ns, si); val.ValidateEndOfAttributes(si); val.ValidateElement("B", ns, si); val.ValidateEndOfAttributes(si); val.ValidateElement("part", ns, si); val.ValidateEndOfAttributes(si); val.ValidateText("1"); val.ValidateEndElement(si); val.ValidateElement("part", ns, si); val.ValidateEndOfAttributes(si); val.ValidateEndElement(si, "1"); val.ValidateElement("part", ns, si); val.ValidateEndOfAttributes(si); val.ValidateText("1"); val.ValidateEndElement(si); val.ValidateEndElement(si); val.ValidateEndElement(si); Assert.Equal(warningCount, 0); Assert.Equal(errorCount, 2); return; }
private void Init() { validationState = ValidatingReaderState.Init; defaultAttributes = new ArrayList(); currentAttrIndex = -1; attributePSVINodes = new AttributePSVIInfo[InitialAttributeCount]; valueGetter = new XmlValueGetter(GetStringValue); TypeOfString = typeof(System.String); xmlSchemaInfo = new XmlSchemaInfo(); //Add common strings to be compared to NameTable NsXmlNs = coreReaderNameTable.Add(XmlReservedNs.NsXmlNs); NsXs = coreReaderNameTable.Add(XmlReservedNs.NsXs); NsXsi = coreReaderNameTable.Add(XmlReservedNs.NsXsi); XsiType = coreReaderNameTable.Add("type"); XsiNil = coreReaderNameTable.Add("nil"); XsiSchemaLocation = coreReaderNameTable.Add("schemaLocation"); XsiNoNamespaceSchemaLocation = coreReaderNameTable.Add("noNamespaceSchemaLocation"); XsdSchema = coreReaderNameTable.Add("schema"); }
public void ValidateContext(XmlCache xcache) { this.cache = xcache; if (string.IsNullOrEmpty(cache.FileName)) { baseUri = null; } else { baseUri = new Uri(new Uri(xcache.FileName), new Uri(".", UriKind.Relative)); } ValidationEventHandler handler = new ValidationEventHandler(OnValidationEvent); SchemaResolver resolver = xcache.SchemaResolver as SchemaResolver; resolver.Handler = handler; XmlDocument doc = xcache.Document; this.info = new XmlSchemaInfo(); this.nsResolver = new MyXmlNamespaceResolver(doc.NameTable); XmlSchemaSet set = new XmlSchemaSet(); // Make sure the SchemaCache is up to date with document. SchemaCache sc = xcache.SchemaCache; foreach (XmlSchema s in doc.Schemas.Schemas()) { sc.Add(s); } if (LoadSchemas(doc, set, resolver)) { set.ValidationEventHandler += handler; set.Compile(); } this.validator = new XmlSchemaValidator(doc.NameTable, set, nsResolver, XmlSchemaValidationFlags.AllowXmlAttributes | XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.ProcessInlineSchema); this.validator.ValidationEventHandler += handler; this.validator.XmlResolver = resolver; this.validator.Initialize(); this.nsResolver.Context = doc; ValidateContent(doc); this.nsResolver.Context = doc; this.validator.EndValidation(); }
internal AttributePSVIInfo() { attributeSchemaInfo = new XmlSchemaInfo(); }