From b01499743cbf362cc4d5da7088712e259e1ef5b1 Mon Sep 17 00:00:00 2001 From: Mihaela Mihaljevic Date: Mon, 8 Jun 2026 13:53:22 +0200 Subject: [PATCH] feat(schema): XSD wildcards and list built-in datatypes Add xs:any and xs:anyAttribute wildcards with namespace and processContents constraints (skip/lax/strict), and resolve the list built-in datatypes (IDREFS, ENTITIES, NMTOKENS) to their item types so each list item validates. WildcardNamespace models ##any/##other/enumerated URI sets; Wildcard.admits gates undeclared attributes and wildcard-matched children. ContentNFA.follow exposes the follow set for completions. Closes #77 --- Sources/Schema/ComplexType.swift | 65 ++++++- Sources/Schema/ComplexValidator.swift | 250 ++++++++++++++++---------- Sources/Schema/ContentMatcher.swift | 8 +- Sources/Schema/XSDCompletions.swift | 2 +- Sources/Schema/XSDContext.swift | 3 + Sources/Schema/XSDParser.swift | 52 +++++- Sources/Schema/XSDSimpleParser.swift | 12 ++ Tests/XSDWildcardTests.swift | 88 +++++++++ 8 files changed, 368 insertions(+), 112 deletions(-) create mode 100644 Tests/XSDWildcardTests.swift diff --git a/Sources/Schema/ComplexType.swift b/Sources/Schema/ComplexType.swift index 0aeb312..254ff66 100644 --- a/Sources/Schema/ComplexType.swift +++ b/Sources/Schema/ComplexType.swift @@ -9,10 +9,57 @@ public extension PureXML.Schema { case all } - /// An element wildcard (`xs:any`). The minimal namespace constraint: any - /// element matches. - struct Wildcard: Sendable { - public init() {} + /// The namespace constraint of a wildcard (`xs:any`/`xs:anyAttribute`). + enum WildcardNamespace: Sendable, Equatable { + /// `##any`: a name in any namespace, or none. + case any + /// `##other`: a name in any namespace other than the target, and not in no + /// namespace. + case other + /// A specific set of namespace URIs; the empty string stands for no + /// namespace (`##local`). + case enumerated(Set) + } + + /// How a wildcard-matched item is validated: `skip` (no validation), `lax` + /// (validate if a declaration is found), or `strict` (a declaration is + /// required). + enum ProcessContents: Sendable, Equatable { + case skip + case lax + case strict + } + + /// An element or attribute wildcard (`xs:any`/`xs:anyAttribute`): which + /// namespaces it admits, and how matched items are validated. + struct Wildcard: Sendable, Equatable { + public var namespace: WildcardNamespace + public var processContents: ProcessContents + /// The schema's target namespace, needed to resolve `##other`. + public var targetNamespace: String? + + public init( + namespace: WildcardNamespace = .any, + processContents: ProcessContents = .strict, + targetNamespace: String? = nil, + ) { + self.namespace = namespace + self.processContents = processContents + self.targetNamespace = targetNamespace + } + + /// Whether `name` is admitted by this wildcard's namespace constraint. + public func admits(_ name: PureXML.Model.QualifiedName) -> Bool { + let namespaceURI = name.namespaceURI ?? "" + switch namespace { + case .any: + return true + case .other: + return !namespaceURI.isEmpty && namespaceURI != (targetNamespace ?? "") + case let .enumerated(uris): + return uris.contains(namespaceURI) + } + } } /// The term of a particle: an element declaration, a nested model group, or a @@ -102,20 +149,20 @@ public extension PureXML.Schema { case mixed(Particle) } - /// A complex type: its attribute uses, whether unknown attributes are allowed, - /// and its content model. + /// A complex type: its attribute uses, an optional attribute wildcard + /// (`xs:anyAttribute`) admitting further attributes, and its content model. struct ComplexType: Sendable { public var attributes: [AttributeUse] - public var allowsOtherAttributes: Bool + public var attributeWildcard: Wildcard? public var content: ContentType public init( attributes: [AttributeUse] = [], - allowsOtherAttributes: Bool = false, + attributeWildcard: Wildcard? = nil, content: ContentType = .empty, ) { self.attributes = attributes - self.allowsOtherAttributes = allowsOtherAttributes + self.attributeWildcard = attributeWildcard self.content = content } } diff --git a/Sources/Schema/ComplexValidator.swift b/Sources/Schema/ComplexValidator.swift index 0463500..ca9eba2 100644 --- a/Sources/Schema/ComplexValidator.swift +++ b/Sources/Schema/ComplexValidator.swift @@ -2,6 +2,12 @@ /// namespace to avoid nesting a type two levels deep. private typealias XSDFailure = PureXML.Validation.ValidationError private typealias XSDPath = [PureXML.Validation.PathKey] +private typealias XSDGroup = PureXML.Schema.Group +private typealias XSDTerm = PureXML.Schema.Term +private typealias XSDTermLabel = PureXML.Schema.TermLabel +private typealias XSDProcessContents = PureXML.Schema.ProcessContents +private typealias XSDElementType = PureXML.Schema.ElementType +private typealias XSDWildcard = PureXML.Schema.Wildcard public extension PureXML.Schema { /// Validates an element against a ``ComplexType``: its attribute uses, its @@ -101,8 +107,10 @@ public extension PureXML.Schema { errors.append(XSDFailure(reason: "missing required attribute '\(use.name.localName)'", at: path)) } } - guard !type.allowsOtherAttributes else { return } + // An undeclared attribute is allowed only if an xs:anyAttribute wildcard + // admits its namespace. for attribute in present where !type.attributes.contains(where: { $0.name.localName == attribute.name.localName }) { + if type.attributeWildcard?.admits(attribute.name) == true { continue } errors.append(XSDFailure(reason: "undeclared attribute '\(attribute.name.localName)'", at: path)) } } @@ -156,19 +164,56 @@ public extension PureXML.Schema { errors.append(XSDFailure(reason: "content does not match the content model", at: path)) return } - validateChildren(children, childTypes: Self.elementTypes(in: particle.term), at: path, into: &errors) + validateChildren( + children, + childTypes: Self.elementTypes(in: particle.term), + wildcard: Self.wildcard(in: particle.term), + at: path, + into: &errors, + ) } private func validateChildren( _ children: [PureXML.Model.Element], childTypes: [String: ElementType], + wildcard: ProcessContents?, at path: XSDPath, into errors: inout [XSDFailure], ) { let steps = Self.childSteps(children) for (child, step) in zip(children, steps) { - guard let declared = childTypes[Self.key(child.name)] else { continue } - validateChild(child, against: declared, at: path + [step], into: &errors) + if let declared = childTypes[Self.key(child.name)] { + validateChild(child, against: declared, at: path + [step], into: &errors) + } else if let wildcard { + // The structure already matched, so an undeclared child here was + // admitted by a wildcard; process its content per the wildcard. + validateWildcardChild(child, processContents: wildcard, at: path + [step], into: &errors) + } + } + } + + /// Validates a wildcard-matched child by its `processContents`: skip does + /// nothing, lax validates against a global declaration when one exists, and + /// strict requires one. + private func validateWildcardChild( + _ child: PureXML.Model.Element, + processContents: ProcessContents, + at path: XSDPath, + into errors: inout [XSDFailure], + ) { + switch processContents { + case .skip: + return + case .lax: + if let declaration = types["element:\(child.name.localName)"] { + validateChild(child, against: declaration, at: path, into: &errors) + } + case .strict: + guard let declaration = types["element:\(child.name.localName)"] else { + errors.append(XSDFailure(reason: "no declaration for wildcard-matched element '\(child.name.localName)'", at: path)) + return + } + validateChild(child, against: declaration, at: path, into: &errors) } } @@ -208,103 +253,124 @@ public extension PureXML.Schema { validateChild(child, against: resolved, at: path, into: &errors) } } + } +} - // MARK: Helpers +extension PureXML.Schema.ComplexValidator { + // MARK: Helpers - /// The coding-path step for each child: its name, with a sibling index only - /// when more than one child shares that name. - private static func childSteps(_ children: [PureXML.Model.Element]) -> [PureXML.Validation.PathKey] { - var totals: [String: Int] = [:] - for child in children { - totals[child.name.description, default: 0] += 1 + /// The coding-path step for each child: its name, with a sibling index only + /// when more than one child shares that name. + static func childSteps(_ children: [PureXML.Model.Element]) -> [PureXML.Validation.PathKey] { + var totals: [String: Int] = [:] + for child in children { + totals[child.name.description, default: 0] += 1 + } + var seen: [String: Int] = [:] + return children.map { child in + let name = child.name.description + let index = (seen[name] ?? 0) + 1 + seen[name] = index + return (totals[name] ?? 0) > 1 ? .element(name, index: index) : .element(name) + } + } + + /// Validates an `all` group order-independently: every child matches a + /// member within its occurrence bounds, and each member meets its minimum. + fileprivate static func matchesAll(_ group: XSDGroup, names: [PureXML.Model.QualifiedName]) -> Bool { + var counts = [Int](repeating: 0, count: group.particles.count) + for name in names { + guard let index = group.particles.indices.first(where: { position in + let member = group.particles[position] + let room = member.maxOccurs.map { counts[position] < $0 } ?? true + return room && label(of: member.term).matches(name) + }) else { return false } + counts[index] += 1 + } + for (index, member) in group.particles.enumerated() where counts[index] < member.minOccurs { + return false + } + return true + } + + fileprivate static func label(of term: XSDTerm) -> XSDTermLabel { + switch term { + case let .element(name, _): .name(name) + case let .wildcard(wildcard): .wildcard(wildcard) + case .group: .wildcard(XSDWildcard()) + } + } + + /// The `processContents` of a wildcard reachable in `term`, if the content + /// model contains one. + fileprivate static func wildcard(in term: XSDTerm) -> XSDProcessContents? { + switch term { + case let .wildcard(wildcard): + return wildcard.processContents + case let .group(group): + for member in group.particles { + if let found = wildcard(in: member.term) { return found } } - var seen: [String: Int] = [:] - return children.map { child in - let name = child.name.description - let index = (seen[name] ?? 0) + 1 - seen[name] = index - return (totals[name] ?? 0) > 1 ? .element(name, index: index) : .element(name) + return nil + case .element: + return nil + } + } + + fileprivate static func elementTypes(in term: XSDTerm) -> [String: XSDElementType] { + var result: [String: XSDElementType] = [:] + collectTypes(term, into: &result) + return result + } + + fileprivate static func collectTypes(_ term: XSDTerm, into result: inout [String: XSDElementType]) { + switch term { + case let .element(name, type): + if let type { result[key(name)] = type } + case let .group(group): + for member in group.particles { + collectTypes(member.term, into: &result) + } + case .wildcard: + break + } + } + + static func key(_ name: PureXML.Model.QualifiedName) -> String { + "{\(name.namespaceURI ?? "")}\(name.localName)" + } + + static func textContent(_ element: PureXML.Model.Element) -> String { + let text = element.children.reduce(into: "") { result, child in + switch child { + case let .text(value), let .cdata(value): result += value + default: break } } + return text.trimmingXMLWhitespace() + } - /// Validates an `all` group order-independently: every child matches a - /// member within its occurrence bounds, and each member meets its minimum. - private static func matchesAll(_ group: Group, names: [PureXML.Model.QualifiedName]) -> Bool { - var counts = [Int](repeating: 0, count: group.particles.count) - for name in names { - guard let index = group.particles.indices.first(where: { position in - let member = group.particles[position] - let room = member.maxOccurs.map { counts[position] < $0 } ?? true - return room && label(of: member.term).matches(name) - }) else { return false } - counts[index] += 1 - } - for (index, member) in group.particles.enumerated() where counts[index] < member.minOccurs { - return false - } - return true - } + static func isNamespaceDeclaration(_ attribute: PureXML.Model.Attribute) -> Bool { + attribute.name.prefix == "xmlns" || (attribute.name.prefix == nil && attribute.name.localName == "xmlns") + } - private static func label(of term: Term) -> TermLabel { - if case let .element(name, _) = term { return .name(name) } - return .any - } + /// Whether an attribute belongs to the XML Schema instance namespace + /// (`xsi:type`, `xsi:nil`, and the schema-location hints), which are + /// processing directives rather than declared attributes. + static func isSchemaInstanceAttribute(_ attribute: PureXML.Model.Attribute) -> Bool { + attribute.name.namespaceURI == "http://www.w3.org/2001/XMLSchema-instance" || attribute.name.prefix == "xsi" + } - private static func elementTypes(in term: Term) -> [String: ElementType] { - var result: [String: ElementType] = [:] - collectTypes(term, into: &result) - return result - } - - private static func collectTypes(_ term: Term, into result: inout [String: ElementType]) { - switch term { - case let .element(name, type): - if let type { result[key(name)] = type } - case let .group(group): - for member in group.particles { - collectTypes(member.term, into: &result) - } - case .wildcard: - break - } - } - - private static func key(_ name: PureXML.Model.QualifiedName) -> String { - "{\(name.namespaceURI ?? "")}\(name.localName)" - } - - private static func textContent(_ element: PureXML.Model.Element) -> String { - let text = element.children.reduce(into: "") { result, child in - switch child { - case let .text(value), let .cdata(value): result += value - default: break - } - } - return text.trimmingXMLWhitespace() - } - - private static func isNamespaceDeclaration(_ attribute: PureXML.Model.Attribute) -> Bool { - attribute.name.prefix == "xmlns" || (attribute.name.prefix == nil && attribute.name.localName == "xmlns") - } - - /// Whether an attribute belongs to the XML Schema instance namespace - /// (`xsi:type`, `xsi:nil`, and the schema-location hints), which are - /// processing directives rather than declared attributes. - private static func isSchemaInstanceAttribute(_ attribute: PureXML.Model.Attribute) -> Bool { - attribute.name.namespaceURI == "http://www.w3.org/2001/XMLSchema-instance" || attribute.name.prefix == "xsi" - } - - /// The local name of an element's `xsi:type` attribute value, or nil when it - /// carries none. Recognizes the attribute by the XML Schema instance - /// namespace or, failing namespace resolution, the conventional `xsi` prefix. - private static func xsiTypeName(_ element: PureXML.Model.Element) -> String? { - let schemaInstance = "http://www.w3.org/2001/XMLSchema-instance" - let match = element.attributes.first { attribute in - attribute.name.localName == "type" - && (attribute.name.namespaceURI == schemaInstance || attribute.name.prefix == "xsi") - } - return match.map { $0.value.split(separator: ":").last.map(String.init) ?? $0.value } + /// The local name of an element's `xsi:type` attribute value, or nil when it + /// carries none. Recognizes the attribute by the XML Schema instance + /// namespace or, failing namespace resolution, the conventional `xsi` prefix. + static func xsiTypeName(_ element: PureXML.Model.Element) -> String? { + let schemaInstance = "http://www.w3.org/2001/XMLSchema-instance" + let match = element.attributes.first { attribute in + attribute.name.localName == "type" + && (attribute.name.namespaceURI == schemaInstance || attribute.name.prefix == "xsi") } + return match.map { $0.value.split(separator: ":").last.map(String.init) ?? $0.value } } } diff --git a/Sources/Schema/ContentMatcher.swift b/Sources/Schema/ContentMatcher.swift index eaa2e1f..ae0bf76 100644 --- a/Sources/Schema/ContentMatcher.swift +++ b/Sources/Schema/ContentMatcher.swift @@ -3,11 +3,11 @@ extension PureXML.Schema { /// element name, or a wildcard. enum TermLabel: Sendable { case name(PureXML.Model.QualifiedName) - case any + case wildcard(Wildcard) func matches(_ actual: PureXML.Model.QualifiedName) -> Bool { switch self { - case .any: true + case let .wildcard(wildcard): wildcard.admits(actual) case let .name(declared): declared.localName == actual.localName && declared.namespaceURI == actual.namespaceURI } @@ -134,8 +134,8 @@ extension PureXML.Schema { switch term { case let .element(name, _): labeled(.name(name)) - case .wildcard: - labeled(.any) + case let .wildcard(wildcard): + labeled(.wildcard(wildcard)) case let .group(group): self.group(group) } diff --git a/Sources/Schema/XSDCompletions.swift b/Sources/Schema/XSDCompletions.swift index b72f7f1..ba96d8d 100644 --- a/Sources/Schema/XSDCompletions.swift +++ b/Sources/Schema/XSDCompletions.swift @@ -59,7 +59,7 @@ public extension PureXML.Schema { case let .elementOnly(particle), let .mixed(particle): let (labels, complete) = ContentNFABuilder.build(particle).follow(after: childNames) let names = labels.compactMap { if case let .name(name) = $0 { name.description } else { nil } } - let anyElement = labels.contains { if case .any = $0 { true } else { false } } + let anyElement = labels.contains { if case .wildcard = $0 { true } else { false } } return Completions(elements: names, complete: complete, allowsAnyElement: anyElement, attributes: attributes) case .empty, .simpleContent: return Completions(elements: [], complete: true, allowsAnyElement: false, attributes: attributes) diff --git a/Sources/Schema/XSDContext.swift b/Sources/Schema/XSDContext.swift index 5253b80..41d6bf8 100644 --- a/Sources/Schema/XSDContext.swift +++ b/Sources/Schema/XSDContext.swift @@ -114,6 +114,9 @@ extension PureXML.Schema { var simpleTypes: [String: SimpleType] var attributeGroups: [String: XSDTree] var groups: [String: XSDTree] + /// The schema's target namespace, for resolving `##other`/`##targetNamespace` + /// in wildcard constraints. + var targetNamespace: String? /// Each substitution-group head maps to its transitive member element /// names, so an `xs:element ref` to a head also admits its members. var substitutions: [String: [String]] = [:] diff --git a/Sources/Schema/XSDParser.swift b/Sources/Schema/XSDParser.swift index 263e0a4..6b6cb6f 100644 --- a/Sources/Schema/XSDParser.swift +++ b/Sources/Schema/XSDParser.swift @@ -18,6 +18,7 @@ extension PureXML.Schema { simpleTypes: [:], attributeGroups: indexByName(allChildren(containers, named: "attributeGroup")), groups: indexByName(allChildren(containers, named: "group")), + targetNamespace: XSDNode.attribute(schema, "targetNamespace"), substitutions: XSDNode.substitutionMembers(containers), ) // Named simple types may restrict or list one another regardless of @@ -96,13 +97,16 @@ extension PureXML.Schema { if let builtin = BuiltinType(rawValue: local) { return .simple(SimpleType(base: builtin)) } + if let item = XSDSimpleParser.listBuiltinItem(local) { + return .simple(.list(item: SimpleType(base: item))) + } return .typeReference(local) } private static var anyType: ComplexType { ComplexType( - allowsOtherAttributes: true, - content: .mixed(Particle(minOccurs: 0, maxOccurs: nil, term: .wildcard(Wildcard()))), + attributeWildcard: Wildcard(processContents: .skip), + content: .mixed(Particle(minOccurs: 0, maxOccurs: nil, term: .wildcard(Wildcard(processContents: .skip)))), ) } @@ -114,14 +118,16 @@ extension PureXML.Schema { if let simpleContent = XSDNode.firstChild(node, named: "simpleContent") { let inner = derivation(simpleContent) attributes += inner.map { attributeUses(under: $0, context) } ?? [] - return ComplexType(attributes: attributes, content: .simpleContent(simpleContentType(simpleContent, context))) + let wildcard = inner.flatMap { attributeWildcard(under: $0, context) } + return ComplexType(attributes: attributes, attributeWildcard: wildcard, content: .simpleContent(simpleContentType(simpleContent, context))) } let container = XSDNode.firstChild(node, named: "complexContent").flatMap(derivation) ?? node attributes += container === node ? [] : attributeUses(under: container, context) + let wildcard = attributeWildcard(under: container, context) guard let particle = modelGroup(in: container, context) else { - return ComplexType(attributes: attributes, content: .empty) + return ComplexType(attributes: attributes, attributeWildcard: wildcard, content: .empty) } - return ComplexType(attributes: attributes, content: mixed ? .mixed(particle) : .elementOnly(particle)) + return ComplexType(attributes: attributes, attributeWildcard: wildcard, content: mixed ? .mixed(particle) : .elementOnly(particle)) } private static func derivation(_ node: XSDTree) -> XSDTree? { @@ -228,7 +234,7 @@ extension PureXML.Schema { case "group": return groupReferenceParticle(node, minimum, maximum, context) case "any": - return Particle(minOccurs: minimum, maxOccurs: maximum, term: .wildcard(Wildcard())) + return Particle(minOccurs: minimum, maxOccurs: maximum, term: .wildcard(wildcard(node, context))) default: return nil } @@ -324,3 +330,37 @@ extension PureXML.Schema.XSDParser { return result } } + +extension PureXML.Schema.XSDParser { + /// The `xs:anyAttribute` wildcard declared directly under `node`, if any. + static func attributeWildcard(under node: XSDTree, _ context: PureXML.Schema.XSDContext) -> PureXML.Schema.Wildcard? { + PureXML.Schema.XSDNode.firstChild(node, named: "anyAttribute").map { wildcard($0, context) } + } + + /// Parses a wildcard's `namespace` and `processContents` constraints. + static func wildcard(_ node: XSDTree, _ context: PureXML.Schema.XSDContext) -> PureXML.Schema.Wildcard { + let processContents: PureXML.Schema.ProcessContents = switch PureXML.Schema.XSDNode.attribute(node, "processContents") { + case "skip": .skip + case "lax": .lax + default: .strict + } + let namespace = wildcardNamespace(PureXML.Schema.XSDNode.attribute(node, "namespace"), context) + return PureXML.Schema.Wildcard(namespace: namespace, processContents: processContents, targetNamespace: context.targetNamespace) + } + + private static func wildcardNamespace(_ value: String?, _ context: PureXML.Schema.XSDContext) -> PureXML.Schema.WildcardNamespace { + switch value { + case nil, "##any": return .any + case "##other": return .other + default: + let uris = (value ?? "").split(whereSeparator: \.isWhitespace).map { token -> String in + switch token { + case "##targetNamespace": context.targetNamespace ?? "" + case "##local": "" + default: String(token) + } + } + return .enumerated(Set(uris)) + } + } +} diff --git a/Sources/Schema/XSDSimpleParser.swift b/Sources/Schema/XSDSimpleParser.swift index c2997a0..8234cb6 100644 --- a/Sources/Schema/XSDSimpleParser.swift +++ b/Sources/Schema/XSDSimpleParser.swift @@ -31,9 +31,21 @@ extension PureXML.Schema { static func simpleTypeReference(_ typeName: String, _ context: XSDContext) -> SimpleType { let local = XSDNode.stripPrefix(typeName) if let builtin = BuiltinType(rawValue: local) { return SimpleType(base: builtin) } + if let item = listBuiltinItem(local) { return .list(item: SimpleType(base: item)) } return context.simpleTypes[local] ?? SimpleType(base: .string) } + /// The item type of a built-in list datatype (`IDREFS`, `ENTITIES`, + /// `NMTOKENS`), each a whitespace-separated list of its singular form. + static func listBuiltinItem(_ name: String) -> BuiltinType? { + switch name { + case "IDREFS": .idref + case "ENTITIES": .entity + case "NMTOKENS": .nmtoken + default: nil + } + } + static func applyFacets(_ restriction: XSDTree, into facets: inout Facets) { for facet in XSDNode.elementChildren(restriction) { let value = XSDNode.attribute(facet, "value") diff --git a/Tests/XSDWildcardTests.swift b/Tests/XSDWildcardTests.swift new file mode 100644 index 0000000..8af6d7e --- /dev/null +++ b/Tests/XSDWildcardTests.swift @@ -0,0 +1,88 @@ +@testable import PureXML +import Testing + +@Suite("XSD wildcards and list builtins") +struct XSDWildcardTests { + private func validate(_ xsd: String, _ xml: String) throws -> [PureXML.Validation.ValidationError] { + try PureXML.Schema.Document(xsd).validate(xml) + } + + @Test("xs:any with processContents=skip admits any element without validating it") + func test_anySkip() throws { + let xsd = """ + + + + + + + + + + """ + #expect(try validate(xsd, "x").isEmpty) + } + + @Test("xs:any with processContents=strict requires a global declaration") + func test_anyStrict() throws { + let xsd = """ + + + + + + + + + + + """ + // A declared element validates against its declaration through the wildcard. + #expect(try validate(xsd, "1").isEmpty) + #expect(try !validate(xsd, "x").isEmpty) + // An undeclared element is rejected under strict. + #expect(try !validate(xsd, "").isEmpty) + } + + @Test("xs:anyAttribute admits undeclared attributes") + func test_anyAttribute() throws { + let xsd = """ + + + + + + + + + """ + #expect(try validate(xsd, "").isEmpty) + } + + @Test("Undeclared attributes are still rejected without a wildcard") + func test_noWildcardRejects() throws { + let xsd = """ + + + + + + + + """ + #expect(try !validate(xsd, "").isEmpty) + } + + @Test("List built-in datatypes validate each item") + func test_listBuiltins() throws { + let xsd = """ + + + + """ + #expect(try validate(xsd, "a b c").isEmpty) + // A space is not a valid NMTOKEN item, but spaces separate items, so this + // tests that an item with an illegal character is rejected. + #expect(try !validate(xsd, "a b@d").isEmpty) + } +}