(defpackage #:topic-maps.prolog.tests (:use #:cl #:topic-maps.tmdm) (:import-from #:topic-maps.registered-original.tests #:check #:binary #:fields #:case-state #:identity-fields #:captured-read #:condition-data) (:export #:run-tests #:write-reports)) (in-package #:topic-maps.prolog.tests) (defparameter *doc* "https://example.invalid/prolog/main.ctm") (defparameter *child* "https://example.invalid/prolog/child.ctm") (defvar *checks* nil) (defvar *positives* nil) (defvar *negatives* nil) (defvar *originals* nil) (defvar *entry-statuses* nil) (defun bytes (text &optional bom) (concatenate '(vector (unsigned-byte 8)) (if bom #(239 187 191) #()) (sb-ext:string-to-octets text :external-format :utf-8))) (defun read-text (text &optional (source "memory:prolog")) (topic-maps.ctm:deserialize-string text :document-iri *doc* :source-name source)) (defun canonical (map) (topic-maps.cxtm:canonicalize-octets map :base-locator *doc*)) (defun file-result (label input &optional encoding) (uiop:with-temporary-file (:pathname path :type "ctm") (with-open-file (out path :direction :output :if-exists :supersede :element-type '(unsigned-byte 8)) (write-sequence input out)) (multiple-value-bind (map condition) (captured-read (lambda () (topic-maps.ctm:deserialize-file path :document-iri *doc* :source-name label :encoding encoding))) (check (concatenate 'string label ":input-bytes-preserved") (equalp input (binary path))) (values map condition)))) (defun positive (label map condition body &optional input) (check (concatenate 'string label ":actual-model-and-CXTM") (and (null condition) map (topic-maps.reference.tests::references-current-p map) (equalp (canonical map) (canonical (read-text body))))) (push (fields "label" label "accepted" :true "inputText" input "actualCXTM" (topic-maps.ctm::decode-utf8 (canonical map)) "model" (topic-maps.template.tests::observe map)) *positives*)) (defun specific (label condition class code position unit &optional (source label) purpose) (check (concatenate 'string label ":specific-condition-code-position-source") (and condition (eq class (type-of condition)) (eq code (topic-maps.ctm:error-code condition)) (= position (topic-maps.ctm:error-position condition)) (eq unit (topic-maps.ctm:error-position-unit condition)) (equal source (topic-maps.ctm:error-source condition)) (null (topic-maps.ctm:error-cause condition)) (if purpose (eq purpose (getf (first (topic-maps.ctm:error-context condition)) :purpose)) (null (topic-maps.ctm:error-context condition))))) (check (concatenate 'string label ":position-units") (if (eq unit :byte) (and (null (topic-maps.ctm:error-line condition)) (null (topic-maps.ctm:error-column condition))) (and (integerp (topic-maps.ctm:error-line condition)) (integerp (topic-maps.ctm:error-column condition))))) (push (fields "label" label "condition" (condition-data condition)) *negatives*) condition) (defun negative-text (label text code position &optional (class 'topic-maps.ctm:ctm-rejection) purpose) (multiple-value-bind (map condition) (captured-read (lambda () (read-text text label))) (declare (ignore map)) (specific label condition class code position :character label purpose))) (defun negative-file (label input code position &optional encoding (class 'topic-maps.ctm:ctm-rejection)) (multiple-value-bind (map condition) (file-result label input encoding) (declare (ignore map)) (specific label condition class code position :byte))) (defun positive-prologs () (dolist (spec (list (list "version-empty" "%version 1.0" "") (list "version-compact" "%version1.0 topic." "topic.") (list "version-body-adjacent" "%version1.0topic." "topic.") (list "version-comments" (format nil "# preface~%%version # version~%1.0~%topic.") "topic.") (list "encoding-version" (format nil "%encoding~C\"utf-8\"~%%version 1.0~%topic." #\Tab) "topic.") (list "version-prefix" "%version1.0 %prefixex ex:topic." ".") (list "version-map-reifier" "%version1.0 ~r topic." "~r topic."))) (destructuring-bind (label text body) spec (multiple-value-bind (map condition) (captured-read (lambda () (read-text text label))) (positive label map condition body text)))) (let ((body "topic - \"Grüße🙂\".")) (dolist (encoding '(nil "UTF-8" "utf-8")) (dolist (bom '(nil t)) (dolist (declaration '(nil "UTF-8" "utf-8")) (let* ((label (format nil "utf8:provided=~A:bom=~A:decl=~A" encoding bom declaration)) (text (concatenate 'string (if declaration (format nil "%encoding \"~A\"~%" declaration) "") (format nil "%version 1.0~%~A" body)))) (multiple-value-bind (map condition) (file-result label (bytes text bom) encoding) (positive label map condition body text)))))))) (defun prolog-rejections () (dolist (version '("10.0" "2.0" "1" "1.00" "01.0" "+1.0" "1.0.0" "\"1.0\"" "")) (negative-text (concatenate 'string "version-spelling:" version) (concatenate 'string "%version " version) :invalid-version 9)) (dolist (spec '(("version-after-body" "topic. %version 1.0" :misplaced-version 7) ("version-after-prefix" "%prefix ex %version 1.0" :misplaced-version 21) ("version-after-reifier" "~r %version 1.0" :misplaced-version 3) ("version-repeated" "%version 1.0 %version 1.0" :misplaced-version 13) ("encoding-after-version" "%version 1.0 %encoding \"UTF-8\"" :misplaced-encoding 13) ("encoding-leading-space" " %encoding \"UTF-8\"" :misplaced-encoding 1) ("encoding-after-body" "topic. %encoding \"UTF-8\"" :misplaced-encoding 7) ("encoding-repeated" "%encoding \"UTF-8\" %encoding \"UTF-8\"" :misplaced-encoding 18) ("unknown-original-type" "%ctm 1.0" :unknown-directive 0) ("unknown-name" "%bogus" :unknown-directive 0) ("unknown-case" "%VERSION 1.0" :unknown-directive 0) ("known-prefix-malformed" "%prefix" :expected-prefix-name 7) ("encoding-missing-quotes" "%encoding UTF-8" :invalid-encoding-declaration 10) ("encoding-empty-name" "%encoding \"\"" :invalid-encoding-declaration 11) ("encoding-unclosed-name" "%encoding \"UTF-8" :invalid-encoding-declaration 16))) (destructuring-bind (label text code position) spec (negative-text label text code position))) (negative-text "known-resource-policy" "%include " :resource-resolver-required 0 'topic-maps.ctm:ctm-unsupported :include) (negative-text "known-triple-string-unsupported" "topic occ: \"\"\"x\"\"\"." :triple-quoted-string 11 'topic-maps.ctm:ctm-unsupported) (negative-text "known-charset-unsupported-text" "%encoding \"iso-8859-5\"" :unsupported-encoding 11 'topic-maps.ctm:ctm-unsupported) (negative-text "encoding-newline-before-name" (format nil "%encoding~%\"UTF-8\"") :invalid-encoding-declaration 9)) (defun byte-order-tests () (negative-file "supplied-vs-BOM" (bytes "topic." t) :encoding-conflict 0 "iso-8859-1") (negative-file "supplied-vs-declaration" (bytes "%encoding \"iso-8859-1\" topic.") :encoding-conflict 11 "UTF-8") (negative-file "supplied-unsupported-vs-UTF8-declaration" (bytes "%encoding \"UTF-8\" topic.") :encoding-conflict 11 "iso-8859-1") (negative-file "matching-unsupported-charset" (bytes "%encoding \"iso-8859-5\"") :unsupported-encoding 11 "ISO-8859-5" 'topic-maps.ctm:ctm-unsupported) (negative-file "supplied-unsupported-charset" (bytes "topic.") :unsupported-encoding 0 "iso-8859-5" 'topic-maps.ctm:ctm-unsupported) (negative-file "invalid-UTF8-retained" #(255) :invalid-utf8 0) (negative-file "invalid-UTF8-after-BOM-retained" #(239 187 191 255) :invalid-utf8 3) (negative-file "truncated-BOM-retained" #(239 187) :invalid-utf8 0) (negative-file "malformed-byte-encoding" (bytes "%encoding UTF-8") :invalid-encoding-declaration 10) (let ((saved (symbol-function 'topic-maps.ctm::decode-utf8)) (calls 0)) (unwind-protect (progn (setf (symbol-function 'topic-maps.ctm::decode-utf8) (lambda (&rest args) (incf calls) (apply saved args))) (negative-file "conflict-before-invalid-body-decoding" (concatenate '(vector (unsigned-byte 8)) (bytes "%encoding \"iso-8859-1\"" t) #(255)) :encoding-conflict 14) (negative-file "unsupported-before-invalid-body-decoding" (concatenate '(vector (unsigned-byte 8)) (bytes "%encoding \"iso-8859-5\"") #(255)) :unsupported-encoding 11 nil 'topic-maps.ctm:ctm-unsupported) (check "encoding-selection-precedes-decoder:zero-calls" (zerop calls))) (setf (symbol-function 'topic-maps.ctm::decode-utf8) saved)))) (defun resource-prolog-tests () (dolist (purpose '(:include :mergemap)) (let* ((parent (if (eq purpose :include) "%include " "%mergemap ")) (good (bytes (format nil "%encoding \"UTF-8\"~%%version 1.0~%topic - \"Grüße🙂\".") t)) (input (copy-seq good)) (calls 0) (resolver (lambda (iri &key purpose from-document-iri notation) (assert (equal iri *child*)) (assert (equal from-document-iri *doc*)) (assert (if (eq purpose :include) (null notation) (equal notation "http://psi.topicmaps.org/iso13250/ctm"))) (incf calls) (values good "source:child")))) (let* ((map (topic-maps.ctm:deserialize-string parent :document-iri *doc* :resource-resolver resolver)) (owner (topic-maps.registered-original.tests::local map *child* "topic"))) (check (format nil "resource:~A:UTF8-BOM-prolog-model-and-immutable-bytes" purpose) (and (= calls 1) (equalp input good) owner (= 1 (length (topic-names owner))) (equal "Grüße🙂" (topic-name-value (first (topic-names owner)))) (topic-maps.reference.tests::references-current-p map))) (push (fields "label" (format nil "resource:~A:UTF8-BOM-prolog" purpose) "accepted" :true "model" (topic-maps.template.tests::observe map)) *positives*)) (dolist (spec (list (list "conflict" (bytes "%encoding \"iso-8859-1\"" t) :encoding-conflict 14 :byte 'topic-maps.ctm:ctm-rejection) (list "version" (bytes "%version 10.0") :invalid-version 9 :character 'topic-maps.ctm:ctm-rejection) (list "unknown" (bytes "%ctm 1.0") :unknown-directive 0 :character 'topic-maps.ctm:ctm-rejection) (list "unsupported" (bytes "%encoding \"iso-8859-5\"") :unsupported-encoding 11 :byte 'topic-maps.ctm:ctm-unsupported))) (destructuring-bind (name input code position unit class) spec (let* ((before (copy-seq input)) (label (format nil "resource:~A:~A" purpose name)) (condition (nth-value 1 (captured-read (lambda () (topic-maps.ctm:deserialize-string parent :document-iri *doc* :resource-resolver (lambda (&rest args) (declare (ignore args)) (values input "source:child")))))))) (specific label condition class code position unit "source:child" purpose) (check (concatenate 'string label ":unchanged-resource-bytes") (equalp before input)))))))) (defun original-contracts () (let* ((corpus topic-maps.ctm.tests::*cxtm-corpus*) (cases (topic-maps.test-foundation:corpus-cases corpus)) (previous (mapcar (lambda (case) (cons case (case-state case))) cases)) (old-cxtm (copy-tree topic-maps.ctm.tests::*cxtm-results*)) (ids '("ctm/invalid/BOM-contradicts-encoding.ctm" "ctm/invalid/unknown-directive.ctm" "ctm/invalid/wrong-version.ctm"))) (setf *entry-statuses* (copy-list (getf (topic-maps.test-foundation:summarize-corpus corpus) :statuses))) (dolist (spec '(("BOM-contradicts-encoding" :encoding-conflict 14 :byte ("CTM 3.2" "CTM 3.5" "CTM 3.6")) ("unknown-directive" :unknown-directive 0 :character ("CTM 3.5" "CTM 3.16")) ("wrong-version" :invalid-version 9 :character ("CTM 3.5" "CTM 3.7")))) (destructuring-bind (name code position unit clauses) spec (let* ((id (format nil "ctm/invalid/~A.ctm" name)) (selected (topic-maps.test-foundation:select-cases corpus :id id)) (case (first selected)) (path (topic-maps.test-foundation:test-case-source-pathname case)) (doc (topic-maps.test-foundation:test-case-document-iri case)) (input (binary path)) (identity (copy-tree (identity-fields case))) (text (topic-maps.ctm::decode-utf8 input :strip-bom t)) (control (cond ((equal name "BOM-contradicts-encoding") (bytes (topic-maps.registered-original.tests::replace-fragment text "iso-8859-1" "UTF-8") t)) ((equal name "unknown-directive") (bytes "%version 1.0")) (t (bytes "%version 1.0"))))) (check (concatenate 'string id ":existing-negative-contract-identity") (and (= 1 (length selected)) (eq :invalid (topic-maps.test-foundation:test-case-category case)) (eq :ctm-rejection (topic-maps.test-foundation:test-case-expected-outcome case)) (null (topic-maps.test-foundation:test-case-expected-baseline case)) (eq :not-run (topic-maps.test-foundation:test-case-status case)) (null (topic-maps.test-foundation:test-case-actual-outcome case)) (equal doc (format nil "https://ctm-tests.example.invalid/~A/~A" (getf (topic-maps.test-foundation:corpus-metadata corpus) :commit) id)))) (multiple-value-bind (map condition) (captured-read (lambda () (topic-maps.ctm:deserialize-file path :document-iri doc :source-name id))) (multiple-value-bind (repeat-map repeated) (captured-read (lambda () (topic-maps.ctm:deserialize-file path :document-iri doc :source-name id))) (multiple-value-bind (control-map control-condition) (file-result (concatenate 'string id ":control") control) (let ((qualified (and (null map) (null repeat-map) (eq 'topic-maps.ctm:ctm-rejection (type-of condition)) (eq code (topic-maps.ctm:error-code condition)) (= position (topic-maps.ctm:error-position condition)) (eq unit (topic-maps.ctm:error-position-unit condition)) (equal id (topic-maps.ctm:error-source condition)) (null (topic-maps.ctm:error-cause condition)) (null (topic-maps.ctm:error-context condition)) (equal (topic-maps.registered-original.tests::condition-signature condition) (topic-maps.registered-original.tests::condition-signature repeated)) (null control-condition) control-map (if (equal name "BOM-contradicts-encoding") (topic-maps.registered-original.tests::plain-locals-p control-map *doc* '("topic")) (null (topic-map-topics control-map)))))) (check (concatenate 'string id ":immutable-source-and-identity") (and (equalp input (binary path)) (equal identity (identity-fields case)))) (when qualified (topic-maps.test-foundation:record-result case :ctm-rejection :diagnostics (list (princ-to-string condition)))) (push (fields "id" id "documentIRI" doc "sourceTextAfterBOM" text "sourceHex" (format nil "~{~2,'0X~^ ~}" (coerce input 'list)) "clauses" (coerce clauses 'vector) "condition" (condition-data condition) "repeatCondition" (condition-data repeated) "qualified" (if qualified :true :false) "status" (topic-maps.test-foundation::word (topic-maps.test-foundation:test-case-status case)) "control" (fields "accepted" (if control-map :true :false) "condition" (condition-data control-condition) "model" (when control-map (topic-maps.template.tests::observe control-map)))) *originals*) (format t "~&PROLOG-ORIGINAL ~A: ~A; ~A~%" id (topic-maps.test-foundation:test-case-status case) condition)))))))) (check "prolog:only-three-intended-original-records-change" (and (eq corpus topic-maps.ctm.tests::*cxtm-corpus*) (equal old-cxtm topic-maps.ctm.tests::*cxtm-results*) (every (lambda (entry) (if (member (topic-maps.test-foundation:test-case-id (car entry)) ids :test #'equal) (equal (first (cdr entry)) (identity-fields (car entry))) (equal (cdr entry) (case-state (car entry))))) previous))) (let ((after (getf (topic-maps.test-foundation:summarize-corpus corpus) :statuses))) (check "prolog:three-new-PASS-four-known-FAILs-retained" (and (= (+ 3 (getf *entry-statuses* :pass)) (getf after :pass)) (= (- (getf *entry-statuses* :not-run) 3) (getf after :not-run)) (= (getf *entry-statuses* :fail) (getf after :fail)) (= (getf *entry-statuses* :unsupported) (getf after :unsupported))))))) (defun run-tests () (unless topic-maps.ctm.tests::*cxtm-corpus* (topic-maps.registered-original.tests:run-tests) (topic-maps.registered-original.tests:run-negative-tests)) (setf *positives* nil *negatives* nil *originals* nil) (let ((topic-maps.registered-original.tests::*checks* nil)) (positive-prologs) (prolog-rejections) (byte-order-tests) (resource-prolog-tests) (original-contracts) (check "prolog:unique-check-names" (= (length topic-maps.registered-original.tests::*checks*) (length (remove-duplicates topic-maps.registered-original.tests::*checks* :test #'equal)))) (setf *checks* (nreverse topic-maps.registered-original.tests::*checks*))) (setf *positives* (nreverse *positives*) *negatives* (nreverse *negatives*) *originals* (nreverse *originals*)) (format t "~&PROLOG-PASS: ~D checks; three intended original rejections~%" (length *checks*)) t) (defun write-reports (prefix) (with-open-file (out (concatenate 'string prefix ".prolog.json") :direction :output :if-exists :supersede) (topic-maps.test-foundation::emit-json-value (fields "kind" "ctm-prolog-execution" "passed" (length *checks*) "failed" 0 "entryStatuses" (topic-maps.test-foundation::counts-object *entry-statuses*) "checks" (coerce *checks* 'vector) "positives" (coerce *positives* 'vector) "negativeControls" (coerce *negatives* 'vector) "originals" (coerce *originals* 'vector)) out) (terpri out)) (topic-maps.ctm.tests::write-cxtm-report (concatenate 'string prefix ".validation.json") (concatenate 'string prefix ".cxtm.json") :additional-checks *checks* :scope "Slice 20C: three intended negative originals; minimal UTF-8 encoding conflict preflight and CTM 1.0 prolog. All earlier contract identities and four known FAILs retained."))