(in-package #:topic-maps.xtm.tests) (defun variant-reifier-current-p (map) (and (name-reifier-current-p map) (every (lambda (v) (let ((r (item-reifier v))) (or (null r) (and (eq r (canonical-topic r)) (member r (topic-map-topics map) :test #'eq) (eq v (topic-reified r)))))) (all-variants map)))) (defun variant-reifier-model-data (map) (let ((topics (topic-map-topics map)) (variants (all-variants map))) (topic-maps.test-foundation::fields "identity" (name-reifier-model-data map) "canonicalVariantReifierInverseEQ" (if (variant-reifier-current-p map) :true :false) "variantReifierTopics" (coerce (mapcar (lambda (v) (when (item-reifier v) (1+ (position (item-reifier v) topics :test #'eq)))) variants) 'vector) "topicReifiedVariants" (coerce (mapcar (lambda (topic) (let ((p (position (topic-reified topic) variants :test #'eq))) (when p (1+ p)))) topics) 'vector)))) (defun variant-reifier-state (map held) (list (name-reifier-state map held) (loop for item in held when (typep item 'variant) collect (list item (topic-maps.tmdm::%variant-forward item) (topic-maps.tmdm::%variant-reifier item))))) (defun variant-reifier-pure (label map &optional held) (let* ((before (variant-reifier-state map held)) (actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*))) (check (concatenate 'string "variant-reifier:" label ":pure-deterministic-model-and-old-handles") (and (equal before (variant-reifier-state map held)) (equalp actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*)) (equal before (variant-reifier-state map held)))) actual)) (defun variant-reifier-xml (r &key (value "V") (themes '("s")) identifiers resource) (format nil "~A~A~A" (if r (format nil " reifier='~A'" r) "") (format nil "~{~A~}" (mapcar (lambda (id) (format nil "" id)) identifiers)) (scope-xml themes) (or resource (format nil "~A" value)))) (defun variant-reifier-control (label body verify) (let* ((source (document body)) (raw (bytes source)) (copy (copy-seq raw)) (map (deserialize-octets raw :document-iri *document* :source-key label))) (funcall verify map) (check (concatenate 'string "variant-reifier:" label ":canonical-native-model") (variant-reifier-current-p map)) (let ((actual (variant-reifier-pure label map (append (all-variants map) (name-reifier-names map) (topic-map-topics map))))) (check (concatenate 'string "variant-reifier:" label ":source-preserved") (equalp raw copy)) (push (topic-maps.test-foundation::fields "label" label "sourceText" source "model" (variant-reifier-model-data map) "actualCXTM" (babel:octets-to-string actual :encoding :utf-8) "condition" nil) *variant-reifier-controls*)))) (defun variant-reifier-error-control (label body class code &optional thunk map) (let ((*map-reifier-controls* nil)) (unwind-protect (map-reifier-error-control (concatenate 'string "variant:" label) (when body (document body)) class code thunk map) (when *map-reifier-controls* (push (first *map-reifier-controls*) *variant-reifier-controls*))))) (defun variant-reifier-original-contracts () (setf *variant-reifier-outputs* nil) (dolist (spec '(("variant-reifier" 326 1) ("variant-duplicate-reifier" 493 2))) (destructuring-bind (stem size source-count) spec (let* ((id (format nil "xtm2/in/~A.xtm" stem)) (*document* (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/" id)) (label (concatenate 'string "variant-reifier-original:" stem)) (raw (file-bytes (corpus-path id))) (copy (copy-seq raw)) (baseline (corpus-path (format nil "xtm2/baseline/~A.xtm.cxtm" stem))) (expected (file-bytes baseline)) (case (topic-maps.test-foundation:make-test-case :id id :category :valid :source-pathname (corpus-path id) :document-iri *document* :expected-outcome :cxtm-equal :expected-baseline baseline :clauses '("XTM 2.0 4.3.1-4.3.4,4.12,4.13,4.16" "TMDM 5.3.4,5.3.5,5.5,6.2,6.4" "CXTM 3,4"))) (map nil) (actual nil) (c nil) (calls 0)) (setf *cases* (append *cases* (list case))) (handler-case (progn (let ((saved (symbol-function 'topic-maps.xml:parse-octets)) (same nil)) (unwind-protect (progn (setf (symbol-function 'topic-maps.xml:parse-octets) (lambda (source handler) (incf calls) (setf same (eq raw source)) (funcall saved source handler))) (setf map (deserialize-octets raw :document-iri *document* :source-key id)) (check (concatenate 'string label ":qualified-parser-once-original-octets-eq") (and (= 1 calls) same))) (setf (symbol-function 'topic-maps.xml:parse-octets) saved))) (let* ((root (topic-maps.xml:parse-octets raw (make-instance 'topic-maps.xtm::source-handler))) (source-topic (first (topic-maps.xtm::elements root))) (source-names (topic-maps.xtm::elements source-topic)) (source-name (first source-names)) (source-variants (rest (topic-maps.xtm::elements source-name))) (owner (by-id map "topic")) (name (first (topic-names owner))) (v (first (all-variants map))) (r (by-id map "reifier")) (theme (by-id map "command")) (type (by-si map (default-name-type-identifier)))) (check (concatenate 'string label ":complete-original-source-properties") (and (= size (length raw)) (= 1 (length (topic-maps.xtm::elements root))) (equal "topic" (topic-maps.xtm::attr source-topic "id")) (= 1 (length source-names)) (null (topic-maps.xtm::node-attributes source-name)) (= source-count (length source-variants)) (equal '("Topic") (topic-maps.xtm::node-children (first (topic-maps.xtm::elements source-name)))) (every (lambda (node) (let* ((kids (topic-maps.xtm::elements node)) (ref (first (topic-maps.xtm::elements (first kids))))) (and (equal "variant" (topic-maps.xtm::node-name node)) (equal "#reifier" (topic-maps.xtm::attr node "reifier")) (= 1 (length (topic-maps.xtm::node-attributes node))) (equal '("scope" "resourceData") (mapcar #'topic-maps.xtm::node-name kids)) (= 1 (length (topic-maps.xtm::elements (first kids)))) (equal "#command" (topic-maps.xtm::attr ref "href")) (null (topic-maps.xtm::node-attributes (second kids))) (equal '("TOPIC!") (topic-maps.xtm::node-children (second kids)))))) source-variants))) (check (concatenate 'string label ":native-values-parents-scopes-and-reifier-inverse-eq") (and (= 4 (length (topic-map-topics map))) (null (topic-map-associations map)) (= 1 (length (name-reifier-names map))) (= 1 (length (all-variants map))) (eq owner (topic-name-parent name)) (eq name (canonical-topic-name name)) (eq type (topic-name-type name)) (equal "Topic" (topic-name-value name)) (null (topic-name-scope name)) (eq name (variant-parent v)) (eq v (canonical-variant v)) (equal "TOPIC!" (variant-value v)) (equal (string-datatype) (variant-datatype v)) (scope-eq-p (list theme) (variant-scope v)) (eq r (item-reifier v)) (eq v (topic-reified r)) (null (item-reifier map)) (null (item-reifier name)) (null (topic-reified owner)) (null (topic-reified theme)) (null (topic-reified type)) (variant-reifier-current-p map))) (check (concatenate 'string label ":complete-separated-native-identifiers") (and (null (item-identifiers map)) (null (item-identifiers name)) (null (item-identifiers v)) (null (item-identifiers type)) (equal (list (default-name-type-identifier)) (topic-subject-identifiers type)) (every (lambda (pair) (let ((topic (car pair)) (local (cdr pair))) (and (equal (list (concatenate 'string *document* "#" local)) (item-identifiers topic)) (null (topic-subject-identifiers topic)) (null (topic-subject-locators topic))))) (list (cons owner "topic") (cons r "reifier") (cons theme "command"))) (every (lambda (topic) (and (null (topic-occurrences topic)) (null (topic-roles-played topic)))) (topic-map-topics map)))) (setf actual (variant-reifier-pure stem map (list owner name v r theme type))) (check (concatenate 'string label ":original-source-and-702-baseline-bytes-preserved") (and (equalp raw copy) (= 702 (length expected)))) (let ((other (deserialize-octets raw :document-iri *document* :source-key "independent:variant-reifier"))) (check (concatenate 'string label ":source-key-independent-model-and-cxtm") (and (equalp (variant-reifier-model-data map) (variant-reifier-model-data other)) (equalp actual (topic-maps.cxtm:canonicalize-octets other :base-locator *document*))))))) (error (condition) (setf c condition))) (record-original-result case actual expected c) (push (topic-maps.test-foundation::fields "id" id "documentIRI" *document* "sourceKey" id "sourceBytes" (length raw) "sourceHex" (format nil "~{~2,'0X~}" (coerce raw 'list)) "sourceText" (babel:octets-to-string raw :encoding :utf-8) "sourceVariantCount" source-count "primaryQualifiedParserCalls" calls "model" (when map (variant-reifier-model-data map)) "condition" (map-reifier-condition-data c) "actualCXTM" (when actual (babel:octets-to-string actual :encoding :utf-8)) "expectedCXTM" (babel:octets-to-string expected :encoding :utf-8) "actualBytes" (when actual (length actual)) "expectedBytes" (length expected) "firstDifferentByte" (when actual (mismatch actual expected)) "status" (string-downcase (string (topic-maps.test-foundation:test-case-status case)))) *variant-reifier-outputs*) (when c (error c)) (check (concatenate 'string label ":byte-exact") (equalp actual expected))))) (setf *variant-reifier-outputs* (nreverse *variant-reifier-outputs*)) (check "variant-reifier-originals:70-unique-records-exactly-two-new-positives" (and (= 70 (length *cases*)) (= 62 (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category)) (= 70 (length (remove-duplicates *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal)))))) (defun variant-reifier-value-tests () (dolist (row `(("absolute" "urn:variant-r" "urn:variant-r") ("relative" "../reifiers#v" "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/reifiers#v") ("fragment" "#r" ,(concatenate 'string *document* "#r")) ("empty" "" ,*document*) ("fragment-not-topicref" "#2r/path" ,(concatenate 'string *document* "#2r/path")) ("unicode" "urn:馬🦊" "urn:馬🦊") ("percent-UTF8" "urn:%E9%A6%AC%F0%9F%A6%8A" "urn:馬🦊"))) (destructuring-bind (label reference expected) row (variant-reifier-control label (format nil "~A" (variant-name-xml nil (variant-reifier-xml reference :value " V & 馬🦊 "))) (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v)) (n (variant-parent v))) (check (concatenate 'string "variant-reifier:" label ":ii-only-not-parent-name-map-and-verbatim-value") (and (equal (list expected) (item-identifiers r)) (null (topic-subject-identifiers r)) (null (topic-subject-locators r)) (equal " V & 馬🦊 " (variant-value v)) (equal (string-datatype) (variant-datatype v)) (eq v (topic-reified r)) (null (item-reifier n)) (null (item-reifier map)) (null (topic-reified (topic-name-parent n))) (null (item-identifiers v))))))))) (dolist (row '(("II-hit" "itemIdentity" t) ("SI-not-II-hit" "subjectIdentifier" t) ("SL-separate" "subjectLocator" nil))) (destructuring-bind (label element merged) row (variant-reifier-control label (format nil "<~A href='urn:r'/>~A" element (variant-name-xml nil (variant-reifier-xml "urn:r"))) (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v)) (old (by-id map "old"))) (check (concatenate 'string "variant-reifier:" label ":required-II-added-independent-of-topicref-lookup") (and (member "urn:r" (item-identifiers r) :test #'equal) (if merged (and (eq r old) (same-identifiers-p (item-identifiers r) (list "urn:r" (concatenate 'string *document* "#old")))) (and (not (eq r old)) (equal '("urn:r") (item-identifiers r)) (null (topic-reified old))))))))))) (dolist (same '(nil t)) (let ((label (if same "equal-same-reifier" "equal-different-reifiers"))) (variant-reifier-control label (format nil "~A" (variant-name-xml '("base") (concatenate 'string (variant-reifier-xml "#r1" :themes '("s" "s") :identifiers '("urn:v1")) (variant-reifier-xml (if same "#r1" "#r2") :themes '("base" "s") :identifiers '("urn:v2"))))) (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v))) (check (concatenate 'string "variant-reifier:" label ":one-variant-unioned-II-and-reifiers-proper-scope") (and (= 1 (length (all-variants map))) (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers v)) (scope-eq-p (variant-scope v) (list (by-id map "base") (by-id map "s"))) (same-identifiers-p (item-identifiers r) (if same (list (concatenate 'string *document* "#r1")) (list (concatenate 'string *document* "#r1") (concatenate 'string *document* "#r2"))))))))))) (variant-reifier-control "different-values-ref-data-forward" (format nil "~A" (variant-name-xml '("base") (concatenate 'string (variant-reifier-xml "#r1" :identifiers '("urn:v1") :resource "") (variant-reifier-xml "#r2" :identifiers '("urn:v2") :resource "../馬") (variant-reifier-xml "#r3" :value "distinct")))) (lambda (map) (let* ((vs (all-variants map)) (a (find (iri-datatype) vs :key #'variant-datatype :test #'equal)) (b (find "distinct" vs :key #'variant-value :test #'equal))) (check "variant-reifier:ref-data-forward:native-equality-datatype-II-reifier-union" (and (= 2 (length vs)) (equal (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/馬") (variant-value a)) (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers a)) (eq (by-id map "r1") (by-id map "r2")) (eq (item-reifier a) (by-id map "definition")) (not (eq (item-reifier a) (item-reifier b))) (eq a (topic-reified (item-reifier a))) (eq b (topic-reified (item-reifier b))))))))) (defun variant-reifier-merge-tests () ;; Parent Topic, Name Scope and Variant Scope: each through SI, SL and II. (dolist (where '(:parent :name-scope :variant-scope)) (dolist (kind '("subjectIdentifier" "subjectLocator" "itemIdentity")) (let* ((label (format nil "merge-~A-~A" where kind)) (one (variant-name-xml (when (eq where :name-scope) '("x")) (variant-reifier-xml "#r1" :themes (if (eq where :variant-scope) '("x") '("extra")) :identifiers '("urn:v1")))) (two (variant-name-xml (when (eq where :name-scope) '("y")) (variant-reifier-xml "#r2" :themes (if (eq where :variant-scope) '("y") '("extra")) :identifiers '("urn:v2")))) (body (concatenate 'string (if (eq where :parent) (format nil "~A~A" one two) (format nil "~A~A" one two)) (format nil "<~A href='urn:shared'/><~A href='urn:shared'/>" kind kind))) (topic-maps.xtm::*document-iri* *document*) (topic-maps.xtm::*source-key* label) (root (topic-maps.xml:parse-octets (bytes (document body)) (make-instance 'topic-maps.xtm::source-handler))) (map (make-topic-map)) (held nil) (old-names nil) (themes nil)) (topic-maps.xtm::validate-source root) (loop for node in (topic-maps.xtm::elements root) for step from 1 do (topic-maps.xtm::read-topic node map) (when (= step (if (eq where :parent) 2 1)) (setf held (append (all-variants map) (mapcar #'item-reifier (all-variants map)))) (setf old-names (name-reifier-names map) themes (list (by-id map "x") (by-id map "y"))) (check (concatenate 'string "variant-reifier:" label ":before-two-variants-two-reifiers") (and (= 2 (length (all-variants map))) (not (eq (first held) (second held))) (not (eq (third held) (fourth held))))))) (let* ((v (first (all-variants map))) (r (item-reifier v)) (n (variant-parent v))) (check (concatenate 'string "variant-reifier:" label ":old-new-variant-name-reifier-theme-canonical-eq") (and (= 1 (length (all-variants map))) (= 1 (length (name-reifier-names map))) (eq v (canonical-variant (first held))) (eq v (canonical-variant (second held))) (eq r (canonical-topic (third held))) (eq r (canonical-topic (fourth held))) (eq v (topic-reified (third held))) (eq v (topic-reified (fourth held))) (every (lambda (old) (eq n (canonical-topic-name old))) old-names) (eq (canonical-topic (first themes)) (canonical-topic (second themes))) (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers v)) (same-identifiers-p (item-identifiers r) (list (concatenate 'string *document* "#r1") (concatenate 'string *document* "#r2"))) (case where (:parent (eq (topic-name-parent n) (by-id map "x"))) (:name-scope (and (scope-eq-p (topic-name-scope n) (list (by-id map "x"))) (scope-eq-p (variant-scope v) (list (by-id map "x") (by-id map "extra"))))) (:variant-scope (scope-eq-p (variant-scope v) (list (by-id map "x"))))) (variant-reifier-current-p map))) (variant-reifier-pure (concatenate 'string label ":staged") map (append held old-names themes)) (variant-reifier-control label body (lambda (other) (check (concatenate 'string "variant-reifier:" label ":public-api-model-equivalent") (equalp (variant-reifier-model-data map) (variant-reifier-model-data other)))))))))) (defun variant-reifier-syntax-conflict-tests () (dolist (row '(("space" "urn:a b" :invalid-iri) ("percent" "urn:%GG" :invalid-percent-escape) ("UTF8" "urn:%C3%28" :invalid-percent-utf8) ("surrogate" "urn:%ED%A0%80" :invalid-percent-utf8) ("control" "urn:%00" :invalid-iri))) (variant-reifier-error-control (first row) (format nil "~A" (variant-name-xml nil (variant-reifier-xml (second row)))) 'xtm-rejection (third row))) (dolist (row '(("attribute" "V" :unexpected-attribute) ("qualified-attribute" "V" :unexpected-attribute) ("reifier-child" "V" :unexpected-element) ("II-order" "V" :element-order) ("scope-after-resource" "V" :missing-variant-scope) ("two-scopes" "V" :duplicate-variant-scope) ("two-resources" "V" :variant-resource-cardinality))) (variant-reifier-error-control (first row) (format nil "~A" (variant-name-xml nil (second row))) 'xtm-rejection (third row))) (variant-reifier-error-control "XML" "N" 'xtm-xml-error :xml-not-well-formed) (variant-reifier-error-control "occurrence-reification-excluded" "O" 'xtm-unsupported :unsupported-construct) (dolist (row '(("variant-II-reifier-II" "NV") ("name-II-reifier-II" "NV") ("map-II-reifier-II" "NV"))) (variant-reifier-error-control (first row) (second row) 'topic-maps.tmdm::occurrence-identifier-error :duplicate-item-identifier)) (variant-reifier-error-control "reuse-reifier" (format nil "~A" (variant-name-xml nil (concatenate 'string (variant-reifier-xml "#r" :value "A") (variant-reifier-xml "#r" :value "B")))) 'reification-error :reifier-conflict) (dolist (themes '(("base") ("base" "base"))) (variant-reifier-error-control (format nil "scope-equal-~D" (length themes)) (format nil "~A" (variant-name-xml '("base") (variant-reifier-xml "#r" :themes themes))) 'variant-error :invalid-variant-scope)) (let* ((map (read-body (format nil "~A" (variant-name-xml '("base") (concatenate 'string (variant-reifier-xml "#r1" :value "A" :themes '("extra")) (variant-reifier-xml "#r2" :value "B" :themes '("extra"))))))) (vs (all-variants map)) (a (first vs)) (b (second vs)) (r (item-reifier a)) (s (item-reifier b))) (variant-reifier-error-control "native-reuse-reifier" nil 'reification-error :reifier-conflict (lambda () (set-item-reifier b r)) map) (variant-reifier-error-control "native-distinct-reified-merge" nil 'reification-error :reifier-conflict (lambda () (merge-topics r s)) map) (variant-reifier-error-control "native-scope-collapse" nil 'variant-error :variant-scope-collapse (lambda () (merge-topics (by-id map "base") (by-id map "extra"))) map) (check "variant-reifier:conflicts:canonical-variant-reifier-parent-scope-inverses-retained" (and (eq a (canonical-variant a)) (eq b (canonical-variant b)) (eq r (item-reifier a)) (eq s (item-reifier b)) (eq a (topic-reified r)) (eq b (topic-reified s)) (variant-reifier-current-p map))) (variant-reifier-pure "native-conflicts" map (list a b r s))) (variant-reifier-error-control "reifier-merge-collapses-scope" (format nil "~A" (variant-name-xml '("base") (concatenate 'string (variant-reifier-xml "#extra" :themes '("extra")) (variant-reifier-xml "#base" :themes '("extra"))))) 'variant-error :variant-scope-collapse) (let* ((map (read-body (format nil "~A" (variant-name-xml '("base") (variant-reifier-xml "#extra" :themes '("extra")))))) (v (first (all-variants map))) (r (item-reifier v))) (variant-reifier-error-control "native-reifier-merge-collapses-scope" nil 'variant-error :variant-scope-collapse (lambda () (set-item-reifier v (by-id map "base"))) map) (check "variant-reifier:scope-collapse:old-canonical-variant-reifier-inverse-retained" (and (eq v (canonical-variant v)) (eq r (item-reifier v)) (eq v (topic-reified r)) (variant-reifier-current-p map)))) ;; Parent Topics reifying DIFFERENT Variants may not be merged even when ;; their Names and Variants would become equal as a consequence. (let* ((map (read-body (format nil "~A~A" (variant-name-xml nil (variant-reifier-xml "#a")) (variant-name-xml nil (variant-reifier-xml "#b")))))) (variant-reifier-error-control "native-parent-reifier-conflict" nil 'reification-error :reifier-conflict (lambda () (merge-topics (by-id map "a") (by-id map "b"))) map))) (defun variant-reifier-tests () (variant-reifier-value-tests) (variant-reifier-merge-tests) (variant-reifier-syntax-conflict-tests))