1 ;;; test-org-element.el --- Tests for org-element.el
3 ;; Copyright (C) 2012, 2013, 2014 Nicolas Goaziou
5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
7 ;; This program is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation, either version 3 of the License, or
10 ;; (at your option) any later version.
12 ;; This program is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
22 (unless (featurep 'org-element
)
23 (signal 'missing-test-dependency
"org-element"))
25 (defun org-test-parse-and-interpret (text)
26 "Parse TEXT as Org syntax and interpret it.
27 Return interpreted string."
31 (org-element-interpret-data (org-element-parse-buffer))))
35 ;;; Test `org-element-map'
37 (ert-deftest test-org-element
/map
()
38 "Test `org-element-map'."
39 ;; Can map to `plain-text' objects.
42 (org-test-with-temp-text "Some text \alpha
48 (org-element-parse-buffer) 'plain-text
49 (lambda (s) (when (string-match "text" s
) (incf count
))))
51 ;; Applies to secondary strings
53 (org-element-map '("some " (bold nil
"bold") "text") 'bold
'identity
))
54 ;; Enter secondary strings before entering contents.
60 (org-test-with-temp-text "* Some \\alpha headline\n\\beta entity."
61 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
)))))
62 ;; Apply NO-RECURSION argument.
64 (org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
66 (org-element-parse-buffer) 'entity
'identity nil nil
'center-block
)))
67 ;; Use WITH-AFFILIATED argument.
71 (org-test-with-temp-text "#+CAPTION[a]: 1\n#+CAPTION[b]: 2\nParagraph"
73 (org-element-at-point) 'plain-text
'identity nil nil nil t
)))))
79 (ert-deftest test-org-element
/put-property
()
80 "Test `org-element-put-property' specifications."
82 (org-test-with-temp-text "* Headline\n *a*"
83 (let ((tree (org-element-parse-buffer)))
84 (org-element-put-property
85 (org-element-map tree
'bold
'identity nil t
) :test
1)
86 (should (org-element-property
87 :test
(org-element-map tree
'bold
'identity nil t
)))))
88 ;; Put property on a string.
90 (org-element-property :test
(org-element-put-property "Paragraph" :test t
))))
92 (ert-deftest test-org-element
/set-contents
()
93 "Test `org-element-set-contents' specifications."
94 ;; Accept multiple entries.
96 (equal '("b" (italic nil
"a"))
97 (org-test-with-temp-text "* Headline\n *a*"
98 (let ((tree (org-element-parse-buffer)))
99 (org-element-set-contents
100 (org-element-map tree
'bold
'identity nil t
) "b" '(italic nil
"a"))
101 (org-element-contents
102 (org-element-map tree
'bold
'identity nil t
))))))
103 ;; Accept atoms and elements.
106 (org-test-with-temp-text "* Headline\n *a*"
107 (let ((tree (org-element-parse-buffer)))
108 (org-element-set-contents
109 (org-element-map tree
'bold
'identity nil t
) "b")
110 (org-element-contents
111 (org-element-map tree
'bold
'identity nil t
))))))
113 (equal '((italic nil
"b"))
114 (org-test-with-temp-text "* Headline\n *a*"
115 (let ((tree (org-element-parse-buffer)))
116 (org-element-set-contents
117 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"b"))
118 (org-element-contents
119 (org-element-map tree
'bold
'identity nil t
))))))
120 ;; Allow nil contents.
122 (org-test-with-temp-text "* Headline\n *a*"
123 (let ((tree (org-element-parse-buffer)))
124 (org-element-set-contents (org-element-map tree
'bold
'identity nil t
))
125 (org-element-contents (org-element-map tree
'bold
'identity nil t
))))))
127 (ert-deftest test-org-element
/secondary-p
()
128 "Test `org-element-secondary-p' specifications."
129 ;; In a secondary string, return property name.
132 (org-test-with-temp-text "* Headline *object*"
133 (org-element-map (org-element-parse-buffer) 'bold
134 (lambda (object) (org-element-secondary-p object
))
136 ;; Outside a secondary string, return nil.
138 (org-test-with-temp-text "Paragraph *object*"
139 (org-element-map (org-element-parse-buffer) 'bold
140 (lambda (object) (org-element-type (org-element-secondary-p object
)))
143 (ert-deftest test-org-element
/adopt-elements
()
144 "Test `org-element-adopt-elements' specifications."
147 (equal '(plain-text italic
)
148 (org-test-with-temp-text "* Headline\n *a*"
149 (let ((tree (org-element-parse-buffer)))
150 (org-element-adopt-elements
151 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"a"))
152 (mapcar (lambda (blob) (org-element-type blob
))
153 (org-element-contents
154 (org-element-map tree
'bold
'identity nil t
)))))))
158 (org-test-with-temp-text "* Headline\n *a*"
159 (let ((tree (org-element-parse-buffer)))
160 (org-element-adopt-elements
161 (org-element-map tree
'bold
'identity nil t
) "b")
162 (org-element-contents
163 (org-element-map tree
'bold
'identity nil t
)))))))
165 (ert-deftest test-org-element
/extract-element
()
166 "Test `org-element-extract-element' specifications."
167 ;; Extract a greater element.
169 (equal '(org-data nil
)
170 (org-test-with-temp-text "* Headline"
171 (let* ((tree (org-element-parse-buffer))
172 (element (org-element-map tree
'headline
'identity nil t
)))
173 (org-element-extract-element element
)
175 ;; Extract an element.
178 (org-test-with-temp-text "Paragraph"
179 (let* ((tree (org-element-parse-buffer))
180 (element (org-element-map tree
'paragraph
'identity nil t
)))
181 (org-element-extract-element element
)
185 ;; Extract an object, even in a secondary string.
188 (org-test-with-temp-text "*bold*"
189 (let* ((tree (org-element-parse-buffer))
190 (element (org-element-map tree
'bold
'identity nil t
)))
191 (org-element-extract-element element
)
197 (org-test-with-temp-text "* Headline *bold*"
198 (let* ((tree (org-element-parse-buffer))
199 (element (org-element-map tree
'bold
'identity nil t
)))
200 (org-element-extract-element element
)
204 ;; Return value doesn't have any :parent set.
206 (org-element-property
208 (org-test-with-temp-text "* Headline\n Paragraph with *bold* text."
209 (let* ((tree (org-element-parse-buffer))
210 (element (org-element-map tree
'bold
'identity nil t
)))
211 (org-element-extract-element element
))))))
213 (ert-deftest test-org-element
/insert-before
()
214 "Test `org-element-insert-before' specifications."
218 '(italic entity bold
)
219 (org-test-with-temp-text "/some/ *paragraph*"
220 (let* ((tree (org-element-parse-buffer))
221 (paragraph (org-element-map tree
'paragraph
'identity nil t
))
222 (bold (org-element-map tree
'bold
'identity nil t
)))
223 (org-element-insert-before '(entity (:name
"\\alpha")) bold
)
224 (org-element-map tree
'(bold entity italic
) #'org-element-type nil
)))))
225 ;; Insert an object in a secondary string.
229 (org-test-with-temp-text "* /A/\n Paragraph."
230 (let* ((tree (org-element-parse-buffer))
231 (headline (org-element-map tree
'headline
'identity nil t
))
232 (italic (org-element-map tree
'italic
'identity nil t
)))
233 (org-element-insert-before '(entity (:name
"\\alpha")) italic
)
234 (org-element-map (org-element-property :title headline
) '(entity italic
)
235 #'org-element-type
))))))
237 (ert-deftest test-org-element
/set-element
()
238 "Test `org-element-set-element' specifications."
239 ;; Check if new element is inserted.
241 (org-test-with-temp-text "* Headline\n*a*"
242 (let* ((tree (org-element-parse-buffer))
243 (bold (org-element-map tree
'bold
'identity nil t
)))
244 (org-element-set-element bold
'(italic nil
"b"))
245 (org-element-map tree
'italic
'identity
))))
246 ;; Check if old element is removed.
248 (org-test-with-temp-text "* Headline\n*a*"
249 (let* ((tree (org-element-parse-buffer))
250 (bold (org-element-map tree
'bold
'identity nil t
)))
251 (org-element-set-element bold
'(italic nil
"b"))
252 (org-element-map tree
'bold
'identity
))))
253 ;; Check if :parent property is correctly set.
256 (org-test-with-temp-text "* Headline\n*a*"
257 (let* ((tree (org-element-parse-buffer))
258 (bold (org-element-map tree
'bold
'identity nil t
)))
259 (org-element-set-element bold
'(italic nil
"b"))
261 (org-element-property
262 :parent
(org-element-map tree
'italic
'identity nil t
)))))))
263 ;; Allow to replace strings with elements.
266 (org-test-with-temp-text "* Headline"
267 (let* ((tree (org-element-parse-buffer))
268 (text (org-element-map tree
'plain-text
'identity nil t
)))
269 (org-element-set-element text
(list 'bold nil
"b"))
270 (org-element-map tree
'plain-text
'identity
)))))
271 ;; Allow to replace elements with strings.
274 (org-test-with-temp-text "* =verbatim="
275 (let* ((tree (org-element-parse-buffer))
276 (verb (org-element-map tree
'verbatim
'identity nil t
)))
277 (org-element-set-element verb
"a")
278 (org-element-map tree
'plain-text
'identity nil t
)))))
279 ;; Allow to replace strings with strings.
282 (org-test-with-temp-text "a"
283 (let* ((tree (org-element-parse-buffer))
284 (text (org-element-map tree
'plain-text
'identity nil t
)))
285 (org-element-set-element text
"b")
286 (org-element-map tree
'plain-text
'identity nil t
))))))
292 ;;;; Affiliated Keywords
294 (ert-deftest test-org-element
/affiliated-keywords-parser
()
295 "Test affiliated keywords parsing."
296 ;; Read simple keywords.
299 (org-element-property
301 (org-test-with-temp-text "#+NAME: para\nParagraph"
302 (org-element-at-point)))))
305 (org-element-property
307 (org-test-with-temp-text "#+NAME: para\nParagraph"
308 (org-element-at-point)))))
309 ;; Parse multiple keywords.
313 (org-element-property
315 (org-test-with-temp-text
316 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
317 (org-element-at-point)))))
318 ;; Parse "parsed" keywords.
322 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
323 (car (org-element-property :caption
(org-element-at-point))))))
324 ;; Parse dual keywords.
327 '((("long") "short"))
328 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
329 (org-element-property :caption
(org-element-at-point)))))
330 ;; Allow multiple caption keywords.
333 '((("l2") "s2") (("l1") "s1"))
334 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
335 (org-element-property :caption
(org-element-at-point)))))
338 '((("l1")) (nil "s1"))
339 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
340 (org-element-property :caption
(org-element-at-point)))))
341 ;; Corner case: orphaned keyword at the end of an element.
344 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
345 (progn (search-forward "name")
346 (org-element-type (org-element-at-point))))))
348 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
349 (progn (search-forward "Some")
350 (org-element-property :name
(org-element-at-point))))))
355 (ert-deftest test-org-element
/babel-call-parser
()
356 "Test `babel-call' parsing."
359 (org-test-with-temp-text "#+CALL: test()"
360 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
363 (org-test-with-temp-text "#+call: test()"
364 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
365 ;; Handle non-empty blank line at the end of buffer.
367 (org-test-with-temp-text "#+CALL: test()\n "
368 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
373 (ert-deftest test-org-element
/bold-parser
()
374 "Test `bold' parser."
377 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
378 (org-test-with-temp-text "*bold*"
379 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
380 ;; Multi-line markup.
383 (org-element-contents
384 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
385 (org-test-with-temp-text "*first line\nsecond line*"
386 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
387 '("first line\nsecond line"))))
392 (ert-deftest test-org-element
/center-block-parser
()
393 "Test `center-block' parser."
396 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
397 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
400 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
401 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
402 ;; Ignore incomplete block.
404 (org-test-with-temp-text "#+BEGIN_CENTER"
405 (org-element-map (org-element-parse-buffer) 'center-block
407 ;; Handle non-empty blank line at the end of buffer.
409 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
410 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
415 (ert-deftest test-org-element
/clock-parser
()
416 "Test `clock' parser."
418 (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
419 (org-element-at-point))))
420 (should (eq (org-element-property :status clock
) 'running
))
422 (equal (org-element-property :raw-value
423 (org-element-property :value clock
))
424 "[2012-01-01 sun. 00:01]"))
425 (should-not (org-element-property :duration clock
)))
428 (org-test-with-temp-text
429 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
430 (org-element-at-point))))
431 (should (eq (org-element-property :status clock
) 'closed
))
432 (should (equal (org-element-property :raw-value
433 (org-element-property :value clock
))
434 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
435 (should (equal (org-element-property :duration clock
) "0:01"))))
440 (ert-deftest test-org-element
/code-parser
()
441 "Test `code' parser."
444 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
445 (org-test-with-temp-text "~code~"
446 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
447 ;; Multi-line markup.
450 (org-element-property
452 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
453 (org-test-with-temp-text "~first line\nsecond line~"
455 (org-element-parse-buffer) 'code
'identity nil t
))))
456 "first line\nsecond line")))
461 (ert-deftest test-org-element
/comment-parser
()
462 "Test `comment' parser."
465 (org-test-with-temp-text "# Comment"
466 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
469 (org-test-with-temp-text " # Comment"
470 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
471 ;; Preserve indentation.
474 (org-element-property
476 (org-test-with-temp-text "# No blank\n# One blank"
477 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
478 "No blank\n One blank"))
479 ;; Comment with blank lines.
482 (org-element-property
484 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
485 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
486 "First part\n\n\nSecond part"))
487 ;; Do not mix comments and keywords.
490 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
491 (length (org-element-map (org-element-parse-buffer) 'comment
495 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
496 (org-element-property
498 (org-element-map (org-element-parse-buffer) 'comment
500 ;; Correctly handle non-empty blank lines at the end of buffer.
502 (org-test-with-temp-text "# A\n "
503 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
508 (ert-deftest test-org-element
/comment-block-parser
()
509 "Test `comment-block' parser."
512 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
513 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
516 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
517 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
518 ;; Ignore incomplete block.
520 (org-test-with-temp-text "#+BEGIN_COMMENT"
521 (org-element-map (org-element-parse-buffer) 'comment-block
523 ;; Handle non-empty blank line at the end of buffer.
525 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
526 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
531 (ert-deftest test-org-element
/diary-sexp-parser
()
532 "Test `diary-sexp' parser."
536 (org-test-with-temp-text
537 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
538 (org-element-type (org-element-at-point)))))
539 ;; Diary sexp must live at beginning of line
542 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
543 (org-element-type (org-element-at-point)))))
544 ;; Handle non-empty blank line at the end of buffer.
546 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
547 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
552 (ert-deftest test-org-element
/drawer-parser
()
553 "Test `drawer' parser."
556 (org-test-with-temp-text ":TEST:\nText\n:END:"
557 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
558 ;; Do not mix regular drawers and property drawers.
560 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
561 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
562 ;; Ignore incomplete drawer.
564 (org-test-with-temp-text ":TEST:"
565 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
566 ;; Handle non-empty blank line at the end of buffer.
568 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
569 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
574 (ert-deftest test-org-element
/dynamic-block-parser
()
575 "Test `dynamic-block' parser."
578 (org-test-with-temp-text
579 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
580 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
583 (org-test-with-temp-text
584 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
585 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
586 ;; Ignore incomplete block.
588 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
589 (org-element-map (org-element-parse-buffer) 'dynamic-block
591 ;; Handle non-empty blank line at the end of buffer.
593 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
594 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
599 (ert-deftest test-org-element
/entity-parser
()
600 "Test `entity' parser."
603 (org-test-with-temp-text "\\sin"
604 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
607 (org-element-property
609 (org-test-with-temp-text "\\alpha{}text"
610 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
611 ;; User-defined entity.
614 (org-element-property
616 (let ((org-entities-user
617 '(("test" "test" nil
"test" "test" "test" "test"))))
618 (org-test-with-temp-text "\\test"
619 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
621 ;; Special case: entity at the end of a container.
624 (org-test-with-temp-text "*\\alpha \\beta*"
625 (search-forward "be")
626 (org-element-type (org-element-context))))))
631 (ert-deftest test-org-element
/example-block-parser
()
632 "Test `example-block' parser."
635 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
636 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
637 ;; Ignore incomplete block.
640 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
641 (org-element-type (org-element-at-point)))))
642 ;; Properly un-escape code.
644 (equal "* Headline\n #+keyword\nText\n"
645 (org-test-with-temp-text
646 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
647 (org-element-property :value
(org-element-at-point)))))
648 ;; Remove block indentation according to block boundaries, unless
649 ;; block contents are less indented than block boundaries.
652 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
653 (let ((org-src-preserve-indentation t
))
654 (org-element-property :value
(org-element-at-point))))))
658 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
659 (let ((org-src-preserve-indentation t
))
660 (org-element-property :value
(org-element-at-point))))))
661 ;; Handle non-empty blank line at the end of buffer.
663 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
664 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
666 (ert-deftest test-org-element
/block-switches
()
667 "Test `example-block' and `src-block' switches parsing."
668 (let ((org-coderef-label-format "(ref:%s)"))
669 ;; 1. Test "-i" switch.
671 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
672 (org-element-property :preserve-indent
(org-element-at-point))))
674 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
675 (org-element-property :preserve-indent
(org-element-at-point))))
677 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
678 (org-element-property :preserve-indent
(org-element-at-point))))
680 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
681 (org-element-property :preserve-indent
(org-element-at-point))))
682 ;; 2. "-n -r -k" combination should number lines, retain labels but
683 ;; not use them in coderefs.
685 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
686 (let ((element (org-element-at-point)))
687 (and (org-element-property :number-lines element
)
688 (org-element-property :retain-labels element
)
689 (not (org-element-property :use-labels element
))))))
691 (org-test-with-temp-text
692 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
693 (let ((element (org-element-at-point)))
694 (and (org-element-property :number-lines element
)
695 (org-element-property :retain-labels element
)
696 (not (org-element-property :use-labels element
))))))
697 ;; 3. "-n -r" combination should number-lines remove labels and not
698 ;; use them in coderefs.
700 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
701 (let ((element (org-element-at-point)))
702 (and (org-element-property :number-lines element
)
703 (not (org-element-property :retain-labels element
))
704 (not (org-element-property :use-labels element
))))))
706 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
707 (let ((element (org-element-at-point)))
708 (and (org-element-property :number-lines element
)
709 (not (org-element-property :retain-labels element
))
710 (not (org-element-property :use-labels element
))))))
711 ;; 4. "-n" or "+n" should number lines, retain labels and use them
714 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
715 (let ((element (org-element-at-point)))
716 (and (org-element-property :number-lines element
)
717 (org-element-property :retain-labels element
)
718 (org-element-property :use-labels element
)))))
720 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
721 (let ((element (org-element-at-point)))
722 (and (org-element-property :number-lines element
)
723 (org-element-property :retain-labels element
)
724 (org-element-property :use-labels element
)))))
726 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
727 (let ((element (org-element-at-point)))
728 (and (org-element-property :number-lines element
)
729 (org-element-property :retain-labels element
)
730 (org-element-property :use-labels element
)))))
732 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
733 (let ((element (org-element-at-point)))
734 (and (org-element-property :number-lines element
)
735 (org-element-property :retain-labels element
)
736 (org-element-property :use-labels element
)))))
737 ;; 5. No switch should not number lines, but retain labels and use
740 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
741 (let ((element (org-element-at-point)))
742 (and (not (org-element-property :number-lines element
))
743 (org-element-property :retain-labels element
)
744 (org-element-property :use-labels element
)))))
746 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
747 (let ((element (org-element-at-point)))
748 (and (not (org-element-property :number-lines element
))
749 (org-element-property :retain-labels element
)
750 (org-element-property :use-labels element
)))))
751 ;; 6. "-r" switch only: do not number lines, remove labels, and
752 ;; don't use labels in coderefs.
754 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
755 (let ((element (org-element-at-point)))
756 (and (not (org-element-property :number-lines element
))
757 (not (org-element-property :retain-labels element
))
758 (not (org-element-property :use-labels element
))))))
760 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
761 (let ((element (org-element-at-point)))
762 (and (not (org-element-property :number-lines element
))
763 (not (org-element-property :retain-labels element
))
764 (not (org-element-property :use-labels element
))))))
765 ;; 7. Recognize coderefs with user-defined syntax.
769 (org-test-with-temp-text
770 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
771 (org-element-property :label-fmt
(org-element-at-point)))))
775 (org-test-with-temp-text
776 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
777 (org-element-property :label-fmt
(org-element-at-point)))))))
782 (ert-deftest test-org-element
/export-block-parser
()
783 "Test `export-block' parser."
786 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
788 (let ((org-element-block-name-alist
789 '(("LATEX" . org-element-export-block-parser
))))
790 (org-element-parse-buffer))
791 'export-block
'identity
)))
794 (let ((org-element-block-name-alist
795 '(("LATEX" . org-element-export-block-parser
))))
796 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
797 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
798 ;; Ignore incomplete block.
800 (let ((org-element-block-name-alist
801 '(("LATEX" . org-element-export-block-parser
))))
802 (org-test-with-temp-text "#+BEGIN_LATEX"
803 (org-element-map (org-element-parse-buffer) 'export-block
805 ;; Handle non-empty blank line at the end of buffer.
807 (let ((org-element-block-name-alist
808 '(("LATEX" . org-element-export-block-parser
))))
809 (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
810 (= (org-element-property :end
(org-element-at-point)) (point-max))))))
815 (ert-deftest test-org-element
/export-snippet-parser
()
816 "Test `export-snippet' parser."
819 '("back-end" .
"contents")
820 (org-test-with-temp-text "@@back-end:contents@@"
822 (org-element-parse-buffer) 'export-snippet
823 (lambda (snippet) (cons (org-element-property :back-end snippet
)
824 (org-element-property :value snippet
)))
830 (ert-deftest test-org-element
/fixed-width-parser
()
831 "Test fixed-width area parsing."
832 ;; Preserve indentation.
834 (org-test-with-temp-text ": no blank\n: one blank"
835 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
836 ;; Fixed-width with empty lines.
838 (org-test-with-temp-text ": first part\n:\n: \n: second part"
839 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
840 ;; Parse indented fixed-width markers.
842 (org-test-with-temp-text "Text\n : no blank\n : one blank"
843 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
844 ;; Distinguish fixed-width areas within a list and outside of it.
848 (org-test-with-temp-text "
851 : fixed-width outside"
852 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
853 ;; Handle non-empty blank line at the end of buffer.
855 (org-test-with-temp-text ": A\n "
856 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
859 ;;;; Footnote Definition
861 (ert-deftest test-org-element
/footnote-definition-parser
()
862 "Test `footnote-definition' parser."
864 (org-test-with-temp-text "[fn:1] Definition"
865 (org-element-map (org-element-parse-buffer) 'footnote-definition
867 ;; Footnote with more contents
870 (org-element-property
872 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
873 (org-element-map (org-element-parse-buffer) 'footnote-definition
875 ;; Footnote starting with special syntax.
877 (org-test-with-temp-text "[fn:1] - no item"
878 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
879 ;; Correctly handle footnote starting with an empty line.
882 (org-test-with-temp-text "[fn:1]\n\n Body"
883 (org-element-property :contents-begin
(org-element-at-point)))))
884 ;; Handle non-empty blank line at the end of buffer.
886 (org-test-with-temp-text "[fn:1] Definition\n "
887 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
890 ;;;; Footnotes Reference.
892 (ert-deftest test-org-element
/footnote-reference-parser
()
893 "Test `footnote-reference' parser."
894 ;; 1. Parse a standard reference.
895 (org-test-with-temp-text "Text[fn:label]"
898 (org-element-parse-buffer) 'footnote-reference
'identity
)))
899 ;; 2. Parse a normalized reference.
900 (org-test-with-temp-text "Text[1]"
903 (org-element-parse-buffer) 'footnote-reference
'identity
)))
904 ;; 3. Parse an inline reference.
905 (org-test-with-temp-text "Text[fn:test:def]"
908 (org-element-parse-buffer) 'footnote-reference
'identity
)))
909 ;; 4. Parse an anonymous reference.
910 (org-test-with-temp-text "Text[fn::def]"
913 (org-element-parse-buffer) 'footnote-reference
'identity
)))
914 ;; 5. Parse nested footnotes.
915 (org-test-with-temp-text "Text[fn::def [fn:label]]"
920 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
921 ;; 6. Parse adjacent footnotes.
922 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
927 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
928 ;; 7. Only properly closed footnotes are recognized as such.
929 (org-test-with-temp-text "Text[fn:label"
932 (org-element-parse-buffer) 'footnote-reference
'identity
))))
937 (ert-deftest test-org-element
/headline-comment-keyword
()
938 "Test COMMENT keyword recognition."
940 (org-test-with-temp-text "* Headline"
941 (let ((org-comment-string "COMMENT"))
942 (should-not (org-element-property :commentedp
(org-element-at-point)))))
943 ;; Standard position.
944 (org-test-with-temp-text "* COMMENT Headline"
945 (let ((org-comment-string "COMMENT")
946 (headline (org-element-at-point)))
947 (should (org-element-property :commentedp headline
))
948 (should (equal (org-element-property :raw-value headline
) "Headline"))))
950 (org-test-with-temp-text "* COMMENT Headline"
951 (let* ((org-comment-string "Comment")
952 (headline (org-element-at-point)))
953 (should-not (org-element-property :commentedp headline
))
954 (should (equal (org-element-property :raw-value headline
)
955 "COMMENT Headline"))))
956 ;; With another keyword.
957 (org-test-with-temp-text "* TODO COMMENT Headline"
958 (let* ((org-comment-string "COMMENT")
959 (org-todo-keywords '((sequence "TODO" "DONE")))
960 (headline (org-element-at-point)))
961 (should (org-element-property :commentedp headline
))
962 (should (equal (org-element-property :raw-value headline
) "Headline"))))
963 ;; With the keyword only.
964 (org-test-with-temp-text "* COMMENT"
965 (let* ((org-comment-string "COMMENT")
966 (headline (org-element-at-point)))
967 (should (org-element-property :commentedp headline
))
968 (should (equal (org-element-property :raw-value headline
) "")))))
970 (ert-deftest test-org-element
/headline-archive-tag
()
971 "Test ARCHIVE tag recognition."
974 (org-test-with-temp-text "* Headline"
975 (let ((org-archive-tag "ARCHIVE"))
976 (org-element-property :archivedp
(org-element-at-point)))))
978 (org-test-with-temp-text "* Headline :ARCHIVE:"
979 (let ((org-archive-tag "ARCHIVE"))
980 (let ((headline (org-element-at-point)))
981 (should (org-element-property :archivedp headline
))
983 (should-not (org-element-property :tags headline
)))))
985 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
986 (let ((org-archive-tag "ARCHIVE"))
987 (let ((headline (org-element-at-point)))
988 (should (org-element-property :archivedp headline
))
990 (should (equal (org-element-property :tags headline
) '("test"))))))
991 ;; Tag is case-sensitive.
993 (org-test-with-temp-text "* Headline :ARCHIVE:"
994 (let ((org-archive-tag "Archive"))
995 (org-element-property :archivedp
(org-element-at-point))))))
997 (ert-deftest test-org-element
/headline-properties
()
998 "Test properties from property drawer."
999 ;; All properties from property drawer have their symbol upper
1002 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1003 (org-element-property :FOO
(org-element-at-point))))
1005 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1006 (org-element-property :foo
(org-element-at-point)))))
1009 ;;;; Horizontal Rule
1011 (ert-deftest test-org-element
/horizontal-rule-parser
()
1012 "Test `horizontal-rule' parser."
1015 (org-test-with-temp-text "-----"
1016 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1019 (org-test-with-temp-text " -----"
1020 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1021 ;; Hyphen must be alone on the line.
1023 (org-test-with-temp-text "-----wrong"
1024 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1025 ;; 4 hyphens is too small.
1027 (org-test-with-temp-text "----"
1028 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1029 ;; Handle non-empty blank line at the end of buffer.
1031 (org-test-with-temp-text "-----\n "
1032 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1035 ;;;; Inline Babel Call
1037 (ert-deftest test-org-element
/inline-babel-call-parser
()
1038 "Test `inline-babel-call' parser."
1040 (org-test-with-temp-text "call_test()"
1042 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
1045 ;;;; Inline Src Block
1047 (ert-deftest test-org-element
/inline-src-block-parser
()
1048 "Test `inline-src-block' parser."
1050 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1051 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1052 ;; Test parsing at the beginning of an item.
1054 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1055 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
1060 (ert-deftest test-org-element
/inlinetask-parser
()
1061 "Test `inlinetask' parser."
1062 (when (featurep 'org-inlinetask
)
1063 (let ((org-inlinetask-min-level 15))
1064 ;; Regular inlinetask.
1067 (org-test-with-temp-text
1068 "*************** Task\nTest\n*************** END"
1069 (org-element-type (org-element-at-point)))))
1070 ;; Degenerate inlinetask.
1073 (org-test-with-temp-text "*************** Task"
1074 (org-element-type (org-element-at-point)))))
1075 ;; Mixed inlinetasks.
1077 (org-test-with-temp-text
1079 *************** Task
1080 *************** Task2
1082 *************** END"
1084 (goto-char (org-element-property :end
(org-element-at-point)))
1090 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1091 (org-test-with-temp-text "*************** TODO Task"
1092 (org-element-property :todo-keyword
(org-element-at-point))))))
1095 (org-test-with-temp-text "
1096 *************** Task
1097 DEADLINE: <2012-03-29 thu.>"
1099 (org-element-property :deadline
(org-element-at-point))))
1104 (org-test-with-temp-text "
1105 *************** [#A] Task"
1107 (org-element-property :priority
(org-element-at-point)))))
1112 (org-test-with-temp-text "
1113 *************** Task :test:"
1115 (org-element-property :tags
(org-element-at-point)))))
1116 ;; Regular properties are accessed through upper case keywords.
1118 (org-test-with-temp-text "
1119 *************** Task
1123 *************** END"
1125 (org-element-property :FOO
(org-element-at-point))))
1127 (org-test-with-temp-text "
1128 *************** Task
1132 *************** END"
1134 (org-element-property :foo
(org-element-at-point))))
1135 ;; Handle non-empty blank line at the end of buffer.
1137 (org-test-with-temp-text "*************** Task\n*************** END\n "
1138 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1143 (ert-deftest test-org-element
/italic-parser
()
1144 "Test `italic' parser."
1147 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1148 (org-test-with-temp-text "/italic/"
1149 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1150 ;; Multi-line markup.
1153 (org-element-contents
1154 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1155 (org-test-with-temp-text "/first line\nsecond line/"
1156 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1157 '("first line\nsecond line"))))
1162 (ert-deftest test-org-element
/item-parser
()
1163 "Test `item' parser."
1166 (org-test-with-temp-text "- item"
1167 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1171 (org-element-property
1173 (org-test-with-temp-text "6. [@6] item"
1174 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1179 (org-element-property
1181 (org-test-with-temp-text "- tag :: description"
1182 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1183 ;; No tags in ordered lists.
1185 (org-element-property
1187 (org-test-with-temp-text "1. tag :: description"
1188 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1193 (org-test-with-temp-text "
1198 (org-element-parse-buffer) 'item
1199 (lambda (item) (org-element-property :checkbox item
))))))
1200 ;; Item starting with special syntax.
1202 (equal '(("- item"))
1203 (org-test-with-temp-text "- - item"
1204 (org-element-map (org-element-parse-buffer) 'paragraph
1205 'org-element-contents
))))
1206 ;; Block in an item: ignore indentation within the block.
1208 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1210 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1215 (ert-deftest test-org-element
/keyword-parser
()
1216 "Test `keyword' parser."
1219 (org-test-with-temp-text "#+KEYWORD: value"
1220 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1221 ;; Keywords are case-insensitive.
1223 (org-test-with-temp-text "#+keyword: value"
1224 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1225 ;; Affiliated keywords are not keywords.
1227 (org-test-with-temp-text "#+NAME: value
1229 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1230 ;; Do not mix keywords with Babel calls and dynamic blocks.
1232 (org-test-with-temp-text "#+CALL: fun()"
1233 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1235 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1236 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1237 ;; Handle non-empty blank line at the end of buffer.
1239 (org-test-with-temp-text "#+KEYWORD: value\n "
1240 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1243 ;;;; Latex Environment
1245 (ert-deftest test-org-element
/latex-environment-parser
()
1246 "Test `latex-environment' parser."
1248 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1249 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1250 ;; Allow nested environments.
1258 (org-test-with-temp-text "
1264 (org-element-property
1267 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1268 ;; Allow environments with options and arguments.
1270 (eq 'latex-environment
1271 (org-test-with-temp-text
1272 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1273 (org-element-type (org-element-at-point)))))
1275 (eq 'latex-environment
1276 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1277 (org-element-type (org-element-at-point)))))
1279 (eq 'latex-environment
1280 (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1281 (org-element-type (org-element-at-point)))))
1282 ;; Handle non-empty blank line at the end of buffer.
1284 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1285 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1290 (ert-deftest test-org-element
/latex-fragment-parser
()
1291 "Test `latex-fragment' parser."
1293 (org-test-with-temp-text "$a$"
1294 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1296 (org-test-with-temp-text "$$a$$"
1297 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1299 (org-test-with-temp-text "\\(a\\)"
1300 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1302 (org-test-with-temp-text "\\[a\\]"
1304 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1305 ;; Test fragment at the beginning of an item.
1308 (org-test-with-temp-text "- $x$"
1309 (progn (search-forward "$")
1310 (org-element-type (org-element-context)))))))
1315 (ert-deftest test-org-element
/line-break-parser
()
1316 "Test `line-break' parser."
1319 (org-test-with-temp-text "Text \\\\"
1320 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1321 ;; Line break with trailing white spaces.
1323 (org-test-with-temp-text "Text \\\\ "
1324 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1325 ;; Three backslashes are too much.
1327 (org-test-with-temp-text "Text \\\\\\"
1328 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1333 (ert-deftest test-org-element
/link-parser
()
1334 "Test `link' parser."
1339 (org-test-with-temp-text "A radio link"
1340 (org-element-property
1343 (let ((org-target-link-regexp "radio")) (org-element-parse-buffer))
1344 'link
'identity nil t
)))))
1347 ;; ... with description.
1351 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1352 (org-element-contents
1353 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1354 ;; ... without description.
1358 (org-test-with-temp-text "[[http://orgmode.org]]"
1359 (org-element-property
1361 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1362 ;; ... with expansion.
1365 "//orgmode.org/worg"
1366 (org-test-with-temp-text "[[Org:worg]]"
1367 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1368 (org-element-property
1370 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1371 ;; ... with translation.
1375 (org-test-with-temp-text "[[http://orgmode.org]]"
1376 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1377 (let ((org-link-translation-function 'link-translate
))
1378 (org-element-property
1380 (org-element-map (org-element-parse-buffer) 'link
1381 'identity nil t
)))))))
1386 (org-test-with-temp-text "[[id:aaaa]]"
1387 (org-element-property
1389 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1390 ;; ... custom-id link.
1394 (org-test-with-temp-text "[[#some-id]]"
1395 (org-element-property
1397 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1398 ;; ... coderef link.
1402 (org-test-with-temp-text "[[(reference)]]"
1403 (org-element-property
1405 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1410 (org-test-with-temp-text "[[target-or-title]]"
1411 (org-element-property
1413 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1414 ;; ... file-type link with search option.
1417 '(("file" "projects.org" "*task title"))
1418 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1419 (org-element-map (org-element-parse-buffer) 'link
1420 (lambda (l) (list (org-element-property :type l
)
1421 (org-element-property :path l
)
1422 (org-element-property :search-option l
)))))))
1423 ;; ... file-type link with application.
1426 '(("file" "projects.org" "docview"))
1427 (org-test-with-temp-text "[[docview:projects.org]]"
1428 (org-element-map (org-element-parse-buffer) 'link
1429 (lambda (l) (list (org-element-property :type l
)
1430 (org-element-property :path l
)
1431 (org-element-property :application l
)))))))
1434 (org-test-with-temp-text "A link: http://orgmode.org"
1435 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1438 (org-test-with-temp-text "A link: <http://orgmode.org>"
1439 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1440 ;; Link abbreviation.
1443 (org-test-with-temp-text
1444 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1445 (progn (org-mode-restart)
1446 (goto-char (1- (point-max)))
1447 (org-element-property :type
(org-element-context))))))
1448 ;; Link abbreviation in a secondary string.
1451 (org-test-with-temp-text
1452 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1453 (progn (org-mode-restart)
1454 (org-element-map (org-element-parse-buffer) 'link
1455 (lambda (link) (org-element-property :type link
))
1457 ;; Plain links are allowed as description of regular links.
1460 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1461 (search-forward "file:")
1462 (org-element-property :type
(org-element-context))))))
1467 (ert-deftest test-org-element
/macro-parser
()
1468 "Test `macro' parser."
1469 ;; Without arguments.
1471 (org-test-with-temp-text "{{{macro}}}"
1472 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1475 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1476 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1477 ;; Properly handle protected commas in arguments...
1481 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1482 (org-element-property :args
(org-element-context))))))
1483 ;; ... even when last argument ends with a protected comma.
1486 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1487 (org-element-property :args
(org-element-context)))))
1488 ;; Allow to escape escaping character.
1491 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1492 (org-element-property :args
(org-element-context)))))
1493 ;; No need to escape backslashes elsewhere.
1496 (org-test-with-temp-text "{{{macro(\\)}}}"
1497 (org-element-property :args
(org-element-context))))))
1502 (ert-deftest test-org-element
/node-property
()
1503 "Test `node-property' parser."
1506 (equal '("abc" "value")
1507 (org-test-with-temp-text ":PROPERTIES:\n:abc: value\n:END:"
1508 (progn (forward-line)
1509 (let ((element (org-element-at-point)))
1510 (list (org-element-property :key element
)
1511 (org-element-property :value element
)))))))
1512 ;; Value should be trimmed.
1515 (org-test-with-temp-text ":PROPERTIES:\n:abc: value \n:END:"
1516 (progn (forward-line)
1517 (let ((element (org-element-at-point)))
1518 (org-element-property :value element
))))))
1519 ;; A node property requires to be wrapped within a property drawer.
1522 (org-test-with-temp-text ":abc: value"
1523 (org-element-type (org-element-at-point))))))
1528 (ert-deftest test-org-element
/paragraph-parser
()
1529 "Test `paragraph' parser."
1532 (org-test-with-temp-text "Paragraph"
1533 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1534 ;; Property find end of a paragraph stuck to another element.
1537 (org-test-with-temp-text "Paragraph\n# Comment"
1538 (org-element-map (org-element-parse-buffer) 'paragraph
1539 (lambda (p) (char-after (org-element-property :end p
)))
1541 ;; Include ill-formed Keywords.
1543 (org-test-with-temp-text "#+wrong_keyword something"
1544 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1545 ;; Include incomplete-drawers.
1547 (org-test-with-temp-text ":TEST:\nParagraph"
1548 (let ((elem (org-element-at-point)))
1549 (and (eq (org-element-type elem
) 'paragraph
)
1550 (= (point-max) (org-element-property :end elem
))))))
1551 ;; Include incomplete blocks.
1553 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1554 (let ((elem (org-element-at-point)))
1555 (and (eq (org-element-type elem
) 'paragraph
)
1556 (= (point-max) (org-element-property :end elem
))))))
1557 ;; Include incomplete dynamic blocks.
1559 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1560 (let ((elem (org-element-at-point)))
1561 (and (eq (org-element-type elem
) 'paragraph
)
1562 (= (point-max) (org-element-property :end elem
))))))
1563 ;; Include incomplete latex environments.
1565 (org-test-with-temp-text "\begin{equation}\nParagraph"
1566 (let ((elem (org-element-at-point)))
1567 (and (eq (org-element-type elem
) 'paragraph
)
1568 (= (point-max) (org-element-property :end elem
))))))
1569 ;; Do not steal affiliated keywords from container.
1571 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1572 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1573 (and (eq (org-element-type elem
) 'paragraph
)
1574 (not (org-element-property :attr_latex elem
))
1575 (/= (org-element-property :begin elem
) 1)))))
1576 ;; Handle non-empty blank line at the end of buffer.
1578 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1579 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1584 (ert-deftest test-org-element
/plain-list-parser
()
1585 "Test `plain-list' parser."
1586 (org-test-with-temp-text "- item"
1587 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1588 ;; Blank lines after the list only belong to outer plain list.
1592 (org-test-with-temp-text "
1597 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1598 (lambda (pl) (org-element-property :end pl
)))))
1600 ;; Move to ending of outer list.
1601 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1602 ;; Move to ending of inner list.
1603 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1604 ;; Correctly compute end of list if it doesn't end at a line
1607 (org-test-with-temp-text "- list\n \n "
1608 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1613 (ert-deftest test-org-element
/planning-parser
()
1614 "Test `planning' parser."
1616 (equal "[2012-03-29 thu.]"
1617 (org-element-property
1619 (org-element-property
1621 (org-test-with-temp-text "CLOSED: [2012-03-29 thu.]"
1622 (org-element-at-point))))))
1624 (equal "<2012-03-29 thu.>"
1625 (org-element-property
1627 (org-element-property
1629 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1630 (org-element-at-point))))))
1632 (equal "<2012-03-29 thu.>"
1633 (org-element-property
1635 (org-element-property
1637 (org-test-with-temp-text "SCHEDULED: <2012-03-29 thu.>"
1638 (org-element-at-point)))))))
1641 ;;;; Property Drawer
1643 (ert-deftest test-org-element
/property-drawer-parser
()
1644 "Test `property-drawer' parser."
1647 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
1649 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1650 ;; Do not mix property drawers and regular drawers.
1652 (org-test-with-temp-text ":TEST:\n:prop: value\n:END:"
1654 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1655 ;; Ignore incomplete drawer.
1657 (org-test-with-temp-text ":PROPERTIES:\n:prop: value"
1659 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1660 ;; Handle non-empty blank line at the end of buffer.
1662 (org-test-with-temp-text ":PROPERTIES:\n:END:\n "
1663 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1668 (ert-deftest test-org-element
/quote-block-parser
()
1669 "Test `quote-block' parser."
1672 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1673 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1674 ;; Ignore incomplete block.
1676 (org-test-with-temp-text "#+BEGIN_QUOTE"
1677 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1678 ;; Handle non-empty blank line at the end of buffer.
1680 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1681 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1686 (ert-deftest test-org-element
/radio-target-parser
()
1687 "Test `radio-target' parser."
1690 (org-test-with-temp-text "<<<radio>>>"
1691 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
)))
1692 ;; Radio targets with objects.
1694 (org-test-with-temp-text "<<<radio \\alpha>>>"
1695 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
))))
1700 (ert-deftest test-org-element
/section-parser
()
1701 "Test `section' parser."
1704 (org-test-with-temp-text "* Headline\nText"
1705 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1706 ;; There's a section before the first headline.
1708 (org-test-with-temp-text "Text"
1709 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1710 ;; A section cannot be empty.
1712 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1713 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1714 ;; A section doesn't contain sub-trees.
1716 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1718 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1719 'headline
'identity
))))
1724 (ert-deftest test-org-element
/special-block-parser
()
1725 "Test `special-block' parser."
1729 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1730 (org-element-property :type
(org-element-at-point)))))
1731 ;; Special blocks can contain paragraphs.
1734 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1736 (org-element-type (org-element-at-point)))))
1737 ;; Ignore incomplete block.
1740 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1741 (org-element-type (org-element-at-point)))))
1742 ;; Allow special characters in type.
1744 (equal '(special-block "SPECIAL*")
1745 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1746 (let ((element (org-element-at-point)))
1747 (list (org-element-type element
)
1748 (org-element-property :type element
))))))
1749 ;; Handle non-empty blank line at the end of buffer.
1751 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1752 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1757 (ert-deftest test-org-element
/src-block-parser
()
1758 "Test `src-block' parser."
1761 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1762 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1763 ;; Ignore incomplete block.
1765 (org-test-with-temp-text "#+BEGIN_SRC"
1766 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1767 ;; Properly un-escape code.
1769 (equal "* Headline\n #+keyword\nText\n"
1770 (org-test-with-temp-text
1771 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1772 (org-element-property :value
(org-element-at-point)))))
1773 ;; Remove block indentation according to block boundaries, unless
1774 ;; block contents are less indented than block boundaries.
1777 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1778 (let ((org-src-preserve-indentation t
))
1779 (org-element-property :value
(org-element-at-point))))))
1783 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1784 (let ((org-src-preserve-indentation t
))
1785 (org-element-property :value
(org-element-at-point))))))
1786 ;; Handle non-empty blank line at the end of buffer.
1788 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
1789 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1792 ;;;; Statistics Cookie
1794 (ert-deftest test-org-element
/statistics-cookie
()
1795 "Test `statistics-cookie' parser."
1798 (org-test-with-temp-text "[1/2]"
1799 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1802 (org-test-with-temp-text "[33%]"
1804 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1809 (ert-deftest test-org-element
/strike-through-parser
()
1810 "Test `strike-through' parser."
1813 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1814 (org-test-with-temp-text "+strike-through+"
1815 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1816 ;; Multi-line markup.
1819 (org-element-contents
1820 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1821 (org-test-with-temp-text "+first line\nsecond line+"
1823 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1824 '("first line\nsecond line"))))
1829 (ert-deftest test-org-element
/subscript-parser
()
1830 "Test `subscript' parser."
1833 (org-test-with-temp-text "a_b"
1834 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1837 (org-test-with-temp-text "a_{b}"
1838 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1839 ;; Multiple subscripts in a paragraph.
1842 (org-test-with-temp-text "a_b and c_d"
1844 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1849 (ert-deftest test-org-element
/superscript-parser
()
1850 "Test `superscript' parser."
1853 (org-test-with-temp-text "a^b"
1854 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1857 (org-test-with-temp-text "a^{b}"
1858 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1859 ;; Multiple superscript in a paragraph.
1862 (org-test-with-temp-text "a^b and c^d"
1865 (org-element-parse-buffer) 'superscript
'identity
))))))
1870 (ert-deftest test-org-element
/table-parser
()
1871 "Test `table' parser."
1873 (org-test-with-temp-text "| a |"
1874 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
1875 ;; TBLFM keyword is case insensitive.
1877 (org-test-with-temp-text "| a |\n#+tblfm: test"
1878 (org-element-property
1880 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
1881 ;; Handle multiple TBLFM lines.
1884 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
1885 (length (org-element-property
1888 (org-element-parse-buffer) 'table
'identity nil t
))))))
1889 ;; Handle non-empty blank line at the end of buffer.
1891 (org-test-with-temp-text "| a |\n "
1892 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1897 (ert-deftest test-org-element
/table-cell-parser
()
1898 "Test `table-cell' parser."
1900 (org-test-with-temp-text "| a |"
1901 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
1906 (ert-deftest test-org-element
/table-row-parser
()
1907 "Test `table-row' parser."
1909 (equal '(standard rule
)
1910 (org-test-with-temp-text "| a |\n|---|"
1912 (org-element-parse-buffer) 'table-row
1913 (lambda (row) (org-element-property :type row
)))))))
1918 (ert-deftest test-org-element
/target-parser
()
1919 "Test `target' parser."
1921 (org-test-with-temp-text "<<target>>"
1922 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
1927 (ert-deftest test-org-element
/timestamp
()
1928 "Test `timestamp' parser."
1929 ;; Active timestamp.
1931 (org-test-with-temp-text "<2012-03-29 16:40>"
1932 (eq (org-element-property :type
(org-element-context)) 'active
)))
1934 (org-test-with-temp-text "<2012-03-29 Thu>"
1935 (let ((timestamp (org-element-context)))
1936 (or (org-element-property :hour-start timestamp
)
1937 (org-element-property :minute-start timestamp
)))))
1939 (equal '(2012 3 29 16 40)
1940 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
1941 (let ((object (org-element-context)))
1942 (list (org-element-property :year-start object
)
1943 (org-element-property :month-start object
)
1944 (org-element-property :day-start object
)
1945 (org-element-property :hour-start object
)
1946 (org-element-property :minute-start object
))))))
1947 ;; Inactive timestamp.
1949 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
1950 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
1953 (equal '(2012 3 29 16 40 7 30)
1954 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1955 (let ((object (org-element-context)))
1956 (list (org-element-property :year-end object
)
1957 (org-element-property :month-end object
)
1958 (org-element-property :day-end object
)
1959 (org-element-property :hour-end object
)
1960 (org-element-property :minute-end object
)
1961 (org-element-property :hour-start object
)
1962 (org-element-property :minute-start object
))))))
1965 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1966 (org-element-property :type
(org-element-context)))))
1969 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
1970 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
1972 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
1973 (let ((timestamp (org-element-context)))
1974 (or (org-element-property :hour-end timestamp
)
1975 (org-element-property :minute-end timestamp
)))))
1976 ;; With repeater, warning delay and both.
1979 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
1980 (org-element-property :repeater-type
(org-element-context)))))
1983 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
1984 (org-element-property :warning-type
(org-element-context)))))
1986 (equal '(cumulate all
)
1987 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
1988 (let ((ts (org-element-context)))
1989 (list (org-element-property :repeater-type ts
)
1990 (org-element-property :warning-type ts
))))))
1991 ;; Timestamps are not planning elements.
1993 (org-test-with-temp-text "SCHEDULED: <2012-03-29 Thu 16:40>"
1994 (org-element-map (org-element-parse-buffer) 'timestamp
'identity
))))
1999 (ert-deftest test-org-element
/underline-parser
()
2000 "Test `underline' parser."
2003 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2004 (org-test-with-temp-text "_underline_"
2005 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
2006 ;; Multi-line markup.
2009 (org-element-contents
2010 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2011 (org-test-with-temp-text "_first line\nsecond line_"
2013 (org-element-parse-buffer) 'underline
'identity nil t
))))
2014 '("first line\nsecond line"))))
2019 (ert-deftest test-org-element
/verbatim-parser
()
2020 "Test `verbatim' parser."
2023 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2024 (org-test-with-temp-text "=verbatim="
2025 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
2026 ;; Multi-line markup.
2029 (org-element-property
2031 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2032 (org-test-with-temp-text "=first line\nsecond line="
2034 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
2035 "first line\nsecond line")))
2040 (ert-deftest test-org-element
/verse-block-parser
()
2041 "Test `verse-block' parser."
2044 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2045 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2048 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2049 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2050 ;; Parse objects in verse blocks.
2052 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2053 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
2054 ;; Ignore incomplete verse block.
2056 (org-test-with-temp-text "#+BEGIN_VERSE"
2057 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
2058 ;; Handle non-empty blank line at the end of buffer.
2060 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2061 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2065 ;;; Test Interpreters.
2067 (ert-deftest test-org-element
/interpret-data
()
2068 "Test `org-element-interpret-data' specifications."
2069 ;; Interpret simple affiliated keywords.
2072 (org-element-interpret-data
2073 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2074 "#+NAME: para\nParagraph\n"))
2075 ;; Interpret multiple affiliated keywords.
2078 (org-element-interpret-data
2079 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2080 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2081 ;; Interpret parsed affiliated keywords.
2084 (org-element-interpret-data
2085 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2086 "#+CAPTION: caption\nParagraph\n"))
2087 ;; Interpret dual affiliated keywords.
2090 (org-element-interpret-data
2091 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2092 "#+CAPTION[short]: long\nParagraph\n"))
2093 ;; Interpret multiple parsed dual keywords.
2096 (org-element-interpret-data
2097 '(org-data nil
(paragraph
2098 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2099 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2100 ;; Pseudo objects and elements are transparent.
2103 (org-element-interpret-data
2104 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")
2108 (org-element-interpret-data
2110 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2111 (paragraph nil
"B"))))))
2113 (ert-deftest test-org-element
/center-block-interpreter
()
2114 "Test center block interpreter."
2116 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2117 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2119 (ert-deftest test-org-element
/drawer-interpreter
()
2120 "Test drawer interpreter."
2122 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2123 ":TEST:\nTest\n:END:\n")))
2125 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2126 "Test dynamic block interpreter."
2128 (equal (org-test-parse-and-interpret
2129 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2130 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2132 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2133 "Test footnote definition interpreter."
2134 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2136 (ert-deftest test-org-element
/headline-interpreter
()
2137 "Test headline and section interpreters."
2138 ;; 1. Standard test.
2139 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2140 ;; 2. With TODO keywords.
2142 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2143 (org-test-parse-and-interpret "* TODO Headline"))
2144 "* TODO Headline\n"))
2147 ;; 3.1. ... and a positive `org-tags-column' value.
2149 (equal (let ((org-tags-column 20))
2150 (org-test-parse-and-interpret "* Headline :tag:"))
2151 "* Headline :tag:\n"))
2152 ;; 3.2. ... and a negative `org-tags-column' value.
2154 (equal (let ((org-tags-column -
20))
2155 (org-test-parse-and-interpret "* Headline :tag:"))
2156 "* Headline :tag:\n"))
2157 ;; 3.3. ... and a null `org-tags-column' value.
2159 (equal (let ((org-tags-column 0))
2160 (org-test-parse-and-interpret "* Headline :tag:"))
2161 "* Headline :tag:\n"))
2162 ;; 4. With priority cookie.
2164 (equal (org-test-parse-and-interpret "* [#B] Headline")
2165 "* [#B] Headline\n"))
2166 ;; 5. With comment keyword.
2168 (equal (let ((org-comment-string "COMMENT"))
2169 (org-test-parse-and-interpret "* COMMENT Headline"))
2170 "* COMMENT Headline\n"))
2171 ;; 6. Keep same number of blank lines before body.
2173 (equal (org-test-parse-and-interpret
2174 "* Headline\n\n\nText after two blank lines.")
2175 "* Headline\n\n\nText after two blank lines.\n")))
2177 (ert-deftest test-org-element
/inlinetask-interpreter
()
2178 "Test inlinetask interpretation."
2179 (when (featurep 'org-inlinetask
)
2180 (let ((org-inlinetask-min-level 15))
2181 ;; 1. Regular inlinetask.
2182 (should (equal (org-test-parse-and-interpret
2183 "*************** Task\nTest\n*************** END")
2184 "*************** Task\nTest\n*************** END\n"))
2185 ;; 2. Degenerate inlinetask.
2186 (should (equal (org-test-parse-and-interpret "*************** Task")
2187 "*************** Task\n"))
2188 ;; 3. Prefer degenerate form when there are no contents.
2189 (should (equal (org-test-parse-and-interpret
2190 "*************** Task\n*************** END")
2191 "*************** Task\n"))
2192 ;; 4. With TODO keywords.
2194 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2195 (org-test-parse-and-interpret "*************** TODO Task"))
2196 "*************** TODO Task\n"))
2199 ;; 5.1. ... and a positive `org-tags-column' value.
2201 (equal (let ((org-tags-column 30))
2202 (org-test-parse-and-interpret "*************** Task :tag:"))
2203 "*************** Task :tag:\n"))
2204 ;; 5.2. ... and a negative `org-tags-column' value.
2206 (equal (let ((org-tags-column -
30))
2207 (org-test-parse-and-interpret "*************** Task :tag:"))
2208 "*************** Task :tag:\n"))
2209 ;; 5.3. ... and a null `org-tags-column' value.
2211 (equal (let ((org-tags-column 0))
2212 (org-test-parse-and-interpret "*************** Task :tag:"))
2213 "*************** Task :tag:\n"))
2214 ;; 6. With priority cookie.
2216 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2217 "*************** [#B] Task\n")))))
2219 (ert-deftest test-org-element
/plain-list-interpreter
()
2220 "Test plain-list and item interpreters."
2221 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2223 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2224 ;; Description list.
2226 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2229 (equal (let ((org-plain-list-ordered-item-terminator t
))
2230 (org-test-parse-and-interpret "1. Item"))
2233 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2234 (org-test-parse-and-interpret "1) Item"))
2236 ;; Ordered list with counter.
2238 (equal (let ((org-plain-list-ordered-item-terminator t
))
2239 (org-test-parse-and-interpret "1. [@5] Item"))
2241 ;; List with check-boxes.
2243 (equal (org-test-parse-and-interpret
2244 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2245 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2246 ;; Item not starting with a paragraph.
2248 (equal (org-test-parse-and-interpret "-\n | a | b |")
2249 "- \n | a | b |\n"))
2250 ;; Special case: correctly handle "*" bullets.
2251 (should (org-test-parse-and-interpret " * item"))
2252 ;; Special case: correctly handle empty items.
2253 (should (org-test-parse-and-interpret "-"))))
2255 (ert-deftest test-org-element
/quote-block-interpreter
()
2256 "Test quote block interpreter."
2257 (should (equal (org-test-parse-and-interpret
2258 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2259 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2261 (ert-deftest test-org-element
/special-block-interpreter
()
2262 "Test special block interpreter."
2263 (should (equal (org-test-parse-and-interpret
2264 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2265 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2267 (ert-deftest test-org-element
/babel-call-interpreter
()
2268 "Test babel call interpreter."
2269 ;; 1. Without argument.
2270 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2271 "#+CALL: test()\n"))
2272 ;; 2. With argument.
2273 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2274 "#+CALL: test(x=2)\n"))
2275 ;; 3. With header arguments.
2276 (should (equal (org-test-parse-and-interpret
2277 "#+CALL: test[:results output]()[:results html]")
2278 "#+CALL: test[:results output]()[:results html]\n")))
2280 (ert-deftest test-org-element
/clock-interpreter
()
2281 "Test clock interpreter."
2285 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2286 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2290 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2291 (org-test-parse-and-interpret "
2292 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))))
2294 (ert-deftest test-org-element
/comment-interpreter
()
2295 "Test comment interpreter."
2297 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2299 (should (equal (org-test-parse-and-interpret " # Comment")
2301 ;; Preserve indentation.
2302 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2303 "# No blank\n# One blank\n")))
2305 (ert-deftest test-org-element
/comment-block-interpreter
()
2306 "Test comment block interpreter."
2307 (should (equal (org-test-parse-and-interpret
2308 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2309 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
2311 (ert-deftest test-org-element
/diary-sexp
()
2312 "Test diary-sexp interpreter."
2315 (org-test-parse-and-interpret
2316 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2317 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2319 (ert-deftest test-org-element
/example-block-interpreter
()
2320 "Test example block interpreter."
2321 ;; Without switches.
2322 (should (equal (org-test-parse-and-interpret
2323 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2324 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2327 (equal (org-test-parse-and-interpret
2328 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2329 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2330 ;; Preserve code escaping.
2332 (equal (org-test-parse-and-interpret
2333 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2334 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n")))
2336 (ert-deftest test-org-element
/export-block-interpreter
()
2337 "Test export block interpreter."
2338 (should (equal (org-test-parse-and-interpret
2339 "#+BEGIN_HTML\nTest\n#+END_HTML")
2340 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2342 (ert-deftest test-org-element
/fixed-width-interpreter
()
2343 "Test fixed width interpreter."
2345 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2346 ;; Preserve indentation.
2347 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2348 ": 2 blanks\n: 1 blank\n"))
2349 ;; Remove last newline character
2351 (equal (org-element-fixed-width-interpreter
2352 '(fixed-width (:value
"Test\n")) nil
)
2355 (equal (org-element-fixed-width-interpreter
2356 '(fixed-width (:value
"Test")) nil
)
2358 ;; Handle empty string.
2360 (equal (org-element-fixed-width-interpreter
2361 '(fixed-width (:value
"")) nil
)
2363 ;; Handle nil value.
2365 (org-element-fixed-width-interpreter
2366 '(fixed-width (:value nil
)) nil
)))
2368 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2369 "Test horizontal rule interpreter."
2370 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2372 (ert-deftest test-org-element
/keyword-interpreter
()
2373 "Test keyword interpreter."
2374 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2375 "#+KEYWORD: value\n")))
2377 (ert-deftest test-org-element
/latex-environment-interpreter
()
2378 "Test latex environment interpreter."
2379 (should (equal (org-test-parse-and-interpret
2380 "\\begin{equation}\n1+1=2\n\\end{equation}")
2381 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2382 (should (equal (org-test-parse-and-interpret
2383 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2384 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2386 (ert-deftest test-org-element
/planning-interpreter
()
2387 "Test planning interpreter."
2391 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2392 (org-test-parse-and-interpret
2394 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2396 (ert-deftest test-org-element
/property-drawer-interpreter
()
2397 "Test property drawer interpreter."
2398 (should (equal (let ((org-property-format "%-10s %s"))
2399 (org-test-parse-and-interpret
2400 ":PROPERTIES:\n:prop: value\n:END:"))
2401 ":PROPERTIES:\n:prop: value\n:END:\n")))
2403 (ert-deftest test-org-element
/src-block-interpreter
()
2404 "Test src block interpreter."
2407 (equal (let ((org-edit-src-content-indentation 2))
2408 (org-test-parse-and-interpret
2409 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2410 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2413 (equal (let ((org-edit-src-content-indentation 2))
2414 (org-test-parse-and-interpret
2415 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2416 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2417 ;; Preserve code escaping.
2419 (equal (let ((org-edit-src-content-indentation 2))
2420 (org-test-parse-and-interpret
2421 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2422 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2423 ;; Do not apply `org-edit-src-content-indentation' when preserving
2426 (equal (let ((org-edit-src-content-indentation 2)
2427 (org-src-preserve-indentation t
))
2428 (org-test-parse-and-interpret
2429 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2430 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2432 (equal (let ((org-edit-src-content-indentation 2)
2433 (org-src-preserve-indentation nil
))
2434 (org-test-parse-and-interpret
2435 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2436 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n")))
2438 (ert-deftest test-org-element
/table-interpreter
()
2439 "Test table, table-row and table-cell interpreters."
2441 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2442 "| a | b |\n| c | d |\n"))
2443 ;; 2. With horizontal rules.
2444 (should (equal (org-test-parse-and-interpret
2445 "| a | b |\n|---+---|\n| c | d |")
2446 "| a | b |\n|---+---|\n| c | d |\n"))
2447 ;; 3. With meta-data.
2448 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2449 "| / | < | > |\n| * | 1 | 2 |\n"))
2450 ;; 4. With a formula.
2452 (equal (org-test-parse-and-interpret
2453 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2454 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2455 ;; 5. With multiple formulas.
2457 (equal (org-test-parse-and-interpret
2458 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2459 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2461 (ert-deftest test-org-element
/timestamp-interpreter
()
2462 "Test timestamp interpreter."
2465 (string-match "<2012-03-29 .* 16:40>"
2466 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2468 (string-match "<2012-03-29 .* 16:40>"
2469 (org-element-timestamp-interpreter
2471 (:type active
:year-start
2012 :month-start
3 :day-start
29
2472 :hour-start
16 :minute-start
40)) nil
)))
2475 (string-match "\\[2012-03-29 .* 16:40\\]"
2476 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2479 "\\[2012-03-29 .* 16:40\\]"
2480 (org-element-timestamp-interpreter
2482 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2483 :hour-start
16 :minute-start
40)) nil
)))
2486 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2487 (org-test-parse-and-interpret
2488 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2491 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2492 (org-element-timestamp-interpreter
2494 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2495 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2496 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2499 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2500 (org-test-parse-and-interpret
2501 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2504 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2505 (org-element-timestamp-interpreter
2507 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2508 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2509 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2511 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2512 "<%%diary-float t 4 2>\n"))
2513 ;; Timestamp with repeater interval, with delay, with both.
2515 (string-match "<2012-03-29 .* \\+1y>"
2516 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2519 "<2012-03-29 .* \\+1y>"
2520 (org-element-timestamp-interpreter
2522 (:type active
:year-start
2012 :month-start
3 :day-start
29
2523 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2527 "<2012-03-29 .* -1y>"
2528 (org-element-timestamp-interpreter
2530 (:type active
:year-start
2012 :month-start
3 :day-start
29
2531 :warning-type all
:warning-value
1 :warning-unit year
))
2535 "<2012-03-29 .* \\+1y -1y>"
2536 (org-element-timestamp-interpreter
2538 (:type active
:year-start
2012 :month-start
3 :day-start
29
2539 :warning-type all
:warning-value
1 :warning-unit year
2540 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2542 ;; Timestamp range with repeater interval
2544 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2545 (org-test-parse-and-interpret
2546 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2549 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2550 (org-element-timestamp-interpreter
2552 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2553 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2554 :repeater-value
1 :repeater-unit year
))
2557 (ert-deftest test-org-element
/verse-block-interpreter
()
2558 "Test verse block interpretation."
2560 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2561 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2563 (ert-deftest test-org-element
/bold-interpreter
()
2564 "Test bold interpreter."
2565 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2567 (ert-deftest test-org-element
/code-interpreter
()
2568 "Test code interpreter."
2569 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2571 (ert-deftest test-org-element
/entity-interpreter
()
2572 "Test entity interpreter."
2573 ;; 1. Without brackets.
2575 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2576 ;; 2. With brackets.
2578 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2580 (ert-deftest test-org-element
/export-snippet-interpreter
()
2581 "Test export snippet interpreter."
2582 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2583 "@@back-end:contents@@\n")))
2585 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2586 "Test footnote reference interpreter."
2587 ;; 1. Regular reference.
2588 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2589 ;; 2. Normalized reference.
2590 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2591 ;; 3. Named reference.
2592 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2593 "Text[fn:label]\n"))
2594 ;; 4. Inline reference.
2595 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2596 "Text[fn:label:def]\n"))
2597 ;; 5. Anonymous reference.
2598 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2599 "Text[fn::def]\n")))
2601 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2602 "Test inline babel call interpreter."
2603 ;; 1. Without arguments.
2604 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2605 ;; 2. With arguments.
2606 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2607 "call_test(x=2)\n"))
2608 ;; 3. With header arguments.
2609 (should (equal (org-test-parse-and-interpret
2610 "call_test[:results output]()[:results html]")
2611 "call_test[:results output]()[:results html]\n")))
2613 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2614 "Test inline src block interpreter."
2615 ;; 1. Without header argument.
2616 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2617 "src_emacs-lisp{(+ 1 1)}\n"))
2618 ;; 2. With header arguments.
2619 (should (equal (org-test-parse-and-interpret
2620 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2621 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2623 (ert-deftest test-org-element
/italic-interpreter
()
2624 "Test italic interpreter."
2625 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2627 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2628 "Test latex fragment interpreter."
2629 (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
2630 (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
2631 (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
2632 (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
2633 (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
2634 (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
2636 (ert-deftest test-org-element
/line-break-interpreter
()
2637 "Test line break interpreter."
2638 (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
2639 "First line \\\\\nSecond line\n")))
2641 (ert-deftest test-org-element
/link-interpreter
()
2642 "Test link interpreter."
2643 ;; 1. Links targeted from a radio target.
2644 (should (equal (let ((org-target-link-regexp "radio-target"))
2645 (org-test-parse-and-interpret "a radio-target"))
2646 "a radio-target\n"))
2647 ;; 2. Regular links.
2649 ;; 2.1. Without description.
2650 (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
2651 "[[http://orgmode.org]]\n"))
2652 ;; 2.2. With a description.
2653 (should (equal (org-test-parse-and-interpret
2654 "[[http://orgmode.org][Org mode]]")
2655 "[[http://orgmode.org][Org mode]]\n"))
2657 (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
2658 ;; 2.4. Custom-id links.
2659 (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
2660 ;; 2.5 Code-ref links.
2661 (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
2662 ;; 3. Normalize plain links.
2663 (should (equal (org-test-parse-and-interpret "http://orgmode.org")
2664 "[[http://orgmode.org]]\n"))
2665 ;; 4. Normalize angular links.
2666 (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
2667 "[[http://orgmode.org]]\n")))
2669 (ert-deftest test-org-element
/macro-interpreter
()
2670 "Test macro interpreter."
2671 ;; 1. Without argument.
2672 (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
2673 ;; 2. With arguments.
2674 (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
2675 "{{{test(arg1,arg2)}}}\n")))
2677 (ert-deftest test-org-element
/radio-target-interpreter
()
2678 "Test radio target interpreter."
2679 (should (equal (org-test-parse-and-interpret "<<<some text>>>")
2680 "<<<some text>>>\n")))
2682 (ert-deftest test-org-element
/statistics-cookie-interpreter
()
2683 "Test statistics cookie interpreter."
2684 ;; 1. Without percent
2685 (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
2687 (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
2689 (ert-deftest test-org-element
/strike-through-interpreter
()
2690 "Test strike through interpreter."
2691 (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
2693 (ert-deftest test-org-element
/subscript-interpreter
()
2694 "Test subscript interpreter."
2695 ;; 1. Without brackets.
2696 (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
2697 ;; 2. With brackets.
2698 (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
2700 (ert-deftest test-org-element
/superscript-interpreter
()
2701 "Test superscript interpreter."
2702 ;; 1. Without brackets.
2703 (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
2704 ;; 2. With brackets.
2705 (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
2707 (ert-deftest test-org-element
/target-interpreter
()
2708 "Test target interpreter."
2709 (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
2711 (ert-deftest test-org-element
/underline-interpreter
()
2712 "Test underline interpreter."
2713 (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
2715 (ert-deftest test-org-element
/verbatim-interpreter
()
2716 "Test verbatim interpreter."
2717 (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
2721 ;;; Test Granularity
2723 (ert-deftest test-org-element
/granularity
()
2724 "Test granularity impact on buffer parsing."
2725 (org-test-with-temp-text "
2732 ;; 1.1. Granularity set to `headline' should parse every headline
2733 ;; in buffer, and only them.
2734 (let ((tree (org-element-parse-buffer 'headline
)))
2735 (should (= 2 (length (org-element-map tree
'headline
'identity
))))
2736 (should-not (org-element-map tree
'paragraph
'identity
)))
2737 ;; 1.2. Granularity set to `greater-element' should not enter
2738 ;; greater elements excepted headlines and sections.
2739 (let ((tree (org-element-parse-buffer 'greater-element
)))
2740 (should (= 1 (length (org-element-map tree
'center-block
'identity
))))
2741 (should (= 1 (length (org-element-map tree
'paragraph
'identity
))))
2742 (should-not (org-element-map tree
'entity
'identity
)))
2743 ;; 1.3. Granularity set to `element' should enter every
2745 (let ((tree (org-element-parse-buffer 'element
)))
2746 (should (= 2 (length (org-element-map tree
'paragraph
'identity
))))
2747 (should-not (org-element-map tree
'entity
'identity
)))
2748 ;; 1.4. Granularity set to `object' can see everything.
2749 (let ((tree (org-element-parse-buffer 'object
)))
2750 (should (= 1 (length (org-element-map tree
'entity
'identity
)))))))
2752 (ert-deftest test-org-element
/secondary-string-parsing
()
2753 "Test if granularity correctly toggles secondary strings parsing."
2754 ;; 1. With a granularity bigger than `object', no secondary string
2755 ;; should be parsed.
2757 ;; 1.1. Test with `headline' type.
2758 (org-test-with-temp-text "* Headline"
2760 (org-element-map (org-element-parse-buffer 'headline
) 'headline
2764 (should (stringp (org-element-property :title headline
)))))
2765 ;; 1.2. Test with `item' type.
2766 (org-test-with-temp-text "* Headline\n- tag :: item"
2767 (let ((item (org-element-map (org-element-parse-buffer 'element
)
2772 (should (stringp (org-element-property :tag item
)))))
2773 ;; 1.3. Test with `inlinetask' type, if avalaible.
2774 (when (featurep 'org-inlinetask
)
2775 (let ((org-inlinetask-min-level 15))
2776 (org-test-with-temp-text "*************** Inlinetask"
2777 (let ((inlinetask (org-element-map (org-element-parse-buffer 'element
)
2782 (should (stringp (org-element-property :title inlinetask
)))))))
2783 ;; 2. With a default granularity, secondary strings should be
2785 (org-test-with-temp-text "* Headline"
2787 (org-element-map (org-element-parse-buffer) 'headline
2791 (should (listp (org-element-property :title headline
)))))
2792 ;; 3. `org-element-at-point' should never parse a secondary string.
2793 (org-test-with-temp-text "* Headline"
2794 (should (stringp (org-element-property :title
(org-element-at-point))))))
2798 ;;; Test Visible Only Parsing
2800 (ert-deftest test-org-element
/parse-buffer-visible
()
2801 "Test `org-element-parse-buffer' with visible only argument."
2803 (equal '("H1" "H3" "H5")
2804 (org-test-with-temp-text
2805 "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
2806 (org-occur ":visible:")
2807 (org-element-map (org-element-parse-buffer nil t
) 'headline
2808 (lambda (hl) (org-element-property :raw-value hl
)))))))
2812 ;;; Test `:parent' Property
2814 (ert-deftest test-org-element
/parent-property
()
2815 "Test `:parent' property."
2817 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
2818 (let* ((tree (org-element-parse-buffer))
2819 (parent (org-element-property
2821 (org-element-map tree
'paragraph
'identity nil t
))))
2823 (should (eq (org-element-map tree
'center-block
'identity nil t
)
2826 (org-test-with-temp-text "a_{/b/}"
2827 (let* ((tree (org-element-parse-buffer))
2828 (parent (org-element-property
2830 (org-element-map tree
'italic
'identity nil t
))))
2833 (org-element-map tree
'subscript
'identity nil t
)))))
2834 ;; Secondary strings
2835 (org-test-with-temp-text "* /italic/"
2836 (let* ((tree (org-element-parse-buffer))
2837 (parent (org-element-property
2838 :parent
(org-element-map tree
'italic
'identity nil t
))))
2841 (org-element-map tree
'headline
'identity nil t
))))))
2845 ;;; Test Normalize Contents
2847 (ert-deftest test-org-element
/normalize-contents
()
2848 "Test `org-element-normalize-contents' specifications."
2849 ;; Remove maximum common indentation from element's contents.
2852 (org-element-normalize-contents
2853 '(paragraph nil
" Two spaces\n Three spaces"))
2854 '(paragraph nil
"Two spaces\n Three spaces")))
2855 ;; Ignore objects within contents when computing maximum common
2859 (org-element-normalize-contents
2860 '(paragraph nil
" One " (emphasis nil
"space") "\n Two spaces"))
2861 '(paragraph nil
"One " (emphasis nil
"space") "\n Two spaces")))
2862 ;; Ignore blank lines.
2865 (org-element-normalize-contents
2866 '(paragraph nil
" Two spaces\n\n \n Two spaces"))
2867 '(paragraph nil
"Two spaces\n\n \nTwo spaces")))
2870 '(paragraph nil
" Two spaces\n" (verbatim nil
"V") "\n Two spaces")
2871 (org-element-normalize-contents
2872 '(paragraph nil
" Two spaces\n " (verbatim nil
"V") "\n Two spaces"))))
2873 ;; Recursively enter objects in order to compute common indentation.
2876 (org-element-normalize-contents
2877 '(paragraph nil
" Two spaces " (bold nil
" and\n One space")))
2878 '(paragraph nil
" Two spaces " (bold nil
" and\nOne space"))))
2879 ;; When optional argument is provided, ignore first line
2883 (org-element-normalize-contents
2884 '(paragraph nil
"No space\n Two spaces\n Three spaces") t
)
2885 '(paragraph nil
"No space\nTwo spaces\n Three spaces"))))
2889 ;;; Test Navigation Tools.
2891 (ert-deftest test-org-element
/at-point
()
2892 "Test `org-element-at-point' specifications."
2893 ;; Return closest element containing point.
2896 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
2897 (progn (search-forward "A")
2898 (org-element-type (org-element-at-point))))))
2899 ;; Correctly set `:parent' property.
2902 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
2903 (progn (search-forward "A")
2905 (org-element-property :parent
(org-element-at-point)))))))
2906 ;; Special case: at a blank line just below a headline, return that
2909 (equal "H1" (org-test-with-temp-text "* H1\n \n* H2\n"
2911 (org-element-property :title
(org-element-at-point)))))
2912 ;; Special case: at the very beginning of a table, return `table'
2913 ;; object instead of `table-row'.
2916 (org-test-with-temp-text "| a | b |"
2917 (org-element-type (org-element-at-point)))))
2918 ;; Special case: at the very beginning of a list or sub-list, return
2919 ;; `plain-list' object instead of `item'.
2922 (org-test-with-temp-text "- item"
2923 (org-element-type (org-element-at-point)))))
2924 ;; Special case: at the closing line of a greater element, be sure
2925 ;; to return it instead of the last element in its contents.
2928 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
2929 (progn (forward-line 2)
2930 (org-element-type (org-element-at-point))))))
2931 ;; Special case: at a blank line between two items, be sure to
2932 ;; return item above instead of the last element of its contents.
2935 (org-test-with-temp-text "- Para1\n\n- Para2"
2936 (progn (forward-line)
2938 (let ((org-list-empty-line-terminates-plain-lists nil
))
2939 (org-element-at-point)))))))
2940 ;; Special case: at the last blank line in a plain list, return it
2941 ;; instead of the last item.
2944 (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
2945 (progn (forward-line 2)
2946 (org-element-type (org-element-at-point))))))
2947 ;; Special case: when a list ends at the end of buffer and there's
2948 ;; no final newline, return last element in last item.
2951 (org-test-with-temp-text "- a"
2953 (org-element-type (org-element-at-point)))))
2954 ;; Parse a list within a block itself contained in a list.
2957 (org-test-with-temp-text
2958 "- outer\n #+begin_center\n - inner\n #+end_center"
2959 (search-forward "inner")
2961 (org-element-type (org-element-at-point)))))
2962 ;; Do not error at eob on an empty line.
2964 (org-test-with-temp-text "* H\n"
2966 (or (org-element-at-point) t
))))
2968 (ert-deftest test-org-element
/context
()
2969 "Test `org-element-context' specifications."
2970 ;; Return closest object containing point.
2973 (org-test-with-temp-text "Some *text with _underline_ text*"
2974 (progn (search-forward "under")
2975 (org-element-type (org-element-context))))))
2976 ;; Find objects in secondary strings.
2979 (org-test-with-temp-text "* Headline _with_ underlining"
2980 (progn (search-forward "w")
2981 (org-element-type (org-element-context))))))
2982 ;; Find objects in objects.
2985 (org-test-with-temp-text "| a | {{{macro}}} |"
2986 (progn (search-forward "{")
2987 (org-element-type (org-element-context))))))
2990 (org-test-with-temp-text "| a | b {{{macro}}} |"
2991 (progn (search-forward "b")
2992 (org-element-type (org-element-context))))))
2993 ;; Find objects in document keywords.
2996 (org-test-with-temp-text "#+DATE: {{{macro}}}"
2997 (progn (search-forward "{")
2998 (org-element-type (org-element-context))))))
2999 ;; Do not find objects in table rules.
3002 (org-test-with-temp-text "| a | b |\n+---+---+\n| c | d |"
3004 (org-element-type (org-element-context)))))
3005 ;; Find objects in parsed affiliated keywords.
3008 (org-test-with-temp-text "#+CAPTION: {{{macro}}}\n| a | b |."
3009 (progn (search-forward "{")
3010 (org-element-type (org-element-context))))))
3013 (org-test-with-temp-text "#+caption: *bold*\nParagraph"
3014 (progn (search-forward "*")
3015 (org-element-type (org-element-context))))))
3016 ;; Correctly set `:parent' property.
3019 (org-test-with-temp-text "Some *bold* text"
3020 (progn (search-forward "bold")
3022 (org-element-property :parent
(org-element-context)))))))
3023 ;; Between two objects, return the second one.
3026 (org-test-with-temp-text "<<target>>{{{test}}}"
3027 (progn (search-forward "{")
3029 (org-element-type (org-element-context))))))
3030 ;; Test optional argument.
3033 (org-test-with-temp-text "Some *text with _underline_ text*"
3035 (search-forward "under")
3036 (org-element-type (org-element-context (org-element-at-point))))))))
3042 (ert-deftest test-org-element
/cache
()
3043 "Test basic expectations and common pitfalls for cache."
3047 (org-test-with-temp-text "para1\n\npara2\n\npara3"
3048 (let ((org-element-use-cache t
))
3049 (save-excursion (goto-char (point-max)) (org-element-at-point))
3052 (let ((element (org-element-at-point)))
3053 (cons (org-element-property :begin element
)
3054 (org-element-property :end element
)))))))
3055 ;; Partial shifting: when the contents of a greater element are
3056 ;; modified, only shift ending positions.
3058 (org-test-with-temp-text
3059 "#+BEGIN_CENTER\nPara1\n\nPara2\n\nPara3\n#+END_CENTER"
3060 (let ((org-element-use-cache t
))
3061 (save-excursion (search-forward "3") (org-element-at-point))
3062 (search-forward "Para2")
3064 (let ((element (org-element-property :parent
(org-element-at-point))))
3065 (equal (cons (org-element-property :begin element
)
3066 (org-element-property :end element
))
3067 (cons (point-min) (point-max)))))))
3068 ;; Re-parent shifted elements.
3071 (org-test-with-temp-text "- item\n\n\n para1\n para2"
3072 (let ((org-element-use-cache t
))
3074 (org-element-at-point)
3075 (save-excursion (goto-char (point-max)) (org-element-at-point))
3078 (goto-char (point-max))
3080 (org-element-property :parent
(org-element-at-point)))))))
3081 ;; Modifying the last line of an element alters the element below.
3083 (org-test-with-temp-text "para1\n\npara2"
3084 (let ((org-element-use-cache t
))
3085 (goto-char (point-max))
3086 (org-element-at-point)
3089 (let ((element (org-element-at-point)))
3090 (equal (cons (org-element-property :begin element
)
3091 (org-element-property :end element
))
3092 (cons (point-min) (point-max)))))))
3093 ;; Modifying the first line of an element alters the element above.
3095 (org-test-with-temp-text ": fixed-width\n:not-fixed-width"
3096 (let ((org-element-use-cache t
))
3097 (goto-char (point-max))
3098 (org-element-at-point)
3099 (search-backward ":")
3102 (let ((element (org-element-at-point)))
3103 (equal (cons (org-element-property :begin element
)
3104 (org-element-property :end element
))
3105 (cons (point-min) (point-max)))))))
3106 ;; Sensitive change: adding a line alters document structure both
3110 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n"
3111 (let ((org-element-use-cache t
))
3112 (goto-char (point-max))
3113 (org-element-at-point)
3114 (insert "#+END_EXAMPLE")
3115 (search-backward "Para1")
3116 (org-element-type (org-element-at-point))))))
3119 (org-test-with-temp-text "Para1\n\nPara2\n#+END_EXAMPLE"
3120 (let ((org-element-use-cache t
))
3121 (save-excursion (goto-char (point-max)) (org-element-at-point))
3122 (insert "#+BEGIN_EXAMPLE\n")
3123 (search-forward "Para2")
3124 (org-element-type (org-element-at-point))))))
3125 ;; Sensitive change: removing a line alters document structure both
3129 (org-test-with-temp-text
3130 "# +BEGIN_EXAMPLE\nPara1\n\nPara2\n#+END_EXAMPLE"
3131 (let ((org-element-use-cache t
))
3132 (save-excursion (goto-char (point-max)) (org-element-at-point))
3135 (search-forward "Para2")
3136 (org-element-type (org-element-at-point))))))
3139 (org-test-with-temp-text
3140 "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n# +END_EXAMPLE"
3141 (let ((org-element-use-cache t
))
3142 (save-excursion (goto-char (point-max)) (org-element-at-point))
3143 (search-forward "# ")
3145 (search-backward "Para1")
3146 (org-element-type (org-element-at-point)))))))
3149 (provide 'test-org-element
)
3151 ;;; test-org-element.el ends here