@testable import PureXML import Testing /// Per-rule isolation tests (Validation rules DTD). @Suite("Validation rules DTD") struct ValidationRuleDTDTests { @Test("DTD.contentModel reports an EMPTY element with content at the element path") func test_contentModel() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.contentModel) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "element is declared EMPTY but has content") #expect(ValidationRuleTestSupport.path(errors[0]) == ["r"]) } @Test("DTD.contentModel accepts an EMPTY element with no content") func test_dtdContentModel_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.contentModel) .errors(for: node, in: schema) #expect(errors.isEmpty) } @Test("DTD.requiredAttributes reports a missing required attribute in isolation") func test_requiredAttributes() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.requiredAttributes) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "required attribute 'id' is missing on ") #expect(ValidationRuleTestSupport.path(errors[0]) == ["r"]) } @Test("DTD.fixedAttributeValues isolates the #FIXED constraint") func test_fixedAttributeValues() throws { // A missing required attribute is invisible to the fixed-value rule alone. let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.fixedAttributeValues) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "attribute 'v' on is #FIXED and must be \"1\"") } @Test("DTD.requiredAttributes accepts a present required attribute") func test_dtdRequiredAttributes_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.requiredAttributes).errors(for: node, in: schema).isEmpty) } @Test("DTD.fixedAttributeValues accepts the fixed value") func test_dtdFixedAttributeValues_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.fixedAttributeValues).errors(for: node, in: schema) .isEmpty) } @Test("DTD.enumeratedAttributeValues accepts a listed value") func test_dtdEnumeratedAttributeValues_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.enumeratedAttributeValues).errors(for: node, in: schema) .isEmpty) } @Test("DTD.tokenizedAttributeTypes accepts a valid NMTOKEN") func test_dtdTokenizedAttributeTypes_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.tokenizedAttributeTypes).errors(for: node, in: schema) .isEmpty) } @Test("DTD.notationAttributes accepts a declared notation") func test_dtdNotationAttributes_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport .dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.notationAttributes).errors(for: node, in: schema).isEmpty) } @Test("DTD.enumeratedAttributeValues isolates the enumeration constraint") func test_enumeratedAttributeValues() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.enumeratedAttributeValues) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "attribute 'k' on has a value outside its enumeration") } @Test("DTD.tokenizedAttributeTypes isolates the NMTOKEN constraint") func test_tokenizedAttributeTypes() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.tokenizedAttributeTypes) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason.contains("NMTOKEN") == true) } @Test("DTD.notationAttributes isolates the NOTATION constraint") func test_notationAttributes() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.notationAttributes) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason.contains("undeclared notation") == true) } @Test("DTD.undeclaredElement uses the single-error Bool form (Failed to satisfy)") func test_undeclaredElement() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.undeclaredElement) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "Failed to satisfy: Element is declared in the DTD") #expect(ValidationRuleTestSupport.path(errors[0]) == ["r"]) } @Test("DTD.identifierIntegrity reports a duplicate ID at the document root") func test_identifierIntegrity() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.identifierIntegrity) .errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason == "duplicate ID 'x' (declared 2 times)") // Runs once over the whole tree, so it is located at the document root. #expect(ValidationRuleTestSupport.path(errors[0]).isEmpty) #expect(String(describing: errors[0]).hasSuffix("at root of document")) } @Test("DTD.identifierIntegrity accepts unique IDs and resolved IDREFs") func test_dtdIdentifierIntegrity_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.identifierIntegrity).errors(for: node, in: schema) .isEmpty) } @Test("DTD.undeclaredElement accepts a declared root element") func test_dtdUndeclaredElement_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.undeclaredElement).errors(for: node, in: schema).isEmpty) } @Test("DTD.undeclaredAttributes reports an attribute not declared in the DTD") func test_dtdUndeclaredAttributes() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.undeclaredAttributes).errors(for: node, in: schema) #expect(errors.count == 1) #expect(errors.first?.reason.contains("extra") == true) } @Test("DTD.undeclaredAttributes accepts only declared attributes") func test_dtdUndeclaredAttributes_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.undeclaredAttributes).errors(for: node, in: schema) .isEmpty) } @Test("DTD.declarationValidity reports duplicate element declarations") func test_dtdDeclarationValidity() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") let errors = PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.declarationValidity).errors(for: node, in: schema) #expect(errors.contains { $0.reason.contains("declared more than once") }) } @Test("DTD.declarationValidity accepts a well-formed declaration set") func test_dtdDeclarationValidity_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.declarationValidity).errors(for: node, in: schema) .isEmpty) } @Test("DTD.rootElementType requires the root to match the DOCTYPE name") func test_dtdRootElementType() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>\n") let errors = PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.rootElementType).errors(for: node, in: schema) #expect(errors.contains { $0.reason.contains("does not match the DOCTYPE name") }) } @Test("DTD.rootElementType accepts a matching root element name") func test_dtdRootElementType_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>\n") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.rootElementType).errors(for: node, in: schema).isEmpty) } @Test("DTD.standaloneAttributes rejects an externally-declared default in standalone documents") func test_dtdStandaloneAttributes() throws { let xml = "\n\n" let (node, schema) = try ValidationRuleTestSupport.dtd(xml, resolver: ValidationRuleTestSupport.standaloneResolver()) let errors = PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.standaloneAttributes).errors(for: node, in: schema) #expect(errors.contains { $0.reason.contains("externally-declared default") }) } @Test("DTD.standaloneAttributes accepts internally-declared attributes in standalone documents") func test_dtdStandaloneAttributes_succeeds() throws { let xml = """ ]> """ let (node, schema) = try ValidationRuleTestSupport.dtd(xml, resolver: ValidationRuleTestSupport.standaloneResolver()) #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.standaloneAttributes).errors(for: node, in: schema) .isEmpty) } @Test("DTD.standaloneElementWhitespace rejects whitespace in externally-declared mixed content") func test_dtdStandaloneElementWhitespace() throws { let xml = "\n\n\n x\n" let (node, schema) = try ValidationRuleTestSupport.dtd(xml, resolver: ValidationRuleTestSupport.standaloneResolver()) let errors = PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.standaloneElementWhitespace).errors( for: node, in: schema, ) #expect(errors.contains { $0.reason.contains("whitespace in the externally-declared element content") }) } @Test("DTD.standaloneElementWhitespace accepts compact content in standalone documents") func test_dtdStandaloneElementWhitespace_succeeds() throws { let xml = "\n\nx" let (node, schema) = try ValidationRuleTestSupport.dtd(xml, resolver: ValidationRuleTestSupport.standaloneResolver()) #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.standaloneElementWhitespace).errors(for: node, in: schema) .isEmpty) } @Test("DTD.parseAdvisories surfaces parse-time advisories at the document root") func test_dtdParseAdvisories() throws { let loose = """ %outside; %undeclared; ]> """ let (node, schema) = try ValidationRuleTestSupport.dtd(loose, resolver: ValidationRuleTestSupport.standaloneResolver()) let warnings = PureXML.Validation.Validator.blank .validating(PureXML.Validation.DTD.parseAdvisories) .warnings(for: node, in: schema) #expect(warnings.contains { $0.reason.contains("'%undeclared;' is referenced but not declared") }) } @Test("DTD.parseAdvisories stays quiet when there are no advisories") func test_dtdParseAdvisories_succeeds() throws { let (node, schema) = try ValidationRuleTestSupport.dtd("]>") #expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.DTD.parseAdvisories).warnings(for: node, in: schema).isEmpty) } }