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
)))
243 ;; Handle non-empty blank line at the end of buffer.
245 (org-test-with-temp-text "#+CALL: test()\n "
246 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
251 (ert-deftest test-org-element
/bold-parser
()
252 "Test `bold' parser."
255 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
256 (org-test-with-temp-text "*bold*"
257 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
258 ;; Multi-line markup.
261 (org-element-contents
262 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
263 (org-test-with-temp-text "*first line\nsecond line*"
264 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
265 '("first line\nsecond line"))))
270 (ert-deftest test-org-element
/center-block-parser
()
271 "Test `center-block' parser."
274 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
275 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
278 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
279 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
280 ;; Ignore incomplete block.
282 (org-test-with-temp-text "#+BEGIN_CENTER"
283 (org-element-map (org-element-parse-buffer) 'center-block
285 ;; Handle non-empty blank line at the end of buffer.
287 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
288 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
293 (ert-deftest test-org-element
/clock-parser
()
294 "Test `clock' parser."
296 (let* ((org-clock-string "CLOCK:")
297 (clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
298 (org-element-at-point))))
299 (should (eq (org-element-property :status clock
) 'running
))
301 (equal (org-element-property :raw-value
302 (org-element-property :value clock
))
303 "[2012-01-01 sun. 00:01]"))
304 (should-not (org-element-property :duration clock
)))
306 (let* ((org-clock-string "CLOCK:")
308 (org-test-with-temp-text
309 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
310 (org-element-at-point))))
311 (should (eq (org-element-property :status clock
) 'closed
))
312 (should (equal (org-element-property :raw-value
313 (org-element-property :value clock
))
314 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
315 (should (equal (org-element-property :duration clock
) "0:01"))))
320 (ert-deftest test-org-element
/code-parser
()
321 "Test `code' parser."
324 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
325 (org-test-with-temp-text "~code~"
326 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
327 ;; Multi-line markup.
330 (org-element-property
332 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
333 (org-test-with-temp-text "~first line\nsecond line~"
335 (org-element-parse-buffer) 'code
'identity nil t
))))
336 "first line\nsecond line")))
341 (ert-deftest test-org-element
/comment-parser
()
342 "Test `comment' parser."
345 (org-test-with-temp-text "# Comment"
346 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
349 (org-test-with-temp-text " # Comment"
350 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
351 ;; Preserve indentation.
354 (org-element-property
356 (org-test-with-temp-text "# No blank\n# One blank"
357 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
358 "No blank\n One blank"))
359 ;; Comment with blank lines.
362 (org-element-property
364 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
365 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
366 "First part\n\n\nSecond part"))
367 ;; Do not mix comments and keywords.
370 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
371 (length (org-element-map (org-element-parse-buffer) 'comment
375 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
376 (org-element-property
378 (org-element-map (org-element-parse-buffer) 'comment
380 ;; Correctly handle non-empty blank lines at the end of buffer.
382 (org-test-with-temp-text "# A\n "
383 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
388 (ert-deftest test-org-element
/comment-block-parser
()
389 "Test `comment-block' parser."
392 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
393 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
396 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
397 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
398 ;; Ignore incomplete block.
400 (org-test-with-temp-text "#+BEGIN_COMMENT"
401 (org-element-map (org-element-parse-buffer) 'comment-block
403 ;; Handle non-empty blank line at the end of buffer.
405 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
406 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
411 (ert-deftest test-org-element
/diary-sexp-parser
()
412 "Test `diary-sexp' parser."
416 (org-test-with-temp-text
417 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
418 (org-element-type (org-element-at-point)))))
419 ;; Diary sexp must live at beginning of line
422 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
423 (org-element-type (org-element-at-point)))))
424 ;; Handle non-empty blank line at the end of buffer.
426 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
427 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
432 (ert-deftest test-org-element
/drawer-parser
()
433 "Test `drawer' parser."
436 (org-test-with-temp-text ":TEST:\nText\n:END:"
437 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
438 ;; Do not mix regular drawers and property drawers.
440 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
441 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
442 ;; Ignore incomplete drawer.
444 (org-test-with-temp-text ":TEST:"
445 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
446 ;; Handle non-empty blank line at the end of buffer.
448 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
449 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
454 (ert-deftest test-org-element
/dynamic-block-parser
()
455 "Test `dynamic-block' parser."
458 (org-test-with-temp-text
459 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
460 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
463 (org-test-with-temp-text
464 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
465 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
466 ;; Ignore incomplete block.
468 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
469 (org-element-map (org-element-parse-buffer) 'dynamic-block
471 ;; Handle non-empty blank line at the end of buffer.
473 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
474 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
479 (ert-deftest test-org-element
/entity-parser
()
480 "Test `entity' parser."
483 (org-test-with-temp-text "\\sin"
484 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
487 (org-element-property
489 (org-test-with-temp-text "\\alpha{}text"
490 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
491 ;; User-defined entity.
494 (org-element-property
496 (let ((org-entities-user
497 '(("test" "test" nil
"test" "test" "test" "test"))))
498 (org-test-with-temp-text "\\test"
499 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
501 ;; Special case: entity at the end of a container.
504 (org-test-with-temp-text "*\\alpha \\beta*"
505 (search-forward "be")
506 (org-element-type (org-element-context))))))
511 (ert-deftest test-org-element
/example-block-parser
()
512 "Test `example-block' parser."
515 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
516 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
517 ;; Ignore incomplete block.
520 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
521 (org-element-type (org-element-at-point)))))
522 ;; Properly un-escape code.
524 (equal "* Headline\n #+keyword\nText\n"
525 (org-test-with-temp-text
526 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
527 (org-element-property :value
(org-element-at-point)))))
528 ;; Remove block indentation according to block boundaries, unless
529 ;; block contents are less indented than block boundaries.
532 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
533 (let ((org-src-preserve-indentation t
))
534 (org-element-property :value
(org-element-at-point))))))
538 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
539 (let ((org-src-preserve-indentation t
))
540 (org-element-property :value
(org-element-at-point))))))
541 ;; Handle non-empty blank line at the end of buffer.
543 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
544 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
546 (ert-deftest test-org-element
/block-switches
()
547 "Test `example-block' and `src-block' switches parsing."
548 (let ((org-coderef-label-format "(ref:%s)"))
549 ;; 1. Test "-i" switch.
551 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
552 (org-element-property :preserve-indent
(org-element-at-point))))
554 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
555 (org-element-property :preserve-indent
(org-element-at-point))))
557 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
558 (org-element-property :preserve-indent
(org-element-at-point))))
560 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
561 (org-element-property :preserve-indent
(org-element-at-point))))
562 ;; 2. "-n -r -k" combination should number lines, retain labels but
563 ;; not use them in coderefs.
565 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
566 (let ((element (org-element-at-point)))
567 (and (org-element-property :number-lines element
)
568 (org-element-property :retain-labels element
)
569 (not (org-element-property :use-labels element
))))))
571 (org-test-with-temp-text
572 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
573 (let ((element (org-element-at-point)))
574 (and (org-element-property :number-lines element
)
575 (org-element-property :retain-labels element
)
576 (not (org-element-property :use-labels element
))))))
577 ;; 3. "-n -r" combination should number-lines remove labels and not
578 ;; use them in coderefs.
580 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
581 (let ((element (org-element-at-point)))
582 (and (org-element-property :number-lines element
)
583 (not (org-element-property :retain-labels element
))
584 (not (org-element-property :use-labels element
))))))
586 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
587 (let ((element (org-element-at-point)))
588 (and (org-element-property :number-lines element
)
589 (not (org-element-property :retain-labels element
))
590 (not (org-element-property :use-labels element
))))))
591 ;; 4. "-n" or "+n" should number lines, retain labels and use them
594 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
595 (let ((element (org-element-at-point)))
596 (and (org-element-property :number-lines element
)
597 (org-element-property :retain-labels element
)
598 (org-element-property :use-labels element
)))))
600 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
601 (let ((element (org-element-at-point)))
602 (and (org-element-property :number-lines element
)
603 (org-element-property :retain-labels element
)
604 (org-element-property :use-labels element
)))))
606 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
607 (let ((element (org-element-at-point)))
608 (and (org-element-property :number-lines element
)
609 (org-element-property :retain-labels element
)
610 (org-element-property :use-labels element
)))))
612 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
613 (let ((element (org-element-at-point)))
614 (and (org-element-property :number-lines element
)
615 (org-element-property :retain-labels element
)
616 (org-element-property :use-labels element
)))))
617 ;; 5. No switch should not number lines, but retain labels and use
620 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
621 (let ((element (org-element-at-point)))
622 (and (not (org-element-property :number-lines element
))
623 (org-element-property :retain-labels element
)
624 (org-element-property :use-labels element
)))))
626 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
627 (let ((element (org-element-at-point)))
628 (and (not (org-element-property :number-lines element
))
629 (org-element-property :retain-labels element
)
630 (org-element-property :use-labels element
)))))
631 ;; 6. "-r" switch only: do not number lines, remove labels, and
632 ;; don't use labels in coderefs.
634 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
635 (let ((element (org-element-at-point)))
636 (and (not (org-element-property :number-lines element
))
637 (not (org-element-property :retain-labels element
))
638 (not (org-element-property :use-labels element
))))))
640 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
641 (let ((element (org-element-at-point)))
642 (and (not (org-element-property :number-lines element
))
643 (not (org-element-property :retain-labels element
))
644 (not (org-element-property :use-labels element
))))))
645 ;; 7. Recognize coderefs with user-defined syntax.
649 (org-test-with-temp-text
650 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
651 (org-element-property :label-fmt
(org-element-at-point)))))
655 (org-test-with-temp-text
656 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
657 (org-element-property :label-fmt
(org-element-at-point)))))))
662 (ert-deftest test-org-element
/export-block-parser
()
663 "Test `export-block' parser."
666 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
668 (let ((org-element-block-name-alist
669 '(("LATEX" . org-element-export-block-parser
))))
670 (org-element-parse-buffer))
671 'export-block
'identity
)))
674 (let ((org-element-block-name-alist
675 '(("LATEX" . org-element-export-block-parser
))))
676 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
677 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
678 ;; Ignore incomplete block.
680 (let ((org-element-block-name-alist
681 '(("LATEX" . org-element-export-block-parser
))))
682 (org-test-with-temp-text "#+BEGIN_LATEX"
683 (org-element-map (org-element-parse-buffer) 'export-block
685 ;; Handle non-empty blank line at the end of buffer.
687 (let ((org-element-block-name-alist
688 '(("LATEX" . org-element-export-block-parser
))))
689 (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
690 (= (org-element-property :end
(org-element-at-point)) (point-max))))))
695 (ert-deftest test-org-element
/export-snippet-parser
()
696 "Test `export-snippet' parser."
699 '("back-end" .
"contents")
700 (org-test-with-temp-text "@@back-end:contents@@"
702 (org-element-parse-buffer) 'export-snippet
703 (lambda (snippet) (cons (org-element-property :back-end snippet
)
704 (org-element-property :value snippet
)))
710 (ert-deftest test-org-element
/fixed-width-parser
()
711 "Test fixed-width area parsing."
712 ;; Preserve indentation.
714 (org-test-with-temp-text ": no blank\n: one blank"
715 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
716 ;; Fixed-width with empty lines.
718 (org-test-with-temp-text ": first part\n:\n: \n: second part"
719 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
720 ;; Parse indented fixed-width markers.
722 (org-test-with-temp-text "Text\n : no blank\n : one blank"
723 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
724 ;; Distinguish fixed-width areas within a list and outside of it.
728 (org-test-with-temp-text "
731 : fixed-width outside"
732 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
733 ;; Handle non-empty blank line at the end of buffer.
735 (org-test-with-temp-text ": A\n "
736 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
739 ;;;; Footnote Definition
741 (ert-deftest test-org-element
/footnote-definition-parser
()
742 "Test `footnote-definition' parser."
744 (org-test-with-temp-text "[fn:1] Definition"
745 (org-element-map (org-element-parse-buffer) 'footnote-definition
747 ;; Footnote with more contents
750 (org-element-property
752 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
753 (org-element-map (org-element-parse-buffer) 'footnote-definition
755 ;; Footnote starting with special syntax.
757 (org-test-with-temp-text "[fn:1] - no item"
758 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
759 ;; Correctly handle footnote starting with an empty line.
762 (org-test-with-temp-text "[fn:1]\n\n Body"
763 (org-element-property :contents-begin
(org-element-at-point)))))
764 ;; Handle non-empty blank line at the end of buffer.
766 (org-test-with-temp-text "[fn:1] Definition\n "
767 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
770 ;;;; Footnotes Reference.
772 (ert-deftest test-org-element
/footnote-reference-parser
()
773 "Test `footnote-reference' parser."
774 ;; 1. Parse a standard reference.
775 (org-test-with-temp-text "Text[fn:label]"
778 (org-element-parse-buffer) 'footnote-reference
'identity
)))
779 ;; 2. Parse a normalized reference.
780 (org-test-with-temp-text "Text[1]"
783 (org-element-parse-buffer) 'footnote-reference
'identity
)))
784 ;; 3. Parse an inline reference.
785 (org-test-with-temp-text "Text[fn:test:def]"
788 (org-element-parse-buffer) 'footnote-reference
'identity
)))
789 ;; 4. Parse an anonymous reference.
790 (org-test-with-temp-text "Text[fn::def]"
793 (org-element-parse-buffer) 'footnote-reference
'identity
)))
794 ;; 5. Parse nested footnotes.
795 (org-test-with-temp-text "Text[fn::def [fn:label]]"
800 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
801 ;; 6. Parse adjacent footnotes.
802 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
807 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
808 ;; 7. Only properly closed footnotes are recognized as such.
809 (org-test-with-temp-text "Text[fn:label"
812 (org-element-parse-buffer) 'footnote-reference
'identity
))))
817 (ert-deftest test-org-element
/headline-quote-keyword
()
818 "Test QUOTE keyword recognition."
820 (org-test-with-temp-text "* Headline"
821 (let ((org-quote-string "QUOTE"))
822 (should-not (org-element-property :quotedp
(org-element-at-point)))))
823 ;; Standard position.
824 (org-test-with-temp-text "* QUOTE Headline"
825 (let* ((org-quote-string "QUOTE")
826 (headline (org-element-at-point)))
827 (should (org-element-property :quotedp headline
))
828 ;; Test removal from raw value.
829 (should (equal (org-element-property :raw-value headline
) "Headline"))))
831 (org-test-with-temp-text "* QUOTE Headline"
832 (let* ((org-quote-string "Quote")
833 (headline (org-element-at-point)))
834 (should-not (org-element-property :quotedp headline
))
835 (should (equal (org-element-property :raw-value headline
)
837 ;; With another keyword.
838 (org-test-with-temp-text "* TODO QUOTE Headline"
839 (let* ((org-quote-string "QUOTE")
840 (org-todo-keywords '((sequence "TODO" "DONE")))
841 (headline (org-element-at-point)))
842 (should (org-element-property :quotedp headline
))
843 (should (equal (org-element-property :raw-value headline
) "Headline"))))
844 ;; With the keyword only.
845 (org-test-with-temp-text "* QUOTE"
846 (let* ((org-quote-string "QUOTE")
847 (headline (org-element-at-point)))
848 (should (org-element-property :quotedp headline
))
849 (should (equal (org-element-property :raw-value headline
) "")))))
851 (ert-deftest test-org-element
/headline-comment-keyword
()
852 "Test COMMENT keyword recognition."
854 (org-test-with-temp-text "* Headline"
855 (let ((org-comment-string "COMMENT"))
856 (should-not (org-element-property :commentedp
(org-element-at-point)))))
857 ;; Standard position.
858 (org-test-with-temp-text "* COMMENT Headline"
859 (let ((org-comment-string "COMMENT")
860 (headline (org-element-at-point)))
861 (should (org-element-property :commentedp headline
))
862 (should (equal (org-element-property :raw-value headline
) "Headline"))))
864 (org-test-with-temp-text "* COMMENT Headline"
865 (let* ((org-comment-string "Comment")
866 (headline (org-element-at-point)))
867 (should-not (org-element-property :commentedp headline
))
868 (should (equal (org-element-property :raw-value headline
)
869 "COMMENT Headline"))))
870 ;; With another keyword.
871 (org-test-with-temp-text "* TODO COMMENT Headline"
872 (let* ((org-comment-string "COMMENT")
873 (org-todo-keywords '((sequence "TODO" "DONE")))
874 (headline (org-element-at-point)))
875 (should (org-element-property :commentedp headline
))
876 (should (equal (org-element-property :raw-value headline
) "Headline"))))
877 ;; With the keyword only.
878 (org-test-with-temp-text "* COMMENT"
879 (let* ((org-comment-string "COMMENT")
880 (headline (org-element-at-point)))
881 (should (org-element-property :commentedp headline
))
882 (should (equal (org-element-property :raw-value headline
) "")))))
884 (ert-deftest test-org-element
/headline-archive-tag
()
885 "Test ARCHIVE tag recognition."
888 (org-test-with-temp-text "* Headline"
889 (let ((org-archive-tag "ARCHIVE"))
890 (org-element-property :archivedp
(org-element-at-point)))))
892 (org-test-with-temp-text "* Headline :ARCHIVE:"
893 (let ((org-archive-tag "ARCHIVE"))
894 (let ((headline (org-element-at-point)))
895 (should (org-element-property :archivedp headline
))
897 (should-not (org-element-property :tags headline
)))))
899 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
900 (let ((org-archive-tag "ARCHIVE"))
901 (let ((headline (org-element-at-point)))
902 (should (org-element-property :archivedp headline
))
904 (should (equal (org-element-property :tags headline
) '("test"))))))
905 ;; Tag is case-sensitive.
907 (org-test-with-temp-text "* Headline :ARCHIVE:"
908 (let ((org-archive-tag "Archive"))
909 (org-element-property :archivedp
(org-element-at-point))))))
911 (ert-deftest test-org-element
/headline-properties
()
912 "Test properties from property drawer."
913 ;; All properties from property drawer have their symbol upper
916 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
917 (org-element-property :FOO
(org-element-at-point))))
919 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
920 (org-element-property :foo
(org-element-at-point)))))
925 (ert-deftest test-org-element
/horizontal-rule-parser
()
926 "Test `horizontal-rule' parser."
929 (org-test-with-temp-text "-----"
930 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
933 (org-test-with-temp-text " -----"
934 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
935 ;; Hyphen must be alone on the line.
937 (org-test-with-temp-text "-----wrong"
938 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
939 ;; 4 hyphens is too small.
941 (org-test-with-temp-text "----"
942 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
943 ;; Handle non-empty blank line at the end of buffer.
945 (org-test-with-temp-text "-----\n "
946 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
949 ;;;; Inline Babel Call
951 (ert-deftest test-org-element
/inline-babel-call-parser
()
952 "Test `inline-babel-call' parser."
954 (org-test-with-temp-text "call_test()"
956 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
959 ;;;; Inline Src Block
961 (ert-deftest test-org-element
/inline-src-block-parser
()
962 "Test `inline-src-block' parser."
964 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
965 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
966 ;; Test parsing at the beginning of an item.
968 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
969 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
974 (ert-deftest test-org-element
/inlinetask-parser
()
975 "Test `inlinetask' parser."
976 (when (featurep 'org-inlinetask
)
977 (let ((org-inlinetask-min-level 15))
978 ;; 1. Regular inlinetask.
980 (org-test-with-temp-text
981 "*************** Task\nTest\n*************** END"
982 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
983 ;; 2. Degenerate inlinetask.
985 (org-test-with-temp-text "*************** Task"
986 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
991 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
992 (org-test-with-temp-text "*************** TODO Task"
993 (org-element-property
995 (org-element-map (org-element-parse-buffer) 'inlinetask
996 'identity nil t
))))))
1001 (org-test-with-temp-text "
1002 *************** Task
1003 DEADLINE: <2012-03-29 thu.>"
1004 (org-element-property
1006 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1011 (org-test-with-temp-text "
1012 *************** [#A] Task"
1013 (org-element-property
1016 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1021 (org-test-with-temp-text "
1022 *************** Task :test:"
1023 (org-element-property
1026 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1027 ;; Regular properties are accessed through upper case keywords.
1029 (org-test-with-temp-text "
1030 *************** Task
1034 *************** END"
1036 (org-element-property :FOO
(org-element-at-point))))
1038 (org-test-with-temp-text "
1039 *************** Task
1043 *************** END"
1045 (org-element-property :foo
(org-element-at-point))))
1046 ;; Handle non-empty blank line at the end of buffer.
1048 (org-test-with-temp-text "*************** Task\n*************** END\n "
1049 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1054 (ert-deftest test-org-element
/italic-parser
()
1055 "Test `italic' parser."
1058 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1059 (org-test-with-temp-text "/italic/"
1060 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1061 ;; Multi-line markup.
1064 (org-element-contents
1065 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1066 (org-test-with-temp-text "/first line\nsecond line/"
1067 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1068 '("first line\nsecond line"))))
1073 (ert-deftest test-org-element
/item-parser
()
1074 "Test `item' parser."
1077 (org-test-with-temp-text "- item"
1078 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1082 (org-element-property
1084 (org-test-with-temp-text "6. [@6] item"
1085 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1090 (org-element-property
1092 (org-test-with-temp-text "- tag :: description"
1093 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1094 ;; No tags in ordered lists.
1096 (org-element-property
1098 (org-test-with-temp-text "1. tag :: description"
1099 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1104 (org-test-with-temp-text "
1109 (org-element-parse-buffer) 'item
1110 (lambda (item) (org-element-property :checkbox item
))))))
1111 ;; Item starting with special syntax.
1113 (equal '(("- item"))
1114 (org-test-with-temp-text "- - item"
1115 (org-element-map (org-element-parse-buffer) 'paragraph
1116 'org-element-contents
))))
1117 ;; Block in an item: ignore indentation within the block.
1119 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1121 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1126 (ert-deftest test-org-element
/keyword-parser
()
1127 "Test `keyword' parser."
1130 (org-test-with-temp-text "#+KEYWORD: value"
1131 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1132 ;; Keywords are case-insensitive.
1134 (org-test-with-temp-text "#+keyword: value"
1135 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1136 ;; Affiliated keywords are not keywords.
1138 (org-test-with-temp-text "#+NAME: value
1140 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1141 ;; Do not mix keywords with Babel calls and dynamic blocks.
1143 (org-test-with-temp-text "#+CALL: fun()"
1144 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1146 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1147 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1148 ;; Handle non-empty blank line at the end of buffer.
1150 (org-test-with-temp-text "#+KEYWORD: value\n "
1151 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1154 ;;;; Latex Environment
1156 (ert-deftest test-org-element
/latex-environment-parser
()
1157 "Test `latex-environment' parser."
1159 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1160 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1161 ;; Allow nested environments.
1169 (org-test-with-temp-text "
1175 (org-element-property
1178 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1179 ;; Allow environments with options and arguments.
1181 (eq 'latex-environment
1182 (org-test-with-temp-text
1183 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1184 (org-element-type (org-element-at-point)))))
1186 (eq 'latex-environment
1187 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1188 (org-element-type (org-element-at-point)))))
1190 (eq 'latex-environment
1191 (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1192 (org-element-type (org-element-at-point)))))
1193 ;; Handle non-empty blank line at the end of buffer.
1195 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1196 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1201 (ert-deftest test-org-element
/latex-fragment-parser
()
1202 "Test `latex-fragment' parser."
1204 (org-test-with-temp-text "$a$"
1205 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1207 (org-test-with-temp-text "$$a$$"
1208 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1210 (org-test-with-temp-text "\\(a\\)"
1211 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1213 (org-test-with-temp-text "\\[a\\]"
1215 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1216 ;; Test fragment at the beginning of an item.
1219 (org-test-with-temp-text "- $x$"
1220 (progn (search-forward "$")
1221 (org-element-type (org-element-context)))))))
1226 (ert-deftest test-org-element
/line-break-parser
()
1227 "Test `line-break' parser."
1230 (org-test-with-temp-text "Text \\\\"
1231 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1232 ;; Line break with trailing white spaces.
1234 (org-test-with-temp-text "Text \\\\ "
1235 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1236 ;; Three backslashes are too much.
1238 (org-test-with-temp-text "Text \\\\\\"
1239 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1244 (ert-deftest test-org-element
/link-parser
()
1245 "Test `link' parser."
1250 (org-test-with-temp-text "A radio link"
1251 (org-element-property
1254 (let ((org-target-link-regexp "radio")) (org-element-parse-buffer))
1255 'link
'identity nil t
)))))
1258 ;; ... with description.
1262 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1263 (org-element-contents
1264 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1265 ;; ... without description.
1269 (org-test-with-temp-text "[[http://orgmode.org]]"
1270 (org-element-property
1272 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1273 ;; ... with expansion.
1276 "//orgmode.org/worg"
1277 (org-test-with-temp-text "[[Org:worg]]"
1278 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1279 (org-element-property
1281 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1282 ;; ... with translation.
1286 (org-test-with-temp-text "[[http://orgmode.org]]"
1287 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1288 (let ((org-link-translation-function 'link-translate
))
1289 (org-element-property
1291 (org-element-map (org-element-parse-buffer) 'link
1292 'identity nil t
)))))))
1297 (org-test-with-temp-text "[[id:aaaa]]"
1298 (org-element-property
1300 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1301 ;; ... custom-id link.
1305 (org-test-with-temp-text "[[#some-id]]"
1306 (org-element-property
1308 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1309 ;; ... coderef link.
1313 (org-test-with-temp-text "[[(reference)]]"
1314 (org-element-property
1316 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1321 (org-test-with-temp-text "[[target-or-title]]"
1322 (org-element-property
1324 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1325 ;; ... file-type link with search option.
1328 '(("file" "projects.org" "*task title"))
1329 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1330 (org-element-map (org-element-parse-buffer) 'link
1331 (lambda (l) (list (org-element-property :type l
)
1332 (org-element-property :path l
)
1333 (org-element-property :search-option l
)))))))
1334 ;; ... file-type link with application.
1337 '(("file" "projects.org" "docview"))
1338 (org-test-with-temp-text "[[docview:projects.org]]"
1339 (org-element-map (org-element-parse-buffer) 'link
1340 (lambda (l) (list (org-element-property :type l
)
1341 (org-element-property :path l
)
1342 (org-element-property :application l
)))))))
1345 (org-test-with-temp-text "A link: http://orgmode.org"
1346 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1349 (org-test-with-temp-text "A link: <http://orgmode.org>"
1350 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1351 ;; Link abbreviation.
1354 (org-test-with-temp-text
1355 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1356 (progn (org-mode-restart)
1357 (goto-char (1- (point-max)))
1358 (org-element-property :type
(org-element-context))))))
1359 ;; Link abbreviation in a secondary string.
1362 (org-test-with-temp-text
1363 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1364 (progn (org-mode-restart)
1365 (org-element-map (org-element-parse-buffer) 'link
1366 (lambda (link) (org-element-property :type link
))
1368 ;; Plain links are allowed as description of regular links.
1371 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1372 (search-forward "file:")
1373 (org-element-property :type
(org-element-context))))))
1378 (ert-deftest test-org-element
/macro-parser
()
1379 "Test `macro' parser."
1380 ;; Without arguments.
1382 (org-test-with-temp-text "{{{macro}}}"
1383 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1386 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1387 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1388 ;; Properly handle protected commas in arguments...
1392 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1393 (org-element-property :args
(org-element-context))))))
1394 ;; ... even when last argument ends with a protected comma.
1397 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1398 (org-element-property :args
(org-element-context)))))
1399 ;; Allow to escape escaping character.
1402 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1403 (org-element-property :args
(org-element-context)))))
1404 ;; No need to escape backslashes elsewhere.
1407 (org-test-with-temp-text "{{{macro(\\)}}}"
1408 (org-element-property :args
(org-element-context))))))
1413 (ert-deftest test-org-element
/node-property
()
1414 "Test `node-property' parser."
1417 (equal '("abc" "value")
1418 (org-test-with-temp-text ":PROPERTIES:\n:abc: value\n:END:"
1419 (progn (forward-line)
1420 (let ((element (org-element-at-point)))
1421 (list (org-element-property :key element
)
1422 (org-element-property :value element
)))))))
1423 ;; Value should be trimmed.
1426 (org-test-with-temp-text ":PROPERTIES:\n:abc: value \n:END:"
1427 (progn (forward-line)
1428 (let ((element (org-element-at-point)))
1429 (org-element-property :value element
))))))
1430 ;; A node property requires to be wrapped within a property drawer.
1433 (org-test-with-temp-text ":abc: value"
1434 (org-element-type (org-element-at-point))))))
1439 (ert-deftest test-org-element
/paragraph-parser
()
1440 "Test `paragraph' parser."
1443 (org-test-with-temp-text "Paragraph"
1444 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1445 ;; Property find end of a paragraph stuck to another element.
1448 (org-test-with-temp-text "Paragraph\n# Comment"
1449 (org-element-map (org-element-parse-buffer) 'paragraph
1450 (lambda (p) (char-after (org-element-property :end p
)))
1452 ;; Include ill-formed Keywords.
1454 (org-test-with-temp-text "#+wrong_keyword something"
1455 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1456 ;; Include incomplete-drawers.
1458 (org-test-with-temp-text ":TEST:\nParagraph"
1459 (let ((elem (org-element-at-point)))
1460 (and (eq (org-element-type elem
) 'paragraph
)
1461 (= (point-max) (org-element-property :end elem
))))))
1462 ;; Include incomplete blocks.
1464 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1465 (let ((elem (org-element-at-point)))
1466 (and (eq (org-element-type elem
) 'paragraph
)
1467 (= (point-max) (org-element-property :end elem
))))))
1468 ;; Include incomplete dynamic blocks.
1470 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1471 (let ((elem (org-element-at-point)))
1472 (and (eq (org-element-type elem
) 'paragraph
)
1473 (= (point-max) (org-element-property :end elem
))))))
1474 ;; Include incomplete latex environments.
1476 (org-test-with-temp-text "\begin{equation}\nParagraph"
1477 (let ((elem (org-element-at-point)))
1478 (and (eq (org-element-type elem
) 'paragraph
)
1479 (= (point-max) (org-element-property :end elem
))))))
1480 ;; Do not steal affiliated keywords from container.
1482 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1483 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1484 (and (eq (org-element-type elem
) 'paragraph
)
1485 (not (org-element-property :attr_latex elem
))
1486 (/= (org-element-property :begin elem
) 1)))))
1487 ;; Handle non-empty blank line at the end of buffer.
1489 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1490 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1495 (ert-deftest test-org-element
/plain-list-parser
()
1496 "Test `plain-list' parser."
1497 (org-test-with-temp-text "- item"
1498 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1499 ;; Blank lines after the list only belong to outer plain list.
1503 (org-test-with-temp-text "
1508 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1509 (lambda (pl) (org-element-property :end pl
)))))
1511 ;; Move to ending of outer list.
1512 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1513 ;; Move to ending of inner list.
1514 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1515 ;; Correctly compute end of list if it doesn't end at a line
1518 (org-test-with-temp-text "- list\n \n "
1519 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1524 (ert-deftest test-org-element
/planning-parser
()
1525 "Test `planning' parser."
1527 (equal "[2012-03-29 thu.]"
1528 (org-element-property
1530 (org-element-property
1532 (org-test-with-temp-text "CLOSED: [2012-03-29 thu.]"
1533 (org-element-at-point))))))
1535 (equal "<2012-03-29 thu.>"
1536 (org-element-property
1538 (org-element-property
1540 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1541 (org-element-at-point))))))
1543 (equal "<2012-03-29 thu.>"
1544 (org-element-property
1546 (org-element-property
1548 (org-test-with-temp-text "SCHEDULED: <2012-03-29 thu.>"
1549 (org-element-at-point)))))))
1552 ;;;; Property Drawer
1554 (ert-deftest test-org-element
/property-drawer-parser
()
1555 "Test `property-drawer' parser."
1558 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
1560 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1561 ;; Do not mix property drawers and regular drawers.
1563 (org-test-with-temp-text ":TEST:\n:prop: value\n:END:"
1565 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1566 ;; Ignore incomplete drawer.
1568 (org-test-with-temp-text ":PROPERTIES:\n:prop: value"
1570 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1571 ;; Handle non-empty blank line at the end of buffer.
1573 (org-test-with-temp-text ":PROPERTIES:\n:END:\n "
1574 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1579 (ert-deftest test-org-element
/quote-block-parser
()
1580 "Test `quote-block' parser."
1583 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1584 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1585 ;; Ignore incomplete block.
1587 (org-test-with-temp-text "#+BEGIN_QUOTE"
1588 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1589 ;; Handle non-empty blank line at the end of buffer.
1591 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1592 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1597 (ert-deftest test-org-element
/quote-section-parser
()
1598 "Test `quote-section' parser."
1600 (let ((org-quote-string "QUOTE"))
1601 (org-test-with-temp-text "* QUOTE Headline\nBody"
1602 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
))))
1604 (let ((org-quote-string "TEST"))
1605 (org-test-with-temp-text "* QUOTE Headline\nBody"
1606 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
)))))
1611 (ert-deftest test-org-element
/radio-target-parser
()
1612 "Test `radio-target' parser."
1615 (org-test-with-temp-text "<<<radio>>>"
1616 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
)))
1617 ;; Radio targets with objects.
1619 (org-test-with-temp-text "<<<radio \\alpha>>>"
1620 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
))))
1625 (ert-deftest test-org-element
/section-parser
()
1626 "Test `section' parser."
1629 (org-test-with-temp-text "* Headline\nText"
1630 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1631 ;; There's a section before the first headline.
1633 (org-test-with-temp-text "Text"
1634 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1635 ;; A section cannot be empty.
1637 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1638 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1639 ;; A section doesn't contain sub-trees.
1641 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1643 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1644 'headline
'identity
))))
1649 (ert-deftest test-org-element
/special-block-parser
()
1650 "Test `special-block' parser."
1654 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1655 (org-element-property :type
(org-element-at-point)))))
1656 ;; Special blocks can contain paragraphs.
1659 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1661 (org-element-type (org-element-at-point)))))
1662 ;; Ignore incomplete block.
1665 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1666 (org-element-type (org-element-at-point)))))
1667 ;; Allow special characters in type.
1669 (equal '(special-block "SPECIAL*")
1670 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1671 (let ((element (org-element-at-point)))
1672 (list (org-element-type element
)
1673 (org-element-property :type element
))))))
1674 ;; Handle non-empty blank line at the end of buffer.
1676 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1677 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1682 (ert-deftest test-org-element
/src-block-parser
()
1683 "Test `src-block' parser."
1686 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1687 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1688 ;; Ignore incomplete block.
1690 (org-test-with-temp-text "#+BEGIN_SRC"
1691 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1692 ;; Properly un-escape code.
1694 (equal "* Headline\n #+keyword\nText\n"
1695 (org-test-with-temp-text
1696 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1697 (org-element-property :value
(org-element-at-point)))))
1698 ;; Remove block indentation according to block boundaries, unless
1699 ;; block contents are less indented than block boundaries.
1702 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1703 (let ((org-src-preserve-indentation t
))
1704 (org-element-property :value
(org-element-at-point))))))
1708 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1709 (let ((org-src-preserve-indentation t
))
1710 (org-element-property :value
(org-element-at-point))))))
1711 ;; Handle non-empty blank line at the end of buffer.
1713 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
1714 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1717 ;;;; Statistics Cookie
1719 (ert-deftest test-org-element
/statistics-cookie
()
1720 "Test `statistics-cookie' parser."
1723 (org-test-with-temp-text "[1/2]"
1724 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1727 (org-test-with-temp-text "[33%]"
1729 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1734 (ert-deftest test-org-element
/strike-through-parser
()
1735 "Test `strike-through' parser."
1738 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1739 (org-test-with-temp-text "+strike-through+"
1740 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1741 ;; Multi-line markup.
1744 (org-element-contents
1745 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1746 (org-test-with-temp-text "+first line\nsecond line+"
1748 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1749 '("first line\nsecond line"))))
1754 (ert-deftest test-org-element
/subscript-parser
()
1755 "Test `subscript' parser."
1758 (org-test-with-temp-text "a_b"
1759 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1762 (org-test-with-temp-text "a_{b}"
1763 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1764 ;; Multiple subscripts in a paragraph.
1767 (org-test-with-temp-text "a_b and c_d"
1769 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1774 (ert-deftest test-org-element
/superscript-parser
()
1775 "Test `superscript' parser."
1778 (org-test-with-temp-text "a^b"
1779 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1782 (org-test-with-temp-text "a^{b}"
1783 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1784 ;; Multiple superscript in a paragraph.
1787 (org-test-with-temp-text "a^b and c^d"
1790 (org-element-parse-buffer) 'superscript
'identity
))))))
1795 (ert-deftest test-org-element
/table-parser
()
1796 "Test `table' parser."
1798 (org-test-with-temp-text "| a |"
1799 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
1800 ;; TBLFM keyword is case insensitive.
1802 (org-test-with-temp-text "| a |\n#+tblfm: test"
1803 (org-element-property
1805 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
1806 ;; Handle multiple TBLFM lines.
1809 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
1810 (length (org-element-property
1813 (org-element-parse-buffer) 'table
'identity nil t
))))))
1814 ;; Handle non-empty blank line at the end of buffer.
1816 (org-test-with-temp-text "| a |\n "
1817 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1822 (ert-deftest test-org-element
/table-cell-parser
()
1823 "Test `table-cell' parser."
1825 (org-test-with-temp-text "| a |"
1826 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
1831 (ert-deftest test-org-element
/table-row-parser
()
1832 "Test `table-row' parser."
1834 (equal '(standard rule
)
1835 (org-test-with-temp-text "| a |\n|---|"
1837 (org-element-parse-buffer) 'table-row
1838 (lambda (row) (org-element-property :type row
)))))))
1843 (ert-deftest test-org-element
/target-parser
()
1844 "Test `target' parser."
1846 (org-test-with-temp-text "<<target>>"
1847 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
1852 (ert-deftest test-org-element
/timestamp
()
1853 "Test `timestamp' parser."
1854 ;; Active timestamp.
1856 (org-test-with-temp-text "<2012-03-29 16:40>"
1857 (eq (org-element-property :type
(org-element-context)) 'active
)))
1859 (org-test-with-temp-text "<2012-03-29 Thu>"
1860 (let ((timestamp (org-element-context)))
1861 (or (org-element-property :hour-start timestamp
)
1862 (org-element-property :minute-start timestamp
)))))
1864 (equal '(2012 3 29 16 40)
1865 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
1866 (let ((object (org-element-context)))
1867 (list (org-element-property :year-start object
)
1868 (org-element-property :month-start object
)
1869 (org-element-property :day-start object
)
1870 (org-element-property :hour-start object
)
1871 (org-element-property :minute-start object
))))))
1872 ;; Inactive timestamp.
1874 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
1875 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
1878 (equal '(2012 3 29 16 40 7 30)
1879 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1880 (let ((object (org-element-context)))
1881 (list (org-element-property :year-end object
)
1882 (org-element-property :month-end object
)
1883 (org-element-property :day-end object
)
1884 (org-element-property :hour-end object
)
1885 (org-element-property :minute-end object
)
1886 (org-element-property :hour-start object
)
1887 (org-element-property :minute-start object
))))))
1890 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1891 (org-element-property :type
(org-element-context)))))
1894 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
1895 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
1897 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
1898 (let ((timestamp (org-element-context)))
1899 (or (org-element-property :hour-end timestamp
)
1900 (org-element-property :minute-end timestamp
)))))
1901 ;; With repeater, warning delay and both.
1904 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
1905 (org-element-property :repeater-type
(org-element-context)))))
1908 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
1909 (org-element-property :warning-type
(org-element-context)))))
1911 (equal '(cumulate all
)
1912 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
1913 (let ((ts (org-element-context)))
1914 (list (org-element-property :repeater-type ts
)
1915 (org-element-property :warning-type ts
))))))
1916 ;; Timestamps are not planning elements.
1918 (org-test-with-temp-text "SCHEDULED: <2012-03-29 Thu 16:40>"
1919 (org-element-map (org-element-parse-buffer) 'timestamp
'identity
))))
1924 (ert-deftest test-org-element
/underline-parser
()
1925 "Test `underline' parser."
1928 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1929 (org-test-with-temp-text "_underline_"
1930 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
1931 ;; Multi-line markup.
1934 (org-element-contents
1935 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1936 (org-test-with-temp-text "_first line\nsecond line_"
1938 (org-element-parse-buffer) 'underline
'identity nil t
))))
1939 '("first line\nsecond line"))))
1944 (ert-deftest test-org-element
/verbatim-parser
()
1945 "Test `verbatim' parser."
1948 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1949 (org-test-with-temp-text "=verbatim="
1950 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
1951 ;; Multi-line markup.
1954 (org-element-property
1956 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1957 (org-test-with-temp-text "=first line\nsecond line="
1959 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
1960 "first line\nsecond line")))
1965 (ert-deftest test-org-element
/verse-block-parser
()
1966 "Test `verse-block' parser."
1969 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
1970 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1973 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
1974 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1975 ;; Parse objects in verse blocks.
1977 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
1978 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
1979 ;; Ignore incomplete verse block.
1981 (org-test-with-temp-text "#+BEGIN_VERSE"
1982 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
1983 ;; Handle non-empty blank line at the end of buffer.
1985 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
1986 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1990 ;;; Test Interpreters.
1992 (ert-deftest test-org-element
/interpret-data
()
1993 "Test `org-element-interpret-data' specifications."
1994 ;; Interpret simple affiliated keywords.
1997 (org-element-interpret-data
1998 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
1999 "#+NAME: para\nParagraph\n"))
2000 ;; Interpret multiple affiliated keywords.
2003 (org-element-interpret-data
2004 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2005 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2006 ;; Interpret parsed affiliated keywords.
2009 (org-element-interpret-data
2010 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2011 "#+CAPTION: caption\nParagraph\n"))
2012 ;; Interpret dual affiliated keywords.
2015 (org-element-interpret-data
2016 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2017 "#+CAPTION[short]: long\nParagraph\n"))
2018 ;; Interpret multiple parsed dual keywords.
2021 (org-element-interpret-data
2022 '(org-data nil
(paragraph
2023 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2024 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2025 ;; Pseudo objects and elements are transparent.
2028 (org-element-interpret-data
2029 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")
2033 (org-element-interpret-data
2035 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2036 (paragraph nil
"B"))))))
2038 (ert-deftest test-org-element
/center-block-interpreter
()
2039 "Test center block interpreter."
2041 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2042 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2044 (ert-deftest test-org-element
/drawer-interpreter
()
2045 "Test drawer interpreter."
2047 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2048 ":TEST:\nTest\n:END:\n")))
2050 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2051 "Test dynamic block interpreter."
2053 (equal (org-test-parse-and-interpret
2054 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2055 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2057 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2058 "Test footnote definition interpreter."
2059 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2061 (ert-deftest test-org-element
/headline-interpreter
()
2062 "Test headline and section interpreters."
2063 ;; 1. Standard test.
2064 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2065 ;; 2. With TODO keywords.
2067 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2068 (org-test-parse-and-interpret "* TODO Headline"))
2069 "* TODO Headline\n"))
2072 ;; 3.1. ... and a positive `org-tags-column' value.
2074 (equal (let ((org-tags-column 20))
2075 (org-test-parse-and-interpret "* Headline :tag:"))
2076 "* Headline :tag:\n"))
2077 ;; 3.2. ... and a negative `org-tags-column' value.
2079 (equal (let ((org-tags-column -
20))
2080 (org-test-parse-and-interpret "* Headline :tag:"))
2081 "* Headline :tag:\n"))
2082 ;; 3.3. ... and a null `org-tags-column' value.
2084 (equal (let ((org-tags-column 0))
2085 (org-test-parse-and-interpret "* Headline :tag:"))
2086 "* Headline :tag:\n"))
2087 ;; 4. With priority cookie.
2089 (equal (org-test-parse-and-interpret "* [#B] Headline")
2090 "* [#B] Headline\n"))
2091 ;; 5. With comment keyword.
2093 (equal (let ((org-comment-string "COMMENT"))
2094 (org-test-parse-and-interpret "* COMMENT Headline"))
2095 "* COMMENT Headline\n"))
2096 ;; 6. With quote section.
2098 (equal (let ((org-quote-string "QUOTE"))
2099 (org-test-parse-and-interpret "* QUOTE Headline"))
2100 "* QUOTE Headline\n"))
2101 ;; 7. Keep same number of blank lines before body.
2103 (equal (org-test-parse-and-interpret
2104 "* Headline\n\n\nText after two blank lines.")
2105 "* Headline\n\n\nText after two blank lines.\n")))
2107 (ert-deftest test-org-element
/inlinetask-interpreter
()
2108 "Test inlinetask interpretation."
2109 (when (featurep 'org-inlinetask
)
2110 (let ((org-inlinetask-min-level 15))
2111 ;; 1. Regular inlinetask.
2112 (should (equal (org-test-parse-and-interpret
2113 "*************** Task\nTest\n*************** END")
2114 "*************** Task\nTest\n*************** END\n"))
2115 ;; 2. Degenerate inlinetask.
2116 (should (equal (org-test-parse-and-interpret "*************** Task")
2117 "*************** Task\n"))
2118 ;; 3. Prefer degenerate form when there are no contents.
2119 (should (equal (org-test-parse-and-interpret
2120 "*************** Task\n*************** END")
2121 "*************** Task\n"))
2122 ;; 4. With TODO keywords.
2124 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2125 (org-test-parse-and-interpret "*************** TODO Task"))
2126 "*************** TODO Task\n"))
2129 ;; 5.1. ... and a positive `org-tags-column' value.
2131 (equal (let ((org-tags-column 30))
2132 (org-test-parse-and-interpret "*************** Task :tag:"))
2133 "*************** Task :tag:\n"))
2134 ;; 5.2. ... and a negative `org-tags-column' value.
2136 (equal (let ((org-tags-column -
30))
2137 (org-test-parse-and-interpret "*************** Task :tag:"))
2138 "*************** Task :tag:\n"))
2139 ;; 5.3. ... and a null `org-tags-column' value.
2141 (equal (let ((org-tags-column 0))
2142 (org-test-parse-and-interpret "*************** Task :tag:"))
2143 "*************** Task :tag:\n"))
2144 ;; 6. With priority cookie.
2146 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2147 "*************** [#B] Task\n")))))
2149 (ert-deftest test-org-element
/plain-list-interpreter
()
2150 "Test plain-list and item interpreters."
2151 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2153 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2154 ;; Description list.
2156 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2159 (equal (let ((org-plain-list-ordered-item-terminator t
))
2160 (org-test-parse-and-interpret "1. Item"))
2163 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2164 (org-test-parse-and-interpret "1) Item"))
2166 ;; Ordered list with counter.
2168 (equal (let ((org-plain-list-ordered-item-terminator t
))
2169 (org-test-parse-and-interpret "1. [@5] Item"))
2171 ;; List with check-boxes.
2173 (equal (org-test-parse-and-interpret
2174 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2175 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2176 ;; Item not starting with a paragraph.
2178 (equal (org-test-parse-and-interpret "-\n | a | b |")
2179 "- \n | a | b |\n"))
2180 ;; Special case: correctly handle "*" bullets.
2181 (should (org-test-parse-and-interpret " * item"))
2182 ;; Special case: correctly handle empty items.
2183 (should (org-test-parse-and-interpret "-"))))
2185 (ert-deftest test-org-element
/quote-block-interpreter
()
2186 "Test quote block interpreter."
2187 (should (equal (org-test-parse-and-interpret
2188 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2189 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2191 (ert-deftest test-org-element
/special-block-interpreter
()
2192 "Test special block interpreter."
2193 (should (equal (org-test-parse-and-interpret
2194 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2195 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2197 (ert-deftest test-org-element
/babel-call-interpreter
()
2198 "Test babel call interpreter."
2199 ;; 1. Without argument.
2200 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2201 "#+CALL: test()\n"))
2202 ;; 2. With argument.
2203 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2204 "#+CALL: test(x=2)\n"))
2205 ;; 3. With header arguments.
2206 (should (equal (org-test-parse-and-interpret
2207 "#+CALL: test[:results output]()[:results html]")
2208 "#+CALL: test[:results output]()[:results html]\n")))
2210 (ert-deftest test-org-element
/clock-interpreter
()
2211 "Test clock interpreter."
2215 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2216 (let ((org-clock-string "CLOCK:"))
2217 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]"))))
2221 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2222 (let ((org-clock-string "CLOCK:"))
2223 (org-test-parse-and-interpret "
2224 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01")))))
2226 (ert-deftest test-org-element
/comment-interpreter
()
2227 "Test comment interpreter."
2229 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2231 (should (equal (org-test-parse-and-interpret " # Comment")
2233 ;; Preserve indentation.
2234 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2235 "# No blank\n# One blank\n")))
2237 (ert-deftest test-org-element
/comment-block-interpreter
()
2238 "Test comment block interpreter."
2239 (should (equal (org-test-parse-and-interpret
2240 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2241 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
2243 (ert-deftest test-org-element
/diary-sexp
()
2244 "Test diary-sexp interpreter."
2247 (org-test-parse-and-interpret
2248 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2249 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2251 (ert-deftest test-org-element
/example-block-interpreter
()
2252 "Test example block interpreter."
2253 ;; Without switches.
2254 (should (equal (org-test-parse-and-interpret
2255 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2256 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2259 (equal (org-test-parse-and-interpret
2260 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2261 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2262 ;; Preserve code escaping.
2264 (equal (org-test-parse-and-interpret
2265 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2266 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n")))
2268 (ert-deftest test-org-element
/export-block-interpreter
()
2269 "Test export block interpreter."
2270 (should (equal (org-test-parse-and-interpret
2271 "#+BEGIN_HTML\nTest\n#+END_HTML")
2272 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2274 (ert-deftest test-org-element
/fixed-width-interpreter
()
2275 "Test fixed width interpreter."
2277 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2278 ;; Preserve indentation.
2279 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2280 ": 2 blanks\n: 1 blank\n"))
2281 ;; Remove last newline character
2283 (equal (org-element-fixed-width-interpreter
2284 '(fixed-width (:value
"Test\n")) nil
)
2287 (equal (org-element-fixed-width-interpreter
2288 '(fixed-width (:value
"Test")) nil
)
2290 ;; Handle empty string.
2292 (equal (org-element-fixed-width-interpreter
2293 '(fixed-width (:value
"")) nil
)
2295 ;; Handle nil value.
2297 (org-element-fixed-width-interpreter
2298 '(fixed-width (:value nil
)) nil
)))
2300 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2301 "Test horizontal rule interpreter."
2302 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2304 (ert-deftest test-org-element
/keyword-interpreter
()
2305 "Test keyword interpreter."
2306 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2307 "#+KEYWORD: value\n")))
2309 (ert-deftest test-org-element
/latex-environment-interpreter
()
2310 "Test latex environment interpreter."
2311 (should (equal (org-test-parse-and-interpret
2312 "\\begin{equation}\n1+1=2\n\\end{equation}")
2313 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2314 (should (equal (org-test-parse-and-interpret
2315 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2316 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2318 (ert-deftest test-org-element
/planning-interpreter
()
2319 "Test planning interpreter."
2320 (let ((org-closed-string "CLOSED:")
2321 (org-deadline-string "DEADLINE:")
2322 (org-scheduled-string "SCHEDULED:"))
2326 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2327 (org-test-parse-and-interpret
2329 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]")))))
2331 (ert-deftest test-org-element
/property-drawer-interpreter
()
2332 "Test property drawer interpreter."
2333 (should (equal (let ((org-property-format "%-10s %s"))
2334 (org-test-parse-and-interpret
2335 ":PROPERTIES:\n:prop: value\n:END:"))
2336 ":PROPERTIES:\n:prop: value\n:END:\n")))
2338 (ert-deftest test-org-element
/src-block-interpreter
()
2339 "Test src block interpreter."
2342 (equal (let ((org-edit-src-content-indentation 2))
2343 (org-test-parse-and-interpret
2344 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2345 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2348 (equal (let ((org-edit-src-content-indentation 2))
2349 (org-test-parse-and-interpret
2350 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2351 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2352 ;; Preserve code escaping.
2354 (equal (let ((org-edit-src-content-indentation 2))
2355 (org-test-parse-and-interpret
2356 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2357 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2358 ;; Do not apply `org-edit-src-content-indentation' when preserving
2361 (equal (let ((org-edit-src-content-indentation 2)
2362 (org-src-preserve-indentation t
))
2363 (org-test-parse-and-interpret
2364 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2365 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2367 (equal (let ((org-edit-src-content-indentation 2)
2368 (org-src-preserve-indentation nil
))
2369 (org-test-parse-and-interpret
2370 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2371 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n")))
2373 (ert-deftest test-org-element
/table-interpreter
()
2374 "Test table, table-row and table-cell interpreters."
2376 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2377 "| a | b |\n| c | d |\n"))
2378 ;; 2. With horizontal rules.
2379 (should (equal (org-test-parse-and-interpret
2380 "| a | b |\n|---+---|\n| c | d |")
2381 "| a | b |\n|---+---|\n| c | d |\n"))
2382 ;; 3. With meta-data.
2383 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2384 "| / | < | > |\n| * | 1 | 2 |\n"))
2385 ;; 4. With a formula.
2387 (equal (org-test-parse-and-interpret
2388 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2389 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2390 ;; 5. With multiple formulas.
2392 (equal (org-test-parse-and-interpret
2393 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2394 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2396 (ert-deftest test-org-element
/timestamp-interpreter
()
2397 "Test timestamp interpreter."
2400 (string-match "<2012-03-29 .* 16:40>"
2401 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2403 (string-match "<2012-03-29 .* 16:40>"
2404 (org-element-timestamp-interpreter
2406 (:type active
:year-start
2012 :month-start
3 :day-start
29
2407 :hour-start
16 :minute-start
40)) nil
)))
2410 (string-match "\\[2012-03-29 .* 16:40\\]"
2411 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2414 "\\[2012-03-29 .* 16:40\\]"
2415 (org-element-timestamp-interpreter
2417 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2418 :hour-start
16 :minute-start
40)) nil
)))
2421 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2422 (org-test-parse-and-interpret
2423 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2426 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2427 (org-element-timestamp-interpreter
2429 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2430 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2431 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2434 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2435 (org-test-parse-and-interpret
2436 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2439 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2440 (org-element-timestamp-interpreter
2442 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2443 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2444 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2446 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2447 "<%%diary-float t 4 2>\n"))
2448 ;; Timestamp with repeater interval, with delay, with both.
2450 (string-match "<2012-03-29 .* \\+1y>"
2451 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2454 "<2012-03-29 .* \\+1y>"
2455 (org-element-timestamp-interpreter
2457 (:type active
:year-start
2012 :month-start
3 :day-start
29
2458 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2462 "<2012-03-29 .* -1y>"
2463 (org-element-timestamp-interpreter
2465 (:type active
:year-start
2012 :month-start
3 :day-start
29
2466 :warning-type all
:warning-value
1 :warning-unit year
))
2470 "<2012-03-29 .* \\+1y -1y>"
2471 (org-element-timestamp-interpreter
2473 (:type active
:year-start
2012 :month-start
3 :day-start
29
2474 :warning-type all
:warning-value
1 :warning-unit year
2475 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2477 ;; Timestamp range with repeater interval
2479 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2480 (org-test-parse-and-interpret
2481 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2484 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2485 (org-element-timestamp-interpreter
2487 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2488 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2489 :repeater-value
1 :repeater-unit year
))
2492 (ert-deftest test-org-element
/verse-block-interpreter
()
2493 "Test verse block interpretation."
2495 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2496 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2498 (ert-deftest test-org-element
/bold-interpreter
()
2499 "Test bold interpreter."
2500 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2502 (ert-deftest test-org-element
/code-interpreter
()
2503 "Test code interpreter."
2504 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2506 (ert-deftest test-org-element
/entity-interpreter
()
2507 "Test entity interpreter."
2508 ;; 1. Without brackets.
2510 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2511 ;; 2. With brackets.
2513 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2515 (ert-deftest test-org-element
/export-snippet-interpreter
()
2516 "Test export snippet interpreter."
2517 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2518 "@@back-end:contents@@\n")))
2520 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2521 "Test footnote reference interpreter."
2522 ;; 1. Regular reference.
2523 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2524 ;; 2. Normalized reference.
2525 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2526 ;; 3. Named reference.
2527 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2528 "Text[fn:label]\n"))
2529 ;; 4. Inline reference.
2530 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2531 "Text[fn:label:def]\n"))
2532 ;; 5. Anonymous reference.
2533 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2534 "Text[fn::def]\n")))
2536 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2537 "Test inline babel call interpreter."
2538 ;; 1. Without arguments.
2539 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2540 ;; 2. With arguments.
2541 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2542 "call_test(x=2)\n"))
2543 ;; 3. With header arguments.
2544 (should (equal (org-test-parse-and-interpret
2545 "call_test[:results output]()[:results html]")
2546 "call_test[:results output]()[:results html]\n")))
2548 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2549 "Test inline src block interpreter."
2550 ;; 1. Without header argument.
2551 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2552 "src_emacs-lisp{(+ 1 1)}\n"))
2553 ;; 2. With header arguments.
2554 (should (equal (org-test-parse-and-interpret
2555 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2556 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2558 (ert-deftest test-org-element
/italic-interpreter
()
2559 "Test italic interpreter."
2560 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2562 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2563 "Test latex fragment interpreter."
2564 (let ((org-latex-regexps
2565 '(("begin" "^[ ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^