1063 lines
47 KiB
EmacsLisp
1063 lines
47 KiB
EmacsLisp
;;; tp-render-tests.el --- ERT regression tests for tp-render.el -*- lexical-binding: t -*-
|
|
|
|
;;; Commentary:
|
|
|
|
;; Regression tests for confirmed bugs fixed in the reactive-render
|
|
;; module (tp-render.el, with supporting fixes in tp-reactive.el).
|
|
;; Each section is tagged with the canonical bug id it guards against.
|
|
|
|
;;; Code:
|
|
|
|
(require 'ert)
|
|
(require 'tp)
|
|
|
|
;; Reactive test variables must be dynamically bound so watcher and
|
|
;; compute machinery can see them through `symbol-value'.
|
|
(defvar tp-rt-b9-var nil)
|
|
(defvar tp-rt-b10-data nil)
|
|
(defvar tp-rt-b10-full nil)
|
|
(defvar tp-rt-b11-face nil)
|
|
(defvar tp-rt-b11b-color nil)
|
|
(defvar tp-rt-b12-color nil)
|
|
(defvar tp-rt-b13-text nil)
|
|
(defvar tp-rt-b13b-text nil)
|
|
(defvar tp-rt-b14-flag nil)
|
|
(defvar tp-rt-b14-inv nil)
|
|
(defvar tp-rt-b14b-init nil)
|
|
(defvar tp-rt-b16-data nil)
|
|
(defvar tp-rt-b16-comp nil)
|
|
(defvar tp-rt-b16-count 0)
|
|
(defvar tp-rt-b17-color nil)
|
|
(defvar tp-rt-b17-text nil)
|
|
(defvar tp-rt-b17b-color nil)
|
|
(defvar tp-rt-b17b-echo nil)
|
|
(defvar tp-rt-b18-text nil)
|
|
(defvar tp-rt-b19-amount nil)
|
|
(defvar tp-rt-b19s-amount nil)
|
|
(defvar tp-rt-r1-color nil)
|
|
(defvar tp-rt-r1b-color nil)
|
|
(defvar tp-rt-r1c-color nil)
|
|
(defvar tp-rt-r1d-color nil)
|
|
(defvar tp-rt-r2-text nil)
|
|
(defvar tp-rt-r2m-text nil)
|
|
(defvar tp-rt-r2n-text nil)
|
|
(defvar tp-rt-r2s-text nil)
|
|
(defvar tp-rt-r3a-color nil)
|
|
(defvar tp-rt-r3b-color nil)
|
|
(defvar tp-rt-r3c-color nil)
|
|
(defvar tp-rt-a02-old-color nil)
|
|
(defvar tp-rt-a02-new-color nil)
|
|
(defvar tp-rt-a11-data nil)
|
|
(defvar tp-rt-a11-computed nil)
|
|
(defvar tp-rt-a11-watched nil)
|
|
(defvar tp-rt-a11-text nil)
|
|
|
|
(defmacro tp-rt-with-cleanup (layers vars &rest body)
|
|
"Run BODY, then undefine LAYERS and reset VARS to nil (teardown)."
|
|
(declare (indent 2))
|
|
`(unwind-protect
|
|
(progn ,@body)
|
|
,@(mapcar (lambda (l) `(tp-undefine-layer ',l)) layers)
|
|
,@(mapcar (lambda (v) `(setq ,v nil)) vars)
|
|
(setq tp-reactive-observer-errors nil)))
|
|
|
|
;;; B9: sub-region tp-text on a string must splice, not replace the whole string
|
|
|
|
(ert-deftest tp-render-test-tp-text-string-region-keeps-rest ()
|
|
"Region-form tp-text on a string keeps the text outside the region."
|
|
(let ((result (tp-set 0 1 '(tp-text "X") (copy-sequence "abc"))))
|
|
(should (equal result "Xbc"))
|
|
(should (equal (get-text-property 0 'tp-text result) "X"))
|
|
;; The preserved suffix must not receive the layer's props
|
|
(should (null (get-text-property 1 'tp-text result)))
|
|
(should (null (get-text-property 2 'tp-text result)))))
|
|
|
|
(ert-deftest tp-render-test-tp-text-string-mid-region-splices ()
|
|
"A mid-string tp-text region splices prefix + replacement + suffix."
|
|
(let ((result (tp-set 1 2 '(face bold tp-text "XY") (copy-sequence "abc"))))
|
|
(should (equal result "aXYc"))
|
|
;; Props only on the replaced span [1, 3)
|
|
(should (null (get-text-property 0 'face result)))
|
|
(should (eq (get-text-property 1 'face result) 'bold))
|
|
(should (eq (get-text-property 2 'face result) 'bold))
|
|
(should (null (get-text-property 3 'face result)))))
|
|
|
|
(ert-deftest tp-render-test-tp-text-string-region-preserves-outside-props ()
|
|
"Splicing keeps the original string's properties outside the region."
|
|
(let* ((source (propertize "abc" 'face 'italic 'my-prop 1))
|
|
(result (tp-set 1 2 '(tp-text "X") source)))
|
|
(should (equal result "aXc"))
|
|
;; Prefix and suffix keep their original props
|
|
(should (eq (get-text-property 0 'face result) 'italic))
|
|
(should (eq (get-text-property 2 'face result) 'italic))
|
|
;; Replaced span preserves non-conflicting props (tp-set preserves)
|
|
(should (eq (get-text-property 1 'my-prop result) 1))))
|
|
|
|
(ert-deftest tp-render-test-tp-text-whole-string-still-replaces ()
|
|
"Whole-string form still returns just the replacement (legacy semantics)."
|
|
(let ((result (tp-set "2" 'face '(:background "green") 'tp-text "6")))
|
|
(should (equal result "6"))
|
|
(should (equal (get-text-property 0 'face result) '(:background "green")))
|
|
(should (equal (get-text-property 0 'tp-text result) "6"))))
|
|
|
|
;;; TP-A01 / TP-A03: initial tp-text application uses per-run properties
|
|
|
|
(ert-deftest tp-render-test-initial-tp-text-keeps-string-property-runs ()
|
|
"Initial string tp-text application does not smear position-zero props."
|
|
(let* ((payload (concat (propertize "AB" 'face 'bold)
|
|
(propertize "CD" 'face 'italic)))
|
|
(result (tp-set "xxxx" 'tp-text payload)))
|
|
(should (eq (get-text-property 0 'face result) 'bold))
|
|
(should (eq (get-text-property 2 'face result) 'italic))))
|
|
|
|
(ert-deftest tp-render-test-initial-tp-text-keeps-buffer-property-runs ()
|
|
"Initial buffer tp-text application preserves every embedded prop run."
|
|
(let ((payload (concat (propertize "AB" 'face 'bold)
|
|
(propertize "CD" 'face 'italic))))
|
|
(with-temp-buffer
|
|
(insert "xxxx")
|
|
(tp-set 1 5 (list 'tp-text payload))
|
|
(should (eq (get-text-property 1 'face) 'bold))
|
|
(should (eq (get-text-property 3 'face) 'italic)))))
|
|
|
|
(ert-deftest tp-render-test-tp-text-explicit-nil-overrides-embedded-value ()
|
|
"A caller-provided nil remains present and wins over embedded props."
|
|
(let* ((payload (propertize "X" 'custom 'embedded))
|
|
(result (tp-set "x" 'tp-text payload 'custom nil)))
|
|
(should (equal (tp-member 0 'custom result) '(custom nil)))
|
|
(with-temp-buffer
|
|
(insert "x")
|
|
(tp-set 1 2 (list 'tp-text payload 'custom nil))
|
|
(should (equal (tp-member 1 'custom) '(custom nil))))))
|
|
|
|
(ert-deftest tp-render-test-same-text-reset-removes-old-properties ()
|
|
"A same-text tp-reset still replaces the complete property set."
|
|
(with-temp-buffer
|
|
(insert (propertize "AB" 'help-echo "old" 'face 'italic))
|
|
(tp-reset 1 3 '(tp-text "AB" face bold))
|
|
(should-not (plist-member (text-properties-at 1) 'help-echo))
|
|
(should (eq (get-text-property 1 'face) 'bold)))
|
|
(let* ((source (propertize "AB" 'help-echo "old" 'face 'italic))
|
|
(result (tp-reset source 'tp-text "AB" 'face 'bold)))
|
|
(should-not (plist-member (text-properties-at 0 result) 'help-echo))
|
|
(should (eq (get-text-property 0 'face result) 'bold))))
|
|
|
|
(ert-deftest tp-render-test-same-text-add-merges-existing-face ()
|
|
"A same-text tp-add keeps add semantics while applying per-run props."
|
|
(with-temp-buffer
|
|
(insert (propertize "AB" 'face 'italic))
|
|
(tp-add 1 3 '(tp-text "AB" face bold))
|
|
(should (equal (get-text-property 1 'face) '(bold italic))))
|
|
(let* ((source (propertize "AB" 'face 'italic))
|
|
(result (tp-add source 'tp-text "AB" 'face 'bold)))
|
|
(should (equal (get-text-property 0 'face result) '(bold italic))))
|
|
(let* ((source (propertize "AB" 'face 'italic))
|
|
(result (tp-add source 'tp-text nil 'face 'bold)))
|
|
(should (equal (get-text-property 0 'face result) '(bold italic)))))
|
|
|
|
;;; TP-A02: layer redefinition refreshes with full old/new ownership
|
|
|
|
(ert-deftest tp-render-test-static-redefinition-refreshes-managed-region ()
|
|
"A simple static redefinition refreshes an already-mounted layer."
|
|
(tp-rt-with-cleanup (tp-rt-a02-static) ()
|
|
(define-tp tp-rt-a02-static () '(face bold help-echo "old"))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-push-layer 1 6 'tp-rt-a02-static)
|
|
(define-tp tp-rt-a02-static () '(face italic))
|
|
(should (eq (get-text-property 1 'face) 'italic))
|
|
(should-not (plist-member (text-properties-at 1) 'help-echo)))))
|
|
|
|
(ert-deftest tp-render-test-redefinition-preserves-external-value ()
|
|
"A value changed after mounting is not deleted as stale layer output."
|
|
(tp-rt-with-cleanup (tp-rt-a02-external) ()
|
|
(define-tp tp-rt-a02-external () '(face bold help-echo "owned"))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-push-layer 1 6 'tp-rt-a02-external)
|
|
(put-text-property 1 6 'help-echo "external")
|
|
(define-tp tp-rt-a02-external () '(face italic))
|
|
(should (eq (get-text-property 1 'face) 'italic))
|
|
(should (equal (get-text-property 1 'help-echo) "external")))))
|
|
|
|
(ert-deftest tp-render-test-reactive-redefinition-removes-old-owned-keys ()
|
|
"Reactive redefinition removes keys and nested face data it no longer owns."
|
|
(tp-rt-with-cleanup
|
|
(tp-rt-a02-reactive) (tp-rt-a02-old-color tp-rt-a02-new-color)
|
|
(setq tp-rt-a02-old-color "red"
|
|
tp-rt-a02-new-color "blue")
|
|
(define-tp tp-rt-a02-reactive ()
|
|
:props '(face (:foreground $tp-rt-a02-old-color)
|
|
help-echo "old"))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-push-layer 1 6 'tp-rt-a02-reactive)
|
|
(define-tp tp-rt-a02-reactive ()
|
|
:props '(face (:background $tp-rt-a02-new-color)))
|
|
(let ((face (get-text-property 1 'face)))
|
|
(should (equal (plist-get face :background) "blue"))
|
|
(should-not (plist-member face :foreground)))
|
|
(should-not (plist-member (text-properties-at 1) 'help-echo)))))
|
|
|
|
;;; TP-A11: business computations fail; observers are isolated and recorded
|
|
|
|
(ert-deftest tp-render-test-transform-error-propagates ()
|
|
"Transform failures and non-string results both propagate."
|
|
(tp-rt-with-cleanup
|
|
(tp-rt-a11-transform tp-rt-a11-nonstring) (tp-rt-a11-text)
|
|
(setq tp-rt-a11-text "raw")
|
|
(define-tp tp-rt-a11-transform ()
|
|
:props '(tp-text $tp-rt-a11-text)
|
|
:transform (lambda (_text) (error "transform failed")))
|
|
(should-error (tp-set "old" 'tp-rt-a11-transform)
|
|
:type 'error)
|
|
(define-tp tp-rt-a11-nonstring ()
|
|
:props '(tp-text $tp-rt-a11-text)
|
|
:transform (lambda (_text) 42))
|
|
(should-error (tp-set "old" 'tp-rt-a11-nonstring)
|
|
:type 'error)))
|
|
|
|
(ert-deftest tp-render-test-compute-errors-propagate ()
|
|
"Initial and update-time compute failures reach the caller."
|
|
(tp-rt-with-cleanup (tp-rt-a11-initial tp-rt-a11-update)
|
|
(tp-rt-a11-data tp-rt-a11-computed)
|
|
(should-error
|
|
(define-tp tp-rt-a11-initial ()
|
|
:props '(help-echo $tp-rt-a11-computed)
|
|
:compute '((tp-rt-a11-computed
|
|
(lambda () (error "initial compute failed")))))
|
|
:type 'error)
|
|
(setq tp-rt-a11-data "ok")
|
|
(define-tp tp-rt-a11-update ()
|
|
:props '(help-echo $tp-rt-a11-computed)
|
|
:data '(tp-rt-a11-data)
|
|
:compute '((tp-rt-a11-computed
|
|
(lambda ()
|
|
(if (equal tp-rt-a11-data "ok")
|
|
"ready"
|
|
(error "update compute failed"))))))
|
|
(should-error (setq tp-rt-a11-data "fail")
|
|
:type 'error)))
|
|
|
|
(ert-deftest tp-render-test-watcher-error-is-recorded-and-update-continues ()
|
|
"Watcher failures are isolated, queryable, and do not block rendering."
|
|
(tp-rt-with-cleanup (tp-rt-a11-watcher) (tp-rt-a11-watched)
|
|
(setq tp-rt-a11-watched "red")
|
|
(when (boundp 'tp-reactive-observer-errors)
|
|
(set 'tp-reactive-observer-errors nil))
|
|
(define-tp tp-rt-a11-watcher ()
|
|
:props '(face (:foreground $tp-rt-a11-watched))
|
|
:watch '((tp-rt-a11-watched
|
|
(lambda (_new _old _layer)
|
|
(error "watcher failed")))))
|
|
(with-temp-buffer
|
|
(insert "x")
|
|
(tp-push-layer 1 2 'tp-rt-a11-watcher)
|
|
(setq tp-rt-a11-watched "blue")
|
|
(should (equal (plist-get (tp-at 1 'face) :foreground) "blue"))
|
|
(should (boundp 'tp-reactive-observer-errors))
|
|
(let ((failure (car (symbol-value 'tp-reactive-observer-errors))))
|
|
(should (eq (plist-get failure :kind) 'watcher))
|
|
(should (eq (plist-get failure :layer) 'tp-rt-a11-watcher))
|
|
(should (eq (plist-get failure :symbol) 'tp-rt-a11-watched))
|
|
(should (eq (car (plist-get failure :condition)) 'error))))))
|
|
|
|
;;; B10: computed-variable path must not clobber sibling static attributes
|
|
|
|
(ert-deftest tp-render-test-computed-update-keeps-static-siblings ()
|
|
"A computed update deep-merges, keeping static nested attributes."
|
|
(tp-rt-with-cleanup (tp-rt-b10-layer) (tp-rt-b10-data tp-rt-b10-full)
|
|
(setq tp-rt-b10-data "red")
|
|
(define-tp tp-rt-b10-layer ()
|
|
:props '(face (:foreground $tp-rt-b10-full :background "green"))
|
|
:data '(tp-rt-b10-data)
|
|
:compute '((tp-rt-b10-full (lambda () (concat "col-" tp-rt-b10-data)))))
|
|
(setq tp-rt-b10-data "blue")
|
|
(let ((face (plist-get (cdr (assoc 'tp-rt-b10-layer tp-layer-alist)) 'face)))
|
|
(should (equal (plist-get face :foreground) "col-blue"))
|
|
;; The sibling static attribute must survive the update
|
|
(should (equal (plist-get face :background) "green")))))
|
|
|
|
;;; B11: reactive refresh replaces the layer's own keys instead of accumulating
|
|
|
|
(ert-deftest tp-render-test-reactive-refresh-replaces-face ()
|
|
"Changing a symbol-valued face variable replaces the face, not stacks it."
|
|
(tp-rt-with-cleanup (tp-rt-b11-layer) (tp-rt-b11-face)
|
|
(setq tp-rt-b11-face 'bold)
|
|
(define-tp tp-rt-b11-layer () '(face $tp-rt-b11-face))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b11-layer)
|
|
(should (eq (get-text-property 1 'face) 'bold))
|
|
(setq tp-rt-b11-face 'italic)
|
|
;; Must be italic alone, not (italic bold)
|
|
(should (eq (get-text-property 1 'face) 'italic)))))
|
|
|
|
(ert-deftest tp-render-test-reactive-refresh-keeps-unrelated-props ()
|
|
"Reactive refresh leaves property keys the layer does not own alone."
|
|
(tp-rt-with-cleanup (tp-rt-b11b-layer) (tp-rt-b11b-color)
|
|
(setq tp-rt-b11b-color "red")
|
|
(define-tp tp-rt-b11b-layer () '(face (:foreground $tp-rt-b11b-color)))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b11b-layer)
|
|
(put-text-property 1 6 'help-echo "keep me")
|
|
(setq tp-rt-b11b-color "green")
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground) "green"))
|
|
(should (equal (get-text-property 1 'help-echo) "keep me")))))
|
|
|
|
;;; B12: setq-local must not leak into the global layer definition
|
|
|
|
(ert-deftest tp-render-test-setq-local-does-not-touch-global-def ()
|
|
"A buffer-local change re-renders the buffer but keeps the global def."
|
|
(tp-rt-with-cleanup (tp-rt-b12-layer) ()
|
|
(setq-default tp-rt-b12-color "red")
|
|
(define-tp tp-rt-b12-layer () '(face (:foreground $tp-rt-b12-color)))
|
|
(let ((buf-a (generate-new-buffer " tp-rt-b12-a"))
|
|
(buf-b (generate-new-buffer " tp-rt-b12-b")))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf-a
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b12-layer))
|
|
(with-current-buffer buf-b
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b12-layer))
|
|
(with-current-buffer buf-a
|
|
(setq-local tp-rt-b12-color "purple"))
|
|
;; Buffer A is re-rendered with its local value
|
|
(with-current-buffer buf-a
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground)
|
|
"purple")))
|
|
;; The GLOBAL definition must not absorb the local value
|
|
(should (equal (plist-get
|
|
(plist-get (cdr (assoc 'tp-rt-b12-layer tp-layer-alist))
|
|
'face)
|
|
:foreground)
|
|
"red"))
|
|
(should (equal (default-value 'tp-rt-b12-color) "red"))
|
|
;; Other buffers keep rendering the global value
|
|
(with-current-buffer buf-b
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground)
|
|
"red"))))
|
|
(kill-buffer buf-a)
|
|
(kill-buffer buf-b)
|
|
(setq-default tp-rt-b12-color nil)))))
|
|
|
|
;;; B13: reactive tp-text replacement preserves unrelated properties
|
|
|
|
(ert-deftest tp-render-test-reactive-text-update-preserves-other-props ()
|
|
"Replacing reactive text keeps properties other layers put on the region."
|
|
(tp-rt-with-cleanup (tp-rt-b13-layer) (tp-rt-b13-text)
|
|
(setq tp-rt-b13-text "aaa")
|
|
(define-tp tp-rt-b13-layer () '(face bold tp-text $tp-rt-b13-text))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b13-layer)
|
|
(put-text-property 1 3 'my-other-prop 42)
|
|
(setq tp-rt-b13-text "bbb")
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"bbb"))
|
|
;; The unrelated property survives the text replacement
|
|
(should (eq (get-text-property 1 'my-other-prop) 42))
|
|
;; The layer's own props are still applied
|
|
(should (eq (get-text-property 1 'face) 'bold)))))
|
|
|
|
(ert-deftest tp-render-test-reactive-text-same-text-preserves-other-props ()
|
|
"A same-text properties-only update keeps unrelated properties too."
|
|
(tp-rt-with-cleanup (tp-rt-b13b-layer) (tp-rt-b13b-text)
|
|
(setq tp-rt-b13b-text "emacs")
|
|
(define-tp tp-rt-b13b-layer () '(tp-text $tp-rt-b13b-text))
|
|
(with-temp-buffer
|
|
(insert "emacs")
|
|
(tp-set 1 6 'tp-rt-b13b-layer)
|
|
(put-text-property 1 6 'my-other-prop 'yes)
|
|
;; Same text, new embedded properties
|
|
(setq tp-rt-b13b-text (propertize "emacs" 'face 'bold))
|
|
(should (eq (get-text-property 1 'face) 'bold))
|
|
(should (eq (get-text-property 1 'my-other-prop) 'yes)))))
|
|
|
|
;;; B14: computed values of nil must propagate
|
|
|
|
(ert-deftest tp-render-test-computed-nil-propagates-on-update ()
|
|
"A compute function returning nil updates the variable and the layer."
|
|
(tp-rt-with-cleanup (tp-rt-b14-layer) (tp-rt-b14-flag tp-rt-b14-inv)
|
|
(setq tp-rt-b14-flag t)
|
|
(define-tp tp-rt-b14-layer ()
|
|
:props '(invisible $tp-rt-b14-inv)
|
|
:data '(tp-rt-b14-flag)
|
|
:compute '((tp-rt-b14-inv (lambda () tp-rt-b14-flag))))
|
|
(should (eq tp-rt-b14-inv t))
|
|
(setq tp-rt-b14-flag nil)
|
|
;; nil is a legitimate computed value, not an error sentinel
|
|
(should (eq tp-rt-b14-inv nil))
|
|
(should (eq (plist-get (cdr (assoc 'tp-rt-b14-layer tp-layer-alist))
|
|
'invisible)
|
|
nil))))
|
|
|
|
(ert-deftest tp-render-test-computed-nil-applies-initially ()
|
|
"An initial computed value of nil overwrites a stale non-nil value."
|
|
(tp-rt-with-cleanup (tp-rt-b14b-layer) (tp-rt-b14b-init)
|
|
(setq tp-rt-b14b-init 'stale)
|
|
(define-tp tp-rt-b14b-layer ()
|
|
:props '(invisible $tp-rt-b14b-init)
|
|
:compute '((tp-rt-b14b-init (lambda () nil))))
|
|
(should (eq tp-rt-b14b-init nil))))
|
|
|
|
;;; B16: no watcher recursion from nested variable writes
|
|
|
|
(ert-deftest tp-render-test-compute-runs-once-per-change ()
|
|
"One data change runs each compute function exactly once (no recursion)."
|
|
(tp-rt-with-cleanup (tp-rt-b16-layer) (tp-rt-b16-data tp-rt-b16-comp)
|
|
(setq tp-rt-b16-data "a" tp-rt-b16-count 0)
|
|
(define-tp tp-rt-b16-layer ()
|
|
:props '(help-echo $tp-rt-b16-comp)
|
|
:data '(tp-rt-b16-data)
|
|
:compute '((tp-rt-b16-comp
|
|
(lambda ()
|
|
(setq tp-rt-b16-count (1+ tp-rt-b16-count))
|
|
(concat tp-rt-b16-data "!")))))
|
|
(with-temp-buffer
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-b16-layer)
|
|
(setq tp-rt-b16-count 0)
|
|
(setq tp-rt-b16-data "b")
|
|
;; The nested (set comp ...) must queue its re-render, not re-enter
|
|
;; the compute machinery.
|
|
(should (= tp-rt-b16-count 1))
|
|
;; The nested change's re-render still lands in the buffer
|
|
(should (equal tp-rt-b16-comp "b!"))
|
|
(should (equal (get-text-property 1 'help-echo) "b!")))))
|
|
|
|
;;; B17: batched entries must union WHERE and the tp-text-affected flag
|
|
|
|
(ert-deftest tp-render-test-batch-tp-text-flag-is-sticky ()
|
|
"A tp-text change deferred after a non-tp-text change still replaces text."
|
|
(tp-rt-with-cleanup (tp-rt-b17-layer) (tp-rt-b17-color tp-rt-b17-text)
|
|
(setq tp-rt-b17-color "red" tp-rt-b17-text "one")
|
|
(define-tp tp-rt-b17-layer ()
|
|
'(face (:foreground $tp-rt-b17-color) tp-text $tp-rt-b17-text))
|
|
(with-temp-buffer
|
|
(insert "one")
|
|
(tp-set 1 4 'tp-rt-b17-layer)
|
|
(tp-with-batch-updates
|
|
(setq tp-rt-b17-color "blue") ; first change: no tp-text
|
|
(setq tp-rt-b17-text "two")) ; second change: tp-text affected
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"two"))
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground)
|
|
"blue")))))
|
|
|
|
(ert-deftest tp-render-test-batch-where-widens-to-all-buffers ()
|
|
"A global change after a buffer-local one must reach other buffers."
|
|
(tp-rt-with-cleanup (tp-rt-b17b-layer) ()
|
|
(setq-default tp-rt-b17b-color "red")
|
|
(setq-default tp-rt-b17b-echo "old")
|
|
(define-tp tp-rt-b17b-layer ()
|
|
'(face (:foreground $tp-rt-b17b-color) help-echo $tp-rt-b17b-echo))
|
|
(let ((buf-a (generate-new-buffer " tp-rt-b17b-a"))
|
|
(buf-b (generate-new-buffer " tp-rt-b17b-b")))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf-a
|
|
(insert "Hello") (tp-set 1 6 'tp-rt-b17b-layer))
|
|
(with-current-buffer buf-b
|
|
(insert "Hello") (tp-set 1 6 'tp-rt-b17b-layer))
|
|
(with-current-buffer buf-a
|
|
(tp-with-batch-updates
|
|
(setq-local tp-rt-b17b-color "blue") ; WHERE = buf-a
|
|
(setq tp-rt-b17b-echo "new"))) ; WHERE = global
|
|
;; The global change must not be trapped in buf-a's WHERE
|
|
(with-current-buffer buf-b
|
|
(should (equal (get-text-property 1 'help-echo) "new"))
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground)
|
|
"red")))
|
|
;; buf-a gets both, with its local color honored
|
|
(with-current-buffer buf-a
|
|
(should (equal (get-text-property 1 'help-echo) "new"))
|
|
(should (equal (plist-get (get-text-property 1 'face) :foreground)
|
|
"blue"))))
|
|
(kill-buffer buf-a)
|
|
(kill-buffer buf-b)
|
|
(setq-default tp-rt-b17b-color nil)
|
|
(setq-default tp-rt-b17b-echo nil)))))
|
|
|
|
;;; B18: multi-interval reactive strings keep per-interval styling
|
|
|
|
(ert-deftest tp-render-test-reactive-text-keeps-per-interval-props ()
|
|
"A propertized reactive string renders each interval's own props."
|
|
(tp-rt-with-cleanup (tp-rt-b18-layer) (tp-rt-b18-text)
|
|
(setq tp-rt-b18-text "init")
|
|
(define-tp tp-rt-b18-layer () '(tp-text $tp-rt-b18-text))
|
|
(with-temp-buffer
|
|
(insert "init")
|
|
(tp-set 1 5 'tp-rt-b18-layer)
|
|
(setq tp-rt-b18-text (concat (propertize "AB" 'face 'bold)
|
|
(propertize "CD" 'face 'italic)))
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"ABCD"))
|
|
;; Position-0 props must not smear over the whole region
|
|
(should (eq (get-text-property 1 'face) 'bold))
|
|
(should (eq (get-text-property 2 'face) 'bold))
|
|
(should (eq (get-text-property 3 'face) 'italic))
|
|
(should (eq (get-text-property 4 'face) 'italic)))))
|
|
|
|
;;; B19: :transform applies on the initial nil-tp-text render too
|
|
|
|
(ert-deftest tp-render-test-transform-applies-on-initial-render ()
|
|
"First render of a nil tp-text layer shows the transformed text."
|
|
(tp-rt-with-cleanup (tp-rt-b19-layer) (tp-rt-b19-amount)
|
|
(setq tp-rt-b19-amount nil)
|
|
(define-tp tp-rt-b19-layer ()
|
|
:props '(face bold tp-text $tp-rt-b19-amount)
|
|
:transform (lambda (s) (concat "$" s)))
|
|
(with-temp-buffer
|
|
(insert "5.00")
|
|
(tp-set 1 5 'tp-rt-b19-layer)
|
|
;; Initial rendering must match later reactive renderings
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"$5.00"))
|
|
;; The model (variable and tp-text prop) keeps the raw value
|
|
(should (equal tp-rt-b19-amount "5.00"))
|
|
(should (equal (get-text-property 1 'tp-text) "5.00"))
|
|
(should (eq (get-text-property 1 'face) 'bold))
|
|
;; And a later update stays consistent
|
|
(setq tp-rt-b19-amount "6.00")
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"$6.00")))))
|
|
|
|
(ert-deftest tp-render-test-transform-applies-on-initial-string-render ()
|
|
"String form of a nil tp-text layer also shows the transformed text."
|
|
(tp-rt-with-cleanup (tp-rt-b19s-layer) (tp-rt-b19s-amount)
|
|
(setq tp-rt-b19s-amount nil)
|
|
(define-tp tp-rt-b19s-layer ()
|
|
:props '(face bold tp-text $tp-rt-b19s-amount)
|
|
:transform (lambda (s) (concat "$" s)))
|
|
(let ((result (tp-set "5.00" 'tp-rt-b19s-layer)))
|
|
(should (equal result "$5.00"))
|
|
;; Model keeps the raw value
|
|
(should (equal tp-rt-b19s-amount "5.00"))
|
|
(should (equal (get-text-property 0 'tp-text result) "5.00"))
|
|
(should (eq (get-text-property 0 'face result) 'bold)))))
|
|
|
|
;;; R1 (0.3.0): reactive buffer registry replaces the buffer-list scan
|
|
|
|
(ert-deftest tp-render-test-registry-update-visits-only-registered ()
|
|
"A reactive update walks only registered buffers, not `buffer-list'."
|
|
(tp-rt-with-cleanup (tp-rt-r1-layer) (tp-rt-r1-color)
|
|
(setq tp-rt-r1-color "red")
|
|
(define-tp tp-rt-r1-layer () '(face (:foreground $tp-rt-r1-color)))
|
|
(let ((buf-a (generate-new-buffer " tp-rt-r1-a"))
|
|
(buf-b (generate-new-buffer " tp-rt-r1-b"))
|
|
(visited nil))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf-a
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-r1-layer))
|
|
(with-current-buffer buf-b (insert "Hello"))
|
|
;; Applying through tp-ops registered the buffer
|
|
(should (equal (tp-reactive-layer-buffers 'tp-rt-r1-layer)
|
|
(list buf-a)))
|
|
;; Count per-buffer visits of the update walk
|
|
(let ((orig (symbol-function 'tp--render-visit-buffer)))
|
|
(cl-letf (((symbol-function 'tp--render-visit-buffer)
|
|
(lambda (buf fn)
|
|
(push buf visited)
|
|
(funcall orig buf fn))))
|
|
(setq tp-rt-r1-color "blue")))
|
|
;; Only the registered buffer was visited
|
|
(should (equal visited (list buf-a)))
|
|
(with-current-buffer buf-a
|
|
(should (equal (plist-get (get-text-property 1 'face)
|
|
:foreground)
|
|
"blue"))))
|
|
(kill-buffer buf-a)
|
|
(kill-buffer buf-b)))))
|
|
|
|
(ert-deftest tp-render-test-registry-prunes-on-kill-buffer ()
|
|
"Killing a buffer removes it from the layer-buffer registry."
|
|
(tp-rt-with-cleanup (tp-rt-r1b-layer) (tp-rt-r1b-color)
|
|
(setq tp-rt-r1b-color "red")
|
|
(define-tp tp-rt-r1b-layer () '(face (:foreground $tp-rt-r1b-color)))
|
|
(let ((buf (generate-new-buffer " tp-rt-r1b")))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-r1b-layer))
|
|
(should (equal (tp-reactive-layer-buffers 'tp-rt-r1b-layer)
|
|
(list buf)))
|
|
(kill-buffer buf)
|
|
;; The kill-buffer hook pruned the raw registry entry ...
|
|
(should-not (memq buf (gethash 'tp-rt-r1b-layer
|
|
tp--layer-buffers)))
|
|
;; ... and the accessor answers "known: none", NOT `unknown'.
|
|
(should (null (tp-reactive-layer-buffers 'tp-rt-r1b-layer)))
|
|
(should-not (eq (tp-reactive-layer-buffers 'tp-rt-r1b-layer)
|
|
'unknown)))
|
|
(when (buffer-live-p buf) (kill-buffer buf))))))
|
|
|
|
(ert-deftest tp-render-test-registry-unknown-full-scan-learns ()
|
|
"An `unknown' layer falls back to a full scan and learns its buffers."
|
|
(tp-rt-with-cleanup (tp-rt-r1c-layer) (tp-rt-r1c-color)
|
|
(setq tp-rt-r1c-color "red")
|
|
(define-tp tp-rt-r1c-layer () '(face (:foreground $tp-rt-r1c-color)))
|
|
(let ((buf (generate-new-buffer " tp-rt-r1c")))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-r1c-layer))
|
|
;; Simulate a buffer that got the layer outside the
|
|
;; registering paths: erase the registry knowledge.
|
|
(remhash 'tp-rt-r1c-layer tp--layer-buffers)
|
|
(should (eq (tp-reactive-layer-buffers 'tp-rt-r1c-layer)
|
|
'unknown))
|
|
;; The update still reaches the buffer (conservative fallback)
|
|
(setq tp-rt-r1c-color "blue")
|
|
(with-current-buffer buf
|
|
(should (equal (plist-get (get-text-property 1 'face)
|
|
:foreground)
|
|
"blue")))
|
|
;; ... and the scan registered the buffer it found (learning)
|
|
(should (equal (tp-reactive-layer-buffers 'tp-rt-r1c-layer)
|
|
(list buf))))
|
|
(kill-buffer buf)))))
|
|
|
|
(ert-deftest tp-render-test-track-buffer-closes-string-insert-gap ()
|
|
"`tp-reactive-track-buffer' registers a buffer filled by string insert."
|
|
(tp-rt-with-cleanup (tp-rt-r1d-layer) (tp-rt-r1d-color)
|
|
(setq tp-rt-r1d-color "red")
|
|
(define-tp tp-rt-r1d-layer () '(face (:foreground $tp-rt-r1d-color)))
|
|
(let ((buf-a (generate-new-buffer " tp-rt-r1d-a"))
|
|
(buf-b (generate-new-buffer " tp-rt-r1d-b")))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf-a
|
|
(insert "Hello")
|
|
(tp-set 1 6 'tp-rt-r1d-layer))
|
|
;; Inserting an already-propertized STRING bypasses the
|
|
;; registering buffer operations.
|
|
(let ((s (tp-set "Hi" 'tp-rt-r1d-layer)))
|
|
(with-current-buffer buf-b (insert s)))
|
|
(should-not (memq buf-b
|
|
(tp-reactive-layer-buffers 'tp-rt-r1d-layer)))
|
|
;; The layer is known, so buf-b is NOT updated (the gap) ...
|
|
(setq tp-rt-r1d-color "blue")
|
|
(with-current-buffer buf-b
|
|
(should (equal (plist-get (get-text-property 1 'face)
|
|
:foreground)
|
|
"red")))
|
|
;; ... until tp-reactive-track-buffer closes it.
|
|
(should (equal (with-current-buffer buf-b
|
|
(tp-reactive-track-buffer))
|
|
'(tp-rt-r1d-layer)))
|
|
(should (memq buf-b
|
|
(tp-reactive-layer-buffers 'tp-rt-r1d-layer)))
|
|
(setq tp-rt-r1d-color "green")
|
|
(with-current-buffer buf-b
|
|
(should (equal (plist-get (get-text-property 1 'face)
|
|
:foreground)
|
|
"green")))
|
|
(with-current-buffer buf-a
|
|
(should (equal (plist-get (get-text-property 1 'face)
|
|
:foreground)
|
|
"green"))))
|
|
(kill-buffer buf-a)
|
|
(kill-buffer buf-b)))))
|
|
|
|
;;; R2 (0.3.0): minimal-diff tp-text replacement
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-point-in-prefix-stays ()
|
|
"Point in the common prefix survives a reactive text edit unmoved."
|
|
(tp-rt-with-cleanup (tp-rt-r2-layer) (tp-rt-r2-text)
|
|
(setq tp-rt-r2-text "abcdef")
|
|
(define-tp tp-rt-r2-layer () '(tp-text $tp-rt-r2-text))
|
|
(with-temp-buffer
|
|
(insert "abcdef")
|
|
(tp-set 1 7 'tp-rt-r2-layer)
|
|
(goto-char 2) ; inside the common prefix "ab"
|
|
(setq tp-rt-r2-text "abXYef")
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"abXYef"))
|
|
(should (= (point) 2)))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-point-in-suffix-stays ()
|
|
"Point in the common suffix stays glued to its character."
|
|
(tp-rt-with-cleanup (tp-rt-r2-layer) (tp-rt-r2-text)
|
|
(setq tp-rt-r2-text "abcdef")
|
|
(define-tp tp-rt-r2-layer () '(tp-text $tp-rt-r2-text))
|
|
(with-temp-buffer
|
|
(insert "abcdef")
|
|
(tp-set 1 7 'tp-rt-r2-layer)
|
|
(goto-char 6) ; on the "f" of the suffix "ef"
|
|
;; Same-length edit: point must not move at all
|
|
(setq tp-rt-r2-text "abXYef")
|
|
(should (= (point) 6))
|
|
(should (eq (char-after) ?f))
|
|
;; Length-changing edit: point stays glued to its character
|
|
(setq tp-rt-r2-text "abXYZWef")
|
|
(should (= (point) 8))
|
|
(should (eq (char-after) ?f)))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-point-inside-diff-clamps ()
|
|
"Point inside the differing span ends up at the edit start."
|
|
(tp-rt-with-cleanup (tp-rt-r2-layer) (tp-rt-r2-text)
|
|
(setq tp-rt-r2-text "abcdef")
|
|
(define-tp tp-rt-r2-layer () '(tp-text $tp-rt-r2-text))
|
|
(with-temp-buffer
|
|
(insert "abcdef")
|
|
(tp-set 1 7 'tp-rt-r2-layer)
|
|
(goto-char 4) ; on "d", inside the "cd" -> "XY" span
|
|
(setq tp-rt-r2-text "abXYef")
|
|
(should (= (point) 3)))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-markers-survive ()
|
|
"Markers in the unchanged prefix and suffix survive a text update."
|
|
(tp-rt-with-cleanup (tp-rt-r2m-layer) (tp-rt-r2m-text)
|
|
(setq tp-rt-r2m-text "abcdef")
|
|
(define-tp tp-rt-r2m-layer () '(tp-text $tp-rt-r2m-text))
|
|
(with-temp-buffer
|
|
(insert "abcdef")
|
|
(tp-set 1 7 'tp-rt-r2m-layer)
|
|
(let ((m-prefix (copy-marker 2)) ; on "b"
|
|
(m-suffix (copy-marker 6))) ; on "f"
|
|
(setq tp-rt-r2m-text "abXYZef") ; "cd" -> "XYZ", one char longer
|
|
(should (equal (buffer-substring-no-properties (point-min)
|
|
(point-max))
|
|
"abXYZef"))
|
|
(should (= (marker-position m-prefix) 2))
|
|
(should (eq (char-after m-prefix) ?b))
|
|
(should (= (marker-position m-suffix) 7))
|
|
(should (eq (char-after m-suffix) ?f))
|
|
(set-marker m-prefix nil)
|
|
(set-marker m-suffix nil)))))
|
|
|
|
;;; TXT-1: the suffix-boundary marker must track its character
|
|
|
|
(defun tp-rt--txt1-marker-after-edit (old new marker-offset)
|
|
"Run a minimal-diff replacement of OLD by NEW with a boundary marker.
|
|
Insert \"HEAD \" OLD \" TAIL\" in a temp buffer, tag OLD with a
|
|
tp-name, put an insertion-type-nil marker at OLD's start plus
|
|
MARKER-OFFSET, replace via `tp--replace-reactive-text-in-buffer' and
|
|
return (MARKER-POSITION CHAR-AT-MARKER ORIGINAL-CHAR)."
|
|
(with-temp-buffer
|
|
(insert "HEAD ")
|
|
(let ((m-start (point)))
|
|
(insert old " TAIL")
|
|
(put-text-property m-start (+ m-start (length old))
|
|
'tp-name 'tp-rt-txt1-layer)
|
|
(let* ((mpos (+ m-start marker-offset))
|
|
(mchar (char-after mpos))
|
|
(mk (copy-marker mpos)))
|
|
(tp--replace-reactive-text-in-buffer 'tp-rt-txt1-layer new nil)
|
|
(prog1 (list (marker-position mk) (char-after mk) mchar)
|
|
(set-marker mk nil))))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-suffix-start-marker-tracks ()
|
|
"A marker on the FIRST character of the preserved suffix tracks it.
|
|
TXT-1: delete-then-insert collapsed such a marker onto the edit
|
|
start, stranding it before the inserted text; insert-then-delete
|
|
shifts it right with its character. Grow, same-length (the clearest
|
|
docstring violation) and shrink edits are all covered."
|
|
;; Grow: "0" -> "42"; marker on the space before "items" (offset 8).
|
|
(pcase-let ((`(,pos ,got ,want)
|
|
(tp-rt--txt1-marker-after-edit
|
|
"count: 0 items" "count: 42 items" 8)))
|
|
(should (eq got want))
|
|
(should (= pos 15))) ; 14 shifted right by 1
|
|
;; Same length: "0" -> "9"; the marker's correct position is
|
|
;; numerically unchanged.
|
|
(pcase-let ((`(,pos ,got ,want)
|
|
(tp-rt--txt1-marker-after-edit
|
|
"count: 0 items" "count: 9 items" 8)))
|
|
(should (eq got want))
|
|
(should (= pos 14)))
|
|
;; Shrink: "42" -> "0".
|
|
(pcase-let ((`(,pos ,got ,want)
|
|
(tp-rt--txt1-marker-after-edit
|
|
"count: 42 items" "count: 0 items" 9)))
|
|
(should (eq got want))
|
|
(should (= pos 14))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-deleted-char-marker-at-edit-end ()
|
|
"A marker whose character was deleted ends at the END of the edit.
|
|
The documented side effect of inserting before deleting; previously
|
|
such markers collapsed to the edit start. Either way they stay
|
|
inside the replacement span."
|
|
;; "100" -> "42": marker on the middle "0" (strictly inside the
|
|
;; edited span) ends after the inserted "42".
|
|
(pcase-let ((`(,pos ,_got ,_want)
|
|
(tp-rt--txt1-marker-after-edit
|
|
"count: 100 items" "count: 42 items" 8)))
|
|
;; Edit span starts at buffer position 13 ("100"), insert "42":
|
|
;; the marker lands at the end of the inserted text.
|
|
(should (= pos 15))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-suffix-marker-real-path ()
|
|
"The suffix-start marker tracks through a real setq-driven update."
|
|
(tp-rt-with-cleanup (tp-rt-r2s-layer) (tp-rt-r2s-text)
|
|
(setq tp-rt-r2s-text "count: 0 items")
|
|
(define-tp tp-rt-r2s-layer () '(tp-text $tp-rt-r2s-text))
|
|
(with-temp-buffer
|
|
(insert "count: 0 items")
|
|
(tp-set 1 15 'tp-rt-r2s-layer)
|
|
(let ((m (copy-marker 9))) ; the space before "items"
|
|
(setq tp-rt-r2s-text "count: 42 items")
|
|
(should (equal (buffer-substring-no-properties (point-min)
|
|
(point-max))
|
|
"count: 42 items"))
|
|
(should (eq (char-after m) ?\s))
|
|
(should (= (marker-position m) 10))
|
|
(set-marker m nil)))))
|
|
|
|
(ert-deftest tp-render-test-minimal-diff-identical-update-is-noop ()
|
|
"An identical-text reactive replacement leaves the buffer unmodified."
|
|
(tp-rt-with-cleanup (tp-rt-r2n-layer) (tp-rt-r2n-text)
|
|
(setq tp-rt-r2n-text "emacs")
|
|
(define-tp tp-rt-r2n-layer () '(face bold tp-text $tp-rt-r2n-text))
|
|
(with-temp-buffer
|
|
(insert "emacs")
|
|
(tp-set 1 6 'tp-rt-r2n-layer)
|
|
(set-buffer-modified-p nil)
|
|
(save-excursion
|
|
(tp--replace-reactive-text-in-buffer
|
|
'tp-rt-r2n-layer "emacs" (tp-layer-props 'tp-rt-r2n-layer t)))
|
|
;; No text edit and no property churn: the flag must stay clear
|
|
(should-not (buffer-modified-p))
|
|
(should (equal (buffer-substring-no-properties (point-min) (point-max))
|
|
"emacs"))
|
|
(should (eq (get-text-property 1 'face) 'bold)))))
|
|
|
|
;;; ARCH-4: the pending queue must survive neither reset nor errors
|
|
|
|
(defvar tp-rt-a4-face nil)
|
|
(defvar tp-rt-a4-color nil)
|
|
|
|
(ert-deftest tp-render-test-reactive-reset-clears-pending-queue ()
|
|
"tp-reactive-reset drops queued batch re-renders (ARCH-4).
|
|
Stranded entries would otherwise survive the reset and replay against
|
|
freshly (re)defined layers on the next flush."
|
|
(unwind-protect
|
|
(progn
|
|
(tp--queue-batch-update 'tp-rt-a4-ghost 'tp-rt-a4-ghost-var nil nil)
|
|
(should tp--batch-update-pending)
|
|
(tp-reactive-reset)
|
|
(should (null tp--batch-update-pending)))
|
|
(setq tp--batch-update-pending nil)))
|
|
|
|
(ert-deftest tp-render-test-error-escaping-update-flushes-nested-queue ()
|
|
"An error escaping a re-render cannot strand nested queued updates.
|
|
A modification hook that writes a second reactive variable and then
|
|
signals used to strand the nested entry in the global queue - the
|
|
flush tail sat outside any unwind-protect. The flush now runs as the
|
|
update unwinds, so the nested variable's re-render still lands and
|
|
the queue is drained (ARCH-4)."
|
|
(setq tp-rt-a4-face 'bold
|
|
tp-rt-a4-color "red")
|
|
(unwind-protect
|
|
(progn
|
|
(define-tp tp-rt-a4-layer-a () '(face $tp-rt-a4-face))
|
|
(define-tp tp-rt-a4-layer-b ()
|
|
'(face (:foreground $tp-rt-a4-color)))
|
|
(with-temp-buffer
|
|
(insert "Hello world")
|
|
(tp-set 1 6 'tp-rt-a4-layer-a)
|
|
(tp-set 7 12 'tp-rt-a4-layer-b)
|
|
(let ((armed t))
|
|
(add-hook 'before-change-functions
|
|
(lambda (_beg _end)
|
|
(when armed
|
|
(setq armed nil)
|
|
;; Nested reactive write from within the
|
|
;; re-render: goes to the global queue.
|
|
(setq tp-rt-a4-color "green")
|
|
(error "boom from modification hook")))
|
|
nil t)
|
|
(should-error (setq tp-rt-a4-face 'italic))
|
|
;; The nested entry was flushed on the way out, not
|
|
;; stranded...
|
|
(should (null tp--batch-update-pending))
|
|
;; ...and its re-render landed despite the error.
|
|
(should (equal (get-text-property 7 'face)
|
|
'(:foreground "green"))))))
|
|
(tp-undefine-layer 'tp-rt-a4-layer-a)
|
|
(tp-undefine-layer 'tp-rt-a4-layer-b)
|
|
(setq tp-rt-a4-face nil
|
|
tp-rt-a4-color nil
|
|
tp--batch-update-pending nil)))
|
|
|
|
;;; R3 (0.3.0): anonymous-layer garbage collection
|
|
|
|
(ert-deftest tp-render-test-gc-collects-unreferenced-anonymous-layer ()
|
|
"GC collects an anonymous layer whose only buffer was killed."
|
|
(setq tp-rt-r3a-color "red")
|
|
(let ((buf (generate-new-buffer " tp-rt-r3a"))
|
|
(name nil))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf
|
|
(insert "Hello")
|
|
(tp-set 1 6 '(face (:foreground $tp-rt-r3a-color)))
|
|
(setq name (get-text-property 1 'tp-name)))
|
|
(should name)
|
|
(should (assoc name tp-layer-alist))
|
|
(kill-buffer buf)
|
|
(should (memq name (tp-gc-anonymous-layers)))
|
|
(should-not (assoc name tp-layer-alist))
|
|
(should-not (rassq name tp--anonymous-layer-registry)))
|
|
(when (buffer-live-p buf) (kill-buffer buf))
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(setq tp-rt-r3a-color nil))))
|
|
|
|
(ert-deftest tp-render-test-gc-keeps-layer-still-displayed ()
|
|
"GC keeps an anonymous layer that a live buffer still shows."
|
|
(setq tp-rt-r3b-color "red")
|
|
(let ((buf (generate-new-buffer " tp-rt-r3b"))
|
|
(name nil))
|
|
(unwind-protect
|
|
(progn
|
|
(with-current-buffer buf
|
|
(insert "Hello")
|
|
(tp-set 1 6 '(face (:foreground $tp-rt-r3b-color)))
|
|
(setq name (get-text-property 1 'tp-name)))
|
|
(should name)
|
|
(should-not (memq name (tp-gc-anonymous-layers)))
|
|
(should (assoc name tp-layer-alist)))
|
|
(kill-buffer buf)
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(setq tp-rt-r3b-color nil))))
|
|
|
|
(ert-deftest tp-render-test-gc-keeps-unknown-registry-layer ()
|
|
"GC keeps an anonymous layer whose registry state is `unknown'."
|
|
(setq tp-rt-r3c-color "red")
|
|
(let* ((s (tp-set "Hello" '(face (:foreground $tp-rt-r3c-color))))
|
|
(name (get-text-property 0 'tp-name s)))
|
|
(unwind-protect
|
|
(progn
|
|
(should name)
|
|
;; Applied to a string only: the registry knows nothing
|
|
(should (eq (tp-reactive-layer-buffers name) 'unknown))
|
|
(should-not (memq name (tp-gc-anonymous-layers)))
|
|
(should (assoc name tp-layer-alist)))
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(setq tp-rt-r3c-color nil))))
|
|
|
|
;;; GC-1: buried and hidden layers are ALIVE for GC and track-buffer
|
|
|
|
(defvar tp-rt-gc1-color nil)
|
|
(defvar tp-rt-gc1b-color nil)
|
|
(defvar tp-rt-gc1c-color nil)
|
|
|
|
(ert-deftest tp-render-test-gc-keeps-layer-buried-under-push ()
|
|
"GC keeps an anonymous layer buried below a pushed top layer.
|
|
The buried layer's tp-name lives inside `tp-layers' storage, not as a
|
|
direct property; the stack-aware liveness scan must still see it, and
|
|
reactivity must survive a later pop (GC-1)."
|
|
(setq tp-rt-gc1-color "blue")
|
|
(let ((buf (generate-new-buffer " tp-rt-gc1"))
|
|
(name nil))
|
|
(unwind-protect
|
|
(progn
|
|
(define-tp tp-rt-gc1-top () '(face bold))
|
|
(with-current-buffer buf
|
|
(insert "0123456789")
|
|
(tp-set 1 6 '(face (:foreground $tp-rt-gc1-color)))
|
|
(setq name (get-text-property 1 'tp-name))
|
|
(should name)
|
|
(tp-push-layer 1 6 'tp-rt-gc1-top)
|
|
;; Now buried: direct tp-name is the pushed top's.
|
|
(should (eq (get-text-property 1 'tp-name) 'tp-rt-gc1-top))
|
|
;; The buffer is live and still holds the layer: GC must
|
|
;; keep it.
|
|
(should-not (memq name (tp-gc-anonymous-layers)))
|
|
(should (assoc name tp-layer-alist))
|
|
;; Reactivity survives: pop and update.
|
|
(tp-pop-layer 1 6)
|
|
(setq tp-rt-gc1-color "red")
|
|
(should (equal (get-text-property 1 'face)
|
|
'(:foreground "red")))))
|
|
(kill-buffer buf)
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(tp-undefine-layer 'tp-rt-gc1-top)
|
|
(setq tp-rt-gc1-color nil))))
|
|
|
|
(ert-deftest tp-render-test-gc-keeps-hidden-layer ()
|
|
"GC keeps an anonymous layer hidden via tp-hide-layer.
|
|
An all-hidden run carries no direct tp-name at all; the layer lives
|
|
only inside `tp-layers' storage yet is queryable and re-showable, so
|
|
GC must not collect it and show+setq must still re-render (GC-1,
|
|
XM-02)."
|
|
(setq tp-rt-gc1b-color "green")
|
|
(let ((buf (generate-new-buffer " tp-rt-gc1b"))
|
|
(name nil))
|
|
(unwind-protect
|
|
(with-current-buffer buf
|
|
(insert "abcdefghij")
|
|
(tp-set 1 6 '(face (:foreground $tp-rt-gc1b-color)))
|
|
(setq name (get-text-property 1 'tp-name))
|
|
(should name)
|
|
(tp-hide-layer 1 6 name)
|
|
(should-not (get-text-property 1 'tp-name))
|
|
;; Live buffer still holds the hidden layer: keep it.
|
|
(should-not (memq name (tp-gc-anonymous-layers)))
|
|
(should (assoc name tp-layer-alist))
|
|
;; Show and update: reactivity must be intact.
|
|
(tp-show-layer 1 6 name)
|
|
(setq tp-rt-gc1b-color "purple")
|
|
(should (equal (get-text-property 1 'face)
|
|
'(:foreground "purple"))))
|
|
(kill-buffer buf)
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(setq tp-rt-gc1b-color nil))))
|
|
|
|
(ert-deftest tp-render-test-track-buffer-finds-buried-and-hidden-layers ()
|
|
"tp-reactive-track-buffer registers layers buried or hidden in storage.
|
|
A propertized string carrying a stacked (buried) layer and an
|
|
all-hidden string are inserted into a fresh buffer; the track scan
|
|
must register every layer name, not just the rendered top ones
|
|
\(GC-1, XM-04)."
|
|
(setq tp-rt-gc1c-color "gold")
|
|
(let ((buf (generate-new-buffer " tp-rt-gc1c"))
|
|
(name nil))
|
|
(unwind-protect
|
|
(progn
|
|
(define-tp tp-rt-gc1c-top () '(face bold))
|
|
(define-tp tp-rt-gc1c-hidden () '(face italic))
|
|
(let ((s (with-temp-buffer
|
|
(insert "trackme")
|
|
(tp-set 1 6 '(face (:foreground $tp-rt-gc1c-color)))
|
|
(setq name (get-text-property 1 'tp-name))
|
|
(tp-push-layer 1 6 'tp-rt-gc1c-top)
|
|
(buffer-string)))
|
|
(h (let ((h (copy-sequence " hideme")))
|
|
(tp-push-layer h 'tp-rt-gc1c-hidden)
|
|
(tp-hide-layer h 'tp-rt-gc1c-hidden)
|
|
h)))
|
|
(with-current-buffer buf
|
|
(insert s)
|
|
(insert h)
|
|
(let ((found (tp-reactive-track-buffer)))
|
|
;; Rendered top, buried layer, and all-hidden layer.
|
|
(should (memq 'tp-rt-gc1c-top found))
|
|
(should (memq name found))
|
|
(should (memq 'tp-rt-gc1c-hidden found)))
|
|
(should (memq buf (tp-reactive-layer-buffers name)))
|
|
(should (memq buf (tp-reactive-layer-buffers
|
|
'tp-rt-gc1c-hidden))))))
|
|
(kill-buffer buf)
|
|
(when (and name (assoc name tp-layer-alist))
|
|
(tp-undefine-layer name))
|
|
(tp-undefine-layer 'tp-rt-gc1c-top)
|
|
(tp-undefine-layer 'tp-rt-gc1c-hidden)
|
|
(setq tp-rt-gc1c-color nil))))
|
|
|
|
(provide 'tp-render-tests)
|
|
;;; tp-render-tests.el ends here
|