* testing/lisp/test-org-element.el: Add new tests

(test-org-element/type):
(test-org-element/type-p):
(test-org-element/org-element-property-1):
(test-org-element/property):
(test-org-element/properties-resolve):
(test-org-element/secondary-p):
(test-org-element/class):
(test-org-element/ast-map):
(test-org-element/properties-mapc):
(test-org-element/properties-map):
(test-org-element/org-element-create):
(test-org-element/put-property):
(test-org-element/set):
(test-org-element/lineage-map): add new and extend tests according to
the new API.
This commit is contained in:
Ihor Radchenko 2023-05-29 13:04:45 +03:00
parent 5c05ac198a
commit b2482d9cc4
No known key found for this signature in database
GPG Key ID: 6470762A7DA11D8B
1 changed files with 627 additions and 48 deletions

View File

@ -33,9 +33,281 @@ Return interpreted string."
(insert text)
(org-element-interpret-data (org-element-parse-buffer))))
;;; Test getters.
(ert-deftest test-org-element/type ()
"Test `org-element-type' specifications."
(should (eq 'plain-text (org-element-type "string")))
(should-not (org-element-type nil))
(should-not (org-element-type 1))
(should (eq 'dummy (org-element-type '(dummy))))
(should (eq 'dummy (org-element-type '(dummy nil 'foo))))
(should (eq 'dummy (org-element-type '(dummy (:a a :b b) 'foo))))
;; anonymous node.
(should-not (org-element-type '((dummy))))
(should (eq 'anonymous (org-element-type '((dummy)) t)))
(should (eq 'anonymous (org-element-type '("string") t)))
(should-not (org-element-type '(1 2) t)))
(ert-deftest test-org-element/type-p ()
"Test `org-element-type-p' specifications."
(should (org-element-type-p '(foo) 'foo))
(should (org-element-type-p '(foo) '(foo)))
(should (org-element-type-p '(foo) '(foo bar)))
(should-not (org-element-type-p '(foo) 'bar))
(should-not (org-element-type-p '(foo) '(bar baz)))
(should (org-element-type-p "string" 'plain-text))
(should (org-element-type-p '((foo)) 'anonymous)))
(ert-deftest test-org-element/org-element-property-1 ()
"Test `org-element-property-1' specifications."
;; No properties.
(dolist (element `( nil
(headline nil)
(headline nil (headline))
"string"))
(should-not (org-element-property-1 :begin element))
(should (eq 'default (org-element-property-1 :begin element 'default)))
(should-not (org-element-property-1 :begin1 element))
(should (eq 'default (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default)))))
;; Only non-standard properties.
(dolist (element `((headline (:begin1 1))
(headline (:begin1 1) (headline))
,(propertize "string" :begin1 1)))
(should-not (org-element-property-1 :begin element))
(should (eq 'default (org-element-property-1 :begin element 'default)))
(should (= 1 (org-element-property-1 :begin1 element)))
(should (= 1 (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should (= 1 (org-element-property-1 prop element)))
(should (= 1 (org-element-property-1 prop element 'default)))))
;; Only standard properties.
(dolist (element `((headline (:standard-properties ,(make-vector 10 'test)))
(headline (:standard-properties ,(make-vector 10 'test)) (headline))))
(should (eq 'test (org-element-property-1 :begin element)))
(should (eq 'test (org-element-property-1 :begin element 'default)))
(should-not (org-element-property-1 :begin1 element))
(should (eq 'default (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should (eq 'test (org-element-property-1 prop element)))
(should (eq 'test (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default)))))
;; Standard properties in the plist.
(dolist (element `((headline (:begin 1))
(headline (:begin 1) (headline))
,(propertize "string" :begin 1)))
(should (= 1 (org-element-property-1 :begin element)))
(should (= 1 (org-element-property-1 :begin element 'default)))
(should-not (org-element-property-1 :begin1 element))
(should (eq 'default (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should (= 1 (org-element-property-1 prop element)))
(should (= 1 (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default)))))
;; Standard properties mixed in the plist and standard array.
(dolist (element `((headline (:standard-properties ,(make-vector 10 'test) :begin 1))
(headline (:begin 1 :standard-properties ,(make-vector 10 'test)))
(headline (:standard-properties ,(make-vector 10 'test) :begin 1) (headline))))
(should (eq 'test (org-element-property-1 :begin element)))
(should (eq 'test (org-element-property-1 :begin element 'default)))
(should-not (org-element-property-1 :begin1 element))
(should (eq 'default (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should (eq 'test (org-element-property-1 prop element)))
(should (eq 'test (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should-not (org-element-property-1 prop element))
(should (eq 'default (org-element-property-1 prop element 'default)))))
;; General case.
(dolist (element `((headline (:standard-properties ,(make-vector 10 'test) :begin1 1))
(headline (:begin1 1 :standard-properties ,(make-vector 10 'test)))
(headline (:standard-properties ,(make-vector 10 'test) :begin1 1) (headline))))
(should (eq 'test (org-element-property-1 :begin element)))
(should (eq 'test (org-element-property-1 :begin element 'default)))
(should (= 1 (org-element-property-1 :begin1 element)))
(should (= 1 (org-element-property-1 :begin1 element 'default)))
(dolist (prop '(:begin))
(should (eq 'test (org-element-property-1 prop element)))
(should (eq 'test (org-element-property-1 prop element 'default))))
(dolist (prop '(:begin1))
(should (= 1 (org-element-property-1 prop element)))
(should (= 1 (org-element-property-1 prop element 'default))))))
(ert-deftest test-org-element/property ()
"Test resolving deferred properties."
;; Resolve `:deferred' property.
(let ((el (org-element-create
'dummy
`(:deferred
,(org-element-deferred-create
t (lambda (el) (org-element-put-property el :foo 'bar) nil))))))
(should (eq 'bar (org-element-property :foo el)))
(should-not (org-element-property :foo2 el)))
;; Deferred value.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create
nil (lambda (_) 'bar))))))
(should (eq 'bar (org-element-property :foo el))))
;; Auto-undefer.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create
t (lambda (_) 'bar))))))
(should (eq 'bar (org-element-property :foo el)))
(should (eq 'bar (org-element-property-1 :foo el))))
;; Force undefer.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create
nil (lambda (_) 'bar))))))
(should (eq 'bar (org-element-property :foo el)))
(should-not (eq 'bar (org-element-property-1 :foo el)))
(should (eq 'bar (org-element-property :foo el nil 'force)))
(should (eq 'bar (org-element-property-1 :foo el))))
;; Test deferred alias.
(let ((el (org-element-create
'dummy
`( :foo 1
:bar
,(org-element-deferred-create-alias :foo)))))
(should (equal 1 (org-element-property :foo el)))
(should (equal 1 (org-element-property :bar el))))
;; Test deferred list.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create-list
(list 1 2 (org-element-deferred-create nil (lambda (_) 3))))))))
(should (equal '(1 2 3) (org-element-property :foo el))))
;; Test deferred property with side effects.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create
nil (lambda (el)
(org-element-put-property el :foo 1)
(throw :org-element-deferred-retry nil)))))))
(should (eq 1 (org-element-property :foo el))))
;; Test recursive undefer.
(let ((el (org-element-create
'dummy
`(:foo
,(org-element-deferred-create
nil (lambda (el)
(org-element-deferred-create
nil (lambda (_) 1))))))))
(should (eq 1 (org-element-property :foo el)))))
(ert-deftest test-org-element/property-2 ()
"Test `org-element-property-2' specifications."
(let ((el (org-element-create 'dummy '(:foo bar))))
(should (eq (org-element-property :foo el)
(org-element-property-2 el :foo)))))
(ert-deftest test-org-element/parent ()
"Test `org-element-parent' specifications."
(let ((el (org-element-create 'dummy '(:parent bar))))
(should (eq (org-element-property :parent el)
(org-element-parent el)))))
(ert-deftest test-org-element/properties-resolve ()
"Test `org-element-properties-resolve' specifications."
(let ((el (org-element-create
'dummy
`( :foo ,(org-element-deferred-create t (lambda (_) 1))
:bar ,(org-element-deferred-create nil (lambda (_) 2))
:deferred
,(org-element-deferred-create
nil (lambda (el)
(org-element-put-property el :baz 3)))))))
;; Resolve conditionally.
(setq el (org-element-properties-resolve el))
(should (eq 1 (org-element-property-1 :foo el)))
(should-not (eq 2 (org-element-property-1 :bar el)))
(should (eq 2 (org-element-property :bar el)))
(should (eq 3 (org-element-property-1 :baz el)))
;; Resolve unconditionally.
(setq el (org-element-properties-resolve el 'force))
(should (eq 2 (org-element-property-1 :bar el)))))
(ert-deftest test-org-element/secondary-p ()
"Test `org-element-secondary-p' specifications."
;; In a secondary string, return property name.
(should
(eq :title
(org-test-with-temp-text "* Headline *object*"
(org-element-map (org-element-parse-buffer) 'bold
(lambda (object) (org-element-secondary-p object))
nil t))))
(should
(eq :foo
(org-element-secondary-p
(let* ((el (org-element-create
'dummy '(:secondary (:foo))))
(child (org-element-create "string" `(:parent ,el))))
(org-element-put-property
el :foo (list child))
child))))
;; Outside a secondary string, return nil.
(should-not
(org-test-with-temp-text "Paragraph *object*"
(org-element-map (org-element-parse-buffer) 'bold
(lambda (object) (org-element-type (org-element-secondary-p object)))
nil t)))
(should-not
(eq :foo
(org-element-secondary-p
(let* ((el (org-element-create
'dummy '(:secondary (:foo))))
(child (org-element-create "string" `(:parent ,el))))
(org-element-put-property
el :bar (list child))
child)))))
(ert-deftest test-org-element/class ()
"Test `org-element-class' specifications."
;; Regular tests.
(should (eq 'element (org-element-class '(paragraph nil) nil)))
(should (eq 'object (org-element-class '(target nil) nil)))
;; Special types.
(should (eq 'element (org-element-class '(org-data nil) nil)))
(should (eq 'object (org-element-class "text" nil)))
(should (eq 'object (org-element-class '("secondary " "string") nil)))
;; Pseudo elements.
(should (eq 'element (org-element-class '(foo nil) nil)))
(should (eq 'element (org-element-class '(foo nil) '(center-block nil))))
(should (eq 'element (org-element-class '(foo nil) '(org-data nil))))
;; Pseudo objects.
(should (eq 'object (org-element-class '(foo nil) '(bold nil))))
(should (eq 'object (org-element-class '(foo nil) '(paragraph nil))))
(should (eq 'object (org-element-class '(foo nil) '("secondary"))))
(should
(eq 'object
(let* ((datum '(foo nil))
(headline `(headline (:title (,datum) :secondary (:title)))))
(org-element-put-property datum :parent headline)
(org-element-class datum)))))
;;; Test `org-element-map'
;;; Test `org-element-map' and `org-element-properties-map'
(ert-deftest test-org-element/map ()
"Test `org-element-map'."
@ -48,8 +320,8 @@ Some other text
#+END_CENTER"
(let ((count 0))
(org-element-map
(org-element-parse-buffer) 'plain-text
(lambda (s) (when (string-match "text" s) (cl-incf count))))
(org-element-parse-buffer) 'plain-text
(lambda (s) (when (string-match "text" s) (cl-incf count))))
count))))
;; Applies to secondary strings
(should
@ -66,19 +338,185 @@ Some other text
(should-not
(org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
(org-element-map
(org-element-parse-buffer) 'entity 'identity nil nil 'center-block)))
(org-element-parse-buffer) 'entity 'identity nil nil 'center-block)))
;; Use WITH-AFFILIATED argument.
(should
(equal
'("1" "a" "2" "b")
(org-test-with-temp-text "#+CAPTION[a]: 1\n#+CAPTION[b]: 2\nParagraph"
(org-element-map
(org-element-at-point) 'plain-text 'identity nil nil nil t)))))
(org-element-at-point) 'plain-text 'identity nil nil nil t)))))
(ert-deftest test-org-element/ast-map ()
"Test `org-element-ast-map' specifications."
;; TYPES = t
(should
(equal
'(plain-text plain-text bold)
(org-element-ast-map
(org-element-create 'anonymous nil "a" "b" (org-element-create 'bold))
t #'org-element-type)))
;; IGNORE
(should
(equal
'(plain-text plain-text)
(let ((bold (org-element-create 'bold)))
(org-element-ast-map
(org-element-create 'anonymous nil "a" "b" bold)
t #'org-element-type (list bold)))))
;; FUN as a list form
(org-test-with-temp-text "* H1\n* H2"
(should
(equal
'("H1" "H2")
(org-element-map
(org-element-parse-buffer)
t '(org-element-property :raw-value node)))))
;; Extra secondary properties.
(should
(equal
'(bold bold)
(org-element-ast-map
(org-element-create
'dummy
`(:foo ,(org-element-create 'bold))
(org-element-create 'bold))
'bold #'org-element-type
nil nil nil '(:foo))))
(should-not
(equal
'(bold bold)
(org-element-ast-map
(org-element-create
'dummy
`(:foo ,(org-element-create 'bold))
(org-element-create 'bold))
'bold #'org-element-type)))
;; No secondary.
(should-not
(equal
'(bold bold)
(org-element-ast-map
(org-element-create
'dummy
`(:secondary (:foo) :foo ,(org-element-create 'bold))
(org-element-create 'bold))
'bold #'org-element-type
nil nil nil nil 'no-secondary)))
(should
(equal
'(bold bold)
(org-element-ast-map
(org-element-create
'dummy
`(:secondary (:foo) :foo ,(org-element-create 'bold))
(org-element-create 'bold))
'bold #'org-element-type)))
;; Deferred values.
(should
(equal
'(dummy bold)
(org-element-ast-map
(org-element-create
'dummy
`(:secondary (:foo) :foo ,(org-element-deferred-create nil (lambda (_) "a")))
(org-element-create 'bold))
t #'org-element-type
nil nil nil nil nil 'no-undefer)))
(should
(equal
'(dummy plain-text bold)
(org-element-ast-map
(org-element-create
'dummy
`(:secondary (:foo) :foo ,(org-element-deferred-create nil (lambda (_) "a")))
(org-element-create 'bold))
t #'org-element-type))))
(ert-deftest test-org-element/properties-mapc ()
"Test `org-element-properties-mapc' specifications."
(let ((el (org-element-create
'dummy
`( :foo ,(org-element-deferred-create t (lambda (_) 1))
:bar 2))))
(should
(catch :found
(org-element-properties-mapc
(lambda (_ val _)
(when (org-element-deferred-p val)
(throw :found t)))
el)))
(should
(catch :found
(org-element-properties-mapc
(lambda (prop val _)
(when (and (eq prop :foo) (eq 1 val))
(throw :found t)))
el 'undefer)))))
(ert-deftest test-org-element/properties-map ()
"Test `org-element-properties-map' specifications."
;; Check resolving deferred properties.
(let ((el (org-element-create
'dummy
`( :foo ,(org-element-deferred-create t (lambda (_) 1))
:bar 2))))
(should
(equal '(2)
(cdr
(org-element-properties-map
(lambda (_ val _) val) el))))
(should-not
(equal '(1 2)
(org-element-properties-map
(lambda (_ val _) val) el)))
(should
(equal '(1 2)
(org-element-properties-map
(lambda (_ val _) val) el 'undefer))))
;; Check functions with different arity.
(let ((el (org-element-create 'dummy '(:foo 1 :bar 2 :baz 3))))
(should
;; Single argument.
(equal '(1 2 3)
(org-element-properties-map #'identity el)))
;; Two arguments.
(should
(equal '(1 2 nil)
(org-element-properties-map
(lambda (prop val) (unless (eq prop :baz) val)) el)))
;; Three arguments.
(should
(equal '(1 2 4)
(org-element-properties-map
(lambda (prop val node)
(if (eq prop :baz)
(1+ (org-element-property-1 :baz node))
val))
el)))))
;;; Test Setters
(ert-deftest test-org-element/org-element-create ()
"Test `org-element-create' specifications."
(should
(pcase (org-element-create 'foo '(:a 1 :b 2))
(`(foo (:standard-properties ,_ :a 1 :b 2)) t)))
(should
(pcase (org-element-create 'foo '(:begin 10))
(`(foo (:standard-properties ,vec))
(= 10 (aref vec (org-element--property-idx :begin))))))
;; Strings
(should (equal "foo" (org-element-create "foo")))
(should (equal "foo" (org-element-create 'plain-text nil "foo")))
(should (get-text-property 0 :a (org-element-create 'plain-text '(:a 1) "foo")))
(should (get-text-property 0 :begin (org-element-create 'plain-text '(:begin 1) "foo")))
;; Children
(let ((children '("a" "b" (org-element-create 'foo))))
(should (equal (cddr (apply #'org-element-create 'bar nil children))
children))))
(ert-deftest test-org-element/put-property ()
"Test `org-element-put-property' specifications."
;; Standard test.
@ -90,7 +528,47 @@ Some other text
:test (org-element-map tree 'bold 'identity nil t)))))
;; Put property on a string.
(should
(org-element-property :test (org-element-put-property "Paragraph" :test t))))
(org-element-property :test (org-element-put-property "Paragraph" :test t)))
;; No properties.
(let ((element (list 'heading nil))
vec)
(setq vec (make-vector (length org-element--standard-properties) nil))
(aset vec 0 1)
(should
(equal
(list 'heading (list :standard-properties vec))
(org-element-put-property element :begin 1))))
(let ((element (list 'heading nil)))
(should
(equal
(list 'heading (list :begin1 1))
(org-element-put-property element :begin1 1))))
;; Standard properties.
(let ((element (list 'heading (list :standard-properties (make-vector (length org-element--standard-properties) 'foo)))))
(should
(= 1
(org-element-property-1 :begin (org-element-put-property element :begin 1)))))
;; Adding standard properties when other standard properties are defined manually in the plist.
(let ((element (list 'heading (list :begin 1 :end 20 :foo 'foo))))
(should
(= 2
(org-element-property-1 :begin (org-element-put-property element :begin 2))))
;; Check setter.
(cl-incf (org-element-property-1 :begin element))
(should
(= 3 (org-element-property-1 :begin element)))
(should
(= 20
(org-element-property-1 :end element)))
(should
(eq 'foo
(org-element-property-1 :foo element)))))
(ert-deftest test-org-element/put-property-2 ()
"Test `org-element-put-property-2' specifications."
(should
(equal (org-element-put-property (org-element-create 'foo) :test 'value)
(org-element-put-property-2 :test 'value (org-element-create 'foo)))))
(ert-deftest test-org-element/set-contents ()
"Test `org-element-set-contents' specifications."
@ -133,46 +611,6 @@ Some other text
(org-element-set-contents element `(b (:parent ,element)))
element))))
(ert-deftest test-org-element/secondary-p ()
"Test `org-element-secondary-p' specifications."
;; In a secondary string, return property name.
(should
(eq :title
(org-test-with-temp-text "* Headline *object*"
(org-element-map (org-element-parse-buffer) 'bold
(lambda (object) (org-element-secondary-p object))
nil t))))
;; Outside a secondary string, return nil.
(should-not
(org-test-with-temp-text "Paragraph *object*"
(org-element-map (org-element-parse-buffer) 'bold
(lambda (object) (org-element-type (org-element-secondary-p object)))
nil t))))
(ert-deftest test-org-element/class ()
"Test `org-element-class' specifications."
;; Regular tests.
(should (eq 'element (org-element-class '(paragraph nil) nil)))
(should (eq 'object (org-element-class '(target nil) nil)))
;; Special types.
(should (eq 'element (org-element-class '(org-data nil) nil)))
(should (eq 'object (org-element-class "text" nil)))
(should (eq 'object (org-element-class '("secondary " "string") nil)))
;; Pseudo elements.
(should (eq 'element (org-element-class '(foo nil) nil)))
(should (eq 'element (org-element-class '(foo nil) '(center-block nil))))
(should (eq 'element (org-element-class '(foo nil) '(org-data nil))))
;; Pseudo objects.
(should (eq 'object (org-element-class '(foo nil) '(bold nil))))
(should (eq 'object (org-element-class '(foo nil) '(paragraph nil))))
(should (eq 'object (org-element-class '(foo nil) '("secondary"))))
(should
(eq 'object
(let* ((datum '(foo nil))
(headline `(headline (:title (,datum) :secondary (:title)))))
(org-element-put-property datum :parent headline)
(org-element-class datum)))))
(ert-deftest test-org-element/adopt-elements ()
"Test `org-element-adopt' specifications."
;; Adopt an element.
@ -267,7 +705,7 @@ Some other text
(org-element-map (org-element-property :title headline) '(entity italic)
#'org-element-type))))))
(ert-deftest test-org-element/set-element ()
(ert-deftest test-org-element/set ()
"Test `org-element-set' specifications."
;; Check if new element is inserted.
(should
@ -316,7 +754,15 @@ Some other text
(let* ((tree (org-element-parse-buffer))
(text (org-element-map tree 'plain-text 'identity nil t)))
(org-element-set text "b")
(org-element-map tree 'plain-text 'identity nil t))))))
(org-element-map tree 'plain-text 'identity nil t)))))
;; KEEP-PROPS
(should
(org-element-property
:foo
(org-element-set
(org-element-create 'dummy '(:foo bar))
(org-element-create 'dummy '(:foo2 bar2))
'(:foo)))))
(ert-deftest test-org-element/copy ()
"Test `org-element-copy' specifications."
@ -3989,6 +4435,139 @@ Text
"* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
(org-element-lineage (org-element-context) '(bold) t))))
(ert-deftest test-org-element/lineage-map ()
"Test `org-element-lineage-map' specifications."
(should
(equal '(paragraph center-block section headline headline org-data)
(org-test-with-temp-text
"* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
(org-element-lineage-map (org-element-context) #'org-element-type))))
;; WITH-SELF.
(should
(equal '(bold paragraph center-block section headline headline org-data)
(org-test-with-temp-text
"* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
(org-element-lineage-map (org-element-context) #'org-element-type nil t))))
;; FUN as a Lisp form.
(should
(equal '("H2" "H1")
(org-test-with-temp-text
"* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
(org-element-lineage-map
(org-element-context)
'(org-element-property :raw-value node)))))
;; FIRST-MATCH
(should
(equal "H2"
(org-test-with-temp-text
"* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
(org-element-lineage-map
(org-element-context)
'(org-element-property :raw-value node)
nil nil t)))))
(ert-deftest test-org-element/property-inherited ()
"Test `org-element-property-inherited' specifications."
;; Property without self.
(should
(equal
'bar
(org-element-property-inherited
:foo
(car (org-element-contents
(org-element-create
'parent '(:foo bar)
(org-element-create 'child '(:foo baz))))))))
;; With self
(should
(equal
'baz
(org-element-property-inherited
:foo
(car (org-element-contents
(org-element-create
'parent '(:foo bar)
(org-element-create 'child '(:foo baz)))))
'with-self)))
;; ACCUMULATE non-nil.
(should
(equal
'(bar baz)
(org-element-property-inherited
:foo
(car (org-element-contents
(org-element-create
'parent '(:foo bar)
(org-element-create 'child '(:foo baz)))))
'with-self 'accumulate)))
;; LITERAL-NIL.
(should-not
(org-element-property-inherited
:foo
(org-element-create 'child '(:foo "nil"))
'with-self nil t))
(should
(org-element-property-inherited
:foo
(org-element-create 'child '(:foo "nil"))
'with-self))
;; INCLUDE-NIL
(should-not
(org-element-property-inherited
:foo
(org-element-map
(thread-last
(org-element-create 'grandchild '(:foo baz))
(org-element-create 'child '(:foo nil))
(org-element-create 'parent '(:foo bar)))
'grandchild #'identity nil t)
nil nil nil t))
(should
(eq
'bar
(org-element-property-inherited
:foo
(org-element-map
(thread-last
(org-element-create 'grandchild '(:foo baz))
(org-element-create 'child '(:foo nil))
(org-element-create 'parent '(:foo bar)))
'grandchild #'identity nil t))))
;; INCLUDE-NIL in accumulated.
(should
(equal
'(bar nil baz)
(org-element-property-inherited
:foo
(org-element-map
(thread-last
(org-element-create 'grandchild '(:foo baz))
(org-element-create 'child '(:foo nil))
(org-element-create 'parent '(:foo bar)))
'grandchild #'identity nil t)
'with-self 'accumulate nil t)))
;; PROPERTY as a list.
(should
(equal
'(bar value)
(org-element-property-inherited
'(:foo :extra)
(car (org-element-contents
(org-element-create
'parent '(:foo bar :extra value)
(org-element-create 'child '(:foo baz)))))
nil 'accumulate)))
;; Append list values
(should
(equal
'(bar value value2)
(org-element-property-inherited
'(:foo :extra)
(car (org-element-contents
(org-element-create
'parent '(:foo bar :extra (value value2))
(org-element-create 'child '(:foo baz)))))
nil 'accumulate))))
;;; Test Cache.