@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)
}
}