import Foundation @testable import PureXML import Testing /// Opt-in runner for the W3C XML Conformance Test Suite's IBM section, the /// deepest block: per-production directories covering valid, invalid, and /// not-wf cases with heavy DTD usage. Classification follows the Sun model: /// `valid` must parse and DTD-validate cleanly (strict mode), `invalid` must /// parse but report at least one validity error, `not-wf` must be rejected. /// Point `XMLCONF_ROOT` at the extracted `xmlconf` directory to run (the /// suite is never vendored; its license permits redistribution only as the /// unmodified archive). The `xml-1.1` subdirectory is out of scope: PureXML /// targets XML 1.0 Fifth Edition. Foundation is used for file access only. @Suite("W3C ibm conformance (opt-in via XMLCONF_ROOT)") struct W3CIBMSuiteTests { private var root: String? { ProcessInfo.processInfo.environment["XMLCONF_ROOT"] } /// not-wf cases this implementation knowingly accepts: both are /// parameter-entity references inside internal-subset markup declarations, /// which this package supports as a feature (the xmltest 160-162 class; /// the strict profile of #128 will reject them). private let knownNotWFAccepted: Set = [ "not-wf/P29/ibm29n03.xml", "not-wf/P29/ibm29n04.xml", ] /// Productions 85-89 are the 1998 character-class appendices (BaseChar, /// Ideographic, CombiningChar, Digit, Extender), deleted by XML 1.0 Fifth /// Edition, whose Name productions this package implements; the characters /// these cases reject became legal (the xmltest 141 class). The count is /// asserted exactly so a regression in either direction is caught (it grew /// from 279 to 300 when scalar-level lexing let combining-mark names parse /// as the Fifth Edition says they should). private let preFifthEditionCaseCount = 300 private func isPreFifthEditionCharacterClass(_ uri: String) -> Bool { (85 ... 89).contains { uri.hasPrefix("not-wf/P\($0)/") } } /// valid cases this implementation knowingly fails (parse or validation). private let knownValidFailures: Set = [] /// invalid cases where this implementation knowingly reports no validity /// error. private let knownInvalidAccepted: Set = [] private struct ManifestCase { let id: String let uri: String } /// Reads one manifest (a fragment with multiple TESTCASES roots), wrapped /// before parsing with PureXML itself. private func manifest(_ file: String, in directory: String) throws -> [ManifestCase] { let source = try String(contentsOfFile: directory + "/" + file, encoding: .utf8) let document = try PureXML.parse("\(source)") return try PureXML.xpath("//TEST", over: document).compactMap { selection in guard let element = selection.element else { return nil } func attribute(_ name: String) -> String? { element.attributes.first { $0.name.description == name }?.value } guard let id = attribute("ID"), let uri = attribute("URI") else { return nil } return ManifestCase(id: id, uri: uri) } } private func limits() -> PureXML.Parsing.Limits { PureXML.Parsing.Limits(allowDoctype: true) } /// Resolves relative SYSTEM identifiers against the case's own directory, /// byte-decoding through PureXML's own decoder. private func resolver(directory: String) -> PureXML.Parsing.EntityResolver { @Sendable func load(_ id: PureXML.Parsing.ExternalID) -> String? { guard let data = try? Data(contentsOf: URL(fileURLWithPath: directory + "/" + id.systemID)) else { return nil } return try? PureXML.Parsing.ByteDecoder.decode([UInt8](data)) } return PureXML.Parsing.EntityResolver( resolveEntity: { _, id in load(id) }, resolveExternalSubset: { id in load(id) }, ) } private func caseDirectory(_ section: String, uri: String) -> String { guard let slash = uri.lastIndex(of: "/") else { return section } return section + "/" + String(uri.prefix(upTo: slash)) } private func source(of uri: String, in section: String) throws -> String { let data = try Data(contentsOf: URL(fileURLWithPath: section + "/" + uri)) return try PureXML.Parsing.ByteDecoder.decode([UInt8](data)) } @Test("Every ibm not-wf case is rejected by the strict parser") func test_notWellFormedRejected() throws { guard let root else { return // Opt-in: suite not present. } let section = root + "/ibm" var unexpectedlyAccepted: [String] = [] var fifthEditionAccepted = 0 for testCase in try manifest("ibm_oasis_not-wf.xml", in: section) where !knownNotWFAccepted.contains(testCase.uri) { let directory = caseDirectory(section, uri: testCase.uri) let accepted = (try? PureXML.parse( source(of: testCase.uri, in: section), limits: limits(), resolver: resolver(directory: directory), )) != nil if accepted { if isPreFifthEditionCharacterClass(testCase.uri) { fifthEditionAccepted += 1 } else { unexpectedlyAccepted.append(testCase.uri) } } } #expect(unexpectedlyAccepted.isEmpty, "accepted \(unexpectedlyAccepted.count) not-wf cases: \(unexpectedlyAccepted)") #expect(fifthEditionAccepted == preFifthEditionCaseCount, "pre-5e class drifted: \(fifthEditionAccepted)") } @Test("Every ibm valid case parses and validates cleanly against its DTD") func test_validCleans() throws { guard let root else { return // Opt-in: suite not present. } let section = root + "/ibm" var failures: [String: String] = [:] for testCase in try manifest("ibm_oasis_valid.xml", in: section) where !knownValidFailures.contains(testCase.uri) { let directory = caseDirectory(section, uri: testCase.uri) do { let errors = try PureXML.validateAgainstInternalDTD( source(of: testCase.uri, in: section), limits: limits(), strict: true, resolver: resolver(directory: directory), ) if let first = errors.first { failures[testCase.uri] = String(describing: first) } } catch { failures[testCase.uri] = String(describing: error) } } #expect(failures.isEmpty, "\(failures.count) valid cases failed: \(failures)") } @Test("Every ibm invalid case parses but reports a validity error") func test_invalidReports() throws { guard let root else { return // Opt-in: suite not present. } let section = root + "/ibm" var silentlyClean: [String] = [] var parseFailures: [String: String] = [:] for testCase in try manifest("ibm_oasis_invalid.xml", in: section) where !knownInvalidAccepted.contains(testCase.uri) { let directory = caseDirectory(section, uri: testCase.uri) do { let errors = try PureXML.validateAgainstInternalDTD( source(of: testCase.uri, in: section), limits: limits(), strict: true, resolver: resolver(directory: directory), ) if errors.isEmpty { silentlyClean.append(testCase.uri) } } catch { parseFailures[testCase.uri] = String(describing: error) } } #expect(parseFailures.isEmpty, "\(parseFailures.count) invalid (well-formed) cases failed to parse: \(parseFailures)") #expect(silentlyClean.isEmpty, "\(silentlyClean.count) invalid cases validated clean: \(silentlyClean)") } }