1 ;;; test-org-element.el --- Tests for org-element.el
3 ;; Copyright (C) 2012, 2013, 2014 Nicolas Goaziou
5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
7 ;; This program is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation, either version 3 of the License, or
10 ;; (at your option) any later version.
12 ;; This program is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
22 (unless (featurep 'org-element
)
23 (signal 'missing-test-dependency
"org-element"))
25 (defun org-test-parse-and-interpret (text)
26 "Parse TEXT as Org syntax and interpret it.
27 Return interpreted string."
31 (org-element-interpret-data (org-element-parse-buffer))))
35 ;;; Test `org-element-map'
37 (ert-deftest test-org-element
/map
()
38 "Test `org-element-map'."
39 ;; Can map to `plain-text' objects.
42 (org-test-with-temp-text "Some text \alpha
48 (org-element-parse-buffer) 'plain-text
49 (lambda (s) (when (string-match "text" s
) (incf count
))))
51 ;; Applies to secondary strings
53 (org-element-map '("some " (bold nil
"bold") "text") 'bold
'identity
))
54 ;; Enter secondary strings before entering contents.
60 (org-test-with-temp-text "* Some \\alpha headline\n\\beta entity."
61 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
)))))
62 ;; Apply NO-RECURSION argument.
64 (org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
66 (org-element-parse-buffer) 'entity
'identity nil nil
'center-block
)))
67 ;; Use WITH-AFFILIATED argument.
71 (org-test-with-temp-text "#+CAPTION[a]: 1\n#+CAPTION[b]: 2\nParagraph"
73 (org-element-at-point) 'plain-text
'identity nil nil nil t
)))))
79 (ert-deftest test-org-element
/put-property
()
80 "Test `org-element-put-property' specifications."
82 (org-test-with-temp-text "* Headline\n *a*"
83 (let ((tree (org-element-parse-buffer)))
84 (org-element-put-property
85 (org-element-map tree
'bold
'identity nil t
) :test
1)
86 (should (org-element-property
87 :test
(org-element-map tree
'bold
'identity nil t
)))))
88 ;; Put property on a string.
90 (org-element-property :test
(org-element-put-property "Paragraph" :test t
))))
92 (ert-deftest test-org-element
/set-contents
()
93 "Test `org-element-set-contents' specifications."
94 ;; Accept multiple entries.
96 (equal '("b" (italic nil
"a"))
97 (org-test-with-temp-text "* Headline\n *a*"
98 (let ((tree (org-element-parse-buffer)))
99 (org-element-set-contents
100 (org-element-map tree
'bold
'identity nil t
) "b" '(italic nil
"a"))
101 (org-element-contents
102 (org-element-map tree
'bold
'identity nil t
))))))
103 ;; Accept atoms and elements.
106 (org-test-with-temp-text "* Headline\n *a*"
107 (let ((tree (org-element-parse-buffer)))
108 (org-element-set-contents
109 (org-element-map tree
'bold
'identity nil t
) "b")
110 (org-element-contents
111 (org-element-map tree
'bold
'identity nil t
))))))
113 (equal '((italic nil
"b"))
114 (org-test-with-temp-text "* Headline\n *a*"
115 (let ((tree (org-element-parse-buffer)))
116 (org-element-set-contents
117 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"b"))
118 (org-element-contents
119 (org-element-map tree
'bold
'identity nil t
))))))
120 ;; Allow nil contents.
122 (org-test-with-temp-text "* Headline\n *a*"
123 (let ((tree (org-element-parse-buffer)))
124 (org-element-set-contents (org-element-map tree
'bold
'identity nil t
))
125 (org-element-contents (org-element-map tree
'bold
'identity nil t
))))))
127 (ert-deftest test-org-element
/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 ;; Test folded block.
281 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
284 (org-element-property
286 (org-element-map (org-element-parse-buffer) 'center-block
288 ;; Ignore incomplete block.
290 (org-test-with-temp-text "#+BEGIN_CENTER"
291 (org-element-map (org-element-parse-buffer) 'center-block
293 ;; Handle non-empty blank line at the end of buffer.
295 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
296 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
301 (ert-deftest test-org-element
/clock-parser
()
302 "Test `clock' parser."
304 (let* ((org-clock-string "CLOCK:")
305 (clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
306 (org-element-at-point))))
307 (should (eq (org-element-property :status clock
) 'running
))
309 (equal (org-element-property :raw-value
310 (org-element-property :value clock
))
311 "[2012-01-01 sun. 00:01]"))
312 (should-not (org-element-property :duration clock
)))
314 (let* ((org-clock-string "CLOCK:")
316 (org-test-with-temp-text
317 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
318 (org-element-at-point))))
319 (should (eq (org-element-property :status clock
) 'closed
))
320 (should (equal (org-element-property :raw-value
321 (org-element-property :value clock
))
322 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
323 (should (equal (org-element-property :duration clock
) "0:01"))))
328 (ert-deftest test-org-element
/code-parser
()
329 "Test `code' parser."
332 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
333 (org-test-with-temp-text "~code~"
334 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
335 ;; Multi-line markup.
338 (org-element-property
340 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
341 (org-test-with-temp-text "~first line\nsecond line~"
343 (org-element-parse-buffer) 'code
'identity nil t
))))
344 "first line\nsecond line")))
349 (ert-deftest test-org-element
/comment-parser
()
350 "Test `comment' parser."
353 (org-test-with-temp-text "# Comment"
354 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
357 (org-test-with-temp-text " # Comment"
358 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
359 ;; Preserve indentation.
362 (org-element-property
364 (org-test-with-temp-text "# No blank\n# One blank"
365 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
366 "No blank\n One blank"))
367 ;; Comment with blank lines.
370 (org-element-property
372 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
373 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
374 "First part\n\n\nSecond part"))
375 ;; Do not mix comments and keywords.
378 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
379 (length (org-element-map (org-element-parse-buffer) 'comment
383 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
384 (org-element-property
386 (org-element-map (org-element-parse-buffer) 'comment
388 ;; Correctly handle non-empty blank lines at the end of buffer.
390 (org-test-with-temp-text "# A\n "
391 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
396 (ert-deftest test-org-element
/comment-block-parser
()
397 "Test `comment-block' parser."
400 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
401 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
404 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
405 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
406 ;; Test folded block.
407 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
410 (org-element-property
412 (org-element-map (org-element-parse-buffer) 'comment-block
414 ;; Ignore incomplete block.
416 (org-test-with-temp-text "#+BEGIN_COMMENT"
417 (org-element-map (org-element-parse-buffer) 'comment-block
419 ;; Handle non-empty blank line at the end of buffer.
421 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
422 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
427 (ert-deftest test-org-element
/diary-sexp-parser
()
428 "Test `diary-sexp' parser."
432 (org-test-with-temp-text
433 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
434 (org-element-type (org-element-at-point)))))
435 ;; Diary sexp must live at beginning of line
438 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
439 (org-element-type (org-element-at-point)))))
440 ;; Handle non-empty blank line at the end of buffer.
442 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
443 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
448 (ert-deftest test-org-element
/drawer-parser
()
449 "Test `drawer' parser."
452 (let ((org-drawers '("TEST")))
453 (org-test-with-temp-text ":TEST:\nText\n:END:"
454 (org-element-map (org-element-parse-buffer) 'drawer
'identity
))))
455 ;; Do not mix regular drawers and property drawers.
457 (let ((org-drawers '("PROPERTIES")))
458 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
459 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
))))
460 ;; Ignore incomplete drawer.
462 (let ((org-drawers '("TEST")))
463 (org-test-with-temp-text ":TEST:"
464 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
))))
465 ;; Handle non-empty blank line at the end of buffer.
467 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
468 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
473 (ert-deftest test-org-element
/dynamic-block-parser
()
474 "Test `dynamic-block' parser."
477 (org-test-with-temp-text
478 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
479 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
481 (org-test-with-temp-text
482 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
485 (org-element-property
487 (org-element-map (org-element-parse-buffer) 'dynamic-block
491 (org-test-with-temp-text
492 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
493 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
494 ;; Ignore incomplete block.
496 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
497 (org-element-map (org-element-parse-buffer) 'dynamic-block
499 ;; Handle non-empty blank line at the end of buffer.
501 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
502 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
507 (ert-deftest test-org-element
/entity-parser
()
508 "Test `entity' parser."
511 (org-test-with-temp-text "\\sin"
512 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
515 (org-element-property
517 (org-test-with-temp-text "\\alpha{}text"
518 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
519 ;; User-defined entity.
522 (org-element-property
524 (let ((org-entities-user
525 '(("test" "test" nil
"test" "test" "test" "test"))))
526 (org-test-with-temp-text "\\test"
527 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
529 ;; Special case: entity at the end of a container.
532 (org-test-with-temp-text "*\\alpha \\beta*"
533 (search-forward "be")
534 (org-element-type (org-element-context))))))
539 (ert-deftest test-org-element
/example-block-parser
()
540 "Test `example-block' parser."
543 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
544 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
545 ;; Test folded block.
547 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
549 (org-element-property :hiddenp
(org-element-at-point))))
550 ;; Ignore incomplete block.
553 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
554 (org-element-type (org-element-at-point)))))
555 ;; Properly un-escape code.
557 (equal "* Headline\n #+keyword\nText\n"
558 (org-test-with-temp-text
559 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
560 (org-element-property :value
(org-element-at-point)))))
561 ;; Nil `org-src-preserve-indentation': Remove maximum common
565 (org-test-with-temp-text "#+BEGIN_EXAMPLE\n L1\n L2\n#+END_EXAMPLE"
566 (let ((org-src-preserve-indentation nil
))
567 (org-element-property :value
(org-element-at-point))))))
568 ;; Non-nil `org-src-preserve-indentation': Remove block indentation
569 ;; only, unless block contents are less indented than block
573 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
574 (let ((org-src-preserve-indentation t
))
575 (org-element-property :value
(org-element-at-point))))))
579 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
580 (let ((org-src-preserve-indentation t
))
581 (org-element-property :value
(org-element-at-point))))))
582 ;; Handle non-empty blank line at the end of buffer.
584 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
585 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
587 (ert-deftest test-org-element
/block-switches
()
588 "Test `example-block' and `src-block' switches parsing."
589 (let ((org-coderef-label-format "(ref:%s)"))
590 ;; 1. Test "-i" switch.
592 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
593 (org-element-property :preserve-indent
(org-element-at-point))))
595 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
596 (org-element-property :preserve-indent
(org-element-at-point))))
598 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
599 (org-element-property :preserve-indent
(org-element-at-point))))
601 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
602 (org-element-property :preserve-indent
(org-element-at-point))))
603 ;; 2. "-n -r -k" combination should number lines, retain labels but
604 ;; not use them in coderefs.
606 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\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 (not (org-element-property :use-labels element
))))))
612 (org-test-with-temp-text
613 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
614 (let ((element (org-element-at-point)))
615 (and (org-element-property :number-lines element
)
616 (org-element-property :retain-labels element
)
617 (not (org-element-property :use-labels element
))))))
618 ;; 3. "-n -r" combination should number-lines remove labels and not
619 ;; use them in coderefs.
621 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
622 (let ((element (org-element-at-point)))
623 (and (org-element-property :number-lines element
)
624 (not (org-element-property :retain-labels element
))
625 (not (org-element-property :use-labels element
))))))
627 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
628 (let ((element (org-element-at-point)))
629 (and (org-element-property :number-lines element
)
630 (not (org-element-property :retain-labels element
))
631 (not (org-element-property :use-labels element
))))))
632 ;; 4. "-n" or "+n" should number lines, retain labels and use them
635 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
636 (let ((element (org-element-at-point)))
637 (and (org-element-property :number-lines element
)
638 (org-element-property :retain-labels element
)
639 (org-element-property :use-labels element
)))))
641 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
642 (let ((element (org-element-at-point)))
643 (and (org-element-property :number-lines element
)
644 (org-element-property :retain-labels element
)
645 (org-element-property :use-labels element
)))))
647 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
648 (let ((element (org-element-at-point)))
649 (and (org-element-property :number-lines element
)
650 (org-element-property :retain-labels element
)
651 (org-element-property :use-labels element
)))))
653 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
654 (let ((element (org-element-at-point)))
655 (and (org-element-property :number-lines element
)
656 (org-element-property :retain-labels element
)
657 (org-element-property :use-labels element
)))))
658 ;; 5. No switch should not number lines, but retain labels and use
661 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
662 (let ((element (org-element-at-point)))
663 (and (not (org-element-property :number-lines element
))
664 (org-element-property :retain-labels element
)
665 (org-element-property :use-labels element
)))))
667 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
668 (let ((element (org-element-at-point)))
669 (and (not (org-element-property :number-lines element
))
670 (org-element-property :retain-labels element
)
671 (org-element-property :use-labels element
)))))
672 ;; 6. "-r" switch only: do not number lines, remove labels, and
673 ;; don't use labels in coderefs.
675 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
676 (let ((element (org-element-at-point)))
677 (and (not (org-element-property :number-lines element
))
678 (not (org-element-property :retain-labels element
))
679 (not (org-element-property :use-labels element
))))))
681 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
682 (let ((element (org-element-at-point)))
683 (and (not (org-element-property :number-lines element
))
684 (not (org-element-property :retain-labels element
))
685 (not (org-element-property :use-labels element
))))))
686 ;; 7. Recognize coderefs with user-defined syntax.
690 (org-test-with-temp-text
691 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
692 (org-element-property :label-fmt
(org-element-at-point)))))
696 (org-test-with-temp-text
697 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
698 (org-element-property :label-fmt
(org-element-at-point)))))))
703 (ert-deftest test-org-element
/export-block-parser
()
704 "Test `export-block' parser."
707 (let ((org-element-block-name-alist
708 '(("LATEX" . org-element-export-block-parser
))))
709 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
710 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
711 ;; Test folded block.
712 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
715 (org-element-property
718 (let ((org-element-block-name-alist
719 '(("LATEX" . org-element-export-block-parser
))))
720 (org-element-parse-buffer))
721 'export-block
'identity nil t
))))
724 (let ((org-element-block-name-alist
725 '(("LATEX" . org-element-export-block-parser
))))
726 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
727 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
728 ;; Ignore incomplete block.
730 (let ((org-element-block-name-alist
731 '(("LATEX" . org-element-export-block-parser
))))
732 (org-test-with-temp-text "#+BEGIN_LATEX"
733 (org-element-map (org-element-parse-buffer) 'export-block
735 ;; Handle non-empty blank line at the end of buffer.
737 (let ((org-element-block-name-alist
738 '(("LATEX" . org-element-export-block-parser
))))
739 (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
740 (= (org-element-property :end
(org-element-at-point)) (point-max))))))
745 (ert-deftest test-org-element
/export-snippet-parser
()
746 "Test `export-snippet' parser."
749 '("back-end" .
"contents")
750 (org-test-with-temp-text "@@back-end:contents@@"
752 (org-element-parse-buffer) 'export-snippet
753 (lambda (snippet) (cons (org-element-property :back-end snippet
)
754 (org-element-property :value snippet
)))
760 (ert-deftest test-org-element
/fixed-width-parser
()
761 "Test fixed-width area parsing."
762 ;; Preserve indentation.
764 (org-test-with-temp-text ": no blank\n: one blank"
765 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
766 ;; Fixed-width with empty lines.
768 (org-test-with-temp-text ": first part\n:\n: \n: second part"
769 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
770 ;; Parse indented fixed-width markers.
772 (org-test-with-temp-text "Text\n : no blank\n : one blank"
773 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
774 ;; Distinguish fixed-width areas within a list and outside of it.
778 (org-test-with-temp-text "
781 : fixed-width outside"
782 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
783 ;; Handle non-empty blank line at the end of buffer.
785 (org-test-with-temp-text ": A\n "
786 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
789 ;;;; Footnote Definition
791 (ert-deftest test-org-element
/footnote-definition-parser
()
792 "Test `footnote-definition' parser."
794 (org-test-with-temp-text "[fn:1] Definition"
795 (org-element-map (org-element-parse-buffer) 'footnote-definition
797 ;; Footnote with more contents
800 (org-element-property
802 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
803 (org-element-map (org-element-parse-buffer) 'footnote-definition
805 ;; Footnote starting with special syntax.
807 (org-test-with-temp-text "[fn:1] - no item"
808 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
809 ;; Correctly handle footnote starting with an empty line.
812 (org-test-with-temp-text "[fn:1]\n\n Body"
813 (org-element-property :contents-begin
(org-element-at-point)))))
814 ;; Handle non-empty blank line at the end of buffer.
816 (org-test-with-temp-text "[fn:1] Definition\n "
817 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
820 ;;;; Footnotes Reference.
822 (ert-deftest test-org-element
/footnote-reference-parser
()
823 "Test `footnote-reference' parser."
824 ;; 1. Parse a standard reference.
825 (org-test-with-temp-text "Text[fn:label]"
828 (org-element-parse-buffer) 'footnote-reference
'identity
)))
829 ;; 2. Parse a normalized reference.
830 (org-test-with-temp-text "Text[1]"
833 (org-element-parse-buffer) 'footnote-reference
'identity
)))
834 ;; 3. Parse an inline reference.
835 (org-test-with-temp-text "Text[fn:test:def]"
838 (org-element-parse-buffer) 'footnote-reference
'identity
)))
839 ;; 4. Parse an anonymous reference.
840 (org-test-with-temp-text "Text[fn::def]"
843 (org-element-parse-buffer) 'footnote-reference
'identity
)))
844 ;; 5. Parse nested footnotes.
845 (org-test-with-temp-text "Text[fn::def [fn:label]]"
850 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
851 ;; 6. Parse adjacent footnotes.
852 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
857 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
858 ;; 7. Only properly closed footnotes are recognized as such.
859 (org-test-with-temp-text "Text[fn:label"
862 (org-element-parse-buffer) 'footnote-reference
'identity
))))
867 (ert-deftest test-org-element
/headline-quote-keyword
()
868 "Test QUOTE keyword recognition."
870 (org-test-with-temp-text "* Headline"
871 (let ((org-quote-string "QUOTE"))
872 (should-not (org-element-property :quotedp
(org-element-at-point)))))
873 ;; Standard position.
874 (org-test-with-temp-text "* QUOTE Headline"
875 (let* ((org-quote-string "QUOTE")
876 (headline (org-element-at-point)))
877 (should (org-element-property :quotedp headline
))
878 ;; Test removal from raw value.
879 (should (equal (org-element-property :raw-value headline
) "Headline"))))
881 (org-test-with-temp-text "* QUOTE Headline"
882 (let* ((org-quote-string "Quote")
883 (headline (org-element-at-point)))
884 (should-not (org-element-property :quotedp headline
))
885 (should (equal (org-element-property :raw-value headline
)
887 ;; With another keyword.
888 (org-test-with-temp-text "* TODO QUOTE Headline"
889 (let* ((org-quote-string "QUOTE")
890 (org-todo-keywords '((sequence "TODO" "DONE")))
891 (headline (org-element-at-point)))
892 (should (org-element-property :quotedp headline
))
893 (should (equal (org-element-property :raw-value headline
) "Headline"))))
894 ;; With the keyword only.
895 (org-test-with-temp-text "* QUOTE"
896 (let* ((org-quote-string "QUOTE")
897 (headline (org-element-at-point)))
898 (should (org-element-property :quotedp headline
))
899 (should (equal (org-element-property :raw-value headline
) "")))))
901 (ert-deftest test-org-element
/headline-comment-keyword
()
902 "Test COMMENT keyword recognition."
904 (org-test-with-temp-text "* Headline"
905 (let ((org-comment-string "COMMENT"))
906 (should-not (org-element-property :commentedp
(org-element-at-point)))))
907 ;; Standard position.
908 (org-test-with-temp-text "* COMMENT Headline"
909 (let ((org-comment-string "COMMENT")
910 (headline (org-element-at-point)))
911 (should (org-element-property :commentedp headline
))
912 (should (equal (org-element-property :raw-value headline
) "Headline"))))
914 (org-test-with-temp-text "* COMMENT Headline"
915 (let* ((org-comment-string "Comment")
916 (headline (org-element-at-point)))
917 (should-not (org-element-property :commentedp headline
))
918 (should (equal (org-element-property :raw-value headline
)
919 "COMMENT Headline"))))
920 ;; With another keyword.
921 (org-test-with-temp-text "* TODO COMMENT Headline"
922 (let* ((org-comment-string "COMMENT")
923 (org-todo-keywords '((sequence "TODO" "DONE")))
924 (headline (org-element-at-point)))
925 (should (org-element-property :commentedp headline
))
926 (should (equal (org-element-property :raw-value headline
) "Headline"))))
927 ;; With the keyword only.
928 (org-test-with-temp-text "* COMMENT"
929 (let* ((org-comment-string "COMMENT")
930 (headline (org-element-at-point)))
931 (should (org-element-property :commentedp headline
))
932 (should (equal (org-element-property :raw-value headline
) "")))))
934 (ert-deftest test-org-element
/headline-archive-tag
()
935 "Test ARCHIVE tag recognition."
937 (org-test-with-temp-text "* Headline"
938 (let ((org-archive-tag "ARCHIVE"))
939 (should-not (org-element-property :archivedp
(org-element-at-point)))))
941 (org-test-with-temp-text "* Headline :ARCHIVE:"
942 (let ((org-archive-tag "ARCHIVE"))
943 (let ((headline (org-element-at-point)))
944 (should (org-element-property :archivedp headline
))
946 (should-not (org-element-property :tags headline
))))
947 (let ((org-archive-tag "Archive"))
948 (should-not (org-element-property :archivedp
(org-element-at-point)))))
950 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
951 (let ((org-archive-tag "ARCHIVE"))
952 (let ((headline (org-element-at-point)))
953 (should (org-element-property :archivedp headline
))
955 (should (equal (org-element-property :tags headline
) '("test")))))))
957 (ert-deftest test-org-element
/headline-properties
()
958 "Test properties from property drawer."
959 ;; All properties from property drawer have their symbol upper
962 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
963 (org-element-property :FOO
(org-element-at-point))))
965 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
966 (org-element-property :foo
(org-element-at-point)))))
971 (ert-deftest test-org-element
/horizontal-rule-parser
()
972 "Test `horizontal-rule' parser."
975 (org-test-with-temp-text "-----"
976 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
979 (org-test-with-temp-text " -----"
980 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
981 ;; Hyphen must be alone on the line.
983 (org-test-with-temp-text "-----wrong"
984 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
985 ;; 4 hyphens is too small.
987 (org-test-with-temp-text "----"
988 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
989 ;; Handle non-empty blank line at the end of buffer.
991 (org-test-with-temp-text "-----\n "
992 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
995 ;;;; Inline Babel Call
997 (ert-deftest test-org-element
/inline-babel-call-parser
()
998 "Test `inline-babel-call' parser."
1000 (org-test-with-temp-text "call_test()"
1002 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
1005 ;;;; Inline Src Block
1007 (ert-deftest test-org-element
/inline-src-block-parser
()
1008 "Test `inline-src-block' parser."
1010 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1011 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1012 ;; Test parsing at the beginning of an item.
1014 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1015 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
1020 (ert-deftest test-org-element
/inlinetask-parser
()
1021 "Test `inlinetask' parser."
1022 (when (featurep 'org-inlinetask
)
1023 (let ((org-inlinetask-min-level 15))
1024 ;; Regular inlinetask.
1027 (org-test-with-temp-text
1028 "*************** Task\nTest\n*************** END"
1029 (org-element-type (org-element-at-point)))))
1030 ;; Degenerate inlinetask.
1033 (org-test-with-temp-text "*************** Task"
1034 (org-element-type (org-element-at-point)))))
1035 ;; Mixed inlinetasks.
1037 (org-test-with-temp-text
1039 *************** Task
1040 *************** Task2
1042 *************** END"
1044 (goto-char (org-element-property :end
(org-element-at-point)))
1050 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1051 (org-test-with-temp-text "*************** TODO Task"
1052 (org-element-property :todo-keyword
(org-element-at-point))))))
1055 (org-test-with-temp-text "
1056 *************** Task
1057 DEADLINE: <2012-03-29 thu.>"
1059 (org-element-property :deadline
(org-element-at-point))))
1064 (org-test-with-temp-text "
1065 *************** [#A] Task"
1067 (org-element-property :priority
(org-element-at-point)))))
1072 (org-test-with-temp-text "
1073 *************** Task :test:"
1075 (org-element-property :tags
(org-element-at-point)))))
1076 ;; Regular properties are accessed through upper case keywords.
1078 (org-test-with-temp-text "
1079 *************** Task
1083 *************** END"
1085 (org-element-property :FOO
(org-element-at-point))))
1087 (org-test-with-temp-text "
1088 *************** Task
1092 *************** END"
1094 (org-element-property :foo
(org-element-at-point))))
1095 ;; Handle non-empty blank line at the end of buffer.
1097 (org-test-with-temp-text "*************** Task\n*************** END\n "
1098 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1103 (ert-deftest test-org-element
/italic-parser
()
1104 "Test `italic' parser."
1107 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1108 (org-test-with-temp-text "/italic/"
1109 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1110 ;; Multi-line markup.
1113 (org-element-contents
1114 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1115 (org-test-with-temp-text "/first line\nsecond line/"
1116 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1117 '("first line\nsecond line"))))
1122 (ert-deftest test-org-element
/item-parser
()
1123 "Test `item' parser."
1126 (org-test-with-temp-text "- item"
1127 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1131 (org-element-property
1133 (org-test-with-temp-text "6. [@6] item"
1134 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1139 (org-element-property
1141 (org-test-with-temp-text "- tag :: description"
1142 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1143 ;; No tags in ordered lists.
1145 (org-element-property
1147 (org-test-with-temp-text "1. tag :: description"
1148 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1153 (org-test-with-temp-text "
1157 (org-element-map (org-element-parse-buffer) 'item
1158 (lambda (item) (org-element-property :checkbox item
))))))
1160 (org-test-with-temp-text "* Headline
1165 (let ((org-cycle-include-plain-lists t
)) (org-cycle))
1167 (org-element-property
1169 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1170 ;; Item starting with special syntax.
1172 (equal '(("- item"))
1173 (org-test-with-temp-text "- - item"
1174 (org-element-map (org-element-parse-buffer) 'paragraph
1175 'org-element-contents
))))
1176 ;; Block in an item: ignore indentation within the block.
1178 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1180 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1185 (ert-deftest test-org-element
/keyword-parser
()
1186 "Test `keyword' parser."
1189 (org-test-with-temp-text "#+KEYWORD: value"
1190 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1191 ;; Keywords are case-insensitive.
1193 (org-test-with-temp-text "#+keyword: value"
1194 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1195 ;; Affiliated keywords are not keywords.
1197 (org-test-with-temp-text "#+NAME: value
1199 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1200 ;; Do not mix keywords with Babel calls and dynamic blocks.
1202 (org-test-with-temp-text "#+CALL: fun()"
1203 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1205 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1206 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1207 ;; Handle non-empty blank line at the end of buffer.
1209 (org-test-with-temp-text "#+KEYWORD: value\n "
1210 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1213 ;;;; Latex Environment
1215 (ert-deftest test-org-element
/latex-environment-parser
()
1216 "Test `latex-environment' parser."
1218 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1219 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1220 ;; Allow nested environments.
1228 (org-test-with-temp-text "
1234 (org-element-property
1237 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1238 ;; Allow environments with options and arguments.
1240 (eq 'latex-environment
1241 (org-test-with-temp-text
1242 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1243 (org-element-type (org-element-at-point)))))
1245 (eq 'latex-environment
1246 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1247 (org-element-type (org-element-at-point)))))
1249 (eq 'latex-environment
1250 (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1251 (org-element-type (org-element-at-point)))))
1252 ;; Handle non-empty blank line at the end of buffer.
1254 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1255 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1260 (ert-deftest test-org-element
/latex-fragment-parser
()
1261 "Test `latex-fragment' parser."
1263 (org-test-with-temp-text "$a$"
1264 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1266 (org-test-with-temp-text "$$a$$"
1267 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1269 (org-test-with-temp-text "\\(a\\)"
1270 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1272 (org-test-with-temp-text "\\[a\\]"
1274 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1275 ;; Test fragment at the beginning of an item.
1278 (org-test-with-temp-text "- $x$"
1279 (progn (search-forward "$")
1280 (org-element-type (org-element-context)))))))
1285 (ert-deftest test-org-element
/line-break-parser
()
1286 "Test `line-break' parser."
1289 (org-test-with-temp-text "Text \\\\"
1290 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1291 ;; Line break with trailing white spaces.
1293 (org-test-with-temp-text "Text \\\\ "
1294 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1295 ;; Three backslashes are too much.
1297 (org-test-with-temp-text "Text \\\\\\"
1298 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1303 (ert-deftest test-org-element
/link-parser
()
1304 "Test `link' parser."
1309 (org-test-with-temp-text "A radio link"
1310 (org-element-property
1313 (let ((org-target-link-regexp "radio")) (org-element-parse-buffer))
1314 'link
'identity nil t
)))))
1317 ;; ... with description.
1321 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1322 (org-element-contents
1323 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1324 ;; ... without description.
1328 (org-test-with-temp-text "[[http://orgmode.org]]"
1329 (org-element-property
1331 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1332 ;; ... with expansion.
1335 "//orgmode.org/worg"
1336 (org-test-with-temp-text "[[Org:worg]]"
1337 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1338 (org-element-property
1340 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1341 ;; ... with translation.
1345 (org-test-with-temp-text "[[http://orgmode.org]]"
1346 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1347 (let ((org-link-translation-function 'link-translate
))
1348 (org-element-property
1350 (org-element-map (org-element-parse-buffer) 'link
1351 'identity nil t
)))))))
1356 (org-test-with-temp-text "[[id:aaaa]]"
1357 (org-element-property
1359 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1360 ;; ... custom-id link.
1364 (org-test-with-temp-text "[[#some-id]]"
1365 (org-element-property
1367 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1368 ;; ... coderef link.
1372 (org-test-with-temp-text "[[(reference)]]"
1373 (org-element-property
1375 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1380 (org-test-with-temp-text "[[target-or-title]]"
1381 (org-element-property
1383 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1384 ;; ... file-type link with search option.
1387 '(("file" "projects.org" "*task title"))
1388 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1389 (org-element-map (org-element-parse-buffer) 'link
1390 (lambda (l) (list (org-element-property :type l
)
1391 (org-element-property :path l
)
1392 (org-element-property :search-option l
)))))))
1393 ;; ... file-type link with application...
1396 '("file" "projects.org" "docview")
1397 (org-test-with-temp-text "[[docview:projects.org]]"
1398 (let ((l (org-element-context)))
1399 (list (org-element-property :type l
)
1400 (org-element-property :path l
)
1401 (org-element-property :application l
))))))
1402 ;; ... multi-line link.
1404 (equal "//orgmode.org"
1405 (org-test-with-temp-text "[[http://orgmode.\norg]]"
1406 (org-element-property :path
(org-element-context)))))
1409 (org-test-with-temp-text "A link: http://orgmode.org"
1410 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1413 (org-test-with-temp-text "A link: <http://orgmode.org>"
1414 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1415 ;; Link abbreviation.
1418 (org-test-with-temp-text
1419 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1420 (progn (org-mode-restart)
1421 (goto-char (1- (point-max)))
1422 (org-element-property :type
(org-element-context))))))
1423 ;; Link abbreviation in a secondary string.
1426 (org-test-with-temp-text
1427 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1428 (progn (org-mode-restart)
1429 (org-element-map (org-element-parse-buffer) 'link
1430 (lambda (link) (org-element-property :type link
))
1432 ;; Plain links are allowed as description of regular links.
1435 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1436 (search-forward "file:")
1437 (org-element-property :type
(org-element-context))))))
1442 (ert-deftest test-org-element
/macro-parser
()
1443 "Test `macro' parser."
1444 ;; Without arguments.
1446 (org-test-with-temp-text "{{{macro}}}"
1447 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1450 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1451 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1452 ;; Properly handle protected commas in arguments...
1456 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1457 (org-element-property :args
(org-element-context))))))
1458 ;; ... even when last argument ends with a protected comma.
1461 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1462 (org-element-property :args
(org-element-context)))))
1463 ;; Allow to escape escaping character.
1466 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1467 (org-element-property :args
(org-element-context)))))
1468 ;; No need to escape backslashes elsewhere.
1471 (org-test-with-temp-text "{{{macro(\\)}}}"
1472 (org-element-property :args
(org-element-context))))))
1477 (ert-deftest test-org-element
/node-property
()
1478 "Test `node-property' parser."
1481 (equal '("abc" "value")
1482 (org-test-with-temp-text ":PROPERTIES:\n<point>:abc: value\n:END:"
1483 (let ((element (org-element-at-point)))
1484 (list (org-element-property :key element
)
1485 (org-element-property :value element
))))))
1486 ;; Value should be trimmed.
1489 (org-test-with-temp-text ":PROPERTIES:\n<point>:abc: value \n:END:"
1490 (org-element-property :value
(org-element-at-point)))))
1491 ;; A node property requires to be wrapped within a property drawer.
1494 (org-test-with-temp-text ":abc: value"
1495 (org-element-type (org-element-at-point)))))
1496 ;; Accept empty properties.
1498 (equal '(("foo" "value") ("bar" nil
))
1499 (org-test-with-temp-text ":PROPERTIES:\n:foo: value\n:bar:\n:END:"
1500 (org-element-map (org-element-parse-buffer) 'node-property
1502 (list (org-element-property :key p
)
1503 (org-element-property :value p
)))))))
1504 ;; Ignore all non-property lines in property drawers.
1508 (org-test-with-temp-text ":PROPERTIES:\nWrong1\n:foo: value\nWrong2\n:END:"
1509 (org-element-map (org-element-parse-buffer) 'node-property
1511 (list (org-element-property :key p
)
1512 (org-element-property :value p
))))))))
1517 (ert-deftest test-org-element
/paragraph-parser
()
1518 "Test `paragraph' parser."
1521 (org-test-with-temp-text "Paragraph"
1522 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1523 ;; Property find end of a paragraph stuck to another element.
1526 (org-test-with-temp-text "Paragraph\n# Comment"
1527 (org-element-map (org-element-parse-buffer) 'paragraph
1528 (lambda (p) (char-after (org-element-property :end p
)))
1530 ;; Include ill-formed Keywords.
1532 (org-test-with-temp-text "#+wrong_keyword something"
1533 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1534 ;; Include incomplete-drawers.
1536 (let ((org-drawers '("TEST")))
1537 (org-test-with-temp-text ":TEST:\nParagraph"
1538 (let ((elem (org-element-at-point)))
1539 (and (eq (org-element-type elem
) 'paragraph
)
1540 (= (point-max) (org-element-property :end elem
)))))))
1541 ;; Include non-existent drawers.
1543 (let ((org-drawers '("TEST")))
1544 (org-test-with-temp-text ":NONAME:"
1545 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
))))
1546 ;; Include incomplete blocks.
1548 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1549 (let ((elem (org-element-at-point)))
1550 (and (eq (org-element-type elem
) 'paragraph
)
1551 (= (point-max) (org-element-property :end elem
))))))
1552 ;; Include incomplete dynamic blocks.
1554 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1555 (let ((elem (org-element-at-point)))
1556 (and (eq (org-element-type elem
) 'paragraph
)
1557 (= (point-max) (org-element-property :end elem
))))))
1558 ;; Include incomplete latex environments.
1560 (org-test-with-temp-text "\begin{equation}\nParagraph"
1561 (let ((elem (org-element-at-point)))
1562 (and (eq (org-element-type elem
) 'paragraph
)
1563 (= (point-max) (org-element-property :end elem
))))))
1564 ;; Do not steal affiliated keywords from container.
1566 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1567 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1568 (and (eq (org-element-type elem
) 'paragraph
)
1569 (not (org-element-property :attr_latex elem
))
1570 (/= (org-element-property :begin elem
) 1)))))
1571 ;; Handle non-empty blank line at the end of buffer.
1573 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1574 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1579 (ert-deftest test-org-element
/plain-list-parser
()
1580 "Test `plain-list' parser."
1581 (org-test-with-temp-text "- item"
1582 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1583 ;; Blank lines after the list only belong to outer plain list.
1587 (org-test-with-temp-text "
1592 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1593 (lambda (pl) (org-element-property :end pl
)))))
1595 ;; Move to ending of outer list.
1596 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1597 ;; Move to ending of inner list.
1598 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1599 ;; Correctly compute end of list if it doesn't end at a line
1602 (org-test-with-temp-text "- list\n \n "
1603 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1608 (ert-deftest test-org-element
/planning-parser
()
1609 "Test `planning' parser."
1611 (equal "[2012-03-29 thu.]"
1612 (org-element-property
1614 (org-element-property
1616 (org-test-with-temp-text "CLOSED: [2012-03-29 thu.]"
1617 (org-element-at-point))))))
1619 (equal "<2012-03-29 thu.>"
1620 (org-element-property
1622 (org-element-property
1624 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1625 (org-element-at-point))))))
1627 (equal "<2012-03-29 thu.>"
1628 (org-element-property
1630 (org-element-property
1632 (org-test-with-temp-text "SCHEDULED: <2012-03-29 thu.>"
1633 (org-element-at-point)))))))
1636 ;;;; Property Drawer
1638 (ert-deftest test-org-element
/property-drawer-parser
()
1639 "Test `property-drawer' parser."
1642 (let ((org-drawers '("PROPERTIES")))
1643 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
1644 (org-element-map (org-element-parse-buffer) 'property-drawer
1646 ;; Do not mix property drawers and regular drawers.
1648 (let ((org-drawers '("TEST")))
1649 (org-test-with-temp-text ":TEST:\n:prop: value\n:END:"
1650 (org-element-map (org-element-parse-buffer) 'property-drawer
1652 ;; Ignore incomplete drawer.
1654 (let ((org-drawers '("PROPERTIES")))
1655 (org-test-with-temp-text ":PROPERTIES:\n:prop: value"
1656 (org-element-map (org-element-parse-buffer) 'property-drawer
1658 ;; Handle non-empty blank line at the end of buffer.
1660 (org-test-with-temp-text ":PROPERTIES:\n:END:\n "
1661 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1666 (ert-deftest test-org-element
/quote-block-parser
()
1667 "Test `quote-block' parser."
1670 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1671 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1672 ;; Test folded block.
1673 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1676 (org-element-property
1678 (org-element-map (org-element-parse-buffer) 'quote-block
1680 ;; Ignore incomplete block.
1682 (org-test-with-temp-text "#+BEGIN_QUOTE"
1683 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1684 ;; Handle non-empty blank line at the end of buffer.
1686 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1687 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1692 (ert-deftest test-org-element
/quote-section-parser
()
1693 "Test `quote-section' parser."
1695 (let ((org-quote-string "QUOTE"))
1696 (org-test-with-temp-text "* QUOTE Headline\nBody"
1697 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
))))
1699 (let ((org-quote-string "TEST"))
1700 (org-test-with-temp-text "* QUOTE Headline\nBody"
1701 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
)))))
1706 (ert-deftest test-org-element
/radio-target-parser
()
1707 "Test `radio-target' parser."
1711 (org-test-with-temp-text "<<<radio>>>"
1712 (org-element-type (org-element-context)))))
1713 ;; Radio targets with objects.
1716 (org-test-with-temp-text "<<<radio \\alpha>>>"
1717 (org-element-type (org-element-context)))))
1718 ;; Radio targets starting with an object.
1721 (org-test-with-temp-text "<<<\\alpha radio>>>"
1722 (org-element-type (org-element-context))))))
1727 (ert-deftest test-org-element
/section-parser
()
1728 "Test `section' parser."
1731 (org-test-with-temp-text "* Headline\nText"
1732 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1733 ;; There's a section before the first headline.
1735 (org-test-with-temp-text "Text"
1736 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1737 ;; A section cannot be empty.
1739 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1740 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1741 ;; A section doesn't contain sub-trees.
1743 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1745 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1746 'headline
'identity
))))
1751 (ert-deftest test-org-element
/special-block-parser
()
1752 "Test `special-block' parser."
1756 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1757 (org-element-property :type
(org-element-at-point)))))
1758 ;; Special blocks can contain paragraphs.
1761 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1763 (org-element-type (org-element-at-point)))))
1764 ;; Test folded block.
1766 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1768 (org-element-property :hiddenp
(org-element-at-point))))
1769 ;; Ignore incomplete block.
1772 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1773 (org-element-type (org-element-at-point)))))
1774 ;; Allow special characters in type.
1776 (equal '(special-block "SPECIAL*")
1777 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1778 (let ((element (org-element-at-point)))
1779 (list (org-element-type element
)
1780 (org-element-property :type element
))))))
1781 ;; Handle non-empty blank line at the end of buffer.
1783 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1784 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1789 (ert-deftest test-org-element
/src-block-parser
()
1790 "Test `src-block' parser."
1793 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1794 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1795 ;; Test folded block.
1797 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1799 (org-element-property :hiddenp
(org-element-at-point))))
1800 ;; Ignore incomplete block.
1802 (org-test-with-temp-text "#+BEGIN_SRC"
1803 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1804 ;; Properly un-escape code.
1806 (equal "* Headline\n #+keyword\nText\n"
1807 (org-test-with-temp-text
1808 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1809 (org-element-property :value
(org-element-at-point)))))
1810 ;; Nil `org-src-preserve-indentation': Remove maximum common
1814 (org-test-with-temp-text "#+BEGIN_SRC org\n L1\n L2\n#+END_SRC"
1815 (let ((org-src-preserve-indentation nil
))
1816 (org-element-property :value
(org-element-at-point))))))
1817 ;; Non-nil `org-src-preserve-indentation': Remove block indentation
1818 ;; only, unless block contents are less indented than block
1822 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1823 (let ((org-src-preserve-indentation t
))
1824 (org-element-property :value
(org-element-at-point))))))
1828 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1829 (let ((org-src-preserve-indentation t
))
1830 (org-element-property :value
(org-element-at-point))))))
1831 ;; Handle non-empty blank line at the end of buffer.
1833 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
1834 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1837 ;;;; Statistics Cookie
1839 (ert-deftest test-org-element
/statistics-cookie
()
1840 "Test `statistics-cookie' parser."
1843 (org-test-with-temp-text "[1/2]"
1844 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1847 (org-test-with-temp-text "[33%]"
1849 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1854 (ert-deftest test-org-element
/strike-through-parser
()
1855 "Test `strike-through' parser."
1858 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1859 (org-test-with-temp-text "+strike-through+"
1860 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1861 ;; Multi-line markup.
1864 (org-element-contents
1865 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1866 (org-test-with-temp-text "+first line\nsecond line+"
1868 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1869 '("first line\nsecond line"))))
1874 (ert-deftest test-org-element
/subscript-parser
()
1875 "Test `subscript' parser."
1878 (org-test-with-temp-text "a_b"
1879 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1882 (org-test-with-temp-text "a_{b}"
1883 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1884 ;; Multiple subscripts in a paragraph.
1887 (org-test-with-temp-text "a_b and c_d"
1889 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1894 (ert-deftest test-org-element
/superscript-parser
()
1895 "Test `superscript' parser."
1898 (org-test-with-temp-text "a^b"
1899 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1902 (org-test-with-temp-text "a^{b}"
1903 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1904 ;; Multiple superscript in a paragraph.
1907 (org-test-with-temp-text "a^b and c^d"
1910 (org-element-parse-buffer) 'superscript
'identity
))))))
1915 (ert-deftest test-org-element
/table-parser
()
1916 "Test `table' parser."
1918 (org-test-with-temp-text "| a |"
1919 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
1920 ;; TBLFM keyword is case insensitive.
1922 (org-test-with-temp-text "| a |\n#+tblfm: test"
1923 (org-element-property
1925 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
1926 ;; Handle multiple TBLFM lines.
1929 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
1930 (length (org-element-property
1933 (org-element-parse-buffer) 'table
'identity nil t
))))))
1934 ;; Handle non-empty blank line at the end of buffer.
1936 (org-test-with-temp-text "| a |\n "
1937 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1942 (ert-deftest test-org-element
/table-cell-parser
()
1943 "Test `table-cell' parser."
1944 ;; Regular table cell.
1946 (org-test-with-temp-text "| a |"
1947 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
)))
1948 ;; Last vertical bar may be omitted.
1950 (org-test-with-temp-text "| a "
1951 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
1956 (ert-deftest test-org-element
/table-row-parser
()
1957 "Test `table-row' parser."
1959 (equal '(standard rule
)
1960 (org-test-with-temp-text "| a |\n|---|"
1962 (org-element-parse-buffer) 'table-row
1963 (lambda (row) (org-element-property :type row
)))))))
1968 (ert-deftest test-org-element
/target-parser
()
1969 "Test `target' parser."
1971 (org-test-with-temp-text "<<target>>"
1972 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
1977 (ert-deftest test-org-element
/timestamp
()
1978 "Test `timestamp' parser."
1979 ;; Active timestamp.
1981 (org-test-with-temp-text "<2012-03-29 16:40>"
1982 (eq (org-element-property :type
(org-element-context)) 'active
)))
1984 (org-test-with-temp-text "<2012-03-29 Thu>"
1985 (let ((timestamp (org-element-context)))
1986 (or (org-element-property :hour-start timestamp
)
1987 (org-element-property :minute-start timestamp
)))))
1989 (equal '(2012 3 29 16 40)
1990 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
1991 (let ((object (org-element-context)))
1992 (list (org-element-property :year-start object
)
1993 (org-element-property :month-start object
)
1994 (org-element-property :day-start object
)
1995 (org-element-property :hour-start object
)
1996 (org-element-property :minute-start object
))))))
1997 ;; Inactive timestamp.
1999 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
2000 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
2003 (equal '(2012 3 29 16 40 7 30)
2004 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2005 (let ((object (org-element-context)))
2006 (list (org-element-property :year-end object
)
2007 (org-element-property :month-end object
)
2008 (org-element-property :day-end object
)
2009 (org-element-property :hour-end object
)
2010 (org-element-property :minute-end object
)
2011 (org-element-property :hour-start object
)
2012 (org-element-property :minute-start object
))))))
2015 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2016 (org-element-property :type
(org-element-context)))))
2019 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
2020 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
2022 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
2023 (let ((timestamp (org-element-context)))
2024 (or (org-element-property :hour-end timestamp
)
2025 (org-element-property :minute-end timestamp
)))))
2026 ;; With repeater, warning delay and both.
2029 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
2030 (org-element-property :repeater-type
(org-element-context)))))
2033 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
2034 (org-element-property :warning-type
(org-element-context)))))
2036 (equal '(cumulate all
)
2037 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
2038 (let ((ts (org-element-context)))
2039 (list (org-element-property :repeater-type ts
)
2040 (org-element-property :warning-type ts
))))))
2041 ;; Timestamps are not planning elements.
2043 (org-test-with-temp-text "SCHEDULED: <2012-03-29 Thu 16:40>"
2044 (org-element-map (org-element-parse-buffer) 'timestamp
'identity
))))
2049 (ert-deftest test-org-element
/underline-parser
()
2050 "Test `underline' parser."
2053 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2054 (org-test-with-temp-text "_underline_"
2055 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
2056 ;; Multi-line markup.
2059 (org-element-contents
2060 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2061 (org-test-with-temp-text "_first line\nsecond line_"
2063 (org-element-parse-buffer) 'underline
'identity nil t
))))
2064 '("first line\nsecond line"))))
2069 (ert-deftest test-org-element
/verbatim-parser
()
2070 "Test `verbatim' parser."
2073 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2074 (org-test-with-temp-text "=verbatim="
2075 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
2076 ;; Multi-line markup.
2079 (org-element-property
2081 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2082 (org-test-with-temp-text "=first line\nsecond line="
2084 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
2085 "first line\nsecond line")))
2090 (ert-deftest test-org-element
/verse-block-parser
()
2091 "Test `verse-block' parser."
2093 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2095 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2097 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2099 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2101 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2102 (org-hide-block-all)
2104 (org-element-property
2106 (org-element-map (org-element-parse-buffer) 'verse-block
2108 ;; Parse objects in verse blocks.
2109 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2110 (should (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
2111 ;; Ignore incomplete verse block.
2113 (org-test-with-temp-text "#+BEGIN_VERSE"
2114 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
2115 ;; Handle non-empty blank line at the end of buffer.
2117 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2118 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2122 ;;; Test Interpreters.
2124 (ert-deftest test-org-element
/affiliated-keywords-interpreter
()
2125 "Test if affiliated keywords are correctly interpreted."
2126 ;; Interpret simple keywords.
2129 (org-element-interpret-data
2130 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2131 "#+NAME: para\nParagraph\n"))
2132 ;; Interpret multiple keywords.
2135 (org-element-interpret-data
2136 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2137 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2138 ;; Interpret parsed keywords.
2141 (org-element-interpret-data
2142 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2143 "#+CAPTION: caption\nParagraph\n"))
2144 ;; Interpret dual keywords.
2147 (org-element-interpret-data
2148 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2149 "#+CAPTION[short]: long\nParagraph\n"))
2150 ;; Interpret multiple parsed dual keywords.
2153 (org-element-interpret-data
2154 '(org-data nil
(paragraph
2155 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2156 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n")))
2158 (ert-deftest test-org-element
/center-block-interpreter
()
2159 "Test center block interpreter."
2161 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2162 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2164 (ert-deftest test-org-element
/drawer-interpreter
()
2165 "Test drawer interpreter."
2167 (equal (let ((org-drawers '("TEST")))
2168 (org-test-parse-and-interpret ":TEST:\nTest\n:END:"))
2169 ":TEST:\nTest\n:END:\n")))
2171 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2172 "Test dynamic block interpreter."
2174 (equal (org-test-parse-and-interpret
2175 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2176 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2178 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2179 "Test footnote definition interpreter."
2180 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2182 (ert-deftest test-org-element
/headline-interpreter
()
2183 "Test headline and section interpreters."
2184 ;; 1. Standard test.
2185 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2186 ;; 2. With TODO keywords.
2188 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2189 (org-test-parse-and-interpret "* TODO Headline"))
2190 "* TODO Headline\n"))
2193 ;; 3.1. ... and a positive `org-tags-column' value.
2195 (equal (let ((org-tags-column 20))
2196 (org-test-parse-and-interpret "* Headline :tag:"))
2197 "* Headline :tag:\n"))
2198 ;; 3.2. ... and a negative `org-tags-column' value.
2200 (equal (let ((org-tags-column -
20))
2201 (org-test-parse-and-interpret "* Headline :tag:"))
2202 "* Headline :tag:\n"))
2203 ;; 3.3. ... and a null `org-tags-column' value.
2205 (equal (let ((org-tags-column 0))
2206 (org-test-parse-and-interpret "* Headline :tag:"))
2207 "* Headline :tag:\n"))
2208 ;; 4. With priority cookie.
2210 (equal (org-test-parse-and-interpret "* [#B] Headline")
2211 "* [#B] Headline\n"))
2212 ;; 5. With comment keyword.
2214 (equal (let ((org-comment-string "COMMENT"))
2215 (org-test-parse-and-interpret "* COMMENT Headline"))
2216 "* COMMENT Headline\n"))
2217 ;; 6. With quote section.
2219 (equal (let ((org-quote-string "QUOTE"))
2220 (org-test-parse-and-interpret "* QUOTE Headline"))
2221 "* QUOTE Headline\n"))
2222 ;; 7. Keep same number of blank lines before body.
2224 (equal (org-test-parse-and-interpret
2225 "* Headline\n\n\nText after two blank lines.")
2226 "* Headline\n\n\nText after two blank lines.\n"))
2227 ;; 8. Preserve `org-odd-levels-only' state.
2229 (equal "* H\n*** H2\n"
2230 (let ((org-odd-levels-only t
))
2231 (org-test-parse-and-interpret "* H\n*** H2")))))
2233 (ert-deftest test-org-element
/inlinetask-interpreter
()
2234 "Test inlinetask interpretation."
2235 (when (featurep 'org-inlinetask
)
2236 (let ((org-inlinetask-min-level 15))
2237 ;; 1. Regular inlinetask.
2238 (should (equal (org-test-parse-and-interpret
2239 "*************** Task\nTest\n*************** END")
2240 "*************** Task\nTest\n*************** END\n"))
2241 ;; 2. Degenerate inlinetask.
2242 (should (equal (org-test-parse-and-interpret "*************** Task")
2243 "*************** Task\n"))
2244 ;; 3. Prefer degenerate form when there are no contents.
2245 (should (equal (org-test-parse-and-interpret
2246 "*************** Task\n*************** END")
2247 "*************** Task\n"))
2248 ;; 4. With TODO keywords.
2250 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2251 (org-test-parse-and-interpret "*************** TODO Task"))
2252 "*************** TODO Task\n"))
2255 ;; 5.1. ... and a positive `org-tags-column' value.
2257 (equal (let ((org-tags-column 30))
2258 (org-test-parse-and-interpret "*************** Task :tag:"))
2259 "*************** Task :tag:\n"))
2260 ;; 5.2. ... and a negative `org-tags-column' value.
2262 (equal (let ((org-tags-column -
30))
2263 (org-test-parse-and-interpret "*************** Task :tag:"))
2264 "*************** Task :tag:\n"))
2265 ;; 5.3. ... and a null `org-tags-column' value.
2267 (equal (let ((org-tags-column 0))
2268 (org-test-parse-and-interpret "*************** Task :tag:"))
2269 "*************** Task :tag:\n"))
2270 ;; 6. With priority cookie.
2272 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2273 "*************** [#B] Task\n")))))
2275 (ert-deftest test-org-element
/plain-list-interpreter
()
2276 "Test plain-list and item interpreters."
2277 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2279 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2280 ;; Description list.
2282 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2285 (equal (let ((org-plain-list-ordered-item-terminator t
))
2286 (org-test-parse-and-interpret "1. Item"))
2289 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2290 (org-test-parse-and-interpret "1) Item"))
2292 ;; Ordered list with counter.
2294 (equal (let ((org-plain-list-ordered-item-terminator t
))
2295 (org-test-parse-and-interpret "1. [@5] Item"))
2297 ;; List with check-boxes.
2299 (equal (org-test-parse-and-interpret
2300 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2301 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2302 ;; Item not starting with a paragraph.
2304 (equal (org-test-parse-and-interpret "-\n | a | b |")
2305 "- \n | a | b |\n"))
2306 ;; Special case: correctly handle "*" bullets.
2307 (should (org-test-parse-and-interpret " * item"))
2308 ;; Special case: correctly handle empty items.
2309 (should (org-test-parse-and-interpret "-"))))
2311 (ert-deftest test-org-element
/quote-block-interpreter
()
2312 "Test quote block interpreter."
2313 (should (equal (org-test-parse-and-interpret
2314 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2315 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2317 (ert-deftest test-org-element
/special-block-interpreter
()
2318 "Test special block interpreter."
2319 (should (equal (org-test-parse-and-interpret
2320 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2321 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2323 (ert-deftest test-org-element
/babel-call-interpreter
()
2324 "Test babel call interpreter."
2325 ;; 1. Without argument.
2326 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2327 "#+CALL: test()\n"))
2328 ;; 2. With argument.
2329 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2330 "#+CALL: test(x=2)\n"))
2331 ;; 3. With header arguments.
2332 (should (equal (org-test-parse-and-interpret
2333 "#+CALL: test[:results output]()[:results html]")
2334 "#+CALL: test[:results output]()[:results html]\n")))
2336 (ert-deftest test-org-element
/clock-interpreter
()
2337 "Test clock interpreter."
2340 (equal (let ((org-clock-string "CLOCK:"))
2341 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]"))
2342 "CLOCK: [2012-01-01 sun. 00:01]\n"))
2346 (let ((org-clock-string "CLOCK:"))
2347 (org-test-parse-and-interpret "
2348 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))
2349 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01\n")))
2351 (ert-deftest test-org-element
/comment-interpreter
()
2352 "Test comment interpreter."
2354 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2356 (should (equal (org-test-parse-and-interpret " # Comment")
2358 ;; Preserve indentation.
2359 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2360 "# No blank\n# One blank\n")))
2362 (ert-deftest test-org-element
/comment-block-interpreter
()
2363 "Test comment block interpreter."
2364 (should (equal (org-test-parse-and-interpret
2365 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2366 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
2368 (ert-deftest test-org-element
/diary-sexp
()
2369 "Test diary-sexp interpreter."
2372 (org-test-parse-and-interpret
2373 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2374 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2376 (ert-deftest test-org-element
/example-block-interpreter
()
2377 "Test example block interpreter."
2378 ;; Without switches.
2379 (should (equal (org-test-parse-and-interpret
2380 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2381 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2384 (equal (org-test-parse-and-interpret
2385 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2386 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2387 ;; Preserve code escaping.
2389 (equal (org-test-parse-and-interpret
2390 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2391 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n")))
2393 (ert-deftest test-org-element
/export-block-interpreter
()
2394 "Test export block interpreter."
2395 (should (equal (org-test-parse-and-interpret
2396 "#+BEGIN_HTML\nTest\n#+END_HTML")
2397 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2399 (ert-deftest test-org-element
/fixed-width-interpreter
()
2400 "Test fixed width interpreter."
2402 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2403 ;; Preserve indentation.
2404 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2405 ": 2 blanks\n: 1 blank\n"))
2406 ;; Remove last newline character
2408 (equal (org-element-fixed-width-interpreter
2409 '(fixed-width (:value
"Test\n")) nil
)
2412 (equal (org-element-fixed-width-interpreter
2413 '(fixed-width (:value
"Test")) nil
)
2415 ;; Handle empty string.
2417 (equal (org-element-fixed-width-interpreter
2418 '(fixed-width (:value
"")) nil
)
2420 ;; Handle nil value.
2422 (org-element-fixed-width-interpreter
2423 '(fixed-width (:value nil
)) nil
)))
2425 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2426 "Test horizontal rule interpreter."
2427 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2429 (ert-deftest test-org-element
/keyword-interpreter
()
2430 "Test keyword interpreter."
2431 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2432 "#+KEYWORD: value\n")))
2434 (ert-deftest test-org-element
/latex-environment-interpreter
()
2435 "Test latex environment interpreter."
2436 (should (equal (org-test-parse-and-interpret
2437 "\\begin{equation}\n1+1=2\n\\end{equation}")
2438 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2439 (should (equal (org-test-parse-and-interpret
2440 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2441 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2443 (ert-deftest test-org-element
/planning-interpreter
()
2444 "Test planning interpreter."
2445 (let ((org-closed-string "CLOSED:")
2446 (org-deadline-string "DEADLINE:")
2447 (org-scheduled-string "SCHEDULED:"))
2450 (org-test-parse-and-interpret
2452 DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01> CLOSED: [2012-01-01]")
2454 DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01> CLOSED: [2012-01-01]\n"))))
2456 (ert-deftest test-org-element
/property-drawer-interpreter
()
2457 "Test property drawer interpreter."
2458 (should (equal (let ((org-property-format "%-10s %s"))
2459 (org-test-parse-and-interpret
2460 ":PROPERTIES:\n:prop: value\n:END:"))
2461 ":PROPERTIES:\n:prop: value\n:END:\n")))
2463 (ert-deftest test-org-element
/src-block-interpreter
()
2464 "Test src block interpreter."
2467 (equal (let ((org-edit-src-content-indentation 2))
2468 (org-test-parse-and-interpret
2469 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2470 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2473 (equal (let ((org-edit-src-content-indentation 2))
2474 (org-test-parse-and-interpret
2475 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2476 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2477 ;; Preserve code escaping.
2479 (equal (let ((org-edit-src-content-indentation 2))
2480 (org-test-parse-and-interpret
2481 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2482 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2483 ;; Do not apply `org-edit-src-content-indentation' when preserving
2486 (equal (let ((org-edit-src-content-indentation 2)
2487 (org-src-preserve-indentation t
))
2488 (org-test-parse-and-interpret
2489 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2490 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2492 (equal (let ((org-edit-src-content-indentation 2)
2493 (org-src-preserve-indentation nil
))
2494 (org-test-parse-and-interpret
2495 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2496 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n")))
2498 (ert-deftest test-org-element
/table-interpreter
()
2499 "Test table, table-row and table-cell interpreters."
2501 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2502 "| a | b |\n| c | d |\n"))
2503 ;; 2. With horizontal rules.
2504 (should (equal (org-test-parse-and-interpret
2505 "| a | b |\n|---+---|\n| c | d |")
2506 "| a | b |\n|---+---|\n| c | d |\n"))
2507 ;; 3. With meta-data.
2508 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2509 "| / | < | > |\n| * | 1 | 2 |\n"))
2510 ;; 4. With a formula.
2512 (equal (org-test-parse-and-interpret
2513 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2514 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2515 ;; 5. With multiple formulas.
2517 (equal (org-test-parse-and-interpret
2518 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2519 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2521 (ert-deftest test-org-element
/timestamp-interpreter
()
2522 "Test timestamp interpreter."
2524 (should (equal (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")
2525 "<2012-03-29 thu. 16:40>\n"))
2527 (string-match "<2012-03-29 .* 16:40>"
2528 (org-element-timestamp-interpreter
2530 (:type active
:year-start
2012 :month-start
3 :day-start
29
2531 :hour-start
16 :minute-start
40)) nil
)))
2533 (should (equal (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")
2534 "[2012-03-29 thu. 16:40]\n"))
2537 "\\[2012-03-29 .* 16:40\\]"
2538 (org-element-timestamp-interpreter
2540 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2541 :hour-start
16 :minute-start
40)) nil
)))
2543 (should (equal (org-test-parse-and-interpret
2544 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")
2545 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>\n"))
2548 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2549 (org-element-timestamp-interpreter
2551 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2552 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2553 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2555 (should (equal (org-test-parse-and-interpret
2556 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")
2557 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]\n"))
2560 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2561 (org-element-timestamp-interpreter
2563 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2564 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2565 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2567 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2568 "<%%diary-float t 4 2>\n"))
2569 ;; Timestamp with repeater interval, with delay, with both.
2570 (should (equal (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")
2571 "<2012-03-29 thu. +1y>\n"))
2574 "<2012-03-29 .* \\+1y>"
2575 (org-element-timestamp-interpreter
2577 (:type active
:year-start
2012 :month-start
3 :day-start
29
2578 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2582 "<2012-03-29 .* -1y>"
2583 (org-element-timestamp-interpreter
2585 (:type active
:year-start
2012 :month-start
3 :day-start
29
2586 :warning-type all
:warning-value
1 :warning-unit year
))
2590 "<2012-03-29 .* \\+1y -1y>"
2591 (org-element-timestamp-interpreter
2593 (:type active
:year-start
2012 :month-start
3 :day-start
29
2594 :warning-type all
:warning-value
1 :warning-unit year
2595 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2597 ;; Timestamp range with repeater interval
2598 (should (equal (org-test-parse-and-interpret
2599 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")
2600 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>\n"))
2603 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2604 (org-element-timestamp-interpreter
2606 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2607 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2608 :repeater-value
1 :repeater-unit year
))
2611 (ert-deftest test-org-element
/verse-block-interpreter
()
2612 "Test verse block interpretation."
2614 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2615 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2617 (ert-deftest test-org-element
/bold-interpreter
()
2618 "Test bold interpreter."
2619 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2621 (ert-deftest test-org-element
/code-interpreter
()
2622 "Test code interpreter."
2623 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2625 (ert-deftest test-org-element
/entity-interpreter
()
2626 "Test entity interpreter."
2627 ;; 1. Without brackets.
2629 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2630 ;; 2. With brackets.
2632 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2634 (ert-deftest test-org-element
/export-snippet-interpreter
()
2635 "Test export snippet interpreter."
2636 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2637 "@@back-end:contents@@\n")))
2639 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2640 "Test footnote reference interpreter."
2641 ;; 1. Regular reference.
2642 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2643 ;; 2. Normalized reference.
2644 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2645 ;; 3. Named reference.
2646 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2647 "Text[fn:label]\n"))
2648 ;; 4. Inline reference.
2649 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2650 "Text[fn:label:def]\n"))
2651 ;; 5. Anonymous reference.
2652 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2653 "Text[fn::def]\n")))
2655 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2656 "Test inline babel call interpreter."
2657 ;; 1. Without arguments.
2658 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2659 ;; 2. With arguments.
2660 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2661 "call_test(x=2)\n"))
2662 ;; 3. With header arguments.
2663 (should (equal (org-test-parse-and-interpret
2664 "call_test[:results output]()[:results html]")
2665 "call_test[:results output]()[:results html]\n")))
2667 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2668 "Test inline src block interpreter."
2669 ;; 1. Without header argument.
2670 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2671 "src_emacs-lisp{(+ 1 1)}\n"))
2672 ;; 2. With header arguments.
2673 (should (equal (org-test-parse-and-interpret
2674 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2675 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2677 (ert-deftest test-org-element
/italic-interpreter
()
2678 "Test italic interpreter."
2679 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2681 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2682 "Test latex fragment interpreter."
2683 (let ((org-latex-regexps
2684 '(("begin" "^[ ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^