]> dreyeck.freedombox.rocks Git - topic-maps.git/blobdiff - tests/xtm-variant-reification.lisp
Implement noncyclic XTM mergeMap content import (Slice 22E)
[topic-maps.git] / tests / xtm-variant-reification.lisp
index 254065950e6f3ced57800d92d06c3cb45afeecb0..82ddd361a33778109bef6ca707b304b16a9c58aa 100644 (file)
 
 (defun variant-reifier-tests ()
   (variant-reifier-value-tests) (variant-reifier-merge-tests) (variant-reifier-syntax-conflict-tests))
+
+;; Slice 22B: the unchanged duplicate-Name original uses the same executor,
+;; Case Records and model serializers as the two Slice-21O originals above.
+(defun variant-reifier-followup-original-contract ()
+  (let* ((id "xtm2/in/variant-duplicate-reifier2.xtm")
+         (*document* (concatenate 'string "https://xtm-tests.example.invalid/cd165b150176c1d6842b37be9cc9051b40d4996b/" id))
+         (label "variant-reifier-original:variant-duplicate-reifier2")
+         (raw (file-bytes (corpus-path id))) (copy (copy-seq raw))
+         (baseline (corpus-path "xtm2/baseline/variant-duplicate-reifier2.xtm.cxtm"))
+         (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.2,4.10-4.13,4.16" "TMDM 5.4-5.5,6.3-6.4" "CXTM 3,4")))
+         (map nil) (actual nil) (condition nil) (root nil) (calls 0) (same nil)
+         (names nil) (pairs nil) (proof nil))
+    (check (concatenate 'string label ":not-previously-registered")
+      (not (find id *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal)))
+    (setf *cases* (append *cases* (list case)))
+    (handler-case
+        (progn
+          ;; Passive observers retain actual handles from this public import.
+          ;; Restore every function even if XML, reader or model execution fails.
+          (let ((parse (symbol-function 'topic-maps.xml:parse-octets))
+                (read-name (symbol-function 'topic-maps.xtm::read-name))
+                (normalize (symbol-function 'topic-maps.tmdm::normalize-variants)))
+            (unwind-protect
+                (progn
+                  (setf (symbol-function 'topic-maps.xml:parse-octets)
+                    (lambda (source handler) (incf calls) (setf same (eq raw source))
+                      (setf root (funcall parse source handler))))
+                  (setf (symbol-function 'topic-maps.xtm::read-name)
+                    (lambda (node owner result)
+                      (let ((name (funcall read-name node owner result))) (push name names) name)))
+                  (setf (symbol-function 'topic-maps.tmdm::normalize-variants)
+                    (lambda (result)
+                      (let ((held (all-variants result)))
+                        (when (= 2 (length held)) (push (copy-list held) pairs)))
+                      (funcall normalize result)))
+                  (setf map (deserialize-octets raw :document-iri *document* :source-key id)))
+              (setf (symbol-function 'topic-maps.xml:parse-octets) parse
+                    (symbol-function 'topic-maps.xtm::read-name) read-name
+                    (symbol-function 'topic-maps.tmdm::normalize-variants) normalize)))
+          (check (concatenate 'string label ":qualified-parser-once-original-octets-eq") (and (= calls 1) same))
+          (let* ((source-topics (topic-maps.xtm::elements root)) (source-topic (first source-topics))
+                 (source-names (topic-maps.xtm::elements source-topic))
+                 (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)))
+                 (held (first pairs)))
+            (check (concatenate 'string label ":543-byte-original-two-names-two-reified-variants")
+              (and (= 543 (length raw)) (= 1 (length source-topics))
+                (equal "topic" (topic-maps.xtm::attr source-topic "id")) (= 2 (length source-names))
+                (every (lambda (n)
+                  (let* ((kids (topic-maps.xtm::elements n)) (variant (second kids))
+                         (vkids (topic-maps.xtm::elements variant)))
+                    (and (equal "name" (topic-maps.xtm::node-name n)) (null (topic-maps.xtm::node-attributes n))
+                      (equal '("value" "variant") (mapcar #'topic-maps.xtm::node-name kids))
+                      (equal '("Topic") (topic-maps.xtm::node-children (first kids)))
+                      (equal "#reifier" (topic-maps.xtm::attr variant "reifier"))
+                      (= 1 (length (topic-maps.xtm::node-attributes variant)))
+                      (equal '("scope" "resourceData") (mapcar #'topic-maps.xtm::node-name vkids))
+                      (= 1 (length (topic-maps.xtm::elements (first vkids))))
+                      (equal "#command" (topic-maps.xtm::attr (first (topic-maps.xtm::elements (first vkids))) "href"))
+                      (null (topic-maps.xtm::node-attributes (second vkids)))
+                      (equal '("TOPIC!") (topic-maps.xtm::node-children (second vkids)))))) source-names)))
+            (check (concatenate 'string label ":one-native-name-variant-parent-type-scope-eq")
+              (and (= 4 (length (topic-map-topics map))) (null (topic-map-associations map))
+                (= 1 (length (name-reifier-names map))) (= 1 (length (all-variants map)))
+                (every (lambda (topic) (eq map (topic-parent topic))) (topic-map-topics 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))
+                (scope-eq-p (list theme) (variant-scope v)) (variant-reifier-current-p map)))
+            (check (concatenate 'string label ":verbatim-value-string-datatype-and-canonical-reifier-inverse-eq")
+              (and (equal "TOPIC!" (variant-value v)) (equal (string-datatype) (variant-datatype v))
+                (eq r (canonical-topic r)) (eq r (item-reifier v)) (eq v (topic-reified r))
+                (null (item-reifier map)) (null (item-reifier name))
+                (every (lambda (topic) (null (topic-reified topic))) (list owner theme type))))
+            (check (concatenate 'string label ":complete-separated-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))
+                (null (topic-subject-locators type))
+                (every (lambda (pair)
+                  (and (equal (list (concatenate 'string *document* "#" (cdr pair))) (item-identifiers (car pair)))
+                    (null (topic-subject-identifiers (car pair))) (null (topic-subject-locators (car pair)))))
+                  (list (cons owner "topic") (cons theme "command") (cons r "reifier")))
+                (every (lambda (topic) (and (null (topic-occurrences topic)) (null (topic-roles-played topic))))
+                  (topic-map-topics map))))
+            (check (concatenate 'string label ":retained-pre-normalization-variant-and-name-handles-canonical-eq")
+              (and (= 2 (length names)) (every (lambda (old) (eq name (canonical-topic-name old))) names)
+                (= 1 (length pairs)) (= 2 (length held)) (not (eq (first held) (second held)))
+                (every (lambda (old) (eq v (canonical-variant old))) held)
+                (some (lambda (old) (not (eq v old))) held)
+                (every (lambda (old) (and (eq name (variant-parent old)) (eq r (item-reifier old))
+                  (eq (canonical-variant old) (topic-reified r)))) held)))
+            (setf proof (topic-maps.test-foundation::fields
+              "sourceNameCalls" (length names) "sameRawNameHandleEQ" (if (eq (first names) (second names)) :true :false)
+              "preNormalizationPairs" (length pairs) "distinctRetainedVariantHandles" (length held)
+              "retainedNameCanonicalEQ" :true "retainedVariantCanonicalEQ" :true
+              "variantReplacementObserved" :true "canonicalParentScopeReifierInverseEQ" :true))
+            (setf actual (variant-reifier-pure "duplicate-name-original" map (append held names (list owner r theme type))))
+            (check (concatenate 'string label ":original-source-and-baseline-preserved")
+              (and (equalp raw copy) (= 702 (length expected)) (equalp expected (file-bytes baseline))))
+            (let ((other (deserialize-octets raw :document-iri *document* :source-key "independent:duplicate-name-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 (c) (setf condition c)))
+    (record-original-result case actual expected condition)
+    (setf *variant-reifier-outputs* (append *variant-reifier-outputs* (list
+      (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) "sourceNameCount" 2 "sourceVariantCount" 2
+        "primaryQualifiedParserCalls" calls "nativeHandleObservation" proof
+        "model" (when map (variant-reifier-model-data map)) "condition" (map-reifier-condition-data condition)
+        "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)))))))
+    (when condition (error condition))
+    (check (concatenate 'string label ":byte-exact") (equalp actual expected))
+    (check "variant-reifier-followup:71-unique-records-exactly-one-additional-positive"
+      (and (= 71 (length *cases*)) (= 63 (count :valid *cases* :key #'topic-maps.test-foundation:test-case-category))
+        (= 8 (count :invalid *cases* :key #'topic-maps.test-foundation:test-case-category))
+        (= 71 (length (remove-duplicates *cases* :key #'topic-maps.test-foundation:test-case-id :test #'equal)))))))