(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))