1 ;;; test-org-element.el --- Tests for org-element.el
3 ;; Copyright (C) 2012-2015 Nicolas Goaziou
5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
7 ;; This program is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation, either version 3 of the License, or
10 ;; (at your option) any later version.
12 ;; This program is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
22 (unless (featurep 'org-element
)
23 (signal 'missing-test-dependency
"org-element"))
25 (defun org-test-parse-and-interpret (text)
26 "Parse TEXT as Org syntax and interpret it.
27 Return interpreted string."
31 (org-element-interpret-data (org-element-parse-buffer))))
35 ;;; Test `org-element-map'
37 (ert-deftest test-org-element
/map
()
38 "Test `org-element-map'."
39 ;; Can map to `plain-text' objects.
42 (org-test-with-temp-text "Some text \alpha
48 (org-element-parse-buffer) 'plain-text
49 (lambda (s) (when (string-match "text" s
) (incf count
))))
51 ;; Applies to secondary strings
53 (org-element-map '("some " (bold nil
"bold") "text") 'bold
'identity
))
54 ;; Enter secondary strings before entering contents.
60 (org-test-with-temp-text "* Some \\alpha headline\n\\beta entity."
61 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
)))))
62 ;; Apply NO-RECURSION argument.
64 (org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
66 (org-element-parse-buffer) 'entity
'identity nil nil
'center-block
)))
67 ;; Use WITH-AFFILIATED argument.
71 (org-test-with-temp-text "#+CAPTION[a]: 1\n#+CAPTION[b]: 2\nParagraph"
73 (org-element-at-point) 'plain-text
'identity nil nil nil t
)))))
79 (ert-deftest test-org-element
/put-property
()
80 "Test `org-element-put-property' specifications."
82 (org-test-with-temp-text "* Headline\n *a*"
83 (let ((tree (org-element-parse-buffer)))
84 (org-element-put-property
85 (org-element-map tree
'bold
'identity nil t
) :test
1)
86 (should (org-element-property
87 :test
(org-element-map tree
'bold
'identity nil t
)))))
88 ;; Put property on a string.
90 (org-element-property :test
(org-element-put-property "Paragraph" :test t
))))
92 (ert-deftest test-org-element
/set-contents
()
93 "Test `org-element-set-contents' specifications."
94 ;; Accept multiple entries.
96 (equal '("b" (italic nil
"a"))
97 (org-test-with-temp-text "* Headline\n *a*"
98 (let ((tree (org-element-parse-buffer)))
99 (org-element-set-contents
100 (org-element-map tree
'bold
'identity nil t
) "b" '(italic nil
"a"))
101 (org-element-contents
102 (org-element-map tree
'bold
'identity nil t
))))))
103 ;; Accept atoms and elements.
106 (org-test-with-temp-text "* Headline\n *a*"
107 (let ((tree (org-element-parse-buffer)))
108 (org-element-set-contents
109 (org-element-map tree
'bold
'identity nil t
) "b")
110 (org-element-contents
111 (org-element-map tree
'bold
'identity nil t
))))))
113 (equal '((italic nil
"b"))
114 (org-test-with-temp-text "* Headline\n *a*"
115 (let ((tree (org-element-parse-buffer)))
116 (org-element-set-contents
117 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"b"))
118 (org-element-contents
119 (org-element-map tree
'bold
'identity nil t
))))))
120 ;; Allow nil contents.
122 (org-test-with-temp-text "* Headline\n *a*"
123 (let ((tree (org-element-parse-buffer)))
124 (org-element-set-contents (org-element-map tree
'bold
'identity nil t
))
125 (org-element-contents (org-element-map tree
'bold
'identity nil t
))))))
127 (ert-deftest test-org-element
/secondary-p
()
128 "Test `org-element-secondary-p' specifications."
129 ;; In a secondary string, return property name.
132 (org-test-with-temp-text "* Headline *object*"
133 (org-element-map (org-element-parse-buffer) 'bold
134 (lambda (object) (org-element-secondary-p object
))
136 ;; Outside a secondary string, return nil.
138 (org-test-with-temp-text "Paragraph *object*"
139 (org-element-map (org-element-parse-buffer) 'bold
140 (lambda (object) (org-element-type (org-element-secondary-p object
)))
143 (ert-deftest test-org-element
/class
()
144 "Test `org-element-class' specifications."
146 (should (eq 'element
(org-element-class '(paragraph nil
) nil
)))
147 (should (eq 'object
(org-element-class '(target nil
) nil
)))
149 (should (eq 'element
(org-element-class '(org-data nil
) nil
)))
150 (should (eq 'object
(org-element-class "text" nil
)))
151 (should (eq 'object
(org-element-class '("secondary " "string") nil
)))
153 (should (eq 'element
(org-element-class '(foo nil
) nil
)))
154 (should (eq 'element
(org-element-class '(foo nil
) '(center-block nil
))))
155 (should (eq 'element
(org-element-class '(foo nil
) '(org-data nil
))))
157 (should (eq 'object
(org-element-class '(foo nil
) '(bold nil
))))
158 (should (eq 'object
(org-element-class '(foo nil
) '(paragraph nil
))))
159 (should (eq 'object
(org-element-class '(foo nil
) '("secondary"))))
162 (let* ((datum '(foo nil
))
163 (headline `(headline (:title
(,datum
)))))
164 (org-element-put-property datum
:parent headline
)
165 (org-element-class datum
)))))
167 (ert-deftest test-org-element
/adopt-elements
()
168 "Test `org-element-adopt-elements' specifications."
171 (equal '(plain-text italic
)
172 (org-test-with-temp-text "* Headline\n *a*"
173 (let ((tree (org-element-parse-buffer)))
174 (org-element-adopt-elements
175 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"a"))
176 (mapcar (lambda (blob) (org-element-type blob
))
177 (org-element-contents
178 (org-element-map tree
'bold
'identity nil t
)))))))
182 (org-test-with-temp-text "* Headline\n *a*"
183 (let ((tree (org-element-parse-buffer)))
184 (org-element-adopt-elements
185 (org-element-map tree
'bold
'identity nil t
) "b")
186 (org-element-contents
187 (org-element-map tree
'bold
'identity nil t
)))))))
189 (ert-deftest test-org-element
/extract-element
()
190 "Test `org-element-extract-element' specifications."
191 ;; Extract a greater element.
193 (equal '(org-data nil
)
194 (org-test-with-temp-text "* Headline"
195 (let* ((tree (org-element-parse-buffer))
196 (element (org-element-map tree
'headline
'identity nil t
)))
197 (org-element-extract-element element
)
199 ;; Extract an element.
202 (org-test-with-temp-text "Paragraph"
203 (let* ((tree (org-element-parse-buffer))
204 (element (org-element-map tree
'paragraph
'identity nil t
)))
205 (org-element-extract-element element
)
209 ;; Extract an object, even in a secondary string.
212 (org-test-with-temp-text "*bold*"
213 (let* ((tree (org-element-parse-buffer))
214 (element (org-element-map tree
'bold
'identity nil t
)))
215 (org-element-extract-element element
)
221 (org-test-with-temp-text "* Headline *bold*"
222 (let* ((tree (org-element-parse-buffer))
223 (element (org-element-map tree
'bold
'identity nil t
)))
224 (org-element-extract-element element
)
228 ;; Return value doesn't have any :parent set.
230 (org-element-property
232 (org-test-with-temp-text "* Headline\n Paragraph with *bold* text."
233 (let* ((tree (org-element-parse-buffer))
234 (element (org-element-map tree
'bold
'identity nil t
)))
235 (org-element-extract-element element
))))))
237 (ert-deftest test-org-element
/insert-before
()
238 "Test `org-element-insert-before' specifications."
242 '(italic entity bold
)
243 (org-test-with-temp-text "/some/ *paragraph*"
244 (let* ((tree (org-element-parse-buffer))
245 (paragraph (org-element-map tree
'paragraph
'identity nil t
))
246 (bold (org-element-map tree
'bold
'identity nil t
)))
247 (org-element-insert-before '(entity (:name
"\\alpha")) bold
)
248 (org-element-map tree
'(bold entity italic
) #'org-element-type nil
)))))
249 ;; Insert an object in a secondary string.
253 (org-test-with-temp-text "* /A/\n Paragraph."
254 (let* ((tree (org-element-parse-buffer))
255 (headline (org-element-map tree
'headline
'identity nil t
))
256 (italic (org-element-map tree
'italic
'identity nil t
)))
257 (org-element-insert-before '(entity (:name
"\\alpha")) italic
)
258 (org-element-map (org-element-property :title headline
) '(entity italic
)
259 #'org-element-type
))))))
261 (ert-deftest test-org-element
/set-element
()
262 "Test `org-element-set-element' specifications."
263 ;; Check if new element is inserted.
265 (org-test-with-temp-text "* Headline\n*a*"
266 (let* ((tree (org-element-parse-buffer))
267 (bold (org-element-map tree
'bold
'identity nil t
)))
268 (org-element-set-element bold
'(italic nil
"b"))
269 (org-element-map tree
'italic
'identity
))))
270 ;; Check if old element is removed.
272 (org-test-with-temp-text "* Headline\n*a*"
273 (let* ((tree (org-element-parse-buffer))
274 (bold (org-element-map tree
'bold
'identity nil t
)))
275 (org-element-set-element bold
'(italic nil
"b"))
276 (org-element-map tree
'bold
'identity
))))
277 ;; Check if :parent property is correctly set.
280 (org-test-with-temp-text "* Headline\n*a*"
281 (let* ((tree (org-element-parse-buffer))
282 (bold (org-element-map tree
'bold
'identity nil t
)))
283 (org-element-set-element bold
'(italic nil
"b"))
285 (org-element-property
286 :parent
(org-element-map tree
'italic
'identity nil t
)))))))
287 ;; Allow to replace strings with elements.
290 (org-test-with-temp-text "* Headline"
291 (let* ((tree (org-element-parse-buffer))
292 (text (org-element-map tree
'plain-text
'identity nil t
)))
293 (org-element-set-element text
(list 'bold nil
"b"))
294 (org-element-map tree
'plain-text
'identity
)))))
295 ;; Allow to replace elements with strings.
298 (org-test-with-temp-text "* =verbatim="
299 (let* ((tree (org-element-parse-buffer))
300 (verb (org-element-map tree
'verbatim
'identity nil t
)))
301 (org-element-set-element verb
"a")
302 (org-element-map tree
'plain-text
'identity nil t
)))))
303 ;; Allow to replace strings with strings.
306 (org-test-with-temp-text "a"
307 (let* ((tree (org-element-parse-buffer))
308 (text (org-element-map tree
'plain-text
'identity nil t
)))
309 (org-element-set-element text
"b")
310 (org-element-map tree
'plain-text
'identity nil t
))))))
312 (ert-deftest test-org-element
/copy
()
313 "Test `org-element-copy' specifications."
316 (org-test-with-temp-text "*bold*"
317 (org-element-type (org-element-copy (org-element-context))))))
318 (should (eq 'plain-text
319 (org-test-with-temp-text "*bold*"
321 (org-element-map (org-element-parse-buffer) 'plain-text
322 #'org-element-copy nil t
)))))
323 ;; Preserve properties except `:parent'.
325 (org-test-with-temp-text "*bold*"
326 (org-element-property
327 :end
(org-element-copy (org-element-context))))))
329 (org-test-with-temp-text "*bold*"
330 (org-element-property
331 :parent
(org-element-copy (org-element-context)))))
333 (org-test-with-temp-text "*bold*"
334 (org-element-property
336 (org-element-map (org-element-parse-buffer) 'plain-text
337 #'org-element-copy nil t
))))
338 ;; Copying nil returns nil.
339 (should-not (org-element-copy nil
))
340 ;; Return a copy secondary strings.
341 (should (equal '("text") (org-element-copy '("text"))))
342 (should-not (eq '("text") (org-element-copy '("text")))))
348 ;;;; Affiliated Keywords
350 (ert-deftest test-org-element
/affiliated-keywords-parser
()
351 "Test affiliated keywords parsing."
352 ;; Read simple keywords.
355 (org-element-property
357 (org-test-with-temp-text "#+NAME: para\nParagraph"
358 (org-element-at-point)))))
361 (org-element-property
363 (org-test-with-temp-text "#+NAME: para\nParagraph"
364 (org-element-at-point)))))
365 ;; Parse multiple keywords.
369 (org-element-property
371 (org-test-with-temp-text
372 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
373 (org-element-at-point)))))
374 ;; Parse "parsed" keywords.
378 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
379 (car (org-element-property :caption
(org-element-at-point))))))
380 ;; Parse dual keywords.
383 '((("long") "short"))
384 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
385 (org-element-property :caption
(org-element-at-point)))))
386 ;; Allow multiple caption keywords.
389 '((("l2") "s2") (("l1") "s1"))
390 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
391 (org-element-property :caption
(org-element-at-point)))))
394 '((("l1")) (nil "s1"))
395 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
396 (org-element-property :caption
(org-element-at-point)))))
397 ;; Corner case: orphaned keyword at the end of an element.
400 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
401 (progn (search-forward "name")
402 (org-element-type (org-element-at-point))))))
404 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
405 (progn (search-forward "Some")
406 (org-element-property :name
(org-element-at-point))))))
411 (ert-deftest test-org-element
/babel-call-parser
()
412 "Test `babel-call' parsing."
416 (org-test-with-temp-text "#+CALL: test()"
417 (org-element-type (org-element-at-point)))))
421 (org-test-with-temp-text "#+call: test()"
422 (org-element-type (org-element-at-point)))))
423 ;; Handle non-empty blank line at the end of buffer.
425 (org-test-with-temp-text "#+CALL: test()\n "
426 (= (org-element-property :end
(org-element-at-point)) (point-max))))
430 (org-test-with-temp-text "#+CALL: test()"
431 (org-element-property :call
(org-element-at-point)))))
432 ;; Parse inside header.
434 (equal ":results output"
435 (org-test-with-temp-text "#+CALL: test[:results output]()"
436 (org-element-property :inside-header
(org-element-at-point)))))
437 ;; Parse arguments, which can be nested.
440 (org-test-with-temp-text "#+CALL: test(n=4)"
441 (org-element-property :arguments
(org-element-at-point)))))
444 (org-test-with-temp-text "#+CALL: test(test())"
445 (org-element-property :arguments
(org-element-at-point)))))
448 (equal ":results html"
449 (org-test-with-temp-text "#+CALL: test() :results html"
450 (org-element-property :end-header
(org-element-at-point))))))
455 (ert-deftest test-org-element
/bold-parser
()
456 "Test `bold' parser."
459 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
460 (org-test-with-temp-text "*bold*"
461 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
462 ;; Multi-line markup.
465 (org-element-contents
466 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
467 (org-test-with-temp-text "*first line\nsecond line*"
468 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
469 '("first line\nsecond line"))))
474 (ert-deftest test-org-element
/center-block-parser
()
475 "Test `center-block' parser."
478 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
479 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
482 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
483 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
484 ;; Ignore incomplete block.
486 (org-test-with-temp-text "#+BEGIN_CENTER"
487 (org-element-map (org-element-parse-buffer) 'center-block
489 ;; Handle non-empty blank line at the end of buffer.
491 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
492 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
497 (ert-deftest test-org-element
/clock-parser
()
498 "Test `clock' parser."
500 (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
501 (org-element-at-point))))
502 (should (eq (org-element-property :status clock
) 'running
))
504 (equal (org-element-property :raw-value
505 (org-element-property :value clock
))
506 "[2012-01-01 sun. 00:01]"))
507 (should-not (org-element-property :duration clock
)))
510 (org-test-with-temp-text
511 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
512 (org-element-at-point))))
513 (should (eq (org-element-property :status clock
) 'closed
))
514 (should (equal (org-element-property :raw-value
515 (org-element-property :value clock
))
516 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
517 (should (equal (org-element-property :duration clock
) "0:01"))))
522 (ert-deftest test-org-element
/code-parser
()
523 "Test `code' parser."
526 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
527 (org-test-with-temp-text "~code~"
528 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
529 ;; Multi-line markup.
532 (org-element-property
534 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
535 (org-test-with-temp-text "~first line\nsecond line~"
537 (org-element-parse-buffer) 'code
'identity nil t
))))
538 "first line\nsecond line")))
543 (ert-deftest test-org-element
/comment-parser
()
544 "Test `comment' parser."
547 (org-test-with-temp-text "# Comment"
548 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
551 (org-test-with-temp-text " # Comment"
552 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
553 ;; Preserve indentation.
556 (org-element-property
558 (org-test-with-temp-text "# No blank\n# One blank"
559 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
560 "No blank\n One blank"))
561 ;; Comment with blank lines.
564 (org-element-property
566 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
567 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
568 "First part\n\n\nSecond part"))
569 ;; Do not mix comments and keywords.
572 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
573 (length (org-element-map (org-element-parse-buffer) 'comment
577 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
578 (org-element-property
580 (org-element-map (org-element-parse-buffer) 'comment
582 ;; Correctly handle non-empty blank lines at the end of buffer.
584 (org-test-with-temp-text "# A\n "
585 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
590 (ert-deftest test-org-element
/comment-block-parser
()
591 "Test `comment-block' parser."
594 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
595 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
598 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
599 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
600 ;; Ignore incomplete block.
602 (org-test-with-temp-text "#+BEGIN_COMMENT"
603 (org-element-map (org-element-parse-buffer) 'comment-block
605 ;; Handle non-empty blank line at the end of buffer.
607 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
608 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
613 (ert-deftest test-org-element
/diary-sexp-parser
()
614 "Test `diary-sexp' parser."
618 (org-test-with-temp-text
619 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
620 (org-element-type (org-element-at-point)))))
621 ;; Diary sexp must live at beginning of line
624 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
625 (org-element-type (org-element-at-point)))))
626 ;; Handle non-empty blank line at the end of buffer.
628 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
629 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
634 (ert-deftest test-org-element
/drawer-parser
()
635 "Test `drawer' parser."
638 (org-test-with-temp-text ":TEST:\nText\n:END:"
639 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
640 ;; Ignore incomplete drawer.
642 (org-test-with-temp-text ":TEST:"
643 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
644 ;; Handle non-empty blank line at the end of buffer.
646 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
647 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
652 (ert-deftest test-org-element
/dynamic-block-parser
()
653 "Test `dynamic-block' parser."
656 (org-test-with-temp-text
657 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
658 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
661 (org-test-with-temp-text
662 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
663 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
664 ;; Ignore incomplete block.
666 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
667 (org-element-map (org-element-parse-buffer) 'dynamic-block
669 ;; Handle non-empty blank line at the end of buffer.
671 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
672 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
677 (ert-deftest test-org-element
/entity-parser
()
678 "Test `entity' parser."
681 (org-test-with-temp-text "\\sin"
682 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
685 (org-element-property
687 (org-test-with-temp-text "\\alpha{}text"
688 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
689 ;; User-defined entity.
692 (org-element-property
694 (let ((org-entities-user
695 '(("test" "test" nil
"test" "test" "test" "test"))))
696 (org-test-with-temp-text "\\test"
697 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
699 ;; Special case: entity at the end of a container.
702 (org-test-with-temp-text "*\\alpha \\beta*"
703 (search-forward "be")
704 (org-element-type (org-element-context))))))
709 (ert-deftest test-org-element
/example-block-parser
()
710 "Test `example-block' parser."
713 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
714 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
715 ;; Ignore incomplete block.
718 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
719 (org-element-type (org-element-at-point)))))
720 ;; Properly un-escape code.
722 (equal "* Headline\n #+keyword\nText\n"
723 (org-test-with-temp-text
724 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
725 (org-element-property :value
(org-element-at-point)))))
726 ;; Handle non-empty blank line at the end of buffer.
728 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
729 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
731 (ert-deftest test-org-element
/block-switches
()
732 "Test `example-block' and `src-block' switches parsing."
733 (let ((org-coderef-label-format "(ref:%s)"))
734 ;; 1. Test "-i" switch.
736 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
737 (org-element-property :preserve-indent
(org-element-at-point))))
739 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
740 (org-element-property :preserve-indent
(org-element-at-point))))
742 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
743 (org-element-property :preserve-indent
(org-element-at-point))))
745 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
746 (org-element-property :preserve-indent
(org-element-at-point))))
747 ;; 2. "-n -r -k" combination should number lines, retain labels but
748 ;; not use them in coderefs.
749 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
750 (let ((element (org-element-at-point)))
751 (should (org-element-property :number-lines element
))
752 (should (org-element-property :retain-labels element
))
753 (should-not (org-element-property :use-labels element
))))
754 (org-test-with-temp-text
755 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
756 (let ((element (org-element-at-point)))
757 (should (org-element-property :number-lines element
))
758 (should (org-element-property :retain-labels element
))
759 (should-not (org-element-property :use-labels element
))))
760 ;; 3. "-n -r" combination should number-lines remove labels and not
761 ;; use them in coderefs.
762 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
763 (let ((element (org-element-at-point)))
764 (should (org-element-property :number-lines element
))
765 (should-not (org-element-property :retain-labels element
))
766 (should-not (org-element-property :use-labels element
))))
767 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
768 (let ((element (org-element-at-point)))
769 (should (org-element-property :number-lines element
))
770 (should-not (org-element-property :retain-labels element
))
771 (should-not (org-element-property :use-labels element
))))
772 ;; 4. "-n" or "+n" should number lines, retain labels and use them
775 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
776 (let ((element (org-element-at-point)))
777 (and (org-element-property :number-lines element
)
778 (org-element-property :retain-labels element
)
779 (org-element-property :use-labels element
)))))
781 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
782 (let ((element (org-element-at-point)))
783 (and (org-element-property :number-lines element
)
784 (org-element-property :retain-labels element
)
785 (org-element-property :use-labels element
)))))
787 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
788 (let ((element (org-element-at-point)))
789 (and (org-element-property :number-lines element
)
790 (org-element-property :retain-labels element
)
791 (org-element-property :use-labels element
)))))
793 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
794 (let ((element (org-element-at-point)))
795 (and (org-element-property :number-lines element
)
796 (org-element-property :retain-labels element
)
797 (org-element-property :use-labels element
)))))
798 ;; 5. No switch should not number lines, but retain labels and use
800 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
801 (let ((element (org-element-at-point)))
802 (should (not (org-element-property :number-lines element
)))
803 (should (org-element-property :retain-labels element
))
804 (should (org-element-property :use-labels element
))))
805 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
806 (let ((element (org-element-at-point)))
807 (should (not (org-element-property :number-lines element
)))
808 (should (org-element-property :retain-labels element
))
809 (should (org-element-property :use-labels element
))))
810 ;; 6. "-r" switch only: do not number lines, remove labels, and
811 ;; don't use labels in coderefs.
812 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
813 (let ((element (org-element-at-point)))
814 (should (not (org-element-property :number-lines element
)))
815 (should (not (org-element-property :retain-labels element
)))
816 (should (not (org-element-property :use-labels element
)))))
817 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
818 (let ((element (org-element-at-point)))
819 (should (not (org-element-property :number-lines element
)))
820 (should (not (org-element-property :retain-labels element
)))
821 (should (not (org-element-property :use-labels element
)))))
822 ;; 7. Recognize coderefs with user-defined syntax.
826 (org-test-with-temp-text
827 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
828 (org-element-property :label-fmt
(org-element-at-point)))))
832 (org-test-with-temp-text
833 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
834 (org-element-property :label-fmt
(org-element-at-point)))))))
839 (ert-deftest test-org-element
/export-block-parser
()
840 "Test `export-block' parser."
844 (org-test-with-temp-text "#+BEGIN_EXPORT LATEX\nText\n#+END_EXPORT"
845 (org-element-type (org-element-at-point)))))
848 (org-test-with-temp-text "#+BEGIN_EXPORT LATEX\nText\n#+END_EXPORT"
849 (org-element-property :type
(org-element-at-point)))))
853 (org-test-with-temp-text "#+begin_export latex\nText\n#+end_export"
854 (org-element-type (org-element-at-point)))))
855 ;; Ignore incomplete block.
858 (org-test-with-temp-text "#+BEGIN_EXPORT"
859 (org-element-type (org-element-at-point)))))
860 ;; Handle non-empty blank line at the end of buffer.
862 (org-test-with-temp-text "#+BEGIN_EXPORT latex\nC\n#+END_EXPORT\n "
863 (= (org-element-property :end
(org-element-at-point)) (point-max))))
864 ;; Un-escape commas in `:value'.
867 (org-test-with-temp-text "#+BEGIN_EXPORT org\n,* H\n#+END_EXPORT\n "
868 (org-element-property :value
(org-element-at-point))))))
873 (ert-deftest test-org-element
/export-snippet-parser
()
874 "Test `export-snippet' parser."
877 '("back-end" .
"contents")
878 (org-test-with-temp-text "@@back-end:contents@@"
880 (org-element-parse-buffer) 'export-snippet
881 (lambda (snippet) (cons (org-element-property :back-end snippet
)
882 (org-element-property :value snippet
)))
888 (ert-deftest test-org-element
/fixed-width-parser
()
889 "Test fixed-width area parsing."
890 ;; Preserve indentation.
892 (org-test-with-temp-text ": no blank\n: one blank"
893 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
894 ;; Fixed-width with empty lines.
896 (org-test-with-temp-text ": first part\n:\n: \n: second part"
897 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
898 ;; Parse indented fixed-width markers.
900 (org-test-with-temp-text "Text\n : no blank\n : one blank"
901 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
902 ;; Distinguish fixed-width areas within a list and outside of it.
906 (org-test-with-temp-text "
909 : fixed-width outside"
910 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
911 ;; Handle non-empty blank line at the end of buffer.
913 (org-test-with-temp-text ": A\n "
914 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
917 ;;;; Footnote Definition
919 (ert-deftest test-org-element
/footnote-definition-parser
()
920 "Test `footnote-definition' parser."
922 (org-test-with-temp-text "[fn:1] Definition"
923 (org-element-map (org-element-parse-buffer) 'footnote-definition
925 ;; Footnote with more contents
928 (org-element-property
930 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
931 (org-element-map (org-element-parse-buffer) 'footnote-definition
933 ;; Footnote starting with special syntax.
935 (org-test-with-temp-text "[fn:1] - no item"
936 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
937 ;; Correctly handle footnote starting with an empty line.
940 (org-test-with-temp-text "[fn:1]\n\n Body"
941 (org-element-property :contents-begin
(org-element-at-point)))))
942 ;; Handle non-empty blank line at the end of buffer.
944 (org-test-with-temp-text "[fn:1] Definition\n "
945 (= (org-element-property :end
(org-element-at-point)) (point-max))))
946 ;; Footnote with attributes.
949 (org-test-with-temp-text "#+attr_latex: :offset 0in\n[fn:1] A footnote."
951 (org-element-map (org-element-parse-buffer) 'footnote-definition
954 (org-test-with-temp-text "[fn:1] 1\n\n#+attr_latex: :offset 0in\n[fn:2] 2"
955 (goto-char (org-element-property :end
(org-element-at-point)))
959 ;;;; Footnotes Reference.
961 (ert-deftest test-org-element
/footnote-reference-parser
()
962 "Test `footnote-reference' parser."
963 ;; Parse a standard reference.
965 (org-test-with-temp-text "Text[fn:label]"
967 (org-element-parse-buffer) 'footnote-reference
'identity
)))
968 ;; Parse an inline reference.
970 (org-test-with-temp-text "Text[fn:test:def]"
972 (org-element-parse-buffer) 'footnote-reference
'identity
)))
973 ;; Parse an anonymous reference.
975 (org-test-with-temp-text "Text[fn::def]"
977 (org-element-parse-buffer) 'footnote-reference
'identity
)))
978 ;; Parse nested footnotes.
982 (org-test-with-temp-text "Text[fn::def [fn:label]]"
984 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
985 ;; Parse adjacent footnotes.
987 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
991 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
992 ;; Only properly closed footnotes are recognized as such.
994 (org-test-with-temp-text "Text[fn:label"
996 (org-element-parse-buffer) 'footnote-reference
'identity
))))
1001 (ert-deftest test-org-element
/headline-comment-keyword
()
1002 "Test COMMENT keyword recognition."
1004 (org-test-with-temp-text "* Headline"
1005 (let ((org-comment-string "COMMENT"))
1006 (should-not (org-element-property :commentedp
(org-element-at-point)))))
1007 ;; Standard position.
1008 (org-test-with-temp-text "* COMMENT Headline"
1009 (let ((org-comment-string "COMMENT")
1010 (headline (org-element-at-point)))
1011 (should (org-element-property :commentedp headline
))
1012 (should (equal (org-element-property :raw-value headline
) "Headline"))))
1013 ;; Case sensitivity.
1014 (org-test-with-temp-text "* COMMENT Headline"
1015 (let* ((org-comment-string "Comment")
1016 (headline (org-element-at-point)))
1017 (should-not (org-element-property :commentedp headline
))
1018 (should (equal (org-element-property :raw-value headline
)
1019 "COMMENT Headline"))))
1020 ;; With another keyword.
1021 (org-test-with-temp-text "* TODO COMMENT Headline"
1022 (let* ((org-comment-string "COMMENT")
1023 (org-todo-keywords '((sequence "TODO" "DONE")))
1024 (headline (org-element-at-point)))
1025 (should (org-element-property :commentedp headline
))
1026 (should (equal (org-element-property :raw-value headline
) "Headline"))))
1027 ;; With the keyword only.
1028 (org-test-with-temp-text "* COMMENT"
1029 (let* ((org-comment-string "COMMENT")
1030 (headline (org-element-at-point)))
1031 (should (org-element-property :commentedp headline
))
1032 (should (equal (org-element-property :raw-value headline
) "")))))
1034 (ert-deftest test-org-element
/headline-archive-tag
()
1035 "Test ARCHIVE tag recognition."
1038 (org-test-with-temp-text "* Headline"
1039 (let ((org-archive-tag "ARCHIVE"))
1040 (org-element-property :archivedp
(org-element-at-point)))))
1042 (org-test-with-temp-text "* Headline :ARCHIVE:"
1043 (let ((org-archive-tag "ARCHIVE"))
1044 (let ((headline (org-element-at-point)))
1045 (should (org-element-property :archivedp headline
)))))
1047 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
1048 (let ((org-archive-tag "ARCHIVE"))
1049 (let ((headline (org-element-at-point)))
1050 (should (org-element-property :archivedp headline
)))))
1051 ;; Tag is case-sensitive.
1053 (org-test-with-temp-text "* Headline :ARCHIVE:"
1054 (let ((org-archive-tag "Archive"))
1055 (org-element-property :archivedp
(org-element-at-point))))))
1057 (ert-deftest test-org-element
/headline-properties
()
1058 "Test properties from property drawer."
1059 ;; All properties from property drawer have their symbol upper
1062 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1063 (org-element-property :FOO
(org-element-at-point))))
1065 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1066 (org-element-property :foo
(org-element-at-point))))
1067 ;; Also parse properties associated in inlinetasks.
1068 (when (featurep 'org-inlinetask
)
1070 (org-test-with-temp-text "*************** Inlinetask
1074 *************** END"
1075 (org-element-property :FOO
(org-element-at-point)))))
1076 ;; Do not find property drawer in a verbatim area.
1078 (org-test-with-temp-text
1085 (org-element-property :FOO
(org-element-at-point))))
1086 ;; Do not use properties from a drawer associated to an inlinetask.
1087 (when (featurep 'org-inlinetask
)
1089 (org-test-with-temp-text
1091 *************** Inlinetask
1095 *************** END"
1096 (org-element-property
1097 :FOO
(let ((org-inlinetask-min-level 15)) (org-element-at-point))))))
1098 ;; Do not find incomplete drawers.
1100 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar"
1101 (org-element-property :FOO
(org-element-at-point)))))
1104 ;;;; Horizontal Rule
1106 (ert-deftest test-org-element
/horizontal-rule-parser
()
1107 "Test `horizontal-rule' parser."
1110 (org-test-with-temp-text "-----"
1111 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1114 (org-test-with-temp-text " -----"
1115 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1116 ;; Hyphen must be alone on the line.
1118 (org-test-with-temp-text "-----wrong"
1119 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1120 ;; 4 hyphens is too small.
1122 (org-test-with-temp-text "----"
1123 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1124 ;; Handle non-empty blank line at the end of buffer.
1126 (org-test-with-temp-text "-----\n "
1127 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1130 ;;;; Inline Babel Call
1132 (ert-deftest test-org-element
/inline-babel-call-parser
()
1133 "Test `inline-babel-call' parser."
1136 (eq 'inline-babel-call
1137 (org-test-with-temp-text "call_test()"
1138 (org-element-type (org-element-context)))))
1140 (eq 'inline-babel-call
1141 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1142 (org-element-type (org-element-context)))))
1147 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1148 (org-element-property :call
(org-element-context)))))
1149 ;; Parse inside header.
1153 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1154 (org-element-property :inside-header
(org-element-context)))))
1159 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1160 (org-element-property :arguments
(org-element-context)))))
1161 ;; Parse end header.
1165 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1166 (org-element-property :end-header
(org-element-context)))))
1167 ;; Handle multi-line babel calls.
1169 (eq 'inline-babel-call
1170 (org-test-with-temp-text
1171 "call_test[:results\noutput](x=2)[:results html]"
1172 (org-element-type (org-element-context)))))
1174 (eq 'inline-babel-call
1175 (org-test-with-temp-text
1176 "call_test[:results output](x=2\ny=3)[:results html]"
1177 (org-element-type (org-element-context)))))
1179 (eq 'inline-babel-call
1180 (org-test-with-temp-text
1181 "call_test[:results output](x=2)[:results\nhtml]"
1182 (org-element-type (org-element-context)))))
1183 ;; Parse parameters containing round brackets.
1185 (eq 'inline-babel-call
1186 (org-test-with-temp-text "call_test[:var x='(1)](x=2)"
1187 (org-element-type (org-element-context))))))
1190 ;;;; Inline Src Block
1192 (ert-deftest test-org-element
/inline-src-block-parser
()
1193 "Test `inline-src-block' parser."
1195 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1196 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1199 (org-test-with-temp-text "src_emacs-lisp[:foo bar]{(+ 1 1)}"
1200 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1202 (org-test-with-temp-text "src_emacs-lisp[ :foo bar]{(+ 1 1)}"
1203 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1206 (org-test-with-temp-text "src_emacs-lisp[]{(+ 1 1)}"
1207 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1210 (org-test-with-temp-text "foosrc_emacs-lisp[]{(+ 1 1)}"
1211 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1213 (org-test-with-temp-text "src_emacs-lisp[]foo{(+ 1 1)}"
1214 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1215 ;; Invalid language name
1217 (org-test-with-temp-text "src_emacs-\tlisp{(+ 1 1)}"
1218 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1219 ;; Test parsing at the beginning of an item.
1221 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1222 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1223 ;; Test parsing multi-line source blocks.
1225 (eq 'inline-src-block
1226 (org-test-with-temp-text "src_emacs-lisp{(+ 1\n 1)}"
1227 (org-element-type (org-element-context)))))
1229 (eq 'inline-src-block
1230 (org-test-with-temp-text "src_emacs-lisp[\n:foo bar]{(+ 1 1)}"
1231 (org-element-type (org-element-context)))))
1233 (eq 'inline-src-block
1234 (org-test-with-temp-text "src_emacs-lisp[:foo\nbar]{(+ 1 1)}"
1235 (org-element-type (org-element-context)))))
1236 ;; Besides curly brackets, ignore any other bracket type.
1239 (org-test-with-temp-text "src_emacs-lisp{[foo}"
1240 (org-element-property :value
(org-element-context)))))
1243 (org-test-with-temp-text "src_emacs-lisp{foo]}"
1244 (org-element-property :value
(org-element-context)))))
1247 (org-test-with-temp-text "src_emacs-lisp{(foo}"
1248 (org-element-property :value
(org-element-context)))))
1251 (org-test-with-temp-text "src_emacs-lisp{foo)}"
1252 (org-element-property :value
(org-element-context)))))
1253 ;; Parse parameters containing square brackets.
1255 (eq 'inline-src-block
1256 (org-test-with-temp-text "src_emacs-lisp[:var table=t[1,1]]{(+ 1 1)}"
1257 (org-element-type (org-element-context))))))
1262 (ert-deftest test-org-element
/inlinetask-parser
()
1263 "Test `inlinetask' parser."
1264 (when (featurep 'org-inlinetask
)
1265 (let ((org-inlinetask-min-level 15))
1266 ;; Regular inlinetask.
1269 (org-test-with-temp-text
1270 "*************** Task\nTest\n*************** END"
1271 (org-element-type (org-element-at-point)))))
1274 (org-test-with-temp-text
1275 "*************** Task\nTest\n*************** END"
1276 (org-element-type (org-element-at-point)))))
1277 ;; Degenerate inlinetask.
1280 (org-test-with-temp-text "*************** Task"
1281 (org-element-type (org-element-at-point)))))
1282 ;; Mixed inlinetasks.
1284 (org-test-with-temp-text
1286 *************** Task
1287 *************** Task2
1289 *************** END"
1291 (goto-char (org-element-property :end
(org-element-at-point)))
1297 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1298 (org-test-with-temp-text "*************** TODO Task"
1299 (org-element-property :todo-keyword
(org-element-at-point))))))
1302 (org-test-with-temp-text "
1303 *************** Task<point>
1304 DEADLINE: <2012-03-29 thu.>
1305 *************** END"
1306 (org-element-property :deadline
(org-element-at-point))))
1309 (org-test-with-temp-text "
1310 *************** Task
1311 <point>DEADLINE: <2012-03-29 thu.>
1312 *************** END"
1313 (org-element-type (org-element-at-point)))))
1315 (org-test-with-temp-text "
1316 *************** Task<point>
1317 DEADLINE: <2012-03-29 thu.>"
1318 (org-element-property :deadline
(org-element-at-point))))
1321 (org-test-with-temp-text "
1322 *************** Task
1323 <point>DEADLINE: <2012-03-29 thu.>"
1324 (org-element-type (org-element-at-point)))))
1329 (org-test-with-temp-text "
1330 *************** [#A] Task"
1332 (org-element-property :priority
(org-element-at-point)))))
1337 (org-test-with-temp-text "
1338 *************** Task :test:"
1340 (org-element-property :tags
(org-element-at-point)))))
1341 ;; Regular properties are accessed through upper case keywords.
1343 (org-test-with-temp-text "
1344 *************** Task
1348 *************** END"
1350 (org-element-property :FOO
(org-element-at-point))))
1352 (org-test-with-temp-text "
1353 *************** Task
1357 *************** END"
1359 (org-element-property :foo
(org-element-at-point))))
1360 ;; Handle non-empty blank line at the end of buffer.
1362 (org-test-with-temp-text "*************** Task\n*************** END\n "
1363 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1368 (ert-deftest test-org-element
/italic-parser
()
1369 "Test `italic' parser."
1372 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1373 (org-test-with-temp-text "/italic/"
1374 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1375 ;; Multi-line markup.
1378 (org-element-contents
1379 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1380 (org-test-with-temp-text "/first line\nsecond line/"
1381 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1382 '("first line\nsecond line"))))
1387 (ert-deftest test-org-element
/item-parser
()
1388 "Test `item' parser."
1391 (org-test-with-temp-text "- item"
1392 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1396 (org-element-property
1398 (org-test-with-temp-text "6. [@6] item"
1399 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1404 (org-element-property
1406 (org-test-with-temp-text "- tag :: description"
1407 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1408 ;; No tags in ordered lists.
1410 (org-element-property
1412 (org-test-with-temp-text "1. tag :: description"
1413 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1418 (org-test-with-temp-text "
1423 (org-element-parse-buffer) 'item
1424 (lambda (item) (org-element-property :checkbox item
))))))
1425 ;; Item starting with special syntax.
1427 (equal '(("- item"))
1428 (org-test-with-temp-text "- - item"
1429 (org-element-map (org-element-parse-buffer) 'paragraph
1430 'org-element-contents
))))
1431 ;; Block in an item: ignore indentation within the block.
1433 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1435 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1440 (ert-deftest test-org-element
/keyword-parser
()
1441 "Test `keyword' parser."
1444 (org-test-with-temp-text "#+KEYWORD: value"
1445 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1446 ;; Keywords are case-insensitive.
1448 (org-test-with-temp-text "#+keyword: value"
1449 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1450 ;; Affiliated keywords are not keywords.
1452 (org-test-with-temp-text "#+NAME: value
1454 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1455 ;; Do not mix keywords with Babel calls and dynamic blocks.
1457 (org-test-with-temp-text "#+CALL: fun()"
1458 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1460 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1461 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1462 ;; Handle non-empty blank line at the end of buffer.
1464 (org-test-with-temp-text "#+KEYWORD: value\n "
1465 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1468 ;;;; Latex Environment
1470 (ert-deftest test-org-element
/latex-environment-parser
()
1471 "Test `latex-environment' parser."
1473 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1474 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1475 ;; Allow nested environments.
1483 (org-test-with-temp-text "
1489 (org-element-property
1492 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1493 ;; Allow environments with options and arguments.
1495 (eq 'latex-environment
1496 (org-test-with-temp-text
1497 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1498 (org-element-type (org-element-at-point)))))
1500 (eq 'latex-environment
1501 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1502 (org-element-type (org-element-at-point)))))
1503 ;; Allow environments without newline after \begin{.}.
1505 (eq 'latex-environment
1506 (org-test-with-temp-text "\\begin{env}{arg}something\nvalue\n\\end{env}"
1507 (org-element-type (org-element-at-point)))))
1508 ;; Allow one-line environments.
1510 (eq 'latex-environment
1511 (org-test-with-temp-text "\\begin{env}{arg}something\\end{env}"
1512 (org-element-type (org-element-at-point)))))
1513 ;; Should not allow different tags.
1515 (eq 'latex-environment
1516 (org-test-with-temp-text "\\begin{env*}{arg}something\\end{env}"
1517 (org-element-type (org-element-at-point)))))
1518 ;; LaTeX environments must be on separate lines.
1520 (eq 'latex-environment
1521 (org-test-with-temp-text "\\begin{env} x \\end{env} y"
1522 (org-element-type (org-element-at-point)))))
1524 (eq 'latex-environment
1525 (org-test-with-temp-text "y \\begin{env} x<point> \\end{env}"
1526 (org-element-type (org-element-at-point)))))
1527 ;; Handle non-empty blank line at the end of buffer.
1529 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1530 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1535 (ert-deftest test-org-element
/latex-fragment-parser
()
1536 "Test `latex-fragment' parser."
1539 (org-test-with-temp-text "$a$"
1540 (org-element-type (org-element-context)))))
1543 (org-test-with-temp-text "$a$!"
1544 (org-element-type (org-element-context)))))
1547 (org-test-with-temp-text "$a$,"
1548 (org-element-type (org-element-context)))))
1551 (org-test-with-temp-text "$a$\""
1552 (org-element-type (org-element-context)))))
1555 (org-test-with-temp-text "$a$)"
1556 (org-element-type (org-element-context)))))
1559 (org-test-with-temp-text "$a$ "
1560 (org-element-type (org-element-context)))))
1563 (org-test-with-temp-text "$a$a"
1564 (org-element-type (org-element-context)))))
1567 (org-test-with-temp-text "$$a$$"
1568 (org-element-type (org-element-context)))))
1571 (org-test-with-temp-text "\\(a\\)"
1572 (org-element-type (org-element-context)))))
1575 (org-test-with-temp-text "\\[a\\]"
1576 (org-element-type (org-element-context)))))
1577 ;; Test fragment at the beginning of an item.
1580 (org-test-with-temp-text "- $<point>x$"
1581 (org-element-type (org-element-context))))))
1586 (ert-deftest test-org-element
/line-break-parser
()
1587 "Test `line-break' parser."
1590 (org-test-with-temp-text "Text \\\\"
1591 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1592 ;; Line break with trailing white spaces.
1594 (org-test-with-temp-text "Text \\\\ "
1595 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1596 ;; Three backslashes are too much.
1598 (org-test-with-temp-text "Text \\\\\\"
1599 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1604 (ert-deftest test-org-element
/link-parser
()
1605 "Test `link' parser."
1610 (org-test-with-temp-text "<<<radio>>>A radio link"
1611 (org-update-radio-target-regexp)
1612 (org-element-property
1614 (org-element-map (org-element-parse-buffer) 'link
#'identity nil t
)))))
1615 ;; Pathological case: radio target of length 1 at beginning of line
1616 ;; not followed by spaces.
1618 (org-test-with-temp-text "* <<<a>>>\n<point>a-bug"
1619 (org-update-radio-target-regexp)
1620 (org-element-parse-buffer)))
1623 ;; ... with description.
1627 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1628 (org-element-contents
1629 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1630 ;; ... without description.
1634 (org-test-with-temp-text "[[http://orgmode.org]]"
1635 (org-element-property
1637 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1638 ;; ... with expansion.
1641 "//orgmode.org/worg"
1642 (org-test-with-temp-text "[[Org:worg]]"
1643 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1644 (org-element-property
1646 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1647 ;; ... with translation.
1651 (org-test-with-temp-text "[[http://orgmode.org]]"
1652 (let ((org-link-translation-function
1653 (lambda (type _
) (cons type
"127.0.0.1"))))
1654 (org-element-property
1656 (org-element-map (org-element-parse-buffer) 'link
1657 #'identity nil t
))))))
1662 (org-test-with-temp-text "[[id:aaaa]]"
1663 (org-element-property
1665 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1666 ;; ... custom-id link.
1670 (org-test-with-temp-text "[[#some-id]]"
1671 (org-element-property
1673 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1674 ;; ... coderef link.
1678 (org-test-with-temp-text "[[(reference)]]"
1679 (org-element-property
1681 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1686 (org-test-with-temp-text "[[target-or-title]]"
1687 (org-element-property
1689 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1690 ;; ... file-type link with search option.
1693 '(("file" "projects.org" "*task title"))
1694 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1695 (org-element-map (org-element-parse-buffer) 'link
1696 (lambda (l) (list (org-element-property :type l
)
1697 (org-element-property :path l
)
1698 (org-element-property :search-option l
)))))))
1699 ;; ... file-type link with application...
1702 '("file" "projects.org" "emacs")
1703 (org-test-with-temp-text "[[file+emacs:projects.org]]"
1704 (let ((l (org-element-context)))
1705 (list (org-element-property :type l
)
1706 (org-element-property :path l
)
1707 (org-element-property :application l
))))))
1708 ;; ... `:path' in a file-type link must be compatible with "file"
1709 ;; scheme in URI syntax, even if Org syntax isn't...
1711 (org-test-with-temp-text-in-file ""
1712 (let ((file (expand-file-name (buffer-file-name))))
1713 (insert (format "[[file://%s]]" file
))
1714 (equal (org-element-property :path
(org-element-context)) file
))))
1716 (org-test-with-temp-text-in-file ""
1717 (let ((file (expand-file-name (buffer-file-name))))
1718 (insert (format "[[file:%s]]" file
))
1719 (equal (org-element-property :path
(org-element-context)) file
))))
1721 (org-test-with-temp-text-in-file ""
1722 (let ((file (expand-file-name (buffer-file-name))))
1723 (insert (format "[[file:%s]]" file
))
1724 (equal (org-element-property :path
(org-element-context)) file
))))
1725 ;; ... multi-line link.
1728 (org-test-with-temp-text "[[shell:ls\n*.org]]"
1729 (org-element-property :path
(org-element-context)))))
1732 (org-test-with-temp-text "A link: http://orgmode.org"
1733 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1734 ;; Angular link. Follow RFC 3986.
1737 (org-test-with-temp-text "A link: <point><http://orgmode.org>"
1738 (org-element-type (org-element-context)))))
1740 (equal "//orgmode.org"
1741 (org-test-with-temp-text "A link: <point><http://orgmode\n.org>"
1742 (org-element-property :path
(org-element-context)))))
1743 ;; Link abbreviation.
1746 (org-test-with-temp-text
1747 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1748 (progn (org-mode-restart)
1749 (goto-char (1- (point-max)))
1750 (org-element-property :type
(org-element-context))))))
1751 ;; Link abbreviation in a secondary string.
1754 (org-test-with-temp-text
1755 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1756 (progn (org-mode-restart)
1757 (org-element-map (org-element-parse-buffer) 'link
1758 (lambda (link) (org-element-property :type link
))
1760 ;; Plain links are allowed as description of regular links.
1763 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1764 (search-forward "file:")
1765 (org-element-property :type
(org-element-context)))))
1766 ;; So are angular links.
1769 (org-test-with-temp-text "[[http://orgmode.org][<file:unicorn.jpg>]]"
1770 (search-forward "file:")
1771 (org-element-property :type
(org-element-context))))))
1776 (ert-deftest test-org-element
/macro-parser
()
1777 "Test `macro' parser."
1778 ;; Without arguments.
1780 (org-test-with-temp-text "{{{macro}}}"
1781 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1784 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1785 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1786 ;; Properly handle protected commas in arguments...
1790 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1791 (org-element-property :args
(org-element-context))))))
1792 ;; ... even when last argument ends with a protected comma.
1795 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1796 (org-element-property :args
(org-element-context)))))
1797 ;; Allow to escape escaping character.
1800 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1801 (org-element-property :args
(org-element-context)))))
1802 ;; No need to escape backslashes elsewhere.
1805 (org-test-with-temp-text "{{{macro(\\)}}}"
1806 (org-element-property :args
(org-element-context))))))
1811 (ert-deftest test-org-element
/node-property
()
1812 "Test `node-property' parser."
1815 (equal '("abc" "value")
1816 (org-test-with-temp-text "* H\n:PROPERTIES:\n<point>:abc: value\n:END:"
1817 (let ((element (org-element-at-point)))
1818 (list (org-element-property :key element
)
1819 (org-element-property :value element
))))))
1820 ;; Value should be trimmed.
1823 (org-test-with-temp-text
1824 "* H\n:PROPERTIES:\n<point>:abc: value \n:END:"
1825 (org-element-property :value
(org-element-at-point)))))
1826 ;; A node property requires to be wrapped within a property drawer.
1829 (org-test-with-temp-text ":abc: value"
1830 (org-element-type (org-element-at-point)))))
1831 ;; Accept empty properties.
1833 (equal '(("foo" "value") ("bar" ""))
1834 (org-test-with-temp-text "* H\n:PROPERTIES:\n:foo: value\n:bar:\n:END:"
1835 (org-element-map (org-element-parse-buffer) 'node-property
1837 (list (org-element-property :key p
)
1838 (org-element-property :value p
))))))))
1843 (ert-deftest test-org-element
/paragraph-parser
()
1844 "Test `paragraph' parser."
1847 (org-test-with-temp-text "Paragraph"
1848 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1849 ;; Property find end of a paragraph stuck to another element.
1852 (org-test-with-temp-text "Paragraph\n# Comment"
1853 (org-element-map (org-element-parse-buffer) 'paragraph
1854 (lambda (p) (char-after (org-element-property :end p
)))
1856 ;; Include ill-formed Keywords.
1858 (org-test-with-temp-text "#+wrong_keyword something"
1859 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1860 ;; Include incomplete-drawers.
1862 (org-test-with-temp-text ":TEST:\nParagraph"
1863 (let ((elem (org-element-at-point)))
1864 (and (eq (org-element-type elem
) 'paragraph
)
1865 (= (point-max) (org-element-property :end elem
))))))
1866 ;; Include incomplete blocks.
1868 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1869 (let ((elem (org-element-at-point)))
1870 (and (eq (org-element-type elem
) 'paragraph
)
1871 (= (point-max) (org-element-property :end elem
))))))
1872 ;; Include incomplete dynamic blocks.
1874 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1875 (let ((elem (org-element-at-point)))
1876 (and (eq (org-element-type elem
) 'paragraph
)
1877 (= (point-max) (org-element-property :end elem
))))))
1878 ;; Include incomplete latex environments.
1880 (org-test-with-temp-text "\begin{equation}\nParagraph"
1881 (let ((elem (org-element-at-point)))
1882 (and (eq (org-element-type elem
) 'paragraph
)
1883 (= (point-max) (org-element-property :end elem
))))))
1885 (org-test-with-temp-text "Paragraph\n\begin{equation}"
1886 (let ((elem (org-element-at-point)))
1887 (and (eq (org-element-type elem
) 'paragraph
)
1888 (= (point-max) (org-element-property :end elem
))))))
1889 ;; Stop at affiliated keywords.
1891 (org-test-with-temp-text "Paragraph\n#+NAME: test\n| table |"
1892 (let ((elem (org-element-at-point)))
1893 (and (eq (org-element-type elem
) 'paragraph
)
1894 (not (org-element-property :name elem
))
1895 (= (org-element-property :end elem
) (line-beginning-position 2))))))
1897 (org-test-with-temp-text
1898 "Paragraph\n#+CAPTION[with short caption]: test\n| table |"
1899 (let ((elem (org-element-at-point)))
1900 (and (eq (org-element-type elem
) 'paragraph
)
1901 (not (org-element-property :name elem
))
1902 (= (org-element-property :end elem
) (line-beginning-position 2))))))
1903 ;; Do not steal affiliated keywords from container.
1905 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item<point> 1"
1906 (let ((elem (org-element-at-point)))
1907 (and (eq (org-element-type elem
) 'paragraph
)
1908 (not (org-element-property :attr_latex elem
))
1909 (/= (org-element-property :begin elem
) 1)))))
1910 ;; Handle non-empty blank line at the end of buffer.
1912 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1913 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1918 (ert-deftest test-org-element
/plain-list-parser
()
1919 "Test `plain-list' parser."
1920 (org-test-with-temp-text "- item"
1921 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1922 ;; Blank lines after the list only belong to outer plain list.
1926 (org-test-with-temp-text "
1931 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1932 (lambda (pl) (org-element-property :end pl
)))))
1934 ;; Move to ending of outer list.
1935 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1936 ;; Move to ending of inner list.
1937 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1938 ;; Correctly compute end of list if it doesn't end at a line
1941 (org-test-with-temp-text "- list\n \n "
1942 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1947 (ert-deftest test-org-element
/planning-parser
()
1948 "Test `planning' parser."
1949 ;; Test various keywords.
1951 (org-element-property
1953 (org-test-with-temp-text "* H\n<point>CLOSED: [2012-03-29 thu.]"
1954 (org-element-at-point))))
1956 (org-element-property
1958 (org-test-with-temp-text "* H\n<point>DEADLINE: <2012-03-29 thu.>"
1959 (org-element-at-point))))
1961 (org-element-property
1963 (org-test-with-temp-text "* H\n<point>SCHEDULED: <2012-03-29 thu.>"
1964 (org-element-at-point))))
1965 ;; Planning line only exists right after a headline.
1968 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1969 (org-element-type (org-element-at-point)))))
1972 (org-test-with-temp-text
1973 "* H\n# Comment\n<point>DEADLINE: <2012-03-29 thu.>"
1974 (org-element-type (org-element-at-point)))))
1977 (org-test-with-temp-text
1978 "* H\n\n<point>DEADLINE: <2012-03-29 thu.>"
1979 (org-element-type (org-element-at-point))))))
1982 ;;;; Property Drawer
1984 (ert-deftest test-org-element
/property-drawer-parser
()
1985 "Test `property-drawer' parser."
1988 (eq 'property-drawer
1989 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value\n:END:"
1990 (org-element-type (org-element-at-point)))))
1992 (eq 'property-drawer
1993 (org-test-with-temp-text
1994 "* H\nDEADLINE: <2014-03-04 tue.>\n<point>:PROPERTIES:\n:prop: value\n:END:"
1995 (org-element-type (org-element-at-point)))))
1996 ;; Allow properties without value and no property at all.
1998 (eq 'property-drawer
1999 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop:\n:END:"
2000 (org-element-type (org-element-at-point)))))
2002 (eq 'property-drawer
2003 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:"
2004 (org-element-type (org-element-at-point)))))
2005 ;; Ignore incomplete drawer, drawer at a wrong location or with
2008 (eq 'property-drawer
2009 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value"
2010 (org-element-type (org-element-at-point)))))
2012 (eq 'property-drawer
2013 (org-test-with-temp-text
2014 "* H\nParagraph\n<point>:PROPERTIES:\n:prop: value\n:END:"
2015 (org-element-type (org-element-at-point)))))
2017 (eq 'property-drawer
2018 (org-test-with-temp-text
2019 "* H\nParagraph\n<point>:PROPERTIES:\nparagraph\n:END:"
2020 (org-element-type (org-element-at-point)))))
2022 (eq 'property-drawer
2023 (org-test-with-temp-text
2024 "* H\n\n<point>:PROPERTIES:\n:prop: value\n:END:"
2025 (org-element-type (org-element-at-point)))))
2026 ;; Handle non-empty blank line at the end of buffer.
2028 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:\n "
2029 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2034 (ert-deftest test-org-element
/quote-block-parser
()
2035 "Test `quote-block' parser."
2038 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
2039 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
2040 ;; Ignore incomplete block.
2042 (org-test-with-temp-text "#+BEGIN_QUOTE"
2043 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
2044 ;; Handle non-empty blank line at the end of buffer.
2046 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
2047 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2052 (ert-deftest test-org-element
/radio-target-parser
()
2053 "Test `radio-target' parser."
2057 (org-test-with-temp-text "<<<radio>>>"
2058 (org-element-type (org-element-context)))))
2059 ;; Radio targets with objects.
2062 (org-test-with-temp-text "<<<radio \\alpha>>>"
2063 (org-element-type (org-element-context)))))
2064 ;; Radio targets starting with an object.
2067 (org-test-with-temp-text "<<<\\alpha radio>>>"
2068 (org-element-type (org-element-context)))))
2069 ;; Radio targets cannot begin or end with white space.
2072 (org-test-with-temp-text "<<< radio>>>"
2073 (org-element-type (org-element-context)))))
2076 (org-test-with-temp-text "<<<radio >>>"
2077 (org-element-type (org-element-context))))))
2082 (ert-deftest test-org-element
/section-parser
()
2083 "Test `section' parser."
2086 (org-test-with-temp-text "* Headline\nText"
2087 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2088 ;; There's a section before the first headline.
2090 (org-test-with-temp-text "Text"
2091 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2092 ;; A section cannot be empty.
2094 (org-test-with-temp-text "* Headline 1\n* Headline 2"
2095 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2096 ;; A section doesn't contain sub-trees.
2098 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
2100 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
2101 'headline
'identity
))))
2106 (ert-deftest test-org-element
/special-block-parser
()
2107 "Test `special-block' parser."
2111 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
2112 (org-element-property :type
(org-element-at-point)))))
2113 ;; Special blocks are case sensitive.
2116 (org-test-with-temp-text "#+BEGIN_CaSe\nText\n#+END_CaSe"
2117 (org-element-property :type
(org-element-at-point)))))
2118 ;; Special blocks can contain paragraphs.
2121 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
2123 (org-element-type (org-element-at-point)))))
2124 ;; Ignore incomplete block.
2127 (org-test-with-temp-text "#+BEGIN_SPECIAL"
2128 (org-element-type (org-element-at-point)))))
2129 ;; Allow special characters in type.
2131 (equal '(special-block "SPECIAL*")
2132 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
2133 (let ((element (org-element-at-point)))
2134 (list (org-element-type element
)
2135 (org-element-property :type element
))))))
2136 ;; Handle non-empty blank line at the end of buffer.
2138 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
2139 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2144 (ert-deftest test-org-element
/src-block-parser
()
2145 "Test `src-block' parser."
2148 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
2149 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
2150 ;; Ignore incomplete block.
2152 (org-test-with-temp-text "#+BEGIN_SRC"
2153 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
2154 ;; Properly un-escape code.
2156 (equal "* Headline\n #+keyword\nText\n"
2157 (org-test-with-temp-text
2158 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
2159 (org-element-property :value
(org-element-at-point)))))
2160 ;; Handle non-empty blank line at the end of buffer.
2162 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
2163 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2166 ;;;; Statistics Cookie
2168 (ert-deftest test-org-element
/statistics-cookie
()
2169 "Test `statistics-cookie' parser."
2172 (org-test-with-temp-text "[1/2]"
2173 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
2176 (org-test-with-temp-text "[33%]"
2178 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
2183 (ert-deftest test-org-element
/strike-through-parser
()
2184 "Test `strike-through' parser."
2187 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2188 (org-test-with-temp-text "+strike-through+"
2189 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
2190 ;; Multi-line markup.
2193 (org-element-contents
2194 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2195 (org-test-with-temp-text "+first line\nsecond line+"
2197 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
2198 '("first line\nsecond line"))))
2203 (ert-deftest test-org-element
/subscript-parser
()
2204 "Test `subscript' parser."
2207 (org-test-with-temp-text "a_b"
2208 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
2211 (org-test-with-temp-text "a_{b}"
2212 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
2213 ;; Multiple subscripts in a paragraph.
2216 (org-test-with-temp-text "a_b and c_d"
2218 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
2223 (ert-deftest test-org-element
/superscript-parser
()
2224 "Test `superscript' parser."
2227 (org-test-with-temp-text "a^b"
2228 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2231 (org-test-with-temp-text "a^{b}"
2232 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2233 ;; Multiple superscript in a paragraph.
2236 (org-test-with-temp-text "a^b and c^d"
2239 (org-element-parse-buffer) 'superscript
'identity
))))))
2244 (ert-deftest test-org-element
/table-parser
()
2245 "Test `table' parser."
2247 (org-test-with-temp-text "| a |"
2248 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
2249 ;; TBLFM keyword is case insensitive.
2251 (org-test-with-temp-text "| a |\n#+tblfm: test"
2252 (org-element-property
2254 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
2255 ;; Handle multiple TBLFM lines.
2258 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
2259 (length (org-element-property
2262 (org-element-parse-buffer) 'table
'identity nil t
))))))
2263 ;; Handle non-empty blank line at the end of buffer.
2265 (org-test-with-temp-text "| a |\n "
2266 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2271 (ert-deftest test-org-element
/table-cell-parser
()
2272 "Test `table-cell' parser."
2273 ;; Regular table cell.
2275 (org-test-with-temp-text "| a |"
2276 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
)))
2277 ;; Last vertical bar may be omitted.
2279 (org-test-with-temp-text "| a "
2280 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
2285 (ert-deftest test-org-element
/table-row-parser
()
2286 "Test `table-row' parser."
2288 (equal '(standard rule
)
2289 (org-test-with-temp-text "| a |\n|---|"
2291 (org-element-parse-buffer) 'table-row
2292 (lambda (row) (org-element-property :type row
)))))))
2297 (ert-deftest test-org-element
/target-parser
()
2298 "Test `target' parser."
2300 (org-test-with-temp-text "<<target>>"
2301 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
2306 (ert-deftest test-org-element
/timestamp
()
2307 "Test `timestamp' parser."
2308 ;; Active timestamp.
2310 (org-test-with-temp-text "<2012-03-29 16:40>"
2311 (eq (org-element-property :type
(org-element-context)) 'active
)))
2313 (org-test-with-temp-text "<2012-03-29 Thu>"
2314 (let ((timestamp (org-element-context)))
2315 (or (org-element-property :hour-start timestamp
)
2316 (org-element-property :minute-start timestamp
)))))
2318 (equal '(2012 3 29 16 40)
2319 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
2320 (let ((object (org-element-context)))
2321 (list (org-element-property :year-start object
)
2322 (org-element-property :month-start object
)
2323 (org-element-property :day-start object
)
2324 (org-element-property :hour-start object
)
2325 (org-element-property :minute-start object
))))))
2326 ;; Inactive timestamp.
2328 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
2329 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
2332 (equal '(2012 3 29 16 40 7 30)
2333 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2334 (let ((object (org-element-context)))
2335 (list (org-element-property :year-end object
)
2336 (org-element-property :month-end object
)
2337 (org-element-property :day-end object
)
2338 (org-element-property :hour-end object
)
2339 (org-element-property :minute-end object
)
2340 (org-element-property :hour-start object
)
2341 (org-element-property :minute-start object
))))))
2344 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2345 (org-element-property :type
(org-element-context)))))
2348 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
2349 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
2351 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
2352 (let ((timestamp (org-element-context)))
2353 (or (org-element-property :hour-end timestamp
)
2354 (org-element-property :minute-end timestamp
)))))
2355 ;; With repeater, warning delay and both.
2358 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
2359 (org-element-property :repeater-type
(org-element-context)))))
2362 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
2363 (org-element-property :warning-type
(org-element-context)))))
2365 (equal '(cumulate all
)
2366 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
2367 (let ((ts (org-element-context)))
2368 (list (org-element-property :repeater-type ts
)
2369 (org-element-property :warning-type ts
)))))))
2374 (ert-deftest test-org-element
/underline-parser
()
2375 "Test `underline' parser."
2378 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2379 (org-test-with-temp-text "_underline_"
2380 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
2381 ;; Multi-line markup.
2384 (org-element-contents
2385 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2386 (org-test-with-temp-text "_first line\nsecond line_"
2388 (org-element-parse-buffer) 'underline
'identity nil t
))))
2389 '("first line\nsecond line"))))
2394 (ert-deftest test-org-element
/verbatim-parser
()
2395 "Test `verbatim' parser."
2398 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2399 (org-test-with-temp-text "=verbatim="
2400 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
2401 ;; Multi-line markup.
2404 (org-element-property
2406 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2407 (org-test-with-temp-text "=first line\nsecond line="
2409 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
2410 "first line\nsecond line")))
2415 (ert-deftest test-org-element
/verse-block-parser
()
2416 "Test `verse-block' parser."
2419 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2420 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2423 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2424 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2425 ;; Parse objects in verse blocks.
2427 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2428 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
2429 ;; Ignore incomplete verse block.
2431 (org-test-with-temp-text "#+BEGIN_VERSE"
2432 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
2433 ;; Handle non-empty blank line at the end of buffer.
2435 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2436 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2440 ;;; Test Interpreters.
2442 (ert-deftest test-org-element
/interpret-data
()
2443 "Test `org-element-interpret-data' specifications."
2444 ;; Interpret simple affiliated keywords.
2447 (org-element-interpret-data
2448 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2449 "#+NAME: para\nParagraph\n"))
2450 ;; Interpret multiple affiliated keywords.
2453 (org-element-interpret-data
2454 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2455 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2456 ;; Interpret parsed affiliated keywords.
2459 (org-element-interpret-data
2460 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2461 "#+CAPTION: caption\nParagraph\n"))
2462 ;; Interpret dual affiliated keywords.
2465 (org-element-interpret-data
2466 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2467 "#+CAPTION[short]: long\nParagraph\n"))
2468 ;; Interpret multiple parsed dual keywords.
2471 (org-element-interpret-data
2472 '(org-data nil
(paragraph
2473 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2474 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2475 ;; Pseudo objects and elements are transparent.
2479 (org-element-interpret-data
2480 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")))))
2483 (org-element-interpret-data
2485 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2486 (paragraph nil
"B"))))))
2488 (ert-deftest test-org-element
/center-block-interpreter
()
2489 "Test center block interpreter."
2491 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2492 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2494 (ert-deftest test-org-element
/drawer-interpreter
()
2495 "Test drawer interpreter."
2497 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2498 ":TEST:\nTest\n:END:\n")))
2500 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2501 "Test dynamic block interpreter."
2503 (equal (org-test-parse-and-interpret
2504 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2505 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2507 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2508 "Test footnote definition interpreter."
2509 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2511 (ert-deftest test-org-element
/headline-interpreter
()
2512 "Test headline and section interpreters."
2513 ;; 1. Standard test.
2514 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2515 ;; 2. With TODO keywords.
2517 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2518 (org-test-parse-and-interpret "* TODO Headline"))
2519 "* TODO Headline\n"))
2522 ;; 3.1. ... and a positive `org-tags-column' value.
2524 (equal (let ((org-tags-column 20))
2525 (org-test-parse-and-interpret "* Headline :tag:"))
2526 "* Headline :tag:\n"))
2527 ;; 3.2. ... and a negative `org-tags-column' value.
2529 (equal (let ((org-tags-column -
20))
2530 (org-test-parse-and-interpret "* Headline :tag:"))
2531 "* Headline :tag:\n"))
2532 ;; 3.3. ... and a null `org-tags-column' value.
2534 (equal (let ((org-tags-column 0))
2535 (org-test-parse-and-interpret "* Headline :tag:"))
2536 "* Headline :tag:\n"))
2537 ;; 4. With priority cookie.
2539 (equal (org-test-parse-and-interpret "* [#B] Headline")
2540 "* [#B] Headline\n"))
2541 ;; 5. With comment keyword.
2543 (equal (let ((org-comment-string "COMMENT"))
2544 (org-test-parse-and-interpret "* COMMENT Headline"))
2545 "* COMMENT Headline\n"))
2546 ;; 6. Keep same number of blank lines before body.
2548 (equal (org-test-parse-and-interpret
2549 "* Headline\n\n\nText after two blank lines.")
2550 "* Headline\n\n\nText after two blank lines.\n"))
2551 ;; 8. Preserve `org-odd-levels-only' state.
2553 (equal "* H\n*** H2\n"
2554 (let ((org-odd-levels-only t
))
2555 (org-test-parse-and-interpret "* H\n*** H2")))))
2557 (ert-deftest test-org-element
/inlinetask-interpreter
()
2558 "Test inlinetask interpretation."
2559 (when (featurep 'org-inlinetask
)
2560 (let ((org-inlinetask-min-level 15))
2561 ;; 1. Regular inlinetask.
2562 (should (equal (org-test-parse-and-interpret
2563 "*************** Task\nTest\n*************** END")
2564 "*************** Task\nTest\n*************** END\n"))
2565 ;; 2. Degenerate inlinetask.
2566 (should (equal (org-test-parse-and-interpret "*************** Task")
2567 "*************** Task\n"))
2568 ;; 3. Prefer degenerate form when there are no contents.
2569 (should (equal (org-test-parse-and-interpret
2570 "*************** Task\n*************** END")
2571 "*************** Task\n"))
2572 ;; 4. With TODO keywords.
2574 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2575 (org-test-parse-and-interpret "*************** TODO Task"))
2576 "*************** TODO Task\n"))
2579 ;; 5.1. ... and a positive `org-tags-column' value.
2581 (equal (let ((org-tags-column 30))
2582 (org-test-parse-and-interpret "*************** Task :tag:"))
2583 "*************** Task :tag:\n"))
2584 ;; 5.2. ... and a negative `org-tags-column' value.
2586 (equal (let ((org-tags-column -
30))
2587 (org-test-parse-and-interpret "*************** Task :tag:"))
2588 "*************** Task :tag:\n"))
2589 ;; 5.3. ... and a null `org-tags-column' value.
2591 (equal (let ((org-tags-column 0))
2592 (org-test-parse-and-interpret "*************** Task :tag:"))
2593 "*************** Task :tag:\n"))
2594 ;; 6. With priority cookie.
2596 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2597 "*************** [#B] Task\n")))))
2599 (ert-deftest test-org-element
/plain-list-interpreter
()
2600 "Test plain-list and item interpreters."
2601 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2603 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2604 ;; Description list.
2606 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2609 (equal (let ((org-plain-list-ordered-item-terminator t
))
2610 (org-test-parse-and-interpret "1. Item"))
2613 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2614 (org-test-parse-and-interpret "1) Item"))
2616 ;; Ordered list with counter.
2618 (equal (let ((org-plain-list-ordered-item-terminator t
))
2619 (org-test-parse-and-interpret "1. [@5] Item"))
2621 ;; List with check-boxes.
2623 (equal (org-test-parse-and-interpret
2624 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2625 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2626 ;; Item not starting with a paragraph.
2628 (equal (org-test-parse-and-interpret "-\n | a | b |")
2629 "- \n | a | b |\n"))
2630 ;; Special case: correctly handle "*" bullets.
2631 (should (org-test-parse-and-interpret " * item"))
2632 ;; Special case: correctly handle empty items.
2633 (should (org-test-parse-and-interpret "-"))))
2635 (ert-deftest test-org-element
/quote-block-interpreter
()
2636 "Test quote block interpreter."
2637 (should (equal (org-test-parse-and-interpret
2638 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2639 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2641 (ert-deftest test-org-element
/special-block-interpreter
()
2642 "Test special block interpreter."
2643 (should (equal (org-test-parse-and-interpret
2644 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2645 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2647 (ert-deftest test-org-element
/babel-call-interpreter
()
2648 "Test Babel call interpreter."
2649 ;; Without argument.
2650 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2651 "#+CALL: test()\n"))
2653 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2654 "#+CALL: test(x=2)\n"))
2655 ;; With header arguments.
2656 (should (equal (org-test-parse-and-interpret
2657 "#+CALL: test[:results output]() :results html")
2658 "#+CALL: test[:results output]() :results html\n")))
2660 (ert-deftest test-org-element
/clock-interpreter
()
2661 "Test clock interpreter."
2665 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2666 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2670 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2671 (org-test-parse-and-interpret "
2672 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))))
2674 (ert-deftest test-org-element
/comment-interpreter
()
2675 "Test comment interpreter."
2677 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2679 (should (equal (org-test-parse-and-interpret " # Comment")
2681 ;; Preserve indentation.
2682 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2683 "# No blank\n# One blank\n")))
2685 (ert-deftest test-org-element
/comment-block-interpreter
()
2686 "Test comment block interpreter."
2687 (should (equal (org-test-parse-and-interpret
2688 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2689 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"))
2690 ;; Accept missing final newline in value.
2693 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"
2694 (org-element-interpret-data '(comment-block (:value
"Test"))))))
2696 (ert-deftest test-org-element
/diary-sexp
()
2697 "Test diary-sexp interpreter."
2700 (org-test-parse-and-interpret
2701 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2702 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2704 (ert-deftest test-org-element
/example-block-interpreter
()
2705 "Test example block interpreter."
2706 ;; Without switches.
2707 (should (equal (org-test-parse-and-interpret
2708 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2709 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2712 (equal (org-test-parse-and-interpret
2713 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2714 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2715 ;; Preserve code escaping.
2717 (equal (org-test-parse-and-interpret
2718 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2719 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n"))
2720 ;; Accept missing final newline in value.
2723 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"
2724 (org-element-interpret-data '(example-block (:value
"Test"))))))
2726 (ert-deftest test-org-element
/export-block-interpreter
()
2727 "Test export block interpreter."
2728 (should (equal (org-test-parse-and-interpret
2729 "#+BEGIN_EXPORT HTML\nTest\n#+END_EXPORT")
2730 "#+BEGIN_EXPORT HTML\nTest\n#+END_EXPORT\n")))
2732 (ert-deftest test-org-element
/fixed-width-interpreter
()
2733 "Test fixed width interpreter."
2735 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2736 ;; Preserve indentation.
2737 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2738 ": 2 blanks\n: 1 blank\n"))
2739 ;; Remove last newline character
2741 (equal (org-element-fixed-width-interpreter
2742 '(fixed-width (:value
"Test\n")) nil
)
2745 (equal (org-element-fixed-width-interpreter
2746 '(fixed-width (:value
"Test")) nil
)
2748 ;; Handle empty string.
2750 (equal (org-element-fixed-width-interpreter
2751 '(fixed-width (:value
"")) nil
)
2753 ;; Handle nil value.
2755 (org-element-fixed-width-interpreter
2756 '(fixed-width (:value nil
)) nil
)))
2758 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2759 "Test horizontal rule interpreter."
2760 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2762 (ert-deftest test-org-element
/keyword-interpreter
()
2763 "Test keyword interpreter."
2764 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2765 "#+KEYWORD: value\n")))
2767 (ert-deftest test-org-element
/latex-environment-interpreter
()
2768 "Test latex environment interpreter."
2769 (should (equal (org-test-parse-and-interpret
2770 "\\begin{equation}\n1+1=2\n\\end{equation}")
2771 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2772 (should (equal (org-test-parse-and-interpret
2773 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2774 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2776 (ert-deftest test-org-element
/planning-interpreter
()
2777 "Test planning interpreter."
2781 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2782 (org-test-parse-and-interpret
2784 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2786 (ert-deftest test-org-element
/property-drawer-interpreter
()
2787 "Test property drawer interpreter."
2788 (should (equal (let ((org-property-format "%-10s %s"))
2789 (org-test-parse-and-interpret
2790 "* H\n:PROPERTIES:\n:prop: value\n:END:"))
2791 "* H\n:PROPERTIES:\n:prop: value\n:END:\n")))
2793 (ert-deftest test-org-element
/src-block-interpreter
()
2794 "Test src block interpreter."
2797 (equal (let ((org-edit-src-content-indentation 2)
2798 (org-src-preserve-indentation nil
))
2799 (org-test-parse-and-interpret
2800 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2801 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2804 (equal (let ((org-edit-src-content-indentation 2)
2805 (org-src-preserve-indentation nil
))
2806 (org-test-parse-and-interpret
2807 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2808 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2809 ;; Preserve code escaping.
2811 (equal (let ((org-edit-src-content-indentation 2)
2812 (org-src-preserve-indentation nil
))
2813 (org-test-parse-and-interpret
2814 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2815 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2816 ;; Do not apply `org-edit-src-content-indentation' when preserving
2819 (equal (let ((org-edit-src-content-indentation 2)
2820 (org-src-preserve-indentation t
))
2821 (org-test-parse-and-interpret
2822 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2823 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2825 (equal (let ((org-edit-src-content-indentation 2)
2826 (org-src-preserve-indentation nil
))
2827 (org-test-parse-and-interpret
2828 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2829 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n"))
2830 ;; Accept missing final newline in value.
2833 "#+BEGIN_SRC emacs-lisp\n Test\n#+END_SRC\n"
2834 (let ((org-edit-src-content-indentation 2)
2835 (org-src-preserve-indentation nil
))
2836 (org-element-interpret-data
2837 '(src-block (:language
"emacs-lisp" :value
"Test")))))))
2839 (ert-deftest test-org-element
/table-interpreter
()
2840 "Test table, table-row and table-cell interpreters."
2842 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2843 "| a | b |\n| c | d |\n"))
2844 ;; 2. With horizontal rules.
2845 (should (equal (org-test-parse-and-interpret
2846 "| a | b |\n|---+---|\n| c | d |")
2847 "| a | b |\n|---+---|\n| c | d |\n"))
2848 ;; 3. With meta-data.
2849 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2850 "| / | < | > |\n| * | 1 | 2 |\n"))
2851 ;; 4. With a formula.
2853 (equal (org-test-parse-and-interpret
2854 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2855 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2856 ;; 5. With multiple formulas.
2858 (equal (org-test-parse-and-interpret
2859 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2860 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2862 (ert-deftest test-org-element
/timestamp-interpreter
()
2863 "Test timestamp interpreter."
2866 (string-match "<2012-03-29 .* 16:40>"
2867 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2869 (string-match "<2012-03-29 .* 16:40>"
2870 (org-element-timestamp-interpreter
2872 (:type active
:year-start
2012 :month-start
3 :day-start
29
2873 :hour-start
16 :minute-start
40)) nil
)))
2876 (string-match "\\[2012-03-29 .* 16:40\\]"
2877 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2880 "\\[2012-03-29 .* 16:40\\]"
2881 (org-element-timestamp-interpreter
2883 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2884 :hour-start
16 :minute-start
40)) nil
)))
2887 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2888 (org-test-parse-and-interpret
2889 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2892 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2893 (org-element-timestamp-interpreter
2895 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2896 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2897 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2900 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2901 (org-test-parse-and-interpret
2902 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2905 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2906 (org-element-timestamp-interpreter
2908 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2909 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2910 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2912 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2913 "<%%diary-float t 4 2>\n"))
2914 ;; Timestamp with repeater interval, with delay, with both.
2916 (string-match "<2012-03-29 .* \\+1y>"
2917 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2920 "<2012-03-29 .* \\+1y>"
2921 (org-element-timestamp-interpreter
2923 (:type active
:year-start
2012 :month-start
3 :day-start
29
2924 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2928 "<2012-03-29 .* -1y>"
2929 (org-element-timestamp-interpreter
2931 (:type active
:year-start
2012 :month-start
3 :day-start
29
2932 :warning-type all
:warning-value
1 :warning-unit year
))
2936 "<2012-03-29 .* \\+1y -1y>"
2937 (org-element-timestamp-interpreter
2939 (:type active
:year-start
2012 :month-start
3 :day-start
29
2940 :warning-type all
:warning-value
1 :warning-unit year
2941 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2943 ;; Timestamp range with repeater interval
2945 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2946 (org-test-parse-and-interpret
2947 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2950 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2951 (org-element-timestamp-interpreter
2953 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2954 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2955 :repeater-value
1 :repeater-unit year
))
2958 (ert-deftest test-org-element
/verse-block-interpreter
()
2959 "Test verse block interpretation."
2961 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2962 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2964 (ert-deftest test-org-element
/bold-interpreter
()
2965 "Test bold interpreter."
2966 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2968 (ert-deftest test-org-element
/code-interpreter
()
2969 "Test code interpreter."
2970 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2972 (ert-deftest test-org-element
/entity-interpreter
()
2973 "Test entity interpreter."
2974 ;; 1. Without brackets.
2976 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2977 ;; 2. With brackets.
2979 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2981 (ert-deftest test-org-element
/export-snippet-interpreter
()
2982 "Test export snippet interpreter."
2983 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2984 "@@back-end:contents@@\n")))
2986 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2987 "Test footnote reference interpreter."
2988 ;; Regular reference.
2989 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2991 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2992 "Text[fn:label]\n"))
2993 ;; Inline reference.
2994 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2995 "Text[fn:label:def]\n"))
2996 ;; Anonymous reference.
2997 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2998 "Text[fn::def]\n")))
3000 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
3001 "Test inline babel call interpreter."
3002 ;; Without arguments.
3003 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
3005 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
3006 "call_test(x=2)\n"))
3007 ;; With header arguments.
3008 (should (equal (org-test-parse-and-interpret
3009 "call_test[:results output]()[:results html]")
3010 "call_test[:results output]()[:results html]\n")))
3012 (ert-deftest test-org-element
/inline-src-block-interpreter
()
3013 "Test inline src block interpreter."
3014 ;; 1. Without header argument.
3015 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
3016 "src_emacs-lisp{(+ 1 1)}\n"))
3017 ;; 2. With header arguments.
3018 (should (equal (org-test-parse-and-interpret
3019 "src_emacs-lisp[:results silent]{(+ 1 1)}")
3020 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
3022 (ert-deftest test-org-element
/italic-interpreter
()
3023 "Test italic interpreter."
3024 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
3026 (ert-deftest test-org-element
/latex-fragment-interpreter
()
3027 "Test latex fragment interpreter."
3028 (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
3029 (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
3030 (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
3031 (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
3032 (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
3033 (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
3035 (ert-deftest test-org-element
/line-break-interpreter
()
3036 "Test line break interpreter."
3037 (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
3038 "First line \\\\\nSecond line\n")))
3040 (ert-deftest test-org-element
/link-interpreter
()
3041 "Test link interpreter."
3042 ;; Links targeted from a radio target.
3043 (should (equal (let ((org-target-link-regexp "radio-target"))
3044 (org-test-parse-and-interpret "a radio-target"))
3045 "a radio-target\n"))
3046 ;; Links without description.
3047 (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
3048 "[[http://orgmode.org]]\n"))
3049 ;; Links with a description, even one containing a link.
3050 (should (equal (org-test-parse-and-interpret
3051 "[[http://orgmode.org][Org mode]]")
3052 "[[http://orgmode.org][Org mode]]\n"))
3053 (should (equal (org-test-parse-and-interpret
3054 "[[http://orgmode.org][http://orgmode.org]]")
3055 "[[http://orgmode.org][http://orgmode.org]]\n"))
3058 (equal (org-test-parse-and-interpret "[[file+emacs:todo.org]]")
3059 "[[file+emacs:todo.org]]\n"))
3061 (equal (org-test-parse-and-interpret "[[file:todo.org::*task]]")
3062 "[[file:todo.org::*task]]\n"))
3064 (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
3066 (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
3068 (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
3070 (should (equal (org-test-parse-and-interpret "http://orgmode.org")
3071 "http://orgmode.org\n"))
3073 (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
3074 "<http://orgmode.org>\n"))
3075 ;; Pathological case: link with a %-sign in description.
3076 (should (equal (org-test-parse-and-interpret "[[file://path][%s]]")
3077 "[[file://path][%s]]\n")))
3079 (ert-deftest test-org-element
/macro-interpreter
()
3080 "Test macro interpreter."
3081 ;; 1. Without argument.
3082 (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
3083 ;; 2. With arguments.
3084 (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
3085 "{{{test(arg1,arg2)}}}\n")))
3087 (ert-deftest test-org-element
/radio-target-interpreter
()
3088 "Test radio target interpreter."
3089 (should (equal (org-test-parse-and-interpret "<<<some text>>>")
3090 "<<<some text>>>\n")))
3092 (ert-deftest test-org-element
/statistics-cookie-interpreter
()
3093 "Test statistics cookie interpreter."
3094 ;; 1. Without percent
3095 (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
3097 (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
3099 (ert-deftest test-org-element
/strike-through-interpreter
()
3100 "Test strike through interpreter."
3101 (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
3103 (ert-deftest test-org-element
/subscript-interpreter
()
3104 "Test subscript interpreter."
3105 ;; 1. Without brackets.
3106 (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
3107 ;; 2. With brackets.
3108 (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
3110 (ert-deftest test-org-element
/superscript-interpreter
()
3111 "Test superscript interpreter."
3112 ;; 1. Without brackets.
3113 (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
3114 ;; 2. With brackets.
3115 (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
3117 (ert-deftest test-org-element
/target-interpreter
()
3118 "Test target interpreter."
3119 (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
3121 (ert-deftest test-org-element
/underline-interpreter
()
3122 "Test underline interpreter."
3123 (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
3125 (ert-deftest test-org-element
/verbatim-interpreter
()
3126 "Test verbatim interpreter."
3127 (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
3131 ;;; Test Granularity
3133 (ert-deftest test-org-element
/granularity
()
3134 "Test granularity impact on buffer parsing."
3135 (org-test-with-temp-text "
3142 ;; 1.1. Granularity set to `headline' should parse every headline
3143 ;; in buffer, and only them.
3144 (let ((tree (org-element-parse-buffer 'headline
)))
3145 (should (= 2 (length (org-element-map tree
'headline
'identity
))))
3146 (should-not (org-element-map tree
'paragraph
'identity
)))
3147 ;; 1.2. Granularity set to `greater-element' should not enter
3148 ;; greater elements excepted headlines and sections.
3149 (let ((tree (org-element-parse-buffer 'greater-element
)))
3150 (should (= 1 (length (org-element-map tree
'center-block
'identity
))))
3151 (should (= 1 (length (org-element-map tree
'paragraph
'identity
))))
3152 (should-not (org-element-map tree
'entity
'identity
)))
3153 ;; 1.3. Granularity set to `element' should enter every
3155 (let ((tree (org-element-parse-buffer 'element
)))
3156 (should (= 2 (length (org-element-map tree
'paragraph
'identity
))))
3157 (should-not (org-element-map tree
'entity
'identity
)))
3158 ;; 1.4. Granularity set to `object' can see everything.
3159 (let ((tree (org-element-parse-buffer 'object
)))
3160 (should (= 1 (length (org-element-map tree
'entity
'identity
)))))))
3162 (ert-deftest test-org-element
/secondary-string-parsing
()
3163 "Test if granularity correctly toggles secondary strings parsing."
3164 ;; With a granularity bigger than `object', no secondary string
3165 ;; should be parsed.
3168 (org-test-with-temp-text "* Headline"
3170 (org-element-map (org-element-parse-buffer 'headline
) 'headline
3171 #'identity nil
'first-match
)))
3172 (org-element-property :title headline
)))))
3175 (org-test-with-temp-text "* Headline\n- tag :: item"
3176 (let ((item (org-element-map (org-element-parse-buffer 'element
) 'item
3177 #'identity nil
'first-match
)))
3178 (org-element-property :tag item
)))))
3179 (when (featurep 'org-inlinetask
)
3182 (let ((org-inlinetask-min-level 15))
3183 (org-test-with-temp-text "*************** Inlinetask"
3184 (let ((inlinetask (org-element-map (org-element-parse-buffer 'element
)
3186 #'identity nil
'first-match
)))
3187 (org-element-property :title inlinetask
)))))))
3188 ;; With a default granularity, secondary strings should be parsed.
3191 (org-test-with-temp-text "* Headline"
3193 (org-element-map (org-element-parse-buffer) 'headline
3194 #'identity nil
'first-match
)))
3195 (org-element-property :title headline
)))))
3196 ;; `org-element-at-point' should never parse a secondary string.
3199 (org-test-with-temp-text "* Headline"
3200 (org-element-property :title
(org-element-at-point)))))
3201 ;; Preserve current local variables when parsing a secondary string.
3203 (let ((org-entities nil
)
3204 (org-entities-user nil
))
3205 (org-test-with-temp-text "
3209 # org-entities-user: ((\"foo\"))
3211 (let ((safe-local-variable-values '((org-entities-user .
(("foo"))))))
3212 (hack-local-variables))
3213 (org-element-map (org-element-parse-buffer) 'entity
3214 #'identity nil nil nil t
)))))
3218 ;;; Test Visible Only Parsing
3220 (ert-deftest test-org-element
/parse-buffer-visible
()
3221 "Test `org-element-parse-buffer' with visible only argument."
3223 (equal '("H1" "H3" "H5")
3224 (org-test-with-temp-text
3225 "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
3226 (org-occur ":visible:")
3227 (org-element-map (org-element-parse-buffer nil t
) 'headline
3228 (lambda (hl) (org-element-property :raw-value hl
)))))))
3232 ;;; Test `:parent' Property
3234 (ert-deftest test-org-element
/parent-property
()
3235 "Test `:parent' property."
3237 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
3238 (let* ((tree (org-element-parse-buffer))
3239 (parent (org-element-property
3241 (org-element-map tree
'paragraph
'identity nil t
))))
3243 (should (eq (org-element-map tree
'center-block
'identity nil t
)
3246 (org-test-with-temp-text "a_{/b/}"
3247 (let* ((tree (org-element-parse-buffer))
3248 (parent (org-element-property
3250 (org-element-map tree
'italic
'identity nil t
))))
3253 (org-element-map tree
'subscript
'identity nil t
)))))
3254 ;; Secondary strings
3255 (org-test-with-temp-text "* /italic/"
3256 (let* ((tree (org-element-parse-buffer))
3257 (parent (org-element-property
3258 :parent
(org-element-map tree
'italic
'identity nil t
))))
3261 (org-element-map tree
'headline
'identity nil t
))))))
3265 ;;; Test Normalize Contents
3267 (ert-deftest test-org-element
/normalize-contents
()
3268 "Test `org-element-normalize-contents' specifications."
3269 ;; Remove maximum common indentation from element's contents.
3272 (org-element-normalize-contents
3273 '(paragraph nil
" Two spaces\n Three spaces"))
3274 '(paragraph nil
"Two spaces\n Three spaces")))
3277 (org-element-normalize-contents
3278 '(paragraph nil
" Two spaces\nNo space"))
3279 '(paragraph nil
" Two spaces\nNo space")))
3280 ;; Ignore objects within contents when computing maximum common
3281 ;; indentation. However, if contents start with an object, common
3282 ;; indentation is 0.
3285 (org-element-normalize-contents
3286 '(paragraph nil
" One " (emphasis nil
"space") "\n Two spaces"))
3287 '(paragraph nil
"One " (emphasis nil
"space") "\n Two spaces")))
3290 (org-element-normalize-contents
3291 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three"))
3292 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three")))
3293 ;; Ignore blank lines.
3296 (org-element-normalize-contents
3297 '(paragraph nil
" Two spaces\n\n \n Two spaces"))
3298 '(paragraph nil
"Two spaces\n\n\nTwo spaces")))
3301 '(paragraph nil
" Two spaces\n" (verbatim nil
"V") "\n Two spaces")
3302 (org-element-normalize-contents
3303 '(paragraph nil
" Two spaces\n " (verbatim nil
"V") "\n Two spaces"))))
3306 '(verse-block nil
"line 1\n\nline 2")
3307 (org-element-normalize-contents
3308 '(verse-block nil
" line 1\n\n line 2"))))
3309 ;; Recursively enter objects in order to compute common indentation.
3312 (org-element-normalize-contents
3313 '(paragraph nil
" Two spaces " (bold nil
" and\n One space")))
3314 '(paragraph nil
" Two spaces " (bold nil
" and\nOne space"))))
3315 ;; When optional argument is provided, ignore first line
3319 (org-element-normalize-contents
3320 '(paragraph nil
"No space\n Two spaces\n Three spaces") t
)
3321 '(paragraph nil
"No space\nTwo spaces\n Three spaces")))
3324 (org-element-normalize-contents
3325 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three") t
)
3326 '(paragraph nil
(verbatim nil
"V") "No space\nTwo\n Three")))
3327 ;; Corner case: do not ignore indentation of string right after
3331 (org-element-normalize-contents
3332 '(paragraph nil
" 1 space" (line-break) " 2 spaces"))
3333 '(paragraph nil
"1 space" (line-break) " 2 spaces"))))
3337 ;;; Test Navigation Tools.
3339 (ert-deftest test-org-element
/at-point
()
3340 "Test `org-element-at-point' specifications."
3341 ;; Return closest element containing point.
3344 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3345 (progn (search-forward "A")
3346 (org-element-type (org-element-at-point))))))
3347 ;; Correctly set `:parent' property.
3350 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3351 (progn (search-forward "A")
3353 (org-element-property :parent
(org-element-at-point)))))))
3354 ;; Special case: at a blank line just below a headline, return that
3357 (equal "H1" (org-test-with-temp-text "* H1\n \n* H2\n"
3359 (org-element-property :title
(org-element-at-point)))))
3360 ;; Special case: at the very beginning of a table, return `table'
3361 ;; object instead of `table-row'.
3364 (org-test-with-temp-text "| a | b |"
3365 (org-element-type (org-element-at-point)))))
3366 ;; Special case: at the very beginning of a list or sub-list, return
3367 ;; `plain-list' object instead of `item'.
3370 (org-test-with-temp-text "- item"
3371 (org-element-type (org-element-at-point)))))
3372 ;; Special case: at the closing line of a greater element, be sure
3373 ;; to return it instead of the last element in its contents.
3376 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
3377 (progn (forward-line 2)
3378 (org-element-type (org-element-at-point))))))
3379 ;; Special case: at a blank line between two items, be sure to
3380 ;; return item above instead of the last element of its contents.
3383 (org-test-with-temp-text "- Para1\n\n- Para2"
3385 (org-element-type (org-element-at-point)))))
3386 ;; Special case: at the last blank line in a plain list, return it
3387 ;; instead of the last item.
3390 (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
3391 (progn (forward-line 2)
3392 (org-element-type (org-element-at-point))))))
3393 ;; Special case: when a list ends at the end of buffer and there's
3394 ;; no final newline, return last element in last item.
3397 (org-test-with-temp-text "- a"
3399 (org-element-type (org-element-at-point)))))
3400 ;; Parse a list within a block itself contained in a list.
3403 (org-test-with-temp-text
3404 "- outer\n #+begin_center\n - inner\n #+end_center"
3405 (search-forward "inner")
3407 (org-element-type (org-element-at-point)))))
3408 ;; Do not error at eob on an empty line.
3410 (org-test-with-temp-text "* H\n"
3412 (or (org-element-at-point) t
))))
3414 (ert-deftest test-org-element
/context
()
3415 "Test `org-element-context' specifications."
3416 ;; Return closest object containing point.
3419 (org-test-with-temp-text "Some *text with _under<point>line_ text*"
3420 (org-element-type (org-element-context)))))
3421 ;; Find objects in secondary strings.
3424 (org-test-with-temp-text "* Headline _<point>with_ underlining"
3425 (org-element-type (org-element-context)))))
3426 ;; Find objects in objects.
3429 (org-test-with-temp-text "| a | {<point>{{macro}}} |"
3430 (org-element-type (org-element-context)))))
3433 (org-test-with-temp-text "| a | b<point> {{{macro}}} |"
3434 (org-element-type (org-element-context)))))
3435 ;; Find objects in planning lines.
3438 (org-test-with-temp-text "* H\n SCHEDULED: <2012<point>-03-29 thu.>"
3439 (org-element-type (org-element-context)))))
3442 (org-test-with-temp-text "* H\n SCHEDULED<point>: <2012-03-29 thu.>"
3443 (org-element-type (org-element-context)))))
3444 ;; Find objects in item tags.
3447 (org-test-with-temp-text "- *bo<point>ld* ::"
3448 (org-element-type (org-element-context)))))
3451 (org-test-with-temp-text "- *bold* ::<point>"
3452 (org-element-type (org-element-context)))))
3455 (org-test-with-temp-text "- *bold* ::\n<point>"
3456 (org-element-type (org-element-context)))))
3457 ;; Do not find objects in table rules.
3460 (org-test-with-temp-text "| a | b |\n|-<point>--|---|\n| c | d |"
3461 (org-element-type (org-element-context)))))
3462 ;; Find objects in parsed affiliated keywords.
3465 (org-test-with-temp-text "#+CAPTION: {<point>{{macro}}}\n| a | b |"
3466 (org-element-type (org-element-context)))))
3469 (org-test-with-temp-text "#+caption: *<point>bold*\nParagraph"
3470 (org-element-type (org-element-context)))))
3471 ;; Find objects at the end of buffer.
3474 (org-test-with-temp-text "*bold*"
3475 (goto-char (point-max))
3476 (org-element-type (org-element-context)))))
3477 ;; Correctly set `:parent' property.
3480 (org-test-with-temp-text "Some *bold<point>* text"
3482 (org-element-property :parent
(org-element-context))))))
3483 ;; Between two objects, return the second one.
3486 (org-test-with-temp-text "<<target>><point>{{{test}}}"
3487 (org-element-type (org-element-context)))))
3488 ;; Test optional argument.
3491 (org-test-with-temp-text "Some *text with _under<point>line_ text*"
3492 (org-element-type (org-element-context (org-element-at-point))))))
3493 ;; Special case: bold object at the beginning of a headline.
3496 (org-test-with-temp-text "* *bo<point>ld*"
3497 (org-element-type (org-element-context)))))
3498 ;; Special case: incomplete cell at the end of a table row.
3501 (org-test-with-temp-text "|a|b|c<point>"
3502 (org-element-type (org-element-context)))))
3503 ;; Special case: objects in inline footnotes.
3506 (org-test-with-temp-text "[fn::[[<point>http://orgmode.org]]]"
3507 (org-element-type (org-element-context)))))
3508 ;; Special case: tags looking like a link.
3511 (org-test-with-temp-text "* Headline :file<point>:tags:"
3512 (org-element-type (org-element-context)))))
3515 (org-test-with-temp-text "* Headline :file<point>:tags: :real:tag:"
3516 (org-element-type (org-element-context))))))
3522 (ert-deftest test-org-element
/lineage
()
3523 "Test `org-element-lineage' specifications."
3524 ;; Regular tests. When applied to an element or object returned by
3525 ;; `org-element-at-point' or `org-element-context', the list is
3526 ;; limited to the current section.
3528 (equal '(paragraph center-block
)
3529 (org-test-with-temp-text
3530 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3531 (mapcar #'car
(org-element-lineage (org-element-context))))))
3533 (equal '(paragraph center-block section headline headline org-data
)
3534 (org-test-with-temp-text
3535 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3537 (org-element-lineage
3538 (org-element-map (org-element-parse-buffer) 'bold
3539 #'identity nil t
))))))
3540 ;; Test TYPES optional argument.
3543 (org-test-with-temp-text
3544 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3546 (org-element-lineage (org-element-context) '(center-block))))))
3548 (org-test-with-temp-text
3549 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3550 (org-element-lineage (org-element-context) '(example-block))))
3551 ;; Test WITH-SELF optional argument.
3553 (equal '(bold paragraph center-block
)
3554 (org-test-with-temp-text
3555 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3556 (mapcar #'car
(org-element-lineage (org-element-context) nil t
)))))
3557 ;; When TYPES and WITH-SELF are provided, the latter is also checked
3558 ;; against the former.
3560 (org-test-with-temp-text
3561 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3562 (org-element-lineage (org-element-context) '(bold) t
))))
3568 (ert-deftest test-org-element
/cache
()
3569 "Test basic expectations and common pitfalls for cache."
3573 (org-test-with-temp-text "para1\n\npara2\n\npara3"
3574 (let ((org-element-use-cache t
))
3575 (save-excursion (goto-char (point-max)) (org-element-at-point))
3578 (let ((element (org-element-at-point)))
3579 (cons (org-element-property :begin element
)
3580 (org-element-property :end element
)))))))
3581 ;; Partial shifting: when the contents of a greater element are
3582 ;; modified, only shift ending positions.
3584 (org-test-with-temp-text
3585 "#+BEGIN_CENTER\nPara1\n\nPara2\n\nPara3\n#+END_CENTER"
3586 (let ((org-element-use-cache t
))
3587 (save-excursion (search-forward "3") (org-element-at-point))
3588 (search-forward "Para2")
3590 (let ((element (org-element-property :parent
(org-element-at-point))))
3591 (equal (cons (org-element-property :begin element
)
3592 (org-element-property :end element
))
3593 (cons (point-min) (point-max)))))))
3594 ;; Re-parent shifted elements.
3597 (org-test-with-temp-text "- item\n\n\n para1\n para2"
3598 (let ((org-element-use-cache t
))
3600 (org-element-at-point)
3601 (save-excursion (goto-char (point-max)) (org-element-at-point))
3604 (goto-char (point-max))
3606 (org-element-property :parent
(org-element-at-point)))))))
3607 ;; Preserve local structures when re-parenting.
3610 (org-test-with-temp-text
3611 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n| c | d |\n#+end_center"
3612 (let ((org-element-use-cache t
))
3613 (save-excursion (search-forward "| c |") (org-element-at-point))
3615 (search-forward "| c |")
3618 (org-element-property :parent
(org-element-at-point)))))))
3621 (org-test-with-temp-text
3622 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n#+end_center"
3623 (let ((org-element-use-cache t
))
3624 (save-excursion (search-forward "| a |") (org-element-at-point))
3626 (search-forward "| a |")
3629 (org-element-property :parent
(org-element-at-point)))))))
3630 ;; When re-parenting, also propagate changes to list structures.
3633 (org-test-with-temp-text "\n Para\n - item<point>"
3634 (let ((org-element-use-cache t
))
3635 (org-element-at-point)
3636 (goto-char (point-min))
3638 (search-forward "- item")
3640 (length (org-element-property :structure
(org-element-at-point)))))))
3641 ;; Modifying the last line of an element alters the element below.
3643 (org-test-with-temp-text "para1\n\npara2"
3644 (let ((org-element-use-cache t
))
3645 (goto-char (point-max))
3646 (org-element-at-point)
3649 (let ((element (org-element-at-point)))
3650 (equal (cons (org-element-property :begin element
)
3651 (org-element-property :end element
))
3652 (cons (point-min) (point-max)))))))
3653 ;; Modifying the first line of an element alters the element above.
3655 (org-test-with-temp-text ": fixed-width\n:not-fixed-width"
3656 (let ((org-element-use-cache t
))
3657 (goto-char (point-max))
3658 (org-element-at-point)
3659 (search-backward ":")
3662 (let ((element (org-element-at-point)))
3663 (equal (cons (org-element-property :begin element
)
3664 (org-element-property :end element
))
3665 (cons (point-min) (point-max)))))))
3666 ;; Sensitive change: adding a line alters document structure both
3670 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n"
3671 (let ((org-element-use-cache t
))
3672 (goto-char (point-max))
3673 (org-element-at-point)
3674 (insert "#+END_EXAMPLE")
3675 (search-backward "Para1")
3676 (org-element-type (org-element-at-point))))))
3679 (org-test-with-temp-text "Para1\n\nPara2\n#+END_EXAMPLE"
3680 (let ((org-element-use-cache t
))
3681 (save-excursion (goto-char (point-max)) (org-element-at-point))
3682 (insert "#+BEGIN_EXAMPLE\n")
3683 (search-forward "Para2")
3684 (org-element-type (org-element-at-point))))))
3685 ;; Sensitive change: removing a line alters document structure both
3689 (org-test-with-temp-text
3690 "# +BEGIN_EXAMPLE\nPara1\n\nPara2\n#+END_EXAMPLE"
3691 (let ((org-element-use-cache t
))
3692 (save-excursion (goto-char (point-max)) (org-element-at-point))
3695 (search-forward "Para2")
3696 (org-element-type (org-element-at-point))))))
3699 (org-test-with-temp-text
3700 "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n# +END_EXAMPLE"
3701 (let ((org-element-use-cache t
))
3702 (save-excursion (goto-char (point-max)) (org-element-at-point))
3703 (search-forward "# ")
3705 (search-backward "Para1")
3706 (org-element-type (org-element-at-point))))))
3707 ;; Corner case: watch out drawers named "PROPERTIES" as they are
3708 ;; fragile, unlike to other drawers.
3711 (org-test-with-temp-text "* H\n:PROPERTIES:\n:A: 1\n:A<point>\n:END:"
3712 (let ((org-element-use-cache t
))
3713 (org-element-at-point)
3715 (org-element-type (org-element-at-point))))))
3716 ;; Properly handle elements not altered by modifications but whose
3717 ;; parents were removed from cache.
3719 (org-test-with-temp-text
3720 "Paragraph\n\n\n\n#+begin_center\n<point>contents\n#+end_center"
3721 (let ((org-element-use-cache t
)
3722 (parent-end (point-max)))
3723 (org-element-at-point)
3724 (save-excursion (search-backward "Paragraph")
3727 (eq (org-element-property
3728 :end
(org-element-property :parent
(org-element-at-point)))
3729 (+ parent-end
3))))))
3732 (provide 'test-org-element
)
3734 ;;; test-org-element.el ends here