1 ;;; test-org-element.el --- Tests for org-element.el
3 ;; Copyright (C) 2012, 2013 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
/set-element
()
128 "Test `org-element-set-element' specifications."
129 (org-test-with-temp-text "* Headline\n*a*"
130 (let ((tree (org-element-parse-buffer)))
131 (org-element-set-element
132 (org-element-map tree
'bold
'identity nil t
)
134 ;; Check if object is correctly replaced.
135 (should (org-element-map tree
'italic
'identity
))
136 (should-not (org-element-map tree
'bold
'identity
))
137 ;; Check if new object's parent is correctly set.
140 (org-element-property :parent
141 (org-element-map tree
'italic
'identity nil t
))
142 (org-element-map tree
'paragraph
'identity nil t
))))))
144 (ert-deftest test-org-element
/adopt-elements
()
145 "Test `org-element-adopt-elements' specifications."
148 (equal '(plain-text italic
)
149 (org-test-with-temp-text "* Headline\n *a*"
150 (let ((tree (org-element-parse-buffer)))
151 (org-element-adopt-elements
152 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"a"))
153 (mapcar (lambda (blob) (org-element-type blob
))
154 (org-element-contents
155 (org-element-map tree
'bold
'identity nil t
)))))))
159 (org-test-with-temp-text "* Headline\n *a*"
160 (let ((tree (org-element-parse-buffer)))
161 (org-element-adopt-elements
162 (org-element-map tree
'bold
'identity nil t
) "b")
163 (org-element-contents
164 (org-element-map tree
'bold
'identity nil t
)))))))
170 ;;;; Affiliated Keywords
172 (ert-deftest test-org-element
/affiliated-keywords-parser
()
173 "Test affiliated keywords parsing."
174 ;; Read simple keywords.
177 (org-element-property
179 (org-test-with-temp-text "#+NAME: para\nParagraph"
180 (org-element-at-point)))))
183 (org-element-property
185 (org-test-with-temp-text "#+NAME: para\nParagraph"
186 (org-element-at-point)))))
187 ;; Parse multiple keywords.
191 (org-element-property
193 (org-test-with-temp-text
194 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
195 (org-element-at-point)))))
196 ;; Parse "parsed" keywords.
200 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
201 (car (org-element-property :caption
(org-element-at-point))))))
202 ;; Parse dual keywords.
205 '((("long") "short"))
206 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
207 (org-element-property :caption
(org-element-at-point)))))
208 ;; Allow multiple caption keywords.
211 '((("l2") "s2") (("l1") "s1"))
212 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
213 (org-element-property :caption
(org-element-at-point)))))
216 '((("l1")) (nil "s1"))
217 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
218 (org-element-property :caption
(org-element-at-point)))))
219 ;; Corner case: orphaned keyword at the end of an element.
222 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
223 (progn (search-forward "name")
224 (org-element-type (org-element-at-point))))))
226 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
227 (progn (search-forward "Some")
228 (org-element-property :name
(org-element-at-point))))))
233 (ert-deftest test-org-element
/babel-call-parser
()
234 "Test `babel-call' parsing."
237 (org-test-with-temp-text "#+CALL: test()"
238 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
241 (org-test-with-temp-text "#+call: test()"
242 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
))))
247 (ert-deftest test-org-element
/bold-parser
()
248 "Test `bold' parser."
251 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
252 (org-test-with-temp-text "*bold*"
253 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
254 ;; Multi-line markup.
257 (org-element-contents
258 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
259 (org-test-with-temp-text "*first line\nsecond line*"
260 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
261 '("first line\nsecond line"))))
266 (ert-deftest test-org-element
/center-block-parser
()
267 "Test `center-block' parser."
270 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
271 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
274 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
275 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
276 ;; Ignore incomplete block.
278 (org-test-with-temp-text "#+BEGIN_CENTER"
280 (org-element-parse-buffer) 'center-block
'identity nil t
))))
285 (ert-deftest test-org-element
/clock-parser
()
286 "Test `clock' parser."
288 (let* ((org-clock-string "CLOCK:")
289 (clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
290 (org-element-at-point))))
291 (should (eq (org-element-property :status clock
) 'running
))
293 (equal (org-element-property :raw-value
294 (org-element-property :value clock
))
295 "[2012-01-01 sun. 00:01]"))
296 (should-not (org-element-property :duration clock
)))
298 (let* ((org-clock-string "CLOCK:")
300 (org-test-with-temp-text
301 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
302 (org-element-at-point))))
303 (should (eq (org-element-property :status clock
) 'closed
))
304 (should (equal (org-element-property :raw-value
305 (org-element-property :value clock
))
306 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
307 (should (equal (org-element-property :duration clock
) "0:01"))))
312 (ert-deftest test-org-element
/code-parser
()
313 "Test `code' parser."
316 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
317 (org-test-with-temp-text "~code~"
318 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
319 ;; Multi-line markup.
322 (org-element-property
324 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
325 (org-test-with-temp-text "~first line\nsecond line~"
327 (org-element-parse-buffer) 'code
'identity nil t
))))
328 "first line\nsecond line")))
333 (ert-deftest test-org-element
/comment-parser
()
334 "Test `comment' parser."
337 (org-test-with-temp-text "# Comment"
338 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
341 (org-test-with-temp-text " # Comment"
342 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
343 ;; Preserve indentation.
346 (org-element-property
348 (org-test-with-temp-text "# No blank\n# One blank"
349 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
350 "No blank\n One blank"))
351 ;; Comment with blank lines.
354 (org-element-property
356 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
357 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
358 "First part\n\n\nSecond part"))
359 ;; Do not mix comments and keywords.
362 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
363 (length (org-element-map
364 (org-element-parse-buffer) 'comment
'identity
)))))
367 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
368 (org-element-property
371 (org-element-parse-buffer) 'comment
'identity nil t
))))))
376 (ert-deftest test-org-element
/comment-block-parser
()
377 "Test `comment-block' parser."
380 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
382 (org-element-parse-buffer) 'comment-block
'identity
)))
385 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
387 (org-element-parse-buffer) 'comment-block
'identity
)))
388 ;; Ignore incomplete block.
390 (org-test-with-temp-text "#+BEGIN_COMMENT"
392 (org-element-parse-buffer) 'comment-block
'identity nil t
))))
397 (ert-deftest test-org-element
/diary-sexp-parser
()
398 "Test `diary-sexp' parser."
402 (org-test-with-temp-text
403 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
404 (org-element-type (org-element-at-point)))))
405 ;; Diary sexp must live at beginning of line
408 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
409 (org-element-type (org-element-at-point))))))
414 (ert-deftest test-org-element
/drawer-parser
()
415 "Test `drawer' parser."
418 (let ((org-drawers '("TEST")))
419 (org-test-with-temp-text ":TEST:\nText\n:END:"
420 (org-element-map (org-element-parse-buffer) 'drawer
'identity
))))
421 ;; Do not mix regular drawers and property drawers.
423 (let ((org-drawers '("PROPERTIES")))
424 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
426 (org-element-parse-buffer) 'drawer
'identity nil t
))))
427 ;; Ignore incomplete drawer.
429 (let ((org-drawers '("TEST")))
430 (org-test-with-temp-text ":TEST:"
432 (org-element-parse-buffer) 'drawer
'identity nil t
)))))
437 (ert-deftest test-org-element
/dynamic-block-parser
()
438 "Test `dynamic-block' parser."
441 (org-test-with-temp-text
442 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
443 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
446 (org-test-with-temp-text
447 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
448 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
449 ;; Ignore incomplete block.
451 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
453 (org-element-parse-buffer) 'dynamic-block
'identity nil t
))))
458 (ert-deftest test-org-element
/entity-parser
()
459 "Test `entity' parser."
462 (org-test-with-temp-text "\\sin"
463 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
466 (org-element-property
468 (org-test-with-temp-text "\\alpha{}text"
469 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
470 ;; User-defined entity.
473 (org-element-property
475 (let ((org-entities-user
476 '(("test" "test" nil
"test" "test" "test" "test"))))
477 (org-test-with-temp-text "\\test"
478 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
480 ;; Special case: entity at the end of a container.
483 (org-test-with-temp-text "*\\alpha \\beta*"
484 (search-forward "be")
485 (org-element-type (org-element-context))))))
490 (ert-deftest test-org-element
/example-block-parser
()
491 "Test `example-block' parser."
494 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
495 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
496 ;; Ignore incomplete block.
499 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
500 (org-element-type (org-element-at-point)))))
501 ;; Properly un-escape code.
503 (equal "* Headline\n #+keyword\nText\n"
504 (org-test-with-temp-text
505 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
506 (org-element-property :value
(org-element-at-point)))))
507 ;; Remove block indentation according to block boundaries, unless
508 ;; block contents are less indented than block boundaries.
511 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
512 (let ((org-src-preserve-indentation t
))
513 (org-element-property :value
(org-element-at-point))))))
517 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
518 (let ((org-src-preserve-indentation t
))
519 (org-element-property :value
(org-element-at-point)))))))
521 (ert-deftest test-org-element
/block-switches
()
522 "Test `example-block' and `src-block' switches parsing."
523 (let ((org-coderef-label-format "(ref:%s)"))
524 ;; 1. Test "-i" switch.
526 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
527 (org-element-property :preserve-indent
(org-element-at-point))))
529 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
530 (org-element-property :preserve-indent
(org-element-at-point))))
532 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
533 (org-element-property :preserve-indent
(org-element-at-point))))
535 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
536 (org-element-property :preserve-indent
(org-element-at-point))))
537 ;; 2. "-n -r -k" combination should number lines, retain labels but
538 ;; not use them in coderefs.
540 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
541 (let ((element (org-element-at-point)))
542 (and (org-element-property :number-lines element
)
543 (org-element-property :retain-labels element
)
544 (not (org-element-property :use-labels element
))))))
546 (org-test-with-temp-text
547 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
548 (let ((element (org-element-at-point)))
549 (and (org-element-property :number-lines element
)
550 (org-element-property :retain-labels element
)
551 (not (org-element-property :use-labels element
))))))
552 ;; 3. "-n -r" combination should number-lines remove labels and not
553 ;; use them in coderefs.
555 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
556 (let ((element (org-element-at-point)))
557 (and (org-element-property :number-lines element
)
558 (not (org-element-property :retain-labels element
))
559 (not (org-element-property :use-labels element
))))))
561 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
562 (let ((element (org-element-at-point)))
563 (and (org-element-property :number-lines element
)
564 (not (org-element-property :retain-labels element
))
565 (not (org-element-property :use-labels element
))))))
566 ;; 4. "-n" or "+n" should number lines, retain labels and use them
569 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
570 (let ((element (org-element-at-point)))
571 (and (org-element-property :number-lines element
)
572 (org-element-property :retain-labels element
)
573 (org-element-property :use-labels element
)))))
575 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
576 (let ((element (org-element-at-point)))
577 (and (org-element-property :number-lines element
)
578 (org-element-property :retain-labels element
)
579 (org-element-property :use-labels element
)))))
581 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
582 (let ((element (org-element-at-point)))
583 (and (org-element-property :number-lines element
)
584 (org-element-property :retain-labels element
)
585 (org-element-property :use-labels element
)))))
587 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
588 (let ((element (org-element-at-point)))
589 (and (org-element-property :number-lines element
)
590 (org-element-property :retain-labels element
)
591 (org-element-property :use-labels element
)))))
592 ;; 5. No switch should not number lines, but retain labels and use
595 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
596 (let ((element (org-element-at-point)))
597 (and (not (org-element-property :number-lines element
))
598 (org-element-property :retain-labels element
)
599 (org-element-property :use-labels element
)))))
601 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
602 (let ((element (org-element-at-point)))
603 (and (not (org-element-property :number-lines element
))
604 (org-element-property :retain-labels element
)
605 (org-element-property :use-labels element
)))))
606 ;; 6. "-r" switch only: do not number lines, remove labels, and
607 ;; don't use labels in coderefs.
609 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
610 (let ((element (org-element-at-point)))
611 (and (not (org-element-property :number-lines element
))
612 (not (org-element-property :retain-labels element
))
613 (not (org-element-property :use-labels element
))))))
615 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
616 (let ((element (org-element-at-point)))
617 (and (not (org-element-property :number-lines element
))
618 (not (org-element-property :retain-labels element
))
619 (not (org-element-property :use-labels element
))))))
620 ;; 7. Recognize coderefs with user-defined syntax.
624 (org-test-with-temp-text
625 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
626 (org-element-property :label-fmt
(org-element-at-point)))))
630 (org-test-with-temp-text
631 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
632 (org-element-property :label-fmt
(org-element-at-point)))))))
637 (ert-deftest test-org-element
/export-block-parser
()
638 "Test `export-block' parser."
641 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
643 (let ((org-element-block-name-alist
644 '(("LATEX" . org-element-export-block-parser
))))
645 (org-element-parse-buffer))
646 'export-block
'identity
)))
649 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
651 (let ((org-element-block-name-alist
652 '(("LATEX" . org-element-export-block-parser
))))
653 (org-element-parse-buffer))
654 'export-block
'identity
)))
655 ;; Ignore incomplete block.
657 (org-test-with-temp-text "#+BEGIN_LATEX"
659 (let ((org-element-block-name-alist
660 '(("LATEX" . org-element-export-block-parser
))))
661 (org-element-parse-buffer))
662 'export-block
'identity nil t
))))
667 (ert-deftest test-org-element
/export-snippet-parser
()
668 "Test `export-snippet' parser."
671 '("back-end" .
"contents")
672 (org-test-with-temp-text "@@back-end:contents@@"
674 (org-element-parse-buffer) 'export-snippet
675 (lambda (snippet) (cons (org-element-property :back-end snippet
)
676 (org-element-property :value snippet
)))
682 (ert-deftest test-org-element
/fixed-width
()
683 "Test fixed-width area parsing."
684 ;; Preserve indentation.
686 (org-test-with-temp-text ": no blank\n: one blank"
687 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
688 ;; Fixed-width with empty lines.
690 (org-test-with-temp-text ": first part\n:\n: \n: second part"
691 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
692 ;; Parse indented fixed-width markers.
694 (org-test-with-temp-text "Text\n : no blank\n : one blank"
695 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
696 ;; Distinguish fixed-width areas within a list and outside of it.
700 (org-test-with-temp-text "
703 : fixed-width outside"
705 (org-element-parse-buffer) 'fixed-width
'identity
))))))
708 ;;;; Footnote Definition
710 (ert-deftest test-org-element
/footnote-definition-parser
()
711 "Test `footnote-definition' parser."
713 (org-test-with-temp-text "[fn:1] Definition"
714 (org-element-map (org-element-parse-buffer) 'footnote-definition
716 ;; Footnote with more contents
719 (org-element-property
721 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
722 (org-element-map (org-element-parse-buffer) 'footnote-definition
724 ;; Footnote starting with special syntax.
726 (org-test-with-temp-text "[fn:1] - no item"
727 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
728 ;; Correctly handle footnote starting with an empty line.
731 (org-test-with-temp-text "[fn:1]\n\n Body"
732 (org-element-property :contents-begin
733 (org-element-at-point))))))
736 ;;;; Footnotes Reference.
738 (ert-deftest test-org-element
/footnote-reference-parser
()
739 "Test `footnote-reference' parser."
740 ;; 1. Parse a standard reference.
741 (org-test-with-temp-text "Text[fn:label]"
744 (org-element-parse-buffer) 'footnote-reference
'identity
)))
745 ;; 2. Parse a normalized reference.
746 (org-test-with-temp-text "Text[1]"
749 (org-element-parse-buffer) 'footnote-reference
'identity
)))
750 ;; 3. Parse an inline reference.
751 (org-test-with-temp-text "Text[fn:test:def]"
754 (org-element-parse-buffer) 'footnote-reference
'identity
)))
755 ;; 4. Parse an anonymous reference.
756 (org-test-with-temp-text "Text[fn::def]"
759 (org-element-parse-buffer) 'footnote-reference
'identity
)))
760 ;; 5. Parse nested footnotes.
761 (org-test-with-temp-text "Text[fn::def [fn:label]]"
766 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
767 ;; 6. Parse adjacent footnotes.
768 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
773 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
774 ;; 7. Only properly closed footnotes are recognized as such.
775 (org-test-with-temp-text "Text[fn:label"
778 (org-element-parse-buffer) 'footnote-reference
'identity
))))
783 (ert-deftest test-org-element
/headline-quote-keyword
()
784 "Test QUOTE keyword recognition."
786 (org-test-with-temp-text "* Headline"
787 (let ((org-quote-string "QUOTE"))
788 (should-not (org-element-property :quotedp
(org-element-at-point)))))
789 ;; Standard position.
790 (org-test-with-temp-text "* QUOTE Headline"
791 (let* ((org-quote-string "QUOTE")
792 (headline (org-element-at-point)))
793 (should (org-element-property :quotedp headline
))
794 ;; Test removal from raw value.
795 (should (equal (org-element-property :raw-value headline
) "Headline"))))
797 (org-test-with-temp-text "* QUOTE Headline"
798 (let* ((org-quote-string "Quote")
799 (headline (org-element-at-point)))
800 (should-not (org-element-property :quotedp headline
))
801 (should (equal (org-element-property :raw-value headline
)
803 ;; With another keyword.
804 (org-test-with-temp-text "* TODO QUOTE Headline"
805 (let* ((org-quote-string "QUOTE")
806 (org-todo-keywords '((sequence "TODO" "DONE")))
807 (headline (org-element-at-point)))
808 (should (org-element-property :quotedp headline
))
809 (should (equal (org-element-property :raw-value headline
) "Headline"))))
810 ;; With the keyword only.
811 (org-test-with-temp-text "* QUOTE"
812 (let* ((org-quote-string "QUOTE")
813 (headline (org-element-at-point)))
814 (should (org-element-property :quotedp headline
))
815 (should (equal (org-element-property :raw-value headline
) "")))))
817 (ert-deftest test-org-element
/headline-comment-keyword
()
818 "Test COMMENT keyword recognition."
820 (org-test-with-temp-text "* Headline"
821 (let ((org-comment-string "COMMENT"))
822 (should-not (org-element-property :commentedp
(org-element-at-point)))))
823 ;; Standard position.
824 (org-test-with-temp-text "* COMMENT Headline"
825 (let ((org-comment-string "COMMENT")
826 (headline (org-element-at-point)))
827 (should (org-element-property :commentedp headline
))
828 (should (equal (org-element-property :raw-value headline
) "Headline"))))
830 (org-test-with-temp-text "* COMMENT Headline"
831 (let* ((org-comment-string "Comment")
832 (headline (org-element-at-point)))
833 (should-not (org-element-property :commentedp headline
))
834 (should (equal (org-element-property :raw-value headline
)
835 "COMMENT Headline"))))
836 ;; With another keyword.
837 (org-test-with-temp-text "* TODO COMMENT Headline"
838 (let* ((org-comment-string "COMMENT")
839 (org-todo-keywords '((sequence "TODO" "DONE")))
840 (headline (org-element-at-point)))
841 (should (org-element-property :commentedp headline
))
842 (should (equal (org-element-property :raw-value headline
) "Headline"))))
843 ;; With the keyword only.
844 (org-test-with-temp-text "* COMMENT"
845 (let* ((org-comment-string "COMMENT")
846 (headline (org-element-at-point)))
847 (should (org-element-property :commentedp headline
))
848 (should (equal (org-element-property :raw-value headline
) "")))))
850 (ert-deftest test-org-element
/headline-archive-tag
()
851 "Test ARCHIVE tag recognition."
853 (org-test-with-temp-text "* Headline"
854 (let ((org-archive-tag "ARCHIVE"))
855 (should-not (org-element-property :archivedp
(org-element-at-point)))))
857 (org-test-with-temp-text "* Headline :ARCHIVE:"
858 (let ((org-archive-tag "ARCHIVE"))
859 (let ((headline (org-element-at-point)))
860 (should (org-element-property :archivedp headline
))
862 (should-not (org-element-property :tags headline
))))
863 (let ((org-archive-tag "Archive"))
864 (should-not (org-element-property :archivedp
(org-element-at-point)))))
866 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
867 (let ((org-archive-tag "ARCHIVE"))
868 (let ((headline (org-element-at-point)))
869 (should (org-element-property :archivedp headline
))
871 (should (equal (org-element-property :tags headline
) '("test")))))))
873 (ert-deftest test-org-element
/headline-properties
()
874 "Test properties from property drawer."
875 ;; All properties from property drawer have their symbol upper
878 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
879 (org-element-property :FOO
(org-element-at-point))))
881 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
882 (org-element-property :foo
(org-element-at-point)))))
887 (ert-deftest test-org-element
/horizontal-rule-parser
()
888 "Test `horizontal-rule' parser."
891 (org-test-with-temp-text "-----"
892 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
895 (org-test-with-temp-text " -----"
896 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
897 ;; Hyphen must be alone on the line.
899 (org-test-with-temp-text "-----wrong"
900 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
901 ;; 4 hyphens is too small.
903 (org-test-with-temp-text "----"
904 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
))))
907 ;;;; Inline Babel Call
909 (ert-deftest test-org-element
/inline-babel-call-parser
()
910 "Test `inline-babel-call' parser."
912 (org-test-with-temp-text "call_test()"
914 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
917 ;;;; Inline Src Block
919 (ert-deftest test-org-element
/inline-src-block-parser
()
920 "Test `inline-src-block' parser."
922 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
923 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
924 ;; Test parsing at the beginning of an item.
926 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
927 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
932 (ert-deftest test-org-element
/inlinetask-parser
()
933 "Test `inlinetask' parser."
934 (when (featurep 'org-inlinetask
)
935 (let ((org-inlinetask-min-level 15))
936 ;; 1. Regular inlinetask.
938 (org-test-with-temp-text
939 "*************** Task\nTest\n*************** END"
940 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
941 ;; 2. Degenerate inlinetask.
943 (org-test-with-temp-text "*************** Task"
944 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
949 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
950 (org-test-with-temp-text "*************** TODO Task"
951 (org-element-property
953 (org-element-map (org-element-parse-buffer) 'inlinetask
954 'identity nil t
))))))
959 (org-test-with-temp-text "
961 DEADLINE: <2012-03-29 thu.>"
962 (org-element-property
964 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
969 (org-test-with-temp-text "
970 *************** [#A] Task"
971 (org-element-property
974 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
979 (org-test-with-temp-text "
980 *************** Task :test:"
981 (org-element-property
984 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
985 ;; Regular properties are accessed through upper case keywords.
987 (org-test-with-temp-text "
994 (org-element-property :FOO
(org-element-at-point))))
996 (org-test-with-temp-text "
1001 *************** END"
1003 (org-element-property :foo
(org-element-at-point)))))))
1008 (ert-deftest test-org-element
/italic-parser
()
1009 "Test `italic' parser."
1012 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1013 (org-test-with-temp-text "/italic/"
1014 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1015 ;; Multi-line markup.
1018 (org-element-contents
1019 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1020 (org-test-with-temp-text "/first line\nsecond line/"
1021 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1022 '("first line\nsecond line"))))
1027 (ert-deftest test-org-element
/item-parser
()
1028 "Test `item' parser."
1031 (org-test-with-temp-text "- item"
1032 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1036 (org-element-property
1038 (org-test-with-temp-text "6. [@6] item"
1039 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1044 (org-element-property
1046 (org-test-with-temp-text "- tag :: description"
1047 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1048 ;; No tags in ordered lists.
1050 (org-element-property
1052 (org-test-with-temp-text "1. tag :: description"
1053 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1058 (org-test-with-temp-text "
1063 (org-element-parse-buffer) 'item
1064 (lambda (item) (org-element-property :checkbox item
))))))
1065 ;; Item starting with special syntax.
1067 (equal '(("- item"))
1068 (org-test-with-temp-text "- - item"
1070 (org-element-parse-buffer) 'paragraph
'org-element-contents
))))
1071 ;; Block in an item: ignore indentation within the block.
1073 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1075 (goto-char (org-element-property :end
(org-element-at-point)))
1081 (ert-deftest test-org-element
/keyword-parser
()
1082 "Test `keyword' parser."
1085 (org-test-with-temp-text "#+KEYWORD: value"
1086 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1087 ;; Keywords are case-insensitive.
1089 (org-test-with-temp-text "#+keyword: value"
1090 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1091 ;; Affiliated keywords are not keywords.
1093 (org-test-with-temp-text "#+NAME: value
1095 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1096 ;; Do not mix keywords with Babel calls and dynamic blocks.
1098 (org-test-with-temp-text "#+CALL: fun()"
1099 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1101 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1102 (org-element-map (org-element-parse-buffer) 'keyword
'identity
))))
1105 ;;;; Latex Environment
1107 (ert-deftest test-org-element
/latex-environment-parser
()
1108 "Test `latex-environment' parser."
1110 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1111 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1112 ;; Allow nested environments.
1120 (org-test-with-temp-text "
1126 (org-element-property
1129 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1130 ;; Allow environments with options and arguments.
1132 (eq 'latex-environment
1133 (org-test-with-temp-text
1134 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1135 (org-element-type (org-element-at-point)))))
1137 (eq 'latex-environment
1138 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1139 (org-element-type (org-element-at-point)))))
1141 (eq 'latex-environment
1142 (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1143 (org-element-type (org-element-at-point))))))
1148 (ert-deftest test-org-element
/latex-fragment-parser
()
1149 "Test `latex-fragment' parser."
1151 (org-test-with-temp-text "$a$"
1152 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1154 (org-test-with-temp-text "$$a$$"
1155 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1157 (org-test-with-temp-text "\\(a\\)"
1158 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1160 (org-test-with-temp-text "\\[a\\]"
1162 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1163 ;; Test fragment at the beginning of an item.
1166 (org-test-with-temp-text "- $x$"
1167 (progn (search-forward "$")
1168 (org-element-type (org-element-context)))))))
1173 (ert-deftest test-org-element
/line-break-parser
()
1174 "Test `line-break' parser."
1177 (org-test-with-temp-text "Text \\\\"
1178 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1179 ;; Line break with trailing white spaces.
1181 (org-test-with-temp-text "Text \\\\ "
1182 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1183 ;; Three backslashes are too much.
1185 (org-test-with-temp-text "Text \\\\\\"
1186 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1191 (ert-deftest test-org-element
/link-parser
()
1192 "Test `link' parser."
1197 (org-test-with-temp-text "A radio link"
1198 (org-element-property
1201 (let ((org-target-link-regexp "radio")) (org-element-parse-buffer))
1202 'link
'identity nil t
)))))
1205 ;; ... with description.
1209 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1210 (org-element-contents
1211 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1212 ;; ... without description.
1216 (org-test-with-temp-text "[[http://orgmode.org]]"
1217 (org-element-property
1219 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1220 ;; ... with expansion.
1223 "//orgmode.org/worg"
1224 (org-test-with-temp-text "[[Org:worg]]"
1225 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1226 (org-element-property
1228 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1229 ;; ... with translation.
1233 (org-test-with-temp-text "[[http://orgmode.org]]"
1234 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1235 (let ((org-link-translation-function 'link-translate
))
1236 (org-element-property
1238 (org-element-map (org-element-parse-buffer) 'link
1239 'identity nil t
)))))))
1244 (org-test-with-temp-text "[[id:aaaa]]"
1245 (org-element-property
1247 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1248 ;; ... custom-id link.
1252 (org-test-with-temp-text "[[#some-id]]"
1253 (org-element-property
1255 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1256 ;; ... coderef link.
1260 (org-test-with-temp-text "[[(reference)]]"
1261 (org-element-property
1263 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1268 (org-test-with-temp-text "[[target-or-title]]"
1269 (org-element-property
1271 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1272 ;; ... file-type link with search option.
1275 '(("file" "projects.org" "*task title"))
1276 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1277 (org-element-map (org-element-parse-buffer) 'link
1278 (lambda (l) (list (org-element-property :type l
)
1279 (org-element-property :path l
)
1280 (org-element-property :search-option l
)))))))
1281 ;; ... file-type link with application.
1284 '(("file" "projects.org" "docview"))
1285 (org-test-with-temp-text "[[docview:projects.org]]"
1286 (org-element-map (org-element-parse-buffer) 'link
1287 (lambda (l) (list (org-element-property :type l
)
1288 (org-element-property :path l
)
1289 (org-element-property :application l
)))))))
1292 (org-test-with-temp-text "A link: http://orgmode.org"
1293 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1296 (org-test-with-temp-text "A link: <http://orgmode.org>"
1297 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1298 ;; Link abbreviation.
1301 (org-test-with-temp-text
1302 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1303 (progn (org-mode-restart)
1304 (goto-char (1- (point-max)))
1305 (org-element-property :type
(org-element-context))))))
1306 ;; Link abbreviation in a secondary string.
1309 (org-test-with-temp-text
1310 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1311 (progn (org-mode-restart)
1312 (org-element-map (org-element-parse-buffer) 'link
1313 (lambda (link) (org-element-property :type link
))
1315 ;; Plain links are allowed as description of regular links.
1318 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1319 (search-forward "file:")
1320 (org-element-property :type
(org-element-context))))))
1325 (ert-deftest test-org-element
/macro-parser
()
1326 "Test `macro' parser."
1327 ;; Without arguments.
1329 (org-test-with-temp-text "{{{macro}}}"
1330 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1333 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1334 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1335 ;; Properly handle protected commas in arguments...
1339 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1340 (org-element-property :args
(org-element-context))))))
1341 ;; ... even when last argument ends with a protected comma.
1344 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1345 (org-element-property :args
(org-element-context)))))
1346 ;; Allow to escape escaping character.
1349 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1350 (org-element-property :args
(org-element-context)))))
1351 ;; No need to escape backslashes elsewhere.
1354 (org-test-with-temp-text "{{{macro(\\)}}}"
1355 (org-element-property :args
(org-element-context))))))
1360 (ert-deftest test-org-element
/node-property
()
1361 "Test `node-property' parser."
1364 (equal '("abc" "value")
1365 (org-test-with-temp-text ":PROPERTIES:\n:abc: value\n:END:"
1366 (progn (forward-line)
1367 (let ((element (org-element-at-point)))
1368 (list (org-element-property :key element
)
1369 (org-element-property :value element
)))))))
1370 ;; Value should be trimmed.
1373 (org-test-with-temp-text ":PROPERTIES:\n:abc: value \n:END:"
1374 (progn (forward-line)
1375 (let ((element (org-element-at-point)))
1376 (org-element-property :value element
))))))
1377 ;; A node property requires to be wrapped within a property drawer.
1380 (org-test-with-temp-text ":abc: value"
1381 (org-element-type (org-element-at-point))))))
1386 (ert-deftest test-org-element
/paragraph-parser
()
1387 "Test `paragraph' parser."
1390 (org-test-with-temp-text "Paragraph"
1391 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1392 ;; Property find end of a paragraph stuck to another element.
1395 (org-test-with-temp-text "Paragraph\n# Comment"
1397 (org-element-parse-buffer) 'paragraph
1398 (lambda (p) (char-after (org-element-property :end p
)))
1400 ;; Include ill-formed Keywords.
1402 (org-test-with-temp-text "#+wrong_keyword something"
1403 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1404 ;; Include incomplete-drawers.
1406 (let ((org-drawers '("TEST")))
1407 (org-test-with-temp-text ":TEST:\nParagraph"
1408 (let ((elem (org-element-at-point)))
1409 (and (eq (org-element-type elem
) 'paragraph
)
1410 (= (point-max) (org-element-property :end elem
)))))))
1411 ;; Include non-existent drawers.
1413 (let ((org-drawers '("TEST")))
1414 (org-test-with-temp-text ":NONAME:"
1415 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
))))
1416 ;; Include incomplete blocks.
1418 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1419 (let ((elem (org-element-at-point)))
1420 (and (eq (org-element-type elem
) 'paragraph
)
1421 (= (point-max) (org-element-property :end elem
))))))
1422 ;; Include incomplete dynamic blocks.
1424 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1425 (let ((elem (org-element-at-point)))
1426 (and (eq (org-element-type elem
) 'paragraph
)
1427 (= (point-max) (org-element-property :end elem
))))))
1428 ;; Include incomplete latex environments.
1430 (org-test-with-temp-text "\begin{equation}\nParagraph"
1431 (let ((elem (org-element-at-point)))
1432 (and (eq (org-element-type elem
) 'paragraph
)
1433 (= (point-max) (org-element-property :end elem
))))))
1434 ;; Do not steal affiliated keywords from container.
1436 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1437 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1438 (and (eq (org-element-type elem
) 'paragraph
)
1439 (not (org-element-property :attr_latex elem
))
1440 (/= (org-element-property :begin elem
) 1))))))
1445 (ert-deftest test-org-element
/plain-list-parser
()
1446 "Test `plain-list' parser."
1447 (org-test-with-temp-text "- item"
1448 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1449 ;; Blank lines after the list only belong to outer plain list.
1453 (org-test-with-temp-text "
1458 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1459 (lambda (pl) (org-element-property :end pl
)))))
1461 ;; Move to ending of outer list.
1462 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1463 ;; Move to ending of inner list.
1464 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1465 ;; Correctly compute end of list if it doesn't end at a line
1468 (org-test-with-temp-text "- list\n \n "
1469 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1474 (ert-deftest test-org-element
/planning-parser
()
1475 "Test `planning' parser."
1477 (equal "[2012-03-29 thu.]"
1478 (org-element-property
1480 (org-element-property
1482 (org-test-with-temp-text "CLOSED: [2012-03-29 thu.]"
1483 (org-element-at-point))))))
1485 (equal "<2012-03-29 thu.>"
1486 (org-element-property
1488 (org-element-property
1490 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1491 (org-element-at-point))))))
1493 (equal "<2012-03-29 thu.>"
1494 (org-element-property
1496 (org-element-property
1498 (org-test-with-temp-text "SCHEDULED: <2012-03-29 thu.>"
1499 (org-element-at-point)))))))
1502 ;;;; Property Drawer
1504 (ert-deftest test-org-element
/property-drawer
()
1505 "Test `property-drawer' parser."
1508 (let ((org-drawers '("PROPERTIES")))
1509 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
1511 (org-element-parse-buffer) 'property-drawer
'identity nil t
))))
1512 ;; Do not mix property drawers and regular drawers.
1514 (let ((org-drawers '("TEST")))
1515 (org-test-with-temp-text ":TEST:\n:prop: value\n:END:"
1517 (org-element-parse-buffer) 'property-drawer
'identity nil t
))))
1518 ;; Ignore incomplete drawer.
1520 (let ((org-drawers '("PROPERTIES")))
1521 (org-test-with-temp-text ":PROPERTIES:\n:prop: value"
1523 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))))
1528 (ert-deftest test-org-element
/quote-block-parser
()
1529 "Test `quote-block' parser."
1532 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1533 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1534 ;; Ignore incomplete block.
1536 (org-test-with-temp-text "#+BEGIN_QUOTE"
1538 (org-element-parse-buffer) 'quote-block
'identity nil t
))))
1543 (ert-deftest test-org-element
/quote-section-parser
()
1544 "Test `quote-section' parser."
1546 (let ((org-quote-string "QUOTE"))
1547 (org-test-with-temp-text "* QUOTE Headline\nBody"
1548 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
))))
1550 (let ((org-quote-string "TEST"))
1551 (org-test-with-temp-text "* QUOTE Headline\nBody"
1552 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
)))))
1557 (ert-deftest test-org-element
/radio-target-parser
()
1558 "Test `radio-target' parser."
1561 (org-test-with-temp-text "<<<radio>>>"
1562 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
)))
1563 ;; Radio targets with objects.
1565 (org-test-with-temp-text "<<<radio \\alpha>>>"
1566 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
))))
1571 (ert-deftest test-org-element
/section-parser
()
1572 "Test `section' parser."
1575 (org-test-with-temp-text "* Headline\nText"
1576 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1577 ;; There's a section before the first headline.
1579 (org-test-with-temp-text "Text"
1580 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1581 ;; A section cannot be empty.
1583 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1584 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1585 ;; A section doesn't contain sub-trees.
1587 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1589 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1590 'headline
'identity
))))
1595 (ert-deftest test-org-element
/special-block-parser
()
1596 "Test `special-block' parser."
1600 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1601 (org-element-property :type
(org-element-at-point)))))
1602 ;; Special blocks can contain paragraphs.
1605 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1607 (org-element-type (org-element-at-point)))))
1608 ;; Ignore incomplete block.
1611 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1612 (org-element-type (org-element-at-point)))))
1613 ;; Allow special characters in type.
1615 (equal '(special-block "SPECIAL*")
1616 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1617 (let ((element (org-element-at-point)))
1618 (list (org-element-type element
)
1619 (org-element-property :type element
)))))))
1624 (ert-deftest test-org-element
/src-block-parser
()
1625 "Test `src-block' parser."
1628 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1629 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1630 ;; Ignore incomplete block.
1632 (org-test-with-temp-text "#+BEGIN_SRC"
1633 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1634 ;; Properly un-escape code.
1636 (equal "* Headline\n #+keyword\nText\n"
1637 (org-test-with-temp-text
1638 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1639 (org-element-property :value
(org-element-at-point)))))
1640 ;; Remove block indentation according to block boundaries, unless
1641 ;; block contents are less indented than block boundaries.
1644 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1645 (let ((org-src-preserve-indentation t
))
1646 (org-element-property :value
(org-element-at-point))))))
1650 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1651 (let ((org-src-preserve-indentation t
))
1652 (org-element-property :value
(org-element-at-point)))))))
1655 ;;;; Statistics Cookie
1657 (ert-deftest test-org-element
/statistics-cookie
()
1658 "Test `statistics-cookie' parser."
1661 (org-test-with-temp-text "[1/2]"
1662 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1665 (org-test-with-temp-text "[33%]"
1667 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1672 (ert-deftest test-org-element
/strike-through-parser
()
1673 "Test `strike-through' parser."
1676 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1677 (org-test-with-temp-text "+strike-through+"
1678 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1679 ;; Multi-line markup.
1682 (org-element-contents
1683 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1684 (org-test-with-temp-text "+first line\nsecond line+"
1686 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1687 '("first line\nsecond line"))))
1692 (ert-deftest test-org-element
/subscript-parser
()
1693 "Test `subscript' parser."
1696 (org-test-with-temp-text "a_b"
1697 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1700 (org-test-with-temp-text "a_{b}"
1701 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1702 ;; Multiple subscripts in a paragraph.
1705 (org-test-with-temp-text "a_b and c_d"
1707 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1712 (ert-deftest test-org-element
/superscript-parser
()
1713 "Test `superscript' parser."
1716 (org-test-with-temp-text "a^b"
1717 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1720 (org-test-with-temp-text "a^{b}"
1721 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1722 ;; Multiple superscript in a paragraph.
1725 (org-test-with-temp-text "a^b and c^d"
1728 (org-element-parse-buffer) 'superscript
'identity
))))))
1733 (ert-deftest test-org-element
/table-parser
()
1734 "Test `table' parser."
1736 (org-test-with-temp-text "| a |"
1737 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
1738 ;; TBLFM keyword is case insensitive.
1740 (org-test-with-temp-text "| a |\n#+tblfm: test"
1741 (org-element-property
1743 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
1744 ;; Handle multiple TBLFM lines.
1747 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
1748 (length (org-element-property
1751 (org-element-parse-buffer) 'table
'identity nil t
))))))
1752 ;; Do not error when parsing a table with trailing white spaces.
1753 (should (org-test-with-temp-text "| a |\n " (org-element-parse-buffer))))
1758 (ert-deftest test-org-element
/table-cell-parser
()
1759 "Test `table-cell' parser."
1761 (org-test-with-temp-text "| a |"
1762 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
1767 (ert-deftest test-org-element
/table-row-parser
()
1768 "Test `table-row' parser."
1770 (equal '(standard rule
)
1771 (org-test-with-temp-text "| a |\n|---|"
1773 (org-element-parse-buffer) 'table-row
1774 (lambda (row) (org-element-property :type row
)))))))
1779 (ert-deftest test-org-element
/target-parser
()
1780 "Test `target' parser."
1782 (org-test-with-temp-text "<<target>>"
1783 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
1788 (ert-deftest test-org-element
/timestamp
()
1789 "Test `timestamp' parser."
1790 ;; Active timestamp.
1792 (org-test-with-temp-text "<2012-03-29 16:40>"
1793 (eq (org-element-property :type
(org-element-context)) 'active
)))
1795 (org-test-with-temp-text "<2012-03-29 Thu>"
1796 (let ((timestamp (org-element-context)))
1797 (or (org-element-property :hour-start timestamp
)
1798 (org-element-property :minute-start timestamp
)))))
1800 (equal '(2012 3 29 16 40)
1801 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
1802 (let ((object (org-element-context)))
1803 (list (org-element-property :year-start object
)
1804 (org-element-property :month-start object
)
1805 (org-element-property :day-start object
)
1806 (org-element-property :hour-start object
)
1807 (org-element-property :minute-start object
))))))
1808 ;; Inactive timestamp.
1810 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
1811 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
1814 (equal '(2012 3 29 16 40 7 30)
1815 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1816 (let ((object (org-element-context)))
1817 (list (org-element-property :year-end object
)
1818 (org-element-property :month-end object
)
1819 (org-element-property :day-end object
)
1820 (org-element-property :hour-end object
)
1821 (org-element-property :minute-end object
)
1822 (org-element-property :hour-start object
)
1823 (org-element-property :minute-start object
))))))
1826 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1827 (org-element-property :type
(org-element-context)))))
1830 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
1831 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
1833 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
1834 (let ((timestamp (org-element-context)))
1835 (or (org-element-property :hour-end timestamp
)
1836 (org-element-property :minute-end timestamp
)))))
1837 ;; With repeater, warning delay and both.
1840 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
1841 (org-element-property :repeater-type
(org-element-context)))))
1844 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
1845 (org-element-property :warning-type
(org-element-context)))))
1847 (equal '(cumulate all
)
1848 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
1849 (let ((ts (org-element-context)))
1850 (list (org-element-property :repeater-type ts
)
1851 (org-element-property :warning-type ts
))))))
1852 ;; Timestamps are not planning elements.
1854 (org-test-with-temp-text "SCHEDULED: <2012-03-29 Thu 16:40>"
1855 (org-element-map (org-element-parse-buffer) 'timestamp
'identity
))))
1860 (ert-deftest test-org-element
/underline-parser
()
1861 "Test `underline' parser."
1864 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1865 (org-test-with-temp-text "_underline_"
1866 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
1867 ;; Multi-line markup.
1870 (org-element-contents
1871 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1872 (org-test-with-temp-text "_first line\nsecond line_"
1874 (org-element-parse-buffer) 'underline
'identity nil t
))))
1875 '("first line\nsecond line"))))
1880 (ert-deftest test-org-element
/verbatim-parser
()
1881 "Test `verbatim' parser."
1884 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1885 (org-test-with-temp-text "=verbatim="
1886 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
1887 ;; Multi-line markup.
1890 (org-element-property
1892 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1893 (org-test-with-temp-text "=first line\nsecond line="
1895 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
1896 "first line\nsecond line")))
1901 (ert-deftest test-org-element
/verse-block-parser
()
1902 "Test `verse-block' parser."
1905 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
1906 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1909 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
1910 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1911 ;; Parse objects in verse blocks.
1913 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
1914 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
1915 ;; Ignore incomplete verse block.
1917 (org-test-with-temp-text "#+BEGIN_VERSE"
1919 (org-element-parse-buffer) 'verse-block
'identity nil t
))))
1923 ;;; Test Interpreters.
1925 (ert-deftest test-org-element
/affiliated-keywords-interpreter
()
1926 "Test if affiliated keywords are correctly interpreted."
1927 ;; Interpret simple keywords.
1930 (org-element-interpret-data
1931 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
1932 "#+NAME: para\nParagraph\n"))
1933 ;; Interpret multiple keywords.
1936 (org-element-interpret-data
1937 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
1938 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
1939 ;; Interpret parsed keywords.
1942 (org-element-interpret-data
1943 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
1944 "#+CAPTION: caption\nParagraph\n"))
1945 ;; Interpret dual keywords.
1948 (org-element-interpret-data
1949 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
1950 "#+CAPTION[short]: long\nParagraph\n"))
1951 ;; Interpret multiple parsed dual keywords.
1954 (org-element-interpret-data
1955 '(org-data nil
(paragraph
1956 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
1957 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n")))
1959 (ert-deftest test-org-element
/center-block-interpreter
()
1960 "Test center block interpreter."
1962 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
1963 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
1965 (ert-deftest test-org-element
/drawer-interpreter
()
1966 "Test drawer interpreter."
1968 (equal (let ((org-drawers '("TEST")))
1969 (org-test-parse-and-interpret ":TEST:\nTest\n:END:"))
1970 ":TEST:\nTest\n:END:\n")))
1972 (ert-deftest test-org-element
/dynamic-block-interpreter
()
1973 "Test dynamic block interpreter."
1975 (equal (org-test-parse-and-interpret
1976 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
1977 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
1979 (ert-deftest test-org-element
/footnote-definition-interpreter
()
1980 "Test footnote definition interpreter."
1981 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
1983 (ert-deftest test-org-element
/headline-interpreter
()
1984 "Test headline and section interpreters."
1985 ;; 1. Standard test.
1986 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
1987 ;; 2. With TODO keywords.
1989 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1990 (org-test-parse-and-interpret "* TODO Headline"))
1991 "* TODO Headline\n"))
1994 ;; 3.1. ... and a positive `org-tags-column' value.
1996 (equal (let ((org-tags-column 20))
1997 (org-test-parse-and-interpret "* Headline :tag:"))
1998 "* Headline :tag:\n"))
1999 ;; 3.2. ... and a negative `org-tags-column' value.
2001 (equal (let ((org-tags-column -
20))
2002 (org-test-parse-and-interpret "* Headline :tag:"))
2003 "* Headline :tag:\n"))
2004 ;; 3.3. ... and a null `org-tags-column' value.
2006 (equal (let ((org-tags-column 0))
2007 (org-test-parse-and-interpret "* Headline :tag:"))
2008 "* Headline :tag:\n"))
2009 ;; 4. With priority cookie.
2011 (equal (org-test-parse-and-interpret "* [#B] Headline")
2012 "* [#B] Headline\n"))
2013 ;; 5. With comment keyword.
2015 (equal (let ((org-comment-string "COMMENT"))
2016 (org-test-parse-and-interpret "* COMMENT Headline"))
2017 "* COMMENT Headline\n"))
2018 ;; 6. With quote section.
2020 (equal (let ((org-quote-string "QUOTE"))
2021 (org-test-parse-and-interpret "* QUOTE Headline"))
2022 "* QUOTE Headline\n"))
2023 ;; 7. Keep same number of blank lines before body.
2025 (equal (org-test-parse-and-interpret
2026 "* Headline\n\n\nText after two blank lines.")
2027 "* Headline\n\n\nText after two blank lines.\n")))
2029 (ert-deftest test-org-element
/inlinetask-interpreter
()
2030 "Test inlinetask interpretation."
2031 (when (featurep 'org-inlinetask
)
2032 (let ((org-inlinetask-min-level 15))
2033 ;; 1. Regular inlinetask.
2034 (should (equal (org-test-parse-and-interpret
2035 "*************** Task\nTest\n*************** END")
2036 "*************** Task\nTest\n*************** END\n"))
2037 ;; 2. Degenerate inlinetask.
2038 (should (equal (org-test-parse-and-interpret "*************** Task")
2039 "*************** Task\n"))
2040 ;; 3. Prefer degenerate form when there are no contents.
2041 (should (equal (org-test-parse-and-interpret
2042 "*************** Task\n*************** END")
2043 "*************** Task\n"))
2044 ;; 4. With TODO keywords.
2046 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2047 (org-test-parse-and-interpret "*************** TODO Task"))
2048 "*************** TODO Task\n"))
2051 ;; 5.1. ... and a positive `org-tags-column' value.
2053 (equal (let ((org-tags-column 30))
2054 (org-test-parse-and-interpret "*************** Task :tag:"))
2055 "*************** Task :tag:\n"))
2056 ;; 5.2. ... and a negative `org-tags-column' value.
2058 (equal (let ((org-tags-column -
30))
2059 (org-test-parse-and-interpret "*************** Task :tag:"))
2060 "*************** Task :tag:\n"))
2061 ;; 5.3. ... and a null `org-tags-column' value.
2063 (equal (let ((org-tags-column 0))
2064 (org-test-parse-and-interpret "*************** Task :tag:"))
2065 "*************** Task :tag:\n"))
2066 ;; 6. With priority cookie.
2068 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2069 "*************** [#B] Task\n")))))
2071 (ert-deftest test-org-element
/plain-list-interpreter
()
2072 "Test plain-list and item interpreters."
2073 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2075 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2076 ;; Description list.
2078 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2081 (equal (let ((org-plain-list-ordered-item-terminator t
))
2082 (org-test-parse-and-interpret "1. Item"))
2085 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2086 (org-test-parse-and-interpret "1) Item"))
2088 ;; Ordered list with counter.
2090 (equal (let ((org-plain-list-ordered-item-terminator t
))
2091 (org-test-parse-and-interpret "1. [@5] Item"))
2093 ;; List with check-boxes.
2095 (equal (org-test-parse-and-interpret
2096 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2097 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2098 ;; Item not starting with a paragraph.
2100 (equal (org-test-parse-and-interpret "-\n | a | b |")
2101 "- \n | a | b |\n"))
2102 ;; Special case: correctly handle "*" bullets.
2103 (should (org-test-parse-and-interpret " * item"))
2104 ;; Special case: correctly handle empty items.
2105 (should (org-test-parse-and-interpret "-"))))
2107 (ert-deftest test-org-element
/quote-block-interpreter
()
2108 "Test quote block interpreter."
2109 (should (equal (org-test-parse-and-interpret
2110 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2111 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2113 (ert-deftest test-org-element
/special-block-interpreter
()
2114 "Test special block interpreter."
2115 (should (equal (org-test-parse-and-interpret
2116 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2117 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2119 (ert-deftest test-org-element
/babel-call-interpreter
()
2120 "Test babel call interpreter."
2121 ;; 1. Without argument.
2122 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2123 "#+CALL: test()\n"))
2124 ;; 2. With argument.
2125 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2126 "#+CALL: test(x=2)\n"))
2127 ;; 3. With header arguments.
2128 (should (equal (org-test-parse-and-interpret
2129 "#+CALL: test[:results output]()[:results html]")
2130 "#+CALL: test[:results output]()[:results html]\n")))
2132 (ert-deftest test-org-element
/clock-interpreter
()
2133 "Test clock interpreter."
2136 (equal (let ((org-clock-string "CLOCK:"))
2137 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]"))
2138 "CLOCK: [2012-01-01 sun. 00:01]\n"))
2142 (let ((org-clock-string "CLOCK:"))
2143 (org-test-parse-and-interpret "
2144 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))
2145 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01\n")))
2147 (ert-deftest test-org-element
/comment-interpreter
()
2148 "Test comment interpreter."
2150 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2152 (should (equal (org-test-parse-and-interpret " # Comment")
2154 ;; Preserve indentation.
2155 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2156 "# No blank\n# One blank\n")))
2158 (ert-deftest test-org-element
/comment-block-interpreter
()
2159 "Test comment block interpreter."
2160 (should (equal (org-test-parse-and-interpret
2161 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2162 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
2164 (ert-deftest test-org-element
/diary-sexp
()
2165 "Test diary-sexp interpreter."
2168 (org-test-parse-and-interpret
2169 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2170 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2172 (ert-deftest test-org-element
/example-block-interpreter
()
2173 "Test example block interpreter."
2174 ;; Without switches.
2175 (should (equal (org-test-parse-and-interpret
2176 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2177 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2180 (equal (org-test-parse-and-interpret
2181 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2182 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2183 ;; Preserve code escaping.
2185 (equal (org-test-parse-and-interpret
2186 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2187 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n")))
2189 (ert-deftest test-org-element
/export-block-interpreter
()
2190 "Test export block interpreter."
2191 (should (equal (org-test-parse-and-interpret
2192 "#+BEGIN_HTML\nTest\n#+END_HTML")
2193 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2195 (ert-deftest test-org-element
/fixed-width-interpreter
()
2196 "Test fixed width interpreter."
2198 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2199 ;; Preserve indentation.
2200 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2201 ": 2 blanks\n: 1 blank\n"))
2202 ;; Remove last newline character
2204 (equal (org-element-fixed-width-interpreter
2205 '(fixed-width (:value
"Test\n")) nil
)
2208 (equal (org-element-fixed-width-interpreter
2209 '(fixed-width (:value
"Test")) nil
)
2211 ;; Handle empty string.
2213 (equal (org-element-fixed-width-interpreter
2214 '(fixed-width (:value
"")) nil
)
2216 ;; Handle nil value.
2218 (org-element-fixed-width-interpreter
2219 '(fixed-width (:value nil
)) nil
)))
2221 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2222 "Test horizontal rule interpreter."
2223 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2225 (ert-deftest test-org-element
/keyword-interpreter
()
2226 "Test keyword interpreter."
2227 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2228 "#+KEYWORD: value\n")))
2230 (ert-deftest test-org-element
/latex-environment-interpreter
()
2231 "Test latex environment interpreter."
2232 (should (equal (org-test-parse-and-interpret
2233 "\\begin{equation}\n1+1=2\n\\end{equation}")
2234 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2235 (should (equal (org-test-parse-and-interpret
2236 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2237 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2239 (ert-deftest test-org-element
/planning-interpreter
()
2240 "Test planning interpreter."
2241 (let ((org-closed-string "CLOSED:")
2242 (org-deadline-string "DEADLINE:")
2243 (org-scheduled-string "SCHEDULED:"))
2246 (org-test-parse-and-interpret
2248 DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01> CLOSED: [2012-01-01]")
2250 DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01> CLOSED: [2012-01-01]\n"))))
2252 (ert-deftest test-org-element
/property-drawer-interpreter
()
2253 "Test property drawer interpreter."
2254 (should (equal (let ((org-property-format "%-10s %s"))
2255 (org-test-parse-and-interpret
2256 ":PROPERTIES:\n:prop: value\n:END:"))
2257 ":PROPERTIES:\n:prop: value\n:END:\n")))
2259 (ert-deftest test-org-element
/src-block-interpreter
()
2260 "Test src block interpreter."
2263 (equal (let ((org-edit-src-content-indentation 2))
2264 (org-test-parse-and-interpret
2265 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2266 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2269 (equal (let ((org-edit-src-content-indentation 2))
2270 (org-test-parse-and-interpret
2271 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2272 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2273 ;; Preserve code escaping.
2275 (equal (let ((org-edit-src-content-indentation 2))
2276 (org-test-parse-and-interpret
2277 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2278 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2279 ;; Do not apply `org-edit-src-content-indentation' when preserving
2282 (equal (let ((org-edit-src-content-indentation 2)
2283 (org-src-preserve-indentation t
))
2284 (org-test-parse-and-interpret
2285 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2286 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2288 (equal (let ((org-edit-src-content-indentation 2)
2289 (org-src-preserve-indentation nil
))
2290 (org-test-parse-and-interpret
2291 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2292 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n")))
2294 (ert-deftest test-org-element
/table-interpreter
()
2295 "Test table, table-row and table-cell interpreters."
2297 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2298 "| a | b |\n| c | d |\n"))
2299 ;; 2. With horizontal rules.
2300 (should (equal (org-test-parse-and-interpret
2301 "| a | b |\n|---+---|\n| c | d |")
2302 "| a | b |\n|---+---|\n| c | d |\n"))
2303 ;; 3. With meta-data.
2304 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2305 "| / | < | > |\n| * | 1 | 2 |\n"))
2306 ;; 4. With a formula.
2308 (equal (org-test-parse-and-interpret
2309 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2310 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2311 ;; 5. With multiple formulas.
2313 (equal (org-test-parse-and-interpret
2314 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2315 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2317 (ert-deftest test-org-element
/timestamp-interpreter
()
2318 "Test timestamp interpreter."
2320 (should (equal (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")
2321 "<2012-03-29 thu. 16:40>\n"))
2323 (string-match "<2012-03-29 .* 16:40>"
2324 (org-element-timestamp-interpreter
2326 (:type active
:year-start
2012 :month-start
3 :day-start
29
2327 :hour-start
16 :minute-start
40)) nil
)))
2329 (should (equal (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")
2330 "[2012-03-29 thu. 16:40]\n"))
2333 "\\[2012-03-29 .* 16:40\\]"
2334 (org-element-timestamp-interpreter
2336 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2337 :hour-start
16 :minute-start
40)) nil
)))
2339 (should (equal (org-test-parse-and-interpret
2340 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")
2341 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>\n"))
2344 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2345 (org-element-timestamp-interpreter
2347 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2348 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2349 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2351 (should (equal (org-test-parse-and-interpret
2352 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")
2353 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]\n"))
2356 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2357 (org-element-timestamp-interpreter
2359 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2360 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2361 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2363 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2364 "<%%diary-float t 4 2>\n"))
2365 ;; Timestamp with repeater interval, with delay, with both.
2366 (should (equal (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")
2367 "<2012-03-29 thu. +1y>\n"))
2370 "<2012-03-29 .* \\+1y>"
2371 (org-element-timestamp-interpreter
2373 (:type active
:year-start
2012 :month-start
3 :day-start
29
2374 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2378 "<2012-03-29 .* -1y>"
2379 (org-element-timestamp-interpreter
2381 (:type active
:year-start
2012 :month-start
3 :day-start
29
2382 :warning-type all
:warning-value
1 :warning-unit year
))
2386 "<2012-03-29 .* \\+1y -1y>"
2387 (org-element-timestamp-interpreter
2389 (:type active
:year-start
2012 :month-start
3 :day-start
29
2390 :warning-type all
:warning-value
1 :warning-unit year
2391 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2393 ;; Timestamp range with repeater interval
2394 (should (equal (org-test-parse-and-interpret
2395 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")
2396 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>\n"))
2399 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2400 (org-element-timestamp-interpreter
2402 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2403 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2404 :repeater-value
1 :repeater-unit year
))
2407 (ert-deftest test-org-element
/verse-block-interpreter
()
2408 "Test verse block interpretation."
2410 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2411 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2413 (ert-deftest test-org-element
/bold-interpreter
()
2414 "Test bold interpreter."
2415 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2417 (ert-deftest test-org-element
/code-interpreter
()
2418 "Test code interpreter."
2419 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2421 (ert-deftest test-org-element
/entity-interpreter
()
2422 "Test entity interpreter."
2423 ;; 1. Without brackets.
2425 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2426 ;; 2. With brackets.
2428 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2430 (ert-deftest test-org-element
/export-snippet-interpreter
()
2431 "Test export snippet interpreter."
2432 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2433 "@@back-end:contents@@\n")))
2435 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2436 "Test footnote reference interpreter."
2437 ;; 1. Regular reference.
2438 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2439 ;; 2. Normalized reference.
2440 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2441 ;; 3. Named reference.
2442 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2443 "Text[fn:label]\n"))
2444 ;; 4. Inline reference.
2445 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2446 "Text[fn:label:def]\n"))
2447 ;; 5. Anonymous reference.
2448 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2449 "Text[fn::def]\n")))
2451 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2452 "Test inline babel call interpreter."
2453 ;; 1. Without arguments.
2454 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2455 ;; 2. With arguments.
2456 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2457 "call_test(x=2)\n"))
2458 ;; 3. With header arguments.
2459 (should (equal (org-test-parse-and-interpret
2460 "call_test[:results output]()[:results html]")
2461 "call_test[:results output]()[:results html]\n")))
2463 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2464 "Test inline src block interpreter."
2465 ;; 1. Without header argument.
2466 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2467 "src_emacs-lisp{(+ 1 1)}\n"))
2468 ;; 2. With header arguments.
2469 (should (equal (org-test-parse-and-interpret
2470 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2471 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2473 (ert-deftest test-org-element
/italic-interpreter
()
2474 "Test italic interpreter."
2475 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2477 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2478 "Test latex fragment interpreter."
2479 (let ((org-latex-regexps
2480 '(("begin" "^[ ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^