]> dreyeck.freedombox.rocks Git - topic-maps.git/blob - tests/xtm-variant-reification.lisp
Support arbitrary absolute XTM resourceData datatypes (Slice 22D)
[topic-maps.git] / tests / xtm-variant-reification.lisp
1 (in-package #:topic-maps.xtm.tests)
2
3 (defun variant-reifier-current-p (map)
4 (and (name-reifier-current-p map)
5 (every (lambda (v) (let ((r (item-reifier v)))
6 (or (null r) (and (eq r (canonical-topic r)) (member r (topic-map-topics map) :test #'eq)
7 (eq v (topic-reified r)))))) (all-variants map))))
8 (defun variant-reifier-model-data (map)
9 (let ((topics (topic-map-topics map)) (variants (all-variants map)))
10 (topic-maps.test-foundation::fields "identity" (name-reifier-model-data map)
11 "canonicalVariantReifierInverseEQ" (if (variant-reifier-current-p map) :true :false)
12 "variantReifierTopics" (coerce (mapcar (lambda (v) (when (item-reifier v)
13 (1+ (position (item-reifier v) topics :test #'eq)))) variants) 'vector)
14 "topicReifiedVariants" (coerce (mapcar (lambda (topic) (let ((p (position (topic-reified topic) variants :test #'eq)))
15 (when p (1+ p)))) topics) 'vector))))
16 (defun variant-reifier-state (map held)
17 (list (name-reifier-state map held)
18 (loop for item in held when (typep item 'variant) collect
19 (list item (topic-maps.tmdm::%variant-forward item) (topic-maps.tmdm::%variant-reifier item)))))
20 (defun variant-reifier-pure (label map &optional held)
21 (let* ((before (variant-reifier-state map held))
22 (actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*)))
23 (check (concatenate 'string "variant-reifier:" label ":pure-deterministic-model-and-old-handles")
24 (and (equal before (variant-reifier-state map held))
25 (equalp actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*))
26 (equal before (variant-reifier-state map held))))
27 actual))
28 (defun variant-reifier-xml (r &key (value "V") (themes '("s")) identifiers resource)
29 (format nil "<variant~A>~A~A~A</variant>"
30 (if r (format nil " reifier='~A'" r) "")
31 (format nil "~{~A~}" (mapcar (lambda (id) (format nil "<itemIdentity href='~A'/>" id)) identifiers))
32 (scope-xml themes) (or resource (format nil "<resourceData>~A</resourceData>" value))))
33 (defun variant-reifier-control (label body verify)
34 (let* ((source (document body)) (raw (bytes source)) (copy (copy-seq raw))
35 (map (deserialize-octets raw :document-iri *document* :source-key label)))
36 (funcall verify map)
37 (check (concatenate 'string "variant-reifier:" label ":canonical-native-model") (variant-reifier-current-p map))
38 (let ((actual (variant-reifier-pure label map (append (all-variants map) (name-reifier-names map) (topic-map-topics map)))))
39 (check (concatenate 'string "variant-reifier:" label ":source-preserved") (equalp raw copy))
40 (push (topic-maps.test-foundation::fields "label" label "sourceText" source
41 "model" (variant-reifier-model-data map) "actualCXTM" (babel:octets-to-string actual :encoding :utf-8)
42 "condition" nil) *variant-reifier-controls*))))
43 (defun variant-reifier-error-control (label body class code &optional thunk map)
44 (let ((*map-reifier-controls* nil))
45 (unwind-protect
46 (map-reifier-error-control (concatenate 'string "variant:" label) (when body (document body)) class code thunk map)
47 (when *map-reifier-controls* (push (first *map-reifier-controls*) *variant-reifier-controls*)))))
48
49 (defun variant-reifier-original-contracts ()
50 (setf *variant-reifier-outputs* nil)
51 (dolist (spec '(("variant-reifier" 326 1) ("variant-duplicate-reifier" 493 2)))
52 (destructuring-bind (stem size source-count) spec
53 (let* ((id (format nil "xtm2/in/~A.xtm" stem))
54 (*document* (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/" id))
55 (label (concatenate 'string "variant-reifier-original:" stem)) (raw (file-bytes (corpus-path id))) (copy (copy-seq raw))
56 (baseline (corpus-path (format nil "xtm2/baseline/~A.xtm.cxtm" stem))) (expected (file-bytes baseline))
57 (case (topic-maps.test-foundation:make-test-case :id id :category :valid :source-pathname (corpus-path id)
58 :document-iri *document* :expected-outcome :cxtm-equal :expected-baseline baseline
59 :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")))
60 (map nil) (actual nil) (c nil) (calls 0))
61 (setf *cases* (append *cases* (list case)))
62 (handler-case
63 (progn
64 (let ((saved (symbol-function 'topic-maps.xml:parse-octets)) (same nil))
65 (unwind-protect
66 (progn (setf (symbol-function 'topic-maps.xml:parse-octets)
67 (lambda (source handler) (incf calls) (setf same (eq raw source)) (funcall saved source handler)))
68 (setf map (deserialize-octets raw :document-iri *document* :source-key id))
69 (check (concatenate 'string label ":qualified-parser-once-original-octets-eq") (and (= 1 calls) same)))
70 (setf (symbol-function 'topic-maps.xml:parse-octets) saved)))
71 (let* ((root (topic-maps.xml:parse-octets raw (make-instance 'topic-maps.xtm::source-handler)))
72 (source-topic (first (topic-maps.xtm::elements root))) (source-names (topic-maps.xtm::elements source-topic))
73 (source-name (first source-names)) (source-variants (rest (topic-maps.xtm::elements source-name)))
74 (owner (by-id map "topic")) (name (first (topic-names owner))) (v (first (all-variants map)))
75 (r (by-id map "reifier")) (theme (by-id map "command")) (type (by-si map (default-name-type-identifier))))
76 (check (concatenate 'string label ":complete-original-source-properties")
77 (and (= size (length raw)) (= 1 (length (topic-maps.xtm::elements root)))
78 (equal "topic" (topic-maps.xtm::attr source-topic "id")) (= 1 (length source-names))
79 (null (topic-maps.xtm::node-attributes source-name)) (= source-count (length source-variants))
80 (equal '("Topic") (topic-maps.xtm::node-children (first (topic-maps.xtm::elements source-name))))
81 (every (lambda (node) (let* ((kids (topic-maps.xtm::elements node)) (ref (first (topic-maps.xtm::elements (first kids)))))
82 (and (equal "variant" (topic-maps.xtm::node-name node)) (equal "#reifier" (topic-maps.xtm::attr node "reifier"))
83 (= 1 (length (topic-maps.xtm::node-attributes node)))
84 (equal '("scope" "resourceData") (mapcar #'topic-maps.xtm::node-name kids))
85 (= 1 (length (topic-maps.xtm::elements (first kids)))) (equal "#command" (topic-maps.xtm::attr ref "href"))
86 (null (topic-maps.xtm::node-attributes (second kids))) (equal '("TOPIC!") (topic-maps.xtm::node-children (second kids)))))) source-variants)))
87 (check (concatenate 'string label ":native-values-parents-scopes-and-reifier-inverse-eq")
88 (and (= 4 (length (topic-map-topics map))) (null (topic-map-associations map))
89 (= 1 (length (name-reifier-names map))) (= 1 (length (all-variants map)))
90 (eq owner (topic-name-parent name)) (eq name (canonical-topic-name name)) (eq type (topic-name-type name))
91 (equal "Topic" (topic-name-value name)) (null (topic-name-scope name))
92 (eq name (variant-parent v)) (eq v (canonical-variant v))
93 (equal "TOPIC!" (variant-value v)) (equal (string-datatype) (variant-datatype v))
94 (scope-eq-p (list theme) (variant-scope v)) (eq r (item-reifier v)) (eq v (topic-reified r))
95 (null (item-reifier map)) (null (item-reifier name)) (null (topic-reified owner))
96 (null (topic-reified theme)) (null (topic-reified type)) (variant-reifier-current-p map)))
97 (check (concatenate 'string label ":complete-separated-native-identifiers")
98 (and (null (item-identifiers map)) (null (item-identifiers name)) (null (item-identifiers v))
99 (null (item-identifiers type)) (equal (list (default-name-type-identifier)) (topic-subject-identifiers type))
100 (every (lambda (pair) (let ((topic (car pair)) (local (cdr pair)))
101 (and (equal (list (concatenate 'string *document* "#" local)) (item-identifiers topic))
102 (null (topic-subject-identifiers topic)) (null (topic-subject-locators topic)))))
103 (list (cons owner "topic") (cons r "reifier") (cons theme "command")))
104 (every (lambda (topic) (and (null (topic-occurrences topic)) (null (topic-roles-played topic)))) (topic-map-topics map))))
105 (setf actual (variant-reifier-pure stem map (list owner name v r theme type)))
106 (check (concatenate 'string label ":original-source-and-702-baseline-bytes-preserved")
107 (and (equalp raw copy) (= 702 (length expected))))
108 (let ((other (deserialize-octets raw :document-iri *document* :source-key "independent:variant-reifier")))
109 (check (concatenate 'string label ":source-key-independent-model-and-cxtm")
110 (and (equalp (variant-reifier-model-data map) (variant-reifier-model-data other))
111 (equalp actual (topic-maps.cxtm:canonicalize-octets other :base-locator *document*)))))))
112 (error (condition) (setf c condition)))
113 (record-original-result case actual expected c)
114 (push (topic-maps.test-foundation::fields "id" id "documentIRI" *document* "sourceKey" id
115 "sourceBytes" (length raw) "sourceHex" (format nil "~{~2,'0X~}" (coerce raw 'list))
116 "sourceText" (babel:octets-to-string raw :encoding :utf-8) "sourceVariantCount" source-count
117 "primaryQualifiedParserCalls" calls "model" (when map (variant-reifier-model-data map)) "condition" (map-reifier-condition-data c)
118 "actualCXTM" (when actual (babel:octets-to-string actual :encoding :utf-8))
119 "expectedCXTM" (babel:octets-to-string expected :encoding :utf-8)
120 "actualBytes" (when actual (length actual)) "expectedBytes" (length expected)
121 "firstDifferentByte" (when actual (mismatch actual expected))
122 "status" (string-downcase (string (topic-maps.test-foundation:test-case-status case)))) *variant-reifier-outputs*)
123 (when c (error c))
124 (check (concatenate 'string label ":byte-exact") (equalp actual expected)))))
125 (setf *variant-reifier-outputs* (nreverse *variant-reifier-outputs*))
126 (check "variant-reifier-originals:70-unique-records-exactly-two-new-positives"
127 (and (= 70 (length *cases*)) (= 62 (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category))
128 (= 70 (length (remove-duplicates *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal))))))
129
130 (defun variant-reifier-value-tests ()
131 (dolist (row `(("absolute" "urn:variant-r" "urn:variant-r")
132 ("relative" "../reifiers#v" "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/reifiers#v")
133 ("fragment" "#r" ,(concatenate 'string *document* "#r")) ("empty" "" ,*document*)
134 ("fragment-not-topicref" "#2r/path" ,(concatenate 'string *document* "#2r/path"))
135 ("unicode" "urn:馬🦊" "urn:馬🦊") ("percent-UTF8" "urn:%E9%A6%AC%F0%9F%A6%8A" "urn:馬🦊")))
136 (destructuring-bind (label reference expected) row
137 (variant-reifier-control label (format nil "<topic id='a'>~A</topic>"
138 (variant-name-xml nil (variant-reifier-xml reference :value " V &amp; 馬🦊 ")))
139 (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v)) (n (variant-parent v)))
140 (check (concatenate 'string "variant-reifier:" label ":ii-only-not-parent-name-map-and-verbatim-value")
141 (and (equal (list expected) (item-identifiers r)) (null (topic-subject-identifiers r)) (null (topic-subject-locators r))
142 (equal " V & 馬🦊 " (variant-value v)) (equal (string-datatype) (variant-datatype v))
143 (eq v (topic-reified r)) (null (item-reifier n)) (null (item-reifier map))
144 (null (topic-reified (topic-name-parent n))) (null (item-identifiers v)))))))))
145 (dolist (row '(("II-hit" "itemIdentity" t) ("SI-not-II-hit" "subjectIdentifier" t) ("SL-separate" "subjectLocator" nil)))
146 (destructuring-bind (label element merged) row
147 (variant-reifier-control label
148 (format nil "<topic id='old'><~A href='urn:r'/></topic><topic id='a'>~A</topic>" element
149 (variant-name-xml nil (variant-reifier-xml "urn:r")))
150 (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v)) (old (by-id map "old")))
151 (check (concatenate 'string "variant-reifier:" label ":required-II-added-independent-of-topicref-lookup")
152 (and (member "urn:r" (item-identifiers r) :test #'equal)
153 (if merged (and (eq r old) (same-identifiers-p (item-identifiers r) (list "urn:r" (concatenate 'string *document* "#old"))))
154 (and (not (eq r old)) (equal '("urn:r") (item-identifiers r)) (null (topic-reified old)))))))))))
155 (dolist (same '(nil t))
156 (let ((label (if same "equal-same-reifier" "equal-different-reifiers")))
157 (variant-reifier-control label
158 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base")
159 (concatenate 'string (variant-reifier-xml "#r1" :themes '("s" "s") :identifiers '("urn:v1"))
160 (variant-reifier-xml (if same "#r1" "#r2") :themes '("base" "s") :identifiers '("urn:v2")))))
161 (lambda (map) (let* ((v (first (all-variants map))) (r (item-reifier v)))
162 (check (concatenate 'string "variant-reifier:" label ":one-variant-unioned-II-and-reifiers-proper-scope")
163 (and (= 1 (length (all-variants map))) (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers v))
164 (scope-eq-p (variant-scope v) (list (by-id map "base") (by-id map "s")))
165 (same-identifiers-p (item-identifiers r) (if same (list (concatenate 'string *document* "#r1"))
166 (list (concatenate 'string *document* "#r1") (concatenate 'string *document* "#r2")))))))))))
167 (variant-reifier-control "different-values-ref-data-forward"
168 (format nil "<topic id='a'>~A</topic><topic id='definition'><itemIdentity href='#r1'/></topic>"
169 (variant-name-xml '("base") (concatenate 'string
170 (variant-reifier-xml "#r1" :identifiers '("urn:v1") :resource "<resourceRef href='../馬'/>")
171 (variant-reifier-xml "#r2" :identifiers '("urn:v2") :resource "<resourceData datatype='http://www.w3.org/2001/XMLSchema#anyURI'>../馬</resourceData>")
172 (variant-reifier-xml "#r3" :value "distinct"))))
173 (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)))
174 (check "variant-reifier:ref-data-forward:native-equality-datatype-II-reifier-union"
175 (and (= 2 (length vs)) (equal (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/馬") (variant-value a))
176 (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers a))
177 (eq (by-id map "r1") (by-id map "r2")) (eq (item-reifier a) (by-id map "definition"))
178 (not (eq (item-reifier a) (item-reifier b))) (eq a (topic-reified (item-reifier a))) (eq b (topic-reified (item-reifier b)))))))))
179
180 (defun variant-reifier-merge-tests ()
181 ;; Parent Topic, Name Scope and Variant Scope: each through SI, SL and II.
182 (dolist (where '(:parent :name-scope :variant-scope))
183 (dolist (kind '("subjectIdentifier" "subjectLocator" "itemIdentity"))
184 (let* ((label (format nil "merge-~A-~A" where kind))
185 (one (variant-name-xml (when (eq where :name-scope) '("x"))
186 (variant-reifier-xml "#r1" :themes (if (eq where :variant-scope) '("x") '("extra")) :identifiers '("urn:v1"))))
187 (two (variant-name-xml (when (eq where :name-scope) '("y"))
188 (variant-reifier-xml "#r2" :themes (if (eq where :variant-scope) '("y") '("extra")) :identifiers '("urn:v2"))))
189 (body (concatenate 'string
190 (if (eq where :parent) (format nil "<topic id='x'>~A</topic><topic id='y'>~A</topic>" one two)
191 (format nil "<topic id='a'>~A~A</topic>" one two))
192 (format nil "<topic id='first'><itemIdentity href='#x'/><~A href='urn:shared'/></topic><topic id='last'><itemIdentity href='#y'/><~A href='urn:shared'/></topic>" kind kind)))
193 (topic-maps.xtm::*document-iri* *document*) (topic-maps.xtm::*source-key* label)
194 (root (topic-maps.xml:parse-octets (bytes (document body)) (make-instance 'topic-maps.xtm::source-handler)))
195 (map (make-topic-map)) (held nil) (old-names nil) (themes nil))
196 (topic-maps.xtm::validate-source root)
197 (loop for node in (topic-maps.xtm::elements root) for step from 1 do
198 (topic-maps.xtm::read-topic node map)
199 (when (= step (if (eq where :parent) 2 1))
200 (setf held (append (all-variants map) (mapcar #'item-reifier (all-variants map))))
201 (setf old-names (name-reifier-names map) themes (list (by-id map "x") (by-id map "y")))
202 (check (concatenate 'string "variant-reifier:" label ":before-two-variants-two-reifiers")
203 (and (= 2 (length (all-variants map))) (not (eq (first held) (second held))) (not (eq (third held) (fourth held)))))))
204 (let* ((v (first (all-variants map))) (r (item-reifier v)) (n (variant-parent v)))
205 (check (concatenate 'string "variant-reifier:" label ":old-new-variant-name-reifier-theme-canonical-eq")
206 (and (= 1 (length (all-variants map))) (= 1 (length (name-reifier-names map)))
207 (eq v (canonical-variant (first held))) (eq v (canonical-variant (second held)))
208 (eq r (canonical-topic (third held))) (eq r (canonical-topic (fourth held)))
209 (eq v (topic-reified (third held))) (eq v (topic-reified (fourth held)))
210 (every (lambda (old) (eq n (canonical-topic-name old))) old-names)
211 (eq (canonical-topic (first themes)) (canonical-topic (second themes)))
212 (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers v))
213 (same-identifiers-p (item-identifiers r) (list (concatenate 'string *document* "#r1") (concatenate 'string *document* "#r2")))
214 (case where (:parent (eq (topic-name-parent n) (by-id map "x")))
215 (:name-scope (and (scope-eq-p (topic-name-scope n) (list (by-id map "x")))
216 (scope-eq-p (variant-scope v) (list (by-id map "x") (by-id map "extra")))))
217 (:variant-scope (scope-eq-p (variant-scope v) (list (by-id map "x")))))
218 (variant-reifier-current-p map)))
219 (variant-reifier-pure (concatenate 'string label ":staged") map (append held old-names themes))
220 (variant-reifier-control label body (lambda (other)
221 (check (concatenate 'string "variant-reifier:" label ":public-api-model-equivalent")
222 (equalp (variant-reifier-model-data map) (variant-reifier-model-data other))))))))))
223
224 (defun variant-reifier-syntax-conflict-tests ()
225 (dolist (row '(("space" "urn:a b" :invalid-iri) ("percent" "urn:%GG" :invalid-percent-escape)
226 ("UTF8" "urn:%C3%28" :invalid-percent-utf8) ("surrogate" "urn:%ED%A0%80" :invalid-percent-utf8)
227 ("control" "urn:%00" :invalid-iri)))
228 (variant-reifier-error-control (first row)
229 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (variant-reifier-xml (second row)))) 'xtm-rejection (third row)))
230 (dolist (row '(("attribute" "<variant reifier='#r' other='x'><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant>" :unexpected-attribute)
231 ("qualified-attribute" "<variant xmlns:q='urn:q' q:reifier='#r'><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant>" :unexpected-attribute)
232 ("reifier-child" "<variant><reifier href='#r'/><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant>" :unexpected-element)
233 ("II-order" "<variant reifier='#r'><scope><topicRef href='#s'/></scope><itemIdentity href='urn:v'/><resourceData>V</resourceData></variant>" :element-order)
234 ("scope-after-resource" "<variant reifier='#r'><resourceData>V</resourceData><scope><topicRef href='#s'/></scope></variant>" :missing-variant-scope)
235 ("two-scopes" "<variant reifier='#r'><scope><topicRef href='#s'/></scope><scope><topicRef href='#t'/></scope><resourceData>V</resourceData></variant>" :duplicate-variant-scope)
236 ("two-resources" "<variant reifier='#r'><scope><topicRef href='#s'/></scope><resourceData>V</resourceData><resourceRef href='urn:r'/></variant>" :variant-resource-cardinality)))
237 (variant-reifier-error-control (first row) (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (second row))) 'xtm-rejection (third row)))
238 (variant-reifier-error-control "XML" "<topic id='a'><name><value>N</value><variant reifier='#r'></name></topic>" 'xtm-xml-error :xml-not-well-formed)
239 (variant-reifier-error-control "occurrence-reification-excluded"
240 "<topic id='a'><occurrence reifier='#r'><type><topicRef href='#t'/></type><resourceData>O</resourceData></occurrence></topic>" 'xtm-unsupported :unsupported-construct)
241 (dolist (row '(("variant-II-reifier-II" "<topic id='a'><name><value>N</value><variant reifier='urn:v'><itemIdentity href='urn:v'/><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant></name></topic>")
242 ("name-II-reifier-II" "<topic id='a'><name><itemIdentity href='urn:n'/><value>N</value><variant reifier='urn:n'><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant></name></topic>")
243 ("map-II-reifier-II" "<itemIdentity href='urn:m'/><topic id='a'><name><value>N</value><variant reifier='urn:m'><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant></name></topic>")))
244 (variant-reifier-error-control (first row) (second row) 'topic-maps.tmdm::occurrence-identifier-error :duplicate-item-identifier))
245 (variant-reifier-error-control "reuse-reifier"
246 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (concatenate 'string
247 (variant-reifier-xml "#r" :value "A") (variant-reifier-xml "#r" :value "B")))) 'reification-error :reifier-conflict)
248 (dolist (themes '(("base") ("base" "base")))
249 (variant-reifier-error-control (format nil "scope-equal-~D" (length themes))
250 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base") (variant-reifier-xml "#r" :themes themes))) 'variant-error :invalid-variant-scope))
251 (let* ((map (read-body (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base")
252 (concatenate 'string (variant-reifier-xml "#r1" :value "A" :themes '("extra"))
253 (variant-reifier-xml "#r2" :value "B" :themes '("extra")))))))
254 (vs (all-variants map)) (a (first vs)) (b (second vs)) (r (item-reifier a)) (s (item-reifier b)))
255 (variant-reifier-error-control "native-reuse-reifier" nil 'reification-error :reifier-conflict (lambda () (set-item-reifier b r)) map)
256 (variant-reifier-error-control "native-distinct-reified-merge" nil 'reification-error :reifier-conflict (lambda () (merge-topics r s)) map)
257 (variant-reifier-error-control "native-scope-collapse" nil 'variant-error :variant-scope-collapse
258 (lambda () (merge-topics (by-id map "base") (by-id map "extra"))) map)
259 (check "variant-reifier:conflicts:canonical-variant-reifier-parent-scope-inverses-retained"
260 (and (eq a (canonical-variant a)) (eq b (canonical-variant b)) (eq r (item-reifier a)) (eq s (item-reifier b))
261 (eq a (topic-reified r)) (eq b (topic-reified s)) (variant-reifier-current-p map)))
262 (variant-reifier-pure "native-conflicts" map (list a b r s)))
263 (variant-reifier-error-control "reifier-merge-collapses-scope"
264 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base")
265 (concatenate 'string (variant-reifier-xml "#extra" :themes '("extra"))
266 (variant-reifier-xml "#base" :themes '("extra"))))) 'variant-error :variant-scope-collapse)
267 (let* ((map (read-body (format nil "<topic id='a'>~A</topic>"
268 (variant-name-xml '("base") (variant-reifier-xml "#extra" :themes '("extra"))))))
269 (v (first (all-variants map))) (r (item-reifier v)))
270 (variant-reifier-error-control "native-reifier-merge-collapses-scope" nil 'variant-error :variant-scope-collapse
271 (lambda () (set-item-reifier v (by-id map "base"))) map)
272 (check "variant-reifier:scope-collapse:old-canonical-variant-reifier-inverse-retained"
273 (and (eq v (canonical-variant v)) (eq r (item-reifier v)) (eq v (topic-reified r)) (variant-reifier-current-p map))))
274 ;; Parent Topics reifying DIFFERENT Variants may not be merged even when
275 ;; their Names and Variants would become equal as a consequence.
276 (let* ((map (read-body (format nil "<topic id='a'>~A</topic><topic id='b'>~A</topic>"
277 (variant-name-xml nil (variant-reifier-xml "#a")) (variant-name-xml nil (variant-reifier-xml "#b"))))))
278 (variant-reifier-error-control "native-parent-reifier-conflict" nil 'reification-error :reifier-conflict
279 (lambda () (merge-topics (by-id map "a") (by-id map "b"))) map)))
280
281 (defun variant-reifier-tests ()
282 (variant-reifier-value-tests) (variant-reifier-merge-tests) (variant-reifier-syntax-conflict-tests))
283
284 ;; Slice 22B: the unchanged duplicate-Name original uses the same executor,
285 ;; Case Records and model serializers as the two Slice-21O originals above.
286 (defun variant-reifier-followup-original-contract ()
287 (let* ((id "xtm2/in/variant-duplicate-reifier2.xtm")
288 (*document* (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/" id))
289 (label "variant-reifier-original:variant-duplicate-reifier2")
290 (raw (file-bytes (corpus-path id))) (copy (copy-seq raw))
291 (baseline (corpus-path "xtm2/baseline/variant-duplicate-reifier2.xtm.cxtm"))
292 (expected (file-bytes baseline))
293 (case (topic-maps.test-foundation:make-test-case :id id :category :valid :source-pathname (corpus-path id)
294 :document-iri *document* :expected-outcome :cxtm-equal :expected-baseline baseline
295 :clauses '("XTM 2.0 4.3.2,4.10-4.13,4.16" "TMDM 5.4-5.5,6.3-6.4" "CXTM 3,4")))
296 (map nil) (actual nil) (condition nil) (root nil) (calls 0) (same nil)
297 (names nil) (pairs nil) (proof nil))
298 (check (concatenate 'string label ":not-previously-registered")
299 (not (find id *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal)))
300 (setf *cases* (append *cases* (list case)))
301 (handler-case
302 (progn
303 ;; Passive observers retain actual handles from this public import.
304 ;; Restore every function even if XML, reader or model execution fails.
305 (let ((parse (symbol-function 'topic-maps.xml:parse-octets))
306 (read-name (symbol-function 'topic-maps.xtm::read-name))
307 (normalize (symbol-function 'topic-maps.tmdm::normalize-variants)))
308 (unwind-protect
309 (progn
310 (setf (symbol-function 'topic-maps.xml:parse-octets)
311 (lambda (source handler) (incf calls) (setf same (eq raw source))
312 (setf root (funcall parse source handler))))
313 (setf (symbol-function 'topic-maps.xtm::read-name)
314 (lambda (node owner result)
315 (let ((name (funcall read-name node owner result))) (push name names) name)))
316 (setf (symbol-function 'topic-maps.tmdm::normalize-variants)
317 (lambda (result)
318 (let ((held (all-variants result)))
319 (when (= 2 (length held)) (push (copy-list held) pairs)))
320 (funcall normalize result)))
321 (setf map (deserialize-octets raw :document-iri *document* :source-key id)))
322 (setf (symbol-function 'topic-maps.xml:parse-octets) parse
323 (symbol-function 'topic-maps.xtm::read-name) read-name
324 (symbol-function 'topic-maps.tmdm::normalize-variants) normalize)))
325 (check (concatenate 'string label ":qualified-parser-once-original-octets-eq") (and (= calls 1) same))
326 (let* ((source-topics (topic-maps.xtm::elements root)) (source-topic (first source-topics))
327 (source-names (topic-maps.xtm::elements source-topic))
328 (owner (by-id map "topic")) (name (first (topic-names owner)))
329 (v (first (all-variants map))) (r (by-id map "reifier"))
330 (theme (by-id map "command")) (type (by-si map (default-name-type-identifier)))
331 (held (first pairs)))
332 (check (concatenate 'string label ":543-byte-original-two-names-two-reified-variants")
333 (and (= 543 (length raw)) (= 1 (length source-topics))
334 (equal "topic" (topic-maps.xtm::attr source-topic "id")) (= 2 (length source-names))
335 (every (lambda (n)
336 (let* ((kids (topic-maps.xtm::elements n)) (variant (second kids))
337 (vkids (topic-maps.xtm::elements variant)))
338 (and (equal "name" (topic-maps.xtm::node-name n)) (null (topic-maps.xtm::node-attributes n))
339 (equal '("value" "variant") (mapcar #'topic-maps.xtm::node-name kids))
340 (equal '("Topic") (topic-maps.xtm::node-children (first kids)))
341 (equal "#reifier" (topic-maps.xtm::attr variant "reifier"))
342 (= 1 (length (topic-maps.xtm::node-attributes variant)))
343 (equal '("scope" "resourceData") (mapcar #'topic-maps.xtm::node-name vkids))
344 (= 1 (length (topic-maps.xtm::elements (first vkids))))
345 (equal "#command" (topic-maps.xtm::attr (first (topic-maps.xtm::elements (first vkids))) "href"))
346 (null (topic-maps.xtm::node-attributes (second vkids)))
347 (equal '("TOPIC!") (topic-maps.xtm::node-children (second vkids)))))) source-names)))
348 (check (concatenate 'string label ":one-native-name-variant-parent-type-scope-eq")
349 (and (= 4 (length (topic-map-topics map))) (null (topic-map-associations map))
350 (= 1 (length (name-reifier-names map))) (= 1 (length (all-variants map)))
351 (every (lambda (topic) (eq map (topic-parent topic))) (topic-map-topics map))
352 (eq owner (topic-name-parent name)) (eq name (canonical-topic-name name))
353 (eq type (topic-name-type name)) (equal "Topic" (topic-name-value name)) (null (topic-name-scope name))
354 (eq name (variant-parent v)) (eq v (canonical-variant v))
355 (scope-eq-p (list theme) (variant-scope v)) (variant-reifier-current-p map)))
356 (check (concatenate 'string label ":verbatim-value-string-datatype-and-canonical-reifier-inverse-eq")
357 (and (equal "TOPIC!" (variant-value v)) (equal (string-datatype) (variant-datatype v))
358 (eq r (canonical-topic r)) (eq r (item-reifier v)) (eq v (topic-reified r))
359 (null (item-reifier map)) (null (item-reifier name))
360 (every (lambda (topic) (null (topic-reified topic))) (list owner theme type))))
361 (check (concatenate 'string label ":complete-separated-identifiers")
362 (and (null (item-identifiers map)) (null (item-identifiers name)) (null (item-identifiers v))
363 (null (item-identifiers type)) (equal (list (default-name-type-identifier)) (topic-subject-identifiers type))
364 (null (topic-subject-locators type))
365 (every (lambda (pair)
366 (and (equal (list (concatenate 'string *document* "#" (cdr pair))) (item-identifiers (car pair)))
367 (null (topic-subject-identifiers (car pair))) (null (topic-subject-locators (car pair)))))
368 (list (cons owner "topic") (cons theme "command") (cons r "reifier")))
369 (every (lambda (topic) (and (null (topic-occurrences topic)) (null (topic-roles-played topic))))
370 (topic-map-topics map))))
371 (check (concatenate 'string label ":retained-pre-normalization-variant-and-name-handles-canonical-eq")
372 (and (= 2 (length names)) (every (lambda (old) (eq name (canonical-topic-name old))) names)
373 (= 1 (length pairs)) (= 2 (length held)) (not (eq (first held) (second held)))
374 (every (lambda (old) (eq v (canonical-variant old))) held)
375 (some (lambda (old) (not (eq v old))) held)
376 (every (lambda (old) (and (eq name (variant-parent old)) (eq r (item-reifier old))
377 (eq (canonical-variant old) (topic-reified r)))) held)))
378 (setf proof (topic-maps.test-foundation::fields
379 "sourceNameCalls" (length names) "sameRawNameHandleEQ" (if (eq (first names) (second names)) :true :false)
380 "preNormalizationPairs" (length pairs) "distinctRetainedVariantHandles" (length held)
381 "retainedNameCanonicalEQ" :true "retainedVariantCanonicalEQ" :true
382 "variantReplacementObserved" :true "canonicalParentScopeReifierInverseEQ" :true))
383 (setf actual (variant-reifier-pure "duplicate-name-original" map (append held names (list owner r theme type))))
384 (check (concatenate 'string label ":original-source-and-baseline-preserved")
385 (and (equalp raw copy) (= 702 (length expected)) (equalp expected (file-bytes baseline))))
386 (let ((other (deserialize-octets raw :document-iri *document* :source-key "independent:duplicate-name-variant-reifier")))
387 (check (concatenate 'string label ":source-key-independent-model-and-cxtm")
388 (and (equalp (variant-reifier-model-data map) (variant-reifier-model-data other))
389 (equalp actual (topic-maps.cxtm:canonicalize-octets other :base-locator *document*)))))))
390 (error (c) (setf condition c)))
391 (record-original-result case actual expected condition)
392 (setf *variant-reifier-outputs* (append *variant-reifier-outputs* (list
393 (topic-maps.test-foundation::fields "id" id "documentIRI" *document* "sourceKey" id
394 "sourceBytes" (length raw) "sourceHex" (format nil "~{~2,'0X~}" (coerce raw 'list))
395 "sourceText" (babel:octets-to-string raw :encoding :utf-8) "sourceNameCount" 2 "sourceVariantCount" 2
396 "primaryQualifiedParserCalls" calls "nativeHandleObservation" proof
397 "model" (when map (variant-reifier-model-data map)) "condition" (map-reifier-condition-data condition)
398 "actualCXTM" (when actual (babel:octets-to-string actual :encoding :utf-8))
399 "expectedCXTM" (babel:octets-to-string expected :encoding :utf-8)
400 "actualBytes" (when actual (length actual)) "expectedBytes" (length expected)
401 "firstDifferentByte" (when actual (mismatch actual expected))
402 "status" (string-downcase (string (topic-maps.test-foundation:test-case-status case)))))))
403 (when condition (error condition))
404 (check (concatenate 'string label ":byte-exact") (equalp actual expected))
405 (check "variant-reifier-followup:71-unique-records-exactly-one-additional-positive"
406 (and (= 71 (length *cases*)) (= 63 (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category))
407 (= 8 (count :invalid *cases* :key #'topic-maps.test-foundation:test-case-category))
408 (= 71 (length (remove-duplicates *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal)))))))