8a8e862098
Split the verified renderer, layout engine, Grid support, native boundary, tests, examples, and paired documentation into the independent Ebox repository. Keep ETAF and application concerns outside this package.
17080 lines
796 KiB
EmacsLisp
17080 lines
796 KiB
EmacsLisp
;;; ebox-core-render-tests.el --- Core render and update regression tests -*- lexical-binding: t; -*-
|
|
|
|
(require 'ert)
|
|
(require 'cl-lib)
|
|
|
|
(unless load-file-name
|
|
(error "This test file must be loaded from disk, not eval'ed directly"))
|
|
|
|
(setq load-prefer-newer t)
|
|
|
|
(load-file (expand-file-name "../ebox.el" (file-name-directory load-file-name)))
|
|
|
|
(defvar ebox--scroll-window-initial-lookahead-lines-override nil)
|
|
|
|
(defun ebox-test--reset-runtime-state ()
|
|
"Reset global runtime state used by ebox rendering tests."
|
|
(setq ebox--region-id-counter 0)
|
|
(setq ebox--runtime-node-id-counter 0)
|
|
(setq ebox--render-region-id nil)
|
|
(setq ebox--scroll-allow-noninteractive-prefetch t)
|
|
(ebox-cache-reset-default-registry)
|
|
(dolist (table (list ebox--region-box-table
|
|
ebox--box-extents
|
|
ebox--buffer-render-state-table
|
|
ebox--scroll-global-state
|
|
ebox--render-root-cache-table-table
|
|
ebox--render-cache-entry-side-effects-table
|
|
ebox--rendered-root-metadata-table
|
|
ebox--rendered-uniform-width-table
|
|
ebox--flex-sized-render-observation-table))
|
|
(clrhash table))
|
|
(maphash (lambda (_region-id timer)
|
|
(when (timerp timer)
|
|
(cancel-timer timer)))
|
|
ebox--scroll-idle-prefetch-timers)
|
|
(clrhash ebox--scroll-idle-prefetch-timers)
|
|
(maphash (lambda (_buffer timer)
|
|
(when (timerp timer)
|
|
(cancel-timer timer)))
|
|
ebox--runtime-prewarm-timers)
|
|
(clrhash ebox--runtime-prewarm-timers)
|
|
(clrhash ebox--runtime-prewarm-jobs)
|
|
(maphash (lambda (_buffer timer)
|
|
(when (timerp timer)
|
|
(cancel-timer timer)))
|
|
ebox--reflow-cache-prewarm-timers)
|
|
(clrhash ebox--reflow-cache-prewarm-timers)
|
|
(when (timerp ebox--deferred-render-gc-timer)
|
|
(cancel-timer ebox--deferred-render-gc-timer))
|
|
(setq ebox--deferred-render-gc-timer nil)
|
|
(setq ebox--deferred-render-gc-state nil))
|
|
|
|
(defmacro ebox-test--with-rendered-buffer (layout &rest body)
|
|
"Render LAYOUT into a temporary ebox buffer and run BODY there."
|
|
(declare (indent 1))
|
|
`(let* ((buffer-name (generate-new-buffer-name " *ebox-test*"))
|
|
(buffer (ebox-render-to-buffer buffer-name ,layout)))
|
|
(unwind-protect
|
|
(with-current-buffer buffer
|
|
,@body)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(defun ebox-test--set-buffer-update-report (buffer report)
|
|
"Store REPORT in BUFFER's render state."
|
|
(plist-put (ebox--buffer-render-state buffer) :last-update-report report))
|
|
|
|
(defun ebox-test--buffer-update-report (&optional buffer)
|
|
"Return BUFFER's update report, defaulting to the active rendered buffer."
|
|
(let ((target
|
|
(or buffer
|
|
(and (ebox--buffer-render-state (current-buffer))
|
|
(current-buffer))
|
|
(let (candidate ambiguous)
|
|
(maphash
|
|
(lambda (render-buffer _state)
|
|
(when (buffer-live-p render-buffer)
|
|
(if candidate
|
|
(setq ambiguous t)
|
|
(setq candidate render-buffer))))
|
|
ebox--buffer-render-state-table)
|
|
(and (not ambiguous) candidate)))))
|
|
(ebox-buffer-update-report target)))
|
|
|
|
(ert-deftest ebox-scroll-window-lookahead-accepts-root-reflow-override ()
|
|
"Root reflow should be able to defer all hidden lookahead work."
|
|
(let ((ebox-scroll-lazy-prefix-lookahead-lines 8)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox--scroll-window-initial-lookahead-lines-override 0))
|
|
(should (= (ebox--scroll-window-initial-lookahead-lines) 0))))
|
|
|
|
(ert-deftest ebox-root-reflow-lookahead-keeps-flex-rows-demand-driven ()
|
|
"Root reflow should not cross an explicit flex item's atomic row eagerly."
|
|
(ebox-test--reset-runtime-state)
|
|
(let (plain-buffer flex-buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq plain-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-plain-lookahead*")
|
|
(ebox-create :content "plain" :width 120)))
|
|
(setq flex-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-flex-lookahead*")
|
|
(ebox-flex
|
|
:width '(120)
|
|
(ebox-flex-item
|
|
(ebox-create :content "item" :width '(40))))))
|
|
(should
|
|
(= (ebox--root-reflow-scroll-lookahead-lines-for-buffer
|
|
plain-buffer)
|
|
ebox--root-reflow-scroll-lookahead-lines))
|
|
(should
|
|
(= (ebox--root-reflow-scroll-lookahead-lines-for-buffer
|
|
flex-buffer)
|
|
0)))
|
|
(dolist (buffer (list plain-buffer flex-buffer))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))))))
|
|
|
|
(ert-deftest ebox-root-reflow-lookahead-keeps-large-runtimes-demand-driven ()
|
|
"Root reflow should not eagerly cross costly rows in a large runtime."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer (generate-new-buffer " *ebox-large-lookahead*"))
|
|
(node-table (make-hash-table :test 'equal))
|
|
(selector-type-table (make-hash-table :test 'eq)))
|
|
(unwind-protect
|
|
(progn
|
|
(dotimes (index 512)
|
|
(puthash index t node-table))
|
|
(puthash buffer
|
|
(list :node-table node-table
|
|
:selector-type-table selector-type-table)
|
|
ebox--buffer-render-state-table)
|
|
(should
|
|
(= (ebox--root-reflow-scroll-lookahead-lines-for-buffer buffer)
|
|
0)))
|
|
(remhash buffer ebox--buffer-render-state-table)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-exact-scroll-prefix-skips-completion-sentinel ()
|
|
"Interactive prefix extension should request only the visible line bound."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((region-id 'exact-prefix)
|
|
(all-lines '("zero" "one" "two" "three" "four"))
|
|
requested-limits
|
|
(render-prefix
|
|
(lambda (_state _region-id limit)
|
|
(push limit requested-limits)
|
|
(list :content-lines (seq-take all-lines limit)
|
|
:rendered-content-lines (seq-take all-lines limit)
|
|
:content-height 2
|
|
:complete nil)))
|
|
(state (list :content-lines (seq-take all-lines 3)
|
|
:rendered-content-lines (seq-take all-lines 3)
|
|
:content-height 2
|
|
:render-content-prefix render-prefix)))
|
|
(let ((ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox--scroll-state-ensure-prefix-lines region-id state 4 t))
|
|
(should (equal requested-limits '(4)))
|
|
(setq requested-limits nil
|
|
state (list :content-lines (seq-take all-lines 3)
|
|
:rendered-content-lines (seq-take all-lines 3)
|
|
:content-height 2
|
|
:render-content-prefix render-prefix))
|
|
(let ((ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox--scroll-state-ensure-prefix-lines region-id state 4))
|
|
(should (equal requested-limits '(5)))))
|
|
|
|
(ert-deftest ebox-scroll-lightweight-line-bounds-extend-incrementally ()
|
|
"Lazy line bounds should extend without rebuilding prior prefix entries."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((line-a (propertize "a" 'ebox-content 11))
|
|
(line-b (propertize "b" 'ebox-content 12))
|
|
(line-c (propertize "c" 'ebox-content 11))
|
|
(ebox--defer-scroll-content-index t)
|
|
(state (ebox--scroll-state-set-lines nil (list line-a line-b)))
|
|
(index (plist-get state :region-line-bounds-index)))
|
|
(should (equal (gethash 11 index) '(0 . 0)))
|
|
(should (equal (gethash 12 index) '(1 . 1)))
|
|
(setq state
|
|
(ebox--scroll-state-set-lines
|
|
state (list line-a line-b line-c)))
|
|
(should (eq index (plist-get state :region-line-bounds-index)))
|
|
(should (equal (gethash 11 index) '(0 . 2)))
|
|
(should (equal (gethash 12 index) '(1 . 1)))
|
|
(should (plist-get state :region-line-span-index-deferred))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-publishes-private-line-with-suffix-paint ()
|
|
"A cached hidden source line should not rebuild the rendered prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 20 :height 2))
|
|
(content-lines '("zero" "one" "two" "three"))
|
|
(state (list :content-lines (seq-take content-lines 3)
|
|
:rendered-content-lines
|
|
(seq-take content-lines 3)
|
|
:content-height 2))
|
|
(source-renders 0)
|
|
rendered-requests
|
|
(original-rendered-lines
|
|
(symbol-function 'ebox--scroll-rendered-content-lines))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer
|
|
box '(:stack ignored) 20 2 nil content-lines)))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (&rest _)
|
|
(cl-incf source-renders)
|
|
(error "Private cached line should satisfy the prefix")))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (&rest args)
|
|
(push (list (length (cadr args)) (nth 3 args))
|
|
rendered-requests)
|
|
(apply original-rendered-lines args))))
|
|
(let ((result (funcall renderer state 'private-prefix 4)))
|
|
(should (= source-renders 0))
|
|
(should (equal rendered-requests '((1 3))))
|
|
(should (= (length (plist-get result :content-lines)) 4))
|
|
(should (= (length (plist-get result :rendered-content-lines)) 4))))))
|
|
|
|
(defun ebox-test--face-has-key-value-p (face key value)
|
|
"Return non-nil when FACE contains KEY with VALUE."
|
|
(cond
|
|
((null face) nil)
|
|
((and (listp face) (keywordp (car face)))
|
|
(equal (plist-get face key) value))
|
|
((listp face)
|
|
(cl-some (lambda (item)
|
|
(ebox-test--face-has-key-value-p item key value))
|
|
face))
|
|
(t nil)))
|
|
|
|
(defun ebox-test--face-has-key-p (face key)
|
|
"Return non-nil when FACE contains KEY."
|
|
(cond
|
|
((null face) nil)
|
|
((and (listp face) (keywordp (car face)))
|
|
(plist-member face key))
|
|
((listp face)
|
|
(cl-some (lambda (item)
|
|
(ebox-test--face-has-key-p item key))
|
|
face))
|
|
(t nil)))
|
|
|
|
(defun ebox-test--border-face-has-color-p (face role color)
|
|
"Return non-nil when FACE paints border ROLE with COLOR."
|
|
(pcase role
|
|
('bt
|
|
(ebox-test--face-has-key-value-p face :overline color))
|
|
('bb
|
|
(ebox-test--face-has-key-value-p
|
|
face :underline (list :position t :color color)))
|
|
((or 'bl 'br)
|
|
(ebox-test--face-has-key-value-p face :background color))))
|
|
|
|
(defun ebox-test--face-at-property (string property)
|
|
"Return first face in STRING at PROPERTY."
|
|
(let ((pos 0)
|
|
(len (length string))
|
|
face)
|
|
(while (and (< pos len) (not face))
|
|
(when (get-text-property pos property string)
|
|
(setq face (get-text-property pos 'face string)))
|
|
(setq pos (or (next-single-property-change pos property string)
|
|
(1+ pos))))
|
|
face))
|
|
|
|
(defun ebox-test--first-content-face (string)
|
|
"Return first content face in STRING."
|
|
(ebox-test--face-at-property string 'ebox-content))
|
|
|
|
(defmacro ebox-test--count-full-rerenders (&rest body)
|
|
"Run BODY and return the number of full buffer rerenders it triggered."
|
|
(declare (indent 0))
|
|
`(let ((full-rerenders 0)
|
|
(original-full-rerender (symbol-function 'ebox--full-rerender-buffer)))
|
|
(cl-letf (((symbol-function 'ebox--full-rerender-buffer)
|
|
(lambda (&rest args)
|
|
(cl-incf full-rerenders)
|
|
(apply original-full-rerender args))))
|
|
,@body)
|
|
full-rerenders))
|
|
|
|
(defconst ebox-test--region-update-paint-cases
|
|
'((:color "#123456" "#123456")
|
|
(:bgcolor "#FDE68A" "#FDE68A")
|
|
(:border-left-color "#111111" "#111111")
|
|
(:border-right-color "#222222" "#222222")
|
|
(:border-top-color "#333333" "#333333")
|
|
(:border-bottom-color "#444444" "#444444")
|
|
(:border-top-p t t)
|
|
(:border-bottom-p t t))
|
|
"Paint-only box longhand update cases: (PROPERTY VALUE EXPECTED).")
|
|
|
|
(defconst ebox-test--region-update-geometry-cases
|
|
'((:box-sizing content-box content-box owner-rerender)
|
|
(:width (120) 120 owner-rerender)
|
|
(:min-width (100) 100 owner-rerender)
|
|
(:max-width (140) 140 owner-rerender)
|
|
(:height 3 3 owner-rerender)
|
|
(:min-height 3 3 owner-rerender)
|
|
(:max-height 1 1 owner-rerender)
|
|
(:padding-left-pixel 9 9 span-patch)
|
|
(:padding-right-pixel 10 10 span-patch)
|
|
(:padding-top-height 1 1 span-patch)
|
|
(:padding-bottom-height 1 1 span-patch)
|
|
(:margin-left-pixel 7 7 owner-rerender)
|
|
(:margin-right-pixel 8 8 owner-rerender)
|
|
(:margin-top-height 1 1 owner-rerender)
|
|
(:margin-bottom-height 1 1 owner-rerender)
|
|
(:border-left-pixel 5 5 span-patch)
|
|
(:border-right-pixel 6 6 span-patch)
|
|
(:text-align center center span-patch)
|
|
(:vertical-align middle center span-patch)
|
|
(:overflow hidden hidden owner-rerender)
|
|
(:wrap-mode char char span-patch)
|
|
(:scroll-offset 1 1 span-patch)
|
|
(:visibility hidden hidden span-patch))
|
|
"Geometry box longhand update cases: (PROPERTY VALUE EXPECTED STRATEGY).")
|
|
|
|
(defun ebox-test--region-update-case-properties (cases)
|
|
"Return the update property names covered by CASES."
|
|
(mapcar #'car cases))
|
|
|
|
(ert-deftest ebox-root-background-covers-transparent-layout-wrappers ()
|
|
"A root canvas background should remain under transparent child wrappers."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 6)
|
|
(layout
|
|
(ebox-build
|
|
'(box :width (viewport) :height (viewport-height)
|
|
:bgcolor "#151A23"
|
|
(column
|
|
(box :width (viewport) :height 1 :bgcolor "#202938"
|
|
"surface")
|
|
(box :width (viewport) :height 1 "transparent")
|
|
(box :width (viewport) :height 1 :bgcolor "#29364A"
|
|
"surface-two")))))
|
|
(lines (ebox-string-lines (ebox-render layout))))
|
|
(should (= (length lines) 6))
|
|
(dolist (line lines)
|
|
(should (ebox-test--face-has-key-value-p
|
|
(get-text-property 0 'face line)
|
|
:background "#151A23")))
|
|
(should (ebox-test--face-has-key-value-p
|
|
(get-text-property 0 'face (nth 0 lines))
|
|
:background "#202938"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
(get-text-property 0 'face (nth 2 lines))
|
|
:background "#29364A"))))
|
|
|
|
(ert-deftest ebox-region-ids-assigns-stable-ids-before-render ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "L" :width 40))
|
|
(right (ebox-create :content "R" :width 50))
|
|
(layout (ebox-concat left right))
|
|
(ids-before (ebox-region-ids layout)))
|
|
(should (equal ids-before '(1 2)))
|
|
(should (equal (ebox-region-ids layout) ids-before))
|
|
(should (equal (ebox-region-ids (ebox-render layout)) ids-before))))
|
|
|
|
(ert-deftest ebox-box-extent-template-excludes-interleaved-concat-boxes ()
|
|
"Prepared extents should omit boxes split by a neighboring concat column."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "A\nB" :width 60))
|
|
(right (ebox-create :content "R1\nR2\nR3" :width 80))
|
|
(rendered (ebox-render (ebox-concat left right)))
|
|
(template (ebox--build-box-extent-template rendered)))
|
|
(should-not (gethash (plist-get left :region-id) template))
|
|
(should-not (gethash (plist-get right :region-id) template))))
|
|
|
|
(ert-deftest ebox-live-mount-uses-runtime-copy-and-leaves-source-stable ()
|
|
"First live mount should copy SOURCE while preserving stable source ids."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((source (ebox-build
|
|
'(box :id "root" :content "before\nhidden" :width (120)
|
|
:color "#111111" :height 1 :overflow scroll)))
|
|
(buffer (generate-new-buffer " *ebox-live-copy-source*")))
|
|
(unwind-protect
|
|
(progn
|
|
(should-not (plist-member source :region-id))
|
|
(ebox-render-to-buffer buffer source)
|
|
(let* ((runtime-root (ebox--buffer-root-node buffer))
|
|
(source-ids (ebox-region-ids source))
|
|
(region-id (car source-ids))
|
|
(runtime-box
|
|
(gethash region-id
|
|
(ebox--buffer-region-box-table buffer))))
|
|
(should source-ids)
|
|
(should (equal (ebox-region-ids source) source-ids))
|
|
(should-not (eq runtime-root source))
|
|
(should (eq runtime-root runtime-box))
|
|
(should (eq (gethash region-id ebox--region-box-table)
|
|
runtime-box))
|
|
(let ((ebox--region-update-buffer-hint buffer))
|
|
(ebox-region-update region-id
|
|
:content "after\nhidden"
|
|
:color "#222222"
|
|
:width '(140)
|
|
:scroll-offset 1))
|
|
(should (equal (ebox-region-ids source) source-ids))
|
|
(should (equal (ebox-get source :content) "before\nhidden"))
|
|
(should (equal (ebox-get source :color) "#111111"))
|
|
(should (equal (ebox-get source :width) 120))
|
|
(should (equal (ebox-get source :scroll-offset) 0))
|
|
(should (equal (ebox-get runtime-box :content) "after\nhidden"))
|
|
(should (equal (ebox-get runtime-box :color) "#222222"))
|
|
(should (equal (ebox-get runtime-box :width) 140))
|
|
(should (equal (ebox-get runtime-box :scroll-offset) 1))
|
|
(should (= (plist-get (ebox--scroll-get-state region-id)
|
|
:scroll-offset)
|
|
1))
|
|
(with-current-buffer buffer
|
|
(should (string-match-p "hidden"
|
|
(buffer-string))))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-live-mount-rejects-second-owner-before-target-cleanup ()
|
|
"Second live mount of retained ids should fail without touching target state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((source (ebox-build
|
|
'(box :id "root" :content "owned\nhidden" :width (120)
|
|
:height 1 :overflow scroll)))
|
|
(_source-ids (ebox-region-ids source))
|
|
(retained-copy (copy-tree source))
|
|
(missing-target-name (generate-new-buffer-name " *ebox-live-missing*"))
|
|
owner-buffer target-buffer
|
|
owner-state owner-root owner-region-id owner-scroll-state
|
|
owner-region-box owner-extents owner-timer
|
|
target-state target-text)
|
|
(unwind-protect
|
|
(progn
|
|
(setq owner-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-live-owner*")
|
|
source))
|
|
(setq target-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-live-target*")
|
|
(ebox-create :content "target stays" :width 120)))
|
|
(setq owner-state (ebox--buffer-render-state owner-buffer)
|
|
owner-root (plist-get owner-state :root-node)
|
|
owner-region-id (car (ebox-region-ids source))
|
|
owner-scroll-state (ebox--scroll-get-state owner-region-id)
|
|
owner-region-box (gethash owner-region-id ebox--region-box-table)
|
|
owner-extents (gethash owner-region-id ebox--box-extents)
|
|
target-state (ebox--buffer-render-state target-buffer))
|
|
(setq owner-timer (run-with-timer 3600 nil #'ignore))
|
|
(puthash owner-region-id owner-timer
|
|
ebox--scroll-idle-prefetch-timers)
|
|
(with-current-buffer target-buffer
|
|
(setq target-text (buffer-string)))
|
|
(dolist (root (list source retained-copy))
|
|
(should-error
|
|
(ebox-render-to-buffer target-buffer root)
|
|
:type 'user-error)
|
|
(should (eq (ebox--buffer-render-state owner-buffer) owner-state))
|
|
(should (eq (plist-get owner-state :root-node) owner-root))
|
|
(should (eq (ebox--scroll-get-state owner-region-id)
|
|
owner-scroll-state))
|
|
(should (eq (gethash owner-region-id ebox--region-box-table)
|
|
owner-region-box))
|
|
(should (eq (gethash owner-region-id ebox--box-extents)
|
|
owner-extents))
|
|
(should (eq (gethash owner-region-id
|
|
ebox--scroll-idle-prefetch-timers)
|
|
owner-timer))
|
|
(should (eq (ebox--buffer-render-state target-buffer)
|
|
target-state))
|
|
(with-current-buffer target-buffer
|
|
(should (equal-including-properties (buffer-string)
|
|
target-text)))))
|
|
(should-error
|
|
(ebox-render-to-buffer missing-target-name retained-copy)
|
|
:type 'user-error)
|
|
(should-not (get-buffer missing-target-name))
|
|
(dolist (buffer (list owner-buffer target-buffer))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))
|
|
(when (timerp owner-timer)
|
|
(cancel-timer owner-timer))
|
|
(when-let ((buffer (get-buffer missing-target-name)))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-live-mount-releases-old-source-after-target-replacement ()
|
|
"Replacing a target root should release the old source ids for reuse."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((old-source (ebox-create :content "old" :width 120))
|
|
(new-source (ebox-create :content "new" :width 120))
|
|
primary-buffer secondary-buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq primary-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-live-primary*")
|
|
old-source))
|
|
(ebox-render-to-buffer primary-buffer new-source)
|
|
(setq secondary-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-live-secondary*")
|
|
old-source))
|
|
(kill-buffer secondary-buffer)
|
|
(setq secondary-buffer nil)
|
|
(setq secondary-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-live-secondary*")
|
|
old-source))
|
|
(should (eq (ebox--region-buffer (car (ebox-region-ids old-source)))
|
|
secondary-buffer)))
|
|
(dolist (buffer (list primary-buffer secondary-buffer))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))))))
|
|
|
|
(ert-deftest ebox-region-update-hint-uses-buffer-owned-runtime-box ()
|
|
"Hinted direct updates should use the buffer-owned box table over globals."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((source (ebox-build
|
|
'(box :id "target" :content "before" :width (120)
|
|
:color "#111111")))
|
|
(buffer (generate-new-buffer " *ebox-hinted-runtime-box*")))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox-render-to-buffer buffer source)
|
|
(let* ((region-id (ebox-test--selector-region-id buffer "#target"))
|
|
(runtime-box (gethash region-id ebox--region-box-table))
|
|
(poison (ebox-create :content "poison" :width 120
|
|
:color "#ff0000")))
|
|
(puthash region-id poison ebox--region-box-table)
|
|
(let ((ebox--region-update-buffer-hint buffer))
|
|
(ebox-region-update region-id :content "after"))
|
|
(should (equal (ebox-get runtime-box :content) "after"))
|
|
(should (equal (ebox-get poison :content) "poison"))
|
|
(should (eq (gethash region-id ebox--region-box-table)
|
|
runtime-box))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-node-ids-cover-layout-and-box-nodes ()
|
|
"Every runtime node should have a stable internal node id."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-stack
|
|
(ebox-create :content "Top" :width 60)
|
|
(ebox-concat
|
|
(ebox-create :content "Left" :width 40)
|
|
(ebox-create :content "Right" :width 40))))
|
|
(ids-before (ebox--runtime-node-ids layout)))
|
|
(should (= (length ids-before) 5))
|
|
(should (= (length (delete-dups (copy-sequence ids-before))) 5))
|
|
(ebox-render layout)
|
|
(should (equal (ebox--runtime-node-ids layout) ids-before))))
|
|
|
|
(ert-deftest ebox-wrapper-child-nodes-are-in-runtime-index ()
|
|
"A wrapper box's child layout should remain visible in runtime state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(box :content "One")
|
|
(box :content "Two"))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node))
|
|
(let ((ids (ebox--runtime-node-ids node)))
|
|
(should (> (length ids) 1))
|
|
(dolist (node-id ids)
|
|
(should (ebox--buffer-runtime-node buffer node-id)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-region-render-owner-index-maps-boxes-and-flex-wrapper ()
|
|
"Region lookup should map each box to its smallest renderable owner."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((plain (ebox-create :content "Plain" :width '(80)))
|
|
(flex-child (ebox-create :content "Flex child" :width '(80)))
|
|
(flex (ebox-flex :width '(120) :padding 1 flex-child))
|
|
(flex-wrapper (plist-get flex :box))
|
|
(layout (ebox-column plain flex)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(table (ebox--buffer-region-node-table buffer))
|
|
(plain-region-id (ebox--ensure-region-id plain))
|
|
(wrapper-region-id (ebox--ensure-region-id flex-wrapper))
|
|
(child-region-id (ebox--ensure-region-id flex-child))
|
|
(plain-node-id (ebox--ensure-node-id plain))
|
|
(flex-node-id (ebox--ensure-node-id flex))
|
|
(wrapper-node-id (ebox--ensure-node-id flex-wrapper))
|
|
(child-node-id (ebox--ensure-node-id flex-child))
|
|
(runtime-plain (ebox--buffer-runtime-node buffer plain-node-id))
|
|
(runtime-flex (ebox--buffer-runtime-node buffer flex-node-id))
|
|
(runtime-child (ebox--buffer-runtime-node buffer child-node-id)))
|
|
(should (hash-table-p table))
|
|
(should (equal (gethash plain-region-id table) plain-node-id))
|
|
(should (equal (gethash wrapper-region-id table) flex-node-id))
|
|
(should-not (equal (gethash wrapper-region-id table)
|
|
wrapper-node-id))
|
|
(should (equal (gethash child-region-id table) child-node-id))
|
|
(should (eq (ebox--buffer-region-render-owner-node
|
|
buffer plain-region-id)
|
|
runtime-plain))
|
|
(should (eq (ebox--buffer-region-render-owner-node
|
|
buffer wrapper-region-id)
|
|
runtime-flex))
|
|
(should (eq (ebox--buffer-region-render-owner-node
|
|
buffer child-region-id)
|
|
runtime-child))))))
|
|
|
|
(ert-deftest ebox-region-render-owner-index-keeps-earlier-duplicate-box ()
|
|
"A later flex wrapper should not replace an earlier duplicate region owner."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((region-id 9001)
|
|
(plain (ebox-create :content "First" :width '(80)))
|
|
(flex (ebox-flex :width '(120)
|
|
(ebox-create :content "Later" :width '(80))))
|
|
(wrapper (plist-get flex :box))
|
|
(layout (ebox-column plain flex)))
|
|
(ebox-put plain :region-id region-id)
|
|
(ebox-put wrapper :region-id region-id)
|
|
(let* ((index (ebox--runtime-index layout))
|
|
(table (plist-get index :region-node-table))
|
|
(expected (car (ebox--node-path-to-region layout region-id))))
|
|
(should (eq expected plain))
|
|
(should (equal (gethash region-id table)
|
|
(ebox--ensure-node-id expected))))))
|
|
|
|
(ert-deftest ebox-region-render-owner-index-keeps-outer-flex-duplicate ()
|
|
"Nested duplicate flex wrappers should retain recursive first-match lookup."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((region-id 9002)
|
|
(inner (ebox-flex :width '(100) :padding 1
|
|
(ebox-create :content "Inner" :width '(80))))
|
|
(outer (ebox-flex :width '(140) :padding 1 inner))
|
|
(inner-wrapper (plist-get inner :box))
|
|
(outer-wrapper (plist-get outer :box)))
|
|
(ebox-put inner-wrapper :region-id region-id)
|
|
(ebox-put outer-wrapper :region-id region-id)
|
|
(let* ((index (ebox--runtime-index outer))
|
|
(table (plist-get index :region-node-table))
|
|
(expected (car (ebox--node-path-to-region outer region-id))))
|
|
(should (eq expected outer))
|
|
(should (equal (gethash region-id table)
|
|
(ebox--ensure-node-id expected))))))
|
|
|
|
(ert-deftest ebox-runtime-index-region-box-table-matches-complete-render ()
|
|
"Runtime indexing should collect the box table with render overwrite order."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((shared-region-id 9003)
|
|
(inner (ebox-create :content "Inner" :width '(60)))
|
|
(outer (ebox-create :content "" :width '(90)))
|
|
(flex-child (ebox-create :content "Flex child" :width '(50)))
|
|
(flex (ebox-flex :width '(120) :padding 1 flex-child))
|
|
(layout (ebox-column outer flex))
|
|
(render-table (make-hash-table :test 'equal)))
|
|
(plist-put outer :ebox-content-node inner)
|
|
;; Complete rendering records parents after their child content. A
|
|
;; duplicated legacy id therefore resolves to OUTER in the box table.
|
|
(ebox-put inner :region-id shared-region-id)
|
|
(ebox-put outer :region-id shared-region-id)
|
|
(let* ((index (ebox--runtime-index layout t))
|
|
(index-table (plist-get index :region-box-table))
|
|
(ebox--region-box-table render-table)
|
|
(ebox--scroll-global-state (make-hash-table :test 'equal)))
|
|
(ebox-render layout)
|
|
(should (= (hash-table-count index-table)
|
|
(hash-table-count render-table)))
|
|
(maphash
|
|
(lambda (region-id box)
|
|
(should (eq (gethash region-id index-table) box)))
|
|
render-table)
|
|
(should (eq (gethash shared-region-id index-table) outer))
|
|
(should
|
|
(eq (gethash (ebox--ensure-region-id (plist-get flex :box))
|
|
index-table)
|
|
(plist-get flex :box))))))
|
|
|
|
(ert-deftest ebox-declarative-candidate-reuses-indexed-region-box-table ()
|
|
"Candidate preparation should not rewalk the tree to collect source boxes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((root (ebox-column
|
|
(ebox-create :key 'first :content "First" :width '(80))
|
|
(ebox-create :key 'second :content "Second" :width '(80))))
|
|
(next-root
|
|
(ebox-column
|
|
(ebox-create :key 'first :content "Changed" :width '(80))
|
|
(ebox-create :key 'second :content "Second" :width '(80)))))
|
|
(ebox-test--with-rendered-buffer root
|
|
(let* ((buffer (current-buffer))
|
|
(old-state (ebox--buffer-render-state buffer))
|
|
(recache-calls 0)
|
|
prepared
|
|
candidate-state)
|
|
(cl-letf (((symbol-function 'ebox--flex-recache-source-boxes)
|
|
(lambda (&rest _)
|
|
(cl-incf recache-calls))))
|
|
(setq prepared
|
|
(ebox-incremental--prepare-declarative-root
|
|
buffer old-state next-root))
|
|
(setq candidate-state
|
|
(ebox-incremental--candidate-state
|
|
old-state
|
|
(plist-get prepared :root)
|
|
(plist-get prepared :index)
|
|
prepared)))
|
|
(should (= recache-calls 0))
|
|
(should
|
|
(eq (plist-get candidate-state :region-box-table)
|
|
(plist-get (plist-get prepared :index) :region-box-table)))
|
|
(should (= (hash-table-count
|
|
(plist-get candidate-state :region-box-table))
|
|
2))))))
|
|
|
|
(ert-deftest ebox-region-render-owner-index-falls-back-for-legacy-state ()
|
|
"A runtime state without the new table should retain recursive lookup."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-create :content "Flex child" :width '(80)))
|
|
(flex (ebox-flex :width '(120) :padding 1 child))
|
|
(wrapper (plist-get flex :box)))
|
|
(ebox-test--with-rendered-buffer flex
|
|
(let* ((buffer (current-buffer))
|
|
(state (ebox--buffer-render-state buffer))
|
|
(table (ebox--buffer-region-node-table buffer))
|
|
(region-id (ebox--ensure-region-id wrapper))
|
|
(expected-node-id
|
|
(ebox--buffer-region-render-owner-node-id buffer region-id))
|
|
(expected-node
|
|
(ebox--buffer-region-render-owner-node buffer region-id))
|
|
(original-path
|
|
(symbol-function 'ebox--node-path-to-region))
|
|
(recursive-calls 0))
|
|
(unwind-protect
|
|
(progn
|
|
(plist-put state :region-node-table nil)
|
|
(cl-letf (((symbol-function 'ebox--node-path-to-region)
|
|
(lambda (&rest args)
|
|
(cl-incf recursive-calls)
|
|
(apply original-path args))))
|
|
(should (equal
|
|
(ebox--buffer-region-render-owner-node-id
|
|
buffer region-id)
|
|
expected-node-id))
|
|
(should (eq (ebox--buffer-region-render-owner-node
|
|
buffer region-id)
|
|
expected-node)))
|
|
(should (> recursive-calls 0)))
|
|
(plist-put state :region-node-table table))))))
|
|
|
|
(ert-deftest ebox-runtime-node-id-survives-viewport-rerender ()
|
|
"Viewport-only rerender should not assign new runtime node ids."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-flex
|
|
:flex-wrap 'wrap
|
|
(ebox-create :content "A" :width '(100))
|
|
(ebox-create :content "B" :width '(100))))
|
|
(ids-before nil)
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(setq ids-before (ebox--runtime-node-ids layout))
|
|
(let ((ebox-viewport-width 160))
|
|
(ebox--rerender-buffer-preserving-runtime buffer))
|
|
(should (equal (ebox--runtime-node-ids layout) ids-before)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-reconcile-preserves-keyed-child-id ()
|
|
"Keyed children should keep runtime ids across structural rebuilds."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((old (ebox--runtime-tree
|
|
(ebox-column
|
|
(ebox-create :key 'a :content "A" :width 40)
|
|
(ebox-create :key 'b :content "B" :width 40))))
|
|
(old-b-id (ebox--runtime-node-id-by-key old 'b))
|
|
(new (ebox--reconcile-runtime-tree
|
|
old
|
|
(ebox-column
|
|
(ebox-create :key 'x :content "X" :width 40)
|
|
(ebox-create :key 'b :content "B2" :width 40)))))
|
|
(should (equal (ebox--runtime-node-id-by-key new 'b) old-b-id))))
|
|
|
|
(ert-deftest ebox-tree-helpers-see-wrapper-child-nodes ()
|
|
"Tree helpers should see wrapper children without rendering static content."
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(box :content "Child" :width (120)))))
|
|
(children (ebox-tree-children node)))
|
|
(should children)
|
|
(should (plist-get (car children) :node-id))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-replaces-box-content-node ()
|
|
"A box content-node replacement should leave other values shared."
|
|
(let* ((old-content (list :ebox-type 'box :content "old"))
|
|
(equal-content (copy-tree old-content))
|
|
(new-content (list :ebox-type 'box :content "new"))
|
|
(wrong-content (list :ebox-type 'box :content "wrong"))
|
|
(metadata (list :owner 'host))
|
|
(node (list :ebox-type 'box
|
|
:ebox-content-node old-content
|
|
:metadata metadata))
|
|
(copy
|
|
(ebox-tree-copy-with-direct-child-replacements
|
|
node (list (cons equal-content wrong-content)
|
|
(cons old-content new-content)))))
|
|
(should-not (eq copy node))
|
|
(should (eq (plist-get copy :ebox-content-node) new-content))
|
|
(should (eq (plist-get copy :metadata) metadata))
|
|
(should (eq (plist-get node :ebox-content-node) old-content))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-replaces-concat-children-and-aliases ()
|
|
"A concat copy should update flat children and both legacy aliases."
|
|
(let* ((left (list :ebox-type 'box :content "left"))
|
|
(right (list :ebox-type 'box :content "right"))
|
|
(new-left (list :ebox-type 'box :content "new-left"))
|
|
(children (list left right))
|
|
(node (list :ebox-type 'concat
|
|
:children children
|
|
:left left
|
|
:right right))
|
|
(copy
|
|
(ebox-tree-copy-with-direct-child-replacements
|
|
node (list (cons left new-left))))
|
|
(copy-children (plist-get copy :children)))
|
|
(should-not (eq copy node))
|
|
(should-not (eq copy-children children))
|
|
(should (eq (car copy-children) new-left))
|
|
(should (eq (cadr copy-children) right))
|
|
(should (eq (plist-get copy :left) new-left))
|
|
(should (eq (plist-get copy :right) right))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-replaces-stack-children-and-aliases ()
|
|
"A stack copy should update flat children and both legacy aliases."
|
|
(let* ((top (list :ebox-type 'box :content "top"))
|
|
(bottom (list :ebox-type 'box :content "bottom"))
|
|
(new-bottom (list :ebox-type 'box :content "new-bottom"))
|
|
(children (list top bottom))
|
|
(node (list :ebox-type 'stack
|
|
:children children
|
|
:top top
|
|
:bottom bottom))
|
|
(copy
|
|
(ebox-tree-copy-with-direct-child-replacements
|
|
node (list (cons bottom new-bottom))))
|
|
(copy-children (plist-get copy :children)))
|
|
(should-not (eq copy node))
|
|
(should-not (eq copy-children children))
|
|
(should (eq (car copy-children) top))
|
|
(should (eq (cadr copy-children) new-bottom))
|
|
(should (eq (plist-get copy :top) top))
|
|
(should (eq (plist-get copy :bottom) new-bottom))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-replaces-flex-box-and-children-once ()
|
|
"One flex copy should apply multiple replacements and share one sibling."
|
|
(let* ((box (list :ebox-type 'box :content "wrapper"))
|
|
(first (list :ebox-type 'box :content "first"))
|
|
(untouched (list :ebox-type 'box :content "untouched"))
|
|
(last (list :ebox-type 'box :content "last"))
|
|
(new-box (list :ebox-type 'box :content "new-wrapper"))
|
|
(new-first (list :ebox-type 'box :content "new-first"))
|
|
(new-last (list :ebox-type 'box :content "new-last"))
|
|
(children (list first untouched last))
|
|
(node (list :ebox-type 'flex :box box :children children))
|
|
(copy
|
|
(ebox-tree-copy-with-direct-child-replacements
|
|
node (list (cons box new-box)
|
|
(cons first new-first)
|
|
(cons last new-last))))
|
|
(copy-children (plist-get copy :children)))
|
|
(should-not (eq copy node))
|
|
(should (eq (plist-get copy :box) new-box))
|
|
(should (eq (nth 0 copy-children) new-first))
|
|
(should (eq (nth 1 copy-children) untouched))
|
|
(should (eq (nth 2 copy-children) new-last))
|
|
(should (eq (plist-get node :box) box))
|
|
(should (eq (nth 0 children) first))
|
|
(should (eq (nth 1 children) untouched))
|
|
(should (eq (nth 2 children) last))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-replaces-flex-item-node ()
|
|
"A flex-item copy should replace its wrapped node by identity."
|
|
(let* ((old-child (list :ebox-type 'box :content "old"))
|
|
(new-child (list :ebox-type 'box :content "new"))
|
|
(props (list :flex-grow 1))
|
|
(node (list :ebox-type 'flex-item :node old-child :props props))
|
|
(copy
|
|
(ebox-tree-copy-with-direct-child-replacements
|
|
node (list (cons old-child new-child)))))
|
|
(should-not (eq copy node))
|
|
(should (eq (plist-get copy :node) new-child))
|
|
(should (eq (plist-get copy :props) props))))
|
|
|
|
(ert-deftest ebox-tree-shallow-copy-without-replacements-shares-values ()
|
|
"A zero-replacement copy should share every nested value."
|
|
(let* ((first (list :ebox-type 'box :content "first"))
|
|
(second (list :ebox-type 'box :content "second"))
|
|
(children (list first second))
|
|
(node (list :ebox-type 'concat :children children))
|
|
(copy (ebox-tree-copy-with-direct-child-replacements node nil)))
|
|
(should-not (eq copy node))
|
|
(should (eq (plist-get copy :children) children))
|
|
(should (eq (car (plist-get copy :children)) first))
|
|
(should (eq (cadr (plist-get copy :children)) second))))
|
|
|
|
(ert-deftest ebox-fragment-signature-excludes-backend-spans ()
|
|
"Fragment signatures should describe layout facts, not backend markers."
|
|
(let ((fragment (ebox-fragment-create
|
|
:node-id "n1"
|
|
:region-ids '("r1")
|
|
:size '(120 . 24)
|
|
:line-signature '(("Child"))
|
|
:buffer-span '(1 . 8))))
|
|
(should (equal (ebox-fragment-layout-signature fragment)
|
|
'(:node-id "n1" :region-ids ("r1") :size (120 . 24)
|
|
:line-signature (("Child")))))))
|
|
|
|
(ert-deftest ebox-cache-registry-records-scope-deps-and-lifetime ()
|
|
"Cache specs should make ownership, scope, dependencies, and lifetime explicit."
|
|
(unwind-protect
|
|
(let ((spec (ebox-cache-register
|
|
:name 'computed-style
|
|
:owner 'ebox-style
|
|
:scope 'node
|
|
:key-deps '(specified-style class-version theme-version)
|
|
:invalidates '(style class theme)
|
|
:lifetime 'buffer-runtime
|
|
:value-owner 'ebox-style)))
|
|
(should (eq (ebox-cache-spec-name spec) 'computed-style))
|
|
(should (eq (ebox-cache-spec-owner spec) 'ebox-style))
|
|
(should (eq (ebox-cache-spec-scope spec) 'node))
|
|
(should (equal (ebox-cache-spec-invalidates spec)
|
|
'(style class theme)))
|
|
(should (eq (ebox-cache-spec-lifetime spec) 'buffer-runtime)))
|
|
(ebox-cache-reset-default-registry)))
|
|
|
|
(ert-deftest ebox-cache-invalidates-by-dirty-kind ()
|
|
"Dirty facts should map to the cache specs they invalidate."
|
|
(unwind-protect
|
|
(progn
|
|
(ebox-cache-clear-registry)
|
|
(ebox-cache-register
|
|
:name 'render-body
|
|
:owner 'ebox-buffer-backend
|
|
:scope 'buffer
|
|
:key-deps '(fragment-signature paint-signature backend-display-signature)
|
|
:invalidates '(paint geometry structure backend-display)
|
|
:lifetime 'buffer-runtime
|
|
:value-owner 'ebox-buffer-backend)
|
|
(ebox-cache-register
|
|
:name 'layout-fragment
|
|
:owner 'ebox-layout
|
|
:scope 'formatting-context
|
|
:key-deps '(node-id computed-style-signature child-signatures available-size)
|
|
:invalidates '(geometry structure viewport)
|
|
:lifetime 'buffer-runtime
|
|
:value-owner 'ebox-layout)
|
|
(should (equal (sort (ebox-cache-invalidated-spec-names '(paint))
|
|
#'string<)
|
|
'(render-body)))
|
|
(should (equal (sort (ebox-cache-invalidated-spec-names '(geometry))
|
|
#'string<)
|
|
'(layout-fragment render-body))))
|
|
(ebox-cache-reset-default-registry)))
|
|
|
|
(ert-deftest ebox-cache-events-appear-in-update-report ()
|
|
"Incremental update reports should expose cache invalidation facts."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-create :content "Cache" :border-color "#111111"))
|
|
(id (car (ebox-region-ids node))))
|
|
(ebox-test--with-rendered-buffer node
|
|
(ebox-region-update id :border-color "#222222")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-member report :cache-invalidated))
|
|
(should (plist-member report :cache-hit-count))
|
|
(should (plist-member report :cache-miss-count))))))
|
|
|
|
(ert-deftest ebox-render-cache-retains-distinct-viewport-widths ()
|
|
"Returning to a warm width should not evict its prior rendered value."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-cache-report-buffer nil)
|
|
(width-a '(display-a 720 42 body))
|
|
(width-b '(display-a 900 42 body)))
|
|
(ebox--render-cache-store 'responsive width-a 'rendered-a)
|
|
(ebox--render-cache-store 'responsive width-b 'rendered-b)
|
|
(should (eq (ebox--render-cache-lookup 'responsive width-a)
|
|
'rendered-a))
|
|
(should (eq (ebox--render-cache-lookup 'responsive width-b)
|
|
'rendered-b))))
|
|
|
|
(ert-deftest ebox-render-cache-retains-distinct-box-width-signatures ()
|
|
"Ordinary box-width variants should coexist under one cache key."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-cache-report-buffer nil)
|
|
(width-a '(display-a nil 42 (:width 720)))
|
|
(width-b '(display-a nil 42 (:width 900))))
|
|
(ebox--render-cache-store 'responsive width-a 'rendered-a)
|
|
(ebox--render-cache-store 'responsive width-b 'rendered-b)
|
|
(should (eq (ebox--render-cache-lookup 'responsive width-a)
|
|
'rendered-a))
|
|
(should (eq (ebox--render-cache-lookup 'responsive width-b)
|
|
'rendered-b))))
|
|
|
|
(ert-deftest ebox-render-cache-distinguishes-content-text-properties ()
|
|
"Equal characters with different properties must not share rendered output."
|
|
(let* ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-cache-report-buffer nil)
|
|
(normal
|
|
(list 'display-a nil 42
|
|
(list :content
|
|
(propertize "Same" 'face 'default))))
|
|
(selected
|
|
(list 'display-a nil 42
|
|
(list :content
|
|
(propertize "Same" 'face 'highlight)))))
|
|
(ebox--render-cache-store 'cell normal 'rendered-normal)
|
|
(should-not (ebox--render-cache-lookup 'cell selected))
|
|
(ebox--render-cache-store 'cell selected 'rendered-selected)
|
|
(should (eq (ebox--render-cache-lookup 'cell selected)
|
|
'rendered-selected))))
|
|
|
|
(ert-deftest ebox-render-cache-evicts-oldest-entry-at-capacity ()
|
|
"A full cache should retain newer width variants without unbounded growth."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 2)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a 'rendered-a)
|
|
(ebox--render-cache-store 'responsive 'width-b 'rendered-b)
|
|
(ebox--render-cache-store 'responsive 'width-c 'rendered-c)
|
|
(should (= (hash-table-count ebox--render-cache-table) 2))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-a))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-b)
|
|
'rendered-b))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-c)
|
|
'rendered-c))))
|
|
|
|
(ert-deftest ebox-render-cache-evicts-oldest-entry-at-byte-budget ()
|
|
"Large rendered values should be bounded even below the entry limit."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-render-cache-max-bytes 400)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a "aa")
|
|
(ebox--render-cache-store 'responsive 'width-b "bb")
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-a))
|
|
(should (equal (ebox--render-cache-lookup 'responsive 'width-b) "bb"))
|
|
(should (= (hash-table-count ebox--render-cache-table) 1))))
|
|
|
|
(ert-deftest ebox-render-cache-does-not-retain-one-oversized-value ()
|
|
"One value above the byte budget should be returned but not retained."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-render-cache-max-bytes 128)
|
|
(ebox-cache-report-buffer nil))
|
|
(should (equal (ebox--render-cache-store
|
|
'responsive 'width-a "oversized")
|
|
"oversized"))
|
|
(should (= (hash-table-count ebox--render-cache-table) 0))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-a))))
|
|
|
|
(ert-deftest ebox-render-cache-oversized-store-preserves-healthy-entries ()
|
|
"One oversized store must not purge unrelated retained entries."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-render-cache-max-bytes 1024)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a "aa")
|
|
(ebox--render-cache-store 'responsive 'width-b "bb")
|
|
(should (equal (ebox--render-cache-store
|
|
'responsive 'width-oversized (make-string 64 ?x))
|
|
(make-string 64 ?x)))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-oversized))
|
|
(should (equal (ebox--render-cache-lookup 'responsive 'width-a) "aa"))
|
|
(should (equal (ebox--render-cache-lookup 'responsive 'width-b) "bb"))
|
|
(should (= (hash-table-count ebox--render-cache-table) 2))))
|
|
|
|
(ert-deftest ebox-render-cache-oversized-update-releases-only-that-entry ()
|
|
"Growing one entry above the budget must release only that entry."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-render-cache-max-bytes 1024)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a "aa")
|
|
(ebox--render-cache-store 'responsive 'width-b "bb")
|
|
(ebox--render-cache-store 'responsive 'width-b (make-string 64 ?x))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-b))
|
|
(should (equal (ebox--render-cache-lookup 'responsive 'width-a) "aa"))
|
|
(should (= (hash-table-count ebox--render-cache-table) 1))))
|
|
|
|
(ert-deftest ebox-render-cache-retains-distinct-sxhash-collisions ()
|
|
"Distinct signatures with one bounded hash must retain separate entries."
|
|
(let* ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-cache-report-buffer nil)
|
|
(signature-a '(same (same (same (same "a")))))
|
|
(signature-b '(same (same (same (same "b"))))))
|
|
(should-not (equal signature-a signature-b))
|
|
(should (= (sxhash-equal signature-a) (sxhash-equal signature-b)))
|
|
(ebox--render-cache-store 'page signature-a 'rendered-a)
|
|
(ebox--render-cache-store 'page signature-b 'rendered-b)
|
|
(should (= (hash-table-count ebox--render-cache-table) 2))
|
|
(should (eq (ebox--render-cache-lookup 'page signature-a) 'rendered-a))
|
|
(should (eq (ebox--render-cache-lookup 'page signature-b) 'rendered-b))))
|
|
|
|
(ert-deftest ebox-render-cache-byte-budget-includes-scroll-side-effects ()
|
|
"Scroll-state metadata must not bypass the retained-byte budget."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 16)
|
|
(ebox-render-cache-max-bytes 1024)
|
|
(ebox-cache-report-buffer nil)
|
|
(side-effects
|
|
(list :scroll-actions
|
|
(list
|
|
(list 'set 'scroll
|
|
(list :content-lines
|
|
(list (make-string 4096 ?x)))))
|
|
:stateful-p t
|
|
:restorable-p t)))
|
|
(should (equal (ebox--render-cache-store
|
|
'responsive 'width-a "x" side-effects)
|
|
"x"))
|
|
(should (= (hash-table-count ebox--render-cache-table) 0))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-a))))
|
|
|
|
(ert-deftest ebox-render-cache-reuses-portable-scroll-state-in-candidate-tree ()
|
|
"Portable scroll templates rebind complete state to the candidate box."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((buffer (generate-new-buffer " *ebox-portable-scroll-cache*"))
|
|
(old-box (ebox-create :content "old" :scroll-offset 0))
|
|
(node-id (ebox--ensure-node-id old-box))
|
|
(candidate-box (ebox-create :content "candidate" :scroll-offset 0))
|
|
(node-table (make-hash-table :test 'eql))
|
|
(template
|
|
(list :box old-box
|
|
:content-lines '("alpha" "beta")
|
|
:rendered-content-lines '("alpha")
|
|
:content-height 1
|
|
:scroll-offset 0))
|
|
(actions (list (list 'set 'scroll template)))
|
|
(entry (cons 'signature "rendered"))
|
|
(metadata
|
|
(list :scroll-actions actions
|
|
:stateful-p t
|
|
:portable-p t
|
|
:restorable-p t))
|
|
(ebox--render-cache-scroll-state-restorable-p nil))
|
|
(plist-put candidate-box :node-id node-id)
|
|
(puthash node-id candidate-box node-table)
|
|
(puthash buffer (list :node-table node-table)
|
|
ebox--buffer-render-state-table)
|
|
(puthash entry metadata ebox--render-cache-entry-side-effects-table)
|
|
(unwind-protect
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-cache-actions-portable-p actions))
|
|
(should (ebox--render-cache-entry-reusable-p entry))
|
|
(ebox--render-cache-replay-entry-side-effects entry)
|
|
(let ((state (ebox--scroll-get-state 'scroll)))
|
|
(should (eq (plist-get state :box) candidate-box))
|
|
(should (equal (plist-get state :content-lines)
|
|
'("alpha" "beta")))
|
|
(should (equal (plist-get state :rendered-content-lines)
|
|
'("alpha")))))
|
|
(ebox--scroll-clear-state 'scroll)
|
|
(remhash entry ebox--render-cache-entry-side-effects-table)
|
|
(remhash buffer ebox--buffer-render-state-table)
|
|
(when (buffer-live-p buffer) (kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-render-cache-rejects-nonportable-candidate-scroll-state ()
|
|
"Candidate publication must not replay closures owned by the old tree."
|
|
(let* ((prefix-renderer (lambda (_count) '("deferred")))
|
|
(materializer (lambda () '("materialized")))
|
|
(actions
|
|
(list
|
|
(list 'set 'scroll
|
|
(list :box (ebox-create :content "old" :scroll-offset 0)
|
|
:content-lines '("alpha")
|
|
:render-content-prefix prefix-renderer
|
|
:materialize-content-lines materializer))))
|
|
(ebox--render-cache-scroll-state-restorable-p nil)
|
|
(entry (cons 'signature "rendered"))
|
|
(metadata
|
|
(list :scroll-actions actions
|
|
:stateful-p t
|
|
:portable-p nil
|
|
:restorable-p t)))
|
|
(puthash entry metadata ebox--render-cache-entry-side-effects-table)
|
|
(unwind-protect
|
|
(progn
|
|
(should-not (ebox--scroll-cache-actions-portable-p actions))
|
|
(should-not (ebox--render-cache-entry-reusable-p entry)))
|
|
(remhash entry ebox--render-cache-entry-side-effects-table))))
|
|
|
|
(ert-deftest ebox-render-cache-ring-recovers-after-clrhash ()
|
|
"An exceptional cache clear should not leave stale eviction metadata."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 2)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a 'rendered-a)
|
|
(ebox--render-cache-store 'responsive 'width-b 'rendered-b)
|
|
(clrhash ebox--render-cache-table)
|
|
(ebox--render-cache-store 'responsive 'width-c 'rendered-c)
|
|
(ebox--render-cache-store 'responsive 'width-d 'rendered-d)
|
|
(ebox--render-cache-store 'responsive 'width-e 'rendered-e)
|
|
(should (= (hash-table-count ebox--render-cache-table) 2))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-c))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-d)
|
|
'rendered-d))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-e)
|
|
'rendered-e))))
|
|
|
|
(ert-deftest ebox-render-cache-ring-retains-newest-entries-when-limit-shrinks ()
|
|
"Lowering the cache limit should retain the newest insertion-order entries."
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox-render-cache-max-entries 3)
|
|
(ebox-cache-report-buffer nil))
|
|
(ebox--render-cache-store 'responsive 'width-a 'rendered-a)
|
|
(ebox--render-cache-store 'responsive 'width-b 'rendered-b)
|
|
(ebox--render-cache-store 'responsive 'width-c 'rendered-c)
|
|
(setq ebox-render-cache-max-entries 2)
|
|
(ebox--render-cache-store 'responsive 'width-d 'rendered-d)
|
|
(should (= (hash-table-count ebox--render-cache-table) 2))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-a))
|
|
(should-not (ebox--render-cache-lookup 'responsive 'width-b))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-c)
|
|
'rendered-c))
|
|
(should (eq (ebox--render-cache-lookup 'responsive 'width-d)
|
|
'rendered-d))))
|
|
|
|
(ert-deftest ebox-buffer-render-cache-stays-bounded-across-unique-widths ()
|
|
"Continuous resize should not retain an unbounded set of rendered widths."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-render-cache-max-entries 32)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil)
|
|
(layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport)
|
|
(flex :width (viewport) :gap 1
|
|
,@(cl-loop for index below 8
|
|
collect
|
|
`(box :id ,(format "card-%d" index)
|
|
:content ,(format "card %d" index)
|
|
:width 72 :height 1))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-cache-bound*") layout))
|
|
(cl-loop for width from 241 to 280
|
|
do (ebox-rerender-buffer-with-context buffer width))
|
|
(let ((cache (ebox--buffer-render-cache buffer)))
|
|
(should (<= (hash-table-count cache)
|
|
ebox-render-cache-max-entries)))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-owner-rerender-reuses-a-returning-width-output ()
|
|
"Returning to a cached root width should not rebuild the rendered owner."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :id "scroll" :width (viewport) :height 2
|
|
:overflow scroll :border t
|
|
:content "cached root owner\nline two\nline three"))))
|
|
buffer
|
|
root-id
|
|
(render-box-count 0)
|
|
(role-refresh-count 0)
|
|
(scroll-refresh-count 0)
|
|
(original-role-refresh
|
|
(symbol-function 'ebox-buffer-refresh-region-role-spans))
|
|
(original-scroll-refresh
|
|
(symbol-function 'ebox--refresh-buffer-scroll-content-markers))
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-root-cache*") layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(260))
|
|
(ebox-region-update root-id :width '(280)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf render-box-count)
|
|
(apply original-render-box args)))
|
|
((symbol-function 'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf role-refresh-count)
|
|
(apply original-role-refresh args)))
|
|
((symbol-function
|
|
'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-refresh-count)
|
|
(apply original-scroll-refresh args))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(260))))
|
|
(should (= render-box-count 0))
|
|
(should (= role-refresh-count 0))
|
|
(should (= scroll-refresh-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-root-cache-keeps-one-manual-resize-round-trip ()
|
|
"A maintained resize sweep should keep its exact widths for the return leg."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(flex :width (viewport) :gap 1
|
|
(box :content "alpha" :width 72 :height 1)
|
|
(box :content "beta" :width 72 :height 1)))))
|
|
(widths '(488 552 616 680 728 664 600 536 472 424))
|
|
buffer
|
|
(render-box-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 440)
|
|
(ebox-viewport-height 8)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-resize-round-trip*")
|
|
layout))
|
|
(dolist (width widths)
|
|
(ebox-rerender-buffer-with-context buffer width 8))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf render-box-count)
|
|
(apply original-render-box args))))
|
|
(ebox-rerender-buffer-with-context buffer (car widths) 8))
|
|
(should (= render-box-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-returning-width-cache-restores-lazy-scroll-context ()
|
|
"A cached subtree must restore lazy scroll state for its render context."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :id "viewport" :width (viewport)
|
|
(box :id "scroll" :width (viewport) :height 4
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for index below 32
|
|
collect
|
|
`(box :content ,(format "cached row %02d" index)
|
|
:width (viewport) :height 1)))))))
|
|
buffer
|
|
scroll-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 6)
|
|
;; Evict the first complete root so the return leg renders the
|
|
;; root while retaining its generic cached scroll subtree.
|
|
(ebox-render-root-cache-max-entries 1)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-scroll-cache-context*")
|
|
layout))
|
|
(setq scroll-id
|
|
(ebox-test--selector-region-id buffer "#scroll"))
|
|
(ebox-rerender-buffer-with-context buffer 320 6)
|
|
(ebox-rerender-buffer-with-context buffer 240 6)
|
|
(let ((state (ebox--scroll-get-state scroll-id)))
|
|
(should state)
|
|
(should (= (ebox--string-pixel-width
|
|
(car (plist-get state :rendered-content-lines)))
|
|
240))
|
|
(dotimes (_ 16)
|
|
(setq state
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
scroll-id state
|
|
(1+ (length (plist-get state :content-lines)))
|
|
t))))
|
|
(with-current-buffer buffer
|
|
(dotimes (_ 6)
|
|
(should (= (ebox--scroll-region-by scroll-id 1) 1)))
|
|
(let ((scrolled (buffer-string)))
|
|
(ebox-buffer-apply-root-rerender buffer)
|
|
(should (equal-including-properties
|
|
scrolled (buffer-string))))))
|
|
(when scroll-id
|
|
(ebox--scroll-cancel-idle-prefetch scroll-id))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-reflow-cache-prewarm-caches-the-complete-root-output ()
|
|
"A predicted viewport should publish a root render reusable by its reflow."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :content "predicted root owner" :width (viewport) :height 1))))
|
|
buffer
|
|
(render-box-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-root-prewarm*") layout))
|
|
(ebox--cancel-buffer-runtime-prewarm buffer)
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(revision (plist-get state :runtime-revision)))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-context
|
|
buffer state revision 240 260 4)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf render-box-count)
|
|
(apply original-render-box args))))
|
|
(ebox-rerender-buffer-with-context buffer 260 4))
|
|
(should (= render-box-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-cold-ordinary-root-reflow-skips-complete-templates ()
|
|
"An ordinary visible cache miss should leave complete scans to prewarming."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :content "cold root metadata" :height 1))))
|
|
buffer
|
|
(template-build-count 0)
|
|
(original-template-builder
|
|
(symbol-function 'ebox-buffer--build-region-role-span-template)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-cold-root-metadata*")
|
|
layout))
|
|
(let ((root-id (ebox-test--selector-region-id buffer "#root")))
|
|
(cl-letf (((symbol-function
|
|
'ebox-buffer--build-region-role-span-template)
|
|
(lambda (&rest arguments)
|
|
(cl-incf template-build-count)
|
|
(apply original-template-builder arguments))))
|
|
(let ((ebox--region-update-buffer-hint buffer))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(260))))
|
|
(should (= template-build-count 0))
|
|
(with-current-buffer buffer
|
|
(should
|
|
(ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-region-role-template-coalesces-unrelated-properties ()
|
|
"Role templates should inspect present properties and preserve full spans."
|
|
(let ((rendered (copy-sequence "abcd")))
|
|
(add-text-properties 0 4 '(ebox-content 7) rendered)
|
|
(add-text-properties 1 2 '(face bold) rendered)
|
|
(add-text-properties 2 4 '(ebox-pl 8) rendered)
|
|
(let ((template
|
|
(ebox-buffer--build-region-role-span-template rendered)))
|
|
(should (equal (gethash (list 7 'content) template)
|
|
'((1 . 5))))
|
|
(should (equal (gethash (list 8 'pl) template)
|
|
'((3 . 5)))))))
|
|
|
|
(ert-deftest ebox-prepared-root-render-is-exact-one-shot-fast-path ()
|
|
"An exact prepared root should bypass layout once and never affect children."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :id "child" :content "prepared" :height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prepared-root*") layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root (plist-get state :root-node))
|
|
(child (ebox--buffer-region-render-owner-node
|
|
buffer
|
|
(ebox-test--selector-region-id buffer "#child")))
|
|
(rendered (propertize "prepared-root" 'face 'bold))
|
|
(prepared
|
|
(list :rendered rendered
|
|
:render-state state
|
|
:node-id (ebox--ensure-node-id root)
|
|
:runtime-revision 0
|
|
:display-signature
|
|
(with-current-buffer buffer
|
|
(ebox-display-signature))
|
|
:kind 'root-width
|
|
:region-id
|
|
(ebox-test--selector-region-id buffer "#root")
|
|
:root-width 240
|
|
:viewport-width 900
|
|
:viewport-height 4)))
|
|
(with-current-buffer buffer
|
|
(ebox--with-buffer-render-context buffer
|
|
(let ((ebox--prepared-root-render prepared))
|
|
;; A local subtree lookup must not inspect or consume the
|
|
;; root-only handoff.
|
|
(ebox--render-with-cache child)
|
|
(should-not (plist-get prepared :consumed-p))
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest _)
|
|
(ert-fail "Exact prepared root reran layout"))))
|
|
(should (eq (ebox--render-with-cache root t) rendered)))
|
|
(should (plist-get prepared :consumed-p))
|
|
(should-not ebox--prepared-root-render))))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-prepared-root-render-rejects-stale-runtime ()
|
|
"A stale prepared root should fall back without entering later updates."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build '(box :id "root" :width (240) :content "old")))
|
|
buffer
|
|
(fallback-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-stale-prepared-root*")
|
|
layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root (plist-get state :root-node))
|
|
(prepared
|
|
(list :rendered "stale"
|
|
:render-state state
|
|
:node-id (ebox--ensure-node-id root)
|
|
:runtime-revision 1
|
|
:display-signature
|
|
(with-current-buffer buffer
|
|
(ebox-display-signature))
|
|
:kind 'root-width
|
|
:region-id
|
|
(ebox-test--selector-region-id buffer "#root")
|
|
:root-width 240
|
|
:viewport-width 900
|
|
:viewport-height 4)))
|
|
(with-current-buffer buffer
|
|
(ebox--with-buffer-render-context buffer
|
|
(let ((ebox--prepared-root-render prepared)
|
|
(ebox--render-cache-table
|
|
(make-hash-table :test 'equal)))
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest _)
|
|
(cl-incf fallback-count)
|
|
"fresh")))
|
|
(should (equal (ebox--render-with-cache root t) "fresh")))
|
|
(should (= fallback-count 1))
|
|
(should-not (plist-get prepared :consumed-p))
|
|
(should-not ebox--prepared-root-render))))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-prepared-animation-restores-complete-final-runtime ()
|
|
"Display-only root frames should defer indexes until one complete final frame."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(column
|
|
(box :id "a" :content "alpha" :height 1)
|
|
(box :id "b" :content "beta" :height 1)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prepared-animation*")
|
|
layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root (plist-get state :root-node))
|
|
(root-node-id (ebox--ensure-node-id root))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(initial
|
|
(with-current-buffer buffer
|
|
(buffer-string)))
|
|
(render-at
|
|
(lambda (width)
|
|
(let* ((isolated (copy-tree root))
|
|
(box (ebox--root-region-box isolated root-id))
|
|
(ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox--render-runtime-revision
|
|
(plist-get state :runtime-revision))
|
|
(ebox--render-cache-table
|
|
(make-hash-table :test 'equal))
|
|
(ebox--render-cache-signature-cache
|
|
(make-hash-table :test 'eq))
|
|
(ebox--region-box-table
|
|
(make-hash-table :test 'equal))
|
|
(ebox--scroll-global-state
|
|
(make-hash-table :test 'equal)))
|
|
(ebox-put box :width width)
|
|
(ebox-render isolated))))
|
|
(full-260 (funcall render-at 260))
|
|
(light-260 (copy-sequence full-260))
|
|
(prepared-260 nil))
|
|
(remove-list-of-text-properties
|
|
0 (length light-260)
|
|
'(ebox-content-idx ebox-content ebox-content-owners
|
|
ebox-content-owner ebox-bb ebox-br ebox-pr ebox-pb ebox-pl
|
|
ebox-bl ebox-bt ebox-pt ebox-scroll-window)
|
|
light-260)
|
|
(setq prepared-260
|
|
(list :rendered light-260
|
|
:render-state state
|
|
:node-id root-node-id
|
|
:runtime-revision 0
|
|
:display-signature
|
|
(with-current-buffer buffer
|
|
(ebox-display-signature))
|
|
:kind 'root-width
|
|
:region-id root-id
|
|
:root-width 260
|
|
:viewport-width 900
|
|
:viewport-height 4))
|
|
(with-current-buffer buffer
|
|
(let ((ebox--prepared-root-render prepared-260)
|
|
(ebox--prepared-root-defer-index-refresh t)
|
|
(ebox--region-update-buffer-hint buffer))
|
|
(ebox-region-update root-id :width '(260))))
|
|
(should (plist-get prepared-260 :consumed-p))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report)
|
|
:snapshot-refresh)
|
|
'prepared-animation))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :index-refresh)
|
|
'defer-extents))
|
|
(should-not (ebox--buffer-region-role-span-table buffer))
|
|
(let* ((snapshot
|
|
(gethash root-node-id
|
|
(ebox--ensure-buffer-layout-snapshots buffer)))
|
|
(spans (plist-get snapshot :buffer-spans)))
|
|
(should (= (caar spans) 1))
|
|
(should (= (cdr (car (last spans)))
|
|
(with-current-buffer buffer (point-max)))))
|
|
(let ((prepared-240
|
|
(list :rendered initial
|
|
:render-state state
|
|
:node-id root-node-id
|
|
:runtime-revision
|
|
(plist-get state :runtime-revision)
|
|
:display-signature
|
|
(with-current-buffer buffer
|
|
(ebox-display-signature))
|
|
:kind 'root-width
|
|
:region-id root-id
|
|
:root-width 240
|
|
:viewport-width 900
|
|
:viewport-height 4)))
|
|
(with-current-buffer buffer
|
|
(let ((ebox--prepared-root-render prepared-240)
|
|
(ebox--prepared-root-defer-index-refresh nil)
|
|
(ebox--region-update-buffer-hint buffer))
|
|
(ebox-region-update root-id :width '(240))))
|
|
(should (plist-get prepared-240 :consumed-p)))
|
|
(with-current-buffer buffer
|
|
(should (equal-including-properties (buffer-string) initial))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-complete-root-output-cache-retains-only-recent-widths ()
|
|
"Full root outputs should not crowd long-lived subtree cache entries."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :content "bounded root output" :width (viewport)))))
|
|
(ebox-render-root-cache-max-entries 2)
|
|
(ebox-render-root-cache-max-bytes (* 8 1024 1024))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-bounded-root-cache*")
|
|
layout))
|
|
(dolist (width '(260 280 300))
|
|
(ebox-rerender-buffer-with-context buffer width 4))
|
|
(let* ((render-cache (ebox--buffer-render-cache buffer))
|
|
(root-cache
|
|
(gethash render-cache ebox--render-root-cache-table-table)))
|
|
(should (hash-table-p root-cache))
|
|
(should (= (hash-table-count root-cache) 2))
|
|
(should-not (eq root-cache render-cache))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-width-cache-prewarm-is-isolated-and-reusable ()
|
|
"Predicted ordinary root width output should stay isolated until update."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :id "scroll" :width (viewport) :height 2
|
|
:overflow scroll :border t
|
|
:content "predicted ordinary root\nline two\nline three"))))
|
|
buffer
|
|
root-id
|
|
(render-box-count 0)
|
|
(role-refresh-count 0)
|
|
(scroll-refresh-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box))
|
|
(original-role-refresh
|
|
(symbol-function 'ebox-buffer-refresh-region-role-spans))
|
|
(original-scroll-refresh
|
|
(symbol-function 'ebox--refresh-buffer-scroll-content-markers)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-root-width-prewarm*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(revision (plist-get state :runtime-revision))
|
|
(root-before (copy-tree (plist-get state :root-node)))
|
|
(text-before (with-current-buffer buffer (buffer-string))))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-root-width
|
|
buffer state revision root-id 240 260))
|
|
(should (equal (plist-get state :root-node) root-before))
|
|
(should (equal-including-properties
|
|
(with-current-buffer buffer (buffer-string))
|
|
text-before)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf render-box-count)
|
|
(apply original-render-box args)))
|
|
((symbol-function 'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf role-refresh-count)
|
|
(apply original-role-refresh args)))
|
|
((symbol-function
|
|
'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-refresh-count)
|
|
(apply original-scroll-refresh args))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(260))))
|
|
(should (= render-box-count 0))
|
|
(should (= role-refresh-count 0))
|
|
(should (= scroll-refresh-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-width-prewarm-reuses-confirmed-isolated-scratch ()
|
|
"Consecutive root predictions should reuse one confirmed isolated tree."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :content "reusable isolated tree" :height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-reflow-scratch*") layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(revision (plist-get state :runtime-revision))
|
|
live-root scratch scratch-tree)
|
|
(setq live-root (plist-get state :root-node))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-root-width
|
|
buffer state revision root-id 240 260))
|
|
(setq scratch (plist-get state :reflow-prewarm-scratch)
|
|
scratch-tree (plist-get scratch :tree))
|
|
(should scratch)
|
|
(should-not (eq scratch-tree live-root))
|
|
(should (= (ebox--literal-root-pixel-width
|
|
(ebox--root-region-box scratch-tree root-id))
|
|
260))
|
|
(should (= (ebox--literal-root-pixel-width
|
|
(ebox--root-region-box live-root root-id))
|
|
240))
|
|
(let ((ebox--region-update-buffer-hint buffer))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(260))))
|
|
(should (eq scratch
|
|
(plist-get state :reflow-prewarm-scratch)))
|
|
(should (= (plist-get scratch :live-revision) 1))
|
|
(should-not (plist-get scratch :predicted-revision))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-root-width
|
|
buffer state 1 root-id 260 280))
|
|
(should (eq scratch-tree
|
|
(plist-get
|
|
(plist-get state :reflow-prewarm-scratch) :tree)))
|
|
(should (= (ebox--literal-root-pixel-width
|
|
(ebox--root-region-box live-root root-id))
|
|
260))
|
|
(should (= (ebox--literal-root-pixel-width
|
|
(ebox--root-region-box scratch-tree root-id))
|
|
280))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-width-prewarm-discards-mismatched-scratch ()
|
|
"A visible root width other than the prediction should discard its scratch."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :content "discard stale prediction" :height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-stale-scratch*") layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root")))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-root-width
|
|
buffer state 0 root-id 240 260))
|
|
(should (plist-get state :reflow-prewarm-scratch))
|
|
(let ((ebox--region-update-buffer-hint buffer))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width '(280))))
|
|
(should-not (plist-get state :reflow-prewarm-scratch))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-prewarm-reuses-live-isolated-scratch ()
|
|
"Viewport predictions should reuse one nonmutating isolated live tree."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :content "viewport scratch" :width (viewport) :height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-viewport-scratch*") layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(live-root (plist-get state :root-node))
|
|
scratch tree)
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-context
|
|
buffer state 0 240 260 4))
|
|
(setq scratch (plist-get state :reflow-prewarm-scratch)
|
|
tree (plist-get scratch :tree))
|
|
(should scratch)
|
|
(should-not (eq tree live-root))
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-context
|
|
buffer state 0 240 280 4))
|
|
(should (eq tree
|
|
(plist-get
|
|
(plist-get state :reflow-prewarm-scratch) :tree)))
|
|
(should (eq live-root (plist-get state :root-node)))
|
|
(should-not (plist-get scratch :predicted-revision))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-width-cache-prewarm-yields-to-user-input ()
|
|
"Ordinary root prediction should run only after an idle interval."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240)
|
|
(box :content "scheduled ordinary root" :height 1))))
|
|
buffer
|
|
scheduled-delay
|
|
scheduled-repeat
|
|
scheduled-function
|
|
scheduled-arguments)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm t)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-root-schedule*")
|
|
layout))
|
|
(let ((root-id (ebox-test--selector-region-id buffer "#root")))
|
|
(cl-letf (((symbol-function 'run-at-time)
|
|
(lambda (&rest _)
|
|
(ert-fail "Resize prediction must yield to input")))
|
|
((symbol-function 'run-with-idle-timer)
|
|
(lambda (delay repeat function &rest arguments)
|
|
(setq scheduled-delay delay
|
|
scheduled-repeat repeat
|
|
scheduled-function function
|
|
scheduled-arguments arguments)
|
|
'scheduled-reflow-timer)))
|
|
(ebox--schedule-buffer-root-width-cache-prewarm
|
|
buffer root-id 240 260)))
|
|
(should (= scheduled-delay
|
|
ebox-runtime-idle-reflow-cache-prewarm-delay))
|
|
(should-not scheduled-repeat)
|
|
(should (eq scheduled-function
|
|
#'ebox--run-root-width-cache-prewarm))
|
|
(should (equal (car scheduled-arguments) buffer))
|
|
(should (eq (gethash buffer ebox--reflow-cache-prewarm-timers)
|
|
'scheduled-reflow-timer)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-scheduled-reflow-prewarms-use-offscreen-gc-pressure ()
|
|
"Both predicted reflow paths should move GC pressure off visible frames."
|
|
(let ((prewarm-count 0)
|
|
(gc-count 0)
|
|
observed)
|
|
(cl-letf (((symbol-function
|
|
'ebox--prewarm-buffer-render-cache-at-root-width)
|
|
(lambda (&rest _)
|
|
(cl-incf prewarm-count)
|
|
(push (list gc-cons-threshold gc-cons-percentage
|
|
ebox-render-gc-cons-threshold
|
|
ebox-render-gc-cons-percentage)
|
|
observed)
|
|
t))
|
|
((symbol-function
|
|
'ebox--prewarm-buffer-render-cache-at-context)
|
|
(lambda (&rest _)
|
|
(cl-incf prewarm-count)
|
|
(push (list gc-cons-threshold gc-cons-percentage
|
|
ebox-render-gc-cons-threshold
|
|
ebox-render-gc-cons-percentage)
|
|
observed)
|
|
t))
|
|
((symbol-function 'garbage-collect)
|
|
(lambda () (cl-incf gc-count))))
|
|
(let ((ebox-reflow-cache-prewarm-gc-cons-threshold 123456)
|
|
(ebox-reflow-cache-prewarm-gc-cons-percentage 0.2))
|
|
(ebox--run-root-width-cache-prewarm
|
|
nil nil 0 'root 300 315)
|
|
(ebox--run-reflow-cache-prewarm
|
|
nil nil 0 300 315 20)))
|
|
(should (= prewarm-count 2))
|
|
(should (= gc-count 0))
|
|
(should (equal observed
|
|
'((123456 0.2 123456 0.2)
|
|
(123456 0.2 123456 0.2))))))
|
|
|
|
(ert-deftest ebox-reflow-prewarm-gc-adapts-to-measured-layout-cost ()
|
|
"Automatic prewarm GC should follow measured allocation and layout time."
|
|
(let ((ebox--physical-memory-bytes (* 16 1024 1024 1024))
|
|
(ebox-reflow-cache-prewarm-gc-auto-frame-budget 0.2)
|
|
(ebox-reflow-cache-prewarm-gc-auto-min-threshold (* 64 1024 1024))
|
|
(ebox-reflow-cache-prewarm-gc-auto-max-threshold (* 1024 1024 1024))
|
|
(ebox-reflow-cache-prewarm-gc-auto-target-layouts 24))
|
|
(should (= (ebox--reflow-cache-prewarm-auto-threshold-for-allocation
|
|
(* 28 1024 1024) 0.16)
|
|
(* 672 1024 1024)))
|
|
(should (= (ebox--reflow-cache-prewarm-auto-threshold-for-allocation
|
|
(* 8 1024 1024) 0.08)
|
|
(* 128 1024 1024)))
|
|
(should (= (ebox--reflow-cache-prewarm-auto-threshold-for-allocation
|
|
(* 2 1024 1024) 0.02)
|
|
(* 64 1024 1024)))
|
|
(should (= (ebox--reflow-cache-prewarm-auto-threshold-for-allocation
|
|
(* 64 1024 1024) 0.21)
|
|
(* 1024 1024 1024)))
|
|
(should (= (ebox--memory-use-counts-estimated-bytes
|
|
'(0 0 0 0 0 0 0) '(1 1 1 1 1 1 1))
|
|
161))
|
|
(let ((state (list :runtime-revision 0)))
|
|
(ebox--record-reflow-cache-prewarm-cost
|
|
state 0.16 0 (* 512 1024 1024) (* 28 1024 1024))
|
|
(should (= (plist-get state :reflow-prewarm-gc-threshold)
|
|
(* 672 1024 1024)))
|
|
(ebox--record-reflow-cache-prewarm-cost
|
|
state 0.5 1 (* 672 1024 1024) (* 28 1024 1024))
|
|
(should (= (plist-get state :reflow-prewarm-gc-threshold)
|
|
(* 672 1024 1024)))
|
|
(should (= (plist-get state :reflow-prewarm-layout-seconds) 0.16)))))
|
|
|
|
(ert-deftest ebox-buffer-backend-maps-paint-style-to-text-properties ()
|
|
"Paint mapping should be a backend operation, not a style-model operation."
|
|
(let* ((style (ebox-style-compute
|
|
(list :color "#111111"
|
|
:background-color "#eeeeee"
|
|
:border-color "#333333")))
|
|
(props (ebox-buffer-paint-text-properties style 'content)))
|
|
(should props)
|
|
(should (plist-member props 'face))))
|
|
|
|
(ert-deftest ebox-buffer-backend-does-not-map-layout-only-properties ()
|
|
"Layout-only properties should not produce text properties directly."
|
|
(let* ((style (ebox-style-compute
|
|
(list :width '(120)
|
|
:padding '(1 2))))
|
|
(props (ebox-buffer-paint-text-properties style 'content)))
|
|
(should-not (memq :width props))
|
|
(should-not (memq :padding-inline-start props))))
|
|
|
|
(ert-deftest ebox-add-content-owner-ignores-paint-only-segment-changes ()
|
|
"Owner stacking should segment only when owner metadata changes."
|
|
(let ((line (copy-sequence "abcdefgh"))
|
|
(stack-lookups 0)
|
|
(original-stack-at (symbol-function 'ebox--content-owner-stack-at)))
|
|
(add-text-properties 0 4 '(ebox-content-owner child-a) line)
|
|
(add-text-properties 4 8 '(ebox-content-owner child-b) line)
|
|
(add-text-properties 1 2 '(face (:foreground "#111111")) line)
|
|
(add-text-properties 2 3 '(display (space :width (3))) line)
|
|
(add-text-properties 5 6 '(face (:background "#eeeeee")) line)
|
|
(cl-letf (((symbol-function 'ebox--content-owner-stack-at)
|
|
(lambda (&rest args)
|
|
(cl-incf stack-lookups)
|
|
(apply original-stack-at args))))
|
|
(let ((owned (ebox--add-content-owner line 'root)))
|
|
(should (= stack-lookups 2))
|
|
(should (equal '(child-a root)
|
|
(get-text-property 0 'ebox-content-owners owned)))
|
|
(should (equal '(child-b root)
|
|
(get-text-property 4 'ebox-content-owners owned)))))))
|
|
|
|
(ert-deftest ebox-add-content-owner-scans-complete-owner-stacks-once ()
|
|
"Complete owner stacks should not require a parallel owner-property scan."
|
|
(let ((line (copy-sequence "abcdefgh"))
|
|
(property-scans 0)
|
|
(original-next (symbol-function 'next-single-property-change)))
|
|
(add-text-properties
|
|
0 4 '(ebox-content-owner child-a ebox-content-owners (child-a)) line)
|
|
(add-text-properties
|
|
4 8 '(ebox-content-owner child-b ebox-content-owners (child-b)) line)
|
|
(cl-letf (((symbol-function 'next-single-property-change)
|
|
(lambda (position property &rest args)
|
|
(when (memq property
|
|
'(ebox-content-owner ebox-content-owners))
|
|
(cl-incf property-scans))
|
|
(apply original-next position property args))))
|
|
(let ((owned (ebox--add-content-owner line 'root)))
|
|
(should (= property-scans 2))
|
|
(should (equal '(child-a root)
|
|
(get-text-property 0 'ebox-content-owners owned)))
|
|
(should (equal '(child-b root)
|
|
(get-text-property 4 'ebox-content-owners owned)))))))
|
|
|
|
(ert-deftest ebox-add-content-owners-merges-all-owners-in-one-scan ()
|
|
"Adding several owners should scan each original owner run only once."
|
|
(let ((line (copy-sequence "abcdefgh"))
|
|
(property-scans 0)
|
|
(original-next (symbol-function 'next-single-property-change)))
|
|
(add-text-properties 0 4 '(ebox-content-owner child-a) line)
|
|
(add-text-properties 4 8 '(ebox-content-owner child-b) line)
|
|
(cl-letf (((symbol-function 'next-single-property-change)
|
|
(lambda (position property &rest args)
|
|
(when (memq property
|
|
'(ebox-content-owner ebox-content-owners))
|
|
(cl-incf property-scans))
|
|
(apply original-next position property args))))
|
|
(let ((owned (ebox--add-content-owners line '(middle root))))
|
|
(should (= property-scans 4))
|
|
(should (eq (get-text-property 0 'ebox-content-owner owned) 'root))
|
|
(should (equal '(child-a middle root)
|
|
(get-text-property 0 'ebox-content-owners owned)))
|
|
(should (equal '(child-b middle root)
|
|
(get-text-property 4 'ebox-content-owners owned)))))))
|
|
|
|
(ert-deftest ebox-propertize-content-line-can-own-private-line-in-place ()
|
|
"A private split line should accept wrapper ownership without another copy."
|
|
(let* ((source (propertize "content"
|
|
'ebox-content 'child
|
|
'ebox-content-owner 'child
|
|
'ebox-content-owners '(child)))
|
|
(source-before (copy-sequence source))
|
|
(private-line (copy-sequence source))
|
|
(regular
|
|
(ebox--propertize-content-line source 'wrapper 0 "fallback"))
|
|
(owned
|
|
(let ((ebox--propertize-private-content-line-p t))
|
|
(ebox--propertize-content-line
|
|
private-line 'wrapper 0 "fallback"))))
|
|
(should-not (eq regular source))
|
|
(should (equal-including-properties source source-before))
|
|
(should (eq owned private-line))
|
|
(should (eq (get-text-property 0 'ebox-content-owner owned) 'wrapper))
|
|
(should (equal (get-text-property 0 'ebox-content-owners owned)
|
|
'(child wrapper)))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-lines-own-color-copy-in-place ()
|
|
"Colored scroll lines should add ownership to the color copy in place."
|
|
(let* ((box (ebox-create :width 120
|
|
:color "#112233"
|
|
:bgcolor "#F4F5F6"))
|
|
(region-id 901)
|
|
(source (propertize "child" 'ebox-content 77
|
|
'ebox-content-owner 77
|
|
'ebox-content-owners '(77)))
|
|
(source-before (copy-sequence source))
|
|
(filler (ebox-pixel-space (ebox--content-pixel box)))
|
|
(expected
|
|
(ebox--propertize-colors
|
|
(ebox--propertize-content-line source region-id 4 filler)
|
|
(ebox-get box :color)
|
|
(ebox-get box :bgcolor)))
|
|
(copying-owner-count 0)
|
|
(original-copying-owner
|
|
(symbol-function 'ebox--add-content-owner))
|
|
actual)
|
|
(cl-letf (((symbol-function 'ebox--add-content-owner)
|
|
(lambda (&rest args)
|
|
(cl-incf copying-owner-count)
|
|
(apply original-copying-owner args))))
|
|
(setq actual
|
|
(car (ebox--scroll-rendered-content-lines
|
|
box (list source) region-id 4))))
|
|
(should (equal-including-properties source source-before))
|
|
(should (equal-including-properties actual expected))
|
|
(should (= copying-owner-count 0))))
|
|
|
|
(ert-deftest ebox-box-render-coalesces-foreground-background-pass ()
|
|
"Foreground and background should not each copy the rendered box lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "paint"
|
|
:width 12 :height 1
|
|
:color "#112233"
|
|
:bgcolor "#ddeeff"))
|
|
(reference (ebox-render box))
|
|
(original-color (symbol-function 'ebox--propertize-color))
|
|
(original-bgcolor (symbol-function 'ebox--propertize-bgcolor))
|
|
(color-calls 0)
|
|
(bgcolor-calls 0)
|
|
actual)
|
|
(cl-letf (((symbol-function 'ebox--propertize-color)
|
|
(lambda (&rest args)
|
|
(cl-incf color-calls)
|
|
(apply original-color args)))
|
|
((symbol-function 'ebox--propertize-bgcolor)
|
|
(lambda (&rest args)
|
|
(cl-incf bgcolor-calls)
|
|
(apply original-bgcolor args))))
|
|
(setq actual (ebox-render box)))
|
|
(should (= color-calls 0))
|
|
(should (= bgcolor-calls 0))
|
|
(should (equal-including-properties actual reference))))
|
|
|
|
(ert-deftest ebox-incremental-update-scheduler-batches-multiple-style-changes ()
|
|
"Scheduler seed should coalesce multiple property changes into one flush."
|
|
(let* ((node (ebox-create :content "Batch" :border-color "#111111"))
|
|
(id (car (ebox-region-ids node))))
|
|
(ebox-test--with-rendered-buffer node
|
|
(ebox-incremental-begin-batch (current-buffer))
|
|
(ebox-region-update id :border-color "#222222")
|
|
(ebox-region-update id :background-color "#eeeeee")
|
|
(should (= (ebox-incremental-pending-count (current-buffer)) 2))
|
|
(ebox-incremental-flush (current-buffer))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (= (plist-get report :flush-count) 1))
|
|
(should (= (plist-get report :patch-count) 1))
|
|
(should (member 'paint (plist-get report :dirty-kinds)))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-keeps-stronger-same-owner-operation ()
|
|
"Same-owner paint and geometry must preserve the stronger operation."
|
|
(dolist (order '((paint geometry) (geometry paint)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Batch width" :width '(160)
|
|
:color "black"))
|
|
(id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((buffer (current-buffer)))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(dolist (operation order)
|
|
(pcase operation
|
|
('paint (ebox-region-update id :color "red"))
|
|
('geometry (ebox-region-update id :width '(80)))))
|
|
(ebox-incremental-flush buffer))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(let ((runtime-box
|
|
(gethash id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (equal (ebox-get box :width) 160))
|
|
(should (= (ebox-get runtime-box :width) 80)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should-not (eq (plist-get report :strategy) 'paint-patch)))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-keeps-descendant-paint-after-ancestor-paint ()
|
|
"Ancestor and child paint must execute general-to-specific in any input order."
|
|
(dolist (order '((parent child) (child parent)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id parent :width (120) :color "black"
|
|
(box :id child :content "Child" :width (120)
|
|
:color "black")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(parent-id (ebox-test--selector-region-id buffer "#parent"))
|
|
(child-id (ebox-test--selector-region-id buffer "#child")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(dolist (operation order)
|
|
(pcase operation
|
|
('parent (ebox-region-update parent-id :color "red"))
|
|
('child (ebox-region-update child-id :color "blue"))))
|
|
(ebox-incremental-flush buffer))
|
|
(goto-char (point-min))
|
|
(search-forward "Child")
|
|
(let ((face (get-text-property (- (point) (length "Child")) 'face)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "blue")))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-paints-before-descendant-text-change ()
|
|
"Ancestor paint must run before a descendant text-changing operation."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id parent :width (160) :color "black"
|
|
(box :id child :content "Child" :width (120)
|
|
:color "blue")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(parent-id (ebox-test--selector-region-id buffer "#parent"))
|
|
(child-id (ebox-test--selector-region-id buffer "#child")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update parent-id :color "red")
|
|
(ebox-region-update child-id :width '(80))
|
|
(ebox-incremental-flush buffer))
|
|
(goto-char (point-min))
|
|
(search-forward "Child")
|
|
(let ((face (get-text-property (- (point) (length "Child")) 'face)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "blue")))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(defun ebox-test--multi-row-batch-flex-layout ()
|
|
"Return a wrapped flex fixture with targets on separate rows."
|
|
(ebox-build
|
|
'(flex :id matrix :width (500) :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1 :padding (0 (12))
|
|
:border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title A" :width (190))
|
|
(box :id target-a :content "Target A" :width (160)
|
|
:height 3 :padding (0 (8)) :border "#999999"
|
|
:text-align right)
|
|
(box :content "Metric A" :width (190) :height 2))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Peer A" :width (190))
|
|
(box :content "Same first row" :width (190) :height 3)
|
|
(box :content "Metric B" :width (190) :height 2))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title B" :width (190))
|
|
(box :id target-b :content "Target B" :width (160)
|
|
:height 3 :padding (0 (8)) :border "#999999"
|
|
:text-align right)
|
|
(box :content "Metric C" :width (190) :height 2))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Peer B" :width (190))
|
|
(box :content "Same second row" :width (190) :height 3)
|
|
(box :content "Metric D" :width (190) :height 2)))))
|
|
|
|
(ert-deftest ebox-explicit-batch-multiple-flex-rows-skip-line-fast-path ()
|
|
"Dirty descendants on separate flex rows must rerender in either order."
|
|
(dolist (order '((target-a target-b) (target-b target-a)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--multi-row-batch-flex-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(target-a-id
|
|
(ebox-test--selector-region-id buffer "#target-a"))
|
|
(target-b-id
|
|
(ebox-test--selector-region-id buffer "#target-b")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(dolist (target order)
|
|
(ebox-region-update
|
|
(if (eq target 'target-a) target-a-id target-b-id)
|
|
:width '(210) :min-width '(150) :max-width '(260)))
|
|
(ebox-incremental-flush buffer))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should-not (plist-get report :flex-line-rerender)))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-absorbed-flex-descendant-keeps-provenance ()
|
|
"An absorbed descendant update must disable a partial flex owner rerender."
|
|
(dolist (order '((geometry paint) (paint geometry)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--multi-row-batch-flex-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(target-a-id
|
|
(ebox-test--selector-region-id buffer "#target-a"))
|
|
(target-b-id
|
|
(ebox-test--selector-region-id buffer "#target-b")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(dolist (operation order)
|
|
(pcase operation
|
|
('geometry
|
|
(ebox-region-update target-a-id
|
|
:width '(210)
|
|
:min-width '(150)
|
|
:max-width '(260)))
|
|
('paint
|
|
(ebox-region-update target-b-id :color "blue"))))
|
|
(ebox-incremental-flush buffer))
|
|
(goto-char (point-min))
|
|
(search-forward "Target B")
|
|
(let* ((start (- (point) (length "Target B")))
|
|
(face (get-text-property start 'face))
|
|
(report (ebox-test--buffer-update-report)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "blue"))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should-not (plist-get report :flex-line-rerender)))))))
|
|
|
|
(ert-deftest ebox-layout-module-renders-row-and-column-through-facade ()
|
|
"Facade rendering should still use extracted layout owners."
|
|
(let ((rendered (ebox-render
|
|
(ebox-build
|
|
'(column
|
|
(row
|
|
(box :content "A" :width (40))
|
|
(box :content "B" :width (40))))))))
|
|
(should (string-match-p "A" rendered))
|
|
(should (string-match-p "B" rendered))))
|
|
|
|
(ert-deftest ebox-layout-snapshot-details-are-computed-lazily ()
|
|
"Initial render should store cheap snapshots and complete spans on demand."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "L" :width 40 :border t))
|
|
(right (ebox-create :content "R" :width 40 :border t))
|
|
(layout (ebox-concat left right))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(let* ((root-id (plist-get layout :node-id))
|
|
(snapshot (ebox--layout-snapshot buffer root-id)))
|
|
(should snapshot)
|
|
(should (eq (plist-get snapshot :type) 'concat))
|
|
(should-not (plist-member snapshot :line-signature))
|
|
(should-not (plist-member snapshot :buffer-spans))
|
|
(let ((detailed
|
|
(ebox--ensure-layout-snapshot-details buffer root-id)))
|
|
(should (plist-get detailed :line-signature))
|
|
(should (plist-get detailed :buffer-spans))
|
|
(should (plist-member
|
|
(ebox--layout-snapshot buffer root-id)
|
|
:line-signature)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-layout-snapshot-details-include-footprint-signatures ()
|
|
"Detailed snapshots should expose explicit L2 footprint signatures."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Footprint" :width '(120)
|
|
:height 1 :border t))
|
|
(node-id (ebox--ensure-node-id box)))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let* ((snapshot (ebox--ensure-layout-snapshot-details
|
|
(current-buffer) node-id))
|
|
(span-footprint
|
|
(plist-get snapshot :span-footprint-signature))
|
|
(external-footprint
|
|
(plist-get snapshot :external-footprint-signature))
|
|
(parent-slot
|
|
(plist-get snapshot :parent-slot-signature))
|
|
(role-topology
|
|
(plist-get snapshot :role-topology-signature))
|
|
(overflow
|
|
(plist-get snapshot :overflow-signature)))
|
|
(should span-footprint)
|
|
(should external-footprint)
|
|
(should parent-slot)
|
|
(should role-topology)
|
|
(should overflow)
|
|
(should (= (plist-get span-footprint :span-count) 1))
|
|
(should (equal (plist-get span-footprint :line-pixel-widths)
|
|
(plist-get snapshot :line-signature)))
|
|
(should (= (plist-get external-footprint :block-lines) 1))
|
|
(should (= (plist-get external-footprint :max-line-pixel-width)
|
|
(car (plist-get snapshot :line-signature))))
|
|
(should (= (plist-get parent-slot :slot-count) 1))
|
|
(should (memq 'content (plist-get role-topology :roles)))
|
|
(should-not (plist-get overflow :visible))))))
|
|
|
|
(ert-deftest ebox-role-topology-signature-uses-published-span-index ()
|
|
"Role topology should read the published index without per-role span copies."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Indexed" :width '(120) :border t))
|
|
(region-id (ebox--ensure-region-id box)))
|
|
(ebox-test--with-rendered-buffer box
|
|
(cl-letf (((symbol-function 'ebox--region-find)
|
|
(lambda (&rest _arguments)
|
|
(ert-fail "role topology rescanned region spans"))))
|
|
(let ((roles (plist-get (ebox--role-topology-signature
|
|
(list region-id))
|
|
:roles)))
|
|
(should (memq 'content roles))
|
|
(should (memq 'content-owner roles)))))))
|
|
|
|
(ert-deftest ebox-replace-line-spans-returns-new-spans-for-contiguous-lines ()
|
|
"Backend span replacement should return updated spans for every path."
|
|
(with-temp-buffer
|
|
(insert "one\ntwo\n")
|
|
(let* ((spans (save-excursion
|
|
(goto-char (point-min))
|
|
(list (cons (line-beginning-position)
|
|
(line-end-position))
|
|
(progn
|
|
(forward-line 1)
|
|
(cons (line-beginning-position)
|
|
(line-end-position))))))
|
|
(new-spans (ebox--replace-line-spans spans
|
|
"alpha\nbeta\ngamma")))
|
|
(should (equal (buffer-string) "alpha\nbeta\ngamma\n"))
|
|
(should (equal (mapcar (lambda (span)
|
|
(buffer-substring-no-properties
|
|
(car span) (cdr span)))
|
|
new-spans)
|
|
'("alpha" "beta" "gamma"))))))
|
|
|
|
(ert-deftest ebox-resolve-line-anchor-falls-back-when-line-is-gone ()
|
|
"Window-state anchors should resolve in bounded time after line replacement."
|
|
(with-temp-buffer
|
|
(insert "before\n")
|
|
(let ((anchor (ebox--line-anchor-at (point-min))))
|
|
(erase-buffer)
|
|
(insert "after\n")
|
|
(should (= (ebox--resolve-line-anchor anchor) (point-min))))))
|
|
|
|
(ert-deftest ebox-line-anchor-occurrence-tracks-duplicate-plain-lines ()
|
|
"Unowned duplicate lines keep resolving to the captured occurrence."
|
|
(with-temp-buffer
|
|
(insert "dup\nother\ndup\ndup\ntail\n")
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(forward-char 1)
|
|
(let ((anchor (ebox--line-anchor-at (point))))
|
|
(should (= (plist-get anchor :occurrence) 2))
|
|
(erase-buffer)
|
|
(insert "prefix\ndup\nother\ndup\nmiddle\ndup\ntail\n")
|
|
(goto-char (ebox--resolve-line-anchor anchor))
|
|
(should (= (line-number-at-pos) 6))
|
|
(should (= (current-column) 1)))))
|
|
|
|
(ert-deftest ebox-line-anchor-occurrence-treats-line-text-literally ()
|
|
"Occurrence counting must not read regexp syntax or partial matches."
|
|
(with-temp-buffer
|
|
(insert "a.*b [x]\naXb x\nxa.*b [x]y\na.*b [x]\n\n\ntext\n\n")
|
|
;; "aXb x" satisfies "a.*b [x]" read as a regexp, and the superstring
|
|
;; line contains it verbatim; only the literal full-line copy counts.
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(should (= (plist-get (ebox--line-anchor-at (point)) :occurrence) 1))
|
|
;; An empty anchor line counts only preceding empty lines and terminates.
|
|
(goto-char (point-max))
|
|
(forward-line -1)
|
|
(should (= (plist-get (ebox--line-anchor-at (point)) :occurrence) 2))))
|
|
|
|
(ert-deftest ebox-layout-snapshot-capture-skips-line-ownership-scan ()
|
|
"Initial snapshot capture should not scan line ownership for every node."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (apply
|
|
#'ebox-column
|
|
(cl-loop for index below 8
|
|
collect
|
|
(ebox-flex
|
|
:border "#64748B" :bgcolor "#F8FAFC"
|
|
:flex-flow '(row wrap)
|
|
(ebox-create
|
|
:content (format "A%d" index)
|
|
:width 60 :bgcolor "#DBEAFE")
|
|
(ebox-create
|
|
:content (format "B%d" index)
|
|
:width 60 :bgcolor "#DCFCE7")
|
|
(ebox-create
|
|
:content (format "C%d" index)
|
|
:width 60 :bgcolor "#FEF3C7")))))
|
|
(calls 0)
|
|
(original (symbol-function 'ebox--pos-region-ids))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 900))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox--clear-layout-snapshots buffer)
|
|
(cl-letf (((symbol-function 'ebox--pos-region-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf calls)
|
|
(apply original args))))
|
|
(ebox--refresh-buffer-layout-snapshots buffer))
|
|
(should (= calls 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-stack-render-flattens-before-width-measurement ()
|
|
"Column rendering should not repeatedly measure already stacked strings."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (apply
|
|
#'ebox-column
|
|
(cl-loop for index below 12
|
|
collect
|
|
(ebox-create
|
|
:content (format "Row %02d" index)
|
|
:width (+ 40 (* index 2))))))
|
|
(multiline-width-calls 0)
|
|
(original (symbol-function 'ebox--string-pixel-width)))
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (string)
|
|
(when (and (stringp string)
|
|
(string-match-p "\n" string))
|
|
(cl-incf multiline-width-calls))
|
|
(funcall original string))))
|
|
(ebox-render layout))
|
|
(should (= multiline-width-calls 0))))
|
|
|
|
(ert-deftest ebox-lines-concat-horizontal-splits-each-input-once ()
|
|
"Horizontal line concatenation should avoid split-pad-resplit work."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((split-count 0)
|
|
(original (symbol-function 'ebox-string-lines))
|
|
result)
|
|
(cl-letf (((symbol-function 'ebox-string-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf split-count)
|
|
(apply original args))))
|
|
(setq result
|
|
(ebox--lines-concat-horizontal
|
|
"A\nB\nC"
|
|
"1\n2"
|
|
"x")))
|
|
(should (string= (substring-no-properties result)
|
|
"A1x\nB2 \nC "))
|
|
(should (= split-count 3))))
|
|
|
|
(ert-deftest ebox-layout-snapshot-table-is-created-when-missing ()
|
|
"Snapshot storage should tolerate render states created before snapshots."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer (generate-new-buffer " *ebox-test*"))
|
|
(node-id "legacy-node"))
|
|
(unwind-protect
|
|
(progn
|
|
(puthash buffer
|
|
(list :root-node nil
|
|
:viewport-width 80)
|
|
ebox--buffer-render-state-table)
|
|
(ebox--put-layout-snapshot buffer node-id (list :node-id node-id))
|
|
(should (equal (plist-get (ebox--layout-snapshot buffer node-id)
|
|
:node-id)
|
|
node-id)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-layout-snapshot-records-display-style-and-wrapper-children ()
|
|
"Snapshots should describe display, style, and child ids for wrapper boxes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1 :bgcolor "linen"
|
|
(box :content "Child A" :width (120))
|
|
(box :content "Child B" :width (120)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node))
|
|
(let* ((snapshot (ebox--layout-snapshot
|
|
buffer (plist-get node :node-id)))
|
|
(child-ids (plist-get snapshot :child-ids))
|
|
(child-snapshot (ebox--layout-snapshot buffer (car child-ids))))
|
|
(should (equal (plist-get snapshot :display) '(block flow)))
|
|
(should (equal (plist-get child-snapshot :display)
|
|
'(block column)))
|
|
(should (plist-get snapshot :style-signature))
|
|
(should child-ids)
|
|
(should (= (length child-ids) 1))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-dirty-set-classifies-paint-only-change ()
|
|
"A color-only change should produce paint dirty, not geometry dirty."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Paint" :width 80
|
|
:border t :border-color "red"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((old (ebox--current-layout-snapshots (current-buffer))))
|
|
(ebox-region-update region-id :border-color "blue")
|
|
(let ((dirty (ebox--diff-layout-snapshots
|
|
old
|
|
(ebox--current-layout-snapshots (current-buffer)))))
|
|
(should dirty)
|
|
(should (eq (plist-get (car dirty) :dirty-kind) 'paint)))))))
|
|
|
|
(ert-deftest ebox-dirty-set-classifies-viewport-wrap-change ()
|
|
"Viewport wrapping should produce geometry or placement dirty."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 240)
|
|
buffer
|
|
layout)
|
|
(setq layout
|
|
(ebox-flex :flex-wrap 'wrap
|
|
(ebox-create :content "A" :width '(120))
|
|
(ebox-create :content "B" :width '(120))))
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(let ((old (ebox--current-layout-snapshots buffer t)))
|
|
(ebox-rerender-buffer-with-context buffer 130)
|
|
(let ((dirty (ebox--diff-layout-snapshots
|
|
old
|
|
(ebox--current-layout-snapshots buffer t))))
|
|
(should (cl-some
|
|
(lambda (entry)
|
|
(memq (plist-get entry :dirty-kind)
|
|
'(geometry placement structure)))
|
|
dirty)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-dirty-set-classifies-wrapper-child-viewport-geometry ()
|
|
"Viewport reflow under a wrapper should produce geometry dirty, not no-op."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(box :content "Text that wraps differently when narrow"
|
|
:wrap-mode word))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(let ((ebox-viewport-width 520))
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(ebox-rerender-buffer-with-context buffer 36)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'viewport))
|
|
(should (member 'geometry (plist-get report :dirty-kinds)))
|
|
(should-not (eq (plist-get report :strategy) 'no-op))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-patch-set-paints-without-rendered-text-replace ()
|
|
"Paint-only dirty entries should produce paint-patch ops."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Paint" :width 80
|
|
:border t :border-color "red"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((replace-count 0)
|
|
(original-replace (symbol-function 'ebox--replace-line-spans)))
|
|
(cl-letf (((symbol-function 'ebox--replace-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf replace-count)
|
|
(apply original-replace args))))
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id :border-color "blue"))))
|
|
(should (= full-rerenders 0))))
|
|
(should (= replace-count 0)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (eq (plist-get report :full-rerender) nil))))))
|
|
|
|
(ert-deftest ebox-flex-wrapper-style-update-uses-paint-patch ()
|
|
"Flex wrapper style updates should patch faces without replacing spans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-flex
|
|
:border "#5E7F6A" :bgcolor "#F8FCF8"
|
|
(ebox-create :content "A" :width 60
|
|
:bgcolor "#DCEBDD")))
|
|
(region-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((replace-count 0)
|
|
(original-replace (symbol-function 'ebox--replace-line-spans)))
|
|
(cl-letf (((symbol-function 'ebox--replace-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf replace-count)
|
|
(apply original-replace args))))
|
|
(ebox-region-update region-id :bgcolor "#FDE68A"))
|
|
(should (= replace-count 0)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should-not (plist-get report :full-rerender))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(paint-patch)))))))
|
|
|
|
(ert-deftest ebox-patch-set-promotes-interleaved-row-child-to-row-owner ()
|
|
"Interleaved row children should promote to their common render owner."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Left" :width 60))
|
|
(right (ebox-create :content "Right" :width 60))
|
|
(layout (ebox-row left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update left-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :owner-type) '(concat row)))
|
|
(should-not (eq (plist-get report :owner-type) 'box))))))
|
|
|
|
(ert-deftest ebox-viewport-resize-patches-single-dependent-box ()
|
|
"Viewport resize should patch the smallest dependent owner when possible."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-column
|
|
(ebox-create :content "Fixed" :width '(120) :border t)
|
|
(ebox-create :content "Fluid" :width 'stretch :border t)))
|
|
buffer
|
|
ids-before)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(setq ids-before (ebox-region-ids layout))
|
|
(let ((returned
|
|
(ebox-rerender-buffer-with-context buffer 260)))
|
|
(should (equal returned
|
|
(ebox-buffer-update-report buffer))))
|
|
(should (equal (ebox-region-ids layout) ids-before))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender root-rerender)))
|
|
(should (plist-get report :dirty-count))
|
|
(should (= (plist-get report :dirty-count) 1))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-report-describes-constraint-change ()
|
|
"Viewport resize reports should use the shared constraint-change model."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 240)
|
|
buffer
|
|
layout)
|
|
(setq layout
|
|
(ebox-flex :flex-wrap 'wrap
|
|
(ebox-create :content "A" :width '(120))
|
|
(ebox-create :content "B" :width '(120))))
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(ebox-rerender-buffer-with-context buffer 160)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'viewport))
|
|
(should (eq (plist-get report :constraint-owner-type)
|
|
'viewport))
|
|
(should (equal (plist-get report :constraint-owner-id)
|
|
'viewport))
|
|
(should (equal (plist-get report :constraint-root-node-id)
|
|
(plist-get layout :node-id)))
|
|
(should (equal (plist-get report :dirty-kinds)
|
|
'(geometry)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-patches-column-children-independently ()
|
|
"Column children should be independent owners when viewport resize rewraps them."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((top (ebox-create
|
|
:content "Top text should wrap into more lines when narrow."
|
|
:wrap-mode 'word))
|
|
(bottom (ebox-create
|
|
:content "Bottom text should also survive after top grows."
|
|
:wrap-mode 'word))
|
|
(layout (ebox-column top bottom))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 260))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 90)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(plain (with-current-buffer buffer
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(owner-rerender owner-rerender)))
|
|
(should (= (plist-get report :patch-count) 2))
|
|
(should-not (member (plist-get layout :node-id)
|
|
(plist-get report :owner-ids)))
|
|
(should (member (plist-get top :node-id)
|
|
(plist-get report :owner-ids)))
|
|
(should (member (plist-get bottom :node-id)
|
|
(plist-get report :owner-ids)))
|
|
(should (string-match-p "Top text" plain))
|
|
(should (string-match-p "Bottom text" plain))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-noops-without-viewport-deps ()
|
|
"Viewport resize should not rerender when no node depends on viewport width."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-create :content "Fixed" :width 80))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 160)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'no-op))
|
|
(should (= (plist-get report :dirty-count) 0))
|
|
(should (= (plist-get report :patch-count) 0))
|
|
(should-not (plist-get report :full-rerender))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-region-width-update-report-describes-constraint-change ()
|
|
"Ordinary box geometry updates should use the shared constraint-change model."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Left" :width 60))
|
|
(right (ebox-create :content "Right" :width 60))
|
|
(layout (ebox-row left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update left-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'region))
|
|
(should (eq (plist-get report :constraint-owner-type) 'box))
|
|
(should (equal (plist-get report :constraint-owner-id)
|
|
(plist-get left :node-id)))
|
|
(should (equal (plist-get report :dirty-kinds)
|
|
'(geometry)))))))
|
|
|
|
(ert-deftest ebox-root-region-width-reflow-invalidates-derived-indexes ()
|
|
"A root box width change should use viewport-equivalent index invalidation."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :width (240)
|
|
:content "ordinary root width")))
|
|
(root-id (car (ebox-region-ids layout)))
|
|
(snapshot-refreshes 0)
|
|
(extent-refreshes 0)
|
|
(region-enumerations 0)
|
|
(scroll-probes 0)
|
|
(visible-index-probes 0)
|
|
(scroll-state-syncs 0)
|
|
(generic-patch-plans 0)
|
|
(original-snapshots
|
|
(symbol-function 'ebox--refresh-buffer-layout-snapshots))
|
|
(original-extents
|
|
(symbol-function 'ebox--refresh-buffer-box-extents))
|
|
(original-region-ids
|
|
(symbol-function 'ebox--node-all-region-ids))
|
|
(original-lazy
|
|
(symbol-function 'ebox--try-lazy-scroll-deferred-patch))
|
|
(original-hidden
|
|
(symbol-function 'ebox--try-hidden-scroll-state-span-patch))
|
|
(original-hidden-root
|
|
(symbol-function 'ebox--try-hidden-scroll-root-fallback))
|
|
(original-scroll-state
|
|
(symbol-function 'ebox--try-scroll-state-span-patch))
|
|
(original-visible-indexes
|
|
(symbol-function 'ebox--ensure-visible-node-runtime-indexes))
|
|
(original-scroll-state-sync
|
|
(symbol-function 'ebox--sync-scroll-state-lines-for-node))
|
|
(original-patch-plan
|
|
(symbol-function 'ebox--patch-set-from-dirty-set)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(cl-letf (((symbol-function 'ebox--node-all-region-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf region-enumerations)
|
|
(apply original-region-ids args))))
|
|
(let ((change (ebox--region-constraint-change
|
|
(current-buffer) root-id 'geometry '(:width))))
|
|
(should-not (plist-get (car (plist-get change :dirty-set))
|
|
:region-ids))))
|
|
(should (= region-enumerations 0))
|
|
(cl-letf (((symbol-function 'ebox--refresh-buffer-layout-snapshots)
|
|
(lambda (&rest args)
|
|
(cl-incf snapshot-refreshes)
|
|
(apply original-snapshots args)))
|
|
((symbol-function 'ebox--refresh-buffer-box-extents)
|
|
(lambda (&rest args)
|
|
(cl-incf extent-refreshes)
|
|
(apply original-extents args)))
|
|
((symbol-function 'ebox--try-lazy-scroll-deferred-patch)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-probes)
|
|
(apply original-lazy args)))
|
|
((symbol-function 'ebox--try-hidden-scroll-state-span-patch)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-probes)
|
|
(apply original-hidden args)))
|
|
((symbol-function 'ebox--try-hidden-scroll-root-fallback)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-probes)
|
|
(apply original-hidden-root args)))
|
|
((symbol-function 'ebox--try-scroll-state-span-patch)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-probes)
|
|
(apply original-scroll-state args)))
|
|
((symbol-function 'ebox--ensure-visible-node-runtime-indexes)
|
|
(lambda (&rest args)
|
|
(cl-incf visible-index-probes)
|
|
(apply original-visible-indexes args)))
|
|
((symbol-function 'ebox--sync-scroll-state-lines-for-node)
|
|
(lambda (&rest args)
|
|
(cl-incf scroll-state-syncs)
|
|
(apply original-scroll-state-sync args)))
|
|
((symbol-function 'ebox--patch-set-from-dirty-set)
|
|
(lambda (&rest args)
|
|
(cl-incf generic-patch-plans)
|
|
(apply original-patch-plan args))))
|
|
(ebox-region-update root-id :width '(160)))
|
|
(should (= snapshot-refreshes 0))
|
|
(should (= extent-refreshes 0))
|
|
(should (= scroll-probes 0))
|
|
(should (= visible-index-probes 0))
|
|
(should (= scroll-state-syncs 0))
|
|
(should (= generic-patch-plans 0))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'region))
|
|
(should (eq (plist-get report :snapshot-refresh)
|
|
'invalidate-details))
|
|
(should (eq (plist-get report :index-refresh)
|
|
'invalidate-extents))))))
|
|
|
|
(ert-deftest ebox-root-region-width-reflow-rebinds-lazy-content-viewport ()
|
|
"A root width update should constrain lazy descendants like viewport resize."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240) :height (viewport-height)
|
|
:overflow scroll
|
|
(column
|
|
(box :content "first" :width (viewport))
|
|
(box :content "second" :width (viewport))
|
|
(box :content "third" :width (viewport))))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update root-id :width '(160))
|
|
(let ((widths
|
|
(mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines (buffer-string)))))
|
|
(should widths)
|
|
(should (= (apply #'max widths) 160))))))
|
|
|
|
(ert-deftest ebox-region-width-update-promotes-parent-layout-owner ()
|
|
"Child geometry changes should patch the parent layout that reflows siblings."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Left" :width 60))
|
|
(right (ebox-create :content "Right" :width 60))
|
|
(layout (ebox-row left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update left-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-owner-type) 'box))
|
|
(should (eq (plist-get report :owner-type) 'concat))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(owner-rerender))))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "Left" plain))
|
|
(should (string-match-p "Right" plain))))))
|
|
|
|
(ert-deftest ebox-wrapper-child-width-update-promotes-to-wrapper-context ()
|
|
"Child geometry inside a wrapper should promote to the wrapper formatting context."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(row
|
|
(box :content "Left" :width (60))
|
|
(box :content "Right" :width (60))))))
|
|
(ids (ebox-region-ids node))
|
|
(left-id (nth 1 ids)))
|
|
(ebox-test--with-rendered-buffer node
|
|
(ebox-region-update left-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'region))
|
|
(should (memq 'owner-rerender (plist-get report :patch-ops))))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "Left" plain))
|
|
(should (string-match-p "Right" plain))))))
|
|
|
|
(ert-deftest ebox-patch-set-uses-wrapper-owner-for-contained-layout-change ()
|
|
"Contained layout changes should patch a real owner instead of vanishing."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column
|
|
(box :content "Stable header" :width (180))
|
|
(column :padding 1
|
|
(box :content "Child text wraps under the wrapper viewport"
|
|
:wrap-mode word)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(let ((ebox-viewport-width 520))
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(ebox-rerender-buffer-with-context buffer 36)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(owner-rerender root-rerender)))
|
|
(should (plist-get report :owner-ids))
|
|
(should-not (equal (plist-get report :patch-ops)
|
|
'(paint-patch)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-patch-set-skips-dirty-nodes-covered-by-owner ()
|
|
"Viewport patch planning should not repeatedly inspect covered dirty nodes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (apply
|
|
#'ebox-row
|
|
(cl-loop for index below 24
|
|
collect
|
|
(ebox-create
|
|
:content (format "Fluid %02d" index)
|
|
:border t))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 640))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(detail-calls 0)
|
|
(original
|
|
(symbol-function 'ebox--ensure-layout-snapshot-details))
|
|
patches)
|
|
(should (> (length dirty) 10))
|
|
(cl-letf (((symbol-function
|
|
'ebox--ensure-layout-snapshot-details)
|
|
(lambda (&rest args)
|
|
(cl-incf detail-calls)
|
|
(apply original args))))
|
|
(setq patches
|
|
(ebox--patch-set-from-dirty-set dirty buffer)))
|
|
(should (= (length patches) 1))
|
|
(should (eq (plist-get (car patches) :op)
|
|
'owner-rerender))
|
|
(should (<= detail-calls 4))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-patch-set-coalesces-large-column-coverage ()
|
|
"Large local owner sets should coalesce when they cover most root lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (apply
|
|
#'ebox-column
|
|
(cl-loop for index below 12
|
|
collect
|
|
(ebox-create
|
|
:content (format "Fluid section %02d" index)
|
|
:border t))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 640))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(patches (ebox--patch-set-from-dirty-set dirty buffer))
|
|
(source-ids
|
|
(ebox--dirty-provenance-node-ids
|
|
(plist-get (car patches) :dirty))))
|
|
(should (> (length dirty) 8))
|
|
(should (= (length patches) 1))
|
|
(should (equal (plist-get (car patches) :owner-id)
|
|
(plist-get layout :node-id)))
|
|
(should (= (length source-ids) (length dirty)))
|
|
(dolist (entry dirty)
|
|
(should (member (plist-get entry :node-id) source-ids)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-coalesces-large-dirty-set-before-promotion ()
|
|
"Large viewport dirty sets should choose root before local owner promotion."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (apply
|
|
#'ebox-column
|
|
(cl-loop for index below 12
|
|
collect
|
|
(ebox-create
|
|
:content (format "Fluid section %02d" index)
|
|
:border t))))
|
|
(promote-count 0)
|
|
(dirty-entry-count 0)
|
|
(original (symbol-function 'ebox--promote-to-patchable-owner))
|
|
(original-dirty-entry (symbol-function 'ebox--dirty-entry))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 640))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(patches (ebox--root-owner-patch-set buffer dirty))
|
|
(source-ids
|
|
(ebox--dirty-provenance-node-ids
|
|
(plist-get (car patches) :dirty))))
|
|
(should (> (length dirty) 8))
|
|
(should (= (length source-ids) (length dirty)))
|
|
(dolist (entry dirty)
|
|
(should (member (plist-get entry :node-id) source-ids))))
|
|
(cl-letf (((symbol-function 'ebox--promote-to-patchable-owner)
|
|
(lambda (&rest args)
|
|
(cl-incf promote-count)
|
|
(apply original args)))
|
|
((symbol-function 'ebox--dirty-entry)
|
|
(lambda (&rest args)
|
|
(cl-incf dirty-entry-count)
|
|
(apply original-dirty-entry args))))
|
|
(ebox-rerender-buffer-with-context buffer 320))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (= promote-count 0))
|
|
(should (= dirty-entry-count 1))
|
|
(should (= (plist-get report :dirty-count) 1))
|
|
(should (= (plist-get report :patch-count) 1))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list (plist-get layout :node-id))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-root-owner-allows-line-count-change ()
|
|
"Root owner rerender should patch even when viewport wrapping changes height."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content
|
|
"alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu")
|
|
(layout (apply
|
|
#'ebox-column
|
|
(cl-loop for _index below 12
|
|
collect
|
|
(ebox-create
|
|
:content content
|
|
:width 'viewport
|
|
:wrap-mode 'word
|
|
:border t))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 120))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let ((wide-height (with-current-buffer buffer
|
|
(count-lines (point-min) (point-max)))))
|
|
(ebox-rerender-buffer-with-context buffer 20)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(narrow-height (with-current-buffer buffer
|
|
(count-lines (point-min) (point-max)))))
|
|
(should (> narrow-height wide-height))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (plist-get report :root-rerender)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-owner-rerender-skips-partial-slot-probe ()
|
|
"Whole-line root owner rerenders should not run partial-slot probing."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content
|
|
"alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu")
|
|
(layout (apply
|
|
#'ebox-column
|
|
(cl-loop for _index below 12
|
|
collect
|
|
(ebox-create
|
|
:content content
|
|
:width 'viewport
|
|
:wrap-mode 'word
|
|
:border t))))
|
|
(slot-probe-count 0)
|
|
(original (symbol-function 'ebox-buffer--rendered-in-existing-slots))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 120))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(cl-letf (((symbol-function 'ebox-buffer--rendered-in-existing-slots)
|
|
(lambda (&rest args)
|
|
(cl-incf slot-probe-count)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 20))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list (plist-get layout :node-id)))))
|
|
(should (= slot-probe-count 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-owner-rerender-renders-in-target-buffer ()
|
|
"Owner rerender should compute display signatures in the target buffer."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (let ((ebox-viewport-width 240))
|
|
(ebox-build
|
|
'(box :content "Viewport text wraps inside the target buffer"
|
|
:width (viewport)
|
|
:wrap-mode word))))
|
|
(buffer nil)
|
|
(other nil)
|
|
(render-buffers nil)
|
|
(original (symbol-function 'ebox-render)))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(setq other (generate-new-buffer " *ebox-other*"))
|
|
(with-current-buffer other
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest args)
|
|
(push (current-buffer) render-buffers)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 120)))
|
|
(should render-buffers)
|
|
(should (cl-every (lambda (seen-buffer)
|
|
(eq seen-buffer buffer))
|
|
render-buffers)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))
|
|
(when (and other (buffer-live-p other))
|
|
(kill-buffer other)))))
|
|
|
|
(ert-deftest ebox-buffer-render-context-selects-target-buffer ()
|
|
"Buffer render contexts should evaluate render-sensitive work in target buffers."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-create :content "context target"))
|
|
(buffer nil)
|
|
(other nil)
|
|
seen-buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node))
|
|
(setq other (generate-new-buffer " *ebox-other*"))
|
|
(with-current-buffer other
|
|
(ebox--with-buffer-render-context buffer
|
|
(setq seen-buffer (current-buffer))))
|
|
(should (eq seen-buffer buffer)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))
|
|
(when (and other (buffer-live-p other))
|
|
(kill-buffer other)))))
|
|
|
|
(ert-deftest ebox-buffer-render-context-preserves-caller-state-binding ()
|
|
"Render context internals should not capture a caller's STATE variable."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-create :content "context state"))
|
|
(buffer nil)
|
|
(state 'caller-scroll-state)
|
|
seen-state)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") node))
|
|
(ebox--with-buffer-render-context buffer
|
|
(setq seen-state state))
|
|
(should (eq seen-state 'caller-scroll-state)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-incremental-rerender-uses-render-gc-threshold ()
|
|
"Incremental rerenders should run inside the Ebox render GC threshold."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content
|
|
"alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu")
|
|
(layout (ebox-create
|
|
:content content
|
|
:width 'viewport
|
|
:wrap-mode 'word))
|
|
(target-threshold (+ gc-cons-threshold 1000000))
|
|
(observed-threshold nil)
|
|
(original (symbol-function 'ebox--execute-patch-set))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 120))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let ((ebox-render-gc-cons-threshold target-threshold))
|
|
(cl-letf (((symbol-function 'ebox--execute-patch-set)
|
|
(lambda (&rest args)
|
|
(setq observed-threshold gc-cons-threshold)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 20)))
|
|
(should observed-threshold)
|
|
(should (>= observed-threshold target-threshold)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-deferred-render-gc-uses-interactive-burst-threshold ()
|
|
"Interactive render bursts should stay bounded and collect when settled."
|
|
(let ((gc-cons-threshold 1000)
|
|
(gc-cons-percentage 0.1)
|
|
(ebox-deferred-render-gc-cons-threshold 2000)
|
|
(ebox-render-gc-cons-percentage 0.6)
|
|
(ebox--deferred-render-gc-state nil)
|
|
(ebox--deferred-render-gc-timer nil)
|
|
(gc-count 0))
|
|
(unwind-protect
|
|
(cl-letf (((symbol-function 'garbage-collect)
|
|
(lambda () (cl-incf gc-count))))
|
|
(ebox--deferred-render-gc-enter)
|
|
(should (= gc-cons-threshold 2000))
|
|
(should (= gc-cons-percentage 0.6))
|
|
(ebox--deferred-render-gc-restore)
|
|
(should (= gc-cons-threshold 1000))
|
|
(should (= gc-cons-percentage 0.1))
|
|
(should (= gc-count 1))
|
|
(ebox--deferred-render-gc-restore)
|
|
(should (= gc-count 1)))
|
|
(when (timerp ebox--deferred-render-gc-timer)
|
|
(cancel-timer ebox--deferred-render-gc-timer)))))
|
|
|
|
(ert-deftest ebox-deferred-render-gc-keeps-overlapping-burst-owned ()
|
|
"A nested idle slice must not restore GC during an active animation."
|
|
(let ((gc-cons-threshold 1000)
|
|
(gc-cons-percentage 0.1)
|
|
(ebox-deferred-render-gc-cons-threshold 4000)
|
|
(ebox--deferred-render-gc-state nil)
|
|
(ebox--deferred-render-gc-timer nil)
|
|
(ebox--deferred-render-gc-depth 0)
|
|
scheduled)
|
|
(cl-letf (((symbol-function 'run-at-time)
|
|
(lambda (&rest _)
|
|
(setq scheduled 'restore-timer)))
|
|
((symbol-function 'timerp)
|
|
(lambda (value) (eq value 'restore-timer))))
|
|
(ebox--deferred-render-gc-enter)
|
|
(ebox--deferred-render-gc-enter)
|
|
(should (= ebox--deferred-render-gc-depth 2))
|
|
(ebox--deferred-render-gc-schedule-restore)
|
|
(should (= ebox--deferred-render-gc-depth 1))
|
|
(should-not scheduled)
|
|
(should (= gc-cons-threshold 4000))
|
|
(ebox--deferred-render-gc-schedule-restore)
|
|
(should (eq scheduled 'restore-timer))
|
|
(should (= ebox--deferred-render-gc-depth 0))
|
|
(should (= gc-cons-threshold 4000)))))
|
|
|
|
(ert-deftest ebox-deferred-render-gc-default-is-memory-bounded ()
|
|
"The interactive burst default should scale within finite memory bounds."
|
|
(should (eq ebox-deferred-render-gc-cons-threshold 'auto))
|
|
(let ((gc-cons-threshold (* 512 1024 1024))
|
|
(gc-cons-percentage 0.1)
|
|
(ebox--physical-memory-bytes (* 16 1024 1024 1024))
|
|
(ebox--deferred-render-gc-state nil)
|
|
(ebox--deferred-render-gc-timer nil))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--deferred-render-gc-enter)
|
|
(should (= gc-cons-threshold (* 512 1024 1024))))
|
|
(ebox--deferred-render-gc-restore))))
|
|
|
|
(ert-deftest ebox-deferred-render-gc-can-raise-an-active-burst-budget ()
|
|
"Measured layout pressure should only raise an active burst budget."
|
|
(let ((gc-cons-threshold 1000)
|
|
(ebox--deferred-render-gc-state nil))
|
|
(ebox--deferred-render-gc-raise-threshold 4000)
|
|
(should (= gc-cons-threshold 1000))
|
|
(setq ebox--deferred-render-gc-state
|
|
'(:gc-cons-threshold 1000 :gc-cons-percentage 0.1))
|
|
(ebox--deferred-render-gc-raise-threshold 4000)
|
|
(should (= gc-cons-threshold 4000))
|
|
(ebox--deferred-render-gc-raise-threshold 2000)
|
|
(should (= gc-cons-threshold 4000))
|
|
(ebox--deferred-render-gc-raise-threshold nil)
|
|
(should (= gc-cons-threshold 4000))))
|
|
|
|
(ert-deftest ebox-deferred-render-gc-can-bound-an-active-burst-budget ()
|
|
"A specialized burst may lower its raised budget but not the saved setting."
|
|
(let ((gc-cons-threshold 5000)
|
|
(ebox--deferred-render-gc-state nil))
|
|
(ebox--deferred-render-gc-set-threshold 3000)
|
|
(should (= gc-cons-threshold 5000))
|
|
(setq ebox--deferred-render-gc-state
|
|
'(:gc-cons-threshold 1000 :gc-cons-percentage 0.1))
|
|
(ebox--deferred-render-gc-set-threshold 3000)
|
|
(should (= gc-cons-threshold 3000))
|
|
(ebox--deferred-render-gc-set-threshold 500)
|
|
(should (= gc-cons-threshold 1000))
|
|
(ebox--deferred-render-gc-set-threshold nil)
|
|
(should (= gc-cons-threshold 1000))))
|
|
|
|
(ert-deftest ebox-visible-root-width-reflows-defer-gc-only-for-root ()
|
|
"Visible root width reflows should defer GC without affecting local updates."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :id "child" :content "responsive child"))))
|
|
(buffer nil)
|
|
root-id child-id
|
|
(enter-count 0)
|
|
(restore-count 0))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout)))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(setq child-id (ebox-test--selector-region-id buffer "#child"))
|
|
(cl-letf (((symbol-function
|
|
'ebox--buffer-visible-in-graphic-frame-p)
|
|
(lambda (_buffer) t))
|
|
((symbol-function 'ebox--deferred-render-gc-enter)
|
|
(lambda () (cl-incf enter-count)))
|
|
((symbol-function
|
|
'ebox--deferred-render-gc-schedule-restore)
|
|
(lambda () (cl-incf restore-count))))
|
|
(ebox-rerender-buffer-with-context buffer 160)
|
|
(should (= enter-count 1))
|
|
(should (= restore-count 1))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update child-id :bgcolor "#223344"))
|
|
(should (= enter-count 1))
|
|
(should (= restore-count 1))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :width 180))
|
|
(should (= enter-count 2))
|
|
(should (= restore-count 2))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-patch-planning-skips-line-signatures ()
|
|
"Owner rerender planning should not compute expensive line signatures."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-column
|
|
(cl-loop for section below 8
|
|
collect
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:row-gap 1
|
|
:column-gap '(8)
|
|
(cl-loop for index below 4
|
|
collect
|
|
(ebox-create
|
|
:content (format "S%d-%d" section index)
|
|
:width 80
|
|
:height 1))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 360))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(line-signature-count 0)
|
|
(original (symbol-function 'ebox--spans-line-signature)))
|
|
(should dirty)
|
|
(cl-letf (((symbol-function 'ebox--spans-line-signature)
|
|
(lambda (&rest args)
|
|
(cl-incf line-signature-count)
|
|
(apply original args))))
|
|
(ebox--patch-set-from-dirty-set dirty buffer))
|
|
(should (= line-signature-count 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-patch-planning-builds-one-shared-line-index ()
|
|
"Multiple owner rerender planning should share one buffer line index."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-column
|
|
(cl-loop for section below 8
|
|
collect
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:row-gap 1
|
|
:column-gap '(8)
|
|
(cl-loop for index below 4
|
|
collect
|
|
(ebox-create
|
|
:content (format "S%d-%d" section index)
|
|
:width 80
|
|
:height 1))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 360))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(index-build-count 0)
|
|
(original (symbol-function 'ebox--build-region-line-index)))
|
|
(should dirty)
|
|
(cl-letf (((symbol-function 'ebox--build-region-line-index)
|
|
(lambda (&rest args)
|
|
(cl-incf index-build-count)
|
|
(apply original args))))
|
|
(ebox--patch-set-from-dirty-set dirty buffer))
|
|
(should (= index-build-count 1))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-single-geometry-planning-skips-full-line-index-without-role-table ()
|
|
"Single geometry updates should not build a full line index after role table invalidation."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id "root" :width (480)
|
|
(box :id "target" :content "mixed padding"
|
|
:width (220) :height 3 :box-sizing border-box
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "peer" :width (220) :height 3
|
|
:border "#999999"))))
|
|
(index-build-count 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(original (symbol-function 'ebox--build-region-line-index)))
|
|
(ebox--set-buffer-region-role-span-table (current-buffer) nil)
|
|
(cl-letf (((symbol-function 'ebox--build-region-line-index)
|
|
(lambda (&rest args)
|
|
(cl-incf index-build-count)
|
|
(apply original args))))
|
|
(ebox-region-update region-id :padding (list 1 '(18) 1 '(18))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scoped-index-refresh))
|
|
(should (= index-build-count 0))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-region-set-line-spans-fallback-uses-live-extents ()
|
|
"Fallback span planning should scan only live extents when indexes are missing."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((before (cl-loop for index below 80
|
|
collect `(box :content ,(format "before %02d" index)
|
|
:height 1)))
|
|
(after (cl-loop for index below 80
|
|
collect `(box :content ,(format "after %02d" index)
|
|
:height 1)))
|
|
(layout
|
|
(ebox-build
|
|
`(column :id "root" :width (480)
|
|
,@before
|
|
(box :id "target" :content "target"
|
|
:width (220) :height 1 :box-sizing border-box
|
|
:padding (0 (8)) :border "#999999")
|
|
,@after)))
|
|
(outside-scan-count 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(extents (ebox--live-box-extents region-id))
|
|
range-start
|
|
range-end
|
|
(original (symbol-function 'ebox--pos-region-ids)))
|
|
(should extents)
|
|
(save-excursion
|
|
(goto-char (marker-position (car extents)))
|
|
(setq range-start (line-beginning-position))
|
|
(goto-char (max (point-min)
|
|
(1- (marker-position (cdr extents)))))
|
|
(setq range-end (line-end-position)))
|
|
(ebox--set-buffer-region-role-span-table (current-buffer) nil)
|
|
(cl-letf (((symbol-function 'ebox--pos-region-ids)
|
|
(lambda (pos)
|
|
(unless (and (>= pos range-start)
|
|
(< pos range-end))
|
|
(cl-incf outside-scan-count))
|
|
(funcall original pos))))
|
|
(ebox--region-set-line-spans (list region-id)))
|
|
(should (= outside-scan-count 0))))))
|
|
|
|
(ert-deftest ebox-box-extents-register-from-property-segments ()
|
|
"Box extent registration should avoid per-character region-id scans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Segment extent"
|
|
:padding '(0 (8))
|
|
:border t))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(with-temp-buffer
|
|
(insert (ebox-render box))
|
|
(let ((ebox--box-extents-segment-scan-min-chars 0))
|
|
(cl-letf (((symbol-function 'ebox--pos-region-ids)
|
|
(lambda (&rest _args)
|
|
(error "unexpected per-character region scan"))))
|
|
(ebox--register-box-extents-in-range (point-min) (point-max))))
|
|
(should (ebox--live-box-extents region-id)))))
|
|
|
|
(ert-deftest ebox-box-extents-small-range-uses-position-scan ()
|
|
"Small extent refreshes should avoid segment scan overhead."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Small extent"
|
|
:border t))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(with-temp-buffer
|
|
(insert (ebox-render box))
|
|
(let ((ebox--box-extents-segment-scan-min-chars most-positive-fixnum))
|
|
(cl-letf (((symbol-function 'ebox--region-property-segments-in-range)
|
|
(lambda (&rest _args)
|
|
(error "unexpected segment scan"))))
|
|
(ebox--register-box-extents-in-range (point-min) (point-max))))
|
|
(should (ebox--live-box-extents region-id)))))
|
|
|
|
(ert-deftest ebox-foreign-region-range-scan-ignores-newline-only-ownership ()
|
|
"Foreign ownership on separator newlines should not interleave extents."
|
|
(with-temp-buffer
|
|
(insert (propertize "\n" 'ebox-content 'foreign))
|
|
(should-not
|
|
(ebox--foreign-region-in-range-p (point-min) (point-max) 'owner))))
|
|
|
|
(ert-deftest ebox-foreign-region-range-scan-checks-visible-text-after-newline ()
|
|
"Interval skipping should still detect visible foreign text after newlines."
|
|
(with-temp-buffer
|
|
(insert (propertize "\nvisible" 'ebox-content 'foreign))
|
|
(should
|
|
(ebox--foreign-region-in-range-p (point-min) (point-max) 'owner))))
|
|
|
|
(ert-deftest ebox-scoped-box-extent-refresh-preserves-ancestor-extents ()
|
|
"Scoped index refresh should not shrink an ancestor to its child span."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let ((root-id 'extent-root)
|
|
(child-id 'extent-child)
|
|
child-span)
|
|
(insert (propertize "root-before\n"
|
|
'ebox-content-owners (list root-id)))
|
|
(let ((start (point)))
|
|
(insert (propertize "child\n"
|
|
'ebox-content child-id
|
|
'ebox-content-owners
|
|
(list child-id root-id)))
|
|
(setq child-span (cons start (point))))
|
|
(insert (propertize "root-after\n"
|
|
'ebox-content-owners (list root-id)))
|
|
;; Exercise both the short position scan and the long-range segment
|
|
;; scan. Both still inspect every owner for interleaving; the allow-set
|
|
;; restricts only which extent records may be published.
|
|
(dolist (threshold (list most-positive-fixnum 0))
|
|
(let ((ebox--box-extents-segment-scan-min-chars threshold))
|
|
(ebox--clear-buffer-extents (current-buffer))
|
|
(ebox--set-box-extents root-id (point-min) (point-max))
|
|
(ebox--set-box-extents child-id
|
|
(car child-span) (cdr child-span))
|
|
(let* ((root-extents (gethash root-id ebox--box-extents))
|
|
(root-span
|
|
(cons (marker-position (car root-extents))
|
|
(marker-position (cdr root-extents)))))
|
|
(ebox--refresh-box-extents-for-region-ids-in-spans
|
|
(list child-id) (list child-span))
|
|
(should (eq root-extents
|
|
(gethash root-id ebox--box-extents)))
|
|
(should (equal root-span
|
|
(cons
|
|
(marker-position (car root-extents))
|
|
(marker-position (cdr root-extents)))))
|
|
(let ((refreshed-child
|
|
(gethash child-id ebox--box-extents)))
|
|
(should refreshed-child)
|
|
(should (equal child-span
|
|
(cons
|
|
(marker-position (car refreshed-child))
|
|
(marker-position
|
|
(cdr refreshed-child))))))))))))
|
|
|
|
(ert-deftest ebox-scoped-role-refresh-records-wrapper-only-active-segment ()
|
|
"Rendered scoped refresh should rebuild visible wrapper-only extents."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((wrapper-id 'wrapper-only)
|
|
(rendered
|
|
(propertize "owned" 'ebox-content-owners (list wrapper-id))))
|
|
(insert rendered)
|
|
(let ((spans (list (cons (point-min) (point-max)))))
|
|
(puthash (current-buffer)
|
|
(list :region-role-span-table
|
|
(make-hash-table :test 'equal))
|
|
ebox--buffer-render-state-table)
|
|
(let* ((refresh
|
|
(ebox-buffer-refresh-region-role-spans-for-region-ids
|
|
(current-buffer) (list wrapper-id) spans nil
|
|
(list (cons rendered spans))))
|
|
(active-segments (plist-get refresh :active-segments))
|
|
(segments (gethash wrapper-id active-segments)))
|
|
(should segments)
|
|
(should
|
|
(equal (sort (copy-sequence segments)
|
|
(lambda (left right) (< (car left) (car right))))
|
|
spans))
|
|
(ebox--refresh-box-extents-from-role-spans
|
|
(list wrapper-id) spans active-segments)
|
|
(let ((extents (gethash wrapper-id ebox--box-extents)))
|
|
(should extents)
|
|
(should
|
|
(equal (cons (marker-position (car extents))
|
|
(marker-position (cdr extents)))
|
|
(car spans)))))))))
|
|
|
|
(ert-deftest
|
|
ebox-scoped-role-refresh-keeps-wrapper-only-interleaved-omitted ()
|
|
"Active wrapper-only segments should still omit interleaved extents."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((wrapper-id 'interleaved-wrapper)
|
|
(foreign-id 'foreign-child)
|
|
(rendered
|
|
(concat
|
|
(propertize "aa" 'ebox-content-owners (list wrapper-id))
|
|
(propertize "X" 'ebox-content foreign-id)
|
|
(propertize "bb" 'ebox-content-owners (list wrapper-id)))))
|
|
(insert rendered)
|
|
(let ((spans (list (cons (point-min) (point-max)))))
|
|
(puthash (current-buffer)
|
|
(list :region-role-span-table
|
|
(make-hash-table :test 'equal))
|
|
ebox--buffer-render-state-table)
|
|
(let* ((refresh
|
|
(ebox-buffer-refresh-region-role-spans-for-region-ids
|
|
(current-buffer) (list wrapper-id) spans nil
|
|
(list (cons rendered spans))))
|
|
(active-segments (plist-get refresh :active-segments)))
|
|
(should (= (length (gethash wrapper-id active-segments)) 2))
|
|
(ebox--refresh-box-extents-from-role-spans
|
|
(list wrapper-id) spans active-segments)
|
|
(should-not (gethash wrapper-id ebox--box-extents)))))))
|
|
|
|
(ert-deftest ebox-scoped-runtime-index-refresh-clears-empty-active-extents ()
|
|
"Scoped refresh should clear broad ids even when no active segment remains."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(insert "stale")
|
|
(let ((stale-id 'stale-owner)
|
|
(active-segments (make-hash-table :test 'equal)))
|
|
(puthash (current-buffer)
|
|
(list :region-role-span-table
|
|
(make-hash-table :test 'equal))
|
|
ebox--buffer-render-state-table)
|
|
(ebox--set-box-extents stale-id (point-min) (point-max))
|
|
(cl-letf (((symbol-function
|
|
'ebox-buffer-refresh-region-role-spans-for-region-ids)
|
|
(lambda (&rest _args)
|
|
(list :active-segments active-segments))))
|
|
(ebox--refresh-runtime-indexes-for-patch-results
|
|
(current-buffer) nil 'span-patch nil
|
|
(list :region-ids (list stale-id)
|
|
:new-spans (list (cons (point-min) (point-max)))
|
|
:old-spans nil
|
|
:removed-region-ids nil)))
|
|
(should-not (gethash stale-id ebox--box-extents)))))
|
|
|
|
(ert-deftest ebox-scoped-role-span-refresh-rebuilds-on-translation-failure ()
|
|
"Ambiguous scoped refresh should rebuild a legacy integer role-span table."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id "root" :width (480)
|
|
(box :id "target" :content "target" :width (220)
|
|
:height 1 :border "#999999")
|
|
(box :id "peer" :content "peer" :width (220)
|
|
:height 1 :border "#999999")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(peer-id (ebox-test--selector-region-id (current-buffer)
|
|
"#peer"))
|
|
(target-spans
|
|
(gethash (ebox-buffer--region-role-key target-id 'content)
|
|
(ebox-buffer--region-role-span-table)))
|
|
(peer-key (ebox-buffer--region-role-key peer-id 'content))
|
|
(legacy-table (make-hash-table :test 'equal))
|
|
(rebuild-count 0)
|
|
(original (symbol-function
|
|
'ebox-buffer--build-region-role-span-table)))
|
|
(should target-spans)
|
|
(should (gethash peer-key (ebox-buffer--region-role-span-table)))
|
|
(maphash
|
|
(lambda (key spans)
|
|
(when (consp key)
|
|
(puthash key
|
|
(mapcar (lambda (span)
|
|
(cons (marker-position (car span))
|
|
(marker-position (cdr span))))
|
|
spans)
|
|
legacy-table)))
|
|
(ebox-buffer--region-role-span-table))
|
|
(ebox--set-buffer-region-role-span-table
|
|
(current-buffer) legacy-table)
|
|
(cl-letf (((symbol-function 'ebox-buffer--build-region-role-span-table)
|
|
(lambda (&rest args)
|
|
(cl-incf rebuild-count)
|
|
(apply original args))))
|
|
(ebox-buffer-refresh-region-role-spans-for-region-ids
|
|
(current-buffer)
|
|
(list target-id)
|
|
target-spans
|
|
(append target-spans target-spans)))
|
|
(should (= rebuild-count 1))
|
|
(should (ebox-buffer--region-role-span-table))
|
|
(should (gethash peer-key (ebox-buffer--region-role-span-table)))))))
|
|
|
|
(ert-deftest ebox-role-span-translation-keeps-left-adjacent-half-open-span ()
|
|
"A role span ending at replacement start stays on its untouched left side."
|
|
(let ((replacements
|
|
'((:old-start 20 :old-end 30
|
|
:new-start 20 :new-end 24 :delta -6))))
|
|
(should
|
|
(equal (ebox-buffer--translate-role-span-through-replacements
|
|
'(10 . 20) replacements)
|
|
'(10 . 20)))
|
|
(should-not
|
|
(ebox-buffer--translate-role-span-through-replacements
|
|
'(20 . 25) replacements))
|
|
(should-not
|
|
(ebox-buffer--translate-role-span-through-replacements
|
|
'(15 . 30) replacements))))
|
|
|
|
(ert-deftest ebox-role-span-translation-index-preserves-enclosing-deltas ()
|
|
"Indexed translation should preserve spans enclosing multiple replacements."
|
|
(let ((replacements
|
|
'((:old-start 20 :old-end 30
|
|
:new-start 20 :new-end 24 :delta -6)
|
|
(:old-start 50 :old-end 55
|
|
:new-start 44 :new-end 57 :delta 8))))
|
|
(should
|
|
(equal (ebox-buffer--translate-role-span-through-replacements
|
|
'(10 . 70) replacements)
|
|
'(10 . 72)))
|
|
(should
|
|
(equal (ebox-buffer--translate-role-span-through-replacements
|
|
'(30 . 50) replacements)
|
|
'(24 . 44)))
|
|
(should-not
|
|
(ebox-buffer--translate-role-span-through-replacements
|
|
'(30 . 55) replacements))))
|
|
|
|
(ert-deftest ebox-marker-role-span-refresh-skips-table-translation ()
|
|
"Marker-backed role-span tables should not translate every stored span."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id "root" :width (480)
|
|
(box :id "target" :content "target" :width (220)
|
|
:height 1 :border "#999999")
|
|
(box :id "peer" :content "peer" :width (220)
|
|
:height 1 :border "#999999")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(peer-id (ebox-test--selector-region-id (current-buffer)
|
|
"#peer"))
|
|
(target-spans
|
|
(gethash (ebox-buffer--region-role-key target-id 'content)
|
|
(ebox-buffer--region-role-span-table)))
|
|
(peer-key (ebox-buffer--region-role-key peer-id 'content))
|
|
(translate-count 0)
|
|
(rebuild-count 0))
|
|
(should target-spans)
|
|
(should (markerp (caar target-spans)))
|
|
(cl-letf (((symbol-function
|
|
'ebox-buffer--translate-region-role-span-table)
|
|
(lambda (&rest _args)
|
|
(cl-incf translate-count)
|
|
(error "marker-backed table should not translate")))
|
|
((symbol-function 'ebox-buffer--build-region-role-span-table)
|
|
(lambda (&rest _args)
|
|
(cl-incf rebuild-count)
|
|
(error "marker-backed table should not rebuild"))))
|
|
(ebox-buffer-refresh-region-role-spans-for-region-ids
|
|
(current-buffer)
|
|
(list target-id)
|
|
target-spans
|
|
(append target-spans target-spans)))
|
|
(should (= translate-count 0))
|
|
(should (= rebuild-count 0))
|
|
(should (gethash peer-key (ebox-buffer--region-role-span-table)))))))
|
|
|
|
(ert-deftest ebox-scoped-role-span-refresh-translates-enclosing-owner-spans ()
|
|
"Scoped role-span refresh should keep enclosing owner spans without rebuilding."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id "root" :width (480)
|
|
(box :id "target" :content "target" :width (220)
|
|
:height 1 :border "#999999")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((root-id (ebox-test--selector-region-id (current-buffer)
|
|
"#root"))
|
|
(target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(target-spans
|
|
(gethash (ebox-buffer--region-role-key target-id 'content)
|
|
(ebox-buffer--region-role-span-table)))
|
|
(root-owner-key
|
|
(ebox-buffer--region-role-key root-id 'content-owner))
|
|
(root-owner-spans
|
|
(gethash root-owner-key
|
|
(ebox-buffer--region-role-span-table)))
|
|
(rebuild-count 0)
|
|
(original (symbol-function
|
|
'ebox-buffer--build-region-role-span-table)))
|
|
(should target-spans)
|
|
(should root-owner-spans)
|
|
(cl-letf (((symbol-function 'ebox-buffer--build-region-role-span-table)
|
|
(lambda (&rest args)
|
|
(cl-incf rebuild-count)
|
|
(apply original args))))
|
|
(ebox-buffer-refresh-region-role-spans-for-region-ids
|
|
(current-buffer)
|
|
(list target-id)
|
|
target-spans
|
|
target-spans))
|
|
(should (= rebuild-count 0))
|
|
(should (equal root-owner-spans
|
|
(gethash root-owner-key
|
|
(ebox-buffer--region-role-span-table))))))))
|
|
|
|
(ert-deftest ebox-viewport-root-owner-spans-skip-region-scan ()
|
|
"Root owner spans should use full buffer lines, not region-property scans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-row
|
|
(cl-loop for section below 8
|
|
collect
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:row-gap 1
|
|
:column-gap '(8)
|
|
(cl-loop for index below 4
|
|
collect
|
|
(ebox-create
|
|
:content (format "S%d-%d" section index)
|
|
:width 80
|
|
:height 1))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 360))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(dirty (ebox--viewport-dirty-set root))
|
|
(region-scan-count 0)
|
|
(original (symbol-function 'ebox--region-set-line-spans)))
|
|
(should dirty)
|
|
(cl-letf (((symbol-function 'ebox--region-set-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf region-scan-count)
|
|
(apply original args))))
|
|
(ebox--patch-set-from-dirty-set dirty buffer))
|
|
(should (= region-scan-count 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-reuses-static-flex-item-renders ()
|
|
"Static flex item renders should be reused across viewport rerenders."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-wrap 'wrap
|
|
(cl-loop for index below 12
|
|
collect
|
|
(ebox-create
|
|
:content (format "Item %02d" index)
|
|
:width 80
|
|
:height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 420))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 360)
|
|
(let ((box-render-count 0)
|
|
(original (symbol-function 'ebox--render-box)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf box-render-count)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 500))
|
|
(should (<= box-render-count 3))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-reuses-sized-flex-item-renders ()
|
|
"Flex item renders with stable computed sizes should be reused."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-wrap 'wrap
|
|
:height 4
|
|
:align-items 'stretch
|
|
(cl-loop for index below 10
|
|
collect
|
|
(ebox-create
|
|
:content (format "Stretch %02d" index)
|
|
:width 80))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 420))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 360)
|
|
(let ((box-render-count 0)
|
|
(original (symbol-function 'ebox--render-box)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (&rest args)
|
|
(cl-incf box-render-count)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 500))
|
|
(should (<= box-render-count 6))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-reuses-flex-item-measurements ()
|
|
"Stable flex item intrinsic measurements should be reused across resizes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-wrap 'wrap
|
|
(cl-loop for index below 12
|
|
collect
|
|
(ebox-create
|
|
:content (format "Measured %02d" index)
|
|
:width 80
|
|
:height 1))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 420))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 360)
|
|
(let ((main-count 0)
|
|
(min-count 0)
|
|
(original-main (symbol-function 'ebox--flex-string-main))
|
|
(original-min (symbol-function 'ebox--content-min-pixel)))
|
|
(cl-letf (((symbol-function 'ebox--flex-string-main)
|
|
(lambda (&rest args)
|
|
(cl-incf main-count)
|
|
(apply original-main args)))
|
|
((symbol-function 'ebox--content-min-pixel)
|
|
(lambda (&rest args)
|
|
(cl-incf min-count)
|
|
(apply original-min args))))
|
|
(ebox-rerender-buffer-with-context buffer 500))
|
|
(should (<= main-count 3))
|
|
(should (<= min-count 3))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-reuses-static-composite-subtrees ()
|
|
"Viewport-dependent flex sections should reuse static composite item sources."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((inner-flexes
|
|
(cl-loop for index below 6
|
|
collect
|
|
(ebox-flex
|
|
:width 180 :height 3
|
|
:flex-flow '(row wrap)
|
|
:column-gap '(8)
|
|
(ebox-create
|
|
:content (format "A%d" index)
|
|
:width 48 :height 1)
|
|
(ebox-create
|
|
:content (format "B%d" index)
|
|
:width 48 :height 1))))
|
|
(layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:row-gap 1
|
|
:column-gap '(8)
|
|
(mapcar (lambda (inner)
|
|
(ebox-column
|
|
(ebox-create :content "Static card"
|
|
:width 180
|
|
:height 1)
|
|
inner))
|
|
inner-flexes)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 320))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(ebox-rerender-buffer-with-context buffer 360)
|
|
(let ((static-flex-renders 0)
|
|
(original (symbol-function 'ebox--render-flex)))
|
|
(cl-letf (((symbol-function 'ebox--render-flex)
|
|
(lambda (node)
|
|
(when (memq node inner-flexes)
|
|
(cl-incf static-flex-renders))
|
|
(funcall original node))))
|
|
(ebox-rerender-buffer-with-context buffer 420))
|
|
(should (= static-flex-renders 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-flex-window-reuses-cached-composite-measurements ()
|
|
"Flex prefix layout should reuse warm measurements for fixed composites."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:column-gap '(8)
|
|
(cl-loop for index below 6
|
|
collect
|
|
(ebox-column
|
|
(ebox-create :content (format "Card %d" index)
|
|
:width 96 :height 1)
|
|
(ebox-create :content "Body" :width 96 :height 2)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 320))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout)))
|
|
(let* ((root (ebox--buffer-root-node buffer))
|
|
(child (car (plist-get root :children))))
|
|
(ebox--with-buffer-render-context buffer
|
|
(should (ebox--flex-window-cheap-item child 'row 0)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-render-cacheability-uses-boolean-viewport-dependency-cache ()
|
|
"Render cacheability should not enumerate viewport-dependent node ids."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-column
|
|
(ebox-create :content "Static" :width 120)
|
|
(ebox-create :content "Also static" :width 120)))
|
|
(calls 0)
|
|
(original (symbol-function 'ebox--viewport-dependent-node-ids)))
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--viewport-dependent-subtree-cache
|
|
(make-hash-table :test 'eq)))
|
|
(cl-letf (((symbol-function 'ebox--viewport-dependent-node-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf calls)
|
|
(apply original args))))
|
|
(should (ebox--render-cacheable-node-p layout))
|
|
(should (ebox--render-cacheable-node-p layout)))
|
|
(should (= calls 0)))))
|
|
|
|
(ert-deftest ebox-render-cacheability-rejects-viewport-dependent-wrapper-child ()
|
|
"Wrapper boxes with viewport-dependent child layout should not reuse static render cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(box :content "Auto child follows viewport"
|
|
:wrap-mode word)))))
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--viewport-dependent-subtree-cache
|
|
(make-hash-table :test 'eq)))
|
|
(should-not (ebox--render-cacheable-node-p node)))))
|
|
|
|
(ert-deftest ebox-render-cacheability-allows-definite-width-wrapper-child ()
|
|
"Definite-width boxes bound descendant viewport-dependent layout."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :width (210) :padding 1
|
|
(box :content "Child wraps inside the card"
|
|
:wrap-mode word)))))
|
|
(let ((ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--viewport-dependent-subtree-cache
|
|
(make-hash-table :test 'eq)))
|
|
(should (ebox--viewport-dependent-subtree-p node))
|
|
(should (ebox--render-cacheable-node-p node)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-reuses-buffer-viewport-dependencies ()
|
|
"Viewport rerenders should reuse the buffer's viewport dependency list."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-flex :flex-wrap 'wrap
|
|
(ebox-create :content "A" :width '(120))
|
|
(ebox-create :content "B" :width '(120))))
|
|
(calls 0)
|
|
(axis-scans 0)
|
|
(original (symbol-function 'ebox--viewport-dependent-node-ids))
|
|
(original-axes
|
|
(symbol-function 'ebox--viewport-dependent-node-id-axes))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(cl-letf (((symbol-function 'ebox--viewport-dependent-node-id-axes)
|
|
(lambda (&rest args)
|
|
(cl-incf axis-scans)
|
|
(apply original-axes args))))
|
|
(ebox-rerender-buffer-with-context buffer 220))
|
|
(should (= axis-scans 0))
|
|
(cl-letf (((symbol-function 'ebox--viewport-dependent-node-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf calls)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 200))
|
|
(should (= calls 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-region-width-update-invalidates-viewport-dependencies ()
|
|
"Width updates can change which boxes participate in viewport resize."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Resizable" :width 80))
|
|
(box-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-rerender-buffer-with-context (current-buffer) 260)
|
|
(ebox-region-update box-id :width '(viewport))
|
|
(ebox-rerender-buffer-with-context (current-buffer) 200)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'viewport))
|
|
(should (= (plist-get report :dirty-count) 1))))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-include-wrapper-child-layout ()
|
|
"Viewport dependency discovery should see lazy child layout under wrapper boxes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :padding 1
|
|
(box :content "Auto child follows the preview width"
|
|
:wrap-mode word))))
|
|
(child (car (ebox--node-children node)))
|
|
(ids (let ((ebox-viewport-width 360))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should ids)
|
|
(should (member (plist-get node :node-id) ids))
|
|
(should (member (plist-get child :node-id) ids))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-stop-at-definite-width-wrapper ()
|
|
"Definite wrappers should contain descendant viewport dependencies."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-build
|
|
'(column :width (210) :padding 1
|
|
(box :content "Auto child wraps inside the fixed card"
|
|
:wrap-mode word))))
|
|
(child (car (ebox--node-children node)))
|
|
(ids (let ((ebox-viewport-width 360))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should-not (member (plist-get node :node-id) ids))
|
|
(should-not (member (plist-get child :node-id) ids))))
|
|
|
|
(ert-deftest ebox-viewport-height-dependency-crosses-definite-width-wrapper ()
|
|
"Definite width should not contain a descendant viewport-height dependency."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((viewport-width 120)
|
|
(node (let ((ebox-viewport-width viewport-width)
|
|
(ebox-viewport-height 2))
|
|
(ebox-build
|
|
'(column :width (120)
|
|
(box :id child
|
|
:content "One\nTwo\nThree\nFour"
|
|
:height (viewport-height)
|
|
:overflow scroll)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width viewport-width)
|
|
(ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(with-current-buffer buffer
|
|
(should (= (length (ebox-string-lines
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
2)))
|
|
(let ((report
|
|
(ebox-rerender-buffer-with-context
|
|
buffer viewport-width 4)))
|
|
(should-not (eq (plist-get report :strategy) 'no-op)))
|
|
(with-current-buffer buffer
|
|
(should (= (length (ebox-string-lines
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
4))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-dependency-axes-classify-both-dimensions ()
|
|
"A node may depend on width, height, or both viewport axes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((width-only (ebox-create :content "Width" :width '(viewport)))
|
|
(height-only (ebox-create :content "Height"
|
|
:width '(120)
|
|
:height '(viewport-height)))
|
|
(both (ebox-create :content "Both"
|
|
:width '(viewport)
|
|
:height '(viewport-height)))
|
|
(layout (ebox-column width-only height-only both)))
|
|
(let ((ebox-viewport-width 360)
|
|
(ebox-viewport-height 12)
|
|
(ebox--viewport-dependent-node-ids-cache
|
|
(make-hash-table :test 'eq))
|
|
(ebox--viewport-height-dependent-subtree-cache
|
|
(make-hash-table :test 'eq)))
|
|
(ebox--runtime-node-ids layout)
|
|
(pcase-let ((`(,width-ids . ,height-ids)
|
|
(ebox--viewport-dependent-node-id-axes layout)))
|
|
(should (member (plist-get width-only :node-id) width-ids))
|
|
(should-not (member (plist-get width-only :node-id) height-ids))
|
|
(should-not (member (plist-get height-only :node-id) width-ids))
|
|
(should (member (plist-get height-only :node-id) height-ids))
|
|
(should (member (plist-get both :node-id) width-ids))
|
|
(should (member (plist-get both :node-id) height-ids))))))
|
|
|
|
(ert-deftest ebox-viewport-width-rerender-skips-height-only-root ()
|
|
"Width-only viewport rerender should not dirty height-only roots."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (let ((ebox-viewport-height 4))
|
|
(ebox-build
|
|
'(column :width (120) :height (viewport-height)
|
|
(box :content "Static" :width (120))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(let ((report (ebox-rerender-buffer-with-context buffer 300)))
|
|
(should (eq (plist-get report :strategy) 'no-op))
|
|
(should (= (plist-get report :dirty-count) 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-keep-only-vertical-axis-under-fixed-width ()
|
|
"Fixed width should retain vertical dependencies without exposing width-only ones."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((width-only
|
|
(ebox-create :content "Width" :width '(viewport)))
|
|
(ordinary-height-nodes
|
|
(cl-loop for (property value)
|
|
in '((:height (viewport-height))
|
|
(:min-height (- (viewport-height) 1))
|
|
(:max-height (+ (viewport-height) 1)))
|
|
collect
|
|
(apply #'ebox-create
|
|
:content "Ordinary"
|
|
(list property value))))
|
|
(flex-height-nodes
|
|
(cl-loop for (property value)
|
|
in '((:height (viewport-height))
|
|
(:min-height (- (viewport-height) 1))
|
|
(:max-height (+ (viewport-height) 1)))
|
|
collect
|
|
(apply #'ebox-flex
|
|
(append
|
|
(list property value)
|
|
(list (ebox-create :content "Flex"))))))
|
|
(layout
|
|
(apply #'ebox-column
|
|
(append (list width-only)
|
|
ordinary-height-nodes
|
|
flex-height-nodes)))
|
|
(node (ebox-create :width '(210)
|
|
:wrap-mode nil
|
|
:ebox-content-node layout))
|
|
(ids (let ((ebox-viewport-width 360)
|
|
(ebox-viewport-height 12))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should-not (member (plist-get width-only :node-id) ids))
|
|
(dolist (vertical-node (append ordinary-height-nodes flex-height-nodes))
|
|
(should (member (plist-get vertical-node :node-id) ids)))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-include-direct-flex-basis ()
|
|
"Viewport dependency discovery should include direct child flex-basis props."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-create :content "A" :width 80
|
|
:flex-basis '(viewport)))
|
|
(node (ebox-flex :width 300
|
|
child
|
|
(ebox-create :content "B" :width 80)))
|
|
(ids (let ((ebox-viewport-width 360))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should (member (plist-get child :node-id) ids))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-ignore-flex-item-wrapper-auto-width ()
|
|
"Flex item wrappers should not be dirty only because their own width is auto."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-create :content "A" :width 80))
|
|
(item (ebox-flex-item child))
|
|
(node (ebox-flex :width 240 item))
|
|
(ids (let ((ebox-viewport-width 360))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should-not (member (plist-get item :node-id) ids))
|
|
(should-not (member (plist-get child :node-id) ids))))
|
|
|
|
(ert-deftest ebox-viewport-dependencies-include-flex-item-viewport-basis ()
|
|
"Flex item wrappers should stay dirty when their flex-basis uses viewport."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-create :content "A" :width 80))
|
|
(item (ebox-flex-item child :flex-basis '(viewport)))
|
|
(node (ebox-flex :width 240 item))
|
|
(ids (let ((ebox-viewport-width 360))
|
|
(ebox--runtime-node-ids node)
|
|
(ebox--viewport-dependent-node-ids node))))
|
|
(should (member (plist-get item :node-id) ids))))
|
|
|
|
(ert-deftest ebox-buffer-viewport-dependency-cache-invalidates-after-display-style-change ()
|
|
"Changing width/display-sensitive style should invalidate viewport dependency cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Resizable" :width 80))
|
|
(box-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-rerender-buffer-with-context (current-buffer) 320)
|
|
(ebox-region-update box-id :width '(viewport))
|
|
(let ((state (ebox--buffer-render-state (current-buffer))))
|
|
(should-not (plist-get state :viewport-dependent-node-ids-ready)))
|
|
(ebox-rerender-buffer-with-context (current-buffer) 240)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :constraint-source) 'viewport))
|
|
(should (= (plist-get report :dirty-count) 1))))))
|
|
|
|
(ert-deftest ebox-initial-render-primes-static-composite-subtree-cache ()
|
|
"The first viewport resize should reuse cache populated by initial render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((inner-flexes
|
|
(cl-loop for index below 6
|
|
collect
|
|
(ebox-flex
|
|
:width 180 :height 3
|
|
:flex-flow '(row wrap)
|
|
:column-gap '(8)
|
|
(ebox-create
|
|
:content (format "A%d" index)
|
|
:width 48 :height 1)
|
|
(ebox-create
|
|
:content (format "B%d" index)
|
|
:width 48 :height 1))))
|
|
(layout
|
|
(apply
|
|
#'ebox-flex
|
|
:flex-flow '(row wrap)
|
|
:row-gap 1
|
|
:column-gap '(8)
|
|
(mapcar (lambda (inner)
|
|
(ebox-column
|
|
(ebox-create :content "Static card"
|
|
:width 180
|
|
:height 1)
|
|
inner))
|
|
inner-flexes)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 320))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(let ((static-flex-renders 0)
|
|
(original (symbol-function 'ebox--render-flex)))
|
|
(cl-letf (((symbol-function 'ebox--render-flex)
|
|
(lambda (node)
|
|
(when (memq node inner-flexes)
|
|
(cl-incf static-flex-renders))
|
|
(funcall original node))))
|
|
(ebox-rerender-buffer-with-context buffer 420))
|
|
(should (= static-flex-renders 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-resize-invalidates-snapshot-details-lazily ()
|
|
"Viewport resize should not recapture every lightweight snapshot eagerly."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :width (viewport)
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :id ,(format "resize-snapshot-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:width (viewport)
|
|
:height 1)))))
|
|
(node-count (length (ebox--runtime-node-ids layout)))
|
|
buffer
|
|
(snapshot-count 0)
|
|
(original (symbol-function 'ebox--node-layout-snapshot)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(cl-letf (((symbol-function 'ebox--node-layout-snapshot)
|
|
(lambda (&rest args)
|
|
(cl-incf snapshot-count)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 320))
|
|
(should (< snapshot-count node-count)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-resize-invalidates-extents-lazily ()
|
|
"Viewport resize should not rescan extents before a later update needs them."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :width (viewport)
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :id ,(format "resize-extents-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:width (viewport)
|
|
:height 1)))))
|
|
buffer
|
|
target-id
|
|
(register-count 0)
|
|
(original-register
|
|
(symbol-function 'ebox--register-box-extents-in-range)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id
|
|
buffer "#resize-extents-12"))
|
|
(cl-letf (((symbol-function
|
|
'ebox--register-box-extents-in-range)
|
|
(lambda (&rest args)
|
|
(cl-incf register-count)
|
|
(apply original-register args))))
|
|
(ebox-rerender-buffer-with-context buffer 320))
|
|
(should (= register-count 0))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update target-id :content "updated after resize")
|
|
(should (string-match-p "updated after resize"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-dependent-node-ids-are-render-pass-memoized ()
|
|
"Viewport dependency discovery should not recurse twice for the same node."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-flex
|
|
:width 240
|
|
(ebox-column
|
|
(ebox-create :content "A" :width 80)
|
|
(ebox-create :content "B" :width 80))))
|
|
(node-count (length (ebox--runtime-node-ids layout)))
|
|
(width-check-count 0)
|
|
(height-check-count 0)
|
|
(original-width
|
|
(symbol-function 'ebox--node-direct-viewport-width-dependent-p))
|
|
(original-height
|
|
(symbol-function 'ebox--node-direct-viewport-height-dependent-p))
|
|
(ebox--viewport-dependent-node-ids-cache
|
|
(make-hash-table :test 'eq)))
|
|
(cl-letf (((symbol-function
|
|
'ebox--node-direct-viewport-width-dependent-p)
|
|
(lambda (&rest args)
|
|
(cl-incf width-check-count)
|
|
(apply original-width args)))
|
|
((symbol-function
|
|
'ebox--node-direct-viewport-height-dependent-p)
|
|
(lambda (&rest args)
|
|
(cl-incf height-check-count)
|
|
(apply original-height args))))
|
|
(ebox--viewport-dependent-node-ids layout)
|
|
(ebox--viewport-dependent-node-ids layout))
|
|
(should (= width-check-count node-count))
|
|
(should (= height-check-count node-count))))
|
|
|
|
(ert-deftest ebox-render-cache-node-signature-is-render-pass-memoized ()
|
|
"Render cache signatures should not recurse twice for the same node."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-flex
|
|
:width 240
|
|
(ebox-column
|
|
(ebox-create :content "A" :width 80)
|
|
(ebox-create :content "B" :width 80))))
|
|
(node-count (length (ebox--runtime-node-ids layout)))
|
|
(signature-count 0)
|
|
(original (symbol-function 'ebox--render-cache-plist-signature))
|
|
(ebox--render-cache-signature-cache
|
|
(make-hash-table :test 'eq)))
|
|
(cl-letf (((symbol-function 'ebox--render-cache-plist-signature)
|
|
(lambda (&rest args)
|
|
(cl-incf signature-count)
|
|
(apply original args))))
|
|
(ebox--render-cache-node-signature layout)
|
|
(ebox--render-cache-node-signature layout))
|
|
(should (= signature-count node-count))))
|
|
|
|
(ert-deftest ebox-render-cache-value-signature-preserves-dotted-pairs ()
|
|
"Native values such as sparse keymaps may contain dotted pairs."
|
|
(let ((value '(keymap (mouse-1 . ebox-test-activate)
|
|
(13 . ebox-test-activate))))
|
|
(should
|
|
(equal (ebox--render-cache-value-signature value)
|
|
value))))
|
|
|
|
(ert-deftest ebox-render-cache-signature-includes-rendered-region-identity ()
|
|
"Cached render strings should never cross distinct region identities."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Stable" :width 80))
|
|
(right (copy-tree left)))
|
|
(plist-put left :node-id 1)
|
|
(plist-put right :node-id 1)
|
|
(plist-put left :region-id 11)
|
|
(plist-put right :region-id 12)
|
|
(should-not
|
|
(equal (ebox--render-cache-node-signature left)
|
|
(ebox--render-cache-node-signature right)))))
|
|
|
|
(ert-deftest ebox-render-transaction-snapshots-display-signature ()
|
|
"One render transaction should sample its display signature once."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-create :content "A" :width 80))
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(ebox--with-validated-display-cache
|
|
(ebox--render-cache-node-signature node)
|
|
(ebox--render-cache-node-signature node)))
|
|
(should (= calls 1))))
|
|
|
|
(ert-deftest ebox-render-transaction-nesting-reuses-display-signature ()
|
|
"A nested render transaction should reuse the outer display snapshot."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-create :content "A" :width 80))
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(ebox--with-validated-display-cache
|
|
(ebox--with-validated-display-cache
|
|
(ebox--render-cache-node-signature node))))
|
|
(should (= calls 1))))
|
|
|
|
(ert-deftest ebox-render-transactions-refresh-display-signature ()
|
|
"Separate render transactions should sample display state independently."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-create :content "A" :width 80))
|
|
(calls 0)
|
|
signatures)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(dotimes (_ 2)
|
|
(push
|
|
(ebox--with-validated-display-cache
|
|
(car (ebox--render-cache-node-signature node)))
|
|
signatures)))
|
|
(should (= calls 2))
|
|
(should-not (equal (car signatures) (cadr signatures)))))
|
|
|
|
(ert-deftest ebox-current-display-signature-is-live-outside-transaction ()
|
|
"The internal accessor should sample live state outside a transaction."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((calls 0)
|
|
signatures)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(setq signatures
|
|
(list (ebox--current-display-signature)
|
|
(ebox--current-display-signature))))
|
|
(should (= calls 2))
|
|
(should-not (equal (car signatures) (cadr signatures)))))
|
|
|
|
(ert-deftest ebox-public-display-signature-stays-live-in-render-transaction ()
|
|
"The public display signature should bypass a render transaction snapshot."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((calls 0)
|
|
signatures)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(setq signatures
|
|
(ebox--with-validated-display-cache
|
|
(list (ebox-display-signature)
|
|
(ebox-display-signature)))))
|
|
(should (= calls 3))
|
|
(should-not (equal (car signatures) (cadr signatures)))))
|
|
|
|
(ert-deftest ebox-clear-cache-samples-live-display-in-render-transaction ()
|
|
"Clearing caches should store live display state inside a transaction."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((calls 0))
|
|
(puthash '(stale) 1 ebox--string-pixel-width-cache)
|
|
(aset ebox--string-pixel-width-cache-ring 0 '(stale))
|
|
(setq ebox--string-pixel-width-cache-ring-index 1)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda ()
|
|
(list 'display (cl-incf calls)))))
|
|
(ebox--with-validated-display-cache
|
|
(ebox-clear-cache)))
|
|
(should (= calls 2))
|
|
(should (= (hash-table-count ebox--string-pixel-width-cache) 0))
|
|
(should (= ebox--string-pixel-width-cache-ring-index 0))
|
|
(should (equal ebox--display-signature-cache '(display 2)))))
|
|
|
|
(ert-deftest ebox-render-cache-signature-keeps-viewport-axes-with-snapshot ()
|
|
"Display snapshots should not collapse width or height cache dimensions."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-create :content "A"
|
|
:width '(viewport)
|
|
:height '(viewport-height)))
|
|
signatures)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda () '(display stable))))
|
|
(ebox--with-validated-display-cache
|
|
(dolist (viewport '((80 10) (90 10) (90 11)))
|
|
(let ((ebox-viewport-width (car viewport))
|
|
(ebox-viewport-height (cadr viewport)))
|
|
(push (ebox--render-cache-node-signature node)
|
|
signatures)))))
|
|
(setq signatures (nreverse signatures))
|
|
(should (equal (mapcar #'car signatures)
|
|
'((display stable) (display stable) (display stable))))
|
|
(should-not (equal (nth 0 signatures) (nth 1 signatures)))
|
|
(should-not (equal (nth 1 signatures) (nth 2 signatures)))))
|
|
|
|
(ert-deftest ebox-render-cache-signature-ignores-unrelated-viewport-height ()
|
|
"Width-only subtree signatures should survive unrelated height changes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (ebox-column
|
|
(ebox-create :content "A" :width '(viewport))
|
|
(ebox-create :content "B" :width 80)))
|
|
(left (let ((ebox-viewport-width 320)
|
|
(ebox-viewport-height 10))
|
|
(ebox--render-cache-node-signature node)))
|
|
(right (let ((ebox-viewport-width 320)
|
|
(ebox-viewport-height 11))
|
|
(ebox--render-cache-node-signature node))))
|
|
(should (equal left right))))
|
|
|
|
(ert-deftest ebox-buffer-height-dependency-cache-invalidates-mutated-path ()
|
|
"Persistent height dependencies should survive siblings and track mutations."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :id "child" :content "child" :width (80)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(cache
|
|
(plist-get state
|
|
:viewport-height-dependent-subtree-cache))
|
|
(child-id
|
|
(plist-get
|
|
(car (ebox-selector-query-buffer buffer "#child"))
|
|
:node-id))
|
|
(child (ebox--buffer-runtime-node buffer child-id))
|
|
(missing (make-symbol "missing")))
|
|
(ebox--with-buffer-render-context buffer
|
|
(should-not (ebox--viewport-height-dependent-subtree-p child)))
|
|
(should-not (eq (gethash child cache missing) missing))
|
|
(ebox-selector-update-buffer buffer "#root" :width '(260))
|
|
(should-not (eq (gethash child cache missing) missing))
|
|
(ebox-selector-update-buffer
|
|
buffer "#child" :height '(viewport-height))
|
|
(should (eq (gethash child cache missing) missing))
|
|
(let ((low (let ((ebox-viewport-height 4))
|
|
(ebox--render-cache-node-signature child)))
|
|
(high (let ((ebox-viewport-height 5))
|
|
(ebox--render-cache-node-signature child))))
|
|
(should-not (equal low high)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-buffer-render-signatures-persist-across-transactions ()
|
|
"Unchanged runtime body signatures should survive buffer render transactions."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-flex
|
|
:width 240
|
|
(ebox-column
|
|
(ebox-create :content "A" :width 80)
|
|
(ebox-create :content "B" :width 80))))
|
|
(node-count (length (ebox--runtime-node-ids layout)))
|
|
(signature-count 0)
|
|
(original (symbol-function 'ebox--render-cache-plist-signature))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(when-let ((cache
|
|
(plist-get (ebox--buffer-render-state buffer)
|
|
:render-signature-cache)))
|
|
(clrhash cache))
|
|
(cl-letf (((symbol-function 'ebox--render-cache-plist-signature)
|
|
(lambda (&rest args)
|
|
(cl-incf signature-count)
|
|
(apply original args))))
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature layout))
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature layout)))
|
|
(should (= signature-count node-count)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-buffer-render-signature-invalidates-mutated-path ()
|
|
"Runtime mutation should not reuse a stale ancestor body signature."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Before" :width 80))
|
|
(right (ebox-create :content "Stable" :width 80))
|
|
(layout (ebox-column left right))
|
|
(left-region-id (car (ebox-region-ids left)))
|
|
old-root-signature
|
|
new-root-signature
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(let ((runtime-root (ebox--buffer-root-node buffer)))
|
|
(setq old-root-signature
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature runtime-root))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update left-region-id :content "After")
|
|
(should (equal (ebox-get left :content) "Before"))
|
|
(setq new-root-signature
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature
|
|
(ebox--buffer-root-node buffer))))
|
|
(should-not (equal old-root-signature new-root-signature))
|
|
(should
|
|
(string-match-p
|
|
"After"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-buffer-render-signature-invalidation-retains-sibling ()
|
|
"Invalidating one runtime path should retain unaffected sibling signatures."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Left" :width 80))
|
|
(right (ebox-create :content "Right" :width 80))
|
|
(layout (ebox-column left right))
|
|
(left-region-id (car (ebox-region-ids left)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(let* ((root-id (ebox--ensure-node-id layout))
|
|
(left-node-id (ebox--ensure-node-id left))
|
|
(right-node-id (ebox--ensure-node-id right))
|
|
(runtime-root (ebox--buffer-runtime-node buffer root-id))
|
|
(runtime-left (ebox--buffer-runtime-node buffer left-node-id))
|
|
(runtime-right (ebox--buffer-runtime-node buffer right-node-id)))
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature runtime-root))
|
|
(let* ((cache (ebox--buffer-render-signature-cache buffer))
|
|
(root-signature (gethash runtime-root cache))
|
|
(left-signature (gethash runtime-left cache))
|
|
(right-signature (gethash runtime-right cache)))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update left-region-id :content "Changed"))
|
|
(should (equal (ebox-get left :content) "Left"))
|
|
(should-not (eq root-signature (gethash runtime-root cache)))
|
|
(should-not (eq left-signature (gethash runtime-left cache)))
|
|
(should (eq right-signature (gethash runtime-right cache)))
|
|
(should root-signature)
|
|
(should left-signature)
|
|
(should right-signature)
|
|
(with-current-buffer buffer
|
|
(should
|
|
(ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-buffer-render-signature-invalidates-direct-scroll-path ()
|
|
"Direct runtime scrolling should invalidate the changed node-to-root path."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((scroll-box
|
|
(ebox-build
|
|
'(box :id "scroll" :height 2 :overflow scroll
|
|
(column
|
|
(box :content "row-1" :height 1)
|
|
(box :content "row-2" :height 1)
|
|
(box :content "row-3" :height 1)))))
|
|
(stable (ebox-create :content "Stable" :height 1))
|
|
(layout (ebox-column scroll-box stable))
|
|
(scroll-region-id (car (ebox-region-ids scroll-box)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(let* ((root-id (ebox--ensure-node-id layout))
|
|
(scroll-node-id (ebox--ensure-node-id scroll-box))
|
|
(stable-node-id (ebox--ensure-node-id stable))
|
|
(runtime-root (ebox--buffer-runtime-node buffer root-id))
|
|
(runtime-scroll (ebox--buffer-runtime-node buffer scroll-node-id))
|
|
(runtime-stable (ebox--buffer-runtime-node buffer stable-node-id)))
|
|
(ebox--with-buffer-render-context buffer
|
|
(ebox--render-cache-node-body-signature runtime-root))
|
|
(let* ((cache (ebox--buffer-render-signature-cache buffer))
|
|
(root-signature (gethash runtime-root cache))
|
|
(scroll-signature (gethash runtime-scroll cache))
|
|
(stable-signature (gethash runtime-stable cache)))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by scroll-region-id 1)))
|
|
(should (equal (ebox-get scroll-box :scroll-offset) 0))
|
|
(should-not (gethash runtime-root cache))
|
|
(should-not (gethash runtime-scroll cache))
|
|
(should (eq stable-signature (gethash runtime-stable cache)))
|
|
(should root-signature)
|
|
(should scroll-signature)
|
|
(should stable-signature)
|
|
(should (= (plist-get (ebox--scroll-get-state scroll-region-id)
|
|
:scroll-offset)
|
|
1)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-render-cache-signature-ignores-viewport-for-static-column ()
|
|
"Static column signatures should not churn only because outer viewport changed."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-column
|
|
(ebox-create :content "A" :width 80)
|
|
(ebox-create :content "B" :width 80))))
|
|
(ebox--runtime-node-ids node)
|
|
(let ((left (let ((ebox-viewport-width 320))
|
|
(ebox--render-cache-node-signature node)))
|
|
(right (let ((ebox-viewport-width 640))
|
|
(ebox--render-cache-node-signature node))))
|
|
(should (equal left right)))))
|
|
|
|
(ert-deftest ebox-render-cache-plist-signature-avoids-append-churn ()
|
|
"Render cache plist signatures should be built linearly."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (ebox-create :content "Signature" :width 80 :border t))
|
|
(original-append (symbol-function 'append))
|
|
(append-calls 0))
|
|
(cl-letf (((symbol-function 'append)
|
|
(lambda (&rest args)
|
|
(cl-incf append-calls)
|
|
(apply original-append args))))
|
|
(ebox--render-cache-plist-signature node))
|
|
(should (= append-calls 0))))
|
|
|
|
(ert-deftest ebox-preformatted-exact-content-skips-justify-measurement ()
|
|
"Exact-width preformatted content should not be remeasured for left justify."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content (ebox-lines-join
|
|
(list (ebox-pixel-space 80)
|
|
(ebox-pixel-space 80))))
|
|
(box (ebox-create :content content :width 80 :wrap-mode nil))
|
|
(measure-count 0)
|
|
(original (symbol-function 'ebox--string-pixel-width)))
|
|
(plist-put box :ebox-content-width-exact-p t)
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (&rest args)
|
|
(cl-incf measure-count)
|
|
(apply original args))))
|
|
(ebox--format-content box))
|
|
(should (= measure-count 0))))
|
|
|
|
(ert-deftest ebox-uniform-stack-content-skips-parent-justify-measurement ()
|
|
"A target-width stack should not be measured again by its parent box."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-column
|
|
(ebox-create :content "A" :width '(viewport))
|
|
(ebox-create :content "B" :width '(viewport))))
|
|
(parent (ebox-create :width '(viewport) :wrap-mode nil
|
|
:ebox-content-node child))
|
|
(justify-count 0)
|
|
(original (symbol-function 'ebox--lines-justify)))
|
|
(let ((ebox-viewport-width 120))
|
|
(cl-letf (((symbol-function 'ebox--lines-justify)
|
|
(lambda (&rest args)
|
|
(cl-incf justify-count)
|
|
(apply original args))))
|
|
(ebox-render parent)))
|
|
;; The two leaf boxes still justify their own text. The parent does not
|
|
;; add a third full-stack pass.
|
|
(should (= justify-count 2))))
|
|
|
|
(ert-deftest ebox-uniform-content-skips-noop-word-and-char-formatting ()
|
|
"Exact uniform lines should bypass proven no-op word/char formatting."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (wrap-mode '(word char))
|
|
(let* ((box (ebox-create :content "" :width '(120)
|
|
:wrap-mode wrap-mode :text-align 'left))
|
|
(pixel-width (ebox--content-pixel box))
|
|
(line (propertize (ebox-pixel-space pixel-width)
|
|
'face '(:foreground "#123456")))
|
|
(content (concat line "\n" line))
|
|
(wrap-count 0)
|
|
(justify-count 0)
|
|
(original-wrap (symbol-function 'ebox--wrap-text))
|
|
(original-justify (symbol-function 'ebox--lines-justify)))
|
|
(ebox--record-rendered-uniform-width content pixel-width)
|
|
(cl-letf (((symbol-function 'ebox--wrap-text)
|
|
(lambda (&rest arguments)
|
|
(cl-incf wrap-count)
|
|
(apply original-wrap arguments)))
|
|
((symbol-function 'ebox--lines-justify)
|
|
(lambda (&rest arguments)
|
|
(cl-incf justify-count)
|
|
(apply original-justify arguments))))
|
|
(should (eq (ebox--format-content-string box content) content)))
|
|
(should (= wrap-count 0))
|
|
(should (= justify-count 0)))))
|
|
|
|
(ert-deftest ebox-uniform-content-keeps-semantic-formatting-paths ()
|
|
"KP, non-left alignment and width mismatch must retain formatting."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (case '((kp left 120)
|
|
(word center 120)
|
|
(char left 119)))
|
|
(let* ((box (ebox-create :content "" :width '(120)
|
|
:wrap-mode (nth 0 case)
|
|
:text-align (nth 1 case)))
|
|
(content (ebox-pixel-space 120))
|
|
(wrap-count 0)
|
|
(original-wrap (symbol-function 'ebox--wrap-text)))
|
|
(ebox--record-rendered-uniform-width content (nth 2 case))
|
|
(cl-letf (((symbol-function 'ebox--wrap-text)
|
|
(lambda (&rest arguments)
|
|
(cl-incf wrap-count)
|
|
(apply original-wrap arguments))))
|
|
(ebox--format-content-string box content))
|
|
(should (> wrap-count 0)))))
|
|
|
|
(ert-deftest ebox-transparent-preformatted-box-fast-path-is-exact ()
|
|
"Transparent exact-width wrappers should match the generic box pipeline."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child-a (ebox-create :content "A" :width '(viewport) :border t
|
|
:region-id 'child-a))
|
|
(child-b (ebox-create :content "B" :width '(viewport) :border t
|
|
:region-id 'child-b))
|
|
(parent (ebox-create :width '(viewport) :wrap-mode nil
|
|
:region-id 'parent
|
|
:ebox-content-node
|
|
(ebox-column child-a child-b)))
|
|
generic fast)
|
|
(let ((ebox-viewport-width 120)
|
|
(ebox--transparent-preformatted-box-fast-path-disabled t))
|
|
(setq generic (ebox-render parent)))
|
|
(clrhash ebox--rendered-uniform-width-table)
|
|
(let ((ebox-viewport-width 120))
|
|
(setq fast (ebox-render parent)))
|
|
(should (equal-including-properties fast generic))))
|
|
|
|
(ert-deftest ebox-flat-preformatted-box-fast-path-is-exact ()
|
|
"One-pass exact wrappers should preserve generic chrome and ownership."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box
|
|
(ebox-create
|
|
:content "" :width '(140) :wrap-mode nil :region-id 'wrapper
|
|
:padding-left-pixel 7 :padding-right-pixel 5
|
|
:padding-top-height 1 :padding-bottom-height 2
|
|
:border-left-pixel 2 :border-left-color "#AA0000"
|
|
:border-right-pixel 3 :border-right-color "#00AA00"
|
|
:border-top-p t :border-top-color "#0000AA"
|
|
:border-bottom-p t :border-bottom-color "#AA00AA"
|
|
:color "#111111" :bgcolor "#EEEEEE"))
|
|
(content-width (ebox--content-pixel box))
|
|
(full-line (ebox-pixel-space content-width))
|
|
(content (concat full-line "\n\n" full-line))
|
|
(fast-path-calls 0)
|
|
(original
|
|
(symbol-function 'ebox--window-render-flat-wrapper-chunk-lines))
|
|
generic fast)
|
|
(plist-put box :content content)
|
|
(plist-put box :ebox-content-width-exact-p t)
|
|
(let ((ebox--flat-preformatted-box-fast-path-disabled t))
|
|
(setq generic (ebox-render box)))
|
|
(clrhash ebox--region-box-table)
|
|
(clrhash ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'ebox--window-render-flat-wrapper-chunk-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf fast-path-calls)
|
|
(apply original args))))
|
|
(setq fast (ebox-render box)))
|
|
(should (= fast-path-calls 1))
|
|
(should (equal-including-properties fast generic))))
|
|
|
|
(ert-deftest ebox-flat-preformatted-fixed-hidden-box-fast-path-is-exact ()
|
|
"Exact fixed-height hidden wrappers should preserve generic output."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box
|
|
(ebox-create
|
|
:content "" :width '(140) :height 6 :box-sizing 'border-box
|
|
:overflow 'hidden :wrap-mode nil :region-id 'fixed-wrapper
|
|
:padding-left-pixel 7 :padding-right-pixel 5
|
|
:padding-top-height 1 :padding-bottom-height 2
|
|
:border-left-pixel 2 :border-left-color "#AA0000"
|
|
:border-right-pixel 3 :border-right-color "#00AA00"
|
|
:border-top-p t :border-top-color "#0000AA"
|
|
:border-bottom-p t :border-bottom-color "#AA00AA"
|
|
:color "#111111" :bgcolor "#EEEEEE"))
|
|
(content-width (ebox--content-pixel box))
|
|
(full-line (ebox-pixel-space content-width))
|
|
(content (concat full-line "\n\n" full-line))
|
|
(fast-path-calls 0)
|
|
(original
|
|
(symbol-function 'ebox--window-render-flat-wrapper-chunk-lines))
|
|
generic fast)
|
|
(plist-put box :content content)
|
|
(plist-put box :ebox-content-width-exact-p t)
|
|
(let ((ebox--flat-preformatted-box-fast-path-disabled t))
|
|
(setq generic (ebox-render box)))
|
|
(clrhash ebox--region-box-table)
|
|
(clrhash ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'ebox--window-render-flat-wrapper-chunk-lines)
|
|
(lambda (&rest arguments)
|
|
(cl-incf fast-path-calls)
|
|
(apply original arguments))))
|
|
(setq fast (ebox-render box)))
|
|
(should (= fast-path-calls 1))
|
|
(should (eq (gethash 'fixed-wrapper ebox--region-box-table) box))
|
|
(should-not (gethash 'fixed-wrapper ebox--scroll-global-state))
|
|
(should (equal-including-properties fast generic))))
|
|
|
|
(ert-deftest ebox-flat-preformatted-fixed-box-rejects-layout-work ()
|
|
"Fixed wrappers should stay generic when clipping or alignment is required."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (case '(("two\nlines" hidden top)
|
|
("one\ntwo\nthree\nfour" hidden top)
|
|
("one\ntwo\nthree" scroll top)
|
|
("one\ntwo\nthree" hidden center)))
|
|
(let* ((box
|
|
(ebox-create
|
|
:content (nth 0 case) :width '(120) :height 5
|
|
:box-sizing 'border-box :overflow (nth 1 case)
|
|
:vertical-align (nth 2 case) :wrap-mode nil))
|
|
(calls 0)
|
|
(original
|
|
(symbol-function 'ebox--window-render-flat-wrapper-chunk-lines)))
|
|
(plist-put box :ebox-content-width-exact-p t)
|
|
(cl-letf (((symbol-function 'ebox--window-render-flat-wrapper-chunk-lines)
|
|
(lambda (&rest arguments)
|
|
(cl-incf calls)
|
|
(apply original arguments))))
|
|
(ebox-render box))
|
|
(should (= calls 0)))))
|
|
|
|
(ert-deftest ebox-scroll-span-template-indexes-only-live-scroll-owners ()
|
|
"Prepared root metadata should not scan or retain non-scroll owners."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((direct
|
|
(propertize "AA" 'ebox-content 'direct-scroll
|
|
'ebox-content-idx 3))
|
|
(ordinary
|
|
(propertize "BB" 'ebox-content 'ordinary
|
|
'ebox-content-idx 0))
|
|
(owned
|
|
(concat
|
|
(propertize "C" 'ebox-content 'child
|
|
'ebox-content-idx 0
|
|
'ebox-content-owner 'owner-scroll
|
|
'face '(:foreground "red"))
|
|
(propertize "C" 'ebox-content 'child
|
|
'ebox-content-idx 0
|
|
'ebox-content-owner 'owner-scroll
|
|
'face '(:foreground "blue"))))
|
|
(rendered (concat direct ordinary "\n" owned))
|
|
template)
|
|
(puthash 'direct-scroll (list :scroll-offset 0)
|
|
ebox--scroll-global-state)
|
|
(puthash 'owner-scroll (list :scroll-offset 0)
|
|
ebox--scroll-global-state)
|
|
(setq template (ebox--build-scroll-content-span-template rendered))
|
|
(should (equal (gethash 'direct-scroll template)
|
|
'((3 0 . 2))))
|
|
(should (equal (gethash 'owner-scroll template)
|
|
'((0 5 . 7))))
|
|
(should-not (gethash 'ordinary template))
|
|
(should-not (gethash 'child template))))
|
|
|
|
(ert-deftest ebox-overflowing-stack-content-still-uses-parent-formatting ()
|
|
"An overflowing child stack must not publish uniform parent-width metadata."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-column
|
|
(ebox-create :content "A" :width 140)
|
|
(ebox-create :content "B" :width 140)))
|
|
(parent (ebox-create :width 120 :wrap-mode nil
|
|
:ebox-content-node child))
|
|
(justify-count 0)
|
|
(original (symbol-function 'ebox--lines-justify))
|
|
rendered)
|
|
(let ((ebox-viewport-width 120))
|
|
(cl-letf (((symbol-function 'ebox--lines-justify)
|
|
(lambda (&rest args)
|
|
(cl-incf justify-count)
|
|
(apply original args))))
|
|
(setq rendered (ebox-render parent))))
|
|
(should (= justify-count 3))
|
|
(should (= (ebox--string-max-pixel-width rendered) 140))))
|
|
|
|
(ert-deftest ebox-render-caches-lazy-box-content-within-render-pass ()
|
|
"A lazy child layout should be rendered once per box/context in one pass."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((child (ebox-column
|
|
(ebox-create :content "A" :width 80)
|
|
(ebox-create :content "B" :width 80)))
|
|
(parent (ebox-create :width 'max-content :padding 2))
|
|
(render-count 0)
|
|
(original (symbol-function 'ebox--render-node-as-box-content)))
|
|
(plist-put parent :ebox-content-node child)
|
|
(cl-letf (((symbol-function 'ebox--render-node-as-box-content)
|
|
(lambda (&rest args)
|
|
(cl-incf render-count)
|
|
(apply original args))))
|
|
(ebox-render parent))
|
|
(should (= render-count 1))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-includes-dirty-and-patch-summary ()
|
|
"Update reports should show dirty and patch-set summaries."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Report" :width 80
|
|
:border t :border-color "red"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :border-color "blue")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-member report :dirty-count))
|
|
(should (plist-member report :patch-count))
|
|
(should (plist-member report :patch-ops))
|
|
(should (equal (plist-get report :dirty-keys)
|
|
'(:border-top-color :border-right-color
|
|
:border-bottom-color :border-left-color)))))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-is-buffer-local ()
|
|
"Updating one rendered buffer should not replace another buffer's report."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((first-box (ebox-create :content "First" :width '(80)))
|
|
(second-box (ebox-create :content "Second" :width '(80)))
|
|
(first-id (car (ebox-region-ids first-box)))
|
|
first-buffer second-buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq first-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-report-first*")
|
|
first-box))
|
|
(setq second-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-report-second*")
|
|
second-box))
|
|
(ebox-test--set-buffer-update-report
|
|
second-buffer '(:strategy second-prior :owner-ids (second)))
|
|
(with-current-buffer first-buffer
|
|
(let ((report (ebox-region-update first-id :content "First!")))
|
|
(should (equal report
|
|
(ebox-buffer-update-report first-buffer)))
|
|
(should-not (equal report
|
|
(ebox-buffer-update-report
|
|
second-buffer)))
|
|
(should (equal (ebox-buffer-update-report second-buffer)
|
|
'(:strategy second-prior
|
|
:owner-ids (second)))))))
|
|
(dolist (buffer (list first-buffer second-buffer))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer))))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-returns-defensive-copy ()
|
|
"The public accessor should not return mutable render-state storage."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Copy" :width '(80)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-report-copy*")
|
|
box))
|
|
(ebox-test--set-buffer-update-report
|
|
buffer '(:strategy paint-patch :owner-ids (1 2)))
|
|
(let ((report (ebox-buffer-update-report buffer)))
|
|
(should (equal report '(:strategy paint-patch :owner-ids (1 2))))
|
|
(plist-put report :strategy 'mutated)
|
|
(setcar (plist-get report :owner-ids) 99))
|
|
(should (equal (ebox-buffer-update-report buffer)
|
|
'(:strategy paint-patch :owner-ids (1 2)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-user-errors-without-rendered-buffer ()
|
|
"The public accessor should reject missing, dead, and unrendered buffers."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((dead (generate-new-buffer " *ebox-report-dead*"))
|
|
(unrendered (generate-new-buffer " *ebox-report-unrendered*")))
|
|
(unwind-protect
|
|
(progn
|
|
(kill-buffer dead)
|
|
(should-error (ebox-buffer-update-report nil) :type 'user-error)
|
|
(should-error (ebox-buffer-update-report dead) :type 'user-error)
|
|
(should-error (ebox-buffer-update-report unrendered)
|
|
:type 'user-error))
|
|
(when (buffer-live-p unrendered)
|
|
(kill-buffer unrendered)))))
|
|
|
|
(ert-deftest ebox-region-update-return-matches-buffer-update-report ()
|
|
"A direct region update should return the report stored on its buffer."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Return" :width '(80)
|
|
:color "#111111"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((report (ebox-region-update region-id :color "#222222")))
|
|
(should (equal report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))))))
|
|
|
|
(ert-deftest ebox-region-update-no-op-replaces-stale-buffer-report ()
|
|
"A direct unchanged update should publish its own no-op report."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "No-op" :width '(80)
|
|
:color "#111111"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((prior '(:strategy paint-patch :owner-ids (prior))))
|
|
(ebox-test--set-buffer-update-report (current-buffer) prior)
|
|
(let ((report
|
|
(ebox-region-update region-id :color "#111111")))
|
|
(should (eq (plist-get report :strategy) 'no-op))
|
|
(should (= (plist-get report :dirty-count) 0))
|
|
(should (= (plist-get report :patch-count) 0))
|
|
(should (equal report (ebox-test--buffer-update-report)))
|
|
(should-not (equal report prior)))))))
|
|
|
|
(ert-deftest ebox-batched-region-update-keeps-prior-report-until-flush ()
|
|
"Batched region updates should return nil and publish only on flush."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Batch" :width '(80)
|
|
:color "#111111"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((buffer (current-buffer))
|
|
(prior '(:strategy prior :owner-ids (prior))))
|
|
(ebox-test--set-buffer-update-report buffer prior)
|
|
(ebox-incremental-begin-batch buffer)
|
|
(should-not (ebox-region-update region-id :color "#333333"))
|
|
(should (equal (ebox-buffer-update-report buffer) prior))
|
|
(let ((flush-report (ebox-incremental-flush buffer)))
|
|
(should flush-report)
|
|
(should (equal flush-report
|
|
(ebox-buffer-update-report buffer)))
|
|
(should (eq (plist-get flush-report :strategy)
|
|
'paint-patch)))))))
|
|
|
|
(ert-deftest ebox-batch-flush-stores-report-on-flushed-buffer-only ()
|
|
"Empty and non-empty flushes should update only the target buffer report."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((first-box (ebox-create :content "First" :width '(80)
|
|
:color "#111111"))
|
|
(second-box (ebox-create :content "Second" :width '(80)
|
|
:color "#111111"))
|
|
(second-id (car (ebox-region-ids second-box)))
|
|
first-buffer second-buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq first-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-flush-first*")
|
|
first-box))
|
|
(setq second-buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-flush-second*")
|
|
second-box))
|
|
(ebox-test--set-buffer-update-report
|
|
first-buffer '(:strategy first-prior))
|
|
(ebox-test--set-buffer-update-report
|
|
second-buffer '(:strategy second-prior))
|
|
(ebox-incremental-begin-batch first-buffer)
|
|
(let ((first-report (ebox-incremental-flush first-buffer)))
|
|
(should (eq (plist-get first-report :strategy) 'no-op))
|
|
(should (equal (ebox-buffer-update-report first-buffer)
|
|
first-report))
|
|
(should (equal (ebox-buffer-update-report second-buffer)
|
|
'(:strategy second-prior)))
|
|
(with-current-buffer second-buffer
|
|
(ebox-incremental-begin-batch second-buffer)
|
|
(should-not
|
|
(ebox-region-update second-id :color "#444444")))
|
|
(let ((second-report (ebox-incremental-flush second-buffer)))
|
|
(should (eq (plist-get second-report :strategy) 'paint-patch))
|
|
(should (equal (ebox-buffer-update-report second-buffer)
|
|
second-report))
|
|
(should (equal (ebox-buffer-update-report first-buffer)
|
|
first-report)))))
|
|
(dolist (buffer (list first-buffer second-buffer))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer))))))
|
|
|
|
(ert-deftest ebox-render-to-buffer-does-not-switch-current-buffer ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((origin (current-buffer))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
(ebox-create :content "Hello" :width 40)))
|
|
(should (eq (current-buffer) origin))
|
|
(should (buffer-live-p buffer))
|
|
(with-current-buffer buffer
|
|
(should ebox-buffer-mode)
|
|
(should buffer-read-only)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-render-to-buffer-keeps-existing-local-map-as-parent ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((buffer-name (generate-new-buffer-name " *ebox-test*"))
|
|
(buffer (get-buffer-create buffer-name))
|
|
(parent-map (make-sparse-keymap)))
|
|
(define-key parent-map (kbd "x") #'ignore)
|
|
(unwind-protect
|
|
(with-current-buffer buffer
|
|
(use-local-map parent-map)
|
|
(ebox-render-to-buffer buffer-name
|
|
(ebox-create :content "Hello" :width 40))
|
|
(should (eq (current-local-map) parent-map))
|
|
(should (eq (lookup-key (current-local-map) (kbd "x")) #'ignore)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-render-to-buffer-defers-extents-and-snapshots ()
|
|
"Initial buffer render should leave expensive indexes to lazy accessors."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :id "root" :width (viewport)
|
|
,@(cl-loop for idx below 12
|
|
collect
|
|
`(box :id ,(format "lazy-initial-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:width (viewport)
|
|
:height 1)))))
|
|
buffer
|
|
(register-count 0)
|
|
(snapshot-count 0)
|
|
(runtime-node-ids-count 0)
|
|
(original-register
|
|
(symbol-function 'ebox--register-box-extents-in-range))
|
|
(original-snapshot
|
|
(symbol-function 'ebox--node-layout-snapshot))
|
|
(original-runtime-node-ids
|
|
(symbol-function 'ebox--runtime-node-ids)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240))
|
|
(cl-letf (((symbol-function
|
|
'ebox--register-box-extents-in-range)
|
|
(lambda (&rest args)
|
|
(cl-incf register-count)
|
|
(apply original-register args)))
|
|
((symbol-function 'ebox--node-layout-snapshot)
|
|
(lambda (&rest args)
|
|
(cl-incf snapshot-count)
|
|
(apply original-snapshot args)))
|
|
((symbol-function 'ebox--runtime-node-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf runtime-node-ids-count)
|
|
(apply original-runtime-node-ids args))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(should (= register-count 0))
|
|
(should (= snapshot-count 0))
|
|
(should (= runtime-node-ids-count 0))
|
|
(let* ((root-node-id (plist-get layout :node-id))
|
|
(target-id (ebox-test--selector-region-id
|
|
buffer "#lazy-initial-06")))
|
|
(should (ebox--layout-snapshot buffer root-node-id))
|
|
(should (ebox--live-box-extents target-id))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-region-buffer-ignores-killed-render-buffers ()
|
|
"Dead render buffers should not break later incremental lookups."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Dead" :width 40))
|
|
(region-id (car (ebox-region-ids box)))
|
|
(buffer (ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
box)))
|
|
(kill-buffer buffer)
|
|
(should-not (ebox--region-buffer region-id))
|
|
(should-not (ebox--buffer-render-state buffer))))
|
|
|
|
(ert-deftest ebox-buffer-kill-clears-region-runtime-caches ()
|
|
"Killing an ebox buffer should clear region-scoped runtime cache entries."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC" :width 80 :height 1
|
|
:overflow 'scroll))
|
|
(region-id (car (ebox-region-ids box)))
|
|
(buffer (ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
box)))
|
|
(should (gethash region-id ebox--region-box-table))
|
|
(should (ebox--scroll-get-state region-id))
|
|
(kill-buffer buffer)
|
|
(should-not (gethash region-id ebox--region-box-table))
|
|
(should-not (ebox--scroll-get-state region-id))))
|
|
|
|
(ert-deftest ebox-buffer-kill-discards-buffer-owned-runtime-state ()
|
|
"Killing an Ebox buffer should discard every buffer-keyed runtime entry."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Lifecycle" :color "#111111"))
|
|
(region-id (car (ebox-region-ids box)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") box))
|
|
|
|
;; A non-batched update creates a real cache report.
|
|
(ebox-region-update region-id :color "#222222")
|
|
|
|
;; A later update remains pending in the explicit batch.
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update region-id :background-color "#eeeeee")
|
|
|
|
(should (gethash buffer ebox--buffer-render-state-table))
|
|
(should (gethash buffer ebox-cache--buffer-report-table))
|
|
(should (gethash buffer ebox-incremental--batch-table))
|
|
(should (ebox-buffer-update-report buffer))
|
|
(should (= (ebox-incremental-pending-count buffer) 1))
|
|
|
|
(kill-buffer buffer)
|
|
(should-not (gethash buffer ebox--buffer-render-state-table))
|
|
(should-not (gethash buffer ebox-cache--buffer-report-table))
|
|
(should-not (gethash buffer ebox-incremental--batch-table))
|
|
(should-error (ebox-buffer-update-report buffer)
|
|
:type 'user-error))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))
|
|
(when buffer
|
|
(remhash buffer ebox--buffer-render-state-table)
|
|
(remhash buffer ebox-cache--buffer-report-table)
|
|
(remhash buffer ebox-incremental--batch-table)))))
|
|
|
|
(ert-deftest ebox-concat-content-update-preserves-neighbor-box ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "A\nB" :width 60))
|
|
(right (ebox-create :content "R1\nR2\nR3" :width 80))
|
|
(layout (ebox-concat left right))
|
|
(ids (ebox-region-ids layout))
|
|
(left-id (nth 0 ids))
|
|
(right-id (nth 1 ids)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should-not (ebox--live-box-extents left-id))
|
|
(ebox-region-update left-id :content "AA\nBB\nCC")
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "CC" plain))
|
|
(should (string-match-p "R3" plain)))
|
|
(should (equal (ebox-region-ids layout) ids))
|
|
(should (gethash right-id ebox--region-box-table)))))
|
|
|
|
(ert-deftest ebox-geometry-update-rerenders-root-once-safely ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((top (ebox-create :content "Top" :width 60))
|
|
(left (ebox-create :content "L" :width 40))
|
|
(right (ebox-create :content "R" :width 40))
|
|
(layout (ebox-stack top (ebox-concat left right)))
|
|
(ids (ebox-region-ids layout))
|
|
(left-id (nth 1 ids)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update left-id :width '(120))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "Top" plain))
|
|
(should (string-match-p "L" plain))
|
|
(should (string-match-p "R" plain)))
|
|
(should (equal (ebox-region-ids layout) ids)))))
|
|
|
|
(ert-deftest ebox-border-color-update-patches-without-full-root-rerender ()
|
|
"A pure border color change should patch owned spans, not rebuild the root."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "L" :width 40
|
|
:border t :border-color "red"))
|
|
(right (ebox-create :content "R" :width 40
|
|
:border t :border-color "green"))
|
|
(layout (ebox-concat left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update left-id :border-color "blue"))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((border-face (get-text-property (point-min) 'face)))
|
|
(should (ebox-test--face-has-key-value-p border-face
|
|
:overline "blue")))
|
|
(should (string-match-p
|
|
"R"
|
|
(buffer-substring-no-properties (point-min) (point-max)))))))
|
|
|
|
(ert-deftest ebox-flex-row-border-color-update-patches-region-role ()
|
|
"Paint-only updates inside flex rows should not fall back to root rerender."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(flex :flex-flow (row wrap) :column-gap (12)
|
|
:padding (0 (12)) :border "#D97757" :bgcolor "#FFF8F2"
|
|
(column
|
|
(box :id left :content "Left" :width (120)
|
|
:padding (0 (8)) :border "#D97757")
|
|
(box :content "Body" :width (120)
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil))
|
|
(column
|
|
(box :id right :content "Right" :width (120)
|
|
:padding (0 (8)) :border "#5E7F6A")
|
|
(box :content "Body" :width (120)
|
|
:padding (0 (8)) :border "#5E7F6A"
|
|
:border-top-p nil)))))
|
|
(left-id (plist-get
|
|
(car (ebox-selector-query-all layout "#left"))
|
|
:region-id)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update left-id :border-bottom-color "blue"))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should-not (plist-get report :root-rerender)))
|
|
(let (bottom-face)
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(while (and (not bottom-face) (< (point) (point-max)))
|
|
(when (equal (get-text-property (point) 'ebox-bb) left-id)
|
|
(setq bottom-face (get-text-property (point) 'face)))
|
|
(forward-char 1)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
bottom-face :underline '(:position t :color "blue")))))))
|
|
|
|
(ert-deftest ebox-paint-update-synthesizes-missing-horizontal-border-surface ()
|
|
"Adding a missing top/bottom paint surface should patch from region anchors."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(flex :flex-flow (row wrap) :column-gap (12)
|
|
:padding (0 (12)) :border "#D97757" :bgcolor "#FFF8F2"
|
|
(column
|
|
(box :id left :content "Left" :width (120)
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-bottom-p nil)
|
|
(box :content "Body" :width (120)
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil))
|
|
(column
|
|
(box :content "Right" :width (120)
|
|
:padding (0 (8)) :border "#5E7F6A"
|
|
:border-bottom-p nil)
|
|
(box :content "Body" :width (120)
|
|
:padding (0 (8)) :border "#5E7F6A"
|
|
:border-top-p nil)))))
|
|
(left-id (plist-get
|
|
(car (ebox-selector-query-all layout "#left"))
|
|
:region-id)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should-not (text-property-search-forward 'ebox-bb left-id t))
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update left-id
|
|
:border-bottom-p t
|
|
:border-bottom-color "blue"))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should-not (plist-get report :root-rerender)))
|
|
(let (bottom-face)
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(while (and (not bottom-face) (< (point) (point-max)))
|
|
(when (equal (get-text-property (point) 'ebox-bb) left-id)
|
|
(setq bottom-face (get-text-property (point) 'face)))
|
|
(forward-char 1)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
bottom-face :underline '(:position t :color "blue")))))))
|
|
|
|
(ert-deftest ebox-horizontal-border-removal-preserves-other-border-colors ()
|
|
"Removing top/bottom border surfaces must not corrupt other border faces."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (case '((:border-top-p bt (bb bl br))
|
|
(:border-bottom-p bb (bt bl br))))
|
|
(let* ((property (nth 0 case))
|
|
(removed-role (nth 1 case))
|
|
(kept-roles (nth 2 case))
|
|
(layout (ebox-create :content "Border"
|
|
:width 80
|
|
:padding '(0 (8))
|
|
:border "#D97757"))
|
|
(region-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(cl-labels ((face-at-role
|
|
(role)
|
|
(let ((prop (alist-get role ebox-region-types))
|
|
face)
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(while (and (not face) (< (point) (point-max)))
|
|
(when (equal (get-text-property (point) prop)
|
|
region-id)
|
|
(setq face (get-text-property (point) 'face)))
|
|
(forward-char 1)))
|
|
face)))
|
|
(ebox-region-update region-id property nil)
|
|
(should-not (face-at-role removed-role))
|
|
(dolist (role kept-roles)
|
|
(should
|
|
(ebox-test--border-face-has-color-p
|
|
(face-at-role role) role "#D97757"))))))))
|
|
|
|
(ert-deftest ebox-side-border-color-patch-toggles-default-paint-exactly ()
|
|
"Side color patches should match default and explicit full-render paint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-create
|
|
:content "Border" :width 80
|
|
:border-left-pixel 2 :border-left-color "#AA0000"
|
|
:border-right-pixel 2 :border-right-color "#AA0000"))
|
|
(region-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update region-id
|
|
:border-left-color nil
|
|
:border-right-color nil)
|
|
(dolist (role '(bl br))
|
|
(let ((face
|
|
(ebox-test--face-at-property
|
|
(buffer-string) (alist-get role ebox-region-types))))
|
|
(should
|
|
(ebox-test--face-has-key-value-p face :inverse-video t))
|
|
(should-not (ebox-test--face-has-key-p face :background))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(ebox-region-update region-id
|
|
:border-left-color "#00AA00"
|
|
:border-right-color "#00AA00")
|
|
(dolist (role '(bl br))
|
|
(let ((face
|
|
(ebox-test--face-at-property
|
|
(buffer-string) (alist-get role ebox-region-types))))
|
|
(should-not (ebox-test--face-has-key-p face :inverse-video))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
face :background "#00AA00"))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-region-update-reuses-buffer-render-viewport-context ()
|
|
"Incremental rerender should use the viewport from the original buffer render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-flex :padding '(0 4) :border "#64748B"
|
|
(ebox-create :content "Flex Child" :width '(120)
|
|
:border t)))
|
|
(region-id (car (ebox--node-all-region-ids layout)))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(with-current-buffer buffer
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id
|
|
:border-color "#2563EB"))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(paint-patch))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-rerender-buffer-with-context-resolves-runtime-viewport ()
|
|
"Runtime rerender should resolve viewport-sized boxes with the new context."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (let ((ebox-viewport-width 240))
|
|
(ebox-build
|
|
'(box :content "Viewport" :width (viewport) :border t))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(should (eq (plist-get node :width) 'viewport))
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(with-current-buffer buffer
|
|
(should (= (ebox--string-pixel-width
|
|
(buffer-substring (point-min) (line-end-position)))
|
|
240)))
|
|
(ebox-rerender-buffer-with-context buffer 160)
|
|
(with-current-buffer buffer
|
|
(should (= (ebox--string-pixel-width
|
|
(buffer-substring (point-min) (line-end-position)))
|
|
160))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-rerender-buffer-with-context-resolves-runtime-viewport-height ()
|
|
"Runtime rerender should resolve viewport-height boxes with the new context."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (let ((ebox-viewport-height 2))
|
|
(ebox-build
|
|
'(box :content "One\nTwo\nThree\nFour"
|
|
:width (120)
|
|
:height (viewport-height)
|
|
:overflow scroll))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(with-current-buffer buffer
|
|
(should (= (length (ebox-string-lines
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
2)))
|
|
(ebox-rerender-buffer-with-context buffer 120 3)
|
|
(with-current-buffer buffer
|
|
(should (= (length (ebox-string-lines
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
3))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-rerender-buffer-with-context-rebuilds-nested-scroll-extents ()
|
|
"Viewport-height rerenders should keep fixed rails outside the scroll box."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (let ((ebox-viewport-width 120)
|
|
(ebox-viewport-height 12))
|
|
(ebox-build
|
|
'(column :id "outer"
|
|
:width (viewport) :height (viewport-height)
|
|
(box :id "top" :content "" :height 2)
|
|
(box :id "root" :height (- (viewport-height) 4)
|
|
:overflow scroll
|
|
(column
|
|
(box :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1)
|
|
(box :content "E" :height 1)
|
|
(box :content "F" :height 1)
|
|
(box :content "G" :height 1)
|
|
(box :content "H" :height 1)
|
|
(box :content "I" :height 1)
|
|
(box :content "J" :height 1)))
|
|
(box :id "bottom" :content "" :height 2)))))
|
|
buffer)
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 120)
|
|
(ebox-viewport-height 12))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
node)))
|
|
(ebox-rerender-buffer-with-context buffer 120 20)
|
|
(with-current-buffer buffer
|
|
(let* ((root-id (plist-get
|
|
(car (ebox-selector-query-buffer buffer "#root"))
|
|
:region-id))
|
|
(top-id (plist-get
|
|
(car (ebox-selector-query-buffer buffer "#top"))
|
|
:region-id))
|
|
(extents (ebox--live-box-extents root-id)))
|
|
(should extents)
|
|
(should (= (length (ebox-string-lines
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
20))
|
|
(should (= (line-number-at-pos (car extents)) 3))
|
|
(should (= (count-lines (car extents) (cdr extents)) 16))
|
|
(save-excursion
|
|
(goto-char (car extents))
|
|
(should (member root-id
|
|
(get-text-property
|
|
(point) 'ebox-content-owners)))
|
|
(should-not (member top-id
|
|
(get-text-property
|
|
(point) 'ebox-content-owners)))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-stable-content-update-patches-without-full-root-rerender ()
|
|
"A content update with unchanged rendered geometry should stay local."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Alpha" :width 80 :height 1))
|
|
(right (ebox-create :content "Right" :width 80 :height 1))
|
|
(layout (ebox-concat left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update left-id :content "Beta"))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "Beta" plain))
|
|
(should-not (string-match-p "Alpha" plain))
|
|
(should (string-match-p "Right" plain))))))
|
|
|
|
(ert-deftest ebox-nested-stable-content-update-patches-leaf-owner ()
|
|
"Stable content updates inside nested layouts should not patch the root."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(flex :flex-flow (row wrap) :column-gap (12)
|
|
:padding (0 (12)) :border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title" :width (190))
|
|
(box :id target :content "before\nsame"
|
|
:width (190) :height 3
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "Metric" :width (190)))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Other" :width (190))
|
|
(box :content "Still here" :width (190))))))
|
|
(target (car (ebox-selector-query-all layout "#target")))
|
|
(target-id (plist-get target :region-id))
|
|
(target-node-id (plist-get target :node-id)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((snapshot (ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) target-node-id)))
|
|
(should snapshot)
|
|
(should (plist-get snapshot :buffer-spans)))
|
|
(ebox-region-update target-id :content "after\nsame")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :owner-ids) (list target-node-id)))
|
|
(should (< (plist-get report :span-count) 10))
|
|
(should-not (plist-get report :full-rerender)))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "after" plain))
|
|
(should-not (string-match-p "before" plain))
|
|
(should (string-match-p "Still here" plain))))))
|
|
|
|
(ert-deftest ebox-flex-contained-geometry-update-does-not-promote-to-root ()
|
|
"Stable flex-contained geometry changes should stop before root."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(column :id root :width (520) :padding (1 (18))
|
|
(flex :id matrix :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1 :padding (0 (12))
|
|
:border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title" :width (190))
|
|
(box :id target :content "width target\nsame height"
|
|
:width (160) :height 3
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "Metric" :width (190)))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Other" :width (190))
|
|
(box :content "Still here" :width (190)))))))
|
|
(target (car (ebox-selector-query-all layout "#target")))
|
|
(target-id (plist-get target :region-id)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update target-id :width '(190))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should-not (plist-get report :full-rerender))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender)))
|
|
(should (< (plist-get report :span-count) 40)))))))
|
|
|
|
(defun ebox-test--nested-width-containment-layout (&optional height)
|
|
"Return a nested flex width-update fixture with optional fixed HEIGHT."
|
|
(let* ((target
|
|
(ebox-create :content "width target\nready to grow"
|
|
:width '(190) :height 3 :padding '(0 (10))
|
|
:border "#999999"))
|
|
(owner
|
|
(apply #'ebox-flex
|
|
(append
|
|
(list :width '(300) :padding '(0 (10))
|
|
:border "#999999" :justify-content 'center
|
|
:align-items 'center)
|
|
(when height (list :height height))
|
|
(list target))))
|
|
(card
|
|
(ebox-column
|
|
(ebox-create :content "Width" :width '(300) :height 2)
|
|
owner
|
|
(ebox-create :content "The target stays in this card"
|
|
:width '(300) :height 3)
|
|
(ebox-create :content "Metric" :width '(300) :height 4)))
|
|
(peer
|
|
(ebox-column
|
|
(ebox-create :content "Peer" :width '(300) :height 2)
|
|
(ebox-create :content "Stable peer" :width '(300) :height 5)
|
|
(ebox-create :content "Footer" :width '(300) :height 7)))
|
|
(layout
|
|
(ebox-flex :width '(720) :flex-flow '(row wrap)
|
|
:column-gap '(12) card peer)))
|
|
(list :layout layout :target target :owner owner)))
|
|
|
|
(ert-deftest ebox-fixed-flex-context-contains-child-width-update ()
|
|
"Fixed flex contexts should patch their five lines, not the whole card."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout 5))
|
|
(layout (plist-get fixture :layout))
|
|
(target (plist-get fixture :target))
|
|
(owner (plist-get fixture :owner))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id (ebox--ensure-node-id owner)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update target-region-id :width '(280))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-contained-partial-flex-content-change-preserves-fixed-slot ()
|
|
"A fixed partial flex should update without disturbing adjacent siblings."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((mark (ebox-create :key 'mark :host-ref 'mark
|
|
:content "○ OFF" :width 'max-content
|
|
:overflow 'hidden))
|
|
(label (ebox-create :key 'label :content " Power off"
|
|
:host-ref 'label :width 'max-content
|
|
:overflow 'hidden))
|
|
(switch (ebox-create :key 'switch :host-ref 'switch
|
|
:width 'max-content :wrap-mode nil
|
|
:overflow 'hidden
|
|
:ebox-content-node (ebox-row mark label)))
|
|
(owner (ebox-flex :width '(496) :min-width '(496)
|
|
:max-width '(496) :height 1 :min-height 1
|
|
:max-height 1 :overflow 'hidden
|
|
:bgcolor "#F7F8FA" :wrap-mode nil
|
|
:flex-flow '(column nowrap) switch))
|
|
(caption (ebox-create :content "switch" :width '(170)
|
|
:min-width '(170) :max-width '(170)
|
|
:height 1 :min-height 1 :max-height 1))
|
|
(outer (ebox-flex :width '(680) :min-width '(680)
|
|
:max-width '(680) :height 1 :min-height 1
|
|
:max-height 1 :overflow 'hidden
|
|
:bgcolor "#F7F8FA" :wrap-mode nil
|
|
:column-gap '(14) :flex-flow '(row nowrap)
|
|
caption owner))
|
|
(footer (ebox-create :content "FOOTER" :width '(680) :height 1))
|
|
(layout (ebox-column outer footer))
|
|
(mark-node-id (ebox--ensure-node-id mark))
|
|
(label-node-id (ebox--ensure-node-id label))
|
|
(owner-node-id (ebox--ensure-node-id owner))
|
|
(caption-region-id (car (ebox-region-ids caption)))
|
|
(footer-region-id (car (ebox-region-ids footer))))
|
|
(plist-put owner :key 'owner)
|
|
(plist-put owner :host-ref 'owner)
|
|
(plist-put outer :key 'outer)
|
|
(plist-put outer :host-ref 'outer)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should (ebox--contained-partial-flex-owner-p
|
|
(current-buffer) owner-node-id))
|
|
(let ((candidate (ebox-candidate-begin (current-buffer))))
|
|
(ebox-candidate-replace
|
|
candidate mark-node-id
|
|
(ebox-create :key 'mark :host-ref 'mark
|
|
:content " ON ● " :width 'max-content
|
|
:overflow 'hidden))
|
|
(ebox-candidate-replace
|
|
candidate label-node-id
|
|
(ebox-create :key 'label :host-ref 'label
|
|
:content " Much longer power on state"
|
|
:width 'max-content
|
|
:overflow 'hidden))
|
|
(ebox-commit (current-buffer) candidate))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids) (list owner-node-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (plist-get report :slot-preserving))
|
|
(should (= (plist-get report :span-count) 1))
|
|
(should-not (memq caption-region-id
|
|
(plist-get report :affected-region-ids)))
|
|
(should-not (memq footer-region-id
|
|
(plist-get report :affected-region-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should
|
|
(ebox-test--buffer-propertized-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-contained-partial-flex-structure-change-preserves-fixed-slot ()
|
|
"A fixed partial flex should own bounded descendant structure changes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((input (ebox-create :key 'input :content "query"
|
|
:overflow 'hidden))
|
|
(content
|
|
(ebox-create :key 'content :host-ref 'content
|
|
:width 'max-content :overflow 'hidden
|
|
:ebox-content-node (ebox-column input)))
|
|
(owner (ebox-flex :width '(180) :height 2 :overflow 'hidden
|
|
:flex-flow '(column nowrap) content))
|
|
(caption (ebox-create :content "search" :width '(80) :height 2))
|
|
(outer (ebox-row caption owner))
|
|
(footer (ebox-create :content "FOOTER" :width '(260) :height 1))
|
|
(layout (ebox-column outer footer))
|
|
(content-node-id (ebox--ensure-node-id content))
|
|
(owner-node-id (ebox--ensure-node-id owner))
|
|
(caption-region-id (car (ebox-region-ids caption)))
|
|
(footer-region-id (car (ebox-region-ids footer))))
|
|
(plist-put owner :key 'owner)
|
|
(plist-put owner :host-ref 'owner)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((candidate (ebox-candidate-begin (current-buffer))))
|
|
(ebox-candidate-replace
|
|
candidate content-node-id
|
|
(ebox-create
|
|
:key 'content :host-ref 'content
|
|
:width 'max-content :overflow 'hidden
|
|
:ebox-content-node
|
|
(ebox-column
|
|
(ebox-create :key 'input :content "query" :overflow 'hidden)
|
|
(ebox-create :key 'option :content "Apple" :overflow 'hidden))))
|
|
(ebox-commit (current-buffer) candidate))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids) (list owner-node-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (plist-get report :slot-preserving))
|
|
(should (= (plist-get report :span-count) 2))
|
|
(should-not (memq caption-region-id
|
|
(plist-get report :affected-region-ids)))
|
|
(should-not (memq footer-region-id
|
|
(plist-get report :affected-region-ids)))
|
|
(should
|
|
(ebox-test--buffer-propertized-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-contained-flex-publication-span-rejects-foreign-sibling ()
|
|
"A declared slot must not expand through a sibling's direct content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((target (ebox-create :content "A" :overflow 'hidden))
|
|
(owner (ebox-flex :width '(180) :height 1 :overflow 'hidden
|
|
:flex-flow '(column nowrap) target))
|
|
(sibling (ebox-create :content "RIGHT" :width '(80) :height 1))
|
|
(layout (ebox-flex :width '(260) :height 1
|
|
:flex-flow '(row nowrap) owner sibling))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id (ebox--ensure-node-id owner))
|
|
(sibling-region-id (car (ebox-region-ids sibling))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((snapshot
|
|
(ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) owner-node-id))
|
|
(spans (plist-get snapshot :buffer-spans))
|
|
(expanded
|
|
(ebox-buffer--contained-flex-publication-spans
|
|
(current-buffer) owner-node-id owner spans))
|
|
(foreign-position (1- (cdar expanded))))
|
|
(should (ebox--contained-partial-flex-owner-p
|
|
(current-buffer) owner-node-id))
|
|
(let ((inhibit-read-only t))
|
|
(put-text-property foreign-position (1+ foreign-position)
|
|
'ebox-content sibling-region-id)
|
|
(unwind-protect
|
|
(should-not
|
|
(ebox-buffer--contained-flex-publication-spans
|
|
(current-buffer) owner-node-id owner spans))
|
|
(put-text-property foreign-position (1+ foreign-position)
|
|
'ebox-content nil))))
|
|
(ebox-region-update
|
|
target-region-id :content
|
|
"This content stays inside its parent's proven fallback")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should
|
|
(ebox-test--buffer-propertized-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-auto-height-flex-context-keeps-ancestor-width-fallback ()
|
|
"Auto-height flex contexts must not contain descendant width reflow."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout))
|
|
(layout (plist-get fixture :layout))
|
|
(target (plist-get fixture :target))
|
|
(owner (plist-get fixture :owner))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id (ebox--ensure-node-id owner)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should-not (ebox--definite-containment-formatting-context-p
|
|
(current-buffer) owner-node-id))
|
|
(ebox-region-update target-region-id :width '(280))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should-not (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should (eq (plist-get report :owner-type) 'stack))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-intrinsic-constrained-flex-context-keeps-ancestor-fallback ()
|
|
"Intrinsic min/max constraints must disable definite containment."
|
|
(dolist (max-width '(min-content (fit-content 260)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout 5))
|
|
(layout (plist-get fixture :layout))
|
|
(target (plist-get fixture :target))
|
|
(owner (plist-get fixture :owner))
|
|
(owner-box (plist-get owner :box))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id (ebox--ensure-node-id owner)))
|
|
(ebox-put owner-box :max-width max-width)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should-not (ebox--definite-containment-formatting-context-p
|
|
(current-buffer) owner-node-id))
|
|
(ebox-region-update target-region-id :width '(280))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should-not (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-visible-overflow-flex-context-keeps-ancestor-fallback ()
|
|
"A fixed context must not contain an unowned visible-overflow suffix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout 5))
|
|
(layout (plist-get fixture :layout))
|
|
(target (plist-get fixture :target))
|
|
(owner (plist-get fixture :owner))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id (ebox--ensure-node-id owner)))
|
|
(ebox-put target :content "line 1\nline 2\nline 3\nline 4")
|
|
(ebox-put target :height 2)
|
|
(ebox-put target :overflow 'visible)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should-not (ebox--definite-containment-formatting-context-p
|
|
(current-buffer) owner-node-id))
|
|
(ebox-region-update target-region-id :width '(280))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should-not (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-visible-overflow-flex-wrapper-disables-width-containment ()
|
|
"A visible-overflow flex wrapper must not contain child width changes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((target
|
|
(ebox-create :content "child" :width '(190)
|
|
:height 5 :min-height 5))
|
|
(owner
|
|
(ebox-flex :width '(300) :height 2 :overflow 'visible
|
|
:align-items 'flex-start target))
|
|
(layout
|
|
(ebox-stack owner
|
|
(ebox-create :content "footer" :width '(300)
|
|
:height 2)))
|
|
(owner-node-id (ebox--ensure-node-id owner)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should (= (ebox-string-height (ebox-render owner)) 5))
|
|
(should-not (ebox--definite-containment-formatting-context-p
|
|
(current-buffer) owner-node-id)))))
|
|
|
|
(ert-deftest ebox-fixed-flex-context-contains-child-block-size-update ()
|
|
"A fixed flex should contain a child block-size change in its five lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout 5))
|
|
(layout (plist-get fixture :layout))
|
|
(target (plist-get fixture :target))
|
|
(target-region-id (car (ebox-region-ids target)))
|
|
(owner-node-id
|
|
(ebox--ensure-node-id (plist-get fixture :owner))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update target-region-id :height 4)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list owner-node-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should-not (member root-id (plist-get report :owner-ids))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-fixed-flex-own-width-change-skips-containment-span-probe ()
|
|
"A fixed flex must not contain a change to its own outer width."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((fixture (ebox-test--nested-width-containment-layout 5))
|
|
(layout (plist-get fixture :layout))
|
|
(owner (plist-get fixture :owner))
|
|
(owner-region-id (car (ebox-region-ids owner)))
|
|
(span-patch-calls 0)
|
|
(original-span-patch
|
|
(symbol-function 'ebox-buffer-apply-span-patch)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-span-patch)
|
|
(lambda (&rest args)
|
|
(cl-incf span-patch-calls)
|
|
(apply original-span-patch args))))
|
|
(ebox-region-update owner-region-id :width '(320)))
|
|
(should (= span-patch-calls 0))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-flex-main-footprint-change-skips-flex-span-probe ()
|
|
"Flex main footprint changes should not render a large flex owner twice."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(column :id root :width (520) :padding (1 (18))
|
|
(flex :id matrix :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1 :padding (0 (12))
|
|
:border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title" :width (190))
|
|
(box :id target :content "width target\nsame height"
|
|
:width (160) :height 3
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "Metric" :width (190)))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Other" :width (190))
|
|
(box :content "Still here" :width (190)))))))
|
|
(target (car (ebox-selector-query-all layout "#target")))
|
|
(target-id (plist-get target :region-id))
|
|
(span-patch-calls 0)
|
|
(original-span-patch (symbol-function 'ebox-buffer-apply-span-patch)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-span-patch)
|
|
(lambda (&rest args)
|
|
(cl-incf span-patch-calls)
|
|
(apply original-span-patch args))))
|
|
(ebox-region-update target-id
|
|
:width '(210)
|
|
:min-width '(150)
|
|
:max-width '(260)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (= span-patch-calls 0))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(defun ebox-test--flex-line-width-owner-layout (&optional count width)
|
|
"Return a wide flex layout whose first row has a nested width target."
|
|
(let* ((count (or count 12))
|
|
(resolved-width (if (eq width :auto)
|
|
nil
|
|
(or width '(2600))))
|
|
(target
|
|
(ebox-create :id "target" :content "width target\nmoves sibling layout"
|
|
:width '(160) :height 3 :padding '(0 (8))
|
|
:border "#999999"))
|
|
(first
|
|
(ebox-column
|
|
(ebox-create :content "Title" :width '(190))
|
|
target
|
|
(ebox-create :content "Metric" :width '(190) :height 4))))
|
|
(apply #'ebox-flex
|
|
(append (list :flex-flow '(row wrap)
|
|
:column-gap '(12)
|
|
:row-gap 1
|
|
:padding '(0 (12))
|
|
:border "#999999")
|
|
(when resolved-width
|
|
(list :width resolved-width))
|
|
(list first)
|
|
(cl-loop for index from 1 below count
|
|
collect
|
|
(ebox-column
|
|
(ebox-create
|
|
:content (format "Title %02d" index)
|
|
:width '(190))
|
|
(ebox-create :content "Peer\nsame row"
|
|
:width '(190) :height 3
|
|
:padding '(0 (8))
|
|
:border "#999999")
|
|
(ebox-create :content "Metric"
|
|
:width '(190) :height 4)))))))
|
|
|
|
(ert-deftest ebox-flex-line-rerender-report-exposes-fast-path ()
|
|
"Reports should expose when an owner rerender only patched one flex row."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--flex-line-width-owner-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer) "#target")))
|
|
(ebox-region-update region-id
|
|
:width '(210)
|
|
:min-width '(150)
|
|
:max-width '(260))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (plist-get report :flex-line-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-line-rerender-skips-auto-width-owner ()
|
|
"Auto-width flex owners should fall back instead of slicing a moving suffix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--flex-line-width-owner-layout 12 :auto)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer) "#target")))
|
|
(ebox-region-update region-id
|
|
:width '(210)
|
|
:min-width '(150)
|
|
:max-width '(260))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should-not (plist-get report :flex-line-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-line-rerender-avoids-all-child-span-snapshots ()
|
|
"Flex row rerender should locate and render one row without all-child fanout."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--flex-line-width-owner-layout 16)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(unrelated-child-id
|
|
(ebox--ensure-node-id
|
|
(car (last (ebox--node-children layout)))))
|
|
(span-snapshot-calls 0)
|
|
(measure-calls 0)
|
|
(original (symbol-function 'ebox--ensure-layout-snapshot-spans))
|
|
(original-measure (symbol-function 'ebox--flex-measure-source)))
|
|
(cl-letf (((symbol-function 'ebox--ensure-layout-snapshot-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf span-snapshot-calls)
|
|
(apply original args)))
|
|
((symbol-function 'ebox--flex-measure-source)
|
|
(lambda (&rest args)
|
|
(cl-incf measure-calls)
|
|
(apply original-measure args))))
|
|
(ebox-region-update region-id
|
|
:width '(210)
|
|
:min-width '(150)
|
|
:max-width '(260)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-get report :flex-line-rerender))
|
|
(should (<= span-snapshot-calls 20))
|
|
(should (< measure-calls 16))
|
|
(should
|
|
(plist-get
|
|
(ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) unrelated-child-id)
|
|
:buffer-spans))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(defun ebox-test--dynamic-update-row-layout ()
|
|
"Return a small flex-row layout shaped like the dynamic update matrix."
|
|
(ebox-build
|
|
'(column :id root :width (1200) :padding (1 (18))
|
|
(flex :id matrix :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1 :padding (0 (12))
|
|
:border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Reference\nshort" :width (190))
|
|
(box :id scroll :content "line 1\nline 2\nline 3\nline 4"
|
|
:width (190) :height 2 :padding (0 (8))
|
|
:border "#999999" :overflow scroll)
|
|
(box :content "Metric" :width (190) :height 4))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Height\nowner" :width (190))
|
|
(box :id height :content "height target\nexpands block"
|
|
:width (190) :height 2 :padding (0 (8))
|
|
:border "#999999")
|
|
(box :content "Metric" :width (190) :height 4))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Margin\nslot stable" :width (190))
|
|
(box :id margin :content "margin target\nparent placement"
|
|
:width (170) :height 3 :padding (0 (8))
|
|
:border "#999999")
|
|
(box :content "Metric" :width (190) :height 4))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Overflow\nowner" :width (190))
|
|
(box :id overflow :content "overflow target\nextra line\nanother line"
|
|
:width (190) :height 2 :padding (0 (8))
|
|
:border "#999999" :overflow scroll)
|
|
(box :content "Metric" :width (190) :height 4))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Tall peer\nkeeps row slot" :width (190))
|
|
(box :content "tall\npeer\nsets\nline\ncross" :width (190)
|
|
:height 5 :padding (0 (8)) :border "#999999")
|
|
(box :content "Metric" :width (190) :height 4))))))
|
|
|
|
(defun ebox-test--dynamic-update-tight-row-layout ()
|
|
"Return a flex-row layout whose target growth exceeds its old item slot."
|
|
(ebox-build
|
|
'(column :id root :width (720)
|
|
(box :content "Header" :width (720))
|
|
(column :id panel :width (720) :border "#999999"
|
|
(flex :id matrix :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1 :padding (0 (12))
|
|
:border "#999999"
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Height\nowner" :width (190))
|
|
(box :id height :content "height target\nexpands block"
|
|
:width (190) :height 2 :padding (0 (8))
|
|
:border "#999999")
|
|
(box :content "Metric" :width (190) :height 2))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Peer" :width (190))
|
|
(box :content "peer\nsame row" :width (190)
|
|
:height 2 :padding (0 (8)) :border "#999999")
|
|
(box :content "Metric" :width (190) :height 2)))))))
|
|
|
|
(defun ebox-test--selector-region-id (buffer selector)
|
|
"Return the first editable region id matching SELECTOR in BUFFER."
|
|
(plist-get (car (ebox-selector-query-buffer buffer selector)) :region-id))
|
|
|
|
(defun ebox-test--visual-line-signature (line)
|
|
"Return LINE's visible glyph positions and total pixel width."
|
|
(let ((pixel 0)
|
|
glyphs)
|
|
(cl-loop for index below (length line)
|
|
for next = (1+ index)
|
|
for char = (aref line index)
|
|
for width = (ebox--substring-pixel-width line index next)
|
|
do (progn
|
|
(unless (eq char ?\s)
|
|
(push (cons pixel char) glyphs))
|
|
(setq pixel (+ pixel width))))
|
|
(list :width pixel :glyphs (nreverse glyphs))))
|
|
|
|
(defun ebox-test--rendered-visually-equal-p (actual expected)
|
|
"Return non-nil when ACTUAL and EXPECTED have the same visible layout."
|
|
(let ((actual-lines (ebox-string-lines actual))
|
|
(expected-lines (ebox-string-lines expected))
|
|
(ok t))
|
|
(setq ok (= (length actual-lines) (length expected-lines)))
|
|
(while (and ok actual-lines expected-lines)
|
|
(setq ok (equal (ebox-test--visual-line-signature (car actual-lines))
|
|
(ebox-test--visual-line-signature (car expected-lines)))
|
|
actual-lines (cdr actual-lines)
|
|
expected-lines (cdr expected-lines)))
|
|
ok))
|
|
|
|
(defun ebox-test--buffer-visually-matches-runtime-render-p ()
|
|
"Return non-nil when current buffer visually equals its runtime root render."
|
|
(let* ((ebox--scroll-global-state (make-hash-table :test 'equal))
|
|
(ebox--region-box-table (make-hash-table :test 'equal))
|
|
(expected
|
|
(ebox--with-buffer-render-context (current-buffer)
|
|
(ebox-render (ebox--buffer-root-node (current-buffer))))))
|
|
(ebox-test--rendered-visually-equal-p
|
|
(buffer-substring (point-min) (point-max))
|
|
expected)))
|
|
|
|
(defun ebox-test--buffer-propertized-matches-runtime-render-p ()
|
|
"Return non-nil when the current buffer exactly matches a runtime render."
|
|
(let* ((ebox--scroll-global-state (make-hash-table :test 'equal))
|
|
(ebox--region-box-table (make-hash-table :test 'equal))
|
|
(expected
|
|
(ebox--with-buffer-render-context (current-buffer)
|
|
(ebox-render (ebox--buffer-root-node (current-buffer))))))
|
|
(equal-including-properties
|
|
(buffer-substring (point-min) (point-max)) expected)))
|
|
|
|
(ert-deftest ebox-scroll-offset-update-uses-scroll-fast-path ()
|
|
"Programmatic scroll-offset updates should replace visible lines without render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-test--dynamic-update-row-layout))
|
|
render-calls)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#scroll"))
|
|
(original-render (symbol-function 'ebox-render)))
|
|
(setq render-calls 0)
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest args)
|
|
(cl-incf render-calls)
|
|
(apply original-render args))))
|
|
(ebox-region-update region-id :scroll-offset 1))
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (= render-calls 0))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-fast-path))
|
|
(should (string-match-p "line 2" plain))
|
|
(should-not (string-match-p "line 1" plain)))))))
|
|
|
|
(ert-deftest ebox-dynamic-update-hot-paths-use-region-owner-index ()
|
|
"Paint, geometry, scroll, and batch updates should avoid region tree walks."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((paint (ebox-create :content "Paint" :width '(80)
|
|
:color "#111111"))
|
|
(geometry (ebox-create :content "Geometry" :width '(80)))
|
|
(scroll (ebox-create :content "line 1\nline 2\nline 3"
|
|
:width '(80) :height 1 :overflow 'scroll))
|
|
(batch (ebox-create :content "Batch" :width '(80)
|
|
:color "#111111"))
|
|
(flex (ebox-flex :width '(120) :padding 1 :color "#111111"
|
|
(ebox-create :content "Flex" :width '(80))))
|
|
(flex-wrapper (plist-get flex :box))
|
|
(paint-id (ebox--ensure-region-id paint))
|
|
(geometry-id (ebox--ensure-region-id geometry))
|
|
(scroll-id (ebox--ensure-region-id scroll))
|
|
(batch-id (ebox--ensure-region-id batch))
|
|
(flex-wrapper-id (ebox--ensure-region-id flex-wrapper))
|
|
(layout (ebox-column paint geometry scroll batch flex)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(region-node-table (ebox--buffer-region-node-table buffer))
|
|
(original-path
|
|
(symbol-function 'ebox--node-path-to-region))
|
|
(recursive-calls 0))
|
|
(cl-letf (((symbol-function 'ebox--node-path-to-region)
|
|
(lambda (&rest args)
|
|
(cl-incf recursive-calls)
|
|
(apply original-path args))))
|
|
(ebox-region-update paint-id :color "#DC2626")
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'paint-patch))
|
|
(should (= recursive-calls 0))
|
|
|
|
(ebox-region-update geometry-id :width '(100))
|
|
(should (memq :width
|
|
(plist-get (ebox-test--buffer-update-report) :dirty-keys)))
|
|
(should (= recursive-calls 0))
|
|
|
|
(ebox-region-update scroll-id :scroll-offset 1)
|
|
(should (plist-get (ebox-test--buffer-update-report) :scroll-fast-path))
|
|
(should (= recursive-calls 0))
|
|
|
|
(ebox-region-update flex-wrapper-id :color "#7C3AED")
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'paint-patch))
|
|
(should (equal (car (plist-get (ebox-test--buffer-update-report) :owner-ids))
|
|
(ebox--ensure-node-id flex)))
|
|
(should (= recursive-calls 0))
|
|
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update batch-id :color "#2563EB")
|
|
(ebox-incremental-flush buffer)
|
|
(should (= (plist-get (ebox-test--buffer-update-report) :flush-count) 1))
|
|
(should (= recursive-calls 0))
|
|
|
|
(ebox--refresh-buffer-layout-snapshots buffer)
|
|
(should (= recursive-calls 0)))
|
|
(should (eq (ebox--buffer-region-node-table buffer)
|
|
region-node-table))))))
|
|
|
|
(ert-deftest ebox-scroll-offset-fast-path-passes-old-offset ()
|
|
"Programmatic scroll updates should preserve the old offset for sliding."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout))
|
|
seen-old-offset
|
|
(forced-window-updates 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#scroll")))
|
|
(cl-letf (((symbol-function
|
|
'ebox--scroll-replace-rendered-content-window)
|
|
(lambda (_state _region-id old-offset)
|
|
(setq seen-old-offset old-offset)
|
|
(list (cons (point-min) (point-min)))))
|
|
((symbol-function 'force-window-update)
|
|
(lambda (&optional _object)
|
|
(cl-incf forced-window-updates))))
|
|
(ebox-region-update region-id :scroll-offset 1))
|
|
(should (= seen-old-offset 0))
|
|
(should (= forced-window-updates 0))))))
|
|
|
|
(ert-deftest ebox-scroll-offset-fast-path-uses-content-markers ()
|
|
"Scroll updates should replace cached visible content spans directly."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#scroll"))
|
|
(state (ebox--scroll-get-state region-id))
|
|
(scan-replace-count 0)
|
|
(original-replace (symbol-function 'ebox--region-replace-line)))
|
|
(should (plist-get state :content-span-markers))
|
|
(cl-letf (((symbol-function 'ebox--region-replace-line)
|
|
(lambda (&rest args)
|
|
(cl-incf scan-replace-count)
|
|
(apply original-replace args))))
|
|
(ebox-region-update region-id :scroll-offset 1))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-get report :scroll-fast-path))
|
|
(should (= scan-replace-count 0)))))))
|
|
|
|
(ert-deftest ebox-scroll-offset-fast-path-preserves-line-display-properties ()
|
|
"Scroll updates must not spread one alignment space across the new line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id scroll
|
|
:content "第 1 行\n第 2 行\n第 3 行\n第 4 行"
|
|
:width (230) :height 2 :padding (0 (10))
|
|
:border "#9CA3AF" :bgcolor "#F8FAFC"
|
|
:color "#3D3A35" :text-align center
|
|
:overflow scroll :scroll-offset 0))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#scroll"))
|
|
forced-buffer
|
|
(nondestructive-replacements 0)
|
|
(original-replace-region-contents
|
|
(symbol-function 'replace-region-contents)))
|
|
(cl-letf (((symbol-function 'replace-region-contents)
|
|
(lambda (&rest args)
|
|
(cl-incf nondestructive-replacements)
|
|
(apply original-replace-region-contents args)))
|
|
((symbol-function 'force-window-update)
|
|
(lambda (&optional object)
|
|
(setq forced-buffer object))))
|
|
(ebox-region-update region-id :scroll-offset 2))
|
|
(should (plist-get (ebox-test--buffer-update-report) :scroll-fast-path))
|
|
(should (> nondestructive-replacements 0))
|
|
(should-not forced-buffer)
|
|
(should-not
|
|
(cl-loop for pos from (point-min) below (point-max)
|
|
thereis (and (not (eq (char-after pos) ?\s))
|
|
(get-text-property pos 'display))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-scroll-offset-fast-path-requires-stable-marker-lengths ()
|
|
"Scroll marker patches should not shift later buffer positions."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id scroll :content
|
|
"x\nsubstantially longer visible line"
|
|
:width (180) :height 1 :overflow scroll
|
|
:scroll-offset 0))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#scroll"))
|
|
(state (ebox--scroll-get-state region-id))
|
|
(lines (plist-get state :content-lines)))
|
|
(should (not (= (length (nth 0 lines))
|
|
(length (nth 1 lines)))))
|
|
(ebox-region-update region-id :scroll-offset 1)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should-not (plist-get report :scroll-fast-path))
|
|
(let ((state (ebox-scroll-state region-id)))
|
|
(should (= (plist-get state :scroll-offset) 1))
|
|
(should-not (plist-get state :lazy-scroll-prefix-dirty))
|
|
(should-not
|
|
(plist-get state :lazy-scroll-window-refresh-required)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-nested-scroll-offset-transaction-replays-outer-cache ()
|
|
"Nested scroll updates should atomically survive outer cache replay."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id root :width (180) :height 2 :overflow scroll
|
|
(column
|
|
(box :id inner :width (180) :height 2 :overflow scroll
|
|
:content "inner 0\ninner 1\ninner 2\ninner 3")
|
|
(box :content "outer 0\nouter 1" :height 2)))))
|
|
root-id inner-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root")
|
|
inner-id (ebox-test--selector-region-id (current-buffer) "#inner"))
|
|
(ebox-region-update inner-id :scroll-offset 1)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state inner-id))
|
|
(plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (= (plist-get state :scroll-offset) 1))
|
|
(should (string-match-p "inner 1" plain))
|
|
(should (string-match-p "inner 2" plain))
|
|
(should-not (string-match-p "inner 0" plain)))
|
|
(should (ebox--scroll-region-by root-id 2 48))
|
|
(should (string-match-p
|
|
"outer 0"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (ebox--scroll-region-by root-id -2 48))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "inner 1" plain))
|
|
(should (string-match-p "inner 2" plain))
|
|
(should-not (string-match-p "inner 0" plain)))
|
|
(should (= (plist-get (ebox-scroll-state inner-id) :scroll-offset) 1))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-scroll-content-window-declines-horizontal-gaps ()
|
|
"Bulk scroll replacement should leave padded line gaps to marker fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let ((region-id 7001)
|
|
starts ends state
|
|
(marker-replacements 0))
|
|
(dolist (entry '(("AA" "x" "PP\n") ("AA" "y" "PP")))
|
|
(insert (car entry))
|
|
(push (point) starts)
|
|
(insert (propertize (cadr entry)
|
|
'ebox-content region-id
|
|
'ebox-content-idx (1- (length starts))))
|
|
(push (point) ends)
|
|
(insert (caddr entry)))
|
|
(setq starts (nreverse starts)
|
|
ends (nreverse ends))
|
|
(let ((markers
|
|
(apply #'vector
|
|
(cl-mapcar (lambda (start end)
|
|
(cons (copy-marker start nil)
|
|
(copy-marker end t)))
|
|
starts ends))))
|
|
(setq state (list :region-id region-id
|
|
:buffer (current-buffer)
|
|
:content-span-markers markers))
|
|
(unwind-protect
|
|
(progn
|
|
(puthash region-id state ebox--scroll-global-state)
|
|
(should-not (ebox--scroll-content-window state 2))
|
|
(let ((before-size (buffer-size))
|
|
(original
|
|
(symbol-function 'ebox--scroll-replace-content-marker)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-replace-content-marker)
|
|
(lambda (&rest args)
|
|
(cl-incf marker-replacements)
|
|
(apply original args))))
|
|
(should (ebox--scroll-update-content
|
|
region-id '("m" "n"))))
|
|
(should (= marker-replacements 2))
|
|
(should (= (buffer-size) before-size))
|
|
(should (equal (buffer-substring-no-properties
|
|
(point-min) (point-max))
|
|
"AAmPP\nAAnPP"))))
|
|
(remhash region-id ebox--scroll-global-state)
|
|
(dotimes (idx (length markers))
|
|
(let ((span (aref markers idx)))
|
|
(set-marker (car span) nil)
|
|
(set-marker (cdr span) nil))))))))
|
|
|
|
(ert-deftest ebox-scroll-child-layout-window-patches-without-rerender ()
|
|
"Scroll boxes made from child layouts should patch the fixed viewport."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "a" :content "A" :height 1)
|
|
(box :id "b" :content "B" :height 1)
|
|
(box :id "c" :content "C" :height 1)
|
|
(box :id "d" :content "D" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout)))
|
|
rerender-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(markers (ebox--scroll-content-marker-spans
|
|
(plist-get state :content-span-markers))))
|
|
(should (= (plist-get state :content-height) 2))
|
|
(should (= (length markers) 2)))
|
|
(cl-letf (((symbol-function 'ebox--rerender-box)
|
|
(lambda (&rest _args)
|
|
(setq rerender-called t)
|
|
nil))
|
|
((symbol-function 'ebox--scroll-replace-rendered-window)
|
|
(lambda (&rest _args)
|
|
(error "unexpected rendered-window fallback"))))
|
|
(should (ebox--scroll-region-by root-id 1)))
|
|
(should-not rerender-called)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (= (length (ebox-string-lines plain)) 2))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))
|
|
(should-not (string-match-p "A" plain))))))
|
|
|
|
(ert-deftest ebox-scroll-child-layout-window-keeps-viewport-padding-and-border ()
|
|
"Fast scroll window patches should keep scroll box padding and border."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 4 :box-sizing border-box
|
|
:overflow scroll
|
|
:padding-top 1 :padding-bottom 1
|
|
:border-top-p t :border-top-color "red"
|
|
:border-bottom-p t :border-bottom-color "blue"
|
|
(column
|
|
(box :id "a" :content "A" :height 1)
|
|
(box :id "b" :content "B" :height 1)
|
|
(box :id "c" :content "C" :height 1)
|
|
(box :id "d" :content "D" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout)))
|
|
rerender-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should (plist-get (ebox--scroll-get-state root-id)
|
|
:rendered-content-lines))
|
|
(cl-letf (((symbol-function 'ebox--rerender-box)
|
|
(lambda (&rest _args)
|
|
(setq rerender-called t)
|
|
nil)))
|
|
(should (ebox--scroll-region-by root-id 1)))
|
|
(should-not rerender-called)
|
|
(should (equal (get-text-property (point-min) 'ebox-bt)
|
|
root-id))
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(should (equal (get-text-property (point) 'ebox-bb)
|
|
root-id)))
|
|
(should (equal (get-text-property (point-min) 'ebox-pt)
|
|
root-id))
|
|
(save-excursion
|
|
(goto-char (point-min))
|
|
(forward-line 3)
|
|
(should (equal (get-text-property (point) 'ebox-pb)
|
|
root-id)))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (= (length (ebox-string-lines plain)) 4))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))
|
|
(should-not (string-match-p "A" plain))))))
|
|
|
|
(ert-deftest ebox-flex-row-height-update-rerenders-slot-owner-not-root ()
|
|
"Flex row item height changes should patch the old row slot, not the root."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#height"))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update region-id
|
|
:height 4 :min-height 3 :max-height 6
|
|
:padding-top 1 :padding-bottom 1)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-row-height-growth-rerenders-flex-ancestor-not-root ()
|
|
"Flex row item growth beyond its old slot should use a flex ancestor fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-tight-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#height"))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update region-id
|
|
:height 4 :min-height 3 :max-height 6
|
|
:padding-top 1 :padding-bottom 1)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-row-inline-margin-update-uses-slot-span-patch ()
|
|
"Inline margin changes inside a stable flex row slot should stay span-local."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((height-id (ebox-test--selector-region-id (current-buffer)
|
|
"#height"))
|
|
(region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#margin"))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update height-id
|
|
:height 4 :min-height 3 :max-height 6
|
|
:padding-top 1 :padding-bottom 1)
|
|
(ebox-region-update region-id
|
|
:margin (list 0 '(8) 0 '(8))
|
|
:margin-inline '((8) (8))
|
|
:margin-block '(0 0)
|
|
:margin-top 0 :margin-right '(8)
|
|
:margin-bottom 0 :margin-left '(8))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (eq (plist-get report :owner-type) 'box))
|
|
(should (plist-get report :slot-preserving))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-border-box-padding-impact-stays-internal-fragment ()
|
|
"Fixed border-box padding changes should remain an internal fragment impact."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (480)
|
|
(flex :id row :flex-flow (row nowrap) :column-gap (12)
|
|
(box :id padding :content "padding target"
|
|
:width (190) :height 3 :box-sizing border-box
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "peer" :width (190) :height 3
|
|
:border "#999999"))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#padding")))
|
|
(ebox-region-update region-id :padding-left (list 24))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (member 'internal-fragment
|
|
(plist-get report :impact-vector)))
|
|
(should-not (member 'parent-layout
|
|
(plist-get report :impact-vector)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-border-box-padding-shorthand-uses-one-local-span-patch ()
|
|
"Mixed block/inline padding shorthand should not promote to a root rerender."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (480)
|
|
(flex :id row :flex-flow (row nowrap) :column-gap (12)
|
|
(box :id padding :content "padding target"
|
|
:width (190) :height 4 :box-sizing border-box
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :content "peer" :width (190) :height 4
|
|
:border "#999999"))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((match (car (ebox-selector-query-buffer
|
|
(current-buffer) "#padding")))
|
|
(node-id (ebox--ensure-node-id (plist-get match :node)))
|
|
(region-id (plist-get match :region-id))
|
|
(mixed-entry
|
|
(list :node-id node-id :dirty-kind 'geometry
|
|
:changed-keys
|
|
'(:padding-top-height :padding-right-pixel
|
|
:padding-bottom-height :padding-left-pixel))))
|
|
(should
|
|
(ebox--dirty-entry-border-box-internal-span-p
|
|
(current-buffer) mixed-entry))
|
|
(ebox-region-update region-id :padding '(2 (20) 0 (8)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :patch-ops) '(span-patch)))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should (member 'internal-fragment
|
|
(plist-get report :impact-vector)))
|
|
(should (member 'external-footprint-proof
|
|
(plist-get report :impact-vector)))
|
|
(should-not (member 'parent-layout
|
|
(plist-get report :impact-vector)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-border-box-padding-span-proof-rejects-overfull-height ()
|
|
"Border-box padding cannot claim a fixed footprint without a content line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id padding :content "padding target"
|
|
:width (190) :height 4 :box-sizing border-box
|
|
:padding 2 :border "#999999"))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((match (car (ebox-selector-query-buffer
|
|
(current-buffer) "#padding")))
|
|
(node-id (ebox--ensure-node-id (plist-get match :node))))
|
|
(let ((entry
|
|
(list :node-id node-id :dirty-kind 'geometry
|
|
:changed-keys
|
|
'(:padding-top-height :padding-right-pixel
|
|
:padding-bottom-height :padding-left-pixel))))
|
|
(should-not
|
|
(ebox--dirty-entry-border-box-internal-span-p
|
|
(current-buffer) entry)))))))
|
|
|
|
(ert-deftest ebox-overflow-impact-keeps-conservative-owner-rerender ()
|
|
"Overflow changes should stay conservative until clipping proof exists."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#overflow")))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (member 'clipping (plist-get report :impact-vector)))
|
|
(should (member 'external-footprint
|
|
(plist-get report :impact-vector)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-owner-rerender-preserves-missing-wrapper-context ()
|
|
"Nested owner rerenders should retain outer paint and surface metadata."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-put layout :color "#1F2328")
|
|
(ebox-put layout :bgcolor "#FAF7F0")
|
|
(ebox-put layout :surface-properties
|
|
'(ebox-test-role outer-wrapper))
|
|
(ebox-put (plist-get (car (ebox--node-children layout)) :box)
|
|
:bgcolor "#FBF9FF")
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#overflow")))
|
|
(ebox-region-update region-id :overflow 'visible)
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'owner-rerender))
|
|
(goto-char (point-min))
|
|
(search-forward "overflow target")
|
|
(let ((face (get-text-property (match-beginning 0) 'face)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "#1F2328"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#FBF9FF"))
|
|
(should
|
|
(eq (get-text-property
|
|
(match-beginning 0) 'ebox-test-role)
|
|
'outer-wrapper)))))))
|
|
|
|
(ert-deftest ebox-owner-rerender-preserves-descendant-region-ownership ()
|
|
"Recursive owner rerenders should keep each descendant's stable region id."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "ownership-parent" :width (240) :padding 1
|
|
(box :id "ownership-child" :content "child ownership"
|
|
:width (120) :height 2 :border "#2563EB")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((parent-id (ebox-test--selector-region-id
|
|
(current-buffer) "#ownership-parent"))
|
|
(child-id (ebox-test--selector-region-id
|
|
(current-buffer) "#ownership-child")))
|
|
(should (text-property-any
|
|
(point-min) (point-max) 'ebox-bl child-id))
|
|
;; This test targets recursive rendering ownership. Supply the
|
|
;; contiguous owner extent directly so scanner eligibility is an
|
|
;; independent concern.
|
|
(ebox--set-box-extents parent-id (point-min) (point-max))
|
|
(ebox--rerender-box parent-id)
|
|
(should (text-property-any
|
|
(point-min) (point-max) 'ebox-bl child-id))
|
|
(should (text-property-any
|
|
(point-min) (point-max) 'ebox-content child-id))
|
|
(should-not (text-property-any
|
|
(point-min) (point-max) 'ebox-bl parent-id))))))
|
|
|
|
(ert-deftest ebox-visible-scroll-content-update-preserves-wrapper-paint ()
|
|
"Visible cached content patches should preserve nested wrapper paint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :id "wrapper" :height 1 :overflow scroll
|
|
:bgcolor "#E2E8F0"
|
|
(column
|
|
(box :id "target" :content "old" :width (80) :height 1
|
|
:border "#64748B" :bgcolor "#1D4ED8")
|
|
(box :content "inner tail" :height 1)))
|
|
(box :content "outer tail" :height 1))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((root-id (ebox-test--selector-region-id
|
|
(current-buffer) "#root"))
|
|
(wrapper-id (ebox-test--selector-region-id
|
|
(current-buffer) "#wrapper"))
|
|
(target-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(owner-set-scans 0))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:rendered-content-lines))
|
|
(should (plist-get (ebox-scroll-state wrapper-id)
|
|
:rendered-content-lines))
|
|
(let ((original
|
|
(symbol-function 'ebox--string-content-owner-set)))
|
|
(cl-letf (((symbol-function 'ebox--string-content-owner-set)
|
|
(lambda (&rest args)
|
|
(cl-incf owner-set-scans)
|
|
(apply original args))))
|
|
(ebox-region-update target-id :content "new")))
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(border-pos (text-property-any
|
|
(point-min) (point-max) 'ebox-bl target-id))
|
|
(content-pos (text-property-any
|
|
(point-min) (point-max)
|
|
'ebox-content target-id))
|
|
(border-face (and border-pos
|
|
(get-text-property border-pos 'face)))
|
|
(content-face (and content-pos
|
|
(get-text-property content-pos 'face)))
|
|
(content-face-specs
|
|
(if (and (listp content-face)
|
|
(keywordp (car content-face)))
|
|
(list content-face)
|
|
content-face))
|
|
(effective-content-background
|
|
(cl-loop for spec in content-face-specs
|
|
when (and (listp spec)
|
|
(plist-member spec :background))
|
|
return (plist-get spec :background))))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (plist-get report :scroll-rendered-range-patch))
|
|
(should (= (plist-get report :span-count) 2))
|
|
;; This is a nested span patch, not a complete root replacement.
|
|
;; The one owner scan is required to preserve wrapper paint.
|
|
(should (= owner-set-scans 1))
|
|
(should border-pos)
|
|
(should content-pos)
|
|
(should (ebox-test--face-has-key-value-p
|
|
border-face :background "#E2E8F0"))
|
|
(should (member wrapper-id
|
|
(get-text-property
|
|
border-pos 'ebox-content-owners)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
content-face :background "#E2E8F0"))
|
|
(should (equal effective-content-background "#1D4ED8"))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-contiguous-replacement-preserves-common-wrapper-paint ()
|
|
"Contiguous fallback strings should retain common wrapper paint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((wrapper (ebox-create :content "" :color "#334155"
|
|
:bgcolor "#E2E8F0"))
|
|
(wrapper-id (car (ebox-region-ids wrapper))))
|
|
(puthash wrapper-id wrapper ebox--region-box-table)
|
|
(with-temp-buffer
|
|
(insert (propertize "old-a" 'ebox-content-owners (list wrapper-id)))
|
|
(insert "\n")
|
|
(insert (propertize "old-b" 'ebox-content-owners (list wrapper-id)))
|
|
(insert "\n")
|
|
(let* ((spans (save-excursion
|
|
(goto-char (point-min))
|
|
(list (cons (line-beginning-position)
|
|
(line-end-position))
|
|
(progn
|
|
(forward-line 1)
|
|
(cons (line-beginning-position)
|
|
(line-end-position))))))
|
|
(new-spans (ebox--replace-line-spans
|
|
spans "new-a\nnew-b\nnew-c")))
|
|
(should (equal (buffer-string) "new-a\nnew-b\nnew-c\n"))
|
|
(should (= (length new-spans) 3))
|
|
(dolist (text '("new-a" "new-b" "new-c"))
|
|
(goto-char (point-min))
|
|
(search-forward text)
|
|
(let* ((pos (match-beginning 0))
|
|
(face (get-text-property pos 'face)))
|
|
(should (equal (get-text-property
|
|
pos 'ebox-content-owners)
|
|
(list wrapper-id)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "#334155"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#E2E8F0"))))))))
|
|
|
|
(ert-deftest ebox-contiguous-replacement-rejects-noncommon-wrapper-paint ()
|
|
"Contiguous fallback should not spread paint across ownerless spans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((wrapper (ebox-create :content "" :color "#334155"
|
|
:bgcolor "#E2E8F0"))
|
|
(wrapper-id (car (ebox-region-ids wrapper))))
|
|
(puthash wrapper-id wrapper ebox--region-box-table)
|
|
(with-temp-buffer
|
|
(insert (propertize "owned" 'ebox-content-owners (list wrapper-id)))
|
|
(insert "\nownerless\n")
|
|
(let* ((spans (save-excursion
|
|
(goto-char (point-min))
|
|
(list (cons (line-beginning-position)
|
|
(line-end-position))
|
|
(progn
|
|
(forward-line 1)
|
|
(cons (line-beginning-position)
|
|
(line-end-position))))))
|
|
(new-spans (ebox--replace-line-spans
|
|
spans "new-a\nnew-b\nnew-c")))
|
|
(should (= (length new-spans) 3))
|
|
(goto-char (point-min))
|
|
(search-forward "new-c")
|
|
(let ((pos (match-beginning 0)))
|
|
(should-not (get-text-property pos 'ebox-content-owner))
|
|
(should-not (get-text-property pos 'ebox-content-owners))
|
|
(should-not (get-text-property pos 'face)))))))
|
|
|
|
(ert-deftest ebox-replacement-boundary-scans-owner-runs-inside-long-span ()
|
|
"A long replacement span should classify owner runs below its boundary."
|
|
(with-temp-buffer
|
|
(insert (propertize "aaabbbccc" 'ebox-content-owners '(outer)))
|
|
(let ((start (point-min))
|
|
(end (point-max)))
|
|
(add-text-properties
|
|
(+ start 3) (+ start 6)
|
|
'(ebox-content-owners (old-leaf old-boundary outer)))
|
|
(add-text-properties
|
|
(+ start 6) end
|
|
'(ebox-content-owners (other-leaf other-boundary outer)))
|
|
(let ((owners
|
|
(ebox-buffer--owners-inside-replacement-boundary
|
|
(list (cons start end)) '(old-boundary))))
|
|
(should (member 'old-leaf owners))
|
|
(should (member 'old-boundary owners))
|
|
(should-not (member 'outer owners))
|
|
(should-not (member 'other-leaf owners))
|
|
(should-not (member 'other-boundary owners))))))
|
|
|
|
(ert-deftest ebox-contiguous-wrapper-preservation-keeps-horizontal-borders ()
|
|
"Contiguous line replacement should retain wrapper top and bottom borders."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((owner 'outer-wrapper)
|
|
(ebox--region-box-table (make-hash-table :test 'equal))
|
|
first-start first-end second-start second-end)
|
|
(puthash owner
|
|
'(:border-top-color "#ff0000"
|
|
:border-bottom-color "#0000ff")
|
|
ebox--region-box-table)
|
|
(setq first-start (point))
|
|
(insert (propertize "old top" 'ebox-content-owners (list owner)
|
|
'ebox-bt owner))
|
|
(setq first-end (point))
|
|
(insert "\n")
|
|
(setq second-start (point))
|
|
(insert (propertize "old bottom" 'ebox-content-owners (list owner)
|
|
'ebox-bb owner))
|
|
(setq second-end (point))
|
|
(let* ((result
|
|
(ebox--string-with-preserved-wrapper-owners
|
|
(list (cons first-start first-end)
|
|
(cons second-start second-end))
|
|
"new top\nnew middle\nnew bottom"))
|
|
(middle-start (string-match "new middle" result))
|
|
(bottom-start (string-match "new bottom" result)))
|
|
(should (equal (get-text-property 0 'ebox-bt result) owner))
|
|
(should-not (get-text-property middle-start 'ebox-bb result))
|
|
(should (equal (get-text-property bottom-start 'ebox-bb result) owner))
|
|
(should (equal (get-text-property middle-start 'ebox-content-owners result)
|
|
(list owner)))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
(get-text-property 0 'face result) :overline "#ff0000"))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
(get-text-property bottom-start 'face result)
|
|
:underline '(:position t :color "#0000ff")))))))
|
|
|
|
(ert-deftest ebox-contiguous-wrapper-expansion-splits-horizontal-borders ()
|
|
"Expanding one old line should keep top and bottom paint on opposite edges."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((owner 'single-line-wrapper)
|
|
(ebox--region-box-table (make-hash-table :test 'equal))
|
|
(start (point)))
|
|
(puthash owner
|
|
'(:border-top-color "#ff0000"
|
|
:border-bottom-color "#0000ff")
|
|
ebox--region-box-table)
|
|
(insert (propertize "old" 'ebox-content-owners (list owner)
|
|
'ebox-bt owner 'ebox-bb owner))
|
|
(let* ((result
|
|
(ebox--string-with-preserved-wrapper-owners
|
|
(list (cons start (point))) "new top\nnew bottom"))
|
|
(bottom-start (string-match "new bottom" result))
|
|
(top-face (get-text-property 0 'face result))
|
|
(bottom-face (get-text-property bottom-start 'face result)))
|
|
(should (equal (get-text-property 0 'ebox-bt result) owner))
|
|
(should-not (get-text-property 0 'ebox-bb result))
|
|
(should (equal (get-text-property bottom-start 'ebox-bb result) owner))
|
|
(should-not (get-text-property bottom-start 'ebox-bt result))
|
|
(should (ebox-test--face-has-key-p top-face :overline))
|
|
(should-not (ebox-test--face-has-key-p top-face :underline))
|
|
(should (ebox-test--face-has-key-p bottom-face :underline))
|
|
(should-not (ebox-test--face-has-key-p bottom-face :overline))))))
|
|
|
|
(ert-deftest ebox-overflow-impact-skips-span-patch-owner-probe ()
|
|
"Clipping changes should not spend time proving impossible span patches."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#overflow"))
|
|
(span-probe-count 0)
|
|
(original (symbol-function 'ebox--span-patchable-owner-p)))
|
|
(cl-letf (((symbol-function 'ebox--span-patchable-owner-p)
|
|
(lambda (&rest args)
|
|
(cl-incf span-probe-count)
|
|
(apply original args))))
|
|
(ebox-region-update region-id :overflow 'hidden))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (member 'clipping (plist-get report :impact-vector)))
|
|
(should (= span-probe-count 0))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-overflow-impact-skips-patchable-owner-promotion ()
|
|
"Clipping changes should not pre-prove conservative owner candidates."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#overflow"))
|
|
(promote-count 0)
|
|
(original (symbol-function 'ebox--promote-to-patchable-owner)))
|
|
(cl-letf (((symbol-function 'ebox--promote-to-patchable-owner)
|
|
(lambda (&rest args)
|
|
(cl-incf promote-count)
|
|
(apply original args))))
|
|
(ebox-region-update region-id :overflow 'visible))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (member 'clipping (plist-get report :impact-vector)))
|
|
(should (= promote-count 0))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-row-visible-overflow-update-rerenders-slot-owner-not-root ()
|
|
"Visible overflow that fits the existing flex row slot should not rerender root."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#overflow"))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer)))
|
|
(full-snapshot-refresh-count 0)
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-layout-snapshots)))
|
|
(cl-letf (((symbol-function 'ebox--refresh-buffer-layout-snapshots)
|
|
(lambda (&rest args)
|
|
(cl-incf full-snapshot-refresh-count)
|
|
(apply original-refresh args))))
|
|
(ebox-region-update region-id :overflow 'visible))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (plist-get report :scoped-index-refresh))
|
|
(should (= full-snapshot-refresh-count 0))
|
|
(let* ((node (ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(snapshot (ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) (ebox--ensure-node-id node))))
|
|
(should (ebox--layout-snapshot-spans-p snapshot))
|
|
(should (eq (plist-get (plist-get snapshot :style-signature)
|
|
:overflow)
|
|
'visible)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-overflow-reversal-removes-visible-suffix ()
|
|
"Clipping a visible target should replace the ancestor-owned old suffix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (760)
|
|
(flex :id matrix :width (600) :height 5
|
|
:flex-flow (row nowrap)
|
|
(box :id card :width (300)
|
|
(box :id overflow
|
|
:content "overflow target\nextra line\nanother line"
|
|
:width (280) :height 2 :overflow scroll))
|
|
(box :id peer :content "P\nQ\nR\nS\nT"
|
|
:width (300) :height 5))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#overflow"))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer)))
|
|
coverage-owner-id)
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id :overflow 'visible)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(setq coverage-owner-id
|
|
(car (plist-get report :owner-ids)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should coverage-owner-id)
|
|
(should-not (equal coverage-owner-id root-id))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list coverage-owner-id)))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should-not (plist-get report :root-rerender))
|
|
(should-not (string-match-p "another line" plain))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
(should (= full-rerenders 0)))))))
|
|
|
|
(ert-deftest ebox-overflow-reversal-skips-layout-only-ancestor ()
|
|
"Old visible suffix coverage should skip ancestors without wrapper ownership."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((target (ebox-create :content "A\nB\nC" :height 1
|
|
:overflow 'visible))
|
|
(region-id (car (ebox-region-ids target)))
|
|
(inner (ebox-stack target (ebox-create :content "TAIL")))
|
|
(layout (ebox-stack inner (ebox-create :content "ROOT TAIL")))
|
|
(inner-id (ebox--ensure-node-id inner))
|
|
(root-id (ebox--ensure-node-id layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (member inner-id (plist-get report :owner-ids)))
|
|
(should (equal (plist-get report :owner-ids) (list root-id)))
|
|
(should-not (string-match-p "[BC]" plain))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-overflow-reversal-skips-visible-wrapper-ancestor ()
|
|
"A visible wrapper cannot cover its own old unowned overflow suffix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((target (ebox-create :content "A\nB\nC" :height 1
|
|
:overflow 'visible))
|
|
(region-id (car (ebox-region-ids target)))
|
|
(wrapper (ebox-create :ebox-content-node target :width '(100)
|
|
:height 1 :overflow 'visible))
|
|
(layout (ebox-stack wrapper (ebox-create :content "TAIL")))
|
|
(wrapper-id (ebox--ensure-node-id wrapper))
|
|
(root-id (ebox--ensure-node-id layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (member wrapper-id (plist-get report :owner-ids)))
|
|
(should (equal (plist-get report :owner-ids) (list root-id)))
|
|
(should-not (string-match-p "[BC]" plain))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-overflow-coverage-crosses-enclosing-visible-wrapper ()
|
|
"Coverage should climb above an enclosing visible wrapper's old footprint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (100)
|
|
(box :id outer :width (100) :height 2 :overflow visible
|
|
(box :id inner :width (100)
|
|
(box :id target :content "A\nB\nC" :height 1
|
|
:overflow visible)))
|
|
(box :content "TAIL")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(target-node (ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(outer-node (plist-get (car (ebox-selector-query-buffer
|
|
(current-buffer) "#outer"))
|
|
:node))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (ebox-get (ebox-fragment-style-source-node target-node)
|
|
:overflow)
|
|
'hidden))
|
|
(should (eq (ebox-get (ebox-fragment-style-source-node outer-node)
|
|
:overflow)
|
|
'visible))
|
|
(should (equal (plist-get report :owner-ids) (list root-id)))
|
|
(should-not (plist-get report :flex-line-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-overflow-coverage-root-flex-replaces-whole-footprint ()
|
|
"Root flex fallback should bypass line rerender for visible overflow changes."
|
|
(dolist (transition '((scroll visible) (visible hidden)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((old-overflow (car transition))
|
|
(new-overflow (cadr transition))
|
|
(layout
|
|
(ebox-build
|
|
`(flex :id root :width (200)
|
|
(box :id target :content "A\nB\nC" :width (80) :height 1
|
|
:overflow ,old-overflow)
|
|
(box :id peer :content "P" :width (80) :height 1)))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(target-node (ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow new-overflow)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (ebox-get (ebox-fragment-style-source-node target-node)
|
|
:overflow)
|
|
new-overflow))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids) (list root-id)))
|
|
(should-not (plist-get report :flex-line-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))))
|
|
|
|
(ert-deftest ebox-overflow-coverage-promotes-partial-flex-item ()
|
|
"Visible overflow changes should not preserve a flex item's stale cross size."
|
|
(dolist (transition '((scroll visible) (visible hidden)))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((old-overflow (car transition))
|
|
(new-overflow (cadr transition))
|
|
(layout
|
|
(ebox-build
|
|
`(flex :id root :width (220)
|
|
(box :id card :width (100)
|
|
(box :id target :content "A\nB\nC" :width (80) :height 1
|
|
:overflow ,old-overflow))
|
|
(box :id peer :content "P" :width (80) :height 1)))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(target-node (ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(card-id (plist-get (car (ebox-selector-query-buffer
|
|
(current-buffer) "#card"))
|
|
:node-id))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-region-update region-id :overflow new-overflow)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (ebox-get (ebox-fragment-style-source-node target-node)
|
|
:overflow)
|
|
new-overflow))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should-not (member card-id (plist-get report :owner-ids)))
|
|
(should (equal (plist-get report :owner-ids) (list root-id)))
|
|
(should-not (plist-get report :flex-line-rerender))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))))
|
|
|
|
(ert-deftest ebox-overflow-coverage-batch-preserves-old-style ()
|
|
"A batch should carry pre-mutation overflow into coverage planning."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (100)
|
|
(box :id wrapper :width (100)
|
|
(column
|
|
(box :id target :content "A\nB\nC" :height 1
|
|
:overflow visible)
|
|
(box :content "TAIL")))
|
|
(box :content "ROOT TAIL")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(target-node (ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(wrapper-id (plist-get (car (ebox-selector-query-buffer
|
|
(current-buffer) "#wrapper"))
|
|
:node-id)))
|
|
(ebox--clear-layout-snapshots (current-buffer))
|
|
(ebox-incremental-begin-batch (current-buffer))
|
|
(ebox-region-update region-id :overflow 'hidden)
|
|
(let* ((state (ebox-incremental--batch-state (current-buffer)))
|
|
(pending (car (plist-get state :pending))))
|
|
(should (equal (plist-get pending :old-style-values)
|
|
'(:overflow visible))))
|
|
(ebox-incremental-flush (current-buffer))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (ebox-get (ebox-fragment-style-source-node target-node)
|
|
:overflow)
|
|
'hidden))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids) (list wrapper-id)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-overflow-coverage-multi-owner-batch-normalizes-scoped-snapshots ()
|
|
"Multiple owner replacements normalize shifted spans before scoped refresh."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (760)
|
|
(flex :id top-matrix :width (600) :height 5
|
|
:flex-flow (row nowrap)
|
|
(box :id top-card :width (300)
|
|
(box :id top-target
|
|
:content "top A\nsubstantially longer top overflow\ntop C"
|
|
:width (280) :height 2 :overflow scroll))
|
|
(box :content "top P\ntop Q\ntop R\ntop S\ntop T"
|
|
:width (300) :height 5))
|
|
(flex :id bottom-matrix :width (600) :height 5
|
|
:flex-flow (row nowrap)
|
|
(box :id bottom-card :width (300)
|
|
(box :id bottom-target
|
|
:content "bottom A\nbottom overflow\nbottom C"
|
|
:width (280) :height 2 :overflow scroll))
|
|
(box :content "bottom P\nbottom Q\nbottom R\nbottom S\nbottom T"
|
|
:width (300) :height 5))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((top-region-id
|
|
(ebox-test--selector-region-id (current-buffer) "#top-target"))
|
|
(bottom-region-id
|
|
(ebox-test--selector-region-id
|
|
(current-buffer) "#bottom-target"))
|
|
(full-snapshot-refresh-count 0)
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-layout-snapshots)))
|
|
(ebox-incremental-begin-batch (current-buffer))
|
|
(ebox-region-update top-region-id :overflow 'visible)
|
|
(ebox-region-update bottom-region-id :overflow 'visible)
|
|
(cl-letf (((symbol-function 'ebox--refresh-buffer-layout-snapshots)
|
|
(lambda (&rest args)
|
|
(cl-incf full-snapshot-refresh-count)
|
|
(apply original-refresh args))))
|
|
(ebox-incremental-flush (current-buffer)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (= (plist-get report :patch-count) 2))
|
|
(should (plist-get report :scoped-index-refresh))
|
|
(should (= full-snapshot-refresh-count 0))
|
|
(ebox--set-buffer-region-role-span-table (current-buffer) nil)
|
|
(ebox-buffer-refresh-region-role-spans (current-buffer))
|
|
(dolist (owner-id (plist-get report :owner-ids))
|
|
(let* ((node (ebox--buffer-runtime-node
|
|
(current-buffer) owner-id))
|
|
(snapshot-spans
|
|
(plist-get (ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) owner-id)
|
|
:buffer-spans))
|
|
(actual-spans
|
|
(ebox--region-set-line-spans
|
|
(ebox--node-all-region-ids node))))
|
|
(should (equal snapshot-spans actual-spans))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))
|
|
(ebox-region-update bottom-region-id :overflow 'hidden)
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-span-patch-refreshes-descendant-snapshots ()
|
|
"Ancestor span patches should keep descendant buffer span snapshots current."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((handle (car (ebox-selector-query-buffer
|
|
(current-buffer) "#margin")))
|
|
(region-id (plist-get handle :region-id))
|
|
(node-id (plist-get handle :node-id))
|
|
(dense-index-builds 0)
|
|
(eager-descendant-span-refreshes 0)
|
|
(original-index-builder
|
|
(symbol-function 'ebox--build-region-line-index-for-spans))
|
|
(original-descendant-refresh
|
|
(symbol-function
|
|
'ebox--capture-layout-snapshot-spans-subtree)))
|
|
(cl-letf (((symbol-function 'ebox--build-region-line-index-for-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf dense-index-builds)
|
|
(apply original-index-builder args)))
|
|
((symbol-function
|
|
'ebox--capture-layout-snapshot-spans-subtree)
|
|
(lambda (&rest args)
|
|
(cl-incf eager-descendant-span-refreshes)
|
|
(apply original-descendant-refresh args))))
|
|
(ebox-region-update region-id
|
|
:margin (list 0 '(8) 0 '(8))
|
|
:margin-inline '((8) (8))
|
|
:margin-block '(0 0)
|
|
:margin-top 0 :margin-right '(8)
|
|
:margin-bottom 0 :margin-left '(8)))
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(snapshot (ebox--ensure-layout-snapshot-spans
|
|
(current-buffer) node-id))
|
|
(snapshot-spans (plist-get snapshot :buffer-spans))
|
|
(actual-spans (ebox--region-set-line-spans
|
|
(list region-id))))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (= dense-index-builds 0))
|
|
(should (= eager-descendant-span-refreshes 0))
|
|
(should (equal snapshot-spans actual-spans))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-sequential-sibling-span-patches-invalidate-stale-coordinates ()
|
|
"Text-changing sibling patches should not reuse translated snapshot spans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (120)
|
|
(box :id a :content "A" :width (120) :height 1)
|
|
(box :id b :content "B" :width (120) :height 1)))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((a-handle (car (ebox-selector-query-buffer
|
|
(current-buffer) "#a")))
|
|
(b-handle (car (ebox-selector-query-buffer
|
|
(current-buffer) "#b")))
|
|
(a-region-id (plist-get a-handle :region-id))
|
|
(b-region-id (plist-get b-handle :region-id))
|
|
(b-node-id (plist-get b-handle :node-id))
|
|
sibling-snapshot-current-p
|
|
reports)
|
|
(ebox-region-update b-region-id :content "BB")
|
|
(push (ebox-test--buffer-update-report) reports)
|
|
(ebox-region-update a-region-id :content "AAAA")
|
|
(push (ebox-test--buffer-update-report) reports)
|
|
(let* ((snapshot (ebox--layout-snapshot
|
|
(current-buffer) b-node-id))
|
|
(snapshot-spans (plist-get snapshot :buffer-spans))
|
|
(actual-spans (ebox--region-set-line-spans
|
|
(list b-region-id))))
|
|
(setq sibling-snapshot-current-p
|
|
(or (not (plist-member snapshot :buffer-spans))
|
|
(equal snapshot-spans actual-spans))))
|
|
(ebox-region-update b-region-id :content "CCC")
|
|
(push (ebox-test--buffer-update-report) reports)
|
|
(dolist (report reports)
|
|
(should (eq (plist-get report :strategy) 'span-patch)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should sibling-snapshot-current-p)))))
|
|
|
|
(ert-deftest ebox-flex-direct-item-inline-margin-rerenders-flex-owner ()
|
|
"Direct flex item margin changes should patch the flex line owner."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(flex :id matrix :width (260) :flex-flow (row nowrap)
|
|
:column-gap (0)
|
|
(box :id target :content "A" :width (80) :height 1
|
|
:border "#999999")
|
|
(box :id peer :content "B" :width (80) :height 1
|
|
:border "#999999")))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target")))
|
|
(ebox-region-update region-id
|
|
:margin-left '(30)
|
|
:margin-right '(30))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-child-width-expansion-reflows-ancestor-after-span-fallback ()
|
|
"Failed promoted span patches must fall back to a layout-safe ancestor."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(flex :id matrix :width (680) :flex-flow (row wrap)
|
|
:column-gap (12) :row-gap 1
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title A" :width (190))
|
|
(box :id target :content "width target\nmoves sibling layout"
|
|
:width (160) :height 3
|
|
:padding (0 (8)) :border "#999999"))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title B" :width (190))
|
|
(box :content "Still here" :width (190)))
|
|
(column :width (210) :border "#999999"
|
|
(box :content "Title C" :width (190))
|
|
(box :content "Third card" :width (190)))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((match (car (ebox-selector-query-buffer
|
|
(current-buffer) "#target")))
|
|
(region-id (plist-get match :region-id)))
|
|
(ebox-region-update region-id :width '(250))
|
|
(let* ((patched (buffer-string))
|
|
(full (ebox--with-buffer-render-context (current-buffer)
|
|
(ebox-render
|
|
(ebox--buffer-root-node (current-buffer))))))
|
|
(should (string= (substring-no-properties patched)
|
|
(substring-no-properties full))))))))
|
|
|
|
(ert-deftest ebox-flex-shrunk-definite-item-content-update-keeps-current-slot ()
|
|
"A definite 520x4 item may update inside its published shrunk slot."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 500)
|
|
(layout
|
|
(ebox-build
|
|
'(flex :id root :width (500) :height 4
|
|
:flex-flow (row nowrap) :align-items flex-start
|
|
(box :id fixed :content "peer" :width (320) :height 4
|
|
:flex-grow 0 :flex-shrink 0)
|
|
(box :id target :content "READY" :width (520) :height 4
|
|
:overflow hidden :wrap-mode word)))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((match (car (ebox-selector-query-buffer
|
|
(current-buffer) "#target")))
|
|
(region-id (plist-get match :region-id))
|
|
(node-id (plist-get match :node-id))
|
|
(node (ebox--buffer-runtime-node (current-buffer) node-id))
|
|
(snapshot (ebox--ensure-layout-snapshot-details
|
|
(current-buffer) node-id))
|
|
(old-widths
|
|
(plist-get (plist-get snapshot :span-footprint-signature)
|
|
:line-pixel-widths)))
|
|
(should (= (length old-widths) 4))
|
|
(should (< (apply #'max old-widths) 520))
|
|
;; Flex measurement may have rendered a temporary sized copy. Keep
|
|
;; this regression focused on the current-slot update contract.
|
|
(puthash region-id node ebox--region-box-table)
|
|
(ebox-region-update region-id :content "DONE")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :owner-ids) (list node-id)))
|
|
(should-not (plist-get report :full-rerender)))
|
|
(should (string-match-p
|
|
"DONE"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-flex-auto-size-content-update-refuses-current-slot ()
|
|
"Auto-sized content must reflow instead of being forced into its old slot."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 300)
|
|
(layout
|
|
(ebox-build
|
|
'(flex :id root :width (300) :height 1
|
|
:flex-flow (row nowrap) :align-items flex-start
|
|
(box :id target :content "A" :width auto :height 1
|
|
:overflow hidden :wrap-mode word)
|
|
(box :id peer :content "P" :width (40) :height 1
|
|
:flex-grow 0 :flex-shrink 0)))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((match (car (ebox-selector-query-buffer
|
|
(current-buffer) "#target")))
|
|
(region-id (plist-get match :region-id))
|
|
(node-id (plist-get match :node-id))
|
|
(node (ebox--buffer-runtime-node (current-buffer) node-id))
|
|
(snapshot (ebox--ensure-layout-snapshot-details
|
|
(current-buffer) node-id)))
|
|
(puthash region-id node ebox--region-box-table)
|
|
(should-not
|
|
(ebox--render-node-in-current-flex-slot
|
|
(current-buffer) node-id snapshot '(:content)))
|
|
(ebox-region-update region-id :content "HELLO")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should-not
|
|
(and (eq (plist-get report :strategy) 'span-patch)
|
|
(equal (plist-get report :owner-ids) (list node-id)))))
|
|
(should (string-match-p
|
|
"HELLO"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-describes-span-patch ()
|
|
"The update report should expose the actual minimal patch strategy."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Trace" :width 80 :height 1))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :content "Patch")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (equal (plist-get report :region-id) region-id))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (eq (plist-get report :owner-type) 'box))
|
|
(should (eq (plist-get report :full-rerender) nil))
|
|
(should (> (plist-get report :span-count) 0))
|
|
(should (equal (plist-get report :old-signature)
|
|
(plist-get report :new-signature)))
|
|
(should (plist-get report :old-span-footprint-signature))
|
|
(should (plist-get report :old-external-footprint-signature))
|
|
(should (equal (plist-get report :old-span-footprint-signature)
|
|
(plist-get report :new-span-footprint-signature)))
|
|
(should (equal (plist-get report :old-external-footprint-signature)
|
|
(plist-get report :new-external-footprint-signature)))))))
|
|
|
|
(ert-deftest ebox-buffer-update-report-describes-owner-rerender-fallback ()
|
|
"The update report should expose geometry owner rerender fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "L" :width 40))
|
|
(right (ebox-create :content "R" :width 40))
|
|
(layout (ebox-concat left right))
|
|
(region-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update region-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (equal (plist-get report :region-id) region-id))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (eq (plist-get report :owner-type) 'concat))
|
|
(should (eq (plist-get report :full-rerender) nil))))))
|
|
|
|
(ert-deftest ebox-region-update-stable-geometry-uses-span-patch ()
|
|
"Geometry updates with stable span footprint should use the L2 planner path."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Align" :width '(120) :height 1
|
|
:text-align 'left))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :text-align 'center)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :patch-ops) '(span-patch)))
|
|
(should (equal (plist-get report :dirty-kinds) '(geometry)))
|
|
(should (eq (plist-get report :owner-type) 'box))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-region-update-parent-layout-change-keeps-owner-rerender ()
|
|
"Geometry updates that move siblings should not be forced into span-patch."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "L" :width '(40)))
|
|
(right (ebox-create :content "R" :width '(40)))
|
|
(layout (ebox-concat left right))
|
|
(region-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update region-id :width '(120))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :patch-ops) '(owner-rerender)))
|
|
(should (eq (plist-get report :owner-type) 'concat))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-region-update-inline-child-stable-geometry-uses-span-patch ()
|
|
"Stable internal changes inside an inline child should not rerender siblings."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((left (ebox-create :content "Left" :width '(80) :height 1
|
|
:text-align 'left))
|
|
(right (ebox-create :content "Right" :width '(80) :height 1))
|
|
(layout (ebox-concat left right))
|
|
(left-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(ebox-region-update left-id :text-align 'center)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :patch-ops) '(span-patch)))
|
|
(should (eq (plist-get report :owner-type) 'box))
|
|
(should (plist-get report :old-parent-slot-signature))
|
|
(should (equal (plist-get report :old-parent-slot-signature)
|
|
(plist-get report :new-parent-slot-signature)))
|
|
(should-not (plist-get report :full-rerender)))
|
|
(should (string-match-p
|
|
"Right"
|
|
(buffer-substring-no-properties (point-min) (point-max)))))))
|
|
|
|
(ert-deftest ebox-region-update-border-box-inline-change-uses-span-patch ()
|
|
"Border-box left/right spacing can be internal when outer width is fixed."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Pad" :width '(120) :height 1
|
|
:box-sizing 'border-box))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :padding-left-pixel 8)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (equal (plist-get report :patch-ops) '(span-patch)))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-region-update-content-box-inline-change-rerenders-owner ()
|
|
"Content-box left/right spacing changes the parent-facing outer width."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Pad" :width '(120) :height 1
|
|
:box-sizing 'content-box))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :padding-left-pixel 8)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :patch-ops) '(owner-rerender)))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-flex-item-box-sizing-update-rerenders-contained-flex ()
|
|
"Changing a flex item's box model should rerun its parent's placement."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (760)
|
|
(flex :id outer :width (600) :height 5 :flex-flow (row nowrap)
|
|
(box :id card :width (300)
|
|
(flex :id inner :width (300) :height 5
|
|
:padding (0 (10)) :border "#6F6A95"
|
|
:justify-content center :align-items center
|
|
(box :id target :content "A\nB"
|
|
:width (230) :height 3 :padding (0 (10))
|
|
:border "#999999" :box-sizing content-box)))
|
|
(box :id peer :content "P\nQ\nR\nS\nT"
|
|
:width (300) :height 5))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(target-node
|
|
(ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(flex-id
|
|
(ebox--runtime-parent-id
|
|
(current-buffer) (ebox--ensure-node-id target-node)))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer))))
|
|
(ebox-region-update region-id :box-sizing 'border-box)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids) (list flex-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should (plist-get report :slot-preserving))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-flex-item-block-size-updates-use-fixed-containment-owner ()
|
|
"Block-size updates should skip flex-slot proof below fixed containment."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id root :width (760)
|
|
(flex :id outer :width (600) :height 5 :flex-flow (row nowrap)
|
|
(box :id card :width (300)
|
|
(flex :id inner :width (300) :height 5
|
|
:padding (0 (10)) :border "#6F6A95"
|
|
:justify-content center :align-items center
|
|
(box :id target :content "A\nB\nC\nD"
|
|
:width (230) :height 2 :overflow scroll
|
|
:padding (0 (10)) :border "#999999")))
|
|
(box :id peer :content "P\nQ\nR\nS\nT"
|
|
:width (300) :height 5))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((region-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(target-node
|
|
(ebox--buffer-region-render-owner-node
|
|
(current-buffer) region-id))
|
|
(flex-id
|
|
(ebox--runtime-parent-id
|
|
(current-buffer) (ebox--ensure-node-id target-node)))
|
|
(root-id (ebox--buffer-root-node-id (current-buffer)))
|
|
(slot-proof-count 0)
|
|
(original-slot-proof
|
|
(symbol-function 'ebox--flex-item-slot-footprint-safe-p)))
|
|
(cl-letf (((symbol-function 'ebox--flex-item-slot-footprint-safe-p)
|
|
(lambda (&rest args)
|
|
(cl-incf slot-proof-count)
|
|
(apply original-slot-proof args))))
|
|
(dolist (change '((:height 4) (:min-height 3) (:max-height 1)))
|
|
(ebox-region-update region-id (car change) (cadr change))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender)))
|
|
(should (equal (plist-get report :owner-ids) (list flex-id)))
|
|
(should (eq (plist-get report :owner-type) 'flex))
|
|
(should (= (plist-get report :span-count) 5))
|
|
(should-not (member root-id (plist-get report :owner-ids)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
(should (= slot-proof-count 0))))))
|
|
|
|
(ert-deftest ebox-region-update-span-candidate-falls-back-on-wrap-change ()
|
|
"A span candidate should degrade to owner rerender when footprint changes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "abcdefghijklmnopqrstuvwxyz"
|
|
:width '(120)
|
|
:box-sizing 'border-box
|
|
:wrap-mode 'char))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :padding-left-pixel 100)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :patch-ops) '(owner-rerender)))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-region-update-matrix-covers-all-box-longhands ()
|
|
"The update tests should classify every non-content box longhand."
|
|
(let ((covered (append (ebox-test--region-update-case-properties
|
|
ebox-test--region-update-paint-cases)
|
|
(ebox-test--region-update-case-properties
|
|
ebox-test--region-update-geometry-cases))))
|
|
(should-not (cl-set-difference ebox--region-update-longhand-props
|
|
covered
|
|
:test #'eq))
|
|
(should-not (cl-set-difference covered
|
|
ebox--region-update-longhand-props
|
|
:test #'eq))
|
|
(should-not (cl-set-difference ebox--paint-style-signature-keys
|
|
(ebox-test--region-update-case-properties
|
|
ebox-test--region-update-paint-cases)
|
|
:test #'eq))))
|
|
|
|
(ert-deftest ebox-region-update-all-paint-longhands-use-paint-patch ()
|
|
"Every paint longhand should patch text properties without replacing spans."
|
|
(dolist (case ebox-test--region-update-paint-cases)
|
|
(pcase-let ((`(,property ,value ,expected) case))
|
|
(ert-info ((format "property %S" property))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Paint" :width '(120)
|
|
:height 1))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((replace-count 0)
|
|
(original-replace (symbol-function
|
|
'ebox--replace-line-spans)))
|
|
(cl-letf (((symbol-function 'ebox--replace-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf replace-count)
|
|
(apply original-replace args))))
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id property value))))
|
|
(should (= full-rerenders 0))))
|
|
(should (= replace-count 0)))
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (eq (gethash region-id ebox--region-box-table)
|
|
runtime-box))
|
|
(should-not (eq runtime-box box))
|
|
(should (equal (ebox-get runtime-box property) expected)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(paint-patch)))
|
|
(should (equal (plist-get report :dirty-kinds) '(paint)))
|
|
(should-not (plist-get report :full-rerender)))))))))
|
|
|
|
(ert-deftest ebox-region-update-all-geometry-longhands-use-minimal-strategy ()
|
|
"Every geometry longhand should use its expected minimal non-root strategy."
|
|
(dolist (case ebox-test--region-update-geometry-cases)
|
|
(pcase-let ((`(,property ,value ,expected ,strategy) case))
|
|
(ert-info ((format "property %S" property))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Alpha\nBeta\nGamma\nDelta"
|
|
:width '(160)
|
|
:height 2
|
|
:overflow 'scroll
|
|
:wrap-mode 'word))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id property value))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (eq (gethash region-id ebox--region-box-table)
|
|
runtime-box))
|
|
(should-not (eq runtime-box box))
|
|
(should (equal (ebox-get runtime-box property) expected)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) strategy))
|
|
(should (equal (plist-get report :patch-ops)
|
|
(list strategy)))
|
|
(should (equal (plist-get report :dirty-kinds) '(geometry)))
|
|
(should (eq (plist-get report :owner-type) 'box))
|
|
(should-not (plist-get report :full-rerender)))))))))
|
|
|
|
(ert-deftest ebox-bgcolor-update-mutates-box-and-keeps-content ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Color" :width 60 :bgcolor "#111111"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :bgcolor "#222222")
|
|
(should (equal (ebox-get box :bgcolor) "#111111"))
|
|
(should (equal (ebox-get (gethash region-id
|
|
(ebox--buffer-region-box-table
|
|
(current-buffer)))
|
|
:bgcolor)
|
|
"#222222"))
|
|
(should (string-match-p
|
|
"Color"
|
|
(buffer-substring-no-properties (point-min) (point-max)))))))
|
|
|
|
(ert-deftest ebox-background-color-creation-matches-bgcolor-updates ()
|
|
"Background color spellings should share one engine longhand and paint path."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((background-box
|
|
(ebox-create :content "Color" :width 60
|
|
:background-color "#111111"))
|
|
(bgcolor-box
|
|
(ebox-create :content "Color" :width 60 :bgcolor "#111111"))
|
|
(background-face
|
|
(ebox-test--first-content-face (ebox-render background-box)))
|
|
(bgcolor-face
|
|
(ebox-test--first-content-face (ebox-render bgcolor-box))))
|
|
(should (equal (ebox-get background-box :bgcolor) "#111111"))
|
|
(should (equal (ebox-get bgcolor-box :bgcolor) "#111111"))
|
|
(should-not (plist-member background-box :background-color))
|
|
(should (equal background-face bgcolor-face))
|
|
(should (ebox-test--face-has-key-value-p
|
|
background-face :background "#111111"))
|
|
(let ((region-id (car (ebox-region-ids background-box))))
|
|
(ebox-test--with-rendered-buffer background-box
|
|
(ebox-region-update region-id :background-color "#222222")
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (equal (ebox-get background-box :bgcolor) "#111111"))
|
|
(should (equal (ebox-get runtime-box :bgcolor) "#222222"))
|
|
(should-not (plist-member runtime-box :background-color)))
|
|
(should-not (plist-member background-box :background-color))
|
|
(should (ebox-test--face-has-key-value-p
|
|
(ebox-test--first-content-face (buffer-string))
|
|
:background "#222222"))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (equal (plist-get report :patch-ops) '(paint-patch)))
|
|
(should (equal (plist-get report :dirty-kinds) '(paint)))
|
|
(should-not (plist-get report :full-rerender)))))))
|
|
|
|
(ert-deftest ebox-vertical-align-middle-alias-matches-center ()
|
|
"Creation and updates should normalize middle to center before rendering."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((middle (ebox-create :content "X" :height 3
|
|
:vertical-align 'middle)))
|
|
(should (equal (ebox--expand-property :vertical-align 'middle)
|
|
'(:vertical-align center)))
|
|
(should (eq (ebox-get middle :vertical-align) 'center))
|
|
(should (= (cl-position-if
|
|
(lambda (line)
|
|
(string-match-p "X" (substring-no-properties line)))
|
|
(ebox-string-lines (ebox-render middle)))
|
|
1))
|
|
(let* ((updated (ebox-create :content "X" :height 3
|
|
:vertical-align 'top))
|
|
(region-id (car (ebox-region-ids updated))))
|
|
(ebox-test--with-rendered-buffer updated
|
|
(goto-char (point-min))
|
|
(search-forward "X")
|
|
(should (= (line-number-at-pos (match-beginning 0)) 1))
|
|
(ebox-region-update region-id :vertical-align 'middle)
|
|
(should (eq (ebox-get updated :vertical-align) 'top))
|
|
(should (eq (ebox-get (gethash region-id
|
|
(ebox--buffer-region-box-table
|
|
(current-buffer)))
|
|
:vertical-align)
|
|
'center))
|
|
(goto-char (point-min))
|
|
(search-forward "X")
|
|
(should (= (line-number-at-pos (match-beginning 0)) 2))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'span-patch))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-update-reuses-shorthand-property-expansion ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Box" :width 60))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id
|
|
:padding '(1 2)
|
|
:border '(2 "#abcdef")
|
|
:margin-inline 3)
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (= (ebox-get box :padding-top-height) 0))
|
|
(should (= (ebox-get runtime-box :padding-top-height) 1))
|
|
(should (= (ebox-get runtime-box :padding-right-pixel)
|
|
(* 2 (ebox--space-pixel-width))))
|
|
(should (= (ebox-get runtime-box :border-left-pixel)
|
|
(* 2 (ebox--space-pixel-width))))
|
|
(should (equal (ebox-get runtime-box :border-right-color) "#abcdef"))
|
|
(should (= (ebox-get runtime-box :margin-left-pixel)
|
|
(* 3 (ebox--space-pixel-width))))))))
|
|
|
|
(ert-deftest ebox-region-update-adds-absent-shorthand-properties-incrementally ()
|
|
"Shorthand updates should locate the same box and patch without root rebuilds."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Absent properties" :width '(160)))
|
|
(region-id (car (ebox-region-ids box)))
|
|
(ids-before (ebox-region-ids box)))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id
|
|
:padding '(1 2)
|
|
:border '(1 "#abcdef")
|
|
:margin-inline 3))))
|
|
(should (= full-rerenders 0)))
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (eq (gethash region-id ebox--region-box-table)
|
|
runtime-box))
|
|
(should-not (eq runtime-box box))
|
|
(should (equal (ebox-region-ids box) ids-before))
|
|
(should (= (ebox-get box :padding-top-height) 0))
|
|
(should (= (ebox-get box :padding-right-pixel) 0))
|
|
(should (= (ebox-get box :border-left-pixel) 0))
|
|
(should (null (ebox-get box :border-right-color)))
|
|
(should (= (ebox-get box :margin-left-pixel) 0))
|
|
(should (= (ebox-get runtime-box :padding-top-height) 1))
|
|
(should (= (ebox-get runtime-box :padding-right-pixel)
|
|
(* 2 (ebox--space-pixel-width))))
|
|
(should (= (ebox-get runtime-box :border-left-pixel)
|
|
(ebox--space-pixel-width)))
|
|
(should (equal (ebox-get runtime-box :border-right-color) "#abcdef"))
|
|
(should (= (ebox-get runtime-box :margin-left-pixel)
|
|
(* 3 (ebox--space-pixel-width)))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(owner-rerender)))
|
|
(should-not (plist-get report :full-rerender)))
|
|
(let ((replace-count 0)
|
|
(original-replace (symbol-function 'ebox--replace-line-spans)))
|
|
(cl-letf (((symbol-function 'ebox--replace-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf replace-count)
|
|
(apply original-replace args))))
|
|
(let ((full-rerenders
|
|
(ebox-test--count-full-rerenders
|
|
(ebox-region-update region-id
|
|
:background-color "#fed7aa"))))
|
|
(should (= full-rerenders 0))))
|
|
(should (= replace-count 0)))
|
|
(should (null (ebox-get box :bgcolor)))
|
|
(should (equal (ebox-get (gethash region-id
|
|
(ebox--buffer-region-box-table
|
|
(current-buffer)))
|
|
:bgcolor)
|
|
"#fed7aa"))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (equal (plist-get report :patch-ops)
|
|
'(paint-patch)))
|
|
(should-not (plist-get report :full-rerender))))))
|
|
|
|
(ert-deftest ebox-color-and-visibility-are-real-and-display-is-ignored ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Paint"
|
|
:color "#eeeeee"
|
|
:display 'none
|
|
:visibility 'hidden))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(should (equal (ebox-get box :color) "#eeeeee"))
|
|
(should (equal (ebox--computed-display box) '(block flow)))
|
|
(should (eq (ebox-get box :visibility) 'hidden))
|
|
(ebox-test--with-rendered-buffer box
|
|
;; Hidden at mount: the text is present but carries no face ink.
|
|
(let ((position (string-match
|
|
"Paint"
|
|
(buffer-substring-no-properties (point-min)
|
|
(point-max)))))
|
|
(should position)
|
|
(should-not (get-text-property (+ (point-min) position) 'face)))
|
|
(ebox-region-update region-id
|
|
:color "#123456"
|
|
:display 'block
|
|
:visibility 'visible)
|
|
(let ((runtime-box
|
|
(gethash region-id (ebox--buffer-region-box-table
|
|
(current-buffer)))))
|
|
(should (equal (ebox-get box :color) "#eeeeee"))
|
|
(should (equal (ebox-get runtime-box :color) "#123456"))
|
|
(should (eq (ebox-get runtime-box :visibility) 'visible)))
|
|
(should (equal (ebox--computed-display box) '(block flow)))
|
|
(should (eq (ebox-get box :visibility) 'hidden))
|
|
(let ((position (string-match
|
|
"Paint"
|
|
(buffer-substring-no-properties (point-min)
|
|
(point-max)))))
|
|
(should position)
|
|
(should (get-text-property (+ (point-min) position) 'face))))))
|
|
|
|
(ert-deftest ebox-row-column-and-spacer-compose-layouts ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((a (ebox-create :content "A" :width 40))
|
|
(b (ebox-create :content "B" :width 40))
|
|
(c (ebox-create :content "C" :width 40))
|
|
(row (ebox-row a nil b c))
|
|
(column (ebox-column a b nil c))
|
|
(spacer (ebox-spacer :width 20 :height 2)))
|
|
(should (equal (ebox-region-ids row) '(1 2 3)))
|
|
(should (equal (ebox-region-ids column) '(1 2 3)))
|
|
(should (eq (plist-get spacer :ebox-type) 'box))
|
|
(should (string-match-p "A.*B.*C"
|
|
(substring-no-properties (ebox-render row))))
|
|
(should (string-match-p "A[^\n]*\nB[^\n]*\nC"
|
|
(substring-no-properties (ebox-render column))))))
|
|
|
|
(ert-deftest ebox-row-and-column-store-children-as-flat-containers ()
|
|
"Row and column should be one container node with direct children."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((children (cl-loop for label in '("A" "B" "C" "D")
|
|
collect (ebox-create :content label :width 40)))
|
|
(row (apply #'ebox-row children))
|
|
(column (apply #'ebox-column children)))
|
|
(should (= (length (ebox--node-children row)) 4))
|
|
(should (= (length (ebox--node-children column)) 4))
|
|
(should (= (length (ebox--runtime-node-ids row)) 5))
|
|
(should (= (length (ebox--runtime-node-ids column)) 5))))
|
|
|
|
(ert-deftest ebox-overflow-hidden-clips-extra-content-lines ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:height 1
|
|
:overflow 'hidden))
|
|
(plain (substring-no-properties (ebox-render box))))
|
|
(should (string-match-p "A" plain))
|
|
(should-not (string-match-p "B" plain))
|
|
(should-not (string-match-p "C" plain))
|
|
(should (= (ebox-string-height plain) 1))))
|
|
|
|
(ert-deftest ebox-overflow-visible-appends-extra-content-lines ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:height 1
|
|
:overflow 'visible))
|
|
(plain (substring-no-properties (ebox-render box))))
|
|
(should (string-match-p "A" plain))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))
|
|
(should (= (ebox-string-height plain) 3))))
|
|
|
|
(defun ebox-test--assert-visible-overflow-paint
|
|
(rendered foreground background)
|
|
"Assert RENDERED keeps visible overflow painted but unowned."
|
|
(let* ((lines (ebox-string-lines rendered))
|
|
(body (car lines))
|
|
(overflow-lines (cdr lines))
|
|
(ownership-properties
|
|
(append '(ebox-content-idx ebox-content-owners)
|
|
(mapcar #'cdr ebox-region-types)))
|
|
(body-pos (cl-position ?A body)))
|
|
(should (= (length lines) 3))
|
|
(should (integerp body-pos))
|
|
(let ((body-face (get-text-property body-pos 'face body)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
body-face :foreground foreground))
|
|
(should (ebox-test--face-has-key-value-p
|
|
body-face :background background)))
|
|
(cl-loop for line in overflow-lines
|
|
for glyph in '(?B ?C)
|
|
do
|
|
(let ((glyph-pos (cl-position glyph line)))
|
|
(should (integerp glyph-pos))
|
|
(should (ebox-test--face-has-key-value-p
|
|
(get-text-property glyph-pos 'face line)
|
|
:foreground foreground)))
|
|
(dolist (offset-pos (list 0 (1- (length line))))
|
|
(should (get-text-property offset-pos 'display line))
|
|
(should-not
|
|
(ebox-test--face-has-key-p
|
|
(get-text-property offset-pos 'face line)
|
|
:foreground)))
|
|
(dotimes (pos (length line))
|
|
(should-not
|
|
(ebox-test--face-has-key-p
|
|
(get-text-property pos 'face line)
|
|
:background))
|
|
(dolist (property ownership-properties)
|
|
(should-not (get-text-property pos property line)))))))
|
|
|
|
(ert-deftest ebox-overflow-visible-paints-foreground-without-ownership ()
|
|
"Visible overflow should inherit only the outer box foreground."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:width '(40)
|
|
:height 1
|
|
:overflow 'visible
|
|
:color "#abcdef"
|
|
:bgcolor "#123456"
|
|
:padding-inline '(6)
|
|
:margin-inline '(4))))
|
|
(ebox-test--assert-visible-overflow-paint
|
|
(ebox-render box) "#abcdef" "#123456")))
|
|
|
|
(ert-deftest ebox-region-update-refreshes-visible-overflow-foreground ()
|
|
"Color updates should refresh visible overflow without owning its suffix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:width '(40)
|
|
:height 1
|
|
:overflow 'visible
|
|
:color "#abcdef"
|
|
:bgcolor "#123456"
|
|
:padding-inline '(6)
|
|
:margin-inline '(4)))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :color "#fedcba")
|
|
(ebox-test--assert-visible-overflow-paint
|
|
(buffer-string) "#fedcba" "#123456"))))
|
|
|
|
(ert-deftest ebox-owner-rerender-keeps-visible-overflow-unowned ()
|
|
"Owner rerenders should not restore box ownership to visible overflow."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:width '(40)
|
|
:height 1
|
|
:overflow 'scroll
|
|
:color "#abcdef"
|
|
:bgcolor "#123456"))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(ebox-region-update region-id :overflow 'visible)
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'owner-rerender))
|
|
(goto-char (point-min))
|
|
(search-forward "C")
|
|
(let* ((pos (match-beginning 0))
|
|
(face (get-text-property pos 'face)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "#abcdef"))
|
|
(should-not (ebox-test--face-has-key-value-p
|
|
face :background "#123456"))
|
|
(should-not (get-text-property pos 'ebox-content-owner))
|
|
(should-not (get-text-property pos 'ebox-content-owners))))))
|
|
|
|
(ert-deftest ebox-overflow-scroll-keeps-window-height-and-state ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:height 1
|
|
:overflow 'scroll))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "A" plain))
|
|
(should-not (string-match-p "B" plain))
|
|
(should (= (ebox-string-height plain) 1)))
|
|
(should (equal (plist-get (ebox--scroll-get-state region-id)
|
|
:content-height)
|
|
1))
|
|
(goto-char (point-min))
|
|
(ebox-scroll-down 1)
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should-not (string-match-p "A" plain))
|
|
(should (= (ebox-string-height plain) 1))))))
|
|
|
|
(ert-deftest ebox-scroll-falls-back-when-region-cannot-scroll ()
|
|
"Scroll commands should let the buffer move when the box has no scroll work."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(insert (ebox-render (ebox-create :content "short" :height 1)))
|
|
(insert "\n")
|
|
(dotimes (index 40)
|
|
(insert (format "tail-%02d\n" index)))
|
|
(goto-char (point-min))
|
|
(should (get-text-property (point) 'ebox-content))
|
|
(let (fallback-called)
|
|
(cl-letf (((symbol-function 'scroll-up)
|
|
(lambda (&optional _arg)
|
|
(setq fallback-called t))))
|
|
(ebox-scroll-down 1))
|
|
(should fallback-called))))
|
|
|
|
(ert-deftest ebox-scroll-bubbles-from-child-to-scrollable-ancestor ()
|
|
"Key scrolling over a child box should scroll the nearest scrollable ancestor."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "child" :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)))))
|
|
(ids (ebox-region-ids layout))
|
|
(root-id (car ids)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(goto-char (point-min))
|
|
(search-forward "A")
|
|
(backward-char)
|
|
(should-not (equal (get-text-property (point) 'ebox-content)
|
|
root-id))
|
|
(let (fallback-called)
|
|
(cl-letf (((symbol-function 'scroll-up)
|
|
(lambda (&optional _arg)
|
|
(setq fallback-called t))))
|
|
(ebox-scroll-down 1))
|
|
(should-not fallback-called))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))))))
|
|
|
|
(ert-deftest ebox-wheel-scroll-falls-back-to-default-mwheel ()
|
|
"Mouse wheel fallback should preserve Emacs' normal scroll behavior."
|
|
(ebox-test--reset-runtime-state)
|
|
(let (mwheel-args scroll-up-called)
|
|
(cl-letf (((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest args)
|
|
(setq mwheel-args args)))
|
|
((symbol-function 'scroll-up)
|
|
(lambda (&optional _arg)
|
|
(setq scroll-up-called t))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1 'fake-arg))
|
|
(should (equal mwheel-args '(fake-wheel-event fake-arg)))
|
|
(should-not scroll-up-called)))
|
|
|
|
(ert-deftest ebox-wheel-scroll-falls-back-for-non-scrollable-region ()
|
|
"Mouse wheel over a normal box should keep default buffer scrolling."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "short" :height 1))
|
|
(region-id (car (ebox-region-ids box)))
|
|
mwheel-args)
|
|
(ebox-test--with-rendered-buffer box
|
|
(cl-letf (((symbol-function 'ebox--wheel-region-ids)
|
|
(lambda (_event) (list region-id)))
|
|
((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest args)
|
|
(setq mwheel-args args))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1 'fake-arg))
|
|
(should (equal mwheel-args '(fake-wheel-event fake-arg))))))
|
|
|
|
(ert-deftest ebox-wheel-scroll-consumes-scrollable-region ()
|
|
"Mouse wheel should still scroll an overflow='scroll box when it can."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:height 1
|
|
:overflow 'scroll))
|
|
(region-id (car (ebox-region-ids box)))
|
|
mwheel-called)
|
|
(ebox-test--with-rendered-buffer box
|
|
(cl-letf (((symbol-function 'ebox--wheel-region-ids)
|
|
(lambda (_event) (list region-id)))
|
|
((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest _args)
|
|
(setq mwheel-called t))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should-not (string-match-p "A" plain)))
|
|
(should-not mwheel-called))))
|
|
|
|
(ert-deftest ebox-wheel-scroll-bubbles-from-child-to-scrollable-ancestor ()
|
|
"Mouse wheel scrolling over a child box should scroll its scrollable ancestor."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "child" :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)))))
|
|
(ids (ebox-region-ids layout))
|
|
(root-id (car ids))
|
|
(child-id (cadr ids))
|
|
mwheel-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(cl-letf (((symbol-function 'ebox--wheel-region-ids)
|
|
(lambda (_event) (list child-id root-id)))
|
|
((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest _args)
|
|
(setq mwheel-called t))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1))
|
|
(should-not mwheel-called)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))))))
|
|
|
|
(ert-deftest ebox-scroll-state-is-created-only-for-scrollable-boxes ()
|
|
"Non-overflowing boxes should not inflate the global scroll hit-test table."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(column
|
|
(box :id "short-a" :content "A" :height 1)
|
|
(box :id "short-b" :content "B" :height 1)
|
|
(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1))))))
|
|
root-id short-a-id short-b-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq short-a-id (ebox-test--selector-region-id (current-buffer)
|
|
"#short-a"))
|
|
(setq short-b-id (ebox-test--selector-region-id (current-buffer)
|
|
"#short-b"))
|
|
(should-not (ebox--scroll-get-state short-a-id))
|
|
(should-not (ebox--scroll-get-state short-b-id))
|
|
(should (ebox--scroll-get-state root-id)))))
|
|
|
|
(ert-deftest ebox-scroll-hit-test-uses-owner-stack-before-extents-scan ()
|
|
"Wheel hit testing should avoid a table-wide extents scan when owners suffice."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :id "child" :content "A" :height 1)
|
|
(box :content "B" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(goto-char (point-min))
|
|
(cl-letf (((symbol-function 'ebox--scroll-region-ids-in-extents-at-pos)
|
|
(lambda (&rest _args)
|
|
(error "unexpected extents scan"))))
|
|
(should (member root-id
|
|
(ebox--scroll-region-ids-at-pos (point))))))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-window-avoids-rerender-path ()
|
|
"Complex scroll boxes should patch visible rendered lines without rerendering."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1" :height 1)
|
|
(box :content "row-2" :height 1)
|
|
(box :content "row-3" :height 1)
|
|
(box :content "row-4" :height 1)
|
|
(box :content "row-5" :height 1)))))
|
|
root-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (plist-get state :rendered-content-lines))
|
|
(should (ebox--scroll-chrome-free-rendered-window-p
|
|
(plist-get state :box))))
|
|
(cl-letf (((symbol-function 'ebox--scroll-replace-rendered-window)
|
|
(lambda (&rest _args)
|
|
(error "unexpected rendered-window fallback")))
|
|
((symbol-function 'ebox--render-scroll-state-window)
|
|
(lambda (&rest _args)
|
|
(error "unexpected scroll-state render"))))
|
|
(should (ebox--scroll-region-by root-id 2)))
|
|
(let ((state (ebox--scroll-get-state root-id))
|
|
(plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (= (plist-get state :scroll-offset) 2))
|
|
(should (eq (plist-get state :buffer) (current-buffer)))
|
|
(should (plist-get state :rendered-window-start-marker))
|
|
(should (plist-get state :rendered-window-end-marker))
|
|
(should (= (plist-get state :rendered-window-line-count)
|
|
(plist-get state :content-height)))
|
|
(should-not (plist-get state :content-span-markers))
|
|
(should-not (plist-get state :content-window-region-id-set))
|
|
(should (string-match-p "row-3" plain))
|
|
(should (string-match-p "row-5" plain))
|
|
(should-not (string-match-p "row-1" plain))))))
|
|
|
|
(ert-deftest ebox-chrome-free-scroll-render-reuses-propertized-prefix-lines ()
|
|
"A chrome-free scroll box should not propertize its visible prefix twice."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "row-1\nrow-2\nrow-3"
|
|
:width 120
|
|
:height 2
|
|
:overflow 'scroll
|
|
:color "#112233"
|
|
:bgcolor "#ddeeff"))
|
|
(region-id (ebox--ensure-region-id box))
|
|
(reference (ebox-create :content "row-1\nrow-2\nrow-3"
|
|
:width 120
|
|
:height 2
|
|
:overflow 'hidden
|
|
:color "#112233"
|
|
:bgcolor "#ddeeff"))
|
|
(original (symbol-function 'ebox--propertize-content-line))
|
|
(root-propertize-count 0)
|
|
actual)
|
|
(plist-put reference :region-id region-id)
|
|
(cl-letf (((symbol-function 'ebox--propertize-content-line)
|
|
(lambda (line owner idx fallback)
|
|
(when (equal owner region-id)
|
|
(cl-incf root-propertize-count))
|
|
(funcall original line owner idx fallback))))
|
|
(setq actual (ebox-render box)))
|
|
(should (= root-propertize-count 3))
|
|
(should-not
|
|
(text-property-not-all 0 (length actual)
|
|
'ebox-scroll-window region-id actual))
|
|
(let ((actual-without-window-marker (copy-sequence actual)))
|
|
(remove-text-properties
|
|
0 (length actual-without-window-marker)
|
|
'(ebox-scroll-window nil)
|
|
actual-without-window-marker)
|
|
(should (equal-including-properties
|
|
actual-without-window-marker
|
|
(ebox-render reference))))))
|
|
|
|
(ert-deftest ebox-underfilled-chrome-free-scroll-fuses-line-finishing-passes ()
|
|
"A complete top-aligned underfill should keep exact output in one line pass."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content
|
|
(concat (propertize "alpha" 'face '(:weight bold)
|
|
'help-echo "rich")
|
|
"\n \nomega"))
|
|
(box (ebox-create :content content
|
|
:width 140
|
|
:height 5
|
|
:overflow 'scroll
|
|
:vertical-align 'top
|
|
:color "#112233"
|
|
:bgcolor "#ddeeff"))
|
|
(region-id (ebox--ensure-region-id box))
|
|
(reference (ebox-create :content content
|
|
:width 140
|
|
:height 5
|
|
:overflow 'hidden
|
|
:vertical-align 'top
|
|
:color "#112233"
|
|
:bgcolor "#ddeeff"))
|
|
(expected (progn
|
|
(plist-put reference :region-id region-id)
|
|
(ebox-render reference)))
|
|
(original-align (symbol-function 'ebox--lines-align-vertical))
|
|
(original-maplines (symbol-function 'ebox--maplines))
|
|
(align-calls 0)
|
|
(mapline-calls 0)
|
|
actual)
|
|
(cl-letf (((symbol-function 'ebox--lines-align-vertical)
|
|
(lambda (&rest args)
|
|
(cl-incf align-calls)
|
|
(apply original-align args)))
|
|
((symbol-function 'ebox--maplines)
|
|
(lambda (&rest args)
|
|
(cl-incf mapline-calls)
|
|
(apply original-maplines args))))
|
|
(setq actual (ebox-render box)))
|
|
(should (= align-calls 0))
|
|
;; Formatting may still justify the source once; finishing must not add
|
|
;; the former blank-normalization and color map passes.
|
|
(should (<= mapline-calls 1))
|
|
(should (equal-including-properties actual expected))
|
|
(should-not (ebox--scroll-get-state region-id))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-window-builds-spans-linearly ()
|
|
"Rendered viewport replacement should not rescan from the start per line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1" :height 1)
|
|
(box :content "row-2" :height 1)
|
|
(box :content "row-3" :height 1)
|
|
(box :content "row-4" :height 1)
|
|
(box :content "row-5" :height 1)
|
|
(box :content "row-6" :height 1)))))
|
|
root-id
|
|
(forward-line-count 0)
|
|
(original-forward-line (symbol-function 'forward-line)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(plist-put state :scroll-offset 2)
|
|
(when-let ((box (plist-get state :box)))
|
|
(ebox-put box :scroll-offset 2))
|
|
(cl-letf (((symbol-function 'forward-line)
|
|
(lambda (&optional n)
|
|
(cl-incf forward-line-count)
|
|
(funcall original-forward-line n))))
|
|
(should (ebox--scroll-replace-rendered-content-window
|
|
state root-id)))
|
|
(should (<= forward-line-count
|
|
(1+ (plist-get state :content-height))))))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-window-slides-small-deltas ()
|
|
"Small scroll deltas should mutate only entering/leaving rendered lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1111" :height 1)
|
|
(box :content "row-2222" :height 1)
|
|
(box :content "row-3333" :height 1)
|
|
(box :content "row-4444" :height 1)
|
|
(box :content "row-5555" :height 1)))))
|
|
root-id
|
|
deleted-bytes
|
|
(original-delete-region (symbol-function 'delete-region)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(let* ((extents (ebox--live-box-extents root-id))
|
|
(full-window-bytes (- (marker-position (cdr extents))
|
|
(marker-position (car extents)))))
|
|
(cl-letf (((symbol-function 'delete-region)
|
|
(lambda (start end)
|
|
(push (- end start) deleted-bytes)
|
|
(funcall original-delete-region start end))))
|
|
(should (ebox--scroll-region-by root-id 1)))
|
|
(should deleted-bytes)
|
|
(should (< (apply #'+ deleted-bytes) full-window-bytes))))))
|
|
|
|
(ert-deftest ebox-scroll-window-slide-preserves-wrapper-properties ()
|
|
"Entering cached lines should keep scroll and outer-wrapper ownership."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "outer" :color "#112233" :bgcolor "#ddeeff"
|
|
(box :id "scroll" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1111" :height 1)
|
|
(box :content "row-2222" :height 1)
|
|
(box :content "row-3333" :height 1)
|
|
(box :content "row-4444" :height 1)
|
|
(box :content "row-5555" :height 1))))))
|
|
outer-id
|
|
scroll-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq outer-id
|
|
(ebox-test--selector-region-id (current-buffer) "#outer")
|
|
scroll-id
|
|
(ebox-test--selector-region-id (current-buffer) "#scroll"))
|
|
(should (= 1 (ebox--scroll-region-by scroll-id 1)))
|
|
(let* ((state (ebox--scroll-get-state scroll-id))
|
|
(extents (ebox--scroll-state-window-extents scroll-id state))
|
|
(start (marker-position (car extents)))
|
|
(spans (ebox--scroll-line-spans-in-window start 3))
|
|
(slid (buffer-string)))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
(current-buffer) scroll-id state))
|
|
(dolist (span spans)
|
|
(should-not
|
|
(text-property-not-all
|
|
(car span) (cdr span) 'ebox-scroll-window scroll-id))
|
|
(should (member outer-id (ebox--span-wrapper-owners span))))
|
|
(ebox-buffer-apply-root-rerender (current-buffer))
|
|
(should (equal-including-properties slid (buffer-string)))))))
|
|
|
|
(ert-deftest ebox-scroll-window-slide-preserves-ancestor-horizontal-borders ()
|
|
"Scrolling inside a bordered ancestor should preserve slot border paint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "outer"
|
|
:border-top-p t :border-top-color "red"
|
|
:border-bottom-p t :border-bottom-color "blue"
|
|
(box :id "scroll" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1111" :height 1)
|
|
(box :content "row-2222" :height 1)
|
|
(box :content "row-3333" :height 1)
|
|
(box :content "row-4444" :height 1)
|
|
(box :content "row-5555" :height 1))))))
|
|
scroll-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq scroll-id
|
|
(ebox-test--selector-region-id (current-buffer) "#scroll"))
|
|
(let ((root-rerenders 0)
|
|
(original-root-rerender
|
|
(symbol-function 'ebox-buffer-apply-root-rerender)))
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-root-rerender)
|
|
(lambda (buffer)
|
|
(cl-incf root-rerenders)
|
|
(funcall original-root-rerender buffer))))
|
|
(should (= 1 (ebox--scroll-region-by scroll-id 1))))
|
|
(should (= root-rerenders 1)))
|
|
(let ((scrolled (buffer-string)))
|
|
(ebox-buffer-apply-root-rerender (current-buffer))
|
|
(should (equal-including-properties scrolled (buffer-string)))))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-window-uses-slide-in-gui ()
|
|
"GUI rendered viewport scrolling should try bounded line sliding."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row-1111" :height 1)
|
|
(box :content "row-2222" :height 1)
|
|
(box :content "row-3333" :height 1)
|
|
(box :content "row-4444" :height 1)
|
|
(box :content "row-5555" :height 1)))))
|
|
root-id
|
|
slide-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(let ((noninteractive nil))
|
|
(cl-letf (((symbol-function 'display-graphic-p)
|
|
(lambda (&optional _display) t))
|
|
((symbol-function
|
|
'ebox--scroll-replace-rendered-content-window-slide)
|
|
(lambda (&rest _args)
|
|
(setq slide-called t)
|
|
nil)))
|
|
(should (ebox--scroll-region-by root-id 1))))
|
|
(should slide-called))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-rendered-window-uses-preformatted-lines ()
|
|
"Lazy scroll windows should not rebuild visible content lines per tick."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(content-window-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(original-content-window
|
|
(symbol-function 'ebox--scroll-replace-content-window)))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (plist-get state :rendered-content-lines))
|
|
(should (plist-get state :render-content-prefix)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-replace-content-window)
|
|
(lambda (&rest args)
|
|
(cl-incf content-window-count)
|
|
(apply original-content-window args))))
|
|
(should (ebox--scroll-region-by root-id 8)))
|
|
(should (= content-window-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 8))
|
|
(should (plist-get state :rendered-content-lines)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-after-viewport-resize-keeps-window-extents ()
|
|
"Viewport resize must preserve lazy scroll's fixed viewport fast path."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :id "viewport" :width (viewport)
|
|
:height (viewport-height)
|
|
(box :content "" :width (viewport) :height 1)
|
|
(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 2)
|
|
:overflow scroll
|
|
(column :width (viewport) :padding (1 (8))
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)
|
|
:width (viewport)
|
|
:height 1)))
|
|
(box :content "" :width (viewport) :height 1)))))
|
|
buffer
|
|
root-id
|
|
(materialize-count 0)
|
|
(rerender-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 12)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(ebox-rerender-buffer-with-context buffer 320 14)
|
|
(with-current-buffer buffer
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(extents (ebox--live-box-extents root-id))
|
|
(extent-lines
|
|
(and extents
|
|
(count-lines (marker-position (car extents))
|
|
(marker-position (cdr extents))))))
|
|
(should extents)
|
|
(ert-info ((format "state=%S"
|
|
(list :content-height
|
|
(plist-get state :content-height)
|
|
:content-lines
|
|
(length (plist-get state
|
|
:content-lines))
|
|
:rendered-lines
|
|
(length (plist-get state
|
|
:rendered-content-lines))
|
|
:extent-lines extent-lines)))
|
|
(should (= extent-lines
|
|
(plist-get state :content-height))))
|
|
(when-let ((materialize
|
|
(plist-get state :materialize-content-lines)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state)))
|
|
(let ((original-rerender
|
|
(symbol-function 'ebox--scroll-rerender-region)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-rerender-region)
|
|
(lambda (&rest args)
|
|
(cl-incf rerender-count)
|
|
(apply original-rerender args))))
|
|
(should (ebox--smooth-scroll-region-by root-id 16))
|
|
(while (gethash root-id ebox--smooth-scroll-state-table)
|
|
(ebox--smooth-scroll-tick root-id))))
|
|
(should (= materialize-count 0))
|
|
(should (= rerender-count 0))))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-offset-viewport-resize-stays-lazy ()
|
|
"Viewport resize after scrolling should not materialize all hidden content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(column :id "viewport" :width (viewport)
|
|
:height (viewport-height)
|
|
(box :content "" :width (viewport) :height 1)
|
|
(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 2)
|
|
:overflow scroll
|
|
(column :width (viewport) :padding (1 (8))
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "offset row %02d" idx)
|
|
:width (viewport)
|
|
:height 1)))
|
|
(box :content "" :width (viewport) :height 1)))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 12)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 16)))
|
|
(ebox-rerender-buffer-with-context buffer 320 14)
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 16))
|
|
(should (plist-get state :render-content-prefix))
|
|
(should (plist-get state :materialize-content-lines))
|
|
(should (< (length (plist-get state :content-lines)) 80))
|
|
(should (>= (length (plist-get state :content-lines))
|
|
(+ (plist-get state :scroll-offset)
|
|
(plist-get state :content-height))))))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-intrinsic-measurement-skips-window-source ()
|
|
"Flex intrinsic measurement should not render lazy scroll window content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 2)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :content ,(format "measurement row %02d" idx)
|
|
:width (viewport)
|
|
:height 1))))))
|
|
(calls 0)
|
|
rendered)
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (&rest _args)
|
|
(cl-incf calls)
|
|
(list :lines nil :complete nil :cache nil))))
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 12)
|
|
(ebox--intrinsic-layout-measurement t))
|
|
(setq rendered (ebox-render layout)))
|
|
(should (= calls 0))
|
|
(should (= (ebox-string-height rendered) 10))
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 12)
|
|
(ebox--intrinsic-layout-measurement nil))
|
|
(ebox-render layout))
|
|
(should (= calls 1)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-sync-prefix-does-not-require-idle-prefetch ()
|
|
"Interactive scrolling should extend a lazy prefix even with idle prefetch off."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 10)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "sync row %02d" idx)
|
|
:width (viewport)
|
|
:height 1))))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 20)
|
|
(ebox-scroll-step 4)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((before (ebox--scroll-get-state root-id))
|
|
(initial-lines (length (plist-get before :content-lines)))
|
|
(content-height (plist-get before :content-height))
|
|
(boundary-offset (- initial-lines content-height)))
|
|
(should (> boundary-offset 0))
|
|
(with-current-buffer buffer
|
|
(should (= boundary-offset
|
|
(ebox--scroll-region-by root-id
|
|
boundary-offset)))))
|
|
(with-current-buffer buffer
|
|
(should (= 4 (ebox--scroll-region-by root-id 4))))
|
|
(let ((after (ebox--scroll-get-state root-id)))
|
|
(should (> (plist-get after :scroll-offset) 4))
|
|
(should (>= (length (plist-get after :content-lines))
|
|
(+ (plist-get after :scroll-offset)
|
|
(plist-get after :content-height))))
|
|
(should-not (plist-get after :content-lines-complete-p))))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-gui-cache-miss-returns-pending ()
|
|
"GUI scroll cache misses should not synchronously render missing content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 10)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "gui row %02d" idx)
|
|
:width (viewport)
|
|
:height 1))))))
|
|
buffer
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 20)
|
|
(ebox-scroll-step 4)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(noninteractive nil))
|
|
(cl-letf (((symbol-function 'display-graphic-p)
|
|
(lambda (&optional _display) t)))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(initial-lines (length (plist-get state :content-lines)))
|
|
(content-height (plist-get state :content-height))
|
|
(boundary-offset (- initial-lines content-height)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state)
|
|
(with-current-buffer buffer
|
|
(should (= boundary-offset
|
|
(ebox--scroll-region-by root-id
|
|
boundary-offset)))
|
|
(should (eq 'pending
|
|
(ebox--scroll-region-by root-id 4)))))
|
|
(should (= prefix-count 0))))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-explicit-budget-syncs-prefix-in-gui ()
|
|
"A caller-provided prefix budget should synchronously extend GUI lazy scrolls."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport)
|
|
:height (- (viewport-height) 10)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "budget row %02d" idx)
|
|
:width (viewport)
|
|
:height 1))))))
|
|
buffer
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 20)
|
|
(ebox-scroll-step 4)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(noninteractive nil))
|
|
(cl-letf (((symbol-function 'display-graphic-p)
|
|
(lambda (&optional _display) t)))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(initial-lines (length (plist-get state :content-lines)))
|
|
(content-height (plist-get state :content-height))
|
|
(boundary-offset (- initial-lines content-height)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state)
|
|
(with-current-buffer buffer
|
|
(should (= boundary-offset
|
|
(ebox--scroll-region-by root-id
|
|
boundary-offset)))
|
|
(should (= 4 (ebox--scroll-region-by root-id 4 4)))))
|
|
(should (= prefix-count 1))))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-window-sliding-is-used-in-gui ()
|
|
"Graphical frames should use bounded line sliding for scroll windows."
|
|
(let ((noninteractive nil))
|
|
(cl-letf (((symbol-function 'display-graphic-p)
|
|
(lambda (&optional _display) t)))
|
|
(should (ebox--scroll-rendered-window-slide-preferred-p)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-reuses-viewport-dependent-flex-leaves ()
|
|
"Lazy prefix extension should not rerender prior viewport flex leaves."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((flex-section
|
|
(lambda (label)
|
|
`(flex :width (viewport) :flex-flow (row wrap)
|
|
,@(cl-loop for idx below 4
|
|
collect
|
|
`(box :content ,(format "%s-%d" label idx)
|
|
:width (110)
|
|
:height 1)))))
|
|
(layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,(funcall flex-section "a")
|
|
(spacer :height 1)
|
|
,(funcall flex-section "b")))))
|
|
(buffer nil)
|
|
root-id
|
|
(flex-render-count 0)
|
|
(original-render-flex (symbol-function 'ebox--render-flex)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (length (plist-get state :content-lines)) 3))
|
|
(should (plist-get state :render-content-prefix)))
|
|
(cl-letf (((symbol-function 'ebox--render-flex)
|
|
(lambda (&rest args)
|
|
(cl-incf flex-render-count)
|
|
(apply original-render-flex args))))
|
|
(should (ebox--scroll-region-by root-id 3)))
|
|
(should (<= flex-render-count 1))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-flex-prefix-renders-only-needed-rows ()
|
|
"Lazy scroll prefixes should not render hidden row-wrap flex rows."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(box :id "head" :content "head" :width (viewport) :height 1)
|
|
(flex :width (viewport) :flex-flow (row wrap)
|
|
:row-gap 0 :column-gap 0
|
|
,@(cl-loop for idx below 12
|
|
collect
|
|
`(box :id ,(format "item-%02d" idx)
|
|
:content ,(format "item %02d" idx)
|
|
:width (100) :height 2)))))))
|
|
(buffer nil)
|
|
(hidden-render-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 1)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when-let ((id (and (listp box) (ebox-get box :id))))
|
|
(when (and (string-prefix-p "item-" id)
|
|
(>= (string-to-number
|
|
(substring id (length "item-")))
|
|
4))
|
|
(cl-incf hidden-render-count)))
|
|
(funcall original-render-box box))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(should (= hidden-render-count 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-flex-window-lines-match-full-render-prefix ()
|
|
"Partial flex window rendering should match the full render prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (240) :flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil :bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 6
|
|
collect
|
|
`(box :id ,(format "prefix-item-%02d" idx)
|
|
:content ,(format "prefix %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(limit 4)
|
|
(full-lines (ebox-string-lines (ebox-render node)))
|
|
(window (ebox--render-flex-window-lines node limit)))
|
|
(should-not (plist-get window :complete))
|
|
(should (equal (mapcar #'substring-no-properties
|
|
(seq-take full-lines limit))
|
|
(mapcar #'substring-no-properties
|
|
(plist-get window :lines))))))
|
|
|
|
(ert-deftest ebox-flex-window-shrinks-definite-wrapping-items ()
|
|
"Window prefix rendering must not freeze shrinkable definite widths."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (160) :flex-flow (row wrap)
|
|
(box :id "shrink-a" :content "alpha beta gamma delta"
|
|
:width (200) :height 2)
|
|
(box :id "shrink-b" :content "second row content"
|
|
:width (160) :height 2))))
|
|
(limit 2)
|
|
(full-lines (ebox-string-lines (ebox-render node)))
|
|
(window (ebox--render-flex-window-lines node limit)))
|
|
;; A nil window means the full-render fallback takes over, which is
|
|
;; also correct. Produced window lines must match the full
|
|
;; renderer's prefix geometry instead of freezing the declared
|
|
;; 200px width inside the 160px container.
|
|
(when window
|
|
(should (equal (mapcar #'ebox--string-pixel-width
|
|
(seq-take full-lines limit))
|
|
(mapcar #'ebox--string-pixel-width
|
|
(plist-get window :lines)))))))
|
|
|
|
(ert-deftest ebox-flex-window-char-wrapper-falls-back-to-full-prefix ()
|
|
"Char-wrapped flex prefixes should use the full-render fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (100) :wrap-mode char :flex-flow (row wrap)
|
|
:row-gap 0 :column-gap 0
|
|
,@(cl-loop for char across "ABCD"
|
|
collect
|
|
`(box :content ,(char-to-string char)
|
|
:width (150) :height 1)))))
|
|
(full-lines (ebox-string-lines (ebox-render node)))
|
|
(expected-signatures
|
|
(mapcar #'ebox-test--visual-line-signature
|
|
(seq-take full-lines 3)))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--render-cache-signature-cache (make-hash-table :test 'eq))
|
|
(first (ebox--render-stack-window-lines node 1))
|
|
(extended
|
|
(ebox--render-stack-window-lines
|
|
node 3 (plist-get first :cache)))
|
|
(producer (ebox--render-node-window-lines node 3))
|
|
(actual-signatures
|
|
(mapcar #'ebox-test--visual-line-signature
|
|
(plist-get extended :lines))))
|
|
(should (equal expected-signatures actual-signatures))
|
|
(should-not producer)))
|
|
|
|
(ert-deftest ebox-flex-window-aligned-wrapper-falls-back-to-full-prefix ()
|
|
"Non-left-aligned flex prefixes should use the full-render fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (100) :text-align center :flex-flow (row wrap)
|
|
:row-gap 0 :column-gap 0
|
|
,@(cl-loop for char across "ABCDEF"
|
|
collect
|
|
`(box :content ,(char-to-string char)
|
|
:width (50) :height 1)))))
|
|
(full-lines (ebox-string-lines (ebox-render node)))
|
|
(expected-signatures
|
|
(mapcar #'ebox-test--visual-line-signature
|
|
(seq-take full-lines 3)))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--render-cache-signature-cache (make-hash-table :test 'eq))
|
|
(first (ebox--render-stack-window-lines node 1))
|
|
(extended
|
|
(ebox--render-stack-window-lines
|
|
node 3 (plist-get first :cache)))
|
|
(producer (ebox--render-node-window-lines node 3))
|
|
(actual-signatures
|
|
(mapcar #'ebox-test--visual-line-signature
|
|
(plist-get extended :lines))))
|
|
(should (equal expected-signatures actual-signatures))
|
|
(should-not producer)))
|
|
|
|
(ert-deftest ebox-flex-window-lines-use-chunk-wrapper-for-first-prefix ()
|
|
"A seedless flex prefix should avoid the generic full wrapper renderer."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-window-wrapper" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil :bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :content ,(format "wrapper %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(full-lines (ebox-string-lines (ebox-render node)))
|
|
(full-wrapper-count 0)
|
|
(chunk-wrapper-count 0)
|
|
(multiline-horizontal-concat-count 0)
|
|
(original-full-wrapper
|
|
(symbol-function 'ebox--flex-window-render-box-lines))
|
|
(original-chunk-wrapper
|
|
(symbol-function 'ebox--flex-window-render-wrapper-chunk-lines))
|
|
(original-horizontal-concat
|
|
(symbol-function 'ebox--lines-concat-horizontal)))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-render-box-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf full-wrapper-count)
|
|
(apply original-full-wrapper args)))
|
|
((symbol-function 'ebox--flex-window-render-wrapper-chunk-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf chunk-wrapper-count)
|
|
(apply original-chunk-wrapper args)))
|
|
((symbol-function 'ebox--lines-concat-horizontal)
|
|
(lambda (&rest args)
|
|
(cl-incf multiline-horizontal-concat-count)
|
|
(apply original-horizontal-concat args))))
|
|
(let ((window (ebox--render-flex-window-lines node 4)))
|
|
(should window)
|
|
(should-not (plist-get window :complete))
|
|
(should (= (length (plist-get window :lines)) 4))
|
|
(should
|
|
(equal-including-properties
|
|
(ebox-lines-join (seq-take full-lines 4))
|
|
(ebox-lines-join (plist-get window :lines))))))
|
|
(should (= full-wrapper-count 0))
|
|
(should (= chunk-wrapper-count 1))
|
|
(should (= multiline-horizontal-concat-count 0))))
|
|
|
|
(ert-deftest ebox-flex-window-lines-use-chunk-wrapper-for-first-completion ()
|
|
"A compatible seedless completion should avoid the generic full wrapper."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-window-complete-wrapper" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil :bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 4
|
|
collect
|
|
`(box :content ,(format "complete %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(full (ebox-render node))
|
|
(full-wrapper-count 0)
|
|
(chunk-wrapper-count 0)
|
|
(original-full-wrapper
|
|
(symbol-function 'ebox--flex-window-render-box-lines))
|
|
(original-chunk-wrapper
|
|
(symbol-function 'ebox--flex-window-render-wrapper-chunk-lines)))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-render-box-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf full-wrapper-count)
|
|
(apply original-full-wrapper args)))
|
|
((symbol-function 'ebox--flex-window-render-wrapper-chunk-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf chunk-wrapper-count)
|
|
(apply original-chunk-wrapper args))))
|
|
(let ((window (ebox--render-flex-window-lines node 8)))
|
|
(should window)
|
|
(should (plist-get window :complete))
|
|
(should
|
|
(equal-including-properties
|
|
full
|
|
(ebox-lines-join (plist-get window :lines))))))
|
|
(should (= full-wrapper-count 0))
|
|
(should (= chunk-wrapper-count 1))))
|
|
|
|
(ert-deftest ebox-flex-flat-wrapper-owns-color-copy-in-place ()
|
|
"Flat flex wrappers should decorate one private line copy per source line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :width 120
|
|
:padding-left 8
|
|
:padding-right 8
|
|
:border-left 1
|
|
:border-right 1
|
|
:border-color "#D97757"
|
|
:bgcolor "#FFF8F2"))
|
|
(source (propertize "child" 'ebox-content 77
|
|
'ebox-content-owner 77
|
|
'ebox-content-owners '(77)))
|
|
(source-before (copy-sequence source))
|
|
(expected
|
|
(ebox--flex-window-render-wrapper-chunk-lines
|
|
box (list source) 0 t))
|
|
(copying-owner-count 0)
|
|
(original-copying-owner
|
|
(symbol-function 'ebox--add-content-owner))
|
|
actual)
|
|
(cl-letf (((symbol-function 'ebox--add-content-owner)
|
|
(lambda (&rest args)
|
|
(cl-incf copying-owner-count)
|
|
(apply original-copying-owner args))))
|
|
(setq actual
|
|
(ebox--flex-window-render-wrapper-chunk-lines
|
|
box (list source) 0 t)))
|
|
(should (equal-including-properties source source-before))
|
|
(should
|
|
(equal-including-properties
|
|
(ebox-lines-join actual)
|
|
(ebox-lines-join expected)))
|
|
(should (= copying-owner-count 0))))
|
|
|
|
(ert-deftest ebox-flex-window-lines-reuses-render-cache ()
|
|
"Repeated flex window renders should reuse the render cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (240) :flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :id ,(format "cache-item-%02d" idx)
|
|
:content ,(format "cache %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(row-render-count 0)
|
|
(original-render-row-line
|
|
(symbol-function 'ebox--flex-render-row-line)))
|
|
(cl-letf (((symbol-function 'ebox--flex-render-row-line)
|
|
(lambda (&rest args)
|
|
(cl-incf row-render-count)
|
|
(apply original-render-row-line args))))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(let ((after-first row-render-count))
|
|
(should (> after-first 0))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(should (= row-render-count after-first))))))
|
|
|
|
(ert-deftest ebox-flex-window-lines-reuses-node-cache-signature ()
|
|
"One flex window render should not repeatedly compute the node signature."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (240) :flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :id ,(format "sig-item-%02d" idx)
|
|
:content ,(format "sig %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--render-cache-signature-cache (make-hash-table :test 'eq))
|
|
(signature-count 0)
|
|
(original-signature
|
|
(symbol-function 'ebox--render-cache-node-signature)))
|
|
(cl-letf (((symbol-function 'ebox--render-cache-node-signature)
|
|
(lambda (&rest args)
|
|
(when (eq (car args) node)
|
|
(cl-incf signature-count))
|
|
(apply original-signature args))))
|
|
(should (ebox--render-flex-window-lines node 4)))
|
|
(should (<= signature-count 2))))
|
|
|
|
(ert-deftest ebox-flex-window-prefix-extension-reuses-wrapper-lines ()
|
|
"Extending a flex prefix should not rerender prior wrapper lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-prefix-wrapper" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil :bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :content ,(format "extend %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(full-lines (mapcar #'substring-no-properties
|
|
(ebox-string-lines (ebox-render node))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(generic-wrapper-render-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when (equal (and (listp box) (ebox-get box :id))
|
|
"flex-prefix-wrapper")
|
|
(cl-incf generic-wrapper-render-count))
|
|
(funcall original-render-box box))))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(should (= generic-wrapper-render-count 0))
|
|
(let ((window (ebox--render-flex-window-lines node 8)))
|
|
(should window)
|
|
(should (= generic-wrapper-render-count 0))
|
|
(should (equal (seq-take full-lines 8)
|
|
(mapcar #'substring-no-properties
|
|
(plist-get window :lines))))))))
|
|
|
|
(ert-deftest ebox-flex-window-prefix-extension-joins-only-new-pieces ()
|
|
"Extending a flex prefix should not rejoin the whole cached prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :width (240) :flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8)) :border "#D97757"
|
|
:border-top-p nil :bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 16
|
|
collect
|
|
`(box :content ,(format "piece %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
join-piece-counts
|
|
(original-join-pieces
|
|
(symbol-function 'ebox--flex-window-lines-from-pieces)))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-lines-from-pieces)
|
|
(lambda (pieces)
|
|
(push (length pieces) join-piece-counts)
|
|
(funcall original-join-pieces pieces))))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(setq join-piece-counts nil)
|
|
(should (ebox--render-flex-window-lines node 8)))
|
|
(should join-piece-counts)
|
|
(should-not (cl-some (lambda (count) (> count 4))
|
|
join-piece-counts))))
|
|
|
|
(ert-deftest ebox-flex-window-complete-prefix-defers-bottom-wrapper ()
|
|
"A complete flex source should not full-render bottom chrome before LIMIT."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-complete-prefix" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8) 2 (8))
|
|
:margin-bottom 2
|
|
:border "#D97757"
|
|
:border-top-p nil
|
|
:bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 2
|
|
collect
|
|
`(box :content ,(format "complete %02d" idx)
|
|
:width (100) :height 8)))))
|
|
(limit 4)
|
|
(full-lines (mapcar #'substring-no-properties
|
|
(ebox-string-lines (ebox-render node))))
|
|
(complete-wrapper-count 0)
|
|
(original-render-box-lines
|
|
(symbol-function 'ebox--flex-window-render-box-lines)))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-render-box-lines)
|
|
(lambda (node content complete limit)
|
|
(when complete
|
|
(cl-incf complete-wrapper-count))
|
|
(funcall original-render-box-lines
|
|
node content complete limit))))
|
|
(let ((window (ebox--render-flex-window-lines node limit)))
|
|
(should window)
|
|
(should-not (plist-get window :complete))
|
|
(should (= complete-wrapper-count 0))
|
|
(should (equal (seq-take full-lines limit)
|
|
(mapcar #'substring-no-properties
|
|
(plist-get window :lines))))))))
|
|
|
|
(ert-deftest ebox-flex-window-complete-extension-appends-bottom-border ()
|
|
"Completing a cached flex prefix should append bottom border without full render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-complete-border" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8))
|
|
:border "#D97757"
|
|
:border-top-p nil
|
|
:bgcolor "#FFF8F2"
|
|
,@(cl-loop for idx below 4
|
|
collect
|
|
`(box :content ,(format "border %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(full-lines (mapcar #'substring-no-properties
|
|
(ebox-string-lines (ebox-render node))))
|
|
(complete-wrapper-count 0)
|
|
(original-render-box-lines
|
|
(symbol-function 'ebox--flex-window-render-box-lines)))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-render-box-lines)
|
|
(lambda (node content complete limit)
|
|
(when complete
|
|
(cl-incf complete-wrapper-count))
|
|
(funcall original-render-box-lines
|
|
node content complete limit))))
|
|
(let ((window (ebox--render-flex-window-lines node 8)))
|
|
(should window)
|
|
(should (plist-get window :complete))
|
|
(should (= complete-wrapper-count 0))
|
|
(should (equal (seq-take full-lines 8)
|
|
(mapcar #'substring-no-properties
|
|
(plist-get window :lines))))))))
|
|
|
|
(ert-deftest ebox-flex-window-failed-completion-keeps-prefix-cache-atomic ()
|
|
"A failed flex completion should not publish half-appended cache lists."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node
|
|
(ebox-build
|
|
`(flex :id "flex-atomic-prefix" :width (240)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap 0
|
|
:padding (0 (8))
|
|
:border "#D97757"
|
|
:border-top-p nil
|
|
,@(cl-loop for idx below 4
|
|
collect
|
|
`(box :content ,(format "atomic %02d" idx)
|
|
:width (100) :height 2)))))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(context (ebox--flex-window-cache-context node)))
|
|
(should (ebox--render-flex-window-lines node 4))
|
|
(let* ((before (ebox--flex-window-prefix-cache-lookup node context))
|
|
(before-lines (plist-get before :lines))
|
|
(before-content-lines (plist-get before :content-lines))
|
|
(before-line-count (plist-get before :line-count))
|
|
(before-content-count (plist-get before :content-line-count)))
|
|
(cl-letf (((symbol-function 'ebox--flex-window-complete-tail-line)
|
|
(lambda (&rest _)
|
|
(error "injected flex completion failure"))))
|
|
(should-error (ebox--render-flex-window-lines node 8)))
|
|
(let ((after (ebox--flex-window-prefix-cache-lookup node context)))
|
|
(should (eq before-lines (plist-get after :lines)))
|
|
(should (eq before-content-lines
|
|
(plist-get after :content-lines)))
|
|
(should (= before-line-count (length before-lines)))
|
|
(should (= before-content-count (length before-content-lines)))
|
|
(should (= (plist-get after :line-count)
|
|
(length (plist-get after :lines))))
|
|
(should (= (plist-get after :content-line-count)
|
|
(length (plist-get after :content-lines)))))
|
|
(should (plist-get (ebox--render-flex-window-lines node 8)
|
|
:complete)))))
|
|
|
|
(ert-deftest ebox-stack-window-completion-reconciles-declared-prefix-tail ()
|
|
"A completed leaf should refresh declared chrome on its cached tail."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((type 'ebox-test-completing-window)
|
|
(leaf (list :ebox-type type))
|
|
(stack (list :ebox-type 'stack :children (list leaf)))
|
|
(plain-tail (propertize "tail" 'face '(:foreground "red")))
|
|
(complete-tail
|
|
(ebox--propertize-underline
|
|
(copy-sequence plain-tail) "blue")))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--register-window-line-renderer
|
|
type
|
|
(lambda (_node limit)
|
|
(if (< limit 3)
|
|
(list :lines (list "head" plain-tail)
|
|
:complete nil)
|
|
(list :lines (list "head" complete-tail)
|
|
:complete t
|
|
:completion-prefix-tail-rewrite-count 1))))
|
|
(let* ((prefix (ebox--render-stack-window-lines stack 2))
|
|
(completed
|
|
(ebox--render-stack-window-lines
|
|
stack 3 (plist-get prefix :cache)))
|
|
(tail (cadr (plist-get completed :lines)))
|
|
(face (get-text-property 0 'face tail))
|
|
(delta (plist-get completed :prefix-delta)))
|
|
(should (plist-get completed :complete))
|
|
(should (= (length (plist-get completed :lines)) 2))
|
|
(should (plist-get delta :exact-p))
|
|
(should (= (plist-get delta :base-count) 2))
|
|
(should (equal (plist-get delta :rewrite-range) '(1 . 2)))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "blue")))))
|
|
(remhash type ebox--window-line-renderer-table))))
|
|
|
|
(ert-deftest ebox-stack-window-invalid-completion-rewrite-rebuilds-prefix ()
|
|
"Invalid completion metadata should discard a potentially stale prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (metadata '(3 -1 invalid missing))
|
|
(let* ((type 'ebox-test-invalid-completing-window)
|
|
(leaf (list :ebox-type type))
|
|
(stack (list :ebox-type 'stack :children (list leaf)))
|
|
(plain-tail "tail")
|
|
(complete-tail
|
|
(ebox--propertize-underline "tail" "blue"))
|
|
(calls 0))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--register-window-line-renderer
|
|
type
|
|
(lambda (_node limit)
|
|
(cl-incf calls)
|
|
(if (< limit 3)
|
|
(list :lines (list "head" plain-tail)
|
|
:complete nil)
|
|
(append
|
|
(list :lines (list "head" complete-tail)
|
|
:complete t)
|
|
(unless (eq metadata 'missing)
|
|
(list :completion-prefix-tail-rewrite-count
|
|
metadata))))))
|
|
(let* ((prefix (ebox--render-stack-window-lines stack 2))
|
|
(completed
|
|
(ebox--render-stack-window-lines
|
|
stack 3 (plist-get prefix :cache)))
|
|
(tail (cadr (plist-get completed :lines)))
|
|
(face (get-text-property 0 'face tail))
|
|
(delta (plist-get completed :prefix-delta)))
|
|
(should (= calls 3))
|
|
(should-not (plist-get delta :exact-p))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "blue")))))
|
|
(remhash type ebox--window-line-renderer-table)))))
|
|
|
|
(ert-deftest ebox-flex-window-completion-tail-metadata-is-border-specific ()
|
|
"Only an existing bottom-border line should request a prefix rewrite."
|
|
(ebox-test--reset-runtime-state)
|
|
(should
|
|
(= 1
|
|
(ebox--flex-window-completion-prefix-tail-rewrite-count
|
|
(list :box (ebox-create :border-bottom-p t
|
|
:padding-bottom 0)))))
|
|
(should
|
|
(= 1
|
|
(ebox--flex-window-completion-prefix-tail-rewrite-count
|
|
(list :box (ebox-create :border-bottom-p t
|
|
:padding-bottom 0
|
|
:margin-bottom 2)))))
|
|
(should
|
|
(= 0
|
|
(ebox--flex-window-completion-prefix-tail-rewrite-count
|
|
(list :box (ebox-create :border-bottom-p t
|
|
:padding-bottom 2)))))
|
|
(should
|
|
(= 0
|
|
(ebox--flex-window-completion-prefix-tail-rewrite-count
|
|
(list :box (ebox-create :border-bottom-p nil
|
|
:padding-bottom 0))))))
|
|
|
|
(ert-deftest ebox-flex-window-cache-rejects-short-incomplete-exact-hit ()
|
|
"An underfilled exact-limit cache must resume from its prefix seed."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((lines (cl-loop repeat 112 collect "line"))
|
|
(entry (list :lines lines
|
|
:line-count 112
|
|
:line-tail (last lines)
|
|
:complete nil))
|
|
looked-up-keys)
|
|
(cl-letf (((symbol-function 'ebox--render-cache-lookup)
|
|
(lambda (key _signature)
|
|
(push key looked-up-keys)
|
|
(cond
|
|
((equal key '(7 flex-window prefix)) entry)
|
|
((equal key '(7 flex-window 118)) entry)))))
|
|
(should-not
|
|
(ebox--flex-window-cache-lookup
|
|
:test-node 118 '(:node-id 7 :signature test-signature))))
|
|
(should (member '(7 flex-window 118) looked-up-keys))))
|
|
|
|
(ert-deftest ebox-byte-compiled-scroll-window-binds-wrapper-viewport ()
|
|
"Compiled lazy rendering must dynamically bind the wrapper content width."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((wrapper (ebox-create :content "" :width '(278) :wrap-mode nil))
|
|
(source (list :stack :test-stack :wrapper wrapper))
|
|
observed-viewport)
|
|
(cl-letf (((symbol-function 'ebox--render-stack-window-lines)
|
|
(lambda (&rest _args)
|
|
(setq observed-viewport ebox-viewport-width)
|
|
(throw 'viewport-observed nil))))
|
|
(let ((ebox-viewport-width 900))
|
|
(catch 'viewport-observed
|
|
(ebox--render-scroll-window-source source 1))))
|
|
(should (= observed-viewport 278))))
|
|
|
|
(ert-deftest ebox-scroll-window-wrapper-applies-declared-prefix-rewrite ()
|
|
"Wrapper prefix reuse should rerender only a declared changed range."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((wrapper (ebox-create :content "" :width 20 :wrap-mode nil))
|
|
(source (list :stack :test-stack :wrapper wrapper))
|
|
(plain-tail "tail")
|
|
(complete-tail
|
|
(ebox--propertize-underline "tail" "blue"))
|
|
(stack-lines (list plain-tail))
|
|
(calls 0)
|
|
(second-call-line-count 0)
|
|
(original-chunk-renderer
|
|
(symbol-function
|
|
'ebox--scroll-window-render-wrapper-chunk-lines)))
|
|
(cl-letf (((symbol-function 'ebox--render-stack-window-lines)
|
|
(lambda (&rest _args)
|
|
(cl-incf calls)
|
|
(if (= calls 1)
|
|
(list :lines stack-lines
|
|
:line-count 1
|
|
:line-tail stack-lines
|
|
:complete nil
|
|
:cache :first
|
|
:prefix-delta
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines nil))
|
|
(setcar stack-lines complete-tail)
|
|
(list :lines stack-lines
|
|
:line-count 1
|
|
:line-tail stack-lines
|
|
:complete nil
|
|
:cache :second
|
|
:prefix-delta
|
|
(list :exact-p t :base-count 1
|
|
:rewrite-range '(0 . 1)
|
|
:rewrite-lines (list complete-tail)
|
|
:append-lines nil)))))
|
|
((symbol-function
|
|
'ebox--scroll-window-render-wrapper-chunk-lines)
|
|
(lambda (&rest args)
|
|
(when (= calls 2)
|
|
(cl-incf second-call-line-count
|
|
(length (cadr args))))
|
|
(apply original-chunk-renderer args)))
|
|
((symbol-function 'equal-including-properties)
|
|
(lambda (&rest _)
|
|
(ert-fail "wrapper reuse scanned the whole prefix"))))
|
|
(let* ((prefix (ebox--render-scroll-window-source source 1))
|
|
(extended
|
|
(ebox--render-scroll-window-source
|
|
source 2 (plist-get prefix :cache)))
|
|
(line (car (plist-get extended :lines)))
|
|
(face (get-text-property 0 'face line))
|
|
(delta (plist-get extended :prefix-delta)))
|
|
(should (= calls 2))
|
|
(should (= second-call-line-count 1))
|
|
(should (plist-get delta :exact-p))
|
|
(should (= (plist-get delta :base-count) 1))
|
|
(should (equal (plist-get delta :rewrite-range) '(0 . 1)))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "blue")))))))
|
|
|
|
(ert-deftest ebox-scroll-window-wrapper-maps-top-chrome-rewrite-ranges ()
|
|
"Wrapper reuse should include top chrome only when source line zero changes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((wrapper (ebox-create :content "" :width 20 :wrap-mode nil
|
|
:margin-top 1 :padding-top 2)))
|
|
(cl-labels
|
|
((mapped-range (source-range)
|
|
(let* ((source
|
|
(list :stack :test-stack :wrapper wrapper))
|
|
(source-lines (list "head" "body"))
|
|
(calls 0))
|
|
(cl-letf
|
|
(((symbol-function 'ebox--render-stack-window-lines)
|
|
(lambda (&rest _)
|
|
(cl-incf calls)
|
|
(when (= calls 2)
|
|
(setcar (nthcdr (car source-range) source-lines)
|
|
"changed"))
|
|
(list
|
|
:lines source-lines
|
|
:line-count 2
|
|
:line-tail (last source-lines)
|
|
:complete nil
|
|
:cache calls
|
|
:prefix-delta
|
|
(if (= calls 1)
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil :rewrite-lines nil
|
|
:append-lines nil)
|
|
(list :exact-p t :base-count 2
|
|
:rewrite-range source-range
|
|
:rewrite-lines (list "changed")
|
|
:append-lines nil))))))
|
|
(let* ((prefix
|
|
(ebox--render-scroll-window-source source 2))
|
|
(extended
|
|
(ebox--render-scroll-window-source
|
|
source 3 (plist-get prefix :cache))))
|
|
(plist-get (plist-get extended :prefix-delta)
|
|
:rewrite-range))))))
|
|
(should (equal (mapped-range '(0 . 1)) '(0 . 4)))
|
|
(should (equal (mapped-range '(1 . 2)) '(4 . 5))))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-renderer-applies-equal-length-prefix-rewrite ()
|
|
"Equal-length completion should rerender only its declared changed line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 20 :height 1
|
|
:wrap-mode nil))
|
|
(plain-lines '("head" "body" "tail"))
|
|
(source-lines (copy-sequence plain-lines))
|
|
(complete-tail
|
|
(ebox--propertize-underline "tail" "blue"))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer box :test-source 20 4))
|
|
(rendered-line-count 0)
|
|
(original-renderer
|
|
(symbol-function 'ebox--scroll-rendered-content-lines)))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (_source limit &optional _cache)
|
|
(when (> limit 3)
|
|
(setcar (nthcdr 2 source-lines) complete-tail))
|
|
(list :lines source-lines
|
|
:line-count 3
|
|
:line-tail (last source-lines)
|
|
:cache nil
|
|
:complete (> limit 3)
|
|
:content-width-exact-p t
|
|
:rendered-lines nil
|
|
:prefix-delta
|
|
(if (= limit 3)
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines nil)
|
|
(list :exact-p t :base-count 3
|
|
:rewrite-range '(2 . 3)
|
|
:rewrite-lines (list complete-tail)
|
|
:append-lines nil)))))
|
|
((symbol-function 'ebox--scroll-window-formatted-lines)
|
|
(lambda (_box window) (plist-get window :lines)))
|
|
((symbol-function 'ebox--scroll-window-source-lines-exact-p)
|
|
(lambda (&rest _) t))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf rendered-line-count (length (cadr args)))
|
|
(apply original-renderer args)))
|
|
((symbol-function 'equal-including-properties)
|
|
(lambda (&rest _)
|
|
(ert-fail "rendered prefix reuse scanned all old lines"))))
|
|
(let* ((prefix (funcall renderer nil 1 3))
|
|
(_ (setq rendered-line-count 0))
|
|
(completed (funcall renderer prefix 1 4))
|
|
(lines (plist-get completed :rendered-content-lines))
|
|
(line (nth 2 lines))
|
|
(face (get-text-property 0 'face line)))
|
|
(should (plist-get completed :complete))
|
|
(should (= (length lines) 3))
|
|
(should (= rendered-line-count 1))
|
|
(should
|
|
(ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "blue")))))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-projects-wrapper-top-chrome-delta ()
|
|
"A published prefix should reuse a source cache with hidden top chrome."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 20 :height 1
|
|
:wrap-mode nil))
|
|
(wrapper (ebox-create :content "" :width 20 :wrap-mode nil
|
|
:padding-top 2 :margin-top 1))
|
|
(source (list :stack :test-stack :wrapper wrapper))
|
|
stack-lines
|
|
stack-tail
|
|
(stack-count 0)
|
|
(calls 0)
|
|
(rendered-line-count 0)
|
|
(original-renderer
|
|
(symbol-function 'ebox--scroll-rendered-content-lines))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer box source 20 4)))
|
|
(cl-letf (((symbol-function 'ebox--render-stack-window-lines)
|
|
(lambda (_stack limit &optional _cache)
|
|
(cl-incf calls)
|
|
(let ((base stack-count)
|
|
appended-lines)
|
|
(while (< stack-count limit)
|
|
(let ((cell (list (format "row-%d" stack-count))))
|
|
(if stack-tail
|
|
(setcdr stack-tail cell)
|
|
(setq stack-lines cell))
|
|
(setq stack-tail cell)
|
|
(push (car cell) appended-lines)
|
|
(cl-incf stack-count)))
|
|
(setq appended-lines (nreverse appended-lines))
|
|
(list :lines stack-lines
|
|
:line-count stack-count
|
|
:line-tail stack-tail
|
|
:complete nil
|
|
:cache (list :call calls)
|
|
:prefix-delta
|
|
(if (= calls 1)
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines nil)
|
|
(list :exact-p t
|
|
:base-count base
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines appended-lines))))))
|
|
((symbol-function 'ebox--scroll-window-formatted-lines)
|
|
(lambda (_box window) (plist-get window :lines)))
|
|
((symbol-function 'ebox--scroll-window-source-lines-exact-p)
|
|
(lambda (&rest _) t))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (&rest args)
|
|
(cl-incf rendered-line-count (length (cadr args)))
|
|
(apply original-renderer args)))
|
|
((symbol-function 'equal-including-properties)
|
|
(lambda (&rest _)
|
|
(ert-fail "top-chrome reuse scanned the whole prefix"))))
|
|
(let* ((prefix (funcall renderer nil 1 6))
|
|
(prefix-count
|
|
(length (plist-get prefix :content-lines)))
|
|
(_ (setq rendered-line-count 0))
|
|
(extended (funcall renderer prefix 1 7)))
|
|
(should (= calls 2))
|
|
(should (= prefix-count 6))
|
|
(should (= (length (plist-get extended :content-lines)) 7))
|
|
(should (= rendered-line-count 1))))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-exact-extension-scans-only-appended-lines ()
|
|
"A long exact prefix should retain its cons cells and scan only its delta."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 20 :height 1
|
|
:wrap-mode nil))
|
|
(source-lines
|
|
(cl-loop for idx below 1000 collect (format "line-%d" idx)))
|
|
(source-tail (last source-lines))
|
|
(source-count 1000)
|
|
(calls 0)
|
|
scan-sizes
|
|
record-scans
|
|
(original-seq-take (symbol-function 'seq-take))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer box :test-source 20 4)))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (_source limit &optional _cache)
|
|
(cl-incf calls)
|
|
(let ((base source-count)
|
|
appended-lines)
|
|
(while (< source-count limit)
|
|
(let ((cell (list (format "line-%d" source-count))))
|
|
(setcdr source-tail cell)
|
|
(setq source-tail cell)
|
|
(push (car cell) appended-lines)
|
|
(cl-incf source-count)))
|
|
(setq appended-lines (nreverse appended-lines))
|
|
(list :lines source-lines
|
|
:line-count source-count
|
|
:line-tail source-tail
|
|
:cache :same
|
|
:complete nil
|
|
:content-width-exact-p t
|
|
:rendered-lines nil
|
|
:prefix-delta
|
|
(if (= calls 1)
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines nil)
|
|
(list :exact-p t :base-count base
|
|
:rewrite-range nil
|
|
:rewrite-lines nil
|
|
:append-lines appended-lines))))))
|
|
((symbol-function 'ebox--scroll-window-formatted-lines)
|
|
(lambda (_box window) (plist-get window :lines)))
|
|
((symbol-function 'ebox--scroll-window-source-lines-exact-p)
|
|
(lambda (&rest _) t))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (_box lines _region-id _start-index) lines))
|
|
((symbol-function 'seq-take)
|
|
(lambda (sequence count)
|
|
(when record-scans
|
|
(push (length sequence) scan-sizes))
|
|
(funcall original-seq-take sequence count))))
|
|
(let* ((prefix (funcall renderer nil 1 1000))
|
|
(content-head (plist-get prefix :content-lines)))
|
|
(setq record-scans t)
|
|
(let ((extended (funcall renderer prefix 1 1001)))
|
|
(should (eq content-head
|
|
(plist-get extended :content-lines)))
|
|
(should (= (length (plist-get extended :content-lines)) 1001))
|
|
(should scan-sizes)
|
|
(should (<= (apply #'max scan-sizes) 1)))))))
|
|
|
|
(ert-deftest ebox-stack-window-completion-rewrite-uses-delta-payload ()
|
|
"A long leaf completion should not scan its full prefix for one rewrite."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((type 'ebox-test-long-completing-window)
|
|
(leaf (list :ebox-type type))
|
|
(stack (list :ebox-type 'stack :children (list leaf)))
|
|
(leaf-lines
|
|
(cl-loop for idx below 1000 collect (format "line-%d" idx)))
|
|
(leaf-tail (last leaf-lines))
|
|
(complete-tail
|
|
(ebox--propertize-underline "line-999" "blue"))
|
|
(original-length (symbol-function 'length))
|
|
(original-nthcdr (symbol-function 'nthcdr))
|
|
(original-seq-subseq (symbol-function 'seq-subseq))
|
|
record-scans
|
|
(full-length-count 0)
|
|
(full-nthcdr-count 0)
|
|
(full-subseq-count 0))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--register-window-line-renderer
|
|
type
|
|
(lambda (_node limit)
|
|
(if (<= limit 1000)
|
|
(list :lines leaf-lines
|
|
:line-count 1000
|
|
:line-tail leaf-tail
|
|
:complete nil)
|
|
(setcar leaf-tail complete-tail)
|
|
(list :lines leaf-lines
|
|
:line-count 1000
|
|
:line-tail leaf-tail
|
|
:complete t
|
|
:completion-prefix-tail-rewrite-count 1
|
|
:prefix-delta
|
|
(list :exact-p t :base-count 1000
|
|
:rewrite-range '(999 . 1000)
|
|
:rewrite-lines (list complete-tail)
|
|
:append-lines nil)))))
|
|
(let ((prefix (ebox--render-stack-window-lines stack 1000)))
|
|
(cl-letf (((symbol-function 'length)
|
|
(lambda (sequence)
|
|
(when (and record-scans (eq sequence leaf-lines))
|
|
(cl-incf full-length-count))
|
|
(funcall original-length sequence)))
|
|
((symbol-function 'nthcdr)
|
|
(lambda (count sequence)
|
|
(when (and record-scans (eq sequence leaf-lines))
|
|
(cl-incf full-nthcdr-count))
|
|
(funcall original-nthcdr count sequence)))
|
|
((symbol-function 'seq-subseq)
|
|
(lambda (sequence start &optional end)
|
|
(when (and record-scans (eq sequence leaf-lines))
|
|
(cl-incf full-subseq-count))
|
|
(funcall original-seq-subseq sequence start end))))
|
|
(setq record-scans t)
|
|
(let ((completed
|
|
(ebox--render-stack-window-lines
|
|
stack 1001 (plist-get prefix :cache))))
|
|
(setq record-scans nil)
|
|
(should (plist-get completed :complete))
|
|
(should (eq (car (plist-get completed :line-tail))
|
|
complete-tail)))))
|
|
(should (= full-length-count 0))
|
|
(should (= full-nthcdr-count 0))
|
|
(should (= full-subseq-count 0)))
|
|
(remhash type ebox--window-line-renderer-table))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-renderer-failure-keeps-published-pair-atomic ()
|
|
"A failed rendered delta should preserve both published prefix lists."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 20 :height 1
|
|
:wrap-mode nil))
|
|
(source-lines (list "line-0" "line-1" "line-2"))
|
|
(source-tail (last source-lines))
|
|
(calls 0)
|
|
cache-arguments
|
|
fail-render
|
|
(original-renderer
|
|
(symbol-function 'ebox--scroll-rendered-content-lines))
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer
|
|
box :test-source 20 4)))
|
|
(cl-letf
|
|
(((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (_source _limit &optional cache)
|
|
(push cache cache-arguments)
|
|
(cl-incf calls)
|
|
(cond
|
|
((= calls 1)
|
|
(list :lines source-lines
|
|
:line-count 3
|
|
:line-tail source-tail
|
|
:cache :first
|
|
:complete nil
|
|
:content-width-exact-p t
|
|
:rendered-lines source-lines
|
|
:prefix-delta
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil :rewrite-lines nil
|
|
:append-lines nil)))
|
|
((= calls 2)
|
|
(let ((cell (list "line-3")))
|
|
(setcdr source-tail cell)
|
|
(setq source-tail cell))
|
|
(list :lines source-lines
|
|
:line-count 4
|
|
:line-tail source-tail
|
|
:cache :second
|
|
:complete nil
|
|
:content-width-exact-p t
|
|
:rendered-lines source-lines
|
|
:prefix-delta
|
|
'(:exact-p t :base-count 3
|
|
:rewrite-range nil :rewrite-lines nil
|
|
:append-lines ("line-3"))))
|
|
(t
|
|
(let ((fresh (list "line-0" "line-1" "line-2" "line-3")))
|
|
(list :lines fresh
|
|
:line-count 4
|
|
:line-tail (last fresh)
|
|
:cache :recovered
|
|
:complete nil
|
|
:content-width-exact-p t
|
|
:rendered-lines fresh
|
|
:prefix-delta
|
|
'(:exact-p nil :base-count 0
|
|
:rewrite-range nil :rewrite-lines nil
|
|
:append-lines nil)))))))
|
|
((symbol-function 'ebox--scroll-window-formatted-lines)
|
|
(lambda (_box window) (plist-get window :lines)))
|
|
((symbol-function 'ebox--scroll-window-source-lines-exact-p)
|
|
(lambda (&rest _) t))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (&rest args)
|
|
(if (and fail-render (= (nth 3 args) 3))
|
|
(error "injected rendered-prefix failure")
|
|
(apply original-renderer args)))))
|
|
(let* ((prefix (funcall renderer nil 1 3))
|
|
(content-lines (plist-get prefix :content-lines))
|
|
(rendered-lines (plist-get prefix :rendered-content-lines)))
|
|
(puthash :poison t ebox--render-cache-table)
|
|
(setq fail-render t)
|
|
(should-error (funcall renderer prefix 1 4))
|
|
(should (= (length content-lines) 3))
|
|
(should (= (length rendered-lines) 3))
|
|
(should-not (cdr (last content-lines)))
|
|
(should-not (cdr (last rendered-lines)))
|
|
(should (= (hash-table-count ebox--render-cache-table) 0))
|
|
(setq fail-render nil)
|
|
(let ((recovered (funcall renderer prefix 1 4)))
|
|
(should (= (length (plist-get recovered :content-lines)) 4))
|
|
(should (= (length (plist-get recovered
|
|
:rendered-content-lines))
|
|
4))))
|
|
(setq cache-arguments (nreverse cache-arguments))
|
|
(should (equal cache-arguments '(nil :first nil))))))
|
|
|
|
(ert-deftest ebox-stack-window-leaf-lines-uses-registered-producer ()
|
|
"Lazy stack scrolling should use generic window-line producers."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((node (list :ebox-type 'test-window-producer))
|
|
(call-count 0)
|
|
result)
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--register-window-line-renderer
|
|
'test-window-producer
|
|
(lambda (_node limit)
|
|
(cl-incf call-count)
|
|
(list :lines (seq-take '("aa" "bb" "cc") limit)
|
|
:complete nil)))
|
|
(setq result
|
|
(ebox--render-stack-window-leaf-lines node 2 0))
|
|
(should (= call-count 1))
|
|
(should-not (plist-get result :complete))
|
|
(should (equal '("aa" "bb")
|
|
(mapcar #'substring-no-properties
|
|
(plist-get result :lines)))))
|
|
(remhash 'test-window-producer
|
|
ebox--window-line-renderer-table))))
|
|
|
|
(ert-deftest ebox-scroll-prefix-yielding-prewarm-converges-after-zero-line-slice ()
|
|
"A prewarm-only prefix slice should yield once, then publish exact content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((node (list :ebox-type 'test-yielding-prewarm))
|
|
(box (ebox-create :content "" :width 20 :height 1
|
|
:wrap-mode nil :overflow 'scroll))
|
|
(renderer
|
|
(ebox--scroll-window-prefix-renderer
|
|
box (list :stack node) 20 1))
|
|
(prewarm-count 0)
|
|
(render-count 0))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox--register-window-line-prewarmer
|
|
'test-yielding-prewarm
|
|
(lambda (_node _target-width)
|
|
(cl-incf prewarm-count)
|
|
(= prewarm-count 1)))
|
|
(ebox--register-window-line-renderer
|
|
'test-yielding-prewarm
|
|
(lambda (_node _limit)
|
|
(cl-incf render-count)
|
|
(list :lines '("ready") :line-count 1
|
|
:line-tail '("ready") :complete t)))
|
|
(let* ((ebox--scroll-window-yielding-prewarm-p t)
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(first (funcall renderer nil "yield-region" 1))
|
|
(second (funcall renderer first "yield-region" 1))
|
|
(complete (funcall renderer second "yield-region" 2)))
|
|
(should (= prewarm-count 2))
|
|
(should (= render-count 1))
|
|
(should-not (plist-get first :content-lines))
|
|
(should-not (plist-get first :complete))
|
|
(should
|
|
(equal '("ready")
|
|
(mapcar #'substring-no-properties
|
|
(plist-get second :content-lines))))
|
|
(should-not (plist-get second :complete))
|
|
(should (plist-get complete :complete))
|
|
(should
|
|
(equal '("ready")
|
|
(mapcar #'substring-no-properties
|
|
(plist-get complete :content-lines))))))
|
|
(remhash 'test-yielding-prewarm
|
|
ebox--window-line-prewarmer-table)
|
|
(remhash 'test-yielding-prewarm
|
|
ebox--window-line-renderer-table))))
|
|
|
|
(ert-deftest ebox-scroll-stack-window-defers-hidden-leaf-render ()
|
|
"Large stack-backed scroll boxes should render hidden rows only on demand."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport) :padding (1 0)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(hidden-render-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when (equal (ebox-tree-node-id box) "row-30")
|
|
(cl-incf hidden-render-count))
|
|
(funcall original-render-box box))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(should (= hidden-render-count 0))
|
|
(with-current-buffer buffer
|
|
(should (string-match-p "row 00"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should-not (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (ebox--scroll-region-by root-id 31))
|
|
(should (= hidden-render-count 0))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(ebox--scroll-idle-prefetch root-id)
|
|
(should (> hidden-render-count 0))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(delta (- 30 (or (plist-get state :scroll-offset)
|
|
0))))
|
|
(when (> delta 0)
|
|
(should (ebox--scroll-region-by root-id delta))))
|
|
(should (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-incremental-render-covers-wheel-drain ()
|
|
"Incremental lazy scroll renders should cover one smooth wheel drain."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "budget-row-%02d" idx)
|
|
:content ,(format "budget row %02d" idx)
|
|
:height 1))))))
|
|
(limits nil)
|
|
(original-render-source
|
|
(symbol-function 'ebox--render-scroll-window-source)))
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 6)
|
|
(ebox--defer-scroll-content-index t)
|
|
(ebox-wheel-smooth-scroll t)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 8))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (source limit &optional cache)
|
|
(push limit limits)
|
|
(funcall original-render-source source limit cache))))
|
|
(ebox-render layout)))
|
|
(should (equal (nreverse limits) '(23)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-small-step-extends-prefix-only ()
|
|
"Small lazy scroll steps should not materialize the whole source."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(hidden-render-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when (equal (ebox-tree-node-id box) "row-30")
|
|
(cl-incf hidden-render-count))
|
|
(funcall original-render-box box))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(should (= hidden-render-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 1))
|
|
(should (= hidden-render-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 1))
|
|
(should (< (length (plist-get state :content-lines)) 40))
|
|
(should (plist-get state :materialize-content-lines)))
|
|
(should (string-match-p "row 01"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should-not (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-large-cache-miss-schedules-prefetch ()
|
|
"Large lazy scroll misses should schedule prefetch without inline render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "cache-row-%02d" idx)
|
|
:content ,(format "cache row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0)
|
|
(materialize-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(should (= (length (plist-get state :content-lines)) 3))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 30))
|
|
(should (= prefix-count 0))
|
|
(should (= materialize-count 0))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(should (< (length (plist-get (ebox--scroll-get-state root-id)
|
|
:content-lines))
|
|
40))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(should-not (string-match-p "cache row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-cache-miss-renders-bounded-prefix ()
|
|
"Smooth scroll cache misses should keep moving with bounded prefix render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "smooth-cache-row-%02d" idx)
|
|
:content ,(format "smooth cache row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0)
|
|
(materialize-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(should (= (length (plist-get state :content-lines)) 3))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16)))
|
|
(should (= prefix-count 1))
|
|
(should (= materialize-count 0))
|
|
(should (> (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((entry (gethash root-id ebox--smooth-scroll-state-table)))
|
|
(should entry)
|
|
(should (> (or (plist-get entry :pending) 0) 0))
|
|
(should-not (plist-get entry :waiting-prefetch))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-cache-miss-continues-with-bounded-prefix ()
|
|
"Smooth scroll cache misses should extend a bounded prefix without stalling."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "smooth-inline-row-%02d" idx)
|
|
:content ,(format "smooth inline row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0)
|
|
(materialize-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(should (= (length (plist-get state :content-lines)) 3))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16))
|
|
(ebox--smooth-scroll-tick root-id))
|
|
(should (> prefix-count 0))
|
|
(should (= materialize-count 0))
|
|
(should (> (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((entry (gethash root-id ebox--smooth-scroll-state-table)))
|
|
(should entry)
|
|
(should-not (plist-get entry :waiting-prefetch))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-large-pending-uses-base-tick-at-prefix-boundary ()
|
|
"Large smooth pending input should not render a large lazy prefix at once."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 200
|
|
collect
|
|
`(box :id ,(format "smooth-large-row-%03d" idx)
|
|
:content ,(format "smooth large row %03d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0)
|
|
requested-lines)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-target-ticks 8)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(should (= (length (plist-get state :content-lines)) 3))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (state region-id required-lines)
|
|
(cl-incf prefix-count)
|
|
(setq requested-lines required-lines)
|
|
(funcall render-prefix state region-id required-lines)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 1000)))
|
|
(should (= prefix-count 1))
|
|
(should (<= requested-lines 8))
|
|
(should (<= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
ebox-wheel-smooth-scroll-lines-per-tick))
|
|
(let ((entry (gethash root-id ebox--smooth-scroll-state-table)))
|
|
(should entry)
|
|
(should-not (plist-get entry :waiting-prefetch))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-cache-miss-defers-prefetch-while-active ()
|
|
"Idle prefetch should not compete with an active smooth scroll timer."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "smooth-defer-row-%02d" idx)
|
|
:content ,(format "smooth defer row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16)))
|
|
(should (gethash root-id ebox--smooth-scroll-state-table))
|
|
(let ((prefix-after-start prefix-count))
|
|
(should (> prefix-after-start 0))
|
|
(ebox--scroll-idle-prefetch root-id)
|
|
(should (= prefix-count prefix-after-start))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-idle-prefetch root-id)
|
|
(should (> prefix-count prefix-after-start))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-cache-miss-never-enters-prefetch-wait ()
|
|
"Smooth scroll should not pause at a lazy prefix boundary."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "smooth-resume-row-%02d" idx)
|
|
:content ,(format "smooth resume row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16)))
|
|
(should (> prefix-count 0))
|
|
(let ((offset-before (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)))
|
|
(ebox--smooth-scroll-tick root-id)
|
|
(should (> (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
offset-before)))
|
|
(let ((entry (gethash root-id ebox--smooth-scroll-state-table)))
|
|
(should entry)
|
|
(should-not (plist-get entry :waiting-prefetch))
|
|
(should (timerp (plist-get entry :timer)))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-repeated-small-steps-keep-marker-window ()
|
|
"Repeated lazy scroll steps should keep marker windows valid."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(hidden-render-count 0)
|
|
(materialize-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when (equal (ebox-tree-node-id box) "row-30")
|
|
(cl-incf hidden-render-count))
|
|
(funcall original-render-box box))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(cl-loop repeat 8
|
|
do (should (ebox--scroll-region-by root-id 1)))
|
|
(should (= hidden-render-count 0))
|
|
(should (= materialize-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 8))
|
|
(should (< (length (plist-get state :content-lines)) 40))
|
|
(should (plist-get state :materialize-content-lines)))
|
|
(should (string-match-p "row 08"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should-not (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-repeated-small-steps-prefetch-prefix ()
|
|
"Repeated lazy scroll steps should reuse a prefetched lazy prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(cl-loop repeat 8
|
|
do (should (ebox--scroll-region-by root-id 1)))
|
|
(should (= prefix-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 8))
|
|
(should (plist-get state :render-content-prefix))
|
|
(should (<= (+ (plist-get state :scroll-offset)
|
|
(plist-get state :content-height)
|
|
1)
|
|
(length (plist-get state :content-lines)))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-extends-prefix-cache ()
|
|
"Idle prefetch should fill lazy scroll lines before wheel ticks need them."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 16))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(before-lines (length (plist-get state :content-lines)))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state)
|
|
(ebox--scroll-idle-prefetch root-id)
|
|
(let ((prefetched (ebox--scroll-get-state root-id)))
|
|
(should (> (length (plist-get prefetched :content-lines))
|
|
before-lines))
|
|
(should (< (length (plist-get prefetched :content-lines))
|
|
80))
|
|
(should (= prefix-count 1))))
|
|
(with-current-buffer buffer
|
|
(cl-loop repeat 8
|
|
do (should (ebox--scroll-region-by root-id 1))))
|
|
(should (= prefix-count 1)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-reuses-display-measurement-cache ()
|
|
"Lazy prefix slices should retain the initial render's display cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :content ,(format "repeated row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
caches)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(original
|
|
(symbol-function 'ebox--render-scroll-window-source)))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (&rest arguments)
|
|
(push ebox--render-string-pixel-width-cache caches)
|
|
(apply original arguments))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prefix-cache*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(before (length (plist-get state :content-lines))))
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state (1+ before) t)))
|
|
(should (>= (length caches) 2))
|
|
(should (car caches))
|
|
(should (cl-every (lambda (cache) (eq cache (car caches)))
|
|
caches)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-covers-visible-window ()
|
|
"Idle prefetch should warm beyond the current visible scroll window."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((region-id "scroll")
|
|
requested-lines)
|
|
(puthash
|
|
region-id
|
|
(list :scroll-offset 0
|
|
:content-height 10
|
|
:content-lines (make-list 3 "")
|
|
:render-content-prefix
|
|
(lambda (_state _region-id target-lines)
|
|
(setq requested-lines target-lines)
|
|
(list :content-lines (make-list target-lines "")
|
|
:content-height 10
|
|
:complete nil)))
|
|
ebox--scroll-global-state)
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 5)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
(should requested-lines)
|
|
(should (>= requested-lines 15))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-is-sliced ()
|
|
"Idle prefetch should extend lazy prefixes in bounded foreground slices."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((region-id "scroll")
|
|
requested-lines)
|
|
(puthash
|
|
region-id
|
|
(list :scroll-offset 0
|
|
:content-height 10
|
|
:content-lines (make-list 3 "")
|
|
:render-content-prefix
|
|
(lambda (_state _region-id target-lines)
|
|
(setq requested-lines target-lines)
|
|
(list :content-lines (make-list target-lines "")
|
|
:content-height 10
|
|
:complete nil)))
|
|
ebox--scroll-global-state)
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 64)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox--scroll-allow-noninteractive-prefetch t))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
;; Three cached lines plus the configured four-line slice. Completion is
|
|
;; probed on a later turn instead of exceeding this callback's budget.
|
|
(should (= requested-lines 7))
|
|
(should (gethash region-id ebox--scroll-idle-prefetch-timers))
|
|
(ebox--scroll-cancel-idle-prefetch region-id)))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-bounds-atomic-item-work ()
|
|
"Item-heavy buffers should request only one new line per idle render turn."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((region-id "scroll")
|
|
buffer
|
|
requested-lines)
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-item-prefetch*")
|
|
(ebox-build
|
|
'(flex :width (240)
|
|
(item (box :content "atomic" :width (120)))))))
|
|
(puthash
|
|
region-id
|
|
(list :buffer buffer
|
|
:scroll-offset 0
|
|
:content-height 10
|
|
:content-lines (make-list 3 "")
|
|
:render-content-prefix
|
|
(lambda (_state _region-id target-lines)
|
|
(setq requested-lines target-lines)
|
|
(list :content-lines (make-list target-lines "")
|
|
:content-height 10
|
|
:complete nil)))
|
|
ebox--scroll-global-state)
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 64)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 16)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 13)
|
|
(ebox--scroll-allow-noninteractive-prefetch t))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
;; Three cached lines + one atomic requested line. The completion
|
|
;; probe must not silently double a latency-sensitive slice.
|
|
(should (= requested-lines 4)))
|
|
(ebox--scroll-cancel-idle-prefetch region-id)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-bounds-large-runtime-work ()
|
|
"Large runtimes should request only one new line per idle render turn."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((region-id "scroll")
|
|
(buffer (generate-new-buffer " *ebox-large-prefetch*"))
|
|
(node-table (make-hash-table :test 'equal))
|
|
(selector-type-table (make-hash-table :test 'eq))
|
|
requested-lines)
|
|
(unwind-protect
|
|
(progn
|
|
(dotimes (index 512)
|
|
(puthash index t node-table))
|
|
(puthash buffer
|
|
(list :node-table node-table
|
|
:selector-type-table selector-type-table)
|
|
ebox--buffer-render-state-table)
|
|
(puthash
|
|
region-id
|
|
(list :buffer buffer
|
|
:scroll-offset 0
|
|
:content-height 10
|
|
:content-lines (make-list 3 "")
|
|
:render-content-prefix
|
|
(lambda (_state _region-id target-lines)
|
|
(setq requested-lines target-lines)
|
|
(list :content-lines (make-list target-lines "")
|
|
:content-height 10
|
|
:complete nil)))
|
|
ebox--scroll-global-state)
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 64)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 16)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 13)
|
|
(ebox--scroll-allow-noninteractive-prefetch t))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
;; Three cached lines + one atomic requested line. The completion
|
|
;; probe must not silently double a latency-sensitive slice.
|
|
(should (= requested-lines 4)))
|
|
(ebox--scroll-cancel-idle-prefetch region-id)
|
|
(remhash buffer ebox--buffer-render-state-table)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-defers-visible-render-gc ()
|
|
"Visible idle prefix slices should not combine atomic rendering with GC."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((region-id "visible-prefix-gc")
|
|
(buffer (generate-new-buffer " *ebox-visible-prefix-gc*"))
|
|
(state
|
|
(list :buffer buffer
|
|
:scroll-offset 0
|
|
:content-height 1
|
|
:content-lines '("row 0")
|
|
:render-content-prefix
|
|
(lambda (input-state _region-id target-lines &optional _exact)
|
|
(setq input-state
|
|
(plist-put input-state :content-lines
|
|
(make-list target-lines "row")))
|
|
(plist-put input-state :content-lines-complete-p t))))
|
|
(gc-enters 0)
|
|
(gc-restores 0))
|
|
(unwind-protect
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 1)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 1)
|
|
(ebox--scroll-allow-noninteractive-prefetch t))
|
|
(puthash region-id state ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'get-buffer-window-list)
|
|
(lambda (&rest _) (list (selected-window))))
|
|
((symbol-function 'display-graphic-p)
|
|
(lambda (&rest _) t))
|
|
((symbol-function 'ebox--deferred-render-gc-enter)
|
|
(lambda () (cl-incf gc-enters)))
|
|
((symbol-function
|
|
'ebox--deferred-render-gc-schedule-restore)
|
|
(lambda () (cl-incf gc-restores)))
|
|
((symbol-function 'ebox--schedule-buffer-runtime-prewarm)
|
|
(lambda (&rest _) nil)))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
(should (= gc-enters 1))
|
|
(should (= gc-restores 1)))
|
|
(ebox--scroll-cancel-idle-prefetch region-id)
|
|
(remhash region-id ebox--scroll-global-state)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefetch-yields-to-input-between-slices ()
|
|
"Background prefix work should use idle time and rearm beyond current idle."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((region-id "scroll")
|
|
scheduled-delay
|
|
scheduled-function)
|
|
(puthash
|
|
region-id
|
|
(list :content-height 2
|
|
:content-lines '("row 0")
|
|
:render-content-prefix
|
|
(lambda (_state _region-id target-lines)
|
|
(list :content-lines (make-list target-lines "row")
|
|
:content-height 2
|
|
:complete nil)))
|
|
ebox--scroll-global-state)
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 8)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 1)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 0.15)
|
|
(ebox--scroll-allow-noninteractive-prefetch t))
|
|
(cl-letf (((symbol-function 'current-idle-time)
|
|
(lambda () (seconds-to-time 0.4)))
|
|
((symbol-function 'run-at-time)
|
|
(lambda (&rest _)
|
|
(ert-fail "Background scroll work must yield to input")))
|
|
((symbol-function 'run-with-idle-timer)
|
|
(lambda (delay _repeat function &rest _arguments)
|
|
(setq scheduled-delay delay
|
|
scheduled-function function)
|
|
'scheduled-scroll-timer)))
|
|
(ebox--scroll-idle-prefetch region-id)))
|
|
(should (< (abs (- scheduled-delay 0.55)) 0.000001))
|
|
(should (eq scheduled-function #'ebox--scroll-idle-prefetch))
|
|
(should (eq (gethash region-id ebox--scroll-idle-prefetch-timers)
|
|
'scheduled-scroll-timer))
|
|
(remhash region-id ebox--scroll-idle-prefetch-timers)))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-rearms-after-scroll ()
|
|
"Successful lazy scroll steps should schedule the next generic prefetch."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 1)))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-pauses-during-smooth-scroll ()
|
|
"Smooth scroll should prefetch only after the active animation stops."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-target-ticks 4)
|
|
(ebox-wheel-smooth-scroll-interval 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16)))
|
|
(should (gethash root-id ebox--smooth-scroll-state-table))
|
|
(should-not (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-idle-prefetch-pauses-for-resize-animation ()
|
|
"A resize animation should own idle time until its final frame settles."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((buffer (generate-new-buffer " *ebox-resize-prefetch*"))
|
|
(region-id "scroll")
|
|
scheduled)
|
|
(unwind-protect
|
|
(progn
|
|
(puthash
|
|
region-id
|
|
(list :buffer buffer
|
|
:content-height 2
|
|
:content-lines '("row 0")
|
|
:render-content-prefix #'ignore
|
|
:content-lines-complete-p nil)
|
|
ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'run-with-idle-timer)
|
|
(lambda (&rest _)
|
|
(setq scheduled 'scroll-timer))))
|
|
(ebox--scroll-inhibit-idle-prefetch-for-buffer buffer)
|
|
(ebox--scroll-schedule-idle-prefetch region-id 0)
|
|
(should-not scheduled)
|
|
(ebox--scroll-resume-idle-prefetch-for-buffer buffer)
|
|
(should (eq scheduled 'scroll-timer))))
|
|
(remhash region-id ebox--scroll-global-state)
|
|
(remhash buffer ebox--scroll-idle-prefetch-inhibited-buffers)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-shares-display-cache-scope ()
|
|
"Each lazy prefix generation should share one display cache scope."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 20
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(validate-count 0)
|
|
(original-validate (symbol-function 'ebox--validate-display-cache)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 1)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (length (plist-get state :content-lines)) 2))
|
|
(should (plist-get state :render-content-prefix)))
|
|
(cl-letf (((symbol-function 'ebox--validate-display-cache)
|
|
(lambda (&rest args)
|
|
(cl-incf validate-count)
|
|
(apply original-validate args))))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 2)))
|
|
(should (= validate-count 1))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers))
|
|
(ebox--scroll-idle-prefetch root-id))
|
|
(should (= validate-count 2)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-reuses-exact-source-lines ()
|
|
"Exact-width lazy scroll source lines should not be reformatted."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 20
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(format-count 0)
|
|
(original-format (symbol-function 'ebox--format-content-string)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 1)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(cl-letf (((symbol-function 'ebox--format-content-string)
|
|
(lambda (&rest args)
|
|
(when (equal (and (listp (car args))
|
|
(ebox-get (car args) :id))
|
|
"root")
|
|
(cl-incf format-count))
|
|
(apply original-format args))))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 2))))
|
|
(should (= format-count 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(defun ebox-test--complete-lazy-scroll-batch-layout ()
|
|
"Return a complete five-row lazy scroll cache fixture."
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(box :content "row 00" :height 1)
|
|
(box :id "target" :content "target row" :height 1
|
|
:color "#111111")
|
|
(box :id "second-target" :content "second target row" :height 1
|
|
:color "#111111")
|
|
(box :content "row 03" :height 1)
|
|
(box :content "row 04" :height 1)))))
|
|
|
|
(defun ebox-test--text-has-foreground-p (string text color)
|
|
"Return non-nil when TEXT in STRING has foreground COLOR."
|
|
(let ((pos (string-match (regexp-quote text)
|
|
(substring-no-properties string))))
|
|
(and pos
|
|
(ebox-test--face-has-key-value-p
|
|
(get-text-property pos 'face string)
|
|
:foreground color))))
|
|
|
|
(defun ebox-test--lines-have-text-foreground-p (lines text color)
|
|
"Return non-nil when one of LINES paints TEXT with foreground COLOR."
|
|
(cl-some (lambda (line)
|
|
(ebox-test--text-has-foreground-p line text color))
|
|
lines))
|
|
|
|
(defun ebox-test--lines-have-text-p (lines text)
|
|
"Return non-nil when one of LINES contains TEXT."
|
|
(and (cl-some (lambda (line)
|
|
(string-match-p (regexp-quote text)
|
|
(substring-no-properties line)))
|
|
lines)
|
|
t))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-extension-keeps-runtime-updates ()
|
|
"Extending a lazy prefix should not replay producer caches from before an update."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 12
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll nil))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#row-01"))
|
|
(state (ebox-scroll-state root-id)))
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
(ebox-region-update target-id :content "updated row 01")
|
|
(setq state (ebox-scroll-state root-id))
|
|
(should (ebox-test--lines-have-text-p
|
|
(plist-get state :content-lines) "updated row 01"))
|
|
(setq state
|
|
(ebox--scroll-state-ensure-prefix-lines root-id state 8))
|
|
(should (ebox-test--lines-have-text-p
|
|
(plist-get state :content-lines) "updated row 01"))))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-does-not-publish-unflushed-batch ()
|
|
"Extending a lazy prefix should preserve committed content until batch flush."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 12
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-wheel-smooth-scroll nil))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#row-01"))
|
|
(initial-revision
|
|
(plist-get (ebox--buffer-render-state buffer)
|
|
:runtime-revision)))
|
|
(ebox-test--set-buffer-update-report
|
|
buffer '(:strategy span-patch))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update target-id :content "unflushed row 01")
|
|
(should (= (plist-get (ebox--buffer-render-state buffer)
|
|
:runtime-revision)
|
|
initial-revision))
|
|
(let ((state
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id (ebox-scroll-state root-id) 8)))
|
|
(should (ebox-test--lines-have-text-p
|
|
(plist-get state :content-lines) "row 01"))
|
|
(should-not (ebox-test--lines-have-text-p
|
|
(plist-get state :content-lines)
|
|
"unflushed row 01")))
|
|
(should (= 2 (ebox--scroll-region-by root-id 2)))
|
|
(should (= -2 (ebox--scroll-region-by root-id -2)))
|
|
(should (string-match-p "row 01"
|
|
(substring-no-properties (buffer-string))))
|
|
(should-not (string-match-p
|
|
"unflushed row 01"
|
|
(substring-no-properties (buffer-string))))
|
|
(ebox-incremental-flush buffer)
|
|
(should (= (plist-get (ebox--buffer-render-state buffer)
|
|
:runtime-revision)
|
|
(1+ initial-revision)))
|
|
(should (ebox-test--lines-have-text-p
|
|
(plist-get (ebox-scroll-state root-id) :content-lines)
|
|
"unflushed row 01"))
|
|
(should (string-match-p
|
|
"unflushed row 01"
|
|
(substring-no-properties (buffer-string))))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-synchronizes-complete-scroll-paint-cache ()
|
|
"A paint-only batch should not replay stale complete scroll cache faces."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--complete-lazy-scroll-batch-layout))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target")))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:content-lines-complete-p))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update target-id :color "#DC2626")
|
|
(ebox-incremental-flush buffer)
|
|
(let* ((runtime (gethash target-id ebox--region-box-table))
|
|
(visible-before
|
|
(ebox-test--text-has-foreground-p
|
|
(buffer-string) "target row" "#DC2626"))
|
|
(state (ebox-scroll-state root-id))
|
|
(content-cache
|
|
(ebox-test--lines-have-text-foreground-p
|
|
(plist-get state :content-lines)
|
|
"target row" "#DC2626"))
|
|
(rendered-cache
|
|
(ebox-test--lines-have-text-foreground-p
|
|
(plist-get state :rendered-content-lines)
|
|
"target row" "#DC2626")))
|
|
(should (= 2 (ebox--scroll-region-by root-id 2)))
|
|
(should (= -2 (ebox--scroll-region-by root-id -2)))
|
|
(should
|
|
(equal
|
|
(list (ebox-get runtime :color)
|
|
visible-before
|
|
content-cache
|
|
rendered-cache
|
|
(ebox-test--text-has-foreground-p
|
|
(buffer-string) "target row" "#DC2626"))
|
|
'("#DC2626" t t t t))))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-synchronizes-mixed-scroll-cache-sources ()
|
|
"A mixed batch should synchronize each final runtime node exactly once."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--complete-lazy-scroll-batch-layout))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(sync-count 0)
|
|
(original-sync
|
|
(symbol-function 'ebox--sync-scroll-state-lines-for-node)))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:content-lines-complete-p))
|
|
(cl-letf (((symbol-function 'ebox--sync-scroll-state-lines-for-node)
|
|
(lambda (&rest args)
|
|
(cl-incf sync-count)
|
|
(apply original-sync args))))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update target-id :content "batched target row")
|
|
(ebox-region-update target-id :color "#2563EB")
|
|
(ebox-incremental-flush buffer))
|
|
(let* ((runtime (gethash target-id ebox--region-box-table))
|
|
(visible-before (buffer-string))
|
|
(state (ebox-scroll-state root-id))
|
|
(content-lines (plist-get state :content-lines))
|
|
(rendered-lines (plist-get state :rendered-content-lines)))
|
|
(should (= 2 (ebox--scroll-region-by root-id 2)))
|
|
(should (= -2 (ebox--scroll-region-by root-id -2)))
|
|
(let ((visible-after (buffer-string)))
|
|
(should
|
|
(equal
|
|
(list (ebox-get runtime :content)
|
|
(ebox-get runtime :color)
|
|
(and (string-match-p
|
|
"batched target row"
|
|
(substring-no-properties visible-before))
|
|
t)
|
|
(ebox-test--text-has-foreground-p
|
|
visible-before "batched target row" "#2563EB")
|
|
(ebox-test--lines-have-text-p
|
|
content-lines "batched target row")
|
|
(ebox-test--lines-have-text-foreground-p
|
|
content-lines "batched target row" "#2563EB")
|
|
(ebox-test--lines-have-text-p
|
|
rendered-lines "batched target row")
|
|
(ebox-test--lines-have-text-foreground-p
|
|
rendered-lines "batched target row" "#2563EB")
|
|
(and (string-match-p
|
|
"batched target row"
|
|
(substring-no-properties visible-after))
|
|
t)
|
|
(ebox-test--text-has-foreground-p
|
|
visible-after "batched target row" "#2563EB")
|
|
sync-count)
|
|
'("batched target row" "#2563EB"
|
|
t t t t t t t t 1)))))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-synchronizes-distinct-scroll-cache-nodes ()
|
|
"A batch flush should synchronize each final node from any current buffer."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--complete-lazy-scroll-batch-layout))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(second-id
|
|
(ebox-test--selector-region-id buffer "#second-target"))
|
|
calls
|
|
(original-sync
|
|
(symbol-function 'ebox--sync-scroll-state-lines-for-node)))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:content-lines-complete-p))
|
|
(cl-letf (((symbol-function 'ebox--sync-scroll-state-lines-for-node)
|
|
(lambda (sync-buffer region-id node changed-keys report)
|
|
(push (list sync-buffer region-id
|
|
(ebox-tree-node-id node)
|
|
changed-keys)
|
|
calls)
|
|
(funcall original-sync sync-buffer region-id node
|
|
changed-keys report))))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(with-temp-buffer
|
|
(ebox-region-update target-id :color "#DC2626")
|
|
(ebox-region-update second-id :color "#2563EB")
|
|
(ebox-incremental-flush buffer)))
|
|
(should (= (length calls) 2))
|
|
(should (cl-every (lambda (call) (eq (car call) buffer)) calls))
|
|
(should
|
|
(equal (sort (mapcar (lambda (call) (nth 2 call)) calls)
|
|
#'string-lessp)
|
|
'("second-target" "target")))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(content-lines (plist-get state :content-lines))
|
|
(rendered-lines (plist-get state :rendered-content-lines)))
|
|
(should (ebox-test--lines-have-text-foreground-p
|
|
content-lines "target row" "#DC2626"))
|
|
(should (ebox-test--lines-have-text-foreground-p
|
|
rendered-lines "target row" "#DC2626"))
|
|
(should (ebox-test--lines-have-text-foreground-p
|
|
content-lines "second target row" "#2563EB"))
|
|
(should (ebox-test--lines-have-text-foreground-p
|
|
rendered-lines "second target row" "#2563EB")))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-scroll-sync-hook-skips-unsuccessful-flushes ()
|
|
"Empty, no-op, and failed batch flushes should not publish sync work."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--complete-lazy-scroll-batch-layout)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(hook-count 0)
|
|
(ebox-incremental--after-successful-batch-flush-hook
|
|
(list (lambda (&rest _args) (cl-incf hook-count)))))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(should (eq (plist-get (ebox-incremental-flush buffer) :strategy)
|
|
'no-op))
|
|
(should (= hook-count 0))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(should (ebox-incremental-record-region-change
|
|
buffer target-id 'paint '(:color)))
|
|
(cl-letf (((symbol-function 'ebox--execute-constraint-change)
|
|
(lambda (&rest _args)
|
|
(ebox--update-report target-id 'no-op))))
|
|
(should (eq (plist-get (ebox-incremental-flush buffer) :strategy)
|
|
'no-op)))
|
|
(should (= hook-count 0))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(should (ebox-incremental-record-region-change
|
|
buffer target-id 'paint '(:color)))
|
|
(cl-letf (((symbol-function 'ebox--execute-constraint-change)
|
|
(lambda (&rest _args) (error "expected flush failure"))))
|
|
(should-error (ebox-incremental-flush buffer)
|
|
:type 'error))
|
|
(should (= hook-count 0))))))
|
|
|
|
(ert-deftest ebox-explicit-batch-flush-retries-after-quit ()
|
|
"A quit during a batch flush must keep the recorded changes retryable."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Batch retry" :color "black"))
|
|
(id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(let ((buffer (current-buffer)))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(ebox-region-update id :color "red")
|
|
(should (= (ebox-incremental-pending-count buffer) 1))
|
|
(cl-letf (((symbol-function 'ebox--execute-constraint-change)
|
|
(lambda (&rest _) (signal 'quit nil))))
|
|
(condition-case nil
|
|
(ebox-incremental-flush buffer)
|
|
(quit nil)))
|
|
;; The interrupted flush published nothing, so the batch must
|
|
;; still be active with the recorded change pending.
|
|
(should (ebox-incremental-batching-p buffer))
|
|
(should (= (ebox-incremental-pending-count buffer) 1))
|
|
;; The retry must execute the preserved change instead of no-op.
|
|
(let ((report (ebox-incremental-flush buffer)))
|
|
(should report)
|
|
(should-not (eq (plist-get report :strategy) 'no-op)))
|
|
(should-not (ebox-incremental-batching-p buffer))
|
|
(should (= (ebox-incremental-pending-count buffer) 0)))
|
|
(goto-char (point-min))
|
|
(search-forward "Batch retry")
|
|
(let ((face (get-text-property (- (point) (length "Batch retry"))
|
|
'face)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "red")))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-paint-sync-does-not-rerender-node ()
|
|
"Paint updates inside scroll caches should patch cached faces without render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 32
|
|
collect
|
|
`(box :id ,(cond
|
|
((= idx 1) "target")
|
|
((= idx 31) "hidden-target")
|
|
(t (format "row-%02d" idx)))
|
|
:content ,(if (= idx 1)
|
|
"target row"
|
|
(format "row %02d" idx))
|
|
:height 1
|
|
:color "#111111"))))))
|
|
(buffer nil)
|
|
target-id
|
|
root-id
|
|
(render-count 0)
|
|
(index-build-count 0)
|
|
(fallback-count 0)
|
|
(face-in-lines-p
|
|
(lambda (lines color)
|
|
(cl-some
|
|
(lambda (line)
|
|
(let* ((plain (substring-no-properties line))
|
|
(pos (string-match "target row" plain)))
|
|
(and pos
|
|
(ebox-test--face-has-key-value-p
|
|
(get-text-property pos 'face line)
|
|
:foreground color))))
|
|
lines)))
|
|
(original-render (symbol-function 'ebox-render))
|
|
(original-index-build
|
|
(symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(original-fallback
|
|
(symbol-function 'ebox--sync-scroll-state-lines-for-node-fallback)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 3)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should
|
|
(plist-get state :rendered-region-line-span-index-deferred))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest args)
|
|
(cl-incf render-count)
|
|
(apply original-render args)))
|
|
((symbol-function
|
|
'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf index-build-count)
|
|
(apply original-index-build args)))
|
|
((symbol-function
|
|
'ebox--sync-scroll-state-lines-for-node-fallback)
|
|
(lambda (&rest args)
|
|
(cl-incf fallback-count)
|
|
(apply original-fallback args))))
|
|
(ebox-region-update target-id :color "#DC2626")
|
|
(setq state (ebox-scroll-state root-id))
|
|
(should
|
|
(plist-get state :rendered-region-line-span-index-deferred))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (plist-get report :scroll-state-paint-sync))
|
|
(should (plist-get report :scroll-state-index-preserved)))
|
|
(let ((lines (plist-get state :content-lines)))
|
|
(should-not
|
|
(cl-some
|
|
(lambda (line)
|
|
(string-match-p "row 31"
|
|
(substring-no-properties line)))
|
|
lines))
|
|
(dolist (key '(:content-lines :rendered-content-lines))
|
|
(should (funcall face-in-lines-p
|
|
(plist-get state key) "#DC2626"))))
|
|
(ebox-region-update
|
|
target-id :border-left-color "#F59E0B")
|
|
(should (= fallback-count 0))
|
|
(ebox-selector-update-buffer
|
|
buffer "#hidden-target" :color "#2563EB")
|
|
(setq state (ebox-scroll-state root-id))
|
|
(should (plist-get state :lazy-scroll-prefix-dirty))
|
|
(ebox-region-update target-id :color "#16A34A")
|
|
(setq state (ebox-scroll-state root-id))
|
|
(should (plist-get state :lazy-scroll-prefix-dirty))
|
|
(should
|
|
(plist-get state :rendered-region-line-span-index-deferred))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(dolist (key '(:content-lines :rendered-content-lines))
|
|
(should (funcall face-in-lines-p
|
|
(plist-get state key) "#16A34A")))
|
|
(should (= fallback-count 0))
|
|
(should (= render-count 0))
|
|
(should (= index-build-count 0)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-appends-rendered-content-lines ()
|
|
"Lazy prefix extension should render only newly appended visible lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "rendered-tail-row-%02d" idx)
|
|
:content ,(format "rendered tail row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
rendered-line-counts
|
|
(original-rendered-lines
|
|
(symbol-function 'ebox--scroll-rendered-content-lines)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(cl-letf (((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (&rest args)
|
|
(push (list (length (cadr args))
|
|
(nth 3 args))
|
|
rendered-line-counts)
|
|
(apply original-rendered-lines args))))
|
|
(dotimes (_ 2)
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(current-lines (length (plist-get state
|
|
:content-lines))))
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state (+ current-lines 4)))))
|
|
(should
|
|
(cl-some (lambda (entry)
|
|
(and (<= (car entry) 5)
|
|
(integerp (cadr entry))
|
|
(> (cadr entry) 0)))
|
|
rendered-line-counts))
|
|
(dolist (entry rendered-line-counts)
|
|
(should (<= (car entry) 8))))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-avoids-full-prefix-joins ()
|
|
"Lazy prefix extension should not join the full cached prefix string."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "join-row-%02d" idx)
|
|
:content ,(format "join row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
join-sizes
|
|
(original-join (symbol-function 'ebox-lines-join)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-wheel-scroll-step 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(cl-letf (((symbol-function 'ebox-lines-join)
|
|
(lambda (&rest args)
|
|
(push (length (car args)) join-sizes)
|
|
(apply original-join args))))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(current-lines (length (plist-get state
|
|
:content-lines))))
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state (+ current-lines 4))))
|
|
(should-not (cl-some (lambda (size) (> size 5)) join-sizes)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-reuses-signature-cache ()
|
|
"Lazy prefix extension should not recompute node signatures each slice."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll)))
|
|
(source-node
|
|
(ebox-build
|
|
`(column :width (viewport)
|
|
(flex :id "signature-flex" :width (viewport)
|
|
:flex-flow (row wrap)
|
|
:row-gap 1 :column-gap (8)
|
|
:padding (0 (12)) :border "#D97757"
|
|
:border-top-p nil
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :content ,(format "signature %02d" idx)
|
|
:width (100) :height 2))))))
|
|
(source (list :stack source-node))
|
|
(renderer (ebox--scroll-window-prefix-renderer
|
|
layout source 240 2 nil nil))
|
|
signature-caches
|
|
(original-node-signature
|
|
(symbol-function 'ebox--render-cache-node-signature)))
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox--render-cache-table (make-hash-table :test 'equal))
|
|
(ebox--render-cache-signature-cache nil))
|
|
(cl-letf (((symbol-function 'ebox--render-cache-node-signature)
|
|
(lambda (node)
|
|
(when (and (listp node)
|
|
ebox--render-cache-signature-cache)
|
|
(push ebox--render-cache-signature-cache
|
|
signature-caches))
|
|
(funcall original-node-signature node))))
|
|
(funcall renderer (list :rendered-content-lines nil)
|
|
"signature-region" 4)
|
|
(funcall renderer (list :rendered-content-lines nil)
|
|
"signature-region" 8))
|
|
(should (> (length signature-caches) 1))
|
|
(let ((first-cache (car signature-caches)))
|
|
(dolist (cache (cdr signature-caches))
|
|
(should (eq cache first-cache)))))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-appends-generic-wrapper-lines ()
|
|
"Lazy prefix extension should append wrapper chrome without rerendering it."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport) :box-sizing border-box
|
|
:padding (1 (8)) :border "#555555"
|
|
:bgcolor "#FAFAFA" :color "#111111"
|
|
,@(cl-loop for idx below 20
|
|
collect
|
|
`(box :id ,(format "wrapped-row-%02d" idx)
|
|
:content ,(format "wrapped row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(wrapper-render-count 0)
|
|
(original-render (symbol-function 'ebox-render)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 1)
|
|
(ebox-wheel-scroll-step 0)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 3)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (length (plist-get state :content-lines)) 2))
|
|
(should (plist-get state :render-content-prefix)))
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (node)
|
|
(when (and (listp node)
|
|
(eq (plist-get node :ebox-type) 'box)
|
|
(plist-get node
|
|
:ebox-content-width-exact-p)
|
|
(null (plist-get node
|
|
:ebox-content-node)))
|
|
(cl-incf wrapper-render-count))
|
|
(funcall original-render node))))
|
|
(ebox--scroll-idle-prefetch root-id))
|
|
(should (= wrapper-render-count 0))
|
|
(should (> (length (plist-get (ebox--scroll-get-state root-id)
|
|
:content-lines))
|
|
2))))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-first-smooth-wheel-uses-prefetched-prefix ()
|
|
"The first smooth wheel input should only replace visible lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(should (<= (+ (plist-get state :content-height)
|
|
ebox-wheel-scroll-step)
|
|
(length (plist-get state :content-lines))))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16))
|
|
(while (gethash root-id ebox--smooth-scroll-state-table)
|
|
(ebox--smooth-scroll-tick root-id))
|
|
(should (string-match-p "row 16"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(should (= prefix-count 0))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
16)))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-incremental-smooth-wheel-uses-prefetched-prefix ()
|
|
"Post-resize lazy scroll should not extend prefixes inside smooth ticks."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "resize-row-%02d" idx)
|
|
:content ,(format "resize row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(prefix-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 6)
|
|
(ebox--defer-scroll-content-index t)
|
|
(ebox-wheel-smooth-scroll t)
|
|
(ebox-wheel-scroll-step 16)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 4)
|
|
(ebox-wheel-smooth-scroll-interval 60.0)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox--scroll-allow-noninteractive-prefetch nil)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 8))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix)))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (&rest args)
|
|
(cl-incf prefix-count)
|
|
(apply render-prefix args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 16))
|
|
(while (gethash root-id ebox--smooth-scroll-state-table)
|
|
(ebox--smooth-scroll-tick root-id))
|
|
(should (string-match-p "resize row 16"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(should (= prefix-count 0))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
16)))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-schedules-urgent-scroll-prefetch ()
|
|
"Viewport rerender should warm lazy scroll prefixes before fast scrolling."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 80
|
|
collect
|
|
`(box :id ,(format "urgent-row-%02d" idx)
|
|
:content ,(format "urgent row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
delays
|
|
(original-schedule
|
|
(symbol-function 'ebox--scroll-schedule-idle-prefetch)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-scroll-lazy-idle-prefetch-delay 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(cl-letf (((symbol-function 'ebox--scroll-schedule-idle-prefetch)
|
|
(lambda (region-id &optional delay)
|
|
(push delay delays)
|
|
(funcall original-schedule region-id delay))))
|
|
(ebox-rerender-buffer-with-context buffer 300 4))
|
|
(should (member 0 delays)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-smooth-scroll-defers-gc-during-animation ()
|
|
"Smooth scrolling should keep render GC settings until the animation stops."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(old-threshold gc-cons-threshold)
|
|
(old-percentage gc-cons-percentage)
|
|
(target-threshold 2000))
|
|
(unwind-protect
|
|
(let ((gc-cons-threshold 1000)
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-render-gc-cons-threshold target-threshold)
|
|
(ebox-deferred-render-gc-cons-threshold target-threshold)
|
|
(ebox-render-gc-cons-percentage 0.9)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
(should (ebox--smooth-scroll-region-by root-id 4)))
|
|
(should (>= gc-cons-threshold target-threshold))
|
|
(should (>= gc-cons-percentage 0.9))
|
|
(should ebox--deferred-render-gc-state)
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(should (timerp ebox--deferred-render-gc-timer)))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(when (timerp ebox--deferred-render-gc-timer)
|
|
(cancel-timer ebox--deferred-render-gc-timer))
|
|
(setq ebox--deferred-render-gc-timer nil)
|
|
(setq ebox--deferred-render-gc-state nil)
|
|
(setq gc-cons-threshold old-threshold)
|
|
(setq gc-cons-percentage old-percentage)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(defun ebox-test--visible-foreground (face)
|
|
"Return the highest-priority :foreground carried by FACE."
|
|
(cond
|
|
((null face) nil)
|
|
((and (listp face) (keywordp (car face)))
|
|
(plist-get face :foreground))
|
|
((listp face)
|
|
(cl-some #'ebox-test--visible-foreground face))
|
|
(t nil)))
|
|
|
|
(ert-deftest ebox-ancestor-paint-patch-preserves-descendant-own-paint ()
|
|
"A parent paint-patch must not clobber a child's own declared paint."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id parent :width (120) :color "black"
|
|
(column :width (120)
|
|
(box :id child :content "Child" :width (120)
|
|
:color "blue")
|
|
(box :id plain :content "Plain" :width (120)))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(parent-id (ebox-test--selector-region-id buffer "#parent")))
|
|
(ebox-region-update parent-id :color "red")
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'paint-patch))
|
|
(goto-char (point-min))
|
|
(search-forward "Child")
|
|
;; The child's own declaration stays the highest-priority paint.
|
|
(should (equal (ebox-test--visible-foreground
|
|
(get-text-property (match-beginning 0) 'face))
|
|
"blue"))
|
|
(goto-char (point-min))
|
|
(search-forward "Plain")
|
|
;; A non-declaring sibling inherits the new parent paint.
|
|
(should (equal (ebox-test--visible-foreground
|
|
(get-text-property (match-beginning 0) 'face))
|
|
"red"))))))
|
|
|
|
(ert-deftest ebox-intrinsic-measurement-preserves-scroll-state ()
|
|
"Intrinsic measurement must not reset live scroll offsets or state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 20
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
(should (ebox--scroll-region-by root-id 5 48)))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
5))
|
|
(let ((box (gethash root-id ebox--region-box-table)))
|
|
(should box)
|
|
;; Flex ancestors measure live subtrees with the intrinsic
|
|
;; flag bound; the measurement render must be side-effect
|
|
;; free for the published runtime.
|
|
(let ((ebox--intrinsic-layout-measurement t))
|
|
(ebox-render box))
|
|
(should (equal (ebox-get box :scroll-offset) 5)))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should state)
|
|
(should (= (plist-get state :scroll-offset) 5))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-viewport-rerender-retries-after-quit ()
|
|
"A quit during viewport reflow must not wedge later same-size reflows."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
:content "viewport reflow retry")))
|
|
(buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(cl-letf (((symbol-function 'ebox--execute-constraint-change)
|
|
(lambda (&rest _) (signal 'quit nil))))
|
|
(condition-case nil
|
|
(ebox-rerender-buffer-with-context buffer 320)
|
|
(quit nil)))
|
|
;; The interrupted reflow published nothing, so the stored
|
|
;; dimensions must still match the published render.
|
|
(should (equal (plist-get (ebox--buffer-render-state buffer)
|
|
:viewport-width)
|
|
240))
|
|
;; The same-size retry must reflow instead of no-op.
|
|
(let ((report (ebox-rerender-buffer-with-context buffer 320)))
|
|
(should report)
|
|
(should-not (eq (plist-get report :strategy) 'no-op)))
|
|
(should (equal (plist-get (ebox--buffer-render-state buffer)
|
|
:viewport-width)
|
|
320)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-smooth-scroll-multi-event-restores-gc-depth ()
|
|
"Coalesced wheel events must not leak the deferred GC lease depth."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(old-threshold gc-cons-threshold)
|
|
(old-percentage gc-cons-percentage))
|
|
(unwind-protect
|
|
(let ((gc-cons-threshold 1000)
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-deferred-render-gc-cons-threshold 2000)
|
|
(ebox-render-gc-cons-percentage 0.9)
|
|
(ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 999))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(with-current-buffer buffer
|
|
;; One trackpad flick delivers many wheel events that
|
|
;; coalesce into a single running animation.
|
|
(dotimes (_ 5)
|
|
(should (ebox--smooth-scroll-region-by root-id 4))))
|
|
(should (= ebox--deferred-render-gc-depth 1))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(should (= ebox--deferred-render-gc-depth 0))
|
|
(should (timerp ebox--deferred-render-gc-timer)))
|
|
(when root-id
|
|
(ebox--smooth-scroll-stop root-id))
|
|
(when (timerp ebox--deferred-render-gc-timer)
|
|
(cancel-timer ebox--deferred-render-gc-timer))
|
|
(setq ebox--deferred-render-gc-timer nil)
|
|
(setq ebox--deferred-render-gc-state nil)
|
|
(setq ebox--deferred-render-gc-depth 0)
|
|
(setq gc-cons-threshold old-threshold)
|
|
(setq gc-cons-percentage old-percentage)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-smooth-scroll-clamps-without-full-materialize ()
|
|
"Smooth wheel clamp should extend lazy scroll prefixes without full render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
(hidden-render-count 0)
|
|
(original-render-box (symbol-function 'ebox--render-box)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(cl-letf (((symbol-function 'ebox--render-box)
|
|
(lambda (box)
|
|
(when (equal (ebox-tree-node-id box) "row-30")
|
|
(cl-incf hidden-render-count))
|
|
(funcall original-render-box box))))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 60.0))
|
|
(should (ebox--smooth-scroll-region-by root-id 2))
|
|
(should (= hidden-render-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (= (plist-get state :scroll-offset) 1))
|
|
(should (< (length (plist-get state :content-lines)) 40))
|
|
(should (plist-get state :materialize-content-lines))))))
|
|
(ebox--smooth-scroll-stop root-id)
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-hidden-child-update-does-not-materialize ()
|
|
"Hidden updates inside lazy scroll windows should stay deferred."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 32
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id target-id next-target-id
|
|
(materialize-count 0)
|
|
(owner-rerenders 0)
|
|
(line-span-scans 0)
|
|
(membership-builds 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(setq target-id (ebox-test--selector-region-id buffer "#row-30"))
|
|
(setq next-target-id
|
|
(ebox-test--selector-region-id buffer "#row-31"))
|
|
(should target-id)
|
|
(should next-target-id)
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (plist-get state :materialize-content-lines))
|
|
(let ((materialize (plist-get state
|
|
:materialize-content-lines)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state)))
|
|
(let ((original-line-span-scan
|
|
(symbol-function 'ebox--scroll-state-region-line-spans))
|
|
(original-membership-build
|
|
(symbol-function
|
|
'ebox--scroll-build-content-region-id-set)))
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-owner-rerender)
|
|
(lambda (&rest _args)
|
|
(cl-incf owner-rerenders)
|
|
nil))
|
|
((symbol-function 'ebox--scroll-state-region-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf line-span-scans)
|
|
(apply original-line-span-scan args)))
|
|
((symbol-function
|
|
'ebox--scroll-build-content-region-id-set)
|
|
(lambda (&rest args)
|
|
(cl-incf membership-builds)
|
|
(apply original-membership-build args))))
|
|
(ebox-selector-update-buffer buffer "#row-30"
|
|
:content "new row 30")
|
|
(ebox-selector-update-buffer buffer "#row-31"
|
|
:content "new row 31")))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (= materialize-count 0))
|
|
(should (= owner-rerenders 0))
|
|
(should (= line-span-scans 0))
|
|
(should (= membership-builds 1))
|
|
(should (plist-get (ebox--scroll-get-state root-id)
|
|
:content-region-id-set))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :lazy-scroll-deferred-patch)))
|
|
(should-not (string-match-p "new row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (ebox--scroll-region-by root-id 30))
|
|
(should (= materialize-count 0))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
(should (gethash root-id ebox--scroll-idle-prefetch-timers)))
|
|
(ebox--scroll-idle-prefetch root-id)
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(delta (- 30 (or (plist-get state :scroll-offset)
|
|
0))))
|
|
(when (> delta 0)
|
|
(should (ebox--scroll-region-by root-id delta))))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should (plist-get state :content-lines-complete-p))
|
|
(should-not (plist-get state :materialize-content-lines)))
|
|
(should (string-match-p "new row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-extension-keeps-live-window-settled ()
|
|
"A clean offscreen prefix extension should not stall the live window."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for index below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" index)
|
|
:width (300) :height 1))))))
|
|
root-id
|
|
(ebox-viewport-width 300)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id
|
|
(current-buffer) "#root"))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(required-lines
|
|
(+ 5 (length (plist-get state :content-lines)))))
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
(setq state
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state required-lines t))
|
|
(should-not
|
|
(plist-get state :lazy-scroll-window-refresh-required)))
|
|
(should (= (ebox--scroll-region-by root-id 1 1) 1))
|
|
(should-not (plist-get (ebox-scroll-state root-id)
|
|
:lazy-scroll-window-refresh-required))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-prefix-refreshes-without-offset-motion ()
|
|
"A visibly changed prefix should publish atomically without offset motion."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for index below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" index)
|
|
:width (300) :height 1))))))
|
|
root-id
|
|
(ebox-viewport-width 300)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id
|
|
(current-buffer) "#root"))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(render-prefix (plist-get state :render-content-prefix))
|
|
(required-lines
|
|
(+ 5 (length (plist-get state :content-lines)))))
|
|
(plist-put
|
|
state :render-content-prefix
|
|
(lambda (source-state region-id limit)
|
|
(let* ((rendered
|
|
(funcall render-prefix source-state region-id limit))
|
|
(lines
|
|
(copy-sequence
|
|
(plist-get rendered :rendered-content-lines)))
|
|
(first (copy-sequence (car lines))))
|
|
(when (> (length first) 0)
|
|
(put-text-property 0 1 'ebox-test-generation t first))
|
|
(setf (car lines) first)
|
|
(plist-put rendered :rendered-content-lines lines)
|
|
rendered)))
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state required-lines t)
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:lazy-scroll-window-refresh-required)))
|
|
(should (eq (ebox--scroll-region-by root-id 0) 'refreshed))
|
|
(should (= (plist-get (ebox-scroll-state root-id) :scroll-offset) 0))
|
|
(should-not (plist-get (ebox-scroll-state root-id)
|
|
:lazy-scroll-window-refresh-required))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-visible-geometry-slot-miss-refreshes-lazy-window-atomically ()
|
|
"A visible slot miss should publish rebuilt lazy lines before returning."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(flex :width (300) :height 5 :padding (0 (10))
|
|
:border "#6F6A95" :justify-content center
|
|
:align-items center
|
|
(box :id "target" :content "width target\nexpands"
|
|
:width (190) :height 3 :padding (0 (10))
|
|
:border "#9CA3AF" :text-align center))
|
|
,@(cl-loop for index below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" index)
|
|
:width (300) :height 1))))))
|
|
root-id target-id
|
|
(ebox-viewport-width 300)
|
|
(ebox-viewport-height 5)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 12)
|
|
(rendered-lookups 0)
|
|
(original-rendered-lookup
|
|
(symbol-function 'ebox--scroll-hot-rendered-line-spans)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id
|
|
(current-buffer) "#root"))
|
|
(setq target-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should (plist-get state :render-content-prefix))
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
;; Cache enough untouched lines that the next one-line scroll does not
|
|
;; cross the old prefix boundary. Dirty-state refresh must not depend
|
|
;; on reaching that boundary.
|
|
(setq state
|
|
(ebox--scroll-state-ensure-prefix-lines
|
|
root-id state 12 t))
|
|
(should (> (- (length (plist-get state :content-lines))
|
|
(plist-get state :content-height))
|
|
1)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-hot-rendered-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf rendered-lookups)
|
|
(apply original-rendered-lookup args))))
|
|
(ebox-region-update target-id :width '(280)))
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state root-id)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-sync-refreshed))
|
|
(should (= (plist-get report :scroll-state-sync-refreshed-count) 1))
|
|
(should-not (plist-get report :scroll-state-sync-deferred))
|
|
(should (= rendered-lookups 0))
|
|
(should-not (plist-get state :lazy-scroll-prefix-dirty))
|
|
(should-not (plist-get state
|
|
:lazy-scroll-window-refresh-required))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))
|
|
;; Later movement must start from the already-published cache generation.
|
|
(should (= (ebox--scroll-region-by root-id 1 1) 1))
|
|
(should-not (plist-get (ebox-scroll-state root-id)
|
|
:lazy-scroll-prefix-dirty))
|
|
(should-not (plist-get (ebox-scroll-state root-id)
|
|
:lazy-scroll-window-refresh-required))
|
|
(should (= (ebox--scroll-region-by root-id -1 1) -1))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-cached-hidden-child-update-patches-prefix ()
|
|
"Hidden updates should patch cached lazy prefix lines before deferring."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(should (ebox--scroll-region-by root-id 30 32))
|
|
(should (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (ebox--scroll-region-by root-id -30))
|
|
(should-not (string-match-p "new row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(ebox-selector-update-buffer buffer "#row-30"
|
|
:content "new row 30")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should-not (plist-get report :lazy-scroll-deferred-patch))
|
|
(should (plist-get report :scroll-state-patch)))
|
|
(should (ebox--scroll-region-by root-id 30))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (string-match-p "new row 30" plain))
|
|
(should-not (string-match-p "^row 30$" plain)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-deferred-update-dirties-future-prefix ()
|
|
"Deferred hidden updates should be visible when lazy prefix reaches them."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
buffer
|
|
root-id
|
|
(materialize-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox--scroll-get-state root-id))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(ebox-selector-update-buffer buffer "#row-30"
|
|
:content "new row 30")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-get report :lazy-scroll-deferred-patch)))
|
|
(should (= materialize-count 0))
|
|
(cl-loop repeat 30
|
|
do (should (ebox--scroll-region-by root-id 1 1)))
|
|
(should (= materialize-count 0))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (string-match-p "new row 30" plain))
|
|
(should-not (string-match-p "^row 30$" plain)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-dirty-prefix-rebinds-signature-cache ()
|
|
"Dirty lazy prefixes should rebind the render signature cache before rendering."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "" :width 10))
|
|
(renderer (ebox--scroll-window-prefix-renderer
|
|
box :test-source 120 4))
|
|
first-cache
|
|
second-cache
|
|
(render-count 0))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-window-source)
|
|
(lambda (&rest _args)
|
|
(cl-incf render-count)
|
|
(if first-cache
|
|
(setq second-cache ebox--render-cache-signature-cache)
|
|
(setq first-cache ebox--render-cache-signature-cache))
|
|
(list :lines (list (format "line %d" render-count))
|
|
:cache nil
|
|
:complete nil
|
|
:content-width-exact-p t
|
|
:rendered-lines
|
|
(list (format "line %d" render-count)))))
|
|
((symbol-function 'ebox--scroll-window-formatted-lines)
|
|
(lambda (_box window)
|
|
(plist-get window :lines)))
|
|
((symbol-function 'ebox--scroll-rendered-content-lines)
|
|
(lambda (_box lines _region-id _start-index)
|
|
lines)))
|
|
(funcall renderer nil 1 1)
|
|
(puthash :stale t first-cache)
|
|
(funcall renderer '(:lazy-scroll-prefix-dirty t) 1 1)
|
|
(should (= render-count 2))
|
|
(should-not (eq first-cache second-cache))
|
|
(should-not (gethash :stale second-cache)))))
|
|
|
|
(ert-deftest ebox-visible-scroll-child-content-paint-patches-scroll-lines ()
|
|
"Visible content plus paint updates should patch scroll lines directly."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :id ,(format "metric-%02d" idx)
|
|
:content "待运行"
|
|
:width (120)
|
|
:height 2))))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 260)
|
|
(ebox-viewport-height 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(ebox-selector-update-buffer buffer "#metric-01"
|
|
:content "结果:通过"
|
|
:color "#B91C1C")
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(state (ebox--scroll-get-state root-id))
|
|
(plain (mapconcat #'substring-no-properties
|
|
(plist-get state :content-lines)
|
|
"\n")))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (string-match-p "结果:通过" plain))
|
|
(should-not (string-match-p "metric-01.*待运行" plain)))
|
|
(should (ebox--scroll-region-by root-id 1 1))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (string-match-p "结果:通过" plain)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-scroll-state-span-patch-key-policy-requires-content-for-paint ()
|
|
"Paint keys should only enter scroll-state patch with content changes."
|
|
(should (ebox--scroll-state-span-patch-keys-p '(:content)))
|
|
(should (ebox--scroll-state-span-patch-keys-p '(:content :color)))
|
|
(should (ebox--scroll-state-span-patch-keys-p
|
|
'(:content :bgcolor :border-top-color)))
|
|
(should (ebox--scroll-state-span-patch-keys-p '(:text-align)))
|
|
(should-not (ebox--scroll-state-span-patch-keys-p '(:color)))
|
|
(should-not (ebox--scroll-state-span-patch-keys-p
|
|
'(:bgcolor :border-top-color))))
|
|
|
|
(ert-deftest ebox-scroll-state-span-patch-ignores-foreign-runtime-states ()
|
|
"One buffer update must not materialize foreign or unrelated ownerless state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "before" :height 1)
|
|
(box :content "tail" :height 1)))))
|
|
(foreign-buffer (generate-new-buffer " *ebox-foreign-scroll*"))
|
|
(foreign-id :foreign-scroll-state)
|
|
(ownerless-id :ownerless-scroll-state)
|
|
(foreign-materializations 0)
|
|
(ownerless-materializations 0))
|
|
(unwind-protect
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((target-id
|
|
(ebox-test--selector-region-id
|
|
(current-buffer) "#target")))
|
|
(puthash
|
|
foreign-id
|
|
(list :buffer foreign-buffer
|
|
:content-lines '("foreign prefix")
|
|
:materialize-content-lines
|
|
(lambda (_state _region-id)
|
|
(cl-incf foreign-materializations)
|
|
'(:content-lines ("foreign complete")
|
|
:rendered-content-lines ("foreign complete")
|
|
:content-height 1)))
|
|
ebox--scroll-global-state)
|
|
(puthash
|
|
ownerless-id
|
|
(list :content-lines '("ownerless prefix")
|
|
:materialize-content-lines
|
|
(lambda (_state _region-id)
|
|
(cl-incf ownerless-materializations)
|
|
'(:content-lines ("ownerless complete")
|
|
:rendered-content-lines ("ownerless complete")
|
|
:content-height 1)))
|
|
ebox--scroll-global-state)
|
|
(ebox-region-update target-id :content "after")
|
|
(should (= foreign-materializations 0))
|
|
(should (= ownerless-materializations 0))
|
|
(should (string-match-p
|
|
"after"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))))
|
|
(remhash foreign-id ebox--scroll-global-state)
|
|
(remhash ownerless-id ebox--scroll-global-state)
|
|
(when (buffer-live-p foreign-buffer)
|
|
(kill-buffer foreign-buffer)))))
|
|
|
|
(ert-deftest ebox-visible-scroll-child-sync-publishes-window-markers ()
|
|
"Post-patch scroll line sync must publish one current marker generation."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :id ,(format "metric-%02d" idx)
|
|
:content "待运行"
|
|
:width (120)
|
|
:height 2))))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 260)
|
|
(ebox-viewport-height 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(ebox-selector-update-buffer buffer "#metric-01"
|
|
:padding-left (list 8)
|
|
:color "#B91C1C")
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(state (ebox--scroll-get-state root-id)))
|
|
(should (plist-get report :scroll-state-sync))
|
|
(should-not
|
|
(plist-get report
|
|
:scroll-state-window-markers-invalidated))
|
|
(should (> (or (plist-get
|
|
report
|
|
:scroll-state-window-marker-refresh-count)
|
|
0)
|
|
0))
|
|
(should (plist-get state :content-span-markers))
|
|
(should (plist-get state :content-window-region-id-set))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer root-id state)))
|
|
(should (ebox--scroll-region-by root-id 1 1))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-scroll-retains-published-window-markers-after-paint-update ()
|
|
"Paint updates and later scrolling should share one current marker window."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
buffer
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 260)
|
|
(ebox-viewport-height 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:content-span-markers))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:rendered-window-start-marker))
|
|
(ebox-selector-update-buffer buffer "#row-01"
|
|
:color "#B91C1C")
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state root-id)))
|
|
(should (plist-get report :scroll-state-paint-sync))
|
|
(should-not
|
|
(plist-get report
|
|
:scroll-state-window-markers-invalidated))
|
|
(should (plist-get state :content-span-markers))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer root-id state)))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:rendered-window-start-marker))
|
|
(cl-loop repeat 6
|
|
do
|
|
(should (ebox--scroll-region-by root-id 1 1))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:rendered-window-start-marker))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer root-id (ebox-scroll-state root-id)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-chromed-scroll-owner-rerender-publishes-current-window ()
|
|
"A scoped chromed owner rerender must publish its cache and live markers."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(column :id "doc" :width (240)
|
|
(box :id "scroll" :width (180) :height 3
|
|
:overflow scroll :border-top-p t
|
|
(column
|
|
(box :id "target" :content "alpha"
|
|
:width (100) :height 1)
|
|
(box :content "tail one" :height 1)
|
|
(box :content "tail two" :height 1)
|
|
(box :content "tail three" :height 1))))))
|
|
(fallback-count 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(scroll-id (ebox-test--selector-region-id buffer "#scroll"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(scroll-node-id
|
|
(ebox--ensure-node-id
|
|
(plist-get (ebox-scroll-state scroll-id) :box)))
|
|
(original-fallback
|
|
(symbol-function
|
|
'ebox--sync-scroll-state-lines-for-node-fallback)))
|
|
(cl-letf (((symbol-function 'ebox--patch-set-from-dirty-set)
|
|
(lambda (dirty-set _buffer)
|
|
(list
|
|
(ebox--patch-op
|
|
'owner-rerender scroll-node-id
|
|
:dirty (car dirty-set)))))
|
|
((symbol-function
|
|
'ebox--sync-scroll-state-lines-for-node-fallback)
|
|
(lambda (&rest args)
|
|
(cl-incf fallback-count)
|
|
(apply original-fallback args))))
|
|
(ebox-region-update target-id :height 2))
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state scroll-id))
|
|
(spans
|
|
(ebox--scroll-content-marker-spans
|
|
(plist-get state :content-span-markers))))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (plist-get report :scroll-state-owner-publication))
|
|
(should (= (or fallback-count 0) 0))
|
|
(should-not (plist-get state :lazy-scroll-prefix-dirty))
|
|
(should-not
|
|
(plist-get state :lazy-scroll-window-refresh-required))
|
|
(should (= (length spans) (plist-get state :content-height)))
|
|
(should
|
|
(cl-every
|
|
(lambda (span)
|
|
(and (marker-buffer (car span))
|
|
(marker-buffer (cdr span))))
|
|
spans))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer scroll-id state))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))
|
|
(should (= (ebox--scroll-region-by scroll-id 1 48) 1))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-owner-rerender-without-scroll-skips-scroll-publication ()
|
|
"A scroll-free root reflow should not scan or publish scroll marker state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(column :width (viewport)
|
|
(box :content "resize" :width (viewport)))))
|
|
buffer
|
|
(containment-count 0)
|
|
(publication-count 0)
|
|
(original-containment
|
|
(symbol-function
|
|
'ebox--scroll-state-region-ids-containing-node-ids))
|
|
(original-publication
|
|
(symbol-function 'ebox--publish-scoped-owner-scroll-windows)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-no-scroll-publication*")
|
|
layout))
|
|
(cl-letf
|
|
(((symbol-function
|
|
'ebox--scroll-state-region-ids-containing-node-ids)
|
|
(lambda (&rest arguments)
|
|
(cl-incf containment-count)
|
|
(apply original-containment arguments)))
|
|
((symbol-function 'ebox--publish-scoped-owner-scroll-windows)
|
|
(lambda (&rest arguments)
|
|
(cl-incf publication-count)
|
|
(apply original-publication arguments))))
|
|
(ebox-rerender-buffer-with-context buffer 260 4))
|
|
(should (= containment-count 0))
|
|
(should (= publication-count 0))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-nested-scroll-fallback-publishes-one-marker-generation ()
|
|
"Nested fallback sync must rebuild markers once without zero-delta scrolls."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "outer" :width (180) :height 3 :overflow scroll
|
|
(column
|
|
(box :id "inner" :width (160) :height 2 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "old" :height 1)
|
|
(box :content "inner 1" :height 1)
|
|
(box :content "inner 2" :height 1)))
|
|
(box :content "outer 1" :height 1)
|
|
(box :content "outer 2" :height 1)))))
|
|
(marker-refresh-count 0)
|
|
(zero-delta-scroll-count 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(outer-id (ebox-test--selector-region-id buffer "#outer"))
|
|
(inner-id (ebox-test--selector-region-id buffer "#inner"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(target-node
|
|
(ebox--buffer-region-render-owner-node buffer target-id)))
|
|
(ebox-region-update target-id :content "new")
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(dolist (scroll-id (list outer-id inner-id))
|
|
(let ((state (ebox-scroll-state scroll-id)))
|
|
(plist-put state :lazy-scroll-window-refresh-required t)
|
|
(puthash scroll-id state ebox--scroll-global-state)))
|
|
(let ((visible-before
|
|
(buffer-substring (point-min) (point-max)))
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-scroll-content-markers))
|
|
(original-scroll (symbol-function 'ebox--scroll-region-by)))
|
|
(cl-letf
|
|
(((symbol-function 'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest args)
|
|
(cl-incf marker-refresh-count)
|
|
(apply original-refresh args)))
|
|
((symbol-function 'ebox--scroll-region-by)
|
|
(lambda (region-id delta &rest args)
|
|
(when (zerop delta)
|
|
(cl-incf zero-delta-scroll-count))
|
|
(apply original-scroll region-id delta args))))
|
|
(ebox--sync-scroll-state-lines-for-node-fallback
|
|
buffer target-id target-node '(:content)
|
|
(ebox-test--buffer-update-report)))
|
|
(should (= (or marker-refresh-count 0) 1))
|
|
(should (= (or zero-delta-scroll-count 0) 0))
|
|
(should (equal-including-properties
|
|
visible-before
|
|
(buffer-substring (point-min) (point-max)))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(dolist (scroll-id (list outer-id inner-id))
|
|
(let ((state (ebox-scroll-state scroll-id)))
|
|
(should-not
|
|
(plist-get state :lazy-scroll-window-refresh-required))
|
|
(should (ebox--scroll-state-window-extents scroll-id state))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer scroll-id state))))))))
|
|
|
|
(ert-deftest ebox-root-scroll-owner-rerender-publishes-current-window ()
|
|
"Root scroll rerenders must publish both plain and chromed windows."
|
|
(dolist (chromed '(nil t))
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (180) :height 3
|
|
:overflow scroll :wrap-mode nil
|
|
,@(when chromed '(:border-top-p t))
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1)
|
|
(box :content "row 2" :height 1)
|
|
(box :content "row 3" :height 1)))))
|
|
(fallback-count 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(root-node-id (ebox--buffer-root-node-id buffer))
|
|
(original-fallback
|
|
(symbol-function
|
|
'ebox--sync-scroll-state-lines-for-node-fallback)))
|
|
(cl-letf (((symbol-function 'ebox--try-scroll-state-span-patch)
|
|
(lambda (&rest _args) nil))
|
|
((symbol-function 'ebox--patch-set-from-dirty-set)
|
|
(lambda (dirty-set _buffer)
|
|
(list
|
|
(ebox--patch-op
|
|
'owner-rerender root-node-id
|
|
:dirty (car dirty-set)))))
|
|
((symbol-function
|
|
'ebox--sync-scroll-state-lines-for-node-fallback)
|
|
(lambda (&rest args)
|
|
(cl-incf fallback-count)
|
|
(apply original-fallback args))))
|
|
(ebox-region-update root-id :wrap-mode 'char))
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state root-id)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (equal (plist-get report :owner-ids)
|
|
(list root-node-id)))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (plist-get report :scroll-state-owner-publication))
|
|
(should (= (or fallback-count 0) 0))
|
|
(should-not
|
|
(plist-get state :lazy-scroll-window-refresh-required))
|
|
(should (ebox--scroll-state-window-markers-healthy-p
|
|
buffer root-id state))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))
|
|
(should (= (ebox--scroll-region-by root-id 1 48) 1))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-hidden-geometry-update-defers-rerender ()
|
|
"Hidden geometry changes in lazy scroll windows should not rerender roots."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 32
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:width (120)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
target-id
|
|
(owner-rerenders 0)
|
|
(root-rerenders 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq target-id (ebox-test--selector-region-id buffer "#row-30"))
|
|
(should target-id)
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-owner-rerender)
|
|
(lambda (&rest _args)
|
|
(cl-incf owner-rerenders)
|
|
nil))
|
|
((symbol-function 'ebox-buffer-apply-root-rerender)
|
|
(lambda (&rest _args)
|
|
(cl-incf root-rerenders)
|
|
nil)))
|
|
(ebox-selector-update-buffer buffer "#row-30" :width '(180)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (= owner-rerenders 0))
|
|
(should (= root-rerenders 0))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :lazy-scroll-deferred-patch)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-hidden-paint-update-keeps-paint-path ()
|
|
"Paint-only updates should not pay lazy scroll geometry deferral costs."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
,@(cl-loop for idx below 32
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:color "#111111"
|
|
:height 1))))))
|
|
(buffer nil)
|
|
target-id)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 2))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(with-current-buffer buffer
|
|
(setq target-id (ebox-test--selector-region-id buffer "#row-30"))
|
|
(should target-id)
|
|
(ebox-selector-update-buffer buffer "#row-30" :color "#cc0000")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should-not (plist-get report :lazy-scroll-deferred-patch)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-scroll-rendered-content-patches-child-range-only ()
|
|
"Hidden child updates should patch the rendered scroll-line range."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "a" :content "A" :height 1)
|
|
(box :id "target" :content "old" :height 1
|
|
:padding (0 (8)) :border "#999999")
|
|
(box :id "c" :content "C" :height 1)))))
|
|
root-id target-id
|
|
(full-window-renders 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(cl-letf (((symbol-function 'ebox--render-scroll-state-window)
|
|
(lambda (&rest _args)
|
|
(cl-incf full-window-renders)
|
|
nil)))
|
|
(ebox-region-update target-id :content "new"))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (plist-get report :scroll-rendered-range-patch))
|
|
(should (= full-window-renders 0)))
|
|
(should (ebox--scroll-region-by root-id 1))
|
|
(should (string-match-p "new"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-scroll-state-set-lines-defers-line-indexes-when-bound ()
|
|
"Deferred scroll state setup should avoid building full line indexes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((content-lines (list (propertize "a" 'ebox-content 1)
|
|
(propertize "b" 'ebox-content 2)))
|
|
(rendered-lines (list (propertize "a" 'ebox-content 1)))
|
|
(build-count 0)
|
|
(original (symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(ebox--defer-scroll-content-index t))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original args))))
|
|
(let ((state (ebox--scroll-state-set-lines nil content-lines
|
|
rendered-lines)))
|
|
(should (= build-count 0))
|
|
(should-not (plist-get state :region-line-span-index))
|
|
(should (plist-get state :region-line-span-index-deferred))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(should (plist-get state
|
|
:rendered-region-line-span-index-deferred))))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-set-state-defers-line-indexes ()
|
|
"Lazy scroll setup should not build hidden content indexes on first render."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((content-lines (list (propertize "a" 'ebox-content 1)
|
|
(propertize "b" 'ebox-content 2)))
|
|
(rendered-lines (list (propertize "a" 'ebox-content 1)))
|
|
(build-count 0)
|
|
(original (symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original args))))
|
|
(ebox--scroll-set-state
|
|
42
|
|
(list :scroll-offset 0
|
|
:content-height 1
|
|
:content-lines content-lines
|
|
:rendered-content-lines rendered-lines
|
|
:render-content-prefix (lambda (&rest _args) nil)
|
|
:materialize-content-lines (lambda (&rest _args) nil)))
|
|
(let ((state (ebox--scroll-get-state 42)))
|
|
(should (= build-count 0))
|
|
(should-not (plist-get state :region-line-span-index))
|
|
(should (plist-get state :region-line-span-index-deferred))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(should (plist-get state
|
|
:rendered-region-line-span-index-deferred))))))
|
|
|
|
(ert-deftest ebox-scroll-state-builds-deferred-rendered-index-on-demand ()
|
|
"Deferred rendered line indexes should be built only when queried."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((content-lines (list (propertize "a" 'ebox-content 1)
|
|
(propertize "b" 'ebox-content 2)))
|
|
(rendered-lines (list (propertize "a" 'ebox-content 1)))
|
|
(build-count 0)
|
|
(original (symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(ebox--defer-scroll-content-index t))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original args))))
|
|
(let ((state (ebox--scroll-state-set-lines nil content-lines
|
|
rendered-lines)))
|
|
(should (= build-count 0))
|
|
(should (ebox--scroll-rendered-line-spans-for-region-ids state
|
|
'(1)))
|
|
(should (= build-count 1))
|
|
(should (plist-get state :rendered-region-line-span-index))
|
|
(should-not
|
|
(plist-get state :rendered-region-line-span-index-deferred))))))
|
|
|
|
(ert-deftest ebox-reflow-cache-prewarm-uses-first-valid-width-delta ()
|
|
"Predictive warming should start from the first valid resize velocity."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :height 2
|
|
(box :content "steady" :width (viewport) :height 1))))
|
|
buffer
|
|
scheduled-delay
|
|
scheduled-repeat
|
|
scheduled-function
|
|
scheduled-arguments)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm t)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout))
|
|
(cl-letf (((symbol-function 'run-at-time)
|
|
(lambda (&rest _)
|
|
(ert-fail "Resize prediction must yield to input")))
|
|
((symbol-function 'run-with-idle-timer)
|
|
(lambda (delay repeat function &rest arguments)
|
|
(setq scheduled-delay delay
|
|
scheduled-repeat repeat
|
|
scheduled-function function
|
|
scheduled-arguments arguments)
|
|
'scheduled-reflow-timer)))
|
|
(ebox-rerender-buffer-with-context buffer 260 4))
|
|
(should (= scheduled-delay
|
|
ebox-runtime-idle-reflow-cache-prewarm-delay))
|
|
(should-not scheduled-repeat)
|
|
(should (eq scheduled-function #'ebox--run-reflow-cache-prewarm))
|
|
(should (equal (car scheduled-arguments) buffer))
|
|
(should (eq (gethash buffer ebox--reflow-cache-prewarm-timers)
|
|
'scheduled-reflow-timer))
|
|
(should (= (plist-get (ebox--buffer-render-state buffer)
|
|
:last-viewport-width-delta)
|
|
20)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-reflow-cache-prewarm-isolates-published-runtime-state ()
|
|
"Predicted renders should publish only persistent render-cache entries."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(flex :width (viewport) :gap 1
|
|
,@(cl-loop for index below 8
|
|
collect
|
|
`(box :id ,(format "card-%d" index)
|
|
:content ,(format "card %d" index)
|
|
:width 72 :height 1))))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout))
|
|
(ebox--cancel-buffer-runtime-prewarm buffer)
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root (plist-get state :root-node))
|
|
(root-before (copy-tree root))
|
|
(text-before
|
|
(with-current-buffer buffer (buffer-string)))
|
|
(cache (plist-get state :render-cache))
|
|
(cache-count (hash-table-count cache))
|
|
(signature-count
|
|
(hash-table-count
|
|
(plist-get state :render-signature-cache)))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(scroll-before
|
|
(copy-tree (ebox--scroll-get-state root-id)))
|
|
(region-table-count (hash-table-count ebox--region-box-table)))
|
|
(ebox-test--set-buffer-update-report
|
|
buffer 'keep-this-report)
|
|
(should
|
|
(ebox--prewarm-buffer-render-cache-at-context
|
|
buffer state 0 240 280 4))
|
|
(should (> (hash-table-count cache) cache-count))
|
|
(should (= (hash-table-count
|
|
(plist-get state :render-signature-cache))
|
|
signature-count))
|
|
(should (equal root root-before))
|
|
(should (equal-including-properties
|
|
(with-current-buffer buffer (buffer-string))
|
|
text-before))
|
|
(should (= (plist-get state :viewport-width) 240))
|
|
(should (equal (ebox--scroll-get-state root-id) scroll-before))
|
|
(should (= (hash-table-count ebox--region-box-table)
|
|
region-table-count))
|
|
(should (eq (ebox-buffer-update-report buffer)
|
|
'keep-this-report))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-reflow-cache-prewarm-rejects-stale-runtime-revision ()
|
|
"A stale predicted render should exit before touching render caches."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :content "stale")))
|
|
buffer
|
|
(render-count 0)
|
|
(original-render (symbol-function 'ebox-render)))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout))
|
|
(ebox--cancel-buffer-runtime-prewarm buffer)
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(cache (plist-get state :render-cache))
|
|
(cache-count (hash-table-count cache)))
|
|
(cl-letf (((symbol-function 'ebox-render)
|
|
(lambda (&rest args)
|
|
(cl-incf render-count)
|
|
(apply original-render args))))
|
|
(should-not
|
|
(ebox--prewarm-buffer-render-cache-at-context
|
|
buffer state 1 240 280 4)))
|
|
(should (= render-count 0))
|
|
(should (= (hash-table-count cache) cache-count))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-local-update-cancels-without-scheduling-reflow-prewarm ()
|
|
"Single-property updates should cancel stale predictions and schedule none."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
(box :id "target" :content "old" :width 80))))
|
|
buffer)
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 4)
|
|
(ebox-runtime-idle-prewarm nil)
|
|
(ebox-runtime-idle-reflow-cache-prewarm t)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout))
|
|
(ebox-rerender-buffer-with-context buffer 260 4)
|
|
(ebox-rerender-buffer-with-context buffer 280 4)
|
|
(should (gethash buffer ebox--reflow-cache-prewarm-timers))
|
|
(ebox-selector-update-buffer buffer "#target" :content "new")
|
|
(should-not (gethash buffer ebox--reflow-cache-prewarm-timers))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'span-patch)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-prepares-shared-update-state ()
|
|
"Idle prewarm should prepare shared update state without materializing scrolls."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height 2 :overflow scroll
|
|
(column
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
root-id
|
|
expected-viewport-ids
|
|
(materialize-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-runtime-idle-prewarm-slice-size 10000)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*") layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(setq expected-viewport-ids
|
|
(ebox--viewport-dependent-node-ids layout))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(before-lines (length (plist-get state :content-lines)))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(when materialize
|
|
(plist-put state :materialize-content-lines
|
|
(lambda (&rest args)
|
|
(cl-incf materialize-count)
|
|
(apply materialize args))))
|
|
(ebox--runtime-prewarm-drain buffer)
|
|
(let ((render-state (ebox--buffer-render-state buffer))
|
|
(warmed (ebox-scroll-state root-id)))
|
|
(should
|
|
(plist-get render-state :layout-snapshots-complete-p))
|
|
(should
|
|
(plist-get render-state :viewport-dependent-node-ids-ready))
|
|
(should
|
|
(equal (plist-get render-state :viewport-dependent-node-ids)
|
|
expected-viewport-ids))
|
|
(should (plist-get warmed :region-line-span-index))
|
|
(should (plist-get warmed :rendered-region-line-span-index))
|
|
(should (= (length (plist-get warmed :content-lines))
|
|
before-lines))
|
|
(should (= materialize-count 0)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-does-not-wait-for-prefix-prefetch ()
|
|
"Prewarm should index current scroll lines while lazy prefix work is active."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "target" :height 1)
|
|
(box :id "row-1" :content "row 1" :height 1)
|
|
(box :id "row-2" :content "row 2" :height 1)))))
|
|
(buffer nil)
|
|
root-id)
|
|
(unwind-protect
|
|
(let ((ebox-runtime-idle-prewarm-slice-size 10000)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*") layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(puthash root-id t ebox--scroll-idle-prefetch-timers)
|
|
(ebox--runtime-prewarm-drain buffer)
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should (plist-get state :region-line-span-index))
|
|
(should (plist-get state :rendered-region-line-span-index))))
|
|
(remhash root-id ebox--scroll-idle-prefetch-timers)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-takes-priority-over-prefix-prefetch ()
|
|
"Lazy prefix warming should yield while shared runtime prewarming is active."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil)
|
|
root-id
|
|
(prefix-render-count 0)
|
|
exact-prefix
|
|
scheduled-delay)
|
|
(unwind-protect
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 8)
|
|
(ebox--scroll-allow-noninteractive-prefetch t)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1))))))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(job (gethash buffer ebox--runtime-prewarm-jobs)))
|
|
(setq state (plist-put state :render-content-prefix t))
|
|
(setq state (plist-put state :content-lines-complete-p nil))
|
|
(setq state (plist-put state :buffer buffer))
|
|
(puthash root-id state ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'ebox--scroll-state-ensure-prefix-lines)
|
|
(lambda (&rest _args)
|
|
(cl-incf prefix-render-count)
|
|
state))
|
|
((symbol-function 'ebox--scroll-schedule-idle-prefetch)
|
|
(lambda (_region-id &optional delay)
|
|
(setq scheduled-delay delay))))
|
|
(ebox--scroll-idle-prefetch root-id))
|
|
(should (= prefix-render-count 0))
|
|
(should (eq (gethash buffer ebox--runtime-prewarm-jobs) job))
|
|
(should (equal scheduled-delay
|
|
ebox-runtime-idle-prewarm-prefix-resume-delay))))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-does-not-delay-cache-miss-prefetch ()
|
|
"Urgent cache-miss prefetch should bypass shared prewarm priority."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil)
|
|
root-id
|
|
(prefix-render-count 0)
|
|
scheduled-delay)
|
|
(unwind-protect
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 8)
|
|
(ebox--scroll-allow-noninteractive-prefetch t)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1))))))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(setq state (plist-put state :render-content-prefix t))
|
|
(setq state (plist-put state :content-lines-complete-p nil))
|
|
(setq state (plist-put state :cache-miss-prefetch-target-lines 8))
|
|
(setq state (plist-put state :buffer buffer))
|
|
(puthash root-id state ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'ebox--scroll-state-ensure-prefix-lines)
|
|
(lambda (_region-id input-state target-lines
|
|
&optional exact)
|
|
(cl-incf prefix-render-count)
|
|
(setq exact-prefix exact)
|
|
(setq input-state
|
|
(plist-put input-state :content-lines
|
|
(make-list target-lines
|
|
(ebox-pixel-space 1))))
|
|
(plist-put input-state :content-lines-complete-p t)))
|
|
((symbol-function 'ebox--scroll-schedule-idle-prefetch)
|
|
(lambda (_region-id &optional delay)
|
|
(setq scheduled-delay delay)))
|
|
((symbol-function 'ebox--schedule-buffer-runtime-prewarm)
|
|
(lambda (&rest _args) nil)))
|
|
(ebox--scroll-idle-prefetch root-id)))
|
|
(should (= prefix-render-count 1))
|
|
(should exact-prefix)
|
|
(should-not (equal scheduled-delay
|
|
ebox-runtime-idle-prewarm-prefix-resume-delay)))
|
|
(ebox--scroll-cancel-idle-prefetch root-id)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-idle-prefix-slices-do-not-restart-runtime-prewarm ()
|
|
"Consecutive prefix slices should not starve behind repeated tree prewarms."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((buffer (generate-new-buffer " *ebox-prefix-slice-test*"))
|
|
(region-id "prefix-slice-scroll")
|
|
(state (list :buffer buffer
|
|
:scroll-offset 0
|
|
:content-height 2
|
|
:content-lines '("row 0" "row 1")
|
|
:render-content-prefix t
|
|
:content-lines-complete-p nil))
|
|
(runtime-prewarm-count 0)
|
|
(prefix-reschedule-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 8)
|
|
(ebox-scroll-lazy-idle-prefetch-slice-lines 1))
|
|
(puthash region-id state ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function 'ebox--scroll-state-ensure-prefix-lines)
|
|
(lambda (_region-id input-state _target-lines
|
|
&optional _exact)
|
|
(plist-put input-state :content-lines
|
|
(append (plist-get input-state :content-lines)
|
|
'("row 2")))
|
|
(puthash region-id input-state
|
|
ebox--scroll-global-state)
|
|
input-state))
|
|
((symbol-function 'ebox--scroll-schedule-idle-prefetch)
|
|
(lambda (&rest _args)
|
|
(cl-incf prefix-reschedule-count)))
|
|
((symbol-function 'ebox--schedule-buffer-runtime-prewarm)
|
|
(lambda (&rest _args)
|
|
(cl-incf runtime-prewarm-count))))
|
|
(ebox--scroll-idle-prefetch region-id))
|
|
(should (= prefix-reschedule-count 1))
|
|
(should (= runtime-prewarm-count 0)))
|
|
(remhash region-id ebox--scroll-global-state)
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-yields-between-slices ()
|
|
"Each prewarm slice should leave an idle interval for redisplay."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil)
|
|
scheduled-delay)
|
|
(unwind-protect
|
|
(let ((ebox-runtime-idle-prewarm-delay 0.1)
|
|
(ebox-runtime-idle-prewarm-slice-size 1)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(box :height 2 :overflow scroll
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1)
|
|
(box :content "row 2" :height 1))))))
|
|
(cl-letf (((symbol-function 'current-idle-time)
|
|
(lambda () (seconds-to-time 0.4)))
|
|
((symbol-function 'ebox--runtime-prewarm-schedule-timer)
|
|
(lambda (_buffer &optional delay)
|
|
(setq scheduled-delay delay))))
|
|
(ebox--runtime-prewarm-timer buffer))
|
|
(should (equal scheduled-delay 0.5)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-removes-first-scroll-style-index-build ()
|
|
"A prewarmed runtime should reuse scroll indexes on its first style update."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :height 2 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "old" :height 1)
|
|
(box :id "head-1" :content "head 1" :height 1)
|
|
(box :id "head-2" :content "head 2" :height 1)
|
|
(box :id "head-3" :content "head 3" :height 1)))))
|
|
(buffer nil)
|
|
root-id target-id
|
|
(build-count 0)
|
|
(scan-count 0)
|
|
(full-snapshot-refresh-count 0))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 900)
|
|
(ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-runtime-idle-prewarm-slice-size 10000)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*") layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(setq target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(ebox--runtime-prewarm-drain buffer)
|
|
(let ((original-build
|
|
(symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(original-scan
|
|
(symbol-function 'ebox--scroll-state-region-line-spans))
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-layout-snapshots)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original-build args)))
|
|
((symbol-function 'ebox--scroll-state-region-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf scan-count)
|
|
(apply original-scan args)))
|
|
((symbol-function 'ebox--refresh-buffer-layout-snapshots)
|
|
(lambda (&rest args)
|
|
(cl-incf full-snapshot-refresh-count)
|
|
(apply original-refresh args))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update target-id :content "new"))))
|
|
(should (= build-count 0))
|
|
(should (= scan-count 0))
|
|
(should (= full-snapshot-refresh-count 0))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should-not (plist-get state :region-line-span-index))
|
|
(should (plist-get state :region-line-span-index-deferred)))
|
|
(should (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(should (plist-get (ebox-test--buffer-update-report)
|
|
:scroll-state-index)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-discards-stale-runtime-revisions ()
|
|
"A runtime mutation should invalidate an older sliced prewarm job."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox-runtime-idle-prewarm-slice-size 1)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(column
|
|
(box :id "a" :content "A")
|
|
(box :id "b" :content "B")))))
|
|
(should (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(ebox--bump-buffer-runtime-revision buffer)
|
|
(should-not (ebox--runtime-prewarm-step buffer))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-jobs)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-cancels-before-update-errors ()
|
|
"A failing mutation should not leave an old prewarm job publishable."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build '(box :id "target" :content "old"))))
|
|
(should (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(let ((target-id
|
|
(ebox-test--selector-region-id buffer "#target")))
|
|
(should-error
|
|
(cl-letf (((symbol-function 'ebox-incremental-record-region-change)
|
|
(lambda (&rest _args)
|
|
(error "forced update failure"))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update target-id :color "#DC2626")))))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-timers)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-cancels-before-rerender-errors ()
|
|
"A failing viewport rerender should discard old prewarm work."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build '(box :id "target" :content "old"))))
|
|
(should (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(should-error
|
|
(cl-letf (((symbol-function
|
|
'ebox-incremental-rerender-buffer-with-context)
|
|
(lambda (&rest _args)
|
|
(error "forced rerender failure"))))
|
|
(ebox-rerender-buffer-with-context buffer 360)))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-timers)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-reschedules-after-batched-updates ()
|
|
"A successful explicit batch should schedule shared-state prewarming."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox-runtime-idle-prewarm-slice-size 10000)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(column
|
|
(box :id "target" :content "old")
|
|
(box :id "sibling" :content "same")))))
|
|
(ebox--runtime-prewarm-drain buffer)
|
|
(should-not (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(let ((target-id
|
|
(ebox-test--selector-region-id buffer "#target")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(with-current-buffer buffer
|
|
(ebox-region-update target-id :color "#DC2626")
|
|
(ebox-incremental-flush buffer)))
|
|
(let ((job (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(state (ebox--buffer-render-state buffer)))
|
|
(should job)
|
|
(should (= (plist-get job :runtime-revision)
|
|
(plist-get state :runtime-revision)))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-cancels-during-open-batch ()
|
|
"An unflushed batch mutation should cancel stale shared-state prewarming."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build '(box :id "target" :content "old"))))
|
|
(should (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(let ((target-id
|
|
(ebox-test--selector-region-id buffer "#target")))
|
|
(ebox-incremental-begin-batch buffer)
|
|
(with-current-buffer buffer
|
|
(ebox-region-update target-id :padding-left 9)))
|
|
(should (= (ebox-incremental-pending-count buffer) 1))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-jobs))
|
|
(should-not (gethash buffer ebox--runtime-prewarm-timers)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-avoids-unbounded-tree-scans ()
|
|
"Scheduling and draining prewarm should not scan all nodes in one callback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil)
|
|
(node-table-scan-count 0)
|
|
(viewport-scan-count 0))
|
|
(unwind-protect
|
|
(let ((ebox--runtime-prewarm-allow-noninteractive t)
|
|
(ebox-runtime-idle-prewarm-slice-size 1))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(column
|
|
(box :content "row 0")
|
|
(box :content "row 1")
|
|
(box :content "row 2")))))
|
|
(ebox--cancel-buffer-runtime-prewarm buffer)
|
|
(let ((node-table (ebox--buffer-node-table buffer))
|
|
(original-maphash (symbol-function 'maphash)))
|
|
(cl-letf (((symbol-function 'maphash)
|
|
(lambda (function table)
|
|
(when (eq table node-table)
|
|
(cl-incf node-table-scan-count))
|
|
(funcall original-maphash function table))))
|
|
(ebox--schedule-buffer-runtime-prewarm buffer)))
|
|
(let ((original-viewport
|
|
(symbol-function
|
|
'ebox--buffer-viewport-dependent-node-ids)))
|
|
(cl-letf
|
|
(((symbol-function 'ebox--buffer-viewport-dependent-node-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf viewport-scan-count)
|
|
(apply original-viewport args))))
|
|
(ebox--runtime-prewarm-drain buffer)))
|
|
(should (= node-table-scan-count 0))
|
|
(should (= viewport-scan-count 0)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-preserves-viewport-dependency-semantics ()
|
|
"Sliced dependency discovery should match the canonical tree algorithm."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((buffer nil))
|
|
(unwind-protect
|
|
(let ((ebox-viewport-width 360)
|
|
(ebox-viewport-height 12)
|
|
(ebox-runtime-idle-prewarm-slice-size 1)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*")
|
|
(ebox-build
|
|
'(box :width (210)
|
|
(column
|
|
(box :id "width-only" :width (viewport))
|
|
(box :id "height-only"
|
|
:height (viewport-height))
|
|
(flex :id "flex-height"
|
|
:min-height (- (viewport-height) 1)
|
|
(box :content "Flex")))))))
|
|
(let* ((state (ebox--buffer-render-state buffer))
|
|
(root (plist-get state :root-node))
|
|
(expected-axes
|
|
(let ((ebox--viewport-dependent-node-ids-cache
|
|
(make-hash-table :test 'eq))
|
|
(ebox--viewport-height-dependent-subtree-cache
|
|
(make-hash-table :test 'eq)))
|
|
(ebox--viewport-dependent-node-id-axes root)))
|
|
(expected
|
|
(delete-dups
|
|
(copy-sequence
|
|
(append (car expected-axes) (cdr expected-axes)))))
|
|
(width-only-node-id
|
|
(plist-get
|
|
(car (ebox-selector-query-buffer buffer "#width-only"))
|
|
:node-id))
|
|
(height-only-node-id
|
|
(plist-get
|
|
(car (ebox-selector-query-buffer buffer "#height-only"))
|
|
:node-id)))
|
|
(ebox--runtime-prewarm-drain buffer)
|
|
(should (equal (plist-get state :viewport-dependent-node-id-axes)
|
|
expected-axes))
|
|
(should (equal (plist-get state :viewport-dependent-node-ids)
|
|
expected))
|
|
(pcase-let ((`(,width-ids . ,height-ids)
|
|
(plist-get state
|
|
:viewport-dependent-node-id-axes)))
|
|
(should-not (member width-only-node-id width-ids))
|
|
(should-not (member width-only-node-id height-ids))
|
|
(should-not (member height-only-node-id width-ids))
|
|
(should (member height-only-node-id height-ids)))
|
|
(should (plist-get state :viewport-dependent-node-ids-ready))))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-runtime-idle-prewarm-scroll-slices-use-list-cursors ()
|
|
"Late cached-line slices should not restart traversal from the list head."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
,@(cl-loop for idx below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)
|
|
:height 1))))))
|
|
(buffer nil)
|
|
(nth-count 0)
|
|
(original-nth (symbol-function 'nth)))
|
|
(unwind-protect
|
|
(let ((ebox-scroll-lazy-idle-prefetch-lines 0)
|
|
(ebox-runtime-idle-prewarm-slice-size 3)
|
|
(ebox--runtime-prewarm-allow-noninteractive t))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-prewarm-test*") layout))
|
|
(cl-letf (((symbol-function 'nth)
|
|
(lambda (&rest args)
|
|
(cl-incf nth-count)
|
|
(apply original-nth args))))
|
|
(ebox--runtime-prewarm-drain buffer))
|
|
(should (= nth-count 0)))
|
|
(when (buffer-live-p buffer)
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-owner-rerender-defers-scroll-content-index ()
|
|
"Owner rerender should not rebuild full hidden scroll content indexes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
`(box :id "root" :width (viewport) :height 2
|
|
:overflow scroll
|
|
(column
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :content
|
|
,(format "row %02d alpha beta gamma"
|
|
idx)
|
|
:wrap-mode word))))))
|
|
(buffer nil)
|
|
(build-count 0)
|
|
(original (symbol-function 'ebox--scroll-build-region-line-span-index)))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original args))))
|
|
(ebox-rerender-buffer-with-context buffer 160))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'owner-rerender))
|
|
(should (= build-count 0))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-owner-viewport-rerender-uses-lightweight-scroll-window ()
|
|
"Root viewport rerender should defer broad indexes and keep scrolling."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height 3 :overflow scroll
|
|
(column
|
|
,@(cl-loop for idx below 16
|
|
collect
|
|
`(box :id ,(format "row-%02d" idx)
|
|
:content
|
|
,(format "row %02d alpha beta gamma" idx)
|
|
:wrap-mode word))))))
|
|
(buffer nil)
|
|
root-id
|
|
(hidden-prewarm-region-id "hidden-prewarm-scroll-state")
|
|
(full-marker-refreshes 0)
|
|
(full-role-refreshes 0)
|
|
(full-property-scans 0)
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-scroll-content-markers))
|
|
(original-role-refresh
|
|
(symbol-function 'ebox-buffer-refresh-region-role-spans))
|
|
(original-property-scan
|
|
(symbol-function
|
|
'ebox--refresh-box-extents-for-region-ids-in-spans)))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout)))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(puthash hidden-prewarm-region-id t
|
|
(ebox--buffer-region-id-set buffer))
|
|
(puthash hidden-prewarm-region-id
|
|
(list :box (ebox-create :content "hidden" :height 2
|
|
:overflow 'scroll)
|
|
:content-height 2)
|
|
ebox--scroll-global-state)
|
|
(cl-letf (((symbol-function
|
|
'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest args)
|
|
(cl-incf full-marker-refreshes)
|
|
(apply original-refresh args)))
|
|
((symbol-function
|
|
'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-role-refreshes)
|
|
(apply original-role-refresh args)))
|
|
((symbol-function
|
|
'ebox--refresh-box-extents-for-region-ids-in-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-property-scans)
|
|
(apply original-property-scan args))))
|
|
(ebox-rerender-buffer-with-context buffer 160)
|
|
(ebox-rerender-buffer-with-context buffer 200))
|
|
(should (= full-marker-refreshes 0))
|
|
(should (= full-role-refreshes 0))
|
|
(should (= full-property-scans 0))
|
|
(should-not (ebox--buffer-region-role-span-table buffer))
|
|
(let ((state (ebox--scroll-get-state root-id)))
|
|
(should-not (plist-get state :content-span-markers))
|
|
(should (plist-get state :rendered-window-start-marker))
|
|
(should (plist-get state :rendered-window-end-marker)))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :scroll-offset 1)
|
|
(should (plist-get (ebox-test--buffer-update-report)
|
|
:scroll-fast-path)))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(cl-letf (((symbol-function
|
|
'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-role-refreshes)
|
|
(apply original-role-refresh args))))
|
|
(with-current-buffer buffer
|
|
(ebox-region-update root-id :bgcolor "#223344")))
|
|
(should (= full-role-refreshes 1))
|
|
(should (hash-table-p
|
|
(ebox--buffer-region-role-span-table buffer)))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer))
|
|
(remhash hidden-prewarm-region-id ebox--scroll-global-state))))
|
|
|
|
(ert-deftest ebox-root-owner-chromed-scroll-rerender-uses-prepared-indexes ()
|
|
"A visible chromed scroll box should install prepared complete indexes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height 3 :overflow scroll
|
|
:border-top-p t
|
|
(column
|
|
,@(cl-loop for idx below 8
|
|
collect
|
|
`(box :content ,(format "row %02d" idx)))))))
|
|
(buffer nil)
|
|
root-id
|
|
(full-marker-refreshes 0)
|
|
(original-refresh
|
|
(symbol-function 'ebox--refresh-buffer-scroll-content-markers)))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout)))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(cl-letf (((symbol-function
|
|
'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest args)
|
|
(cl-incf full-marker-refreshes)
|
|
(apply original-refresh args))))
|
|
(ebox-rerender-buffer-with-context buffer 160))
|
|
(should (= full-marker-refreshes 0))
|
|
(should
|
|
(gethash
|
|
ebox-buffer--role-span-table-template-key
|
|
(ebox--buffer-region-role-span-table buffer)))
|
|
(should (vectorp
|
|
(plist-get (ebox--scroll-get-state root-id)
|
|
:content-span-markers)))
|
|
(with-current-buffer buffer
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-root-owner-rerender-publishes-property-aware-patches ()
|
|
"A root owner rerender should publish only its property-aware delta."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :width (viewport)
|
|
:content "responsive root\nsecond line\nthird line")))
|
|
(buffer nil)
|
|
(owner-set-scans 0)
|
|
(root-patch-publications 0)
|
|
(original-owner-set
|
|
(symbol-function 'ebox--string-content-owner-set))
|
|
(original-replace
|
|
(symbol-function
|
|
'ebox-buffer--replace-root-with-property-patches)))
|
|
(unwind-protect
|
|
(progn
|
|
(let ((ebox-viewport-width 240))
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*") layout)))
|
|
(cl-letf (((symbol-function 'ebox--string-content-owner-set)
|
|
(lambda (&rest args)
|
|
(cl-incf owner-set-scans)
|
|
(apply original-owner-set args)))
|
|
((symbol-function
|
|
'ebox-buffer--replace-root-with-property-patches)
|
|
(lambda (spans rendered)
|
|
(cl-incf root-patch-publications)
|
|
(funcall original-replace spans rendered))))
|
|
(ebox-rerender-buffer-with-context buffer 160))
|
|
(should (= owner-set-scans 0))
|
|
(should (= root-patch-publications 1))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'owner-rerender))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report)
|
|
:publication-scope)
|
|
'minimal-spans))
|
|
(should (plist-get (ebox-test--buffer-update-report)
|
|
:published-buffer-spans))
|
|
(let ((expected (let ((ebox-viewport-width 160))
|
|
(ebox-render layout))))
|
|
(with-current-buffer buffer
|
|
(should (equal-including-properties
|
|
(buffer-substring (point-min) (point-max))
|
|
expected)))))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-span-patch-defers-scroll-content-index ()
|
|
"Span patches should not rebuild full hidden scroll content indexes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
`(box :id "root" :width 160 :height 2
|
|
:overflow scroll
|
|
(column
|
|
,@(cl-loop for idx below 24
|
|
collect
|
|
`(box :content
|
|
,(format "row %02d alpha beta gamma"
|
|
idx)
|
|
:wrap-mode word))))))
|
|
(buffer nil)
|
|
root-id
|
|
(build-count 0)
|
|
(original (symbol-function 'ebox--scroll-build-region-line-span-index)))
|
|
(unwind-protect
|
|
(progn
|
|
(setq buffer
|
|
(ebox-render-to-buffer
|
|
(generate-new-buffer-name " *ebox-test*")
|
|
layout))
|
|
(setq root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-count)
|
|
(apply original args))))
|
|
(should (ebox-buffer-apply-span-patch
|
|
buffer
|
|
(list :owner-id root-id
|
|
:dirty (list :changed-keys '(:width))))))
|
|
(should (= build-count 0)))
|
|
(when (and buffer (buffer-live-p buffer))
|
|
(kill-buffer buffer)))))
|
|
|
|
(ert-deftest ebox-hidden-scroll-child-content-update-patches-scroll-state ()
|
|
"Hidden scroll children should update cached scroll lines without rerendering."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :content "visible" :height 1)
|
|
(box :id "target" :content "old" :height 1)
|
|
(box :content "tail" :height 1)))))
|
|
root-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#target"))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "visible" plain))
|
|
(should-not (string-match-p "old" plain)))
|
|
(let ((owner-rerenders 0))
|
|
(cl-letf (((symbol-function 'ebox-buffer-apply-owner-rerender)
|
|
(lambda (&rest _args)
|
|
(cl-incf owner-rerenders)
|
|
nil)))
|
|
(ebox-region-update target-id :content "new")
|
|
(should (= owner-rerenders 0))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should-not (plist-get report :full-rerender)))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "visible" plain))
|
|
(should-not (string-match-p "new" plain)))
|
|
(should (ebox--scroll-region-by root-id 1))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "new" plain))
|
|
(should-not (string-match-p "old" plain))))))
|
|
|
|
(ert-deftest ebox-visible-lazy-scroll-child-update-does-not-defer ()
|
|
"Lazy scroll children in the current visible range should patch immediately."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((children (cl-loop for idx below 40
|
|
collect `(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1)))
|
|
(layout (ebox-build
|
|
`(box :id "root" :height 2 :overflow scroll
|
|
(column ,@children))))
|
|
root-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(should (ebox--scroll-region-by root-id 30))
|
|
(setq target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#row-30"))
|
|
(should target-id)
|
|
(should (string-match-p "row 30"
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(cl-letf (((symbol-function 'ebox--region-ids-visible-in-buffer-p)
|
|
(lambda (&rest _args) nil)))
|
|
(ebox-region-update target-id :content "new row 30"))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender root-rerender)))
|
|
(should-not (plist-get report :lazy-scroll-deferred-patch)))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "new row 30" plain))))))
|
|
|
|
(ert-deftest ebox-visible-empty-scroll-child-content-update-settles-window ()
|
|
"An empty fixed box in a visible scene must not be mistaken for hidden."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
`(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(flex :id "scene" :width (viewport) :height 4
|
|
:align-items center :justify-content center
|
|
(box :id "target" :content "SEED" :width (180) :height 3
|
|
:overflow hidden :bgcolor "#DDEAE4"))
|
|
,@(cl-loop for index below 40
|
|
collect
|
|
`(box :content ,(format "row %02d" index)
|
|
:height 1))))))
|
|
(ebox-viewport-width 300)
|
|
(ebox-viewport-height 4)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 12)
|
|
root-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root")
|
|
target-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target"))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:render-content-prefix))
|
|
(ebox-region-update target-id :content "")
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should-not
|
|
(member (ebox--buffer-root-node-id (current-buffer))
|
|
(plist-get report :owner-ids))))
|
|
(ebox-region-update target-id :content "NOW VISIBLE")
|
|
(let ((report (ebox-test--buffer-update-report))
|
|
(state (ebox-scroll-state root-id)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should-not
|
|
(member (ebox--buffer-root-node-id (current-buffer))
|
|
(plist-get report :owner-ids)))
|
|
(should-not (plist-get report :lazy-scroll-deferred-patch))
|
|
(should-not (plist-get state :lazy-scroll-prefix-dirty))
|
|
(should-not (plist-get state
|
|
:lazy-scroll-window-refresh-required)))
|
|
(should (string-match-p
|
|
"NOW VISIBLE"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-lazy-scroll-ignores-updates-to-sibling-status-box ()
|
|
"A sibling update must not materialize an unrelated lazy scroll state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((rows (cl-loop for index below 40
|
|
collect `(box :id ,(format "row-%02d" index)
|
|
:content ,(format "row %02d" index)
|
|
:height 1)))
|
|
(layout
|
|
(ebox-build
|
|
`(column :width (viewport)
|
|
(box :id "rail" :content "ready" :width (viewport)
|
|
:height 1)
|
|
(box :id "root" :width (viewport)
|
|
:height (viewport-height) :overflow scroll
|
|
(column ,@rows)))))
|
|
(ebox-viewport-width 240)
|
|
(ebox-viewport-height 3)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0)
|
|
rail-id root-id materialize-count)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq rail-id (ebox-test--selector-region-id
|
|
(current-buffer) "#rail")
|
|
root-id (ebox-test--selector-region-id
|
|
(current-buffer) "#root"))
|
|
(let* ((state (ebox-scroll-state root-id))
|
|
(materialize (plist-get state :materialize-content-lines)))
|
|
(should materialize)
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
(should (plist-get state :rendered-content-lines))
|
|
(plist-put
|
|
state :materialize-content-lines
|
|
(lambda (&rest arguments)
|
|
(cl-incf materialize-count)
|
|
(apply materialize arguments)))
|
|
(puthash root-id state ebox--scroll-global-state))
|
|
(ebox-region-update rail-id :content "updated")
|
|
(should (= (or materialize-count 0) 0))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should-not (plist-get state :content-lines-complete-p))
|
|
(should (plist-get state :rendered-content-lines)))
|
|
(should (string-match-p
|
|
"updated"
|
|
(buffer-substring-no-properties (point-min) (point-max)))))))
|
|
|
|
(ert-deftest ebox-visible-scroll-marker-window-detects-owner-stack ()
|
|
"Visible marker checks should recognize owner-stack-only regions."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((region-id 4242)
|
|
(line (propertize "owned visible line"
|
|
'ebox-content-owners (list region-id)))
|
|
start end state)
|
|
(insert line)
|
|
(setq start (copy-marker (point-min) nil))
|
|
(setq end (copy-marker (point-max) t))
|
|
(setq state (list :content-span-markers
|
|
(vector (cons start end))))
|
|
(should (ebox--scroll-state-region-visible-in-window-p
|
|
state (list region-id)))
|
|
(set-marker start nil)
|
|
(set-marker end nil))))
|
|
|
|
(ert-deftest ebox-scroll-marker-window-visible-set-is-authoritative ()
|
|
"A cached visible region set should avoid marker text fallback scans."
|
|
(ebox-test--reset-runtime-state)
|
|
(with-temp-buffer
|
|
(let* ((region-id 4343)
|
|
(line (propertize "owned visible line"
|
|
'ebox-content-owners (list region-id)))
|
|
(empty-visible-set (make-hash-table :test 'equal))
|
|
start end state
|
|
(scans 0))
|
|
(insert line)
|
|
(setq start (copy-marker (point-min) nil))
|
|
(setq end (copy-marker (point-max) t))
|
|
(setq state (list :content-window-region-id-set empty-visible-set
|
|
:content-span-markers (vector (cons start end))))
|
|
(let ((original (symbol-function 'ebox--pos-region-ids)))
|
|
(cl-letf (((symbol-function 'ebox--pos-region-ids)
|
|
(lambda (&rest args)
|
|
(cl-incf scans)
|
|
(apply original args))))
|
|
(should-not (ebox--scroll-state-region-visible-in-window-p
|
|
state (list region-id)))))
|
|
(should (= scans 0))
|
|
(set-marker start nil)
|
|
(set-marker end nil))))
|
|
|
|
(ert-deftest ebox-scroll-updates-rendered-window-extents-when-window-moves ()
|
|
"Scrolling should keep lightweight rendered window extents current."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((children (cl-loop for idx below 20
|
|
collect `(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1)))
|
|
(layout (ebox-build
|
|
`(box :id "root" :height 2 :overflow scroll
|
|
(column ,@children))))
|
|
root-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(should (plist-get (ebox-scroll-state root-id)
|
|
:content-window-region-id-set))
|
|
(should (ebox--scroll-region-by root-id 1))
|
|
(let ((state (ebox-scroll-state root-id)))
|
|
(should (plist-get state :rendered-window-start-marker))
|
|
(should (plist-get state :rendered-window-end-marker))
|
|
(should-not (plist-get state :content-span-markers))
|
|
(should-not (plist-get state :content-window-region-id-set))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))))))
|
|
|
|
(ert-deftest ebox-scroll-reveal-indexes-visible-child-paint ()
|
|
"A child revealed by scrolling should paint the live buffer immediately."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (180) :height 2 :overflow scroll
|
|
(column
|
|
(box :id "row-0" :content "row 0" :height 1)
|
|
(box :id "row-1" :content "row 1" :height 1)
|
|
(box :id "row-2" :content "row 2" :height 1)
|
|
(box :id "target" :content "target" :height 1)
|
|
(box :id "row-4" :content "row 4" :height 1)))))
|
|
root-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(should (ebox--scroll-region-by root-id 3 48))
|
|
(ebox-region-update target-id :color "#abcdef")
|
|
(should (ebox--region-find target-id 'content))
|
|
(let* ((report (ebox-test--buffer-update-report))
|
|
(span (car (ebox--region-find target-id 'content)))
|
|
(face (and span (get-text-property (car span) 'face))))
|
|
(should (eq (plist-get report :strategy) 'paint-patch))
|
|
(should (> (or (plist-get report :span-count) 0) 0))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "#abcdef")))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should (ebox--scroll-region-by root-id -3 48))
|
|
(should (ebox--scroll-region-by root-id 3 48))
|
|
(let* ((span (car (ebox--region-find target-id 'content)))
|
|
(face (and span (get-text-property (car span) 'face))))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :foreground "#abcdef")))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-scroll-reveal-keeps-visible-geometry-indexed ()
|
|
"Geometry updates on a revealed child should not fall back to broad scans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (180) :height 2 :overflow scroll
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1)
|
|
(box :content "row 2" :height 1)
|
|
(box :id "target" :content "target" :width (120) :height 1
|
|
:box-sizing border-box :padding-left (2))))))
|
|
root-id target-id
|
|
(span-scans 0)
|
|
(full-extent-refreshes 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(should (ebox--scroll-region-by root-id 2 48))
|
|
(let ((original-scan
|
|
(symbol-function 'ebox--region-set-line-spans-by-scan))
|
|
(original-extents
|
|
(symbol-function 'ebox--refresh-buffer-box-extents)))
|
|
(cl-letf (((symbol-function 'ebox--region-set-line-spans-by-scan)
|
|
(lambda (&rest args)
|
|
(cl-incf span-scans)
|
|
(apply original-scan args)))
|
|
((symbol-function 'ebox--refresh-buffer-box-extents)
|
|
(lambda (&rest args)
|
|
(cl-incf full-extent-refreshes)
|
|
(apply original-extents args))))
|
|
(ebox-region-update target-id :padding-left (list 12))))
|
|
(should (= span-scans 0))
|
|
(should (= full-extent-refreshes 0))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'span-patch))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-scroll-role-markers-do-not-paint-a-displaced-row ()
|
|
"Scroll-displaced marker spans should not paint their replacement row."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :content "row 0" :height 1)
|
|
(box :content "row 1" :height 1)
|
|
(box :id "target" :content "target" :height 1)
|
|
(box :id "row-3" :content "row 3" :height 1)
|
|
(box :content "row 4" :height 1)))))
|
|
root-id target-id row-3-id
|
|
(full-role-refreshes 0)
|
|
(property-scans 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(setq row-3-id
|
|
(ebox-test--selector-region-id (current-buffer) "#row-3"))
|
|
(let ((stale-role-table (ebox-buffer--region-role-span-table)))
|
|
(should (hash-table-p stale-role-table))
|
|
(should (ebox--scroll-region-by root-id 1 48))
|
|
(should-not (ebox-buffer--region-role-span-table))
|
|
(ebox--set-buffer-region-role-span-table
|
|
(current-buffer) stale-role-table)
|
|
(should (eq (ebox--region-ids-role-table-status
|
|
stale-role-table (list target-id))
|
|
'stale))
|
|
(should-not
|
|
(ebox--region-ids-visible-via-role-table-p (list target-id)))
|
|
(let ((original-refresh
|
|
(symbol-function 'ebox-buffer-refresh-region-role-spans))
|
|
(original-scan
|
|
(symbol-function 'ebox--region-ids-visible-by-property-scan-p)))
|
|
(cl-letf (((symbol-function 'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-role-refreshes)
|
|
(apply original-refresh args)))
|
|
((symbol-function
|
|
'ebox--region-ids-visible-by-property-scan-p)
|
|
(lambda (&rest args)
|
|
(cl-incf property-scans)
|
|
(apply original-scan args))))
|
|
(ebox-region-update target-id :color "#abcdef"))))
|
|
(let* ((target-pos
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(row-3-pos
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content row-3-id))
|
|
(target-face
|
|
(and target-pos (get-text-property target-pos 'face)))
|
|
(row-3-face
|
|
(and row-3-pos (get-text-property row-3-pos 'face))))
|
|
(should (= full-role-refreshes 1))
|
|
(should (= property-scans 0))
|
|
(should (ebox-test--face-has-key-value-p
|
|
target-face :foreground "#abcdef"))
|
|
(should-not (ebox-test--face-has-key-value-p
|
|
row-3-face :foreground "#abcdef"))))))
|
|
|
|
(ert-deftest ebox-partially-stale-role-spans-rebuild-before-paint ()
|
|
"A current target span must not hide a stale span on a neighboring line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(column :id "root" :width (180)
|
|
(box :id "target" :content "target" :height 1)
|
|
(box :id "neighbor" :content "neighbor" :height 1))))
|
|
(full-role-refreshes 0)
|
|
(property-scans 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(neighbor-id
|
|
(ebox-test--selector-region-id (current-buffer) "#neighbor"))
|
|
(table (ebox-buffer--region-role-span-table))
|
|
(target-key
|
|
(ebox-buffer--region-role-key target-id 'content))
|
|
(neighbor-key
|
|
(ebox-buffer--region-role-key neighbor-id 'content))
|
|
(valid-span (car (gethash target-key table)))
|
|
(displaced-span (car (gethash neighbor-key table))))
|
|
(should valid-span)
|
|
(should displaced-span)
|
|
(should-not
|
|
(= (line-number-at-pos (marker-position (car valid-span)))
|
|
(line-number-at-pos (marker-position (car displaced-span)))))
|
|
(puthash target-key (list valid-span displaced-span) table)
|
|
(should (ebox-buffer--current-region-role-span-p
|
|
valid-span target-id 'content))
|
|
(should-not (ebox-buffer--current-region-role-span-p
|
|
displaced-span target-id 'content))
|
|
(should (ebox--region-ids-visible-via-role-table-p (list target-id)))
|
|
(should (eq (ebox--region-ids-role-table-status
|
|
table (list target-id))
|
|
'stale))
|
|
(let ((original-refresh
|
|
(symbol-function 'ebox-buffer-refresh-region-role-spans))
|
|
(original-scan
|
|
(symbol-function 'ebox--region-ids-visible-by-property-scan-p)))
|
|
(cl-letf (((symbol-function 'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-role-refreshes)
|
|
(apply original-refresh args)))
|
|
((symbol-function
|
|
'ebox--region-ids-visible-by-property-scan-p)
|
|
(lambda (&rest args)
|
|
(cl-incf property-scans)
|
|
(apply original-scan args))))
|
|
(ebox-region-update target-id :color "#abcdef")))
|
|
(let* ((target-pos
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(neighbor-pos
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content neighbor-id))
|
|
(target-face
|
|
(and target-pos (get-text-property target-pos 'face)))
|
|
(neighbor-face
|
|
(and neighbor-pos (get-text-property neighbor-pos 'face))))
|
|
(should (= full-role-refreshes 1))
|
|
(should (= property-scans 0))
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'paint-patch))
|
|
(should (ebox-test--face-has-key-value-p
|
|
target-face :foreground "#abcdef"))
|
|
(should-not (ebox-test--face-has-key-value-p
|
|
neighbor-face :foreground "#abcdef")))))))
|
|
|
|
(ert-deftest ebox-scroll-hidden-update-keeps-the-visible-window ()
|
|
"Updating a scrolled-away node should not reuse its stale buffer spans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (180) :height 2 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "target" :width (120) :height 1
|
|
:box-sizing border-box :padding-left (2))
|
|
(box :content "row 1" :height 1)
|
|
(box :content "row 2" :height 1)
|
|
(box :content "row 3" :height 1)
|
|
(box :content "row 4" :height 1)))))
|
|
root-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(should (ebox--scroll-region-by root-id 3 48))
|
|
(let ((visible-before
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(ebox-region-update target-id :padding-left (list 12))
|
|
(should (equal visible-before
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (= (plist-get report :patch-count) 1)))
|
|
(should-not
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(let ((visible-before
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(ebox-region-update target-id :width (list 400))
|
|
(should (equal visible-before
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'root-rerender))
|
|
(should (plist-get report :root-rerender))
|
|
(should (plist-get report :scroll-state-patch)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should (ebox--scroll-region-by root-id -3 48))
|
|
(should
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-nested-scroll-hidden-geometry-replays-both-caches ()
|
|
"A hidden inner-scroll update should survive inner and outer replay."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (180) :height 1 :overflow scroll
|
|
(column
|
|
(box :id "wrapper" :width (180) :height 1 :overflow scroll
|
|
(column
|
|
(box :id "target" :content "target" :width (120)
|
|
:height 1 :box-sizing border-box
|
|
:padding-left (2))
|
|
(box :content "inner tail" :height 1)))
|
|
(box :content "outer tail" :height 1)))))
|
|
root-id wrapper-id target-id)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq wrapper-id
|
|
(ebox-test--selector-region-id (current-buffer) "#wrapper"))
|
|
(setq target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(should (ebox--scroll-region-by wrapper-id 1 48))
|
|
(should-not
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(let ((visible-before
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(ebox-region-update target-id :padding-left (list 12))
|
|
(should (equal visible-before
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max)))))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'root-rerender))
|
|
(should (plist-get report :root-rerender))
|
|
(should (plist-get report :scroll-state-patch)))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should (ebox--scroll-region-by root-id 1 48))
|
|
(should (ebox--scroll-region-by root-id -1 48))
|
|
(should-not
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p))
|
|
(should (ebox--scroll-region-by wrapper-id -1 48))
|
|
(should
|
|
(text-property-any
|
|
(point-min) (point-max) 'ebox-content target-id))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))
|
|
|
|
(ert-deftest ebox-scroll-hot-rendered-lookup-uses-content-line-hints ()
|
|
"A deferred rendered index should inspect target lines, not the full prefix."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content-lines
|
|
(cl-loop for index below 100
|
|
collect (propertize (format "row %d" index)
|
|
'ebox-content index)))
|
|
(rendered-lines (mapcar #'copy-sequence content-lines))
|
|
(state (let ((ebox--defer-scroll-content-index t))
|
|
(ebox--scroll-state-set-lines
|
|
nil content-lines rendered-lines)))
|
|
(content-index
|
|
(ebox--scroll-build-region-line-span-index content-lines))
|
|
(full-builds 0)
|
|
(full-scans 0)
|
|
(membership-builds 0)
|
|
(hint-scans 0))
|
|
(plist-put state :region-line-span-index content-index)
|
|
(plist-put state :region-line-span-index-deferred nil)
|
|
(let ((original-build
|
|
(symbol-function 'ebox--scroll-build-region-line-span-index))
|
|
(original-scan
|
|
(symbol-function 'ebox--scroll-state-region-line-spans))
|
|
(original-membership-build
|
|
(symbol-function 'ebox--scroll-build-content-region-id-set))
|
|
(original-hint-scan
|
|
(symbol-function 'ebox--scroll-line-spans-at-index-hints)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf full-builds)
|
|
(apply original-build args)))
|
|
((symbol-function 'ebox--scroll-state-region-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf full-scans)
|
|
(apply original-scan args)))
|
|
((symbol-function 'ebox--scroll-build-content-region-id-set)
|
|
(lambda (&rest args)
|
|
(cl-incf membership-builds)
|
|
(apply original-membership-build args)))
|
|
((symbol-function 'ebox--scroll-line-spans-at-index-hints)
|
|
(lambda (&rest args)
|
|
(cl-incf hint-scans)
|
|
(apply original-hint-scan args))))
|
|
(let* ((content-spans
|
|
(ebox--scroll-hot-content-line-spans state '(70)))
|
|
(rendered-spans
|
|
(ebox--scroll-hot-rendered-line-spans
|
|
state '(70) content-spans)))
|
|
(should (= (caar content-spans) 70))
|
|
(should (= (caar rendered-spans) 70)))))
|
|
(should (= full-builds 0))
|
|
(should (= full-scans 0))
|
|
(should (= membership-builds 0))
|
|
(should (= hint-scans 0))
|
|
(should-not (plist-get state :rendered-region-line-span-index))
|
|
(should (plist-get state :rendered-region-line-span-index-deferred))))
|
|
|
|
(ert-deftest ebox-hidden-scroll-child-content-update-reuses-prebuilt-index ()
|
|
"Hidden scroll child updates should reuse a prebuilt line index."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((children (cl-loop for idx below 80
|
|
collect `(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1)))
|
|
(layout (ebox-build
|
|
`(box :id "root" :height 2 :overflow scroll
|
|
(column ,@children))))
|
|
root-id target-id
|
|
(scan-calls 0)
|
|
(build-index-calls 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq root-id (ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(setq target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#row-70"))
|
|
(setq next-target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#row-71"))
|
|
(let ((original (symbol-function 'ebox--scroll-state-region-line-spans))
|
|
(original-build
|
|
(symbol-function 'ebox--scroll-build-region-line-span-index)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-state-region-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf scan-calls)
|
|
(apply original args)))
|
|
((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-index-calls)
|
|
(apply original-build args))))
|
|
(ebox-region-update target-id :content "new 70")))
|
|
(should (= scan-calls 0))
|
|
(should (= build-index-calls 0))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))
|
|
(should (plist-get report :scroll-state-index)))
|
|
(let ((original (symbol-function 'ebox--scroll-state-region-line-spans))
|
|
(original-build
|
|
(symbol-function 'ebox--scroll-build-region-line-span-index)))
|
|
(cl-letf (((symbol-function 'ebox--scroll-state-region-line-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf scan-calls)
|
|
(apply original args)))
|
|
((symbol-function 'ebox--scroll-build-region-line-span-index)
|
|
(lambda (&rest args)
|
|
(cl-incf build-index-calls)
|
|
(apply original-build args))))
|
|
(ebox-region-update next-target-id :content "alt 71")))
|
|
(should (= scan-calls 0))
|
|
(should (= build-index-calls 0))
|
|
(should (ebox--scroll-region-by root-id 70))
|
|
(let ((visible
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "new 70" visible))
|
|
(should (string-match-p "alt 71" visible))))))
|
|
|
|
(ert-deftest ebox-hidden-scroll-child-visibility-check-skips-live-extents ()
|
|
"Hidden scroll child updates should not force buffer-wide live extent scans."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((children (cl-loop for idx below 80
|
|
collect `(box :id ,(format "row-%02d" idx)
|
|
:content ,(format "row %02d" idx)
|
|
:height 1)))
|
|
(layout (ebox-build
|
|
`(box :id "root" :height 2 :overflow scroll
|
|
(column ,@children))))
|
|
target-id
|
|
(live-extents-calls 0)
|
|
(property-scan-calls 0)
|
|
(original (symbol-function 'ebox--live-box-extents))
|
|
(original-property-scan
|
|
(symbol-function 'ebox--region-ids-visible-by-property-scan-p)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(setq target-id (ebox-test--selector-region-id (current-buffer)
|
|
"#row-70"))
|
|
(should (hash-table-p (ebox-buffer--region-role-span-table)))
|
|
(cl-letf (((symbol-function 'ebox--live-box-extents)
|
|
(lambda (&rest args)
|
|
(cl-incf live-extents-calls)
|
|
(apply original args)))
|
|
((symbol-function 'ebox--region-ids-visible-by-property-scan-p)
|
|
(lambda (&rest args)
|
|
(cl-incf property-scan-calls)
|
|
(apply original-property-scan args))))
|
|
(ebox-region-update target-id :content "new 70"))
|
|
(should (= live-extents-calls 0))
|
|
(should (= property-scan-calls 0))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scroll-state-patch))))))
|
|
|
|
(ert-deftest ebox-small-geometry-span-patch-refreshes-indexes-scoped ()
|
|
"Small geometry span patches should not rebuild all buffer runtime indexes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout (ebox-test--dynamic-update-row-layout))
|
|
(full-extents 0)
|
|
(full-roles 0)
|
|
(full-scroll 0)
|
|
(scoped-property-scans 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id (current-buffer)
|
|
"#margin"))
|
|
(original-scoped-scan
|
|
(symbol-function
|
|
'ebox--refresh-box-extents-for-region-ids-in-spans)))
|
|
(cl-letf (((symbol-function 'ebox--refresh-buffer-box-extents)
|
|
(lambda (&rest _args)
|
|
(cl-incf full-extents)
|
|
nil))
|
|
((symbol-function 'ebox-buffer-refresh-region-role-spans)
|
|
(lambda (&rest _args)
|
|
(cl-incf full-roles)
|
|
nil))
|
|
((symbol-function 'ebox--refresh-buffer-scroll-content-markers)
|
|
(lambda (&rest _args)
|
|
(cl-incf full-scroll)
|
|
nil))
|
|
((symbol-function
|
|
'ebox--refresh-box-extents-for-region-ids-in-spans)
|
|
(lambda (&rest args)
|
|
(cl-incf scoped-property-scans)
|
|
(apply original-scoped-scan args))))
|
|
(ebox-region-update region-id :margin-left (list 20)))
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (eq (plist-get report :strategy) 'span-patch))
|
|
(should (plist-get report :scoped-index-refresh))
|
|
(should (= full-extents 0))
|
|
(should (= full-roles 0))
|
|
(should (= full-scroll 0))
|
|
(should (= scoped-property-scans 0))
|
|
(should (ebox-test--buffer-visually-matches-runtime-render-p)))))))
|
|
|
|
(ert-deftest ebox-wheel-scroll-uses-buffer-scroll-region-without-point ()
|
|
"Wheel events from fringe-like areas should still scroll the ebox page."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 2 :overflow scroll
|
|
(column
|
|
(box :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout)))
|
|
mwheel-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(switch-to-buffer (current-buffer))
|
|
(cl-letf (((symbol-function 'event-start)
|
|
(lambda (_event)
|
|
(list (selected-window) 'mode-line '(0 . 0)
|
|
0 nil nil nil nil nil nil)))
|
|
((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest _args)
|
|
(setq mwheel-called t))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1))
|
|
(should-not mwheel-called)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))))))
|
|
|
|
(ert-deftest ebox-scroll-first-region-ignores-zero-consumption ()
|
|
"A zero-line scroll result should not consume the scroll event."
|
|
(let (visited)
|
|
(cl-letf (((symbol-function 'ebox--scroll-region-by)
|
|
(lambda (region-id _delta &optional _prefix-budget-lines)
|
|
(push region-id visited)
|
|
(if (eq region-id 'stalled) 0 1))))
|
|
(should (ebox--scroll-first-region-by '(stalled active) 1)))
|
|
(should (equal (nreverse visited) '(stalled active)))))
|
|
|
|
(ert-deftest ebox-scroll-progress-requires-real-delta-or-pending ()
|
|
"Scroll progress is either a non-zero consumed line count or lazy pending."
|
|
(should (ebox--scroll-progress-p 1))
|
|
(should (ebox--scroll-progress-p -1))
|
|
(should (ebox--scroll-progress-p 'pending))
|
|
(should-not (ebox--scroll-progress-p 0))
|
|
(should-not (ebox--scroll-progress-p nil)))
|
|
|
|
(ert-deftest ebox-smooth-wheel-scroll-moves-immediately-then-drains ()
|
|
"Smooth wheel scrolling should respond immediately and drain pending lines."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 60.0))
|
|
(should (ebox--smooth-scroll-region-by root-id 2))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(ebox--smooth-scroll-tick root-id)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
2))
|
|
(should-not (gethash root-id ebox--smooth-scroll-state-table))))))
|
|
|
|
(ert-deftest ebox-smooth-wheel-scroll-coalesces-while-timer-active ()
|
|
"Further wheel input should queue behind the active timer, not edit at once."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 60.0))
|
|
(should (ebox--smooth-scroll-region-by root-id 2))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(should (gethash root-id ebox--smooth-scroll-state-table))
|
|
(should (ebox--smooth-scroll-region-by root-id 2))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(while (gethash root-id ebox--smooth-scroll-state-table)
|
|
(ebox--smooth-scroll-tick root-id))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
3))))))
|
|
|
|
(ert-deftest ebox-smooth-wheel-scroll-clamps-pending-to-range ()
|
|
"Large smooth wheel input should not leave an oversized timer backlog."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 1 :overflow scroll
|
|
(column
|
|
(box :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((ebox-wheel-smooth-scroll-lines-per-tick 1)
|
|
(ebox-wheel-smooth-scroll-interval 60.0))
|
|
(should (ebox--smooth-scroll-region-by root-id 1000))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(should (<= (plist-get
|
|
(gethash root-id ebox--smooth-scroll-state-table)
|
|
:pending)
|
|
2))
|
|
(while (gethash root-id ebox--smooth-scroll-state-table)
|
|
(ebox--smooth-scroll-tick root-id))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
3))))))
|
|
|
|
(ert-deftest ebox-page-scroll-bubbles-from-child-to-scrollable-ancestor ()
|
|
"Page scrolling over a child box should scroll the nearest scrollable ancestor."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height 3 :overflow scroll
|
|
(column
|
|
(box :id "child" :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1)
|
|
(box :content "E" :height 1)
|
|
(box :content "F" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout)))
|
|
fallback-called)
|
|
(ebox-test--with-rendered-buffer layout
|
|
(goto-char (point-min))
|
|
(search-forward "A")
|
|
(backward-char)
|
|
(cl-letf (((symbol-function 'window-body-height)
|
|
(lambda (&optional _window _pixelwise) 5))
|
|
((symbol-function 'scroll-up-command)
|
|
(lambda (&optional _arg)
|
|
(setq fallback-called t))))
|
|
(ebox-scroll-page-down))
|
|
(should-not fallback-called)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
3))
|
|
(let ((plain (buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (string-match-p "D" plain))
|
|
(should (string-match-p "F" plain))
|
|
(should-not (string-match-p "A" plain))))))
|
|
|
|
(ert-deftest ebox-scroll-rerender-preserves-viewport-height-context ()
|
|
"Scroll rerender fallback should keep viewport-height boxes clipped."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "root" :height (viewport-height) :overflow scroll
|
|
(column
|
|
(box :id "child" :content "A" :height 1)
|
|
(box :content "B" :height 1)
|
|
(box :content "C" :height 1)
|
|
(box :content "D" :height 1)))))
|
|
(root-id (car (ebox-region-ids layout))))
|
|
(let ((ebox-viewport-height 2))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:content-height)
|
|
2))
|
|
(goto-char (point-min))
|
|
(search-forward "A")
|
|
(backward-char)
|
|
(ebox-scroll-down 1)
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:content-height)
|
|
2))
|
|
(should (= (plist-get (ebox--scroll-get-state root-id)
|
|
:scroll-offset)
|
|
1))
|
|
(let ((plain (buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(should (string-match-p "B" plain))
|
|
(should (string-match-p "C" plain))
|
|
(should-not (string-match-p "A" plain)))))))
|
|
|
|
(ert-deftest ebox-wheel-scroll-falls-back-at-scroll-boundary ()
|
|
"Mouse wheel should bubble to the buffer when inner scroll is at its edge."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC"
|
|
:height 1
|
|
:overflow 'scroll))
|
|
(region-id (car (ebox-region-ids box)))
|
|
mwheel-args)
|
|
(ebox-test--with-rendered-buffer box
|
|
(should (ebox--scroll-region-by region-id 3))
|
|
(cl-letf (((symbol-function 'ebox--wheel-region-ids)
|
|
(lambda (_event) (list region-id)))
|
|
((symbol-function 'mwheel-scroll)
|
|
(lambda (&rest args)
|
|
(setq mwheel-args args))))
|
|
(ebox--wheel-scroll 'fake-wheel-event 1 'fake-arg))
|
|
(should (equal mwheel-args '(fake-wheel-event fake-arg))))))
|
|
|
|
(ert-deftest ebox-scroll-map-keeps-wheel-on-event-aware-handler ()
|
|
"Mouse wheel bindings should use event-aware handlers, not line fallbacks."
|
|
(should (eq (lookup-key ebox-scroll-map [wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map [wheel-up])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (lookup-key ebox-scroll-map [mouse-5])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map [mouse-4])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (lookup-key ebox-scroll-map [right-fringe wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map [right-fringe wheel-up])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (lookup-key ebox-scroll-map [mode-line wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map [mode-line wheel-up])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (lookup-key ebox-scroll-map [vertical-scroll-bar wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map [vertical-scroll-bar wheel-up])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (lookup-key ebox-scroll-map [remap scroll-up-command])
|
|
#'ebox-scroll-page-down))
|
|
(should (eq (lookup-key ebox-scroll-map [remap scroll-down-command])
|
|
#'ebox-scroll-page-up))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "C-v"))
|
|
#'ebox-scroll-page-down))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "<next>"))
|
|
#'ebox-scroll-page-down))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "M-v"))
|
|
#'ebox-scroll-page-up))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "<prior>"))
|
|
#'ebox-scroll-page-up))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "n"))
|
|
#'ebox-scroll-down))
|
|
(should (eq (lookup-key ebox-scroll-map (kbd "p"))
|
|
#'ebox-scroll-up)))
|
|
|
|
(ert-deftest ebox-buffer-mode-overrides-pixel-scroll-bindings ()
|
|
"Ebox buffers should keep their own scroll bindings under pixel scrolling."
|
|
(unless (fboundp 'pixel-scroll-precision-mode)
|
|
(ert-skip "pixel-scroll-precision-mode is unavailable"))
|
|
(let ((was-enabled pixel-scroll-precision-mode))
|
|
(unwind-protect
|
|
(with-temp-buffer
|
|
(pixel-scroll-precision-mode 1)
|
|
(ebox-buffer-mode 1)
|
|
(should (eq (key-binding [wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (key-binding [wheel-up])
|
|
#'ebox-wheel-scroll-up))
|
|
(should (eq (key-binding [right-fringe wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (key-binding [mode-line wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (key-binding [vertical-scroll-bar wheel-down])
|
|
#'ebox-wheel-scroll-down))
|
|
(should (eq (key-binding (kbd "<next>"))
|
|
#'ebox-scroll-page-down))
|
|
(should (eq (key-binding (kbd "<prior>"))
|
|
#'ebox-scroll-page-up)))
|
|
(unless was-enabled
|
|
(pixel-scroll-precision-mode -1)))))
|
|
|
|
(ert-deftest ebox-border-box-max-height-includes-vertical-padding ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A\nB\nC\nD"
|
|
:box-sizing 'border-box
|
|
:max-height 3
|
|
:padding '(1 0)
|
|
:overflow 'hidden))
|
|
(plain (substring-no-properties (ebox-render box))))
|
|
(should (= (ebox-string-height plain) 3))
|
|
(should-not (string-match-p "C" plain))
|
|
(should-not (string-match-p "D" plain))))
|
|
|
|
(ert-deftest ebox-content-box-min-height-wins-when-min-exceeds-max ()
|
|
"Content-box height conflicts should use the minimum as the used height."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A"
|
|
:box-sizing 'content-box
|
|
:min-height 5
|
|
:max-height 3
|
|
:padding '(1 0)
|
|
:overflow 'hidden))
|
|
(rendered (ebox-render box)))
|
|
(should (= (ebox--content-height box 1) 5))
|
|
(should (= (ebox-string-height rendered) 7))))
|
|
|
|
(ert-deftest ebox-border-box-min-height-wins-when-min-exceeds-max ()
|
|
"Border-box height conflicts should use the minimum as the outer height."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "A"
|
|
:box-sizing 'border-box
|
|
:min-height 5
|
|
:max-height 3
|
|
:padding '(1 0)
|
|
:overflow 'hidden))
|
|
(rendered (ebox-render box)))
|
|
(should (= (ebox--content-height box 1) 3))
|
|
(should (= (ebox-string-height rendered) 5))))
|
|
|
|
(ert-deftest ebox-border-box-max-width-includes-horizontal-padding-and-border ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((box (ebox-create :content "abc abc abc abc abc abc abc abc abc abc"
|
|
:box-sizing 'border-box
|
|
:max-width '(100)
|
|
:padding-inline '(20)
|
|
:border-left '(10)
|
|
:border-right '(10)
|
|
:overflow 'hidden)))
|
|
(should (<= (ebox--total-pixel box) 100))))
|
|
|
|
(ert-deftest ebox-auto-width-without-viewport-uses-max-content-across-all-lines ()
|
|
"Omitted :width should fall back to the widest unwrapped content line."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "short\nmuch wider line")
|
|
(expected (apply #'max
|
|
(mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines content))))
|
|
(box (ebox-create :content content))
|
|
(rendered (ebox-render box))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines rendered))))
|
|
(should (= (ebox--content-pixel box) expected))
|
|
(should (cl-every (lambda (width) (= width expected)) widths))))
|
|
|
|
(ert-deftest ebox-auto-width-stretches-to-viewport-when-available ()
|
|
"Omitted :width and :width auto should fill the viewport margin box."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 240))
|
|
(dolist (width-value '(nil auto))
|
|
(let ((box (apply #'ebox-create
|
|
(append (list :content "short line wraps into viewport"
|
|
:padding-inline '(20)
|
|
:border-left '(10)
|
|
:border-right '(10)
|
|
:margin-inline '(5))
|
|
(when width-value
|
|
(list :width width-value))))))
|
|
(should (= (ebox--total-pixel box) 240))))))
|
|
|
|
(ert-deftest ebox-explicit-width-can-overflow-containing-block ()
|
|
"A definite width remains definite even when the containing block is narrower."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 120)
|
|
(content "alpha beta gamma delta")
|
|
(box (ebox-create :content content :width '(220) :wrap-mode 'word))
|
|
(rendered (ebox-render box))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines rendered))))
|
|
(should (cl-some (lambda (width) (> width ebox-viewport-width))
|
|
widths))
|
|
(should (cl-every (lambda (width) (= width 220)) widths))))
|
|
|
|
(ert-deftest ebox-column-wrapper-width-reflows-auto-child-layout ()
|
|
"A column wrapper width should contain auto-sized children."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 1000)
|
|
(node (ebox-build
|
|
'(column :width (120)
|
|
(box :content "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega"
|
|
:wrap-mode word))))
|
|
(rendered (ebox-render node))
|
|
(plain (substring-no-properties rendered))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines rendered))))
|
|
(should (cl-every (lambda (width) (<= width 120)) widths))
|
|
(dolist (word '("alpha" "beta" "gamma" "delta" "epsilon" "theta"
|
|
"omega"))
|
|
(should (string-match-p word plain)))
|
|
(should (> (ebox-string-height rendered) 1))))
|
|
|
|
(ert-deftest ebox-wrapper-child-layout-keeps-pixel-width-with-wide-font ()
|
|
"Engine pixel widths must not be reparsed as public character widths."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 1000))
|
|
(cl-letf (((symbol-function 'ebox--space-pixel-width) (lambda () 7)))
|
|
(let* ((node (ebox-build
|
|
'(column :width (400)
|
|
(box :content "X"))))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines (ebox-render node)))))
|
|
(should (equal widths '(400)))))))
|
|
|
|
(ert-deftest ebox-column-wrapper-width-reflows-auto-flex-layout ()
|
|
"A column wrapper width should become the viewport for nested auto flex."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 1000)
|
|
(node (ebox-build
|
|
'(column :width (240)
|
|
(flex :flex-wrap wrap :column-gap (10)
|
|
(box :content "A" :width (100))
|
|
(box :content "B" :width (100))
|
|
(box :content "C" :width (100))))))
|
|
(rendered (ebox-render node))
|
|
(plain-lines (ebox-string-lines
|
|
(substring-no-properties rendered)))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines rendered))))
|
|
(should (cl-every (lambda (width) (<= width 240)) widths))
|
|
(should (string-match-p "A.*B" (car plain-lines)))
|
|
(should (cl-some (lambda (line) (string-match-p "C" line))
|
|
(cdr plain-lines)))))
|
|
|
|
(ert-deftest ebox-column-containing-block-does-not-expand-to-overflow-child ()
|
|
"An overflowing definite child should not widen unrelated column rows."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 200)
|
|
(node (ebox-column
|
|
(ebox-create :content "Auto row")
|
|
(ebox-create :content "Fixed row" :width '(300))))
|
|
(widths (mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines (ebox-render node)))))
|
|
(should (equal widths '(200 300)))))
|
|
|
|
(ert-deftest ebox-width-keywords-resolve-intrinsic-content-sizes ()
|
|
"auto, min-content, max-content, and none should keep CSS-like meanings."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "aa bbbb")
|
|
(max-content (ebox--string-pixel-width content))
|
|
(min-content (ebox--string-pixel-width "bbbb")))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content :width 'auto))
|
|
max-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content :width 'max-content))
|
|
max-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content :width 'min-content))
|
|
min-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width '(80)
|
|
:max-width 'none))
|
|
80))
|
|
(should-error (ebox-create :content content :width 'none)
|
|
:type 'error)))
|
|
|
|
(ert-deftest ebox-max-content-wrapper-measures-composite-child-intrinsically ()
|
|
"A max-content wrapper should not stretch its composite child to the viewport."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((ebox-viewport-width 480)
|
|
(lines '("Compact" "Natural width"))
|
|
(expected
|
|
(apply #'max (mapcar #'ebox--string-pixel-width lines)))
|
|
(node
|
|
(ebox-create
|
|
:width 'max-content
|
|
:ebox-content-node
|
|
(apply #'ebox-column
|
|
(mapcar (lambda (line)
|
|
(ebox-create :content line))
|
|
lines))))
|
|
(widths
|
|
(mapcar #'ebox--string-pixel-width
|
|
(ebox-string-lines (ebox-render node)))))
|
|
(should (equal widths (make-list (length lines) expected)))))
|
|
|
|
(ert-deftest ebox-definite-width-skips-unused-max-content-measurement ()
|
|
"A definite preferred width should not evaluate its unused auto fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((box (ebox-create :content "measurement must stay cold"
|
|
:width '(80)))
|
|
(measurements 0)
|
|
(original (symbol-function 'ebox--content-max-pixel)))
|
|
(cl-letf (((symbol-function 'ebox--content-max-pixel)
|
|
(lambda (candidate)
|
|
(cl-incf measurements)
|
|
(funcall original candidate))))
|
|
(should (= (ebox--content-pixel box) 80))
|
|
(should (= measurements 0)))))
|
|
|
|
(ert-deftest ebox-definite-width-still-resolves-intrinsic-constraints ()
|
|
"Intrinsic min/max constraints must still measure definite-width content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "intrinsic constraint")
|
|
(expected (ebox--string-pixel-width content))
|
|
(box (ebox-create :content content
|
|
:width '(20)
|
|
:min-width 'max-content))
|
|
(measurements 0)
|
|
(original (symbol-function 'ebox--content-max-pixel)))
|
|
(cl-letf (((symbol-function 'ebox--content-max-pixel)
|
|
(lambda (candidate)
|
|
(cl-incf measurements)
|
|
(funcall original candidate))))
|
|
(should (= (ebox--content-pixel box) expected))
|
|
(should (= measurements 1)))))
|
|
|
|
(ert-deftest ebox-auto-width-keeps-max-content-fallback-without-viewport ()
|
|
"An unresolved auto width should retain its intrinsic max-content fallback."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((box (ebox-create :content "auto fallback"))
|
|
(measurements 0)
|
|
(original (symbol-function 'ebox--content-max-pixel)))
|
|
(cl-letf (((symbol-function 'ebox--content-max-pixel)
|
|
(lambda (candidate)
|
|
(cl-incf measurements)
|
|
(funcall original candidate))))
|
|
(should (> (ebox--content-pixel box) 0))
|
|
(should (= measurements 1)))))
|
|
|
|
(ert-deftest ebox-fit-content-width-clamps-between-min-and-max-content ()
|
|
"fit-content() should clamp by min-content and max-content."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "aa widest")
|
|
(min-content (ebox--string-pixel-width "widest"))
|
|
(max-content (ebox--string-pixel-width content))
|
|
(between (+ min-content (/ (- max-content min-content) 2))))
|
|
(should (< min-content between))
|
|
(should (< between max-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width (list 'fit-content (list between))))
|
|
between))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width (list 'fit-content (list 1))))
|
|
min-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width (list 'fit-content
|
|
(list (+ max-content 50)))))
|
|
max-content))))
|
|
|
|
(ert-deftest ebox-fit-content-keyword-uses-stretch-when-viewport-is-definite ()
|
|
"The fit-content keyword should clamp stretch between intrinsic sizes."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "aa widest")
|
|
(min-content (ebox--string-pixel-width "widest"))
|
|
(max-content (ebox--string-pixel-width content))
|
|
(stretch (+ min-content (/ (- max-content min-content) 2)))
|
|
(ebox-viewport-width stretch))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content :width 'fit-content))
|
|
stretch))))
|
|
|
|
(ert-deftest ebox-min-and-max-width-keywords-constrain-preferred-width ()
|
|
"Intrinsic keywords should work on min-width and max-width too."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "aa widest")
|
|
(min-content (ebox--string-pixel-width "widest"))
|
|
(max-content (ebox--string-pixel-width content))
|
|
(between (+ min-content (/ (- max-content min-content) 2))))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width '(1)
|
|
:min-width 'max-content))
|
|
max-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width (list (+ max-content 50))
|
|
:max-width 'min-content))
|
|
min-content))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width '(1)
|
|
:min-width (list 'fit-content
|
|
(list between))))
|
|
between))
|
|
(should (= (ebox--content-pixel
|
|
(ebox-create :content content
|
|
:width (list (+ max-content 50))
|
|
:max-width (list 'fit-content
|
|
(list between))))
|
|
between))))
|
|
|
|
(ert-deftest ebox-stretch-and-contain-width-fill-viewport-margin-box ()
|
|
"stretch and contain should resolve against the current viewport."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox-viewport-width 240))
|
|
(dolist (keyword '(stretch contain))
|
|
(let ((box (ebox-create :content "x"
|
|
:width keyword
|
|
:padding-inline '(20)
|
|
:border-left '(10)
|
|
:border-right '(10)
|
|
:margin-inline '(5))))
|
|
(should (= (ebox--total-pixel box) 240))))))
|
|
|
|
(ert-deftest ebox-max-width-clamps-used-width-before-content-minimum ()
|
|
"A max-width smaller than one glyph should constrain used width."
|
|
(ebox-test--reset-runtime-state)
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (_string) 60))
|
|
((symbol-function 'ebox--max-char-pixel)
|
|
(lambda (_string) 60)))
|
|
(let ((box (ebox-create :content "W"
|
|
:max-width '(20)
|
|
:wrap-mode 'char)))
|
|
(should (= (ebox--content-pixel box) 20))
|
|
(should (= (ebox--total-pixel box) 20)))))
|
|
|
|
(ert-deftest ebox-min-width-wins-when-min-width-exceeds-max-width ()
|
|
"CSS width constraints make min-width override max-width conflicts."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((box (ebox-create :content "short"
|
|
:width '(40)
|
|
:min-width '(120)
|
|
:max-width '(80))))
|
|
(should (= (ebox--content-pixel box) 120))
|
|
(should (= (ebox--total-pixel box) 120))))
|
|
|
|
(ert-deftest ebox-width-properties-reject-negative-values ()
|
|
"Width, min-width, and max-width should reject negative lengths."
|
|
(ebox-test--reset-runtime-state)
|
|
(should-error (ebox-create :content "bad" :width '(-1)) :type 'error)
|
|
(should-error (ebox-create :content "bad" :min-width '(-1)) :type 'error)
|
|
(should-error (ebox-create :content "bad" :max-width '(-1)) :type 'error))
|
|
|
|
(ert-deftest ebox-edge-properties-reject-negative-values ()
|
|
"Public edge properties and engine longhands should reject negatives."
|
|
(ebox-test--reset-runtime-state)
|
|
(dolist (props '((:padding -1)
|
|
(:padding-left-pixel -1)
|
|
(:margin -1)
|
|
(:margin-top-height -1)
|
|
(:border-width -1)
|
|
(:border-top-width -1)
|
|
(:border-left-pixel -1)))
|
|
(should-error
|
|
(apply #'ebox-create (append '(:content "bad") props))
|
|
:type 'error)))
|
|
|
|
(ert-deftest ebox-line-min-content-skips-discarded-space-measurements ()
|
|
"Literal spaces split runs and plain ASCII reuses exact character widths."
|
|
(let ((line (copy-sequence "fi x"))
|
|
(ebox--display-cache-validated t)
|
|
(ebox--char-width-cache (make-hash-table :test 'eql))
|
|
measured)
|
|
(puthash ?i 4 ebox--char-width-cache)
|
|
(add-text-properties 0 1 '(face (:height 1.2)) line)
|
|
(add-text-properties 3 4 '(display (raise 0.1)) line)
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (string)
|
|
(push (substring-no-properties string) measured)
|
|
(pcase (substring-no-properties string)
|
|
("f" 3)
|
|
("x" 2)
|
|
(" " 99)
|
|
(_ 99)))))
|
|
;; Per-grapheme addition remains intentional: measuring the whole "fi"
|
|
;; could produce a non-additive ligature width and change the contract.
|
|
(should (= (ebox--line-min-content-pixel line) 7))
|
|
(should (equal (nreverse measured) '("f" "x"))))))
|
|
|
|
(ert-deftest ebox-region-update-valid-paint-and-invalid-edge-is-atomic ()
|
|
"Invalid geometry should fail before a valid sibling property mutates."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((box (ebox-create :content "Atomic"
|
|
:width '(120)
|
|
:bgcolor "#111111"
|
|
:padding-left-pixel 2))
|
|
(region-id (car (ebox-region-ids box))))
|
|
(ebox-test--with-rendered-buffer box
|
|
(should-error
|
|
(ebox-region-update region-id
|
|
:bgcolor "#222222"
|
|
:padding-left-pixel -1)
|
|
:type 'error)
|
|
(should (equal (ebox-get box :bgcolor) "#111111"))
|
|
(should (= (ebox-get box :padding-left-pixel) 2)))))
|
|
|
|
(ert-deftest ebox-region-update-no-op-skips-rollback-snapshot ()
|
|
"A legal no-op should return before discovering rollback scope."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (240) :height 1 :overflow scroll
|
|
(box :id "target" :content "same" :width (120))))))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target")))
|
|
(cl-letf
|
|
(((symbol-function 'ebox--node-all-region-ids)
|
|
(lambda (&rest _)
|
|
(ert-fail "no-op discovered subtree rollback scope")))
|
|
((symbol-function
|
|
'ebox--scroll-state-region-ids-containing-node-ids)
|
|
(lambda (&rest _)
|
|
(ert-fail "no-op discovered containing scroll scope"))))
|
|
(let ((report
|
|
(ebox-region-update target-id :content "same")))
|
|
(should (eq (plist-get report :strategy) 'no-op))
|
|
(should (= (plist-get report :dirty-count) 0))))))))
|
|
|
|
(ert-deftest ebox-region-update-rollback-snapshot-keeps-scroll-owner-box-by-identity ()
|
|
"A child rollback snapshot should retain its scroll owner's box identity."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(box :id "target" :content "paint" :width (120)
|
|
:color "#111111")
|
|
(box :content "tail" :width (120)))))))
|
|
(let ((ebox-viewport-width 240)
|
|
(ebox-viewport-height 1))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((root-id
|
|
(ebox-test--selector-region-id (current-buffer) "#root"))
|
|
(target-id
|
|
(ebox-test--selector-region-id (current-buffer) "#target"))
|
|
(scroll-box
|
|
(plist-get (ebox--scroll-get-state root-id) :box))
|
|
(original-copy-tree (symbol-function 'copy-tree)))
|
|
(should scroll-box)
|
|
(cl-letf
|
|
(((symbol-function 'copy-tree)
|
|
(lambda (tree &optional vectors-and-records)
|
|
(when (eq tree scroll-box)
|
|
(ert-fail "deep-copied containing scroll owner box"))
|
|
(funcall original-copy-tree tree vectors-and-records))))
|
|
(ebox-region-update target-id :color "#222222"))
|
|
(should (equal
|
|
(ebox-get
|
|
(gethash target-id ebox--region-box-table) :color)
|
|
"#222222")))))))
|
|
|
|
(ert-deftest ebox-region-update-rolls-back-when-rerender-fails ()
|
|
"A failed local rerender must leave model, buffer, and report unchanged."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "target" :content "before" :width (120))))
|
|
(report-before 'keep-report))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(region-id (ebox-test--selector-region-id buffer "#target"))
|
|
(box (gethash region-id ebox--region-box-table))
|
|
(box-before (copy-tree box))
|
|
(text-before (buffer-string)))
|
|
(ebox-test--set-buffer-update-report buffer report-before)
|
|
(cl-letf (((symbol-function 'ebox--rerender-region-for-dirty-kind)
|
|
(lambda (&rest _)
|
|
(error "Injected rerender failure"))))
|
|
(should-error
|
|
(ebox-region-update region-id :content "after")
|
|
:type 'error))
|
|
(should (equal box box-before))
|
|
(should (equal-including-properties (buffer-string) text-before))
|
|
(should (eq (ebox-buffer-update-report buffer) report-before))))))
|
|
|
|
(ert-deftest ebox-region-update-rolls-back-after-scroll-sync-fails ()
|
|
"A post-publication scroll sync failure must roll back all published state."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "root" :width (viewport) :height (viewport-height)
|
|
:overflow scroll
|
|
(column :width (viewport)
|
|
(box :id "target" :content "before" :width (120) :height 1)
|
|
(box :content "tail" :width (120) :height 1)))))
|
|
(report-before 'keep-scroll-report))
|
|
(let ((ebox-viewport-width 260)
|
|
(ebox-viewport-height 2)
|
|
(ebox-scroll-lazy-prefix-lookahead-lines 0))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(root-id (ebox-test--selector-region-id buffer "#root"))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(target-box (gethash target-id ebox--region-box-table))
|
|
(target-box-before (copy-tree target-box))
|
|
(scroll-state-before (copy-tree (ebox--scroll-get-state root-id)))
|
|
(runtime-state (ebox--buffer-render-state buffer))
|
|
(runtime-root-before
|
|
(copy-tree (plist-get runtime-state :root-node)))
|
|
(runtime-revision-before
|
|
(plist-get runtime-state :runtime-revision))
|
|
(text-before (buffer-string)))
|
|
(ebox-test--set-buffer-update-report buffer report-before)
|
|
(cl-letf (((symbol-function 'ebox--sync-scroll-state-lines-for-node)
|
|
(lambda (&rest _)
|
|
(error "Injected scroll sync failure"))))
|
|
(should-error
|
|
(ebox-region-update target-id :content "after")
|
|
:type 'error))
|
|
(should (equal target-box target-box-before))
|
|
(should (equal (ebox--scroll-get-state root-id)
|
|
scroll-state-before))
|
|
(should (equal-including-properties (buffer-string) text-before))
|
|
(should (eq (ebox--buffer-render-state buffer) runtime-state))
|
|
(should (equal (plist-get runtime-state :root-node)
|
|
runtime-root-before))
|
|
(should (equal (plist-get runtime-state :runtime-revision)
|
|
runtime-revision-before))
|
|
(should (eq (ebox-buffer-update-report buffer)
|
|
report-before)))))))
|
|
|
|
(ert-deftest ebox-region-update-rolls-back-new-scroll-state-after-post-failure ()
|
|
"Rollback must tombstone scroll state created during a failed update."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout
|
|
(ebox-build
|
|
'(box :id "target" :content "before\nhidden" :width (120)
|
|
:height 1 :overflow visible)))
|
|
(report-before 'keep-new-scroll-report))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let* ((buffer (current-buffer))
|
|
(target-id (ebox-test--selector-region-id buffer "#target"))
|
|
(target-box (gethash target-id ebox--region-box-table))
|
|
(target-box-before (copy-tree target-box))
|
|
(runtime-state (ebox--buffer-render-state buffer))
|
|
(runtime-root-before
|
|
(copy-tree (plist-get runtime-state :root-node)))
|
|
(runtime-revision-before
|
|
(plist-get runtime-state :runtime-revision))
|
|
(text-before (buffer-string)))
|
|
(should-not (ebox--scroll-get-state target-id))
|
|
(ebox-test--set-buffer-update-report buffer report-before)
|
|
(cl-letf (((symbol-function 'ebox--schedule-buffer-runtime-prewarm)
|
|
(lambda (&rest _)
|
|
(error "Injected post-publication failure"))))
|
|
(should-error
|
|
(ebox-region-update target-id :overflow 'scroll)
|
|
:type 'error))
|
|
(should-not (ebox--scroll-get-state target-id))
|
|
(should (equal target-box target-box-before))
|
|
(should (equal-including-properties (buffer-string) text-before))
|
|
(should (eq (ebox--buffer-render-state buffer) runtime-state))
|
|
(should (equal (plist-get runtime-state :root-node)
|
|
runtime-root-before))
|
|
(should (equal (plist-get runtime-state :runtime-revision)
|
|
runtime-revision-before))
|
|
(should (eq (ebox-buffer-update-report buffer) report-before))))))
|
|
|
|
(ert-deftest ebox-region-update-success-path-uses-local-transaction-snapshot ()
|
|
"Successful local updates must not take full-buffer or global-table snapshots."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((layout (ebox-build
|
|
'(box :id "target" :content "before" :width (120))))
|
|
(buffer-string-calls 0)
|
|
(hash-key-calls 0)
|
|
(copy-hash-table-calls 0)
|
|
(original-buffer-string (symbol-function 'buffer-string))
|
|
(original-hash-keys (symbol-function 'ebox-incremental--hash-keys))
|
|
(original-copy-hash-table (symbol-function 'copy-hash-table)))
|
|
(ebox-test--with-rendered-buffer layout
|
|
(let ((region-id (ebox-test--selector-region-id
|
|
(current-buffer) "#target")))
|
|
(cl-letf (((symbol-function 'buffer-string)
|
|
(lambda ()
|
|
(cl-incf buffer-string-calls)
|
|
(funcall original-buffer-string)))
|
|
((symbol-function 'ebox-incremental--hash-keys)
|
|
(lambda (&rest args)
|
|
(cl-incf hash-key-calls)
|
|
(apply original-hash-keys args)))
|
|
((symbol-function 'copy-hash-table)
|
|
(lambda (&rest args)
|
|
(cl-incf copy-hash-table-calls)
|
|
(apply original-copy-hash-table args))))
|
|
(ebox-region-update region-id :content "after"))
|
|
(should (string-match-p
|
|
"after"
|
|
(buffer-substring-no-properties (point-min) (point-max))))
|
|
(should (= buffer-string-calls 0))
|
|
(should (= hash-key-calls 0))
|
|
(should (= copy-hash-table-calls 0))))))
|
|
|
|
(ert-deftest ebox-cjk-wraps-by-character-width-in-word-mode ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((content "你好世界")
|
|
(width (* 2 (ebox--string-pixel-width "你")))
|
|
(lines (ebox-string-lines
|
|
(substring-no-properties
|
|
(ebox-render
|
|
(ebox-create :content content
|
|
:width (list width)
|
|
:wrap-mode 'word))))))
|
|
(should (= (length lines) 2))
|
|
(should (string-prefix-p "你好" (nth 0 lines)))
|
|
(should (string-prefix-p "世界" (nth 1 lines)))
|
|
(dolist (line lines)
|
|
(should (<= (ebox--string-pixel-width line) width)))))
|
|
|
|
(ert-deftest ebox-wrap-keeps-combining-mark-with-base-character ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((cluster "é")
|
|
(text (concat cluster cluster))
|
|
(width (ebox--string-pixel-width cluster)))
|
|
(should (equal (mapcar #'substring-no-properties
|
|
(ebox--wrap-line text width 'char))
|
|
(list cluster cluster)))))
|
|
|
|
(ert-deftest ebox-word-wrap-skips-overflowing-separator-at-line-break ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((text "normal behaves stretch-like for auto cross size in this DSL.")
|
|
(width (ebox--string-pixel-width "stretch-like for"))
|
|
(lines (ebox--wrap-line text width 'word)))
|
|
(dolist (line lines)
|
|
(should (<= (ebox--string-pixel-width line) width)))
|
|
(should-not (cl-some (lambda (line)
|
|
(string-prefix-p " " line))
|
|
lines))))
|
|
|
|
(ert-deftest ebox-wrap-keeps-emoji-zwj-and-regional-indicator-clusters ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((family "👨👩👧👦")
|
|
(china "🇨🇳")
|
|
(usa "🇺🇸"))
|
|
(should (equal (mapcar #'substring-no-properties
|
|
(ebox--wrap-line (concat family family)
|
|
(ebox--string-pixel-width family)
|
|
'char))
|
|
(list family family)))
|
|
(should (equal (mapcar #'substring-no-properties
|
|
(ebox--wrap-line (concat china usa)
|
|
(ebox--string-pixel-width china)
|
|
'char))
|
|
(list china usa)))))
|
|
|
|
(ert-deftest ebox-kp-wrap-mode-invokes-ekp-justification ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let (require-called justify-args)
|
|
(cl-letf (((symbol-function 'require)
|
|
(lambda (feature &optional _filename _noerror)
|
|
(when (eq feature 'ekp)
|
|
(setq require-called t))
|
|
t))
|
|
((symbol-function 'ekp-pixel-justify)
|
|
(lambda (text width)
|
|
(setq justify-args (list text width))
|
|
text)))
|
|
(ebox-render (ebox-create :content "abc"
|
|
:width '(100)
|
|
:wrap-mode 'kp)))
|
|
(should require-called)
|
|
(should (equal justify-args (list "abc" 100)))))
|
|
|
|
(ert-deftest ebox-kp-wrap-mode-respects-text-align ()
|
|
"KP-wrapped lines should honor the box's horizontal text alignment."
|
|
(ebox-test--reset-runtime-state)
|
|
(cl-letf (((symbol-function 'require)
|
|
(lambda (feature &optional _filename _noerror)
|
|
(when (eq feature 'ekp) t)))
|
|
((symbol-function 'ekp-pixel-justify)
|
|
(lambda (&rest _)
|
|
"abc\nx")))
|
|
(dolist (align '(center right))
|
|
(let* ((box (ebox-create :content "ignored"
|
|
:width '(100)
|
|
:wrap-mode 'kp
|
|
:text-align align))
|
|
(width (ebox--content-pixel box))
|
|
(rendered (ebox-render box))
|
|
(line (car (ebox-string-lines rendered)))
|
|
(expected (ebox--pixel-reach "abc" width align)))
|
|
(should (equal (get-text-property 0 'display line)
|
|
(get-text-property 0 'display expected)))))))
|
|
|
|
(ert-deftest ebox-kp-wrap-preserves-content-width-for-ragged-lines ()
|
|
(ebox-test--reset-runtime-state)
|
|
(cl-letf (((symbol-function 'require)
|
|
(lambda (feature &optional _filename _noerror)
|
|
(when (eq feature 'ekp) t)))
|
|
((symbol-function 'ekp-pixel-justify)
|
|
(lambda (_text width)
|
|
(concat (ebox-pixel-space width) "\nshort"))))
|
|
(let* ((rendered (ebox-render
|
|
(ebox-create :content "ignored"
|
|
:width '(100)
|
|
:wrap-mode 'kp)))
|
|
(widths (mapcar #'ebox-string-pixel-width
|
|
(ebox-string-lines rendered))))
|
|
(should (equal widths '(100 100))))))
|
|
|
|
(ert-deftest ebox-content-face-keeps-foreground-and-background ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((rendered (ebox-render
|
|
(ebox-create :content "Face"
|
|
:width 40
|
|
:color "#abcdef"
|
|
:bgcolor "#123456")))
|
|
(face (ebox-test--first-content-face rendered)))
|
|
(should (ebox-test--face-has-key-value-p face :foreground "#abcdef"))
|
|
(should (ebox-test--face-has-key-value-p face :background "#123456"))))
|
|
|
|
(ert-deftest ebox-border-faces-keep-side-specific-properties ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((rendered (ebox-render
|
|
(ebox-create :content "Border"
|
|
:width 60
|
|
:padding '(1 1)
|
|
:border '(1 "#ff0000"))))
|
|
(left-face (ebox-test--face-at-property rendered 'ebox-bl))
|
|
(right-face (ebox-test--face-at-property rendered 'ebox-br))
|
|
(top-face (ebox-test--face-at-property rendered 'ebox-bt))
|
|
(bottom-face (ebox-test--face-at-property rendered 'ebox-bb)))
|
|
(should-not (ebox-test--face-has-key-p left-face :inverse-video))
|
|
(should (ebox-test--face-has-key-value-p left-face :background "#ff0000"))
|
|
(should-not (ebox-test--face-has-key-p right-face :inverse-video))
|
|
(should (ebox-test--face-has-key-value-p right-face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p top-face :overline "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
bottom-face
|
|
:underline
|
|
'(:position t :color "#ff0000")))))
|
|
|
|
(ert-deftest ebox-border-faces-omit-unspecified-frame-colors ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((original-frame-parameter (symbol-function 'frame-parameter)))
|
|
(dolist (sentinel '(unspecified unspecified-fg unspecified-bg
|
|
"unspecified" "unspecified-fg" "unspecified-bg"))
|
|
(cl-letf (((symbol-function 'frame-parameter)
|
|
(lambda (frame parameter)
|
|
(if (eq parameter 'foreground-color)
|
|
sentinel
|
|
(funcall original-frame-parameter frame parameter)))))
|
|
(let* ((rendered (ebox-render
|
|
(ebox-create :content "Border"
|
|
:width 60
|
|
:padding '(1 1)
|
|
:border t)))
|
|
(left-face (ebox-test--face-at-property rendered 'ebox-bl))
|
|
(right-face (ebox-test--face-at-property rendered 'ebox-br))
|
|
(top-face (ebox-test--face-at-property rendered 'ebox-bt))
|
|
(bottom-face (ebox-test--face-at-property rendered 'ebox-bb)))
|
|
(should (ebox-test--face-has-key-value-p
|
|
left-face :inverse-video t))
|
|
(should (ebox-test--face-has-key-value-p
|
|
right-face :inverse-video t))
|
|
(should (ebox-test--face-has-key-value-p top-face :overline t))
|
|
(should (ebox-test--face-has-key-value-p
|
|
bottom-face :underline '(:position t))))))))
|
|
|
|
(ert-deftest ebox-horizontal-borders-cover-side-border-corners ()
|
|
(ebox-test--reset-runtime-state)
|
|
(require 'face-remap)
|
|
(let* ((text-scale-mode-amount 2)
|
|
(rendered (ebox-render
|
|
(ebox-create :content "Border"
|
|
:width 120
|
|
:padding '(0 (8))
|
|
:border '(1 "#ff0000"))))
|
|
(lines (ebox-string-lines rendered))
|
|
(top (car lines))
|
|
(bottom (car (last lines)))
|
|
(top-left (get-text-property 0 'face top))
|
|
(top-right (get-text-property (1- (length top)) 'face top))
|
|
(bottom-left (get-text-property 0 'face bottom))
|
|
(bottom-right (get-text-property (1- (length bottom)) 'face bottom)))
|
|
(dolist (face (list top-left top-right))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p face :overline "#ff0000")))
|
|
(dolist (face (list bottom-left bottom-right))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "#ff0000"))))))
|
|
|
|
(ert-deftest ebox-horizontal-borders-cover-side-border-corners-when-shrunk ()
|
|
(ebox-test--reset-runtime-state)
|
|
(require 'face-remap)
|
|
(let* ((text-scale-mode-amount -2)
|
|
(rendered (ebox-render
|
|
(ebox-create :content "Border"
|
|
:width 120
|
|
:padding '(0 (8))
|
|
:border '(1 "#ff0000"))))
|
|
(lines (ebox-string-lines rendered))
|
|
(top (car lines))
|
|
(bottom (car (last lines)))
|
|
(top-left (get-text-property 0 'face top))
|
|
(top-right (get-text-property (1- (length top)) 'face top))
|
|
(bottom-left (get-text-property 0 'face bottom))
|
|
(bottom-right (get-text-property (1- (length bottom)) 'face bottom)))
|
|
(dolist (face (list top-left top-right))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p face :overline "#ff0000")))
|
|
(dolist (face (list bottom-left bottom-right))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "#ff0000"))))))
|
|
|
|
(ert-deftest ebox-horizontal-borders-do-not-cover-horizontal-margins ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((rendered (ebox-render
|
|
(ebox-create :content "Border"
|
|
:width 80
|
|
:margin '(0 (8) 0 (8))
|
|
:border '(1 "#ff0000"))))
|
|
(lines (ebox-string-lines rendered))
|
|
(top (car lines))
|
|
(bottom (car (last lines)))
|
|
(top-left-margin (get-text-property 0 'face top))
|
|
(top-left-border (get-text-property 1 'face top))
|
|
(top-right-border (get-text-property (- (length top) 2) 'face top))
|
|
(top-right-margin (get-text-property (1- (length top)) 'face top))
|
|
(bottom-left-margin (get-text-property 0 'face bottom))
|
|
(bottom-left-border (get-text-property 1 'face bottom))
|
|
(bottom-right-border (get-text-property (- (length bottom) 2) 'face bottom))
|
|
(bottom-right-margin (get-text-property (1- (length bottom)) 'face bottom)))
|
|
(dolist (face (list top-left-border top-right-border))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p face :overline "#ff0000")))
|
|
(dolist (face (list bottom-left-border bottom-right-border))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :background "#ff0000"))
|
|
(should (ebox-test--face-has-key-value-p
|
|
face :underline '(:position t :color "#ff0000"))))
|
|
(dolist (face (list top-left-margin top-right-margin))
|
|
(should-not (ebox-test--face-has-key-p face :overline)))
|
|
(dolist (face (list bottom-left-margin bottom-right-margin))
|
|
(should-not (ebox-test--face-has-key-p face :underline)))))
|
|
|
|
(ert-deftest ebox-pixel-cache-invalidates-when-display-signature-changes ()
|
|
(ebox-test--reset-runtime-state)
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(let ((signature 'first))
|
|
(lambda () signature))))
|
|
(clrhash ebox--char-width-cache)
|
|
(ebox--clear-string-pixel-width-cache)
|
|
(setq ebox--space-pixel-cache nil)
|
|
(setq ebox--display-signature-cache nil)
|
|
(ebox--char-pixel-width ?A)
|
|
(should (= (hash-table-count ebox--char-width-cache) 1))
|
|
(should (> (hash-table-count ebox--string-pixel-width-cache) 0))
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda () 'second)))
|
|
(ebox--ensure-display-cache-current)
|
|
(should (= (hash-table-count ebox--char-width-cache) 0))
|
|
(should (= (hash-table-count ebox--string-pixel-width-cache) 0))
|
|
(should-not ebox--space-pixel-cache)
|
|
(should (equal ebox--display-signature-cache 'second)))))
|
|
|
|
(ert-deftest ebox-display-signature-includes-face-remapping ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((plain (ebox--display-signature))
|
|
(face-remapping-alist '((default (:height 1.4)))))
|
|
(should-not (equal plain (ebox--display-signature)))))
|
|
|
|
(ert-deftest ebox-pixel-width-respects-text-scale-with-fixed-spaces ()
|
|
(ebox-test--reset-runtime-state)
|
|
(require 'face-remap)
|
|
(let* ((plain (ebox--string-pixel-width "AAAA"))
|
|
(fixed (ebox-pixel-space 30))
|
|
(text-scale-mode-amount 2)
|
|
(scaled (ebox--string-pixel-width "AAAA"))
|
|
(scaled-with-fixed (ebox--string-pixel-width
|
|
(concat "AAAA" fixed))))
|
|
(should (> scaled plain))
|
|
(should (= scaled-with-fixed (+ scaled 30)))))
|
|
|
|
(ert-deftest ebox-pixel-width-caches-plain-lines-during-render-context ()
|
|
"Repeated plain text width checks should share the render-local cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-cache-validated t)
|
|
(ebox--render-string-pixel-width-cache (make-hash-table :test 'equal))
|
|
(ebox--string-pixel-width-cache (make-hash-table :test 'equal))
|
|
(ebox--string-pixel-width-cache-ring
|
|
(make-vector ebox--string-pixel-width-cache-max-entries nil))
|
|
(ebox--string-pixel-width-cache-ring-index 0)
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'string-pixel-width)
|
|
(lambda (string)
|
|
(cl-incf calls)
|
|
(length string))))
|
|
(should (= (ebox--string-pixel-width "cached") 6))
|
|
(should (= (ebox--string-pixel-width "cached") 6))
|
|
(should (= calls 1)))))
|
|
|
|
(ert-deftest ebox-pixel-width-reuses-plain-lines-across-render-transactions ()
|
|
"Stable display transactions should share plain string measurements."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-signature-cache 'stable)
|
|
(probe (format "cross-render-%S" (make-symbol "probe")))
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda () 'stable))
|
|
((symbol-function 'string-pixel-width)
|
|
(lambda (string)
|
|
(cl-incf calls)
|
|
(length string))))
|
|
(dotimes (_ 2)
|
|
(ebox--with-validated-display-cache
|
|
(ebox--string-pixel-width probe)))
|
|
(should (= calls 1)))))
|
|
|
|
(ert-deftest ebox-pixel-width-reuses-face-only-lines-with-face-isolation ()
|
|
"Display-scoped measurements should reuse equal faces without collisions."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-signature-cache 'stable)
|
|
(bold (propertize "face-cache" 'face 'bold))
|
|
(italic (propertize "face-cache" 'face 'italic))
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'ebox--display-signature)
|
|
(lambda () 'stable))
|
|
((symbol-function 'string-pixel-width)
|
|
(lambda (string)
|
|
(cl-incf calls)
|
|
(if (eq (get-text-property 0 'face string) 'bold)
|
|
10
|
|
20))))
|
|
(should
|
|
(= (ebox--with-validated-display-cache
|
|
(ebox--string-pixel-width bold))
|
|
10))
|
|
(should
|
|
(= (ebox--with-validated-display-cache
|
|
(ebox--string-pixel-width bold))
|
|
10))
|
|
(should
|
|
(= (ebox--with-validated-display-cache
|
|
(ebox--string-pixel-width italic))
|
|
20))
|
|
(should (= calls 2)))))
|
|
|
|
(ert-deftest ebox-persistent-pixel-width-cache-stays-bounded ()
|
|
"Display-scoped reusable string widths should evict at their entry cap."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-cache-validated t)
|
|
(ebox--render-string-pixel-width-cache nil)
|
|
(ebox--string-pixel-width-cache (make-hash-table :test 'equal))
|
|
(ebox--string-pixel-width-cache-ring
|
|
(make-vector ebox--string-pixel-width-cache-max-entries nil))
|
|
(ebox--string-pixel-width-cache-ring-index 0))
|
|
(cl-letf (((symbol-function 'string-pixel-width)
|
|
(lambda (string) (length string))))
|
|
(dotimes (index (+ ebox--string-pixel-width-cache-max-entries 17))
|
|
(ebox--string-pixel-width (format "measurement-%d" index))))
|
|
(should
|
|
(= (hash-table-count ebox--string-pixel-width-cache)
|
|
ebox--string-pixel-width-cache-max-entries))))
|
|
|
|
(ert-deftest ebox-string-max-pixel-width-works-without-render-cache ()
|
|
"Multiline max-width measurement should not require a render-local cache."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-cache-validated t)
|
|
(ebox--render-string-max-pixel-width-cache nil))
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (line)
|
|
(length (substring-no-properties line)))))
|
|
(should (= (ebox--string-max-pixel-width "wide\nn") 4)))))
|
|
|
|
(ert-deftest ebox-flex-string-width-caches-rendered-strings ()
|
|
"Repeated flex width checks should reuse render-local rendered string widths."
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--display-cache-validated t)
|
|
(ebox--render-string-pixel-width-cache (make-hash-table :test 'equal))
|
|
(ebox--render-string-max-pixel-width-cache (make-hash-table :test 'eq))
|
|
(rendered (concat (propertize "wide" 'face 'bold)
|
|
"\n"
|
|
(propertize "narrow" 'display '(space :width (2)))))
|
|
(calls 0))
|
|
(cl-letf (((symbol-function 'ebox--string-pixel-width)
|
|
(lambda (line)
|
|
(cl-incf calls)
|
|
(length (substring-no-properties line)))))
|
|
(should (= (ebox--flex-string-width rendered) 6))
|
|
(should (= (ebox--flex-string-width rendered) 6))
|
|
(should (= calls 2)))))
|
|
|
|
(ert-deftest ebox-flex-recache-skips-visited-source-subtrees ()
|
|
"Repeated source recache calls should not walk the same subtree twice."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((source (ebox-column
|
|
(ebox-create :content "A")
|
|
(ebox-create :content "B")))
|
|
(ebox--render-recached-source-node-cache
|
|
(make-hash-table :test 'eq))
|
|
(original-puthash (symbol-function 'puthash))
|
|
(region-table-writes 0))
|
|
(ebox-region-ids source)
|
|
(cl-letf (((symbol-function 'puthash)
|
|
(lambda (key value table)
|
|
(when (eq table ebox--region-box-table)
|
|
(cl-incf region-table-writes))
|
|
(funcall original-puthash key value table))))
|
|
(ebox--flex-recache-source-boxes source)
|
|
(ebox--flex-recache-source-boxes source))
|
|
(should (= region-table-writes 2))))
|
|
|
|
(ert-deftest ebox-face-height-width-detection-handles-shrinking-text ()
|
|
(ebox-test--reset-runtime-state)
|
|
(let ((ebox--face-height-width-cache nil)
|
|
(factor 0.7))
|
|
(cl-letf (((symbol-function 'string-pixel-width)
|
|
(lambda (string)
|
|
(if (get-text-property 0 'face string)
|
|
70
|
|
101))))
|
|
(should (ebox--face-height-affects-width-p factor))
|
|
(should (= (ebox--scaled-string-pixel-width "probe" factor)
|
|
70)))))
|
|
|
|
(ert-deftest ebox-buffer-property-patches-split-disjoint-property-changes ()
|
|
"Root publication should touch only disjoint property-aware changes."
|
|
(let* ((old (concat (propertize "a" 'face 'bold) "bcd"))
|
|
(new (concat (propertize "a" 'face 'italic)
|
|
"b"
|
|
(propertize "c" 'display '(space :width (12)))
|
|
"d"))
|
|
(reordered (propertize "x" 'alpha 1 'beta '(2)))
|
|
(same (propertize "x" 'beta '(2) 'alpha 1)))
|
|
(should
|
|
(equal (ebox-buffer--minimal-property-patches old new)
|
|
'((:old-start 0 :old-end 1 :new-start 0 :new-end 1)
|
|
(:old-start 2 :old-end 3 :new-start 2 :new-end 3))))
|
|
(should-not (ebox-buffer--minimal-property-patches reordered same))))
|
|
|
|
(ert-deftest ebox-buffer-property-patches-trim-length-change-boundaries ()
|
|
"A length-changing publication should retain its exact common edges."
|
|
(should
|
|
(equal (ebox-buffer--minimal-property-patches "abXYcd" "abZcd")
|
|
'((:old-start 2 :old-end 4 :new-start 2 :new-end 3)))))
|
|
|
|
(ert-deftest ebox-buffer-property-patches-preserve-internal-common-runs ()
|
|
"Text edits should not absorb unchanged runs inside a length change."
|
|
(should
|
|
(equal (ebox-buffer--minimal-property-patches
|
|
"abXcdYef" "abZcdWQef")
|
|
'((:old-start 2 :old-end 3 :new-start 2 :new-end 3)
|
|
(:old-start 5 :old-end 6 :new-start 5 :new-end 7)))))
|
|
|
|
(ert-deftest ebox-buffer-property-patches-align-equal-length-moves ()
|
|
"Equal-length text shifts should retain aligned unchanged characters."
|
|
(should
|
|
(equal (ebox-buffer--minimal-property-patches "abc" "bca")
|
|
'((:old-start 0 :old-end 1 :new-start 0 :new-end 0)
|
|
(:old-start 3 :old-end 3 :new-start 2 :new-end 3)))))
|
|
|
|
(ert-deftest ebox-buffer-myers-runs-preserve-shortest-edit-distance ()
|
|
"Compressed alignment runs should retain the exact Myers edit distance."
|
|
(cl-labels
|
|
((strings-of-length
|
|
(length)
|
|
(if (zerop length)
|
|
'("")
|
|
(cl-loop for prefix in (strings-of-length (1- length))
|
|
append (list (concat prefix "a")
|
|
(concat prefix "b")))))
|
|
(reference-distance
|
|
(old new)
|
|
(let ((memo (make-hash-table :test 'equal)))
|
|
(cl-labels
|
|
((visit
|
|
(old-position new-position)
|
|
(or (gethash (cons old-position new-position) memo)
|
|
(let ((distance
|
|
(cond
|
|
((= old-position (length old))
|
|
(- (length new) new-position))
|
|
((= new-position (length new))
|
|
(- (length old) old-position))
|
|
((= (aref old old-position)
|
|
(aref new new-position))
|
|
(visit (1+ old-position) (1+ new-position)))
|
|
(t
|
|
(1+ (min (visit (1+ old-position) new-position)
|
|
(visit old-position
|
|
(1+ new-position))))))))
|
|
(puthash (cons old-position new-position)
|
|
distance memo)
|
|
distance))))
|
|
(visit 0 0)))))
|
|
(let ((strings
|
|
(cl-loop for length from 0 to 4
|
|
append (strings-of-length length))))
|
|
(dolist (old strings)
|
|
(dolist (new strings)
|
|
(let ((old-position 0)
|
|
(new-position 0)
|
|
(edits 0))
|
|
(dolist (run (ebox-buffer--myers-text-matches old new))
|
|
(let ((run-old (nth 0 run))
|
|
(run-new (nth 1 run))
|
|
(run-length (nth 2 run)))
|
|
(cl-incf edits (- run-old old-position))
|
|
(cl-incf edits (- run-new new-position))
|
|
(should
|
|
(equal (substring old run-old (+ run-old run-length))
|
|
(substring new run-new (+ run-new run-length))))
|
|
(setq old-position (+ run-old run-length)
|
|
new-position (+ run-new run-length))))
|
|
(cl-incf edits (- (length old) old-position))
|
|
(cl-incf edits (- (length new) new-position))
|
|
(should (= edits (reference-distance old new)))))))))
|
|
|
|
(ert-deftest ebox-buffer-root-property-patches-publish-only-changed-spans ()
|
|
"Applying root patches should preserve exact output and report actual writes."
|
|
(with-temp-buffer
|
|
(let* ((old (concat (propertize "a" 'face 'bold) "bcd"))
|
|
(new (concat (propertize "a" 'face 'italic)
|
|
"b"
|
|
(propertize "c" 'display '(space :width (12)))
|
|
"d")))
|
|
(insert old)
|
|
(let ((result
|
|
(ebox-buffer--replace-root-with-property-patches
|
|
'((1 . 5)) new)))
|
|
(should (equal-including-properties (buffer-string) new))
|
|
(should (equal (plist-get result :published-buffer-spans)
|
|
'((1 . 2) (3 . 4))))
|
|
(should-not (plist-get result :full-root-required-p))
|
|
(should (equal (plist-get result :new-buffer-spans)
|
|
'((1 . 5))))))))
|
|
|
|
(ert-deftest ebox-buffer-rust-root-patches-bypass-full-string-diff ()
|
|
"Rust-origin patches should publish directly without a complete target string."
|
|
(with-temp-buffer
|
|
(let* ((old (concat (propertize "a" 'face 'bold) "bcd"))
|
|
(replacement-a (propertize "a" 'face 'italic))
|
|
(replacement-c
|
|
(propertize "c" 'display '(space :width (12))))
|
|
(native-patch
|
|
(list :native-patch t
|
|
:patch-origin 'rust
|
|
:base-character-count 4
|
|
:target-character-count 4
|
|
:target-line-count 1
|
|
:patches
|
|
(list
|
|
(list :old-start 0 :old-end 1
|
|
:new-start 0 :new-end 1
|
|
:replacement replacement-a)
|
|
(list :old-start 2 :old-end 3
|
|
:new-start 2 :new-end 3
|
|
:replacement replacement-c)))))
|
|
(insert old)
|
|
(cl-letf (((symbol-function 'ebox-buffer--minimal-property-patches)
|
|
(lambda (&rest _)
|
|
(ert-fail "Rust patch path rebuilt the complete diff"))))
|
|
(let ((result
|
|
(ebox-buffer--apply-root-property-patches
|
|
'((1 . 5)) native-patch)))
|
|
(should
|
|
(equal-including-properties
|
|
(buffer-string)
|
|
(concat replacement-a "b" replacement-c "d")))
|
|
(should (equal (plist-get result :published-buffer-spans)
|
|
'((1 . 2) (3 . 4))))
|
|
(should (eq (plist-get result :patch-origin) 'rust))
|
|
(should (= (plist-get result :full-frame-bytes) 0)))))))
|
|
|
|
(ert-deftest ebox-visibility-hidden-suppresses-ink-and-keeps-footprint ()
|
|
"A hidden box renders blank with identical text, lengths, and metadata."
|
|
(let* ((make-box
|
|
(lambda (visibility)
|
|
(ebox-create :content "Hello" :width (list 90) :border t
|
|
:border-color "#AA3311" :bgcolor "#223344"
|
|
:color "#FFFFFF" :padding '(0 1)
|
|
:visibility visibility)))
|
|
(visible (ebox-render (funcall make-box 'visible)))
|
|
(hidden (ebox-render (funcall make-box 'hidden))))
|
|
(should (equal (substring-no-properties visible)
|
|
(substring-no-properties hidden)))
|
|
(should (equal (mapcar #'length (ebox-string-lines visible))
|
|
(mapcar #'length (ebox-string-lines hidden))))
|
|
;; No character carries a face, every character renders under a
|
|
;; display spec, and each line's blank cover is measured to the
|
|
;; visible line's exact pixel width.
|
|
(dotimes (index (length hidden))
|
|
(unless (eq (aref hidden index) ?\n)
|
|
(should-not (get-text-property index 'face hidden))
|
|
(should (get-text-property index 'display hidden))))
|
|
(cl-loop for visible-line in (ebox-string-lines visible)
|
|
for hidden-line in (ebox-string-lines hidden)
|
|
do (should (= (ebox-string-pixel-width visible-line)
|
|
(ebox-string-pixel-width hidden-line))))
|
|
;; Region metadata still identifies the same owner surfaces at the
|
|
;; content characters.
|
|
(let ((position (string-match "Hello"
|
|
(substring-no-properties visible))))
|
|
(should position)
|
|
(should (get-text-property position 'ebox-content-owner visible))
|
|
(should (get-text-property position 'ebox-content-owner hidden)))))
|
|
|
|
(ert-deftest ebox-visibility-toggle-is-local-and-restores-exactly ()
|
|
"Hiding and showing one region never widens beyond its owner.
|
|
The buffer text never changes; showing again restores the visible
|
|
publication with properties intact."
|
|
(let* ((buffer (generate-new-buffer " *ebox-visibility*"))
|
|
(root (ebox-create
|
|
:width (list 300)
|
|
:ebox-content-node
|
|
(ebox-column
|
|
(ebox-create :content "Header line" :id 'header
|
|
:width (list 300))
|
|
(ebox-create :content "Secret content" :id 'secret
|
|
:width (list 300) :border t
|
|
:bgcolor "#224466" :color "#FFFFFF")
|
|
(ebox-create :content "Footer line" :id 'footer
|
|
:width (list 300))))))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox-render-to-buffer buffer root)
|
|
(let ((before (with-current-buffer buffer (buffer-string))))
|
|
(ebox-selector-update-buffer buffer "#secret"
|
|
:visibility 'hidden)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender paint-patch)))
|
|
(should (= (plist-get report :patch-count) 1)))
|
|
(should (equal (with-current-buffer buffer
|
|
(substring-no-properties (buffer-string)))
|
|
(substring-no-properties before)))
|
|
(ebox-selector-update-buffer buffer "#secret"
|
|
:visibility 'visible)
|
|
(let ((report (ebox-test--buffer-update-report)))
|
|
(should (memq (plist-get report :strategy)
|
|
'(span-patch owner-rerender paint-patch)))
|
|
(should (= (plist-get report :patch-count) 1)))
|
|
(should (equal-including-properties
|
|
(with-current-buffer buffer (buffer-string))
|
|
before))))
|
|
(kill-buffer buffer))))
|
|
|
|
(ert-deftest ebox-parent-border-color-patch-never-recolors-descendants ()
|
|
"A parent border-color paint patch touches only the owner's chrome.
|
|
Border surfaces belong to each box: a full render never propagates an
|
|
ancestor border color into a descendant's border runs, so the cheap
|
|
face patch must match that exactly (issue014)."
|
|
(ebox-test--reset-runtime-state)
|
|
(let* ((make-tree
|
|
(lambda (parent-color)
|
|
(ebox-create
|
|
:id 'parent :width (list 400)
|
|
:border (list '(4) 'solid parent-color)
|
|
:padding '(1 (12))
|
|
:ebox-content-node
|
|
(ebox-column
|
|
(ebox-create :id 'child :content "CHILD" :width (list 200)
|
|
:border '((4) solid "#00AA00"))))))
|
|
(visual-runs
|
|
(lambda (buffer role)
|
|
(with-current-buffer buffer
|
|
(let (runs (position (point-min)))
|
|
(while (< position (point-max))
|
|
(when (get-text-property position role)
|
|
(push (list (line-number-at-pos position)
|
|
(get-text-property position role)
|
|
(ebox--face-visual-attributes
|
|
(get-text-property position 'face)))
|
|
runs))
|
|
(setq position
|
|
(or (next-single-property-change position role)
|
|
(point-max))))
|
|
(nreverse runs)))))
|
|
(patched (generate-new-buffer " *i14-patched*"))
|
|
(reference (generate-new-buffer " *i14-reference*")))
|
|
(unwind-protect
|
|
(progn
|
|
(ebox-render-to-buffer patched (funcall make-tree "#AA0000"))
|
|
(ebox-selector-update-buffer patched "#parent"
|
|
:border-color "#0000AA")
|
|
(should (eq (plist-get (ebox-test--buffer-update-report) :strategy)
|
|
'paint-patch))
|
|
(ebox-test--reset-runtime-state)
|
|
(ebox-render-to-buffer reference (funcall make-tree "#0000AA"))
|
|
(dolist (role '(ebox-bl ebox-br ebox-bt ebox-bb))
|
|
(ert-info ((format "border role %S" role))
|
|
(should (equal
|
|
(mapcar (lambda (run) (cons (car run) (caddr run)))
|
|
(funcall visual-runs patched role))
|
|
(mapcar (lambda (run) (cons (car run) (caddr run)))
|
|
(funcall visual-runs reference role)))))))
|
|
(kill-buffer patched)
|
|
(kill-buffer reference))))
|
|
|
|
;;; ebox-core-render-tests.el ends here
|