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
/secondary-p
()
145 "Test `org-element-secondary-p' specifications."
146 ;; In a secondary string, return property name.
149 (org-test-with-temp-text "* Headline *object*"
150 (org-element-map (org-element-parse-buffer) 'bold
151 (lambda (object) (org-element-secondary-p object
))
153 ;; Outside a secondary string, return nil.
155 (org-test-with-temp-text "Paragraph *object*"
156 (org-element-map (org-element-parse-buffer) 'bold
157 (lambda (object) (org-element-type (org-element-secondary-p object
)))
160 (ert-deftest test-org-element
/adopt-elements
()
161 "Test `org-element-adopt-elements' specifications."
164 (equal '(plain-text italic
)
165 (org-test-with-temp-text "* Headline\n *a*"
166 (let ((tree (org-element-parse-buffer)))
167 (org-element-adopt-elements
168 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"a"))
169 (mapcar (lambda (blob) (org-element-type blob
))
170 (org-element-contents
171 (org-element-map tree
'bold
'identity nil t
)))))))
175 (org-test-with-temp-text "* Headline\n *a*"
176 (let ((tree (org-element-parse-buffer)))
177 (org-element-adopt-elements
178 (org-element-map tree
'bold
'identity nil t
) "b")
179 (org-element-contents
180 (org-element-map tree
'bold
'identity nil t
)))))))
186 ;;;; Affiliated Keywords
188 (ert-deftest test-org-element
/affiliated-keywords-parser
()
189 "Test affiliated keywords parsing."
190 ;; Read simple keywords.
193 (org-element-property
195 (org-test-with-temp-text "#+NAME: para\nParagraph"
196 (org-element-at-point)))))
199 (org-element-property
201 (org-test-with-temp-text "#+NAME: para\nParagraph"
202 (org-element-at-point)))))
203 ;; Parse multiple keywords.
207 (org-element-property
209 (org-test-with-temp-text
210 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
211 (org-element-at-point)))))
212 ;; Parse "parsed" keywords.
216 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
217 (car (org-element-property :caption
(org-element-at-point))))))
218 ;; Parse dual keywords.
221 '((("long") "short"))
222 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
223 (org-element-property :caption
(org-element-at-point)))))
224 ;; Allow multiple caption keywords.
227 '((("l2") "s2") (("l1") "s1"))
228 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
229 (org-element-property :caption
(org-element-at-point)))))
232 '((("l1")) (nil "s1"))
233 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
234 (org-element-property :caption
(org-element-at-point)))))
235 ;; Corner case: orphaned keyword at the end of an element.
238 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
239 (progn (search-forward "name")
240 (org-element-type (org-element-at-point))))))
242 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
243 (progn (search-forward "Some")
244 (org-element-property :name
(org-element-at-point))))))
249 (ert-deftest test-org-element
/babel-call-parser
()
250 "Test `babel-call' parsing."
253 (org-test-with-temp-text "#+CALL: test()"
254 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
257 (org-test-with-temp-text "#+call: test()"
258 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
259 ;; Handle non-empty blank line at the end of buffer.
261 (org-test-with-temp-text "#+CALL: test()\n "
262 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
267 (ert-deftest test-org-element
/bold-parser
()
268 "Test `bold' parser."
271 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
272 (org-test-with-temp-text "*bold*"
273 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
274 ;; Multi-line markup.
277 (org-element-contents
278 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
279 (org-test-with-temp-text "*first line\nsecond line*"
280 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
281 '("first line\nsecond line"))))
286 (ert-deftest test-org-element
/center-block-parser
()
287 "Test `center-block' parser."
290 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
291 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
294 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
295 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
296 ;; Ignore incomplete block.
298 (org-test-with-temp-text "#+BEGIN_CENTER"
299 (org-element-map (org-element-parse-buffer) 'center-block
301 ;; Handle non-empty blank line at the end of buffer.
303 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
304 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
309 (ert-deftest test-org-element
/clock-parser
()
310 "Test `clock' parser."
312 (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
313 (org-element-at-point))))
314 (should (eq (org-element-property :status clock
) 'running
))
316 (equal (org-element-property :raw-value
317 (org-element-property :value clock
))
318 "[2012-01-01 sun. 00:01]"))
319 (should-not (org-element-property :duration clock
)))
322 (org-test-with-temp-text
323 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
324 (org-element-at-point))))
325 (should (eq (org-element-property :status clock
) 'closed
))
326 (should (equal (org-element-property :raw-value
327 (org-element-property :value clock
))
328 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
329 (should (equal (org-element-property :duration clock
) "0:01"))))
334 (ert-deftest test-org-element
/code-parser
()
335 "Test `code' parser."
338 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
339 (org-test-with-temp-text "~code~"
340 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
341 ;; Multi-line markup.
344 (org-element-property
346 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
347 (org-test-with-temp-text "~first line\nsecond line~"
349 (org-element-parse-buffer) 'code
'identity nil t
))))
350 "first line\nsecond line")))
355 (ert-deftest test-org-element
/comment-parser
()
356 "Test `comment' parser."
359 (org-test-with-temp-text "# Comment"
360 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
363 (org-test-with-temp-text " # Comment"
364 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
365 ;; Preserve indentation.
368 (org-element-property
370 (org-test-with-temp-text "# No blank\n# One blank"
371 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
372 "No blank\n One blank"))
373 ;; Comment with blank lines.
376 (org-element-property
378 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
379 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
380 "First part\n\n\nSecond part"))
381 ;; Do not mix comments and keywords.
384 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
385 (length (org-element-map (org-element-parse-buffer) 'comment
389 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
390 (org-element-property
392 (org-element-map (org-element-parse-buffer) 'comment
394 ;; Correctly handle non-empty blank lines at the end of buffer.
396 (org-test-with-temp-text "# A\n "
397 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
402 (ert-deftest test-org-element
/comment-block-parser
()
403 "Test `comment-block' parser."
406 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
407 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
410 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
411 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
412 ;; Ignore incomplete block.
414 (org-test-with-temp-text "#+BEGIN_COMMENT"
415 (org-element-map (org-element-parse-buffer) 'comment-block
417 ;; Handle non-empty blank line at the end of buffer.
419 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
420 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
425 (ert-deftest test-org-element
/diary-sexp-parser
()
426 "Test `diary-sexp' parser."
430 (org-test-with-temp-text
431 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
432 (org-element-type (org-element-at-point)))))
433 ;; Diary sexp must live at beginning of line
436 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
437 (org-element-type (org-element-at-point)))))
438 ;; Handle non-empty blank line at the end of buffer.
440 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
441 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
446 (ert-deftest test-org-element
/drawer-parser
()
447 "Test `drawer' parser."
450 (org-test-with-temp-text ":TEST:\nText\n:END:"
451 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
452 ;; Do not mix regular drawers and property drawers.
454 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
455 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
456 ;; Ignore incomplete drawer.
458 (org-test-with-temp-text ":TEST:"
459 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
460 ;; Handle non-empty blank line at the end of buffer.
462 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
463 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
468 (ert-deftest test-org-element
/dynamic-block-parser
()
469 "Test `dynamic-block' parser."
472 (org-test-with-temp-text
473 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
474 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
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
)))
480 ;; Ignore incomplete block.
482 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
483 (org-element-map (org-element-parse-buffer) 'dynamic-block
485 ;; Handle non-empty blank line at the end of buffer.
487 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
488 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
493 (ert-deftest test-org-element
/entity-parser
()
494 "Test `entity' parser."
497 (org-test-with-temp-text "\\sin"
498 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
501 (org-element-property
503 (org-test-with-temp-text "\\alpha{}text"
504 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
505 ;; User-defined entity.
508 (org-element-property
510 (let ((org-entities-user
511 '(("test" "test" nil
"test" "test" "test" "test"))))
512 (org-test-with-temp-text "\\test"
513 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
515 ;; Special case: entity at the end of a container.
518 (org-test-with-temp-text "*\\alpha \\beta*"
519 (search-forward "be")
520 (org-element-type (org-element-context))))))
525 (ert-deftest test-org-element
/example-block-parser
()
526 "Test `example-block' parser."
529 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
530 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
531 ;; Ignore incomplete block.
534 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
535 (org-element-type (org-element-at-point)))))
536 ;; Properly un-escape code.
538 (equal "* Headline\n #+keyword\nText\n"
539 (org-test-with-temp-text
540 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
541 (org-element-property :value
(org-element-at-point)))))
542 ;; Remove block indentation according to block boundaries, unless
543 ;; block contents are less indented than block boundaries.
546 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
547 (let ((org-src-preserve-indentation t
))
548 (org-element-property :value
(org-element-at-point))))))
552 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
553 (let ((org-src-preserve-indentation t
))
554 (org-element-property :value
(org-element-at-point))))))
555 ;; Handle non-empty blank line at the end of buffer.
557 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
558 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
560 (ert-deftest test-org-element
/block-switches
()
561 "Test `example-block' and `src-block' switches parsing."
562 (let ((org-coderef-label-format "(ref:%s)"))
563 ;; 1. Test "-i" switch.
565 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
566 (org-element-property :preserve-indent
(org-element-at-point))))
568 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
569 (org-element-property :preserve-indent
(org-element-at-point))))
571 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
572 (org-element-property :preserve-indent
(org-element-at-point))))
574 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
575 (org-element-property :preserve-indent
(org-element-at-point))))
576 ;; 2. "-n -r -k" combination should number lines, retain labels but
577 ;; not use them in coderefs.
579 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
580 (let ((element (org-element-at-point)))
581 (and (org-element-property :number-lines element
)
582 (org-element-property :retain-labels element
)
583 (not (org-element-property :use-labels element
))))))
585 (org-test-with-temp-text
586 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
587 (let ((element (org-element-at-point)))
588 (and (org-element-property :number-lines element
)
589 (org-element-property :retain-labels element
)
590 (not (org-element-property :use-labels element
))))))
591 ;; 3. "-n -r" combination should number-lines remove labels and not
592 ;; use them in coderefs.
594 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
595 (let ((element (org-element-at-point)))
596 (and (org-element-property :number-lines element
)
597 (not (org-element-property :retain-labels element
))
598 (not (org-element-property :use-labels element
))))))
600 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
601 (let ((element (org-element-at-point)))
602 (and (org-element-property :number-lines element
)
603 (not (org-element-property :retain-labels element
))
604 (not (org-element-property :use-labels element
))))))
605 ;; 4. "-n" or "+n" should number lines, retain labels and use them
608 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
609 (let ((element (org-element-at-point)))
610 (and (org-element-property :number-lines element
)
611 (org-element-property :retain-labels element
)
612 (org-element-property :use-labels element
)))))
614 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
615 (let ((element (org-element-at-point)))
616 (and (org-element-property :number-lines element
)
617 (org-element-property :retain-labels element
)
618 (org-element-property :use-labels element
)))))
620 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
621 (let ((element (org-element-at-point)))
622 (and (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\n(+ 1 1)\n#+END_SRC"
627 (let ((element (org-element-at-point)))
628 (and (org-element-property :number-lines element
)
629 (org-element-property :retain-labels element
)
630 (org-element-property :use-labels element
)))))
631 ;; 5. No switch should not number lines, but retain labels and use
634 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
635 (let ((element (org-element-at-point)))
636 (and (not (org-element-property :number-lines element
))
637 (org-element-property :retain-labels element
)
638 (org-element-property :use-labels element
)))))
640 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
641 (let ((element (org-element-at-point)))
642 (and (not (org-element-property :number-lines element
))
643 (org-element-property :retain-labels element
)
644 (org-element-property :use-labels element
)))))
645 ;; 6. "-r" switch only: do not number lines, remove labels, and
646 ;; don't use labels in coderefs.
648 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
649 (let ((element (org-element-at-point)))
650 (and (not (org-element-property :number-lines element
))
651 (not (org-element-property :retain-labels element
))
652 (not (org-element-property :use-labels element
))))))
654 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
655 (let ((element (org-element-at-point)))
656 (and (not (org-element-property :number-lines element
))
657 (not (org-element-property :retain-labels element
))
658 (not (org-element-property :use-labels element
))))))
659 ;; 7. Recognize coderefs with user-defined syntax.
663 (org-test-with-temp-text
664 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
665 (org-element-property :label-fmt
(org-element-at-point)))))
669 (org-test-with-temp-text
670 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
671 (org-element-property :label-fmt
(org-element-at-point)))))))
676 (ert-deftest test-org-element
/export-block-parser
()
677 "Test `export-block' parser."
680 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
682 (let ((org-element-block-name-alist
683 '(("LATEX" . org-element-export-block-parser
))))
684 (org-element-parse-buffer))
685 'export-block
'identity
)))
688 (let ((org-element-block-name-alist
689 '(("LATEX" . org-element-export-block-parser
))))
690 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
691 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
692 ;; Ignore incomplete block.
694 (let ((org-element-block-name-alist
695 '(("LATEX" . org-element-export-block-parser
))))
696 (org-test-with-temp-text "#+BEGIN_LATEX"
697 (org-element-map (org-element-parse-buffer) 'export-block
699 ;; Handle non-empty blank line at the end of buffer.
701 (let ((org-element-block-name-alist
702 '(("LATEX" . org-element-export-block-parser
))))
703 (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
704 (= (org-element-property :end
(org-element-at-point)) (point-max))))))
709 (ert-deftest test-org-element
/export-snippet-parser
()
710 "Test `export-snippet' parser."
713 '("back-end" .
"contents")
714 (org-test-with-temp-text "@@back-end:contents@@"
716 (org-element-parse-buffer) 'export-snippet
717 (lambda (snippet) (cons (org-element-property :back-end snippet
)
718 (org-element-property :value snippet
)))
724 (ert-deftest test-org-element
/fixed-width-parser
()
725 "Test fixed-width area parsing."
726 ;; Preserve indentation.
728 (org-test-with-temp-text ": no blank\n: one blank"
729 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
730 ;; Fixed-width with empty lines.
732 (org-test-with-temp-text ": first part\n:\n: \n: second part"
733 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
734 ;; Parse indented fixed-width markers.
736 (org-test-with-temp-text "Text\n : no blank\n : one blank"
737 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
738 ;; Distinguish fixed-width areas within a list and outside of it.
742 (org-test-with-temp-text "
745 : fixed-width outside"
746 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
747 ;; Handle non-empty blank line at the end of buffer.
749 (org-test-with-temp-text ": A\n "
750 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
753 ;;;; Footnote Definition
755 (ert-deftest test-org-element
/footnote-definition-parser
()
756 "Test `footnote-definition' parser."
758 (org-test-with-temp-text "[fn:1] Definition"
759 (org-element-map (org-element-parse-buffer) 'footnote-definition
761 ;; Footnote with more contents
764 (org-element-property
766 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
767 (org-element-map (org-element-parse-buffer) 'footnote-definition
769 ;; Footnote starting with special syntax.
771 (org-test-with-temp-text "[fn:1] - no item"
772 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
773 ;; Correctly handle footnote starting with an empty line.
776 (org-test-with-temp-text "[fn:1]\n\n Body"
777 (org-element-property :contents-begin
(org-element-at-point)))))
778 ;; Handle non-empty blank line at the end of buffer.
780 (org-test-with-temp-text "[fn:1] Definition\n "
781 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
784 ;;;; Footnotes Reference.
786 (ert-deftest test-org-element
/footnote-reference-parser
()
787 "Test `footnote-reference' parser."
788 ;; 1. Parse a standard reference.
789 (org-test-with-temp-text "Text[fn:label]"
792 (org-element-parse-buffer) 'footnote-reference
'identity
)))
793 ;; 2. Parse a normalized reference.
794 (org-test-with-temp-text "Text[1]"
797 (org-element-parse-buffer) 'footnote-reference
'identity
)))
798 ;; 3. Parse an inline reference.
799 (org-test-with-temp-text "Text[fn:test:def]"
802 (org-element-parse-buffer) 'footnote-reference
'identity
)))
803 ;; 4. Parse an anonymous reference.
804 (org-test-with-temp-text "Text[fn::def]"
807 (org-element-parse-buffer) 'footnote-reference
'identity
)))
808 ;; 5. Parse nested footnotes.
809 (org-test-with-temp-text "Text[fn::def [fn:label]]"
814 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
815 ;; 6. Parse adjacent footnotes.
816 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
821 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
822 ;; 7. Only properly closed footnotes are recognized as such.
823 (org-test-with-temp-text "Text[fn:label"
826 (org-element-parse-buffer) 'footnote-reference
'identity
))))
831 (ert-deftest test-org-element
/headline-quote-keyword
()
832 "Test QUOTE keyword recognition."
834 (org-test-with-temp-text "* Headline"
835 (let ((org-quote-string "QUOTE"))
836 (should-not (org-element-property :quotedp
(org-element-at-point)))))
837 ;; Standard position.
838 (org-test-with-temp-text "* QUOTE Headline"
839 (let* ((org-quote-string "QUOTE")
840 (headline (org-element-at-point)))
841 (should (org-element-property :quotedp headline
))
842 ;; Test removal from raw value.
843 (should (equal (org-element-property :raw-value headline
) "Headline"))))
845 (org-test-with-temp-text "* QUOTE Headline"
846 (let* ((org-quote-string "Quote")
847 (headline (org-element-at-point)))
848 (should-not (org-element-property :quotedp headline
))
849 (should (equal (org-element-property :raw-value headline
)
851 ;; With another keyword.
852 (org-test-with-temp-text "* TODO QUOTE Headline"
853 (let* ((org-quote-string "QUOTE")
854 (org-todo-keywords '((sequence "TODO" "DONE")))
855 (headline (org-element-at-point)))
856 (should (org-element-property :quotedp headline
))
857 (should (equal (org-element-property :raw-value headline
) "Headline"))))
858 ;; With the keyword only.
859 (org-test-with-temp-text "* QUOTE"
860 (let* ((org-quote-string "QUOTE")
861 (headline (org-element-at-point)))
862 (should (org-element-property :quotedp headline
))
863 (should (equal (org-element-property :raw-value headline
) "")))))
865 (ert-deftest test-org-element
/headline-comment-keyword
()
866 "Test COMMENT keyword recognition."
868 (org-test-with-temp-text "* Headline"
869 (let ((org-comment-string "COMMENT"))
870 (should-not (org-element-property :commentedp
(org-element-at-point)))))
871 ;; Standard position.
872 (org-test-with-temp-text "* COMMENT Headline"
873 (let ((org-comment-string "COMMENT")
874 (headline (org-element-at-point)))
875 (should (org-element-property :commentedp headline
))
876 (should (equal (org-element-property :raw-value headline
) "Headline"))))
878 (org-test-with-temp-text "* COMMENT Headline"
879 (let* ((org-comment-string "Comment")
880 (headline (org-element-at-point)))
881 (should-not (org-element-property :commentedp headline
))
882 (should (equal (org-element-property :raw-value headline
)
883 "COMMENT Headline"))))
884 ;; With another keyword.
885 (org-test-with-temp-text "* TODO COMMENT Headline"
886 (let* ((org-comment-string "COMMENT")
887 (org-todo-keywords '((sequence "TODO" "DONE")))
888 (headline (org-element-at-point)))
889 (should (org-element-property :commentedp headline
))
890 (should (equal (org-element-property :raw-value headline
) "Headline"))))
891 ;; With the keyword only.
892 (org-test-with-temp-text "* COMMENT"
893 (let* ((org-comment-string "COMMENT")
894 (headline (org-element-at-point)))
895 (should (org-element-property :commentedp headline
))
896 (should (equal (org-element-property :raw-value headline
) "")))))
898 (ert-deftest test-org-element
/headline-archive-tag
()
899 "Test ARCHIVE tag recognition."
902 (org-test-with-temp-text "* Headline"
903 (let ((org-archive-tag "ARCHIVE"))
904 (org-element-property :archivedp
(org-element-at-point)))))
906 (org-test-with-temp-text "* Headline :ARCHIVE:"
907 (let ((org-archive-tag "ARCHIVE"))
908 (let ((headline (org-element-at-point)))
909 (should (org-element-property :archivedp headline
))
911 (should-not (org-element-property :tags headline
)))))
913 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
914 (let ((org-archive-tag "ARCHIVE"))
915 (let ((headline (org-element-at-point)))
916 (should (org-element-property :archivedp headline
))
918 (should (equal (org-element-property :tags headline
) '("test"))))))
919 ;; Tag is case-sensitive.
921 (org-test-with-temp-text "* Headline :ARCHIVE:"
922 (let ((org-archive-tag "Archive"))
923 (org-element-property :archivedp
(org-element-at-point))))))
925 (ert-deftest test-org-element
/headline-properties
()
926 "Test properties from property drawer."
927 ;; All properties from property drawer have their symbol upper
930 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
931 (org-element-property :FOO
(org-element-at-point))))
933 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
934 (org-element-property :foo
(org-element-at-point)))))
939 (ert-deftest test-org-element
/horizontal-rule-parser
()
940 "Test `horizontal-rule' parser."
943 (org-test-with-temp-text "-----"
944 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
947 (org-test-with-temp-text " -----"
948 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
949 ;; Hyphen must be alone on the line.
951 (org-test-with-temp-text "-----wrong"
952 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
953 ;; 4 hyphens is too small.
955 (org-test-with-temp-text "----"
956 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
957 ;; Handle non-empty blank line at the end of buffer.
959 (org-test-with-temp-text "-----\n "
960 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
963 ;;;; Inline Babel Call
965 (ert-deftest test-org-element
/inline-babel-call-parser
()
966 "Test `inline-babel-call' parser."
968 (org-test-with-temp-text "call_test()"
970 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
973 ;;;; Inline Src Block
975 (ert-deftest test-org-element
/inline-src-block-parser
()
976 "Test `inline-src-block' parser."
978 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
979 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
980 ;; Test parsing at the beginning of an item.
982 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
983 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
988 (ert-deftest test-org-element
/inlinetask-parser
()
989 "Test `inlinetask' parser."
990 (when (featurep 'org-inlinetask
)
991 (let ((org-inlinetask-min-level 15))
992 ;; 1. Regular inlinetask.
994 (org-test-with-temp-text
995 "*************** Task\nTest\n*************** END"
996 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
997 ;; 2. Degenerate inlinetask.
999 (org-test-with-temp-text "*************** Task"
1000 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity
)))
1005 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1006 (org-test-with-temp-text "*************** TODO Task"
1007 (org-element-property
1009 (org-element-map (org-element-parse-buffer) 'inlinetask
1010 'identity nil t
))))))
1015 (org-test-with-temp-text "
1016 *************** Task
1017 DEADLINE: <2012-03-29 thu.>"
1018 (org-element-property
1020 (org-element-map (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1025 (org-test-with-temp-text "
1026 *************** [#A] Task"
1027 (org-element-property
1030 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1035 (org-test-with-temp-text "
1036 *************** Task :test:"
1037 (org-element-property
1040 (org-element-parse-buffer) 'inlinetask
'identity nil t
)))))
1041 ;; Regular properties are accessed through upper case keywords.
1043 (org-test-with-temp-text "
1044 *************** Task
1048 *************** END"
1050 (org-element-property :FOO
(org-element-at-point))))
1052 (org-test-with-temp-text "
1053 *************** Task
1057 *************** END"
1059 (org-element-property :foo
(org-element-at-point))))
1060 ;; Handle non-empty blank line at the end of buffer.
1062 (org-test-with-temp-text "*************** Task\n*************** END\n "
1063 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1068 (ert-deftest test-org-element
/italic-parser
()
1069 "Test `italic' parser."
1072 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1073 (org-test-with-temp-text "/italic/"
1074 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1075 ;; Multi-line markup.
1078 (org-element-contents
1079 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1080 (org-test-with-temp-text "/first line\nsecond line/"
1081 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1082 '("first line\nsecond line"))))
1087 (ert-deftest test-org-element
/item-parser
()
1088 "Test `item' parser."
1091 (org-test-with-temp-text "- item"
1092 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1096 (org-element-property
1098 (org-test-with-temp-text "6. [@6] item"
1099 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1104 (org-element-property
1106 (org-test-with-temp-text "- tag :: description"
1107 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1108 ;; No tags in ordered lists.
1110 (org-element-property
1112 (org-test-with-temp-text "1. tag :: description"
1113 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1118 (org-test-with-temp-text "
1123 (org-element-parse-buffer) 'item
1124 (lambda (item) (org-element-property :checkbox item
))))))
1125 ;; Item starting with special syntax.
1127 (equal '(("- item"))
1128 (org-test-with-temp-text "- - item"
1129 (org-element-map (org-element-parse-buffer) 'paragraph
1130 'org-element-contents
))))
1131 ;; Block in an item: ignore indentation within the block.
1133 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1135 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1140 (ert-deftest test-org-element
/keyword-parser
()
1141 "Test `keyword' parser."
1144 (org-test-with-temp-text "#+KEYWORD: value"
1145 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1146 ;; Keywords are case-insensitive.
1148 (org-test-with-temp-text "#+keyword: value"
1149 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1150 ;; Affiliated keywords are not keywords.
1152 (org-test-with-temp-text "#+NAME: value
1154 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1155 ;; Do not mix keywords with Babel calls and dynamic blocks.
1157 (org-test-with-temp-text "#+CALL: fun()"
1158 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1160 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1161 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1162 ;; Handle non-empty blank line at the end of buffer.
1164 (org-test-with-temp-text "#+KEYWORD: value\n "
1165 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1168 ;;;; Latex Environment
1170 (ert-deftest test-org-element
/latex-environment-parser
()
1171 "Test `latex-environment' parser."
1173 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1174 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1175 ;; Allow nested environments.
1183 (org-test-with-temp-text "
1189 (org-element-property
1192 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1193 ;; Allow environments with options and arguments.
1195 (eq 'latex-environment
1196 (org-test-with-temp-text
1197 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1198 (org-element-type (org-element-at-point)))))
1200 (eq 'latex-environment
1201 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1202 (org-element-type (org-element-at-point)))))
1204 (eq 'latex-environment
1205 (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1206 (org-element-type (org-element-at-point)))))
1207 ;; Handle non-empty blank line at the end of buffer.
1209 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1210 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1215 (ert-deftest test-org-element
/latex-fragment-parser
()
1216 "Test `latex-fragment' parser."
1218 (org-test-with-temp-text "$a$"
1219 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1221 (org-test-with-temp-text "$$a$$"
1222 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1224 (org-test-with-temp-text "\\(a\\)"
1225 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1227 (org-test-with-temp-text "\\[a\\]"
1229 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1230 ;; Test fragment at the beginning of an item.
1233 (org-test-with-temp-text "- $x$"
1234 (progn (search-forward "$")
1235 (org-element-type (org-element-context)))))))
1240 (ert-deftest test-org-element
/line-break-parser
()
1241 "Test `line-break' parser."
1244 (org-test-with-temp-text "Text \\\\"
1245 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1246 ;; Line break with trailing white spaces.
1248 (org-test-with-temp-text "Text \\\\ "
1249 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1250 ;; Three backslashes are too much.
1252 (org-test-with-temp-text "Text \\\\\\"
1253 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1258 (ert-deftest test-org-element
/link-parser
()
1259 "Test `link' parser."
1264 (org-test-with-temp-text "A radio link"
1265 (org-element-property
1268 (let ((org-target-link-regexp "radio")) (org-element-parse-buffer))
1269 'link
'identity nil t
)))))
1272 ;; ... with description.
1276 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1277 (org-element-contents
1278 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1279 ;; ... without description.
1283 (org-test-with-temp-text "[[http://orgmode.org]]"
1284 (org-element-property
1286 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1287 ;; ... with expansion.
1290 "//orgmode.org/worg"
1291 (org-test-with-temp-text "[[Org:worg]]"
1292 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1293 (org-element-property
1295 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1296 ;; ... with translation.
1300 (org-test-with-temp-text "[[http://orgmode.org]]"
1301 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1302 (let ((org-link-translation-function 'link-translate
))
1303 (org-element-property
1305 (org-element-map (org-element-parse-buffer) 'link
1306 'identity nil t
)))))))
1311 (org-test-with-temp-text "[[id:aaaa]]"
1312 (org-element-property
1314 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1315 ;; ... custom-id link.
1319 (org-test-with-temp-text "[[#some-id]]"
1320 (org-element-property
1322 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1323 ;; ... coderef link.
1327 (org-test-with-temp-text "[[(reference)]]"
1328 (org-element-property
1330 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1335 (org-test-with-temp-text "[[target-or-title]]"
1336 (org-element-property
1338 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1339 ;; ... file-type link with search option.
1342 '(("file" "projects.org" "*task title"))
1343 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1344 (org-element-map (org-element-parse-buffer) 'link
1345 (lambda (l) (list (org-element-property :type l
)
1346 (org-element-property :path l
)
1347 (org-element-property :search-option l
)))))))
1348 ;; ... file-type link with application.
1351 '(("file" "projects.org" "docview"))
1352 (org-test-with-temp-text "[[docview:projects.org]]"
1353 (org-element-map (org-element-parse-buffer) 'link
1354 (lambda (l) (list (org-element-property :type l
)
1355 (org-element-property :path l
)
1356 (org-element-property :application l
)))))))
1359 (org-test-with-temp-text "A link: http://orgmode.org"
1360 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1363 (org-test-with-temp-text "A link: <http://orgmode.org>"
1364 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1365 ;; Link abbreviation.
1368 (org-test-with-temp-text
1369 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1370 (progn (org-mode-restart)
1371 (goto-char (1- (point-max)))
1372 (org-element-property :type
(org-element-context))))))
1373 ;; Link abbreviation in a secondary string.
1376 (org-test-with-temp-text
1377 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1378 (progn (org-mode-restart)
1379 (org-element-map (org-element-parse-buffer) 'link
1380 (lambda (link) (org-element-property :type link
))
1382 ;; Plain links are allowed as description of regular links.
1385 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1386 (search-forward "file:")
1387 (org-element-property :type
(org-element-context))))))
1392 (ert-deftest test-org-element
/macro-parser
()
1393 "Test `macro' parser."
1394 ;; Without arguments.
1396 (org-test-with-temp-text "{{{macro}}}"
1397 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1400 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1401 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1402 ;; Properly handle protected commas in arguments...
1406 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1407 (org-element-property :args
(org-element-context))))))
1408 ;; ... even when last argument ends with a protected comma.
1411 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1412 (org-element-property :args
(org-element-context)))))
1413 ;; Allow to escape escaping character.
1416 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1417 (org-element-property :args
(org-element-context)))))
1418 ;; No need to escape backslashes elsewhere.
1421 (org-test-with-temp-text "{{{macro(\\)}}}"
1422 (org-element-property :args
(org-element-context))))))
1427 (ert-deftest test-org-element
/node-property
()
1428 "Test `node-property' parser."
1431 (equal '("abc" "value")
1432 (org-test-with-temp-text ":PROPERTIES:\n:abc: value\n:END:"
1433 (progn (forward-line)
1434 (let ((element (org-element-at-point)))
1435 (list (org-element-property :key element
)
1436 (org-element-property :value element
)))))))
1437 ;; Value should be trimmed.
1440 (org-test-with-temp-text ":PROPERTIES:\n:abc: value \n:END:"
1441 (progn (forward-line)
1442 (let ((element (org-element-at-point)))
1443 (org-element-property :value element
))))))
1444 ;; A node property requires to be wrapped within a property drawer.
1447 (org-test-with-temp-text ":abc: value"
1448 (org-element-type (org-element-at-point))))))
1453 (ert-deftest test-org-element
/paragraph-parser
()
1454 "Test `paragraph' parser."
1457 (org-test-with-temp-text "Paragraph"
1458 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1459 ;; Property find end of a paragraph stuck to another element.
1462 (org-test-with-temp-text "Paragraph\n# Comment"
1463 (org-element-map (org-element-parse-buffer) 'paragraph
1464 (lambda (p) (char-after (org-element-property :end p
)))
1466 ;; Include ill-formed Keywords.
1468 (org-test-with-temp-text "#+wrong_keyword something"
1469 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1470 ;; Include incomplete-drawers.
1472 (org-test-with-temp-text ":TEST:\nParagraph"
1473 (let ((elem (org-element-at-point)))
1474 (and (eq (org-element-type elem
) 'paragraph
)
1475 (= (point-max) (org-element-property :end elem
))))))
1476 ;; Include incomplete blocks.
1478 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1479 (let ((elem (org-element-at-point)))
1480 (and (eq (org-element-type elem
) 'paragraph
)
1481 (= (point-max) (org-element-property :end elem
))))))
1482 ;; Include incomplete dynamic blocks.
1484 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1485 (let ((elem (org-element-at-point)))
1486 (and (eq (org-element-type elem
) 'paragraph
)
1487 (= (point-max) (org-element-property :end elem
))))))
1488 ;; Include incomplete latex environments.
1490 (org-test-with-temp-text "\begin{equation}\nParagraph"
1491 (let ((elem (org-element-at-point)))
1492 (and (eq (org-element-type elem
) 'paragraph
)
1493 (= (point-max) (org-element-property :end elem
))))))
1494 ;; Do not steal affiliated keywords from container.
1496 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1497 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1498 (and (eq (org-element-type elem
) 'paragraph
)
1499 (not (org-element-property :attr_latex elem
))
1500 (/= (org-element-property :begin elem
) 1)))))
1501 ;; Handle non-empty blank line at the end of buffer.
1503 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1504 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1509 (ert-deftest test-org-element
/plain-list-parser
()
1510 "Test `plain-list' parser."
1511 (org-test-with-temp-text "- item"
1512 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1513 ;; Blank lines after the list only belong to outer plain list.
1517 (org-test-with-temp-text "
1522 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1523 (lambda (pl) (org-element-property :end pl
)))))
1525 ;; Move to ending of outer list.
1526 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1527 ;; Move to ending of inner list.
1528 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1529 ;; Correctly compute end of list if it doesn't end at a line
1532 (org-test-with-temp-text "- list\n \n "
1533 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1538 (ert-deftest test-org-element
/planning-parser
()
1539 "Test `planning' parser."
1541 (equal "[2012-03-29 thu.]"
1542 (org-element-property
1544 (org-element-property
1546 (org-test-with-temp-text "CLOSED: [2012-03-29 thu.]"
1547 (org-element-at-point))))))
1549 (equal "<2012-03-29 thu.>"
1550 (org-element-property
1552 (org-element-property
1554 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1555 (org-element-at-point))))))
1557 (equal "<2012-03-29 thu.>"
1558 (org-element-property
1560 (org-element-property
1562 (org-test-with-temp-text "SCHEDULED: <2012-03-29 thu.>"
1563 (org-element-at-point)))))))
1566 ;;;; Property Drawer
1568 (ert-deftest test-org-element
/property-drawer-parser
()
1569 "Test `property-drawer' parser."
1572 (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
1574 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1575 ;; Do not mix property drawers and regular drawers.
1577 (org-test-with-temp-text ":TEST:\n:prop: value\n:END:"
1579 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1580 ;; Ignore incomplete drawer.
1582 (org-test-with-temp-text ":PROPERTIES:\n:prop: value"
1584 (org-element-parse-buffer) 'property-drawer
'identity nil t
)))
1585 ;; Handle non-empty blank line at the end of buffer.
1587 (org-test-with-temp-text ":PROPERTIES:\n:END:\n "
1588 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1593 (ert-deftest test-org-element
/quote-block-parser
()
1594 "Test `quote-block' parser."
1597 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1598 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1599 ;; Ignore incomplete block.
1601 (org-test-with-temp-text "#+BEGIN_QUOTE"
1602 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1603 ;; Handle non-empty blank line at the end of buffer.
1605 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1606 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1611 (ert-deftest test-org-element
/quote-section-parser
()
1612 "Test `quote-section' parser."
1614 (let ((org-quote-string "QUOTE"))
1615 (org-test-with-temp-text "* QUOTE Headline\nBody"
1616 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
))))
1618 (let ((org-quote-string "TEST"))
1619 (org-test-with-temp-text "* QUOTE Headline\nBody"
1620 (org-element-map (org-element-parse-buffer) 'quote-section
'identity
)))))
1625 (ert-deftest test-org-element
/radio-target-parser
()
1626 "Test `radio-target' parser."
1629 (org-test-with-temp-text "<<<radio>>>"
1630 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
)))
1631 ;; Radio targets with objects.
1633 (org-test-with-temp-text "<<<radio \\alpha>>>"
1634 (org-element-map (org-element-parse-buffer) 'radio-target
'identity
))))
1639 (ert-deftest test-org-element
/section-parser
()
1640 "Test `section' parser."
1643 (org-test-with-temp-text "* Headline\nText"
1644 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1645 ;; There's a section before the first headline.
1647 (org-test-with-temp-text "Text"
1648 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1649 ;; A section cannot be empty.
1651 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1652 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1653 ;; A section doesn't contain sub-trees.
1655 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1657 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1658 'headline
'identity
))))
1663 (ert-deftest test-org-element
/special-block-parser
()
1664 "Test `special-block' parser."
1668 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1669 (org-element-property :type
(org-element-at-point)))))
1670 ;; Special blocks can contain paragraphs.
1673 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1675 (org-element-type (org-element-at-point)))))
1676 ;; Ignore incomplete block.
1679 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1680 (org-element-type (org-element-at-point)))))
1681 ;; Allow special characters in type.
1683 (equal '(special-block "SPECIAL*")
1684 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1685 (let ((element (org-element-at-point)))
1686 (list (org-element-type element
)
1687 (org-element-property :type element
))))))
1688 ;; Handle non-empty blank line at the end of buffer.
1690 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1691 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1696 (ert-deftest test-org-element
/src-block-parser
()
1697 "Test `src-block' parser."
1700 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1701 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1702 ;; Ignore incomplete block.
1704 (org-test-with-temp-text "#+BEGIN_SRC"
1705 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1706 ;; Properly un-escape code.
1708 (equal "* Headline\n #+keyword\nText\n"
1709 (org-test-with-temp-text
1710 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1711 (org-element-property :value
(org-element-at-point)))))
1712 ;; Remove block indentation according to block boundaries, unless
1713 ;; block contents are less indented than block boundaries.
1716 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1717 (let ((org-src-preserve-indentation t
))
1718 (org-element-property :value
(org-element-at-point))))))
1722 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1723 (let ((org-src-preserve-indentation t
))
1724 (org-element-property :value
(org-element-at-point))))))
1725 ;; Handle non-empty blank line at the end of buffer.
1727 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
1728 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1731 ;;;; Statistics Cookie
1733 (ert-deftest test-org-element
/statistics-cookie
()
1734 "Test `statistics-cookie' parser."
1737 (org-test-with-temp-text "[1/2]"
1738 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1741 (org-test-with-temp-text "[33%]"
1743 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1748 (ert-deftest test-org-element
/strike-through-parser
()
1749 "Test `strike-through' parser."
1752 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1753 (org-test-with-temp-text "+strike-through+"
1754 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1755 ;; Multi-line markup.
1758 (org-element-contents
1759 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1760 (org-test-with-temp-text "+first line\nsecond line+"
1762 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1763 '("first line\nsecond line"))))
1768 (ert-deftest test-org-element
/subscript-parser
()
1769 "Test `subscript' parser."
1772 (org-test-with-temp-text "a_b"
1773 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1776 (org-test-with-temp-text "a_{b}"
1777 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1778 ;; Multiple subscripts in a paragraph.
1781 (org-test-with-temp-text "a_b and c_d"
1783 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1788 (ert-deftest test-org-element
/superscript-parser
()
1789 "Test `superscript' parser."
1792 (org-test-with-temp-text "a^b"
1793 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1796 (org-test-with-temp-text "a^{b}"
1797 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
1798 ;; Multiple superscript in a paragraph.
1801 (org-test-with-temp-text "a^b and c^d"
1804 (org-element-parse-buffer) 'superscript
'identity
))))))
1809 (ert-deftest test-org-element
/table-parser
()
1810 "Test `table' parser."
1812 (org-test-with-temp-text "| a |"
1813 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
1814 ;; TBLFM keyword is case insensitive.
1816 (org-test-with-temp-text "| a |\n#+tblfm: test"
1817 (org-element-property
1819 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
1820 ;; Handle multiple TBLFM lines.
1823 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
1824 (length (org-element-property
1827 (org-element-parse-buffer) 'table
'identity nil t
))))))
1828 ;; Handle non-empty blank line at the end of buffer.
1830 (org-test-with-temp-text "| a |\n "
1831 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1836 (ert-deftest test-org-element
/table-cell-parser
()
1837 "Test `table-cell' parser."
1839 (org-test-with-temp-text "| a |"
1840 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
1845 (ert-deftest test-org-element
/table-row-parser
()
1846 "Test `table-row' parser."
1848 (equal '(standard rule
)
1849 (org-test-with-temp-text "| a |\n|---|"
1851 (org-element-parse-buffer) 'table-row
1852 (lambda (row) (org-element-property :type row
)))))))
1857 (ert-deftest test-org-element
/target-parser
()
1858 "Test `target' parser."
1860 (org-test-with-temp-text "<<target>>"
1861 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
1866 (ert-deftest test-org-element
/timestamp
()
1867 "Test `timestamp' parser."
1868 ;; Active timestamp.
1870 (org-test-with-temp-text "<2012-03-29 16:40>"
1871 (eq (org-element-property :type
(org-element-context)) 'active
)))
1873 (org-test-with-temp-text "<2012-03-29 Thu>"
1874 (let ((timestamp (org-element-context)))
1875 (or (org-element-property :hour-start timestamp
)
1876 (org-element-property :minute-start timestamp
)))))
1878 (equal '(2012 3 29 16 40)
1879 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
1880 (let ((object (org-element-context)))
1881 (list (org-element-property :year-start object
)
1882 (org-element-property :month-start object
)
1883 (org-element-property :day-start object
)
1884 (org-element-property :hour-start object
)
1885 (org-element-property :minute-start object
))))))
1886 ;; Inactive timestamp.
1888 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
1889 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
1892 (equal '(2012 3 29 16 40 7 30)
1893 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1894 (let ((object (org-element-context)))
1895 (list (org-element-property :year-end object
)
1896 (org-element-property :month-end object
)
1897 (org-element-property :day-end object
)
1898 (org-element-property :hour-end object
)
1899 (org-element-property :minute-end object
)
1900 (org-element-property :hour-start object
)
1901 (org-element-property :minute-start object
))))))
1904 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
1905 (org-element-property :type
(org-element-context)))))
1908 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
1909 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
1911 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
1912 (let ((timestamp (org-element-context)))
1913 (or (org-element-property :hour-end timestamp
)
1914 (org-element-property :minute-end timestamp
)))))
1915 ;; With repeater, warning delay and both.
1918 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
1919 (org-element-property :repeater-type
(org-element-context)))))
1922 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
1923 (org-element-property :warning-type
(org-element-context)))))
1925 (equal '(cumulate all
)
1926 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
1927 (let ((ts (org-element-context)))
1928 (list (org-element-property :repeater-type ts
)
1929 (org-element-property :warning-type ts
))))))
1930 ;; Timestamps are not planning elements.
1932 (org-test-with-temp-text "SCHEDULED: <2012-03-29 Thu 16:40>"
1933 (org-element-map (org-element-parse-buffer) 'timestamp
'identity
))))
1938 (ert-deftest test-org-element
/underline-parser
()
1939 "Test `underline' parser."
1942 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1943 (org-test-with-temp-text "_underline_"
1944 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
1945 ;; Multi-line markup.
1948 (org-element-contents
1949 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1950 (org-test-with-temp-text "_first line\nsecond line_"
1952 (org-element-parse-buffer) 'underline
'identity nil t
))))
1953 '("first line\nsecond line"))))
1958 (ert-deftest test-org-element
/verbatim-parser
()
1959 "Test `verbatim' parser."
1962 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1963 (org-test-with-temp-text "=verbatim="
1964 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
1965 ;; Multi-line markup.
1968 (org-element-property
1970 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1971 (org-test-with-temp-text "=first line\nsecond line="
1973 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
1974 "first line\nsecond line")))
1979 (ert-deftest test-org-element
/verse-block-parser
()
1980 "Test `verse-block' parser."
1983 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
1984 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1987 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
1988 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
1989 ;; Parse objects in verse blocks.
1991 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
1992 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
1993 ;; Ignore incomplete verse block.
1995 (org-test-with-temp-text "#+BEGIN_VERSE"
1996 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
1997 ;; Handle non-empty blank line at the end of buffer.
1999 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2000 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2004 ;;; Test Interpreters.
2006 (ert-deftest test-org-element
/interpret-data
()
2007 "Test `org-element-interpret-data' specifications."
2008 ;; Interpret simple affiliated keywords.
2011 (org-element-interpret-data
2012 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2013 "#+NAME: para\nParagraph\n"))
2014 ;; Interpret multiple affiliated keywords.
2017 (org-element-interpret-data
2018 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2019 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2020 ;; Interpret parsed affiliated keywords.
2023 (org-element-interpret-data
2024 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2025 "#+CAPTION: caption\nParagraph\n"))
2026 ;; Interpret dual affiliated keywords.
2029 (org-element-interpret-data
2030 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2031 "#+CAPTION[short]: long\nParagraph\n"))
2032 ;; Interpret multiple parsed dual keywords.
2035 (org-element-interpret-data
2036 '(org-data nil
(paragraph
2037 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2038 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2039 ;; Pseudo objects and elements are transparent.
2042 (org-element-interpret-data
2043 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")
2047 (org-element-interpret-data
2049 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2050 (paragraph nil
"B"))))))
2052 (ert-deftest test-org-element
/center-block-interpreter
()
2053 "Test center block interpreter."
2055 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2056 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2058 (ert-deftest test-org-element
/drawer-interpreter
()
2059 "Test drawer interpreter."
2061 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2062 ":TEST:\nTest\n:END:\n")))
2064 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2065 "Test dynamic block interpreter."
2067 (equal (org-test-parse-and-interpret
2068 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2069 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2071 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2072 "Test footnote definition interpreter."
2073 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2075 (ert-deftest test-org-element
/headline-interpreter
()
2076 "Test headline and section interpreters."
2077 ;; 1. Standard test.
2078 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2079 ;; 2. With TODO keywords.
2081 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2082 (org-test-parse-and-interpret "* TODO Headline"))
2083 "* TODO Headline\n"))
2086 ;; 3.1. ... and a positive `org-tags-column' value.
2088 (equal (let ((org-tags-column 20))
2089 (org-test-parse-and-interpret "* Headline :tag:"))
2090 "* Headline :tag:\n"))
2091 ;; 3.2. ... and a negative `org-tags-column' value.
2093 (equal (let ((org-tags-column -
20))
2094 (org-test-parse-and-interpret "* Headline :tag:"))
2095 "* Headline :tag:\n"))
2096 ;; 3.3. ... and a null `org-tags-column' value.
2098 (equal (let ((org-tags-column 0))
2099 (org-test-parse-and-interpret "* Headline :tag:"))
2100 "* Headline :tag:\n"))
2101 ;; 4. With priority cookie.
2103 (equal (org-test-parse-and-interpret "* [#B] Headline")
2104 "* [#B] Headline\n"))
2105 ;; 5. With comment keyword.
2107 (equal (let ((org-comment-string "COMMENT"))
2108 (org-test-parse-and-interpret "* COMMENT Headline"))
2109 "* COMMENT Headline\n"))
2110 ;; 6. With quote section.
2112 (equal (let ((org-quote-string "QUOTE"))
2113 (org-test-parse-and-interpret "* QUOTE Headline"))
2114 "* QUOTE Headline\n"))
2115 ;; 7. Keep same number of blank lines before body.
2117 (equal (org-test-parse-and-interpret
2118 "* Headline\n\n\nText after two blank lines.")
2119 "* Headline\n\n\nText after two blank lines.\n")))
2121 (ert-deftest test-org-element
/inlinetask-interpreter
()
2122 "Test inlinetask interpretation."
2123 (when (featurep 'org-inlinetask
)
2124 (let ((org-inlinetask-min-level 15))
2125 ;; 1. Regular inlinetask.
2126 (should (equal (org-test-parse-and-interpret
2127 "*************** Task\nTest\n*************** END")
2128 "*************** Task\nTest\n*************** END\n"))
2129 ;; 2. Degenerate inlinetask.
2130 (should (equal (org-test-parse-and-interpret "*************** Task")
2131 "*************** Task\n"))
2132 ;; 3. Prefer degenerate form when there are no contents.
2133 (should (equal (org-test-parse-and-interpret
2134 "*************** Task\n*************** END")
2135 "*************** Task\n"))
2136 ;; 4. With TODO keywords.
2138 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2139 (org-test-parse-and-interpret "*************** TODO Task"))
2140 "*************** TODO Task\n"))
2143 ;; 5.1. ... and a positive `org-tags-column' value.
2145 (equal (let ((org-tags-column 30))
2146 (org-test-parse-and-interpret "*************** Task :tag:"))
2147 "*************** Task :tag:\n"))
2148 ;; 5.2. ... and a negative `org-tags-column' value.
2150 (equal (let ((org-tags-column -
30))
2151 (org-test-parse-and-interpret "*************** Task :tag:"))
2152 "*************** Task :tag:\n"))
2153 ;; 5.3. ... and a null `org-tags-column' value.
2155 (equal (let ((org-tags-column 0))
2156 (org-test-parse-and-interpret "*************** Task :tag:"))
2157 "*************** Task :tag:\n"))
2158 ;; 6. With priority cookie.
2160 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2161 "*************** [#B] Task\n")))))
2163 (ert-deftest test-org-element
/plain-list-interpreter
()
2164 "Test plain-list and item interpreters."
2165 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2167 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2168 ;; Description list.
2170 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2173 (equal (let ((org-plain-list-ordered-item-terminator t
))
2174 (org-test-parse-and-interpret "1. Item"))
2177 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2178 (org-test-parse-and-interpret "1) Item"))
2180 ;; Ordered list with counter.
2182 (equal (let ((org-plain-list-ordered-item-terminator t
))
2183 (org-test-parse-and-interpret "1. [@5] Item"))
2185 ;; List with check-boxes.
2187 (equal (org-test-parse-and-interpret
2188 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2189 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2190 ;; Item not starting with a paragraph.
2192 (equal (org-test-parse-and-interpret "-\n | a | b |")
2193 "- \n | a | b |\n"))
2194 ;; Special case: correctly handle "*" bullets.
2195 (should (org-test-parse-and-interpret " * item"))
2196 ;; Special case: correctly handle empty items.
2197 (should (org-test-parse-and-interpret "-"))))
2199 (ert-deftest test-org-element
/quote-block-interpreter
()
2200 "Test quote block interpreter."
2201 (should (equal (org-test-parse-and-interpret
2202 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2203 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2205 (ert-deftest test-org-element
/special-block-interpreter
()
2206 "Test special block interpreter."
2207 (should (equal (org-test-parse-and-interpret
2208 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2209 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2211 (ert-deftest test-org-element
/babel-call-interpreter
()
2212 "Test babel call interpreter."
2213 ;; 1. Without argument.
2214 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2215 "#+CALL: test()\n"))
2216 ;; 2. With argument.
2217 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2218 "#+CALL: test(x=2)\n"))
2219 ;; 3. With header arguments.
2220 (should (equal (org-test-parse-and-interpret
2221 "#+CALL: test[:results output]()[:results html]")
2222 "#+CALL: test[:results output]()[:results html]\n")))
2224 (ert-deftest test-org-element
/clock-interpreter
()
2225 "Test clock interpreter."
2229 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2230 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2234 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2235 (org-test-parse-and-interpret "
2236 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))))
2238 (ert-deftest test-org-element
/comment-interpreter
()
2239 "Test comment interpreter."
2241 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2243 (should (equal (org-test-parse-and-interpret " # Comment")
2245 ;; Preserve indentation.
2246 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2247 "# No blank\n# One blank\n")))
2249 (ert-deftest test-org-element
/comment-block-interpreter
()
2250 "Test comment block interpreter."
2251 (should (equal (org-test-parse-and-interpret
2252 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2253 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
2255 (ert-deftest test-org-element
/diary-sexp
()
2256 "Test diary-sexp interpreter."
2259 (org-test-parse-and-interpret
2260 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2261 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2263 (ert-deftest test-org-element
/example-block-interpreter
()
2264 "Test example block interpreter."
2265 ;; Without switches.
2266 (should (equal (org-test-parse-and-interpret
2267 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2268 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2271 (equal (org-test-parse-and-interpret
2272 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2273 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2274 ;; Preserve code escaping.
2276 (equal (org-test-parse-and-interpret
2277 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2278 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n")))
2280 (ert-deftest test-org-element
/export-block-interpreter
()
2281 "Test export block interpreter."
2282 (should (equal (org-test-parse-and-interpret
2283 "#+BEGIN_HTML\nTest\n#+END_HTML")
2284 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2286 (ert-deftest test-org-element
/fixed-width-interpreter
()
2287 "Test fixed width interpreter."
2289 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2290 ;; Preserve indentation.
2291 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2292 ": 2 blanks\n: 1 blank\n"))
2293 ;; Remove last newline character
2295 (equal (org-element-fixed-width-interpreter
2296 '(fixed-width (:value
"Test\n")) nil
)
2299 (equal (org-element-fixed-width-interpreter
2300 '(fixed-width (:value
"Test")) nil
)
2302 ;; Handle empty string.
2304 (equal (org-element-fixed-width-interpreter
2305 '(fixed-width (:value
"")) nil
)
2307 ;; Handle nil value.
2309 (org-element-fixed-width-interpreter
2310 '(fixed-width (:value nil
)) nil
)))
2312 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2313 "Test horizontal rule interpreter."
2314 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2316 (ert-deftest test-org-element
/keyword-interpreter
()
2317 "Test keyword interpreter."
2318 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2319 "#+KEYWORD: value\n")))
2321 (ert-deftest test-org-element
/latex-environment-interpreter
()
2322 "Test latex environment interpreter."
2323 (should (equal (org-test-parse-and-interpret
2324 "\\begin{equation}\n1+1=2\n\\end{equation}")
2325 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2326 (should (equal (org-test-parse-and-interpret
2327 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2328 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2330 (ert-deftest test-org-element
/planning-interpreter
()
2331 "Test planning interpreter."
2335 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2336 (org-test-parse-and-interpret
2338 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2340 (ert-deftest test-org-element
/property-drawer-interpreter
()
2341 "Test property drawer interpreter."
2342 (should (equal (let ((org-property-format "%-10s %s"))
2343 (org-test-parse-and-interpret
2344 ":PROPERTIES:\n:prop: value\n:END:"))
2345 ":PROPERTIES:\n:prop: value\n:END:\n")))
2347 (ert-deftest test-org-element
/src-block-interpreter
()
2348 "Test src block interpreter."
2351 (equal (let ((org-edit-src-content-indentation 2))
2352 (org-test-parse-and-interpret
2353 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2354 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2357 (equal (let ((org-edit-src-content-indentation 2))
2358 (org-test-parse-and-interpret
2359 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2360 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2361 ;; Preserve code escaping.
2363 (equal (let ((org-edit-src-content-indentation 2))
2364 (org-test-parse-and-interpret
2365 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2366 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2367 ;; Do not apply `org-edit-src-content-indentation' when preserving
2370 (equal (let ((org-edit-src-content-indentation 2)
2371 (org-src-preserve-indentation t
))
2372 (org-test-parse-and-interpret
2373 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2374 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2376 (equal (let ((org-edit-src-content-indentation 2)
2377 (org-src-preserve-indentation nil
))
2378 (org-test-parse-and-interpret
2379 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2380 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n")))
2382 (ert-deftest test-org-element
/table-interpreter
()
2383 "Test table, table-row and table-cell interpreters."
2385 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2386 "| a | b |\n| c | d |\n"))
2387 ;; 2. With horizontal rules.
2388 (should (equal (org-test-parse-and-interpret
2389 "| a | b |\n|---+---|\n| c | d |")
2390 "| a | b |\n|---+---|\n| c | d |\n"))
2391 ;; 3. With meta-data.
2392 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2393 "| / | < | > |\n| * | 1 | 2 |\n"))
2394 ;; 4. With a formula.
2396 (equal (org-test-parse-and-interpret
2397 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2398 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2399 ;; 5. With multiple formulas.
2401 (equal (org-test-parse-and-interpret
2402 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2403 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2405 (ert-deftest test-org-element
/timestamp-interpreter
()
2406 "Test timestamp interpreter."
2409 (string-match "<2012-03-29 .* 16:40>"
2410 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2412 (string-match "<2012-03-29 .* 16:40>"
2413 (org-element-timestamp-interpreter
2415 (:type active
:year-start
2012 :month-start
3 :day-start
29
2416 :hour-start
16 :minute-start
40)) nil
)))
2419 (string-match "\\[2012-03-29 .* 16:40\\]"
2420 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2423 "\\[2012-03-29 .* 16:40\\]"
2424 (org-element-timestamp-interpreter
2426 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2427 :hour-start
16 :minute-start
40)) nil
)))
2430 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2431 (org-test-parse-and-interpret
2432 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2435 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2436 (org-element-timestamp-interpreter
2438 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2439 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2440 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2443 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2444 (org-test-parse-and-interpret
2445 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2448 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2449 (org-element-timestamp-interpreter
2451 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2452 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2453 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2455 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2456 "<%%diary-float t 4 2>\n"))
2457 ;; Timestamp with repeater interval, with delay, with both.
2459 (string-match "<2012-03-29 .* \\+1y>"
2460 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2463 "<2012-03-29 .* \\+1y>"
2464 (org-element-timestamp-interpreter
2466 (:type active
:year-start
2012 :month-start
3 :day-start
29
2467 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2471 "<2012-03-29 .* -1y>"
2472 (org-element-timestamp-interpreter
2474 (:type active
:year-start
2012 :month-start
3 :day-start
29
2475 :warning-type all
:warning-value
1 :warning-unit year
))
2479 "<2012-03-29 .* \\+1y -1y>"
2480 (org-element-timestamp-interpreter
2482 (:type active
:year-start
2012 :month-start
3 :day-start
29
2483 :warning-type all
:warning-value
1 :warning-unit year
2484 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2486 ;; Timestamp range with repeater interval
2488 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2489 (org-test-parse-and-interpret
2490 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2493 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2494 (org-element-timestamp-interpreter
2496 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2497 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2498 :repeater-value
1 :repeater-unit year
))
2501 (ert-deftest test-org-element
/verse-block-interpreter
()
2502 "Test verse block interpretation."
2504 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2505 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2507 (ert-deftest test-org-element
/bold-interpreter
()
2508 "Test bold interpreter."
2509 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2511 (ert-deftest test-org-element
/code-interpreter
()
2512 "Test code interpreter."
2513 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2515 (ert-deftest test-org-element
/entity-interpreter
()
2516 "Test entity interpreter."
2517 ;; 1. Without brackets.
2519 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2520 ;; 2. With brackets.
2522 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2524 (ert-deftest test-org-element
/export-snippet-interpreter
()
2525 "Test export snippet interpreter."
2526 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2527 "@@back-end:contents@@\n")))
2529 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2530 "Test footnote reference interpreter."
2531 ;; 1. Regular reference.
2532 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2533 ;; 2. Normalized reference.
2534 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2535 ;; 3. Named reference.
2536 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2537 "Text[fn:label]\n"))
2538 ;; 4. Inline reference.
2539 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2540 "Text[fn:label:def]\n"))
2541 ;; 5. Anonymous reference.
2542 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2543 "Text[fn::def]\n")))
2545 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2546 "Test inline babel call interpreter."
2547 ;; 1. Without arguments.
2548 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2549 ;; 2. With arguments.
2550 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2551 "call_test(x=2)\n"))
2552 ;; 3. With header arguments.
2553 (should (equal (org-test-parse-and-interpret
2554 "call_test[:results output]()[:results html]")
2555 "call_test[:results output]()[:results html]\n")))
2557 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2558 "Test inline src block interpreter."
2559 ;; 1. Without header argument.
2560 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2561 "src_emacs-lisp{(+ 1 1)}\n"))
2562 ;; 2. With header arguments.
2563 (should (equal (org-test-parse-and-interpret
2564 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2565 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2567 (ert-deftest test-org-element
/italic-interpreter
()
2568 "Test italic interpreter."
2569 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2571 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2572 "Test latex fragment interpreter."
2573 (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
2574 (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
2575 (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
2576 (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
2577 (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
2578 (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
2580 (ert-deftest test-org-element
/line-break-interpreter
()
2581 "Test line break interpreter."
2582 (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
2583 "First line \\\\\nSecond line\n")))
2585 (ert-deftest test-org-element
/link-interpreter
()
2586 "Test link interpreter."
2587 ;; 1. Links targeted from a radio target.
2588 (should (equal (let ((org-target-link-regexp "radio-target"))
2589 (org-test-parse-and-interpret "a radio-target"))
2590 "a radio-target\n"))
2591 ;; 2. Regular links.
2593 ;; 2.1. Without description.
2594 (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
2595 "[[http://orgmode.org]]\n"))
2596 ;; 2.2. With a description.
2597 (should (equal (org-test-parse-and-interpret
2598 "[[http://orgmode.org][Org mode]]")
2599 "[[http://orgmode.org][Org mode]]\n"))
2601 (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
2602 ;; 2.4. Custom-id links.
2603 (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
2604 ;; 2.5 Code-ref links.
2605 (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
2606 ;; 3. Normalize plain links.
2607 (should (equal (org-test-parse-and-interpret "http://orgmode.org")
2608 "[[http://orgmode.org]]\n"))
2609 ;; 4. Normalize angular links.
2610 (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
2611 "[[http://orgmode.org]]\n")))
2613 (ert-deftest test-org-element
/macro-interpreter
()
2614 "Test macro interpreter."
2615 ;; 1. Without argument.
2616 (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
2617 ;; 2. With arguments.
2618 (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
2619 "{{{test(arg1,arg2)}}}\n")))
2621 (ert-deftest test-org-element
/radio-target-interpreter
()
2622 "Test radio target interpreter."
2623 (should (equal (org-test-parse-and-interpret "<<<some text>>>")
2624 "<<<some text>>>\n")))
2626 (ert-deftest test-org-element
/statistics-cookie-interpreter
()
2627 "Test statistics cookie interpreter."
2628 ;; 1. Without percent
2629 (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
2631 (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
2633 (ert-deftest test-org-element
/strike-through-interpreter
()
2634 "Test strike through interpreter."
2635 (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
2637 (ert-deftest test-org-element
/subscript-interpreter
()
2638 "Test subscript interpreter."
2639 ;; 1. Without brackets.
2640 (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
2641 ;; 2. With brackets.
2642 (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
2644 (ert-deftest test-org-element
/superscript-interpreter
()
2645 "Test superscript interpreter."
2646 ;; 1. Without brackets.
2647 (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
2648 ;; 2. With brackets.
2649 (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
2651 (ert-deftest test-org-element
/target-interpreter
()
2652 "Test target interpreter."
2653 (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
2655 (ert-deftest test-org-element
/underline-interpreter
()
2656 "Test underline interpreter."
2657 (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
2659 (ert-deftest test-org-element
/verbatim-interpreter
()
2660 "Test verbatim interpreter."
2661 (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
2665 ;;; Test Granularity
2667 (ert-deftest test-org-element
/granularity
()
2668 "Test granularity impact on buffer parsing."
2669 (org-test-with-temp-text "
2676 ;; 1.1. Granularity set to `headline' should parse every headline
2677 ;; in buffer, and only them.
2678 (let ((tree (org-element-parse-buffer 'headline
)))
2679 (should (= 2 (length (org-element-map tree
'headline
'identity
))))
2680 (should-not (org-element-map tree
'paragraph
'identity
)))
2681 ;; 1.2. Granularity set to `greater-element' should not enter
2682 ;; greater elements excepted headlines and sections.
2683 (let ((tree (org-element-parse-buffer 'greater-element
)))
2684 (should (= 1 (length (org-element-map tree
'center-block
'identity
))))
2685 (should (= 1 (length (org-element-map tree
'paragraph
'identity
))))
2686 (should-not (org-element-map tree
'entity
'identity
)))
2687 ;; 1.3. Granularity set to `element' should enter every
2689 (let ((tree (org-element-parse-buffer 'element
)))
2690 (should (= 2 (length (org-element-map tree
'paragraph
'identity
))))
2691 (should-not (org-element-map tree
'entity
'identity
)))
2692 ;; 1.4. Granularity set to `object' can see everything.
2693 (let ((tree (org-element-parse-buffer 'object
)))
2694 (should (= 1 (length (org-element-map tree
'entity
'identity
)))))))
2696 (ert-deftest test-org-element
/secondary-string-parsing
()
2697 "Test if granularity correctly toggles secondary strings parsing."
2698 ;; 1. With a granularity bigger than `object', no secondary string
2699 ;; should be parsed.
2701 ;; 1.1. Test with `headline' type.
2702 (org-test-with-temp-text "* Headline"
2704 (org-element-map (org-element-parse-buffer 'headline
) 'headline
2708 (should (stringp (org-element-property :title headline
)))))
2709 ;; 1.2. Test with `item' type.
2710 (org-test-with-temp-text "* Headline\n- tag :: item"
2711 (let ((item (org-element-map (org-element-parse-buffer 'element
)
2716 (should (stringp (org-element-property :tag item
)))))
2717 ;; 1.3. Test with `inlinetask' type, if avalaible.
2718 (when (featurep 'org-inlinetask
)
2719 (let ((org-inlinetask-min-level 15))
2720 (org-test-with-temp-text "*************** Inlinetask"
2721 (let ((inlinetask (org-element-map (org-element-parse-buffer 'element
)
2726 (should (stringp (org-element-property :title inlinetask
)))))))
2727 ;; 2. With a default granularity, secondary strings should be
2729 (org-test-with-temp-text "* Headline"
2731 (org-element-map (org-element-parse-buffer) 'headline
2735 (should (listp (org-element-property :title headline
)))))
2736 ;; 3. `org-element-at-point' should never parse a secondary string.
2737 (org-test-with-temp-text "* Headline"
2738 (should (stringp (org-element-property :title
(org-element-at-point))))))
2742 ;;; Test Visible Only Parsing
2744 (ert-deftest test-org-element
/parse-buffer-visible
()
2745 "Test `org-element-parse-buffer' with visible only argument."
2747 (equal '("H1" "H3" "H5")
2748 (org-test-with-temp-text
2749 "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
2750 (org-occur ":visible:")
2751 (org-element-map (org-element-parse-buffer nil t
) 'headline
2752 (lambda (hl) (org-element-property :raw-value hl
)))))))
2756 ;;; Test `:parent' Property
2758 (ert-deftest test-org-element
/parent-property
()
2759 "Test `:parent' property."
2761 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
2762 (let* ((tree (org-element-parse-buffer))
2763 (parent (org-element-property
2765 (org-element-map tree
'paragraph
'identity nil t
))))
2767 (should (eq (org-element-map tree
'center-block
'identity nil t
)
2770 (org-test-with-temp-text "a_{/b/}"
2771 (let* ((tree (org-element-parse-buffer))
2772 (parent (org-element-property
2774 (org-element-map tree
'italic
'identity nil t
))))
2777 (org-element-map tree
'subscript
'identity nil t
)))))
2778 ;; Secondary strings
2779 (org-test-with-temp-text "* /italic/"
2780 (let* ((tree (org-element-parse-buffer))
2781 (parent (org-element-property
2782 :parent
(org-element-map tree
'italic
'identity nil t
))))
2785 (org-element-map tree
'headline
'identity nil t
))))))
2789 ;;; Test Normalize Contents
2791 (ert-deftest test-org-element
/normalize-contents
()
2792 "Test `org-element-normalize-contents' specifications."
2793 ;; 1. Remove maximum common indentation from element's contents.
2796 (org-element-normalize-contents
2797 '(paragraph nil
" Two spaces\n Three spaces"))
2798 '(paragraph nil
"Two spaces\n Three spaces")))
2799 ;; 2. Ignore objects within contents when computing maximum common
2803 (org-element-normalize-contents
2804 '(paragraph nil
" One " (emphasis nil
"space") "\n Two spaces"))
2805 '(paragraph nil
"One " (emphasis nil
"space") "\n Two spaces")))
2806 ;; 3. Ignore blank lines.
2809 (org-element-normalize-contents
2810 '(paragraph nil
" Two spaces\n\n \n Two spaces"))
2811 '(paragraph nil
"Two spaces\n\n \nTwo spaces")))
2812 ;; 4. Recursively enter objects in order to compute common
2816 (org-element-normalize-contents
2817 '(paragraph nil
" Two spaces " (bold nil
" and\n One space")))
2818 '(paragraph nil
" Two spaces " (bold nil
" and\nOne space"))))
2819 ;; 5. When optional argument is provided, ignore first line
2823 (org-element-normalize-contents
2824 '(paragraph nil
"No space\n Two spaces\n Three spaces") t
)
2825 '(paragraph nil
"No space\nTwo spaces\n Three spaces"))))
2829 ;;; Test Navigation Tools.
2831 (ert-deftest test-org-element
/at-point
()
2832 "Test `org-element-at-point' specifications."
2833 ;; Return closest element containing point.
2836 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
2837 (progn (search-forward "A")
2838 (org-element-type (org-element-at-point))))))
2839 ;; Correctly set `:parent' property.
2842 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
2843 (progn (search-forward "A")
2845 (org-element-property :parent
(org-element-at-point)))))))
2846 ;; Special case: at a blank line just below a headline, return that
2849 (equal "H1" (org-test-with-temp-text "* H1\n \n* H2\n"
2851 (org-element-property :title
(org-element-at-point)))))
2852 ;; Special case: at the very beginning of a table, return `table'
2853 ;; object instead of `table-row'.
2856 (org-test-with-temp-text "| a | b |"
2857 (org-element-type (org-element-at-point)))))
2858 ;; Special case: at the very beginning of a list or sub-list, return
2859 ;; `plain-list' object instead of `item'.
2862 (org-test-with-temp-text "- item"
2863 (org-element-type (org-element-at-point)))))
2864 ;; Special case: at the closing line of a greater element, be sure
2865 ;; to return it instead of the last element in its contents.
2868 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
2869 (progn (forward-line 2)
2870 (org-element-type (org-element-at-point))))))
2871 ;; Special case: at a blank line between two items, be sure to
2872 ;; return item above instead of the last element of its contents.
2875 (org-test-with-temp-text "- Para1\n\n- Para2"
2876 (progn (forward-line)
2878 (let ((org-list-empty-line-terminates-plain-lists nil
))
2879 (org-element-at-point)))))))
2880 ;; Special case: at the last blank line in a plain list, return it
2881 ;; instead of the last item.
2884 (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
2885 (progn (forward-line 2)
2886 (org-element-type (org-element-at-point))))))
2887 ;; Special case: when a list ends at the end of buffer and there's
2888 ;; no final newline, return last element in last item.
2891 (org-test-with-temp-text "- a"
2893 (org-element-type (org-element-at-point)))))
2894 ;; Parse a list within a block itself contained in a list.
2897 (org-test-with-temp-text
2898 "- outer\n #+begin_center\n - inner\n #+end_center"
2899 (search-forward "inner")
2901 (org-element-type (org-element-at-point)))))
2902 ;; Do not error at eob on an empty line.
2904 (org-test-with-temp-text "* H\n"
2906 (or (org-element-at-point) t
))))
2908 (ert-deftest test-org-element
/context
()
2909 "Test `org-element-context' specifications."
2910 ;; Return closest object containing point.
2913 (org-test-with-temp-text "Some *text with _underline_ text*"
2914 (progn (search-forward "under")
2915 (org-element-type (org-element-context))))))
2916 ;; Find objects in secondary strings.
2919 (org-test-with-temp-text "* Headline _with_ underlining"
2920 (progn (search-forward "w")
2921 (org-element-type (org-element-context))))))
2922 ;; Find objects in objects.
2925 (org-test-with-temp-text "| a | {{{macro}}} |"
2926 (progn (search-forward "{")
2927 (org-element-type (org-element-context))))))
2930 (org-test-with-temp-text "| a | b {{{macro}}} |"
2931 (progn (search-forward "b")
2932 (org-element-type (org-element-context))))))
2933 ;; Find objects in document keywords.
2936 (org-test-with-temp-text "#+DATE: {{{macro}}}"
2937 (progn (search-forward "{")
2938 (org-element-type (org-element-context))))))
2939 ;; Do not find objects in table rules.
2942 (org-test-with-temp-text "| a | b |\n+---+---+\n| c | d |"
2944 (org-element-type (org-element-context)))))
2945 ;; Find objects in parsed affiliated keywords.
2948 (org-test-with-temp-text "#+CAPTION: {{{macro}}}\n| a | b |."
2949 (progn (search-forward "{")
2950 (org-element-type (org-element-context))))))
2953 (org-test-with-temp-text "#+caption: *bold*\nParagraph"
2954 (progn (search-forward "*")
2955 (org-element-type (org-element-context))))))
2956 ;; Correctly set `:parent' property.
2959 (org-test-with-temp-text "Some *bold* text"
2960 (progn (search-forward "bold")
2962 (org-element-property :parent
(org-element-context)))))))
2963 ;; Between two objects, return the second one.
2966 (org-test-with-temp-text "<<target>>{{{test}}}"
2967 (progn (search-forward "{")
2969 (org-element-type (org-element-context))))))
2970 ;; Test optional argument.
2973 (org-test-with-temp-text "Some *text with _underline_ text*"
2975 (search-forward "under")
2976 (org-element-type (org-element-context (org-element-at-point))))))))
2979 (provide 'test-org-element
)
2980 ;;; test-org-element.el ends here