X-Git-Url: https://dreyeck.freedombox.rocks/gitweb/topic-maps.git/blobdiff_plain/d498716b1e30ca1ef2b5c124038b372851ccb731..b2eecffa:/tests/xtm-identity.lisp?ds=inline diff --git a/tests/xtm-identity.lisp b/tests/xtm-identity.lisp index 501e704..ad9de7d 100644 --- a/tests/xtm-identity.lisp +++ b/tests/xtm-identity.lisp @@ -6,10 +6,67 @@ (in-package #:topic-maps.xtm.tests) (defparameter *document* "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/in/example.xtm") +(defvar *cq-results* nil) +(defvar *cq-native* nil) +(defvar *cq-api* nil) +(defvar *cr-results* nil) +(defvar *cr-native* nil) +(defvar *cr-controls* nil) +(defvar *cr-executed* nil) +(defvar *ss-retargets* nil) +(defvar *ss-results* nil) +(defvar *ss-controls* nil) +(defvar *ss-replays* nil) +(defvar *ss-executed* nil) +(defvar *occurrence-outputs* nil) +(defvar *occurrence-controls* nil) +(defvar *registered-mergemap-outputs* nil) +(defvar *association-outputs* nil) +(defvar *item-identity-outputs* nil) +(defvar *role-reifier-native* nil) +(defvar *role-reifier-outputs* nil) +(defvar *role-reifier-controls* nil) +(defvar *association-reifier-native* nil) +(defvar *association-reifier-outputs* nil) +(defvar *association-reifier-controls* nil) +(defvar *occurrence-reifier-native* nil) +(defvar *occurrence-reifier-outputs* nil) +(defvar *occurrence-reifier-controls* nil) +(defvar *item-identity-controls* nil) +(defvar *association-controls* nil) +(defvar *mergemap-controls* nil) +(defvar *mergemap-originals* nil) +(defvar *datatype-outputs* nil) +(defvar *datatype-controls* nil) (defvar *checks* nil) (defvar *cases* nil) (defvar *outputs* nil) (defvar *fixture* nil) +(defvar *negative-outputs* nil) +(defvar *negative-controls* nil) +(defvar *name-outputs* nil) +(defvar *name-controls* nil) +(defvar *scope-outputs* nil) +(defvar *scope-controls* nil) +(defvar *iid-outputs* nil) +(defvar *iid-controls* nil) +(defvar *variant-outputs* nil) +(defvar *variant-negative-outputs* nil) +(defvar *variant-controls* nil) +(defvar *variant-merge-outputs* nil) +(defvar *resource-ref-outputs* nil) +(defvar *resource-ref-controls* nil) +(defvar *uri-data-outputs* nil) +(defvar *uri-data-controls* nil) +(defvar *variant-iid-outputs* nil) +(defvar *variant-iid-controls* nil) +(defvar *map-reifier-outputs* nil) +(defvar *map-reifier-controls* nil) +(defvar *name-reifier-outputs* nil) +(defvar *name-reifier-controls* nil) +(defvar *name-followup-outputs* nil) +(defvar *variant-reifier-outputs* nil) +(defvar *variant-reifier-controls* nil) (defun check (name truth) (push name *checks*) (unless truth (error "XTM test failed: ~A" name)) @@ -33,6 +90,7 @@ (defun core (map name) (by-si map (concatenate 'string "http://psi.topicmaps.org/iso13250/model/" name))) (defun condition-from (thunk) (handler-case (progn (funcall thunk) nil) (error (c) c))) (defun rejection (name source class code) + (setf source (ss-unsupported-source source code name)) (let ((c (condition-from (lambda () (deserialize-octets (bytes source) :document-iri *document* :source-key name))))) (check (concatenate 'string name ":class") (typep c class)) (check (concatenate 'string name ":code") (eq code (error-code c))) @@ -241,7 +299,7 @@ (dolist (spec (list (list "xml" "" 'xtm-xml-error :fail) (list "xtm" (document "") 'xtm-rejection :fail) (list "tmdm" (document "") 'item-identifier-error :fail) - (list "unsupported" (document "N") 'xtm-unsupported :unsupported))) + (list "unsupported" (document "") 'xtm-unsupported :unsupported))) (let ((case (case-record)) (c (condition-from (lambda () (deserialize-octets (bytes (second spec)) :document-iri *document*))))) (record-original-result case nil #() c) @@ -406,12 +464,13 @@ "" "]>")) (rejection (concatenate 'string "doctype:" body) (concatenate 'string body (document "")) 'xtm-xml-error :doctype-forbidden)) - (dolist (spec '(("unsupported-name" "Name" :unsupported-construct) - ("unsupported-occurrence" "v" :unsupported-construct) - ("unsupported-association" "" :unsupported-construct) - ("unsupported-mergemap" "" :unsupported-construct))) - (rejection (first spec) (document (second spec)) 'xtm-unsupported (third spec))) - (rejection "unsupported-reifier" "" 'xtm-unsupported :reification) + (dolist (spec '(("unsupported-name-variant-resourceData-datatype" "Name42" :resource-resolver-required) + ("unsupported-occurrence" "v" :resource-resolver-required) + ("unsupported-association" "" :invalid-percent-escape) + ("unsupported-mergemap" "" :resource-resolver-required))) + (rejection (first spec) (document (second spec)) + (if (equal (first spec) "unsupported-association") 'xtm-rejection 'xtm-unsupported) (third spec))) + (rejection "unsupported-occurrence-reifier" (document "O") 'xtm-unsupported :resource-resolver-required) (let ((c (condition-from (lambda () (read-body (format nil "~%~%")))))) (check "diagnostic:multiline-observed-position" (and (typep c 'xtm-rejection) (= 3 (error-line c)) (plusp (error-column c))))) (dolist (iri '(nil "relative.xtm" "https://example.test/a#fragment")) @@ -461,17 +520,23 @@ (setf *fixture* map))) (defun run-tests () - (setf *checks* nil *fixture* nil) + (setf *ss-retargets* nil *ss-results* nil *ss-controls* nil *ss-replays* nil *ss-executed* nil) + (setf *cr-results* nil *cr-native* nil *cr-controls* nil *cr-executed* nil) + (setf *cq-results* nil *cq-native* nil *cq-api* nil) + (setf *role-reifier-native* nil *role-reifier-outputs* nil *role-reifier-controls* nil *association-reifier-native* nil *association-reifier-outputs* nil *association-reifier-controls* nil *occurrence-reifier-native* nil *occurrence-reifier-outputs* nil *occurrence-reifier-controls* nil *item-identity-outputs* nil *item-identity-controls* nil *association-outputs* nil *association-controls* nil *registered-mergemap-outputs* nil *occurrence-outputs* nil *occurrence-controls* nil *mergemap-controls* nil *mergemap-originals* nil *datatype-outputs* nil *datatype-controls* nil *checks* nil *fixture* nil *negative-outputs* nil *negative-controls* nil *name-outputs* nil *name-controls* nil *scope-outputs* nil *scope-controls* nil *iid-outputs* nil *iid-controls* nil *variant-outputs* nil *variant-negative-outputs* nil *variant-controls* nil *variant-merge-outputs* nil *resource-ref-outputs* nil *resource-ref-controls* nil *uri-data-outputs* nil *uri-data-controls* nil *variant-iid-outputs* nil *variant-iid-controls* nil *map-reifier-outputs* nil *map-reifier-controls* nil *name-reifier-outputs* nil *name-reifier-controls* nil *name-followup-outputs* nil *variant-reifier-outputs* nil *variant-reifier-controls* nil) (handler-case - (progn (original-contracts) (result-classification-tests) - (semantic-tests) (identity-cascade-tests) (negative-tests) (helper-source-test)) + (progn (original-contracts) (negative-original-controls) (negative-original-contracts) + (name-original-contracts) (name-tests) (scope-original-contracts) (scope-tests) (iid-original-contracts) (iid-tests) (variant-original-contracts) (variant-negative-original) (variant-tests) (variant-merge-original-contract) (resource-ref-original-contracts) (resource-ref-tests) (uri-data-original-contract) (uri-data-tests) (variant-iid-original-contracts) (variant-iid-tests) (map-reifier-original-contract) (map-reifier-tests) (name-reifier-original-contracts) (name-reifier-tests) (name-reifier-followup-original-contracts) (variant-reifier-original-contracts) (variant-reifier-tests) (variant-reifier-followup-original-contract) (datatype-original-contract) (datatype-tests) (mergemap-tests) (occurrence-original-contracts) (occurrence-tests) (registered-mergemap-original-contracts) (association-original-contracts) (association-tests) (item-identity-original-contracts) (item-identity-tests) (orr-native-tests) (occurrence-reifier-original-contracts) (occurrence-reifier-tests) (arr-native-tests) (association-reifier-original-contracts) (association-reifier-tests) (rrr-native-tests) (role-reifier-original-contracts) (role-reifier-tests) (cq-tests) (cr-tests) (result-classification-tests) + (semantic-tests) (identity-cascade-tests) (negative-tests) (helper-source-test) (ss-tests)) (error (condition) ;; Preserve the actual failed outcome before ASDF propagates the failure. (let ((report (uiop:getenv "TOPIC_MAPS_XTM_REPORT"))) (when report (write-report report))) (error condition))) (check "checks:unique-test-names" (= (length *checks*) (length (remove-duplicates *checks* :test #'equal)))) - (format t "XTM-SUMMARY ~D PASS 0 FAIL; ~D original CXTM PASS; helper source PASS~%" (length *checks*) (length *cases*)) + (format t "XTM-SUMMARY ~D PASS 0 FAIL; ~D original CXTM PASS; ~D negative originals PASS; helper source PASS~%" + (length *checks*) (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category) + (count :invalid *cases* :key #'topic-maps.test-foundation:test-case-category)) (length *checks*)) (defun write-report (pathname) @@ -480,14 +545,15 @@ (array (items) (coerce items 'vector))) (with-open-file (out pathname :direction :output :if-exists :supersede :external-format :utf-8) (topic-maps.test-foundation::emit-json-value - (fields "scope" "XTM 2.0 identity subset, 26 registered positive contracts only; no CTM Mergemap integration" + (fields "scope" "XTM 2.0 identity/Name/Scope/Item-Identity/Variant/Reification and Occurrence/MergeMap/Association/Role subset; actual original outcomes are recorded in cases; no CTM Mergemap integration" "corpusCommit" "cd165b150176c1d6842b37be9cc9051b40d4996b" "statuses" (fields "pass" (count :pass cases :key #'topic-maps.test-foundation:test-case-status) "fail" (count :fail cases :key #'topic-maps.test-foundation:test-case-status) "unsupported" (count :unsupported cases :key #'topic-maps.test-foundation:test-case-status) "not-run" (count :not-run cases :key #'topic-maps.test-foundation:test-case-status)) - "otherCorpusInputs" (fields "positiveUnexecuted" (- (length (directory (corpus-path "xtm2/in/*.xtm"))) (length cases)) - "negativeUnregisteredUnexecuted" (length (directory (corpus-path "xtm2/invalid/*.xtm")))) + "otherCorpusInputs" (fields "positiveUnexecuted" (- (length (directory (corpus-path "xtm2/in/*.xtm"))) (count :valid cases :key #'topic-maps.test-foundation:test-case-category)) + "negativeUnregisteredUnexecuted" (- (length (directory (corpus-path "xtm2/invalid/*.xtm"))) + (count :invalid cases :key #'topic-maps.test-foundation:test-case-category))) "checks" (array (reverse *checks*)) "cases" (array (loop for case in cases collect (fields "id" (topic-maps.test-foundation:test-case-id case) @@ -498,6 +564,54 @@ "helperSource" (fields "id" "ctm/in/mergemap-xtm.sub" "status" (if fixture "pass" "not-run") "topics" (when fixture (length (topic-map-topics fixture))) "associations" (when fixture (length (topic-map-associations fixture))) "roles" 2 "ctmMergemapContract" "NOT-RUN; direct helper deserialization only") + "negativeOriginals" (array *negative-outputs*) + "negativeControls" (array *negative-controls*) + "nameOriginals" (array *name-outputs*) + "nameControls" (array *name-controls*) + "scopeOriginals" (array *scope-outputs*) + "scopeControls" (array *scope-controls*) + "nameItemIdentityOriginals" (array *iid-outputs*) + "nameItemIdentityControls" (array *iid-controls*) + "variantOriginals" (array *variant-outputs*) + "variantNegativeOriginals" (array *variant-negative-outputs*) + "variantControls" (array *variant-controls*) + "variantMergeOriginals" (array *variant-merge-outputs*) + "variantResourceRefOriginals" (array *resource-ref-outputs*) + "variantResourceRefControls" (array *resource-ref-controls*) + "variantResourceDataURIOriginals" (array *uri-data-outputs*) + "variantResourceDataURIControls" (array *uri-data-controls*) + "variantItemIdentityOriginals" (array *variant-iid-outputs*) + "variantItemIdentityControls" (array *variant-iid-controls*) + "mapReifierOriginals" (array *map-reifier-outputs*) + "mapReifierControls" (array (reverse *map-reifier-controls*)) + "nameReifierOriginals" (array *name-reifier-outputs*) + "nameReifierControls" (array (reverse *name-reifier-controls*)) + "nameFollowupOriginals" (array *name-followup-outputs*) + "variantReifierOriginals" (array *variant-reifier-outputs*) + "variantReifierControls" (array (reverse *variant-reifier-controls*)) + "datatypeOriginals" (array *datatype-outputs*) + "datatypeControls" (array *datatype-controls*) + "mergemapControls" (array *mergemap-controls*) + "mergemapOriginalObservations" (array *mergemap-originals*) + "occurrenceOriginals" (array *occurrence-outputs*) + "occurrenceControls" (array *occurrence-controls*) + "c14nPreflight" (cq-feature-report) + "resourceDataC14N" (cr-feature-report) + "anyTypeReader" (ss-report) + "roleReifierNative" (array *role-reifier-native*) + "roleReifierOriginals" (array *role-reifier-outputs*) + "roleReifierControls" (array *role-reifier-controls*) + "associationReifierNative" (array *association-reifier-native*) + "associationReifierOriginals" (array *association-reifier-outputs*) + "associationReifierControls" (array *association-reifier-controls*) + "occurrenceReifierNative" (array *occurrence-reifier-native*) + "occurrenceReifierOriginals" (array *occurrence-reifier-outputs*) + "occurrenceReifierControls" (array *occurrence-reifier-controls*) + "itemIdentityOriginals" (array *item-identity-outputs*) + "itemIdentityControls" (array *item-identity-controls*) + "associationOriginals" (array *association-outputs*) + "associationControls" (array *association-controls*) + "registeredMergemapOriginals" (array *registered-mergemap-outputs*) "actualAndExpected" (array (loop for (id actual expected model condition source-length) in *outputs* collect (fields "id" id "actual" (when actual (babel:octets-to-string actual :encoding :utf-8)) "expected" (babel:octets-to-string expected :encoding :utf-8) "byteLength" (when actual (length actual))