]> dreyeck.freedombox.rocks Git - topic-maps.git/blob - tests/xtm-variant-item-identities.lisp
Integrate qualified XML anyType values into the XTM reader
[topic-maps.git] / tests / xtm-variant-item-identities.lisp
1 (in-package #:topic-maps.xtm.tests)
2
3 (defun variant-iid-owners (map iri)
4 (remove-if-not (lambda (item) (member iri (item-identifiers item) :test #'equal))
5 (topic-maps.tmdm::map-information-items map)))
6 (defun variant-iid-xml (value themes identifiers &optional resource)
7 (format nil "<variant>~{~A~}~A~A</variant>"
8 (mapcar (lambda (iri) (format nil "<itemIdentity href='~A'/>" iri)) identifiers)
9 (scope-xml themes) (or resource (format nil "<resourceData>~A</resourceData>" value))))
10
11 (defun variant-iid-original-model-checks (map raw source-count label)
12 (let* ((owner (by-id map "topic")) (name (first (topic-names owner))) (v (first (all-variants map)))
13 (theme (by-id map "command")) (type (by-si map (default-name-type-identifier)))
14 (iri (concatenate 'string *document* "#the-variant"))
15 (root (topic-maps.xml:parse-octets raw (make-instance 'topic-maps.xtm::source-handler)))
16 (source-name (first (topic-maps.xtm::elements (first (topic-maps.xtm::elements root)))))
17 (source-variants (rest (topic-maps.xtm::elements source-name))))
18 (check (concatenate 'string label ":actual-original-variant-elements")
19 (and (= source-count (length source-variants))
20 (every (lambda (node) (let ((children (topic-maps.xtm::elements node)))
21 (and (equal "variant" (topic-maps.xtm::node-name node)) (= 3 (length children))
22 (equal "itemIdentity" (topic-maps.xtm::node-name (first children)))
23 (equal "#the-variant" (topic-maps.xtm::attr (first children) "href"))
24 (equal "scope" (topic-maps.xtm::node-name (second children)))
25 (equal "resourceData" (topic-maps.xtm::node-name (third children)))
26 (null (topic-maps.xtm::node-attributes (third children)))
27 (equal "TOPIC!" (apply #'concatenate 'string (topic-maps.xtm::node-children (third children))))))) source-variants)))
28 (check (concatenate 'string label ":native-normalized-parent-value-datatype-scope-eq")
29 (and (= 3 (length (topic-map-topics map))) (null (topic-map-associations map))
30 (= 1 (length (topic-names owner))) (= 1 (length (all-variants map)))
31 (eq owner (topic-name-parent name)) (eq type (topic-name-type name))
32 (eq name (canonical-topic-name name)) (eq name (variant-parent v)) (eq v (canonical-variant v))
33 (equal "Topic" (topic-name-value name)) (equal "TOPIC!" (variant-value v))
34 (equal (string-datatype) (variant-datatype v)) (null (topic-name-scope name))
35 (scope-eq-p (variant-scope v) (list theme)) (variants-current-p map)))
36 (check (concatenate 'string label ":complete-identifier-sets-exclusive-variant-owner")
37 (and (equal (list iri) (item-identifiers v)) (equal (list v) (variant-iid-owners map iri))
38 (equal (list (concatenate 'string *document* "#topic")) (item-identifiers owner))
39 (null (topic-subject-identifiers owner)) (null (topic-subject-locators owner))
40 (equal (list (concatenate 'string *document* "#command")) (item-identifiers theme))
41 (null (topic-subject-identifiers theme)) (null (topic-subject-locators theme))
42 (equal (list (default-name-type-identifier)) (topic-subject-identifiers type))
43 (null (item-identifiers type)) (null (topic-subject-locators type)) (null (topic-names type)) (null (topic-names theme))
44 (null (item-identifiers map)) (null (item-identifiers name)) (null (item-reifier name)) (null (item-reifier v))
45 (topic-maps.tmdm::validate-map-item-identifiers map)))))
46
47 (defun variant-iid-original-contracts ()
48 (setf *variant-iid-outputs* nil)
49 (dolist (spec '(("itemid-variant" 1) ("variant-duplicate-iid" 2)))
50 (destructuring-bind (stem source-count) spec
51 (let* ((id (format nil "xtm2/in/~A.xtm" stem))
52 (*document* (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/" id))
53 (raw (file-bytes (corpus-path id))) (copy (copy-seq raw))
54 (expected (file-bytes (corpus-path (format nil "xtm2/baseline/~A.xtm.cxtm" stem))))
55 (case (topic-maps.test-foundation:make-test-case :id id :category :valid
56 :source-pathname (corpus-path id) :document-iri *document* :expected-outcome :cxtm-equal
57 :expected-baseline (corpus-path (format nil "xtm2/baseline/~A.xtm.cxtm" stem))
58 :clauses '("XTM 2.0 4.3.1,4.3.3,4.3.4,4.6,4.12" "TMDM 5.1,5.5,6.4" "CXTM 3,4")))
59 (map nil) (actual nil) (c nil) (label (concatenate 'string "variant-iid-original:" stem)))
60 (setf *cases* (append *cases* (list case)))
61 (handler-case
62 (progn
63 (setf map (deserialize-octets raw :document-iri *document* :source-key id))
64 (variant-iid-original-model-checks map raw source-count label)
65 (let ((before (variant-state map)))
66 (setf actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*))
67 (check (concatenate 'string label ":source-preserved-pure-deterministic")
68 (and (= 666 (length expected)) (equalp raw copy) (equal before (variant-state map))
69 (equalp actual (topic-maps.cxtm:canonicalize-octets map :base-locator *document*))
70 (equal before (variant-state map)))))
71 (let ((other (deserialize-octets raw :document-iri *document* :source-key "independent:variant-item-identity")))
72 (check (concatenate 'string label ":source-key-independent-model-and-cxtm")
73 (and (equalp (variant-model-data map) (variant-model-data other))
74 (equalp actual (topic-maps.cxtm:canonicalize-octets other :base-locator *document*))))))
75 (error (condition) (setf c condition)))
76 (record-original-result case actual expected c)
77 (push (topic-maps.test-foundation::fields "id" id "documentIRI" *document* "sourceKey" id
78 "sourceBytes" (length raw) "sourceHex" (format nil "~{~2,'0X~}" (coerce raw 'list))
79 "sourceText" (babel:octets-to-string raw :encoding :utf-8) "sourceVariantCount" source-count
80 "variantIdentifier" (concatenate 'string *document* "#the-variant")
81 "model" (when map (variant-model-data map)) "condition" (negative-condition-data c)
82 "actualCXTM" (when actual (babel:octets-to-string actual :encoding :utf-8))
83 "expectedCXTM" (babel:octets-to-string expected :encoding :utf-8)
84 "actualBytes" (when actual (length actual)) "expectedBytes" (length expected)
85 "firstDifferentByte" (when actual (mismatch actual expected))
86 "status" (string-downcase (string (topic-maps.test-foundation:test-case-status case)))) *variant-iid-outputs*)
87 (when c (error c))
88 (check (concatenate 'string label ":byte-exact") (equalp actual expected)))))
89 (setf *variant-iid-outputs* (nreverse *variant-iid-outputs*))
90 (check "variant-iid-originals:62-unique-case-records"
91 (and (= 62 (length *cases*)) (= 54 (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category))
92 (= 62 (length (remove-duplicates *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal))))))
93
94 (defun variant-iid-control (label body verify)
95 (variant-control (concatenate 'string "variant-iid:" label) body
96 (lambda (map) (funcall verify map)
97 (check (concatenate 'string "variant-iid:" label ":global-identifier-uniqueness")
98 (topic-maps.tmdm::validate-map-item-identifiers map)))))
99 (defun variant-iid-value-controls ()
100 (dolist (row '(("absolute" "urn:variant" "urn:variant")
101 ("relative" "../variants#v" "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/variants#v")
102 ("fragment-not-shorthand" "#2valid/not-a-topicRef" "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/in/example.xtm#2valid/not-a-topicRef")
103 ("empty-reference" "" "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/xtm2/in/example.xtm")
104 ("unicode" "urn:馬籠🦊" "urn:馬籠🦊") ("percent-UTF8" "urn:%E9%A6%AC%F0%9F%A6%8A" "urn:馬🦊")))
105 (destructuring-bind (label href expected) row
106 (variant-iid-control label
107 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (variant-iid-xml "V" '("s") (list href))))
108 (lambda (map)
109 (let* ((owner (by-id map "a")) (name (first (topic-names owner))) (v (first (all-variants map))))
110 (check (concatenate 'string "variant-iid:" label ":only-native-variant-owns-resolved-locator")
111 (and (= 3 (length (topic-map-topics map))) (= 1 (length (all-variants map)))
112 (eq name (variant-parent v)) (eq v (canonical-variant v))
113 (equal (list expected) (item-identifiers v)) (equal (list v) (variant-iid-owners map expected))
114 (null (item-identifiers name)) (null (item-identifiers (topic-name-type name)))
115 (equal (list (concatenate 'string *document* "#a")) (item-identifiers owner))
116 (equal (list (concatenate 'string *document* "#s")) (item-identifiers (by-id map "s"))))))))))
117 (let ((*document* "https://variants.example.invalid/maps/input.xtm"))
118 (variant-iid-control "alternate-document-multiple-duplicate"
119 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil
120 (variant-iid-xml "V" '("s") '("#v" "#v" "../variants#v" "urn:absolute" "#m%C3%A4"))))
121 (lambda (map) (check "variant-iid:multiple-resolved-identifier-set"
122 (same-identifiers-p (item-identifiers (first (all-variants map)))
123 '("https://variants.example.invalid/maps/input.xtm#v" "https://variants.example.invalid/variants#v" "urn:absolute" "https://variants.example.invalid/maps/input.xtm#mä"))))))
124 (dolist (same '(nil t))
125 (variant-iid-control (if same "equal-variants-same-II" "equal-variants-different-II")
126 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base") (concatenate 'string
127 (variant-iid-xml "V" '("extra" "extra") '("urn:first"))
128 (variant-iid-xml "V" '("extra") (if same '("urn:first") '("urn:second"))))))
129 (lambda (map) (let* ((name (first (topic-names (by-id map "a")))) (v (first (all-variants map)))
130 (ids (if same '("urn:first") '("urn:first" "urn:second"))))
131 (check (if same "variant-iid:same-II-idempotent-after-normalization" "variant-iid:different-IIs-union-after-normalization")
132 (and (= 1 (length (all-variants map))) (eq v (canonical-variant v)) (eq name (variant-parent v))
133 (same-identifiers-p ids (item-identifiers v))
134 (every (lambda (id) (equal (list v) (variant-iid-owners map id))) ids)))))))
135 (dolist (resource '("<resourceRef href='urn:resource'/>" "<resourceData datatype='http://www.w3.org/2001/XMLSchema#anyURI'>urn:resource</resourceData>"))
136 (variant-iid-control (if (search "resourceRef" resource) "resourceRef" "anyURI-data")
137 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (variant-iid-xml nil '("s") '("urn:v") resource)))
138 (lambda (map) (let ((v (first (all-variants map))))
139 (check (if (search "resourceRef" resource) "variant-iid:resourceRef-properties" "variant-iid:anyURI-data-properties")
140 (and (equal "urn:resource" (variant-value v)) (equal (iri-datatype) (variant-datatype v))
141 (equal '("urn:v") (item-identifiers v))))))))
142 (variant-iid-control "variant-II-and-topic-SI-stay-separate"
143 (format nil "<topic id='s'><subjectIdentifier href='urn:v'/></topic><topic id='a'>~A</topic>"
144 (variant-name-xml nil (variant-iid-xml "V" '("s") '("urn:v"))))
145 (lambda (map) (let ((v (first (all-variants map))))
146 (check "variant-iid:no-implicit-reification-or-topic-merge"
147 (and (= 3 (length (topic-map-topics map))) (null (topic-reified (by-id map "s")))
148 (null (item-reifier v)) (equal (list v) (variant-iid-owners map "urn:v"))))))))
149
150 (defun variant-iid-merge-controls ()
151 (dolist (target '("parent" "variant-theme" "name-theme"))
152 (dolist (kind '("subjectIdentifier" "subjectLocator" "itemIdentity"))
153 (let* ((label (format nil "variant-iid-merge:~A:~A" target kind)) (old-names nil) (old-variants nil) (old-themes nil)
154 (first-v (variant-iid-xml "V" '("extra") '("urn:v1"))) (second-v (variant-iid-xml "V" '("extra") '("urn:v2"))) (body nil) (*name-controls* nil))
155 (labels ((topic-source (id locator content)
156 (format nil "<topic id='~A'>~A~A</topic>" id
157 (if (equal kind "itemIdentity") "" (format nil "<~A href='~A'/>" kind locator)) content))
158 (bridge (a b)
159 (format nil "<topic id='bridge'><~A href='~A'/><~A href='~A'/></topic>" kind
160 (if (equal kind "itemIdentity") (concatenate 'string "#" a) "urn:one") kind
161 (if (equal kind "itemIdentity") (concatenate 'string "#" b) "urn:two"))))
162 (setf body
163 (cond
164 ((equal target "parent")
165 (concatenate 'string
166 (topic-source "a" "urn:one" (variant-name-xml '("base") first-v "urn:n1"))
167 (topic-source "b" "urn:two" (variant-name-xml '("base") second-v "urn:n2")) (bridge "a" "b")))
168 ((equal target "variant-theme")
169 (concatenate 'string
170 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base")
171 (concatenate 'string (variant-iid-xml "V" '("x") '("urn:v1")) (variant-iid-xml "V" '("y") '("urn:v2"))) "urn:n1"))
172 (topic-source "x" "urn:one" "") (topic-source "y" "urn:two" "") (bridge "x" "y")))
173 (t
174 (concatenate 'string (format nil "<topic id='a'>~A~A</topic>"
175 (variant-name-xml '("x") first-v "urn:n1") (variant-name-xml '("y") second-v "urn:n2"))
176 (topic-source "x" "urn:one" "") (topic-source "y" "urn:two" "") (bridge "x" "y")))))
177 (staged-name-control label body
178 (lambda (map step)
179 (if (equal target "parent")
180 (when (<= step 2)
181 (let ((name (first (topic-names (by-id map (if (= step 1) "a" "b"))))))
182 (push name old-names) (push (first (topic-name-variants name)) old-variants)))
183 (when (= step 1)
184 (setf old-names (topic-names (by-id map "a")))
185 (setf old-variants (loop for name in old-names append (topic-name-variants name)))
186 (setf old-themes (list (by-id map "x") (by-id map "y")))))
187 (when (= step (if (equal target "parent") 2 3))
188 (check (concatenate 'string label ":distinct-before")
189 (and (= 2 (length old-variants)) (not (eq (first old-variants) (second old-variants)))
190 (every (lambda (v) (eq v (canonical-variant v))) old-variants)))))
191 (lambda (map)
192 (let* ((owner (by-id map "a")) (name (first (topic-names owner))) (v (first (topic-name-variants name)))
193 (before (variant-state map))
194 (themes (cond ((equal target "parent") (list (by-id map "base") (by-id map "extra")))
195 ((equal target "variant-theme") (list (by-id map "base") (by-id map "bridge")))
196 (t (list (by-id map "bridge") (by-id map "extra"))))))
197 (check (concatenate 'string label ":canonical-parent-name-variant-handles")
198 (and (= 1 (length (topic-names owner))) (= 1 (length (all-variants map)))
199 (every (lambda (old) (eq name (canonical-topic-name old))) old-names)
200 (every (lambda (old) (and (eq v (canonical-variant old)) (eq name (variant-parent old))
201 (scope-eq-p (variant-scope old) themes))) old-variants)
202 (if (equal target "parent") (eq owner (by-id map "b"))
203 (every (lambda (old) (eq (by-id map "bridge") (canonical-topic old))) old-themes))
204 (same-identifiers-p (item-identifiers name)
205 (if (equal target "variant-theme") '("urn:n1") '("urn:n1" "urn:n2")))
206 (variants-current-p map)))
207 (topic-maps.cxtm:canonicalize-octets map :base-locator *document*)
208 (check (concatenate 'string label ":identifier-union-and-exclusive-canonical-owner")
209 (and (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers v))
210 (every (lambda (id) (equal (list v) (variant-iid-owners map id))) '("urn:v1" "urn:v2"))
211 (every (lambda (old) (same-identifiers-p '("urn:v1" "urn:v2") (item-identifiers old))) old-variants)
212 (topic-maps.tmdm::validate-map-item-identifiers map)))
213 (check (concatenate 'string label ":cxtm-pure-retains-handles") (equal before (variant-state map)))
214 (push (topic-maps.test-foundation::fields "label" label "kind" "staged-native-reader-control"
215 "sourceText" (document body) "model" (variant-model-data map)) *variant-controls*)))))))))
216
217 (defun variant-iid-error-controls ()
218 (dolist (row '(("after-scope" "<scope><topicRef href='#s'/></scope><itemIdentity href='urn:v'/><resourceData>V</resourceData>" :element-order)
219 ("after-resource" "<scope><topicRef href='#s'/></scope><resourceData>V</resourceData><itemIdentity href='urn:v'/>" :element-order)))
220 (variant-error-control (concatenate 'string "variant-iid:" (first row))
221 (format nil "<topic id='a'><name><value>N</value><variant>~A</variant></name></topic>" (second row)) 'xtm-rejection (third row)))
222 (dolist (row '(("missing-href" "<itemIdentity/>" :missing-attribute)
223 ("attribute" "<itemIdentity href='urn:v' other='bad'/>" :unexpected-attribute)
224 ("child" "<itemIdentity href='urn:v'><topicRef href='#s'/></itemIdentity>" :unexpected-child)
225 ("text" "<itemIdentity href='urn:v'>text</itemIdentity>" :unexpected-text)
226 ("invalid-iri" "<itemIdentity href='bad space'/>" :invalid-iri)
227 ("percent-short" "<itemIdentity href='urn:v%2'/>" :invalid-percent-escape)
228 ("percent-hex" "<itemIdentity href='urn:v%GG'/>" :invalid-percent-escape)
229 ("percent-utf8" "<itemIdentity href='urn:v%C3'/>" :invalid-percent-utf8)
230 ("percent-overlong" "<itemIdentity href='urn:v%C0%AF'/>" :invalid-percent-utf8)))
231 (variant-error-control (concatenate 'string "variant-iid:" (first row))
232 (format nil "<topic id='a'><name><value>N</value><variant>~A<scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant></name></topic>" (second row))
233 'xtm-rejection (third row)))
234 (dolist (row '(("collision-map" "<itemIdentity href='urn:collision'/><topic id='a'><name><value>N</value>" "urn:collision")
235 ("collision-topic" "<topic id='a'><name><value>N</value>" "#a")
236 ("collision-name" "<topic id='a'><name><itemIdentity href='urn:collision'/><value>N</value>" "urn:collision")))
237 (variant-error-control (concatenate 'string "variant-iid:" (first row))
238 (concatenate 'string (second row) (variant-iid-xml "V" '("s") (list (third row))) "</name></topic>")
239 'item-identifier-error :duplicate-item-identifier))
240 (dolist (row '(("different-value" "<resourceData>W</resourceData>" ("s"))
241 ("different-datatype" "<resourceRef href='urn:V'/>" ("s"))
242 ("different-scope" "<resourceData>urn:V</resourceData>" ("t"))))
243 (variant-error-control (concatenate 'string "variant-iid:collision:" (first row))
244 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (concatenate 'string
245 (variant-iid-xml "urn:V" '("s") '("urn:collision"))
246 (variant-iid-xml nil (third row) '("urn:collision") (second row)))))
247 'item-identifier-error :duplicate-item-identifier))
248 (variant-error-control "variant-iid:collision-different-parent"
249 (format nil "<topic id='a'>~A</topic><topic id='b'>~A</topic>"
250 (variant-name-xml nil (variant-iid-xml "V" '("s") '("urn:collision")))
251 (variant-name-xml nil (variant-iid-xml "V" '("s") '("urn:collision"))))
252 'item-identifier-error :duplicate-item-identifier)
253 (variant-error-control "variant-iid:topicRef-does-not-reify-variant"
254 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil (concatenate 'string
255 (variant-iid-xml "V" '("s") '("#v")) (variant-iid-xml "W" '("v") nil))))
256 'topic-maps.tmdm::occurrence-identifier-error :duplicate-item-identifier)
257 (variant-error-control "variant-iid:scope-not-proper-superset"
258 (format nil "<topic id='a'>~A</topic>" (variant-name-xml '("base") (variant-iid-xml "V" '("base") '("urn:v"))))
259 'variant-error :invalid-variant-scope)
260 (variant-error-control "variant-iid:reifier-excluded-datatype"
261 "<topic id='a'><name><value>N</value><variant reifier='#r'><itemIdentity href='urn:v'/><scope><topicRef href='#s'/></scope><resourceData datatype='http://www.w3.org/2001/XMLSchema#anyType'>42</resourceData></variant></name></topic>"
262 'xtm-unsupported :resource-resolver-required)
263 (variant-error-control "variant-iid:other-datatype-still-unsupported"
264 (format nil "<topic id='a'>~A</topic>" (variant-name-xml nil
265 (variant-iid-xml nil '("s") '("urn:v") "<resourceData datatype='http://www.w3.org/2001/XMLSchema#anyType'>42</resourceData>")))
266 'xtm-unsupported :resource-resolver-required)
267 (let* ((key "variant-iid:invalid-raw-UTF8")
268 (raw (concatenate '(vector (unsigned-byte 8))
269 (bytes "<topicMap xmlns='http://www.topicmaps.org/xtm/' version='2.0'><topic id='a'><name><value>N</value><variant><itemIdentity href='urn:")
270 #(255) (bytes "'/><scope><topicRef href='#s'/></scope><resourceData>V</resourceData></variant></name></topic></topicMap>")))
271 (c (condition-from (lambda () (deserialize-octets raw :document-iri *document* :source-key key)))))
272 (check "variant-iid:invalid-raw-UTF8-is-XML-error"
273 (and (eq 'xtm-xml-error (type-of c)) (eq :xml-not-well-formed (error-code c))
274 (equal key (error-source-key c)) (equal *document* (error-document-iri c))))
275 (push (topic-maps.test-foundation::fields "label" key "kind" "invalid-XML-octets"
276 "sourceHex" (format nil "~{~2,'0X~}" (coerce raw 'list)) "condition" (negative-condition-data c)) *variant-controls*)))
277
278 (defun variant-iid-atomic-controls ()
279 (let* ((body (concatenate 'string "<itemIdentity href='urn:map'/><topic id='a'>"
280 (variant-name-xml nil (concatenate 'string
281 (variant-iid-xml "V" '("s") '("urn:v1")) (variant-iid-xml "W" '("s") '("urn:v2"))) "urn:name") "</topic>"))
282 (map (read-body body)) (owner (by-id map "a")) (name (first (topic-names owner)))
283 (v (first (all-variants map))) (other (second (all-variants map))))
284 (dolist (target (list map owner name (by-id map "s") other))
285 (let* ((id (first (item-identifiers target))) (before (variant-state map))
286 (c (condition-from (lambda () (add-item-identifier v id))))
287 (label (cond ((eq target map) "map") ((eq target owner) "topic")
288 ((eq target name) "name") ((eq target other) "other-variant") (t "theme"))))
289 (check (concatenate 'string "variant-iid:atomic-conflict:" label)
290 (and (eq 'item-identifier-error (type-of c)) (eq :duplicate-item-identifier (item-identifier-error-code c))
291 (equal before (variant-state map)) (eq v (canonical-variant v)) (eq other (canonical-variant other))
292 (equal (list target) (variant-iid-owners map id)) (equal '("urn:v1") (item-identifiers v))
293 (variants-current-p map) (topic-maps.tmdm::validate-map-item-identifiers map)))
294 (push (topic-maps.test-foundation::fields "label" (concatenate 'string "variant-iid:atomic-conflict:" label)
295 "kind" "native-TMDM-identifier-atomicity" "sourceText" (document body) "attemptedIdentifier" id
296 "condition" (negative-condition-data c) "modelUnchanged" :true "model" (variant-model-data map)) *variant-controls*)))))
297
298 (defun variant-iid-tests ()
299 (let ((*variant-controls* nil))
300 (variant-iid-value-controls)
301 (variant-iid-merge-controls)
302 (variant-iid-error-controls)
303 (variant-iid-atomic-controls)
304 (setf *variant-iid-controls* (nreverse *variant-controls*))))