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
/adopt-elements
()
144 "Test `org-element-adopt-elements' specifications."
147 (equal '(plain-text italic
)
148 (org-test-with-temp-text "* Headline\n *a*"
149 (let ((tree (org-element-parse-buffer)))
150 (org-element-adopt-elements
151 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"a"))
152 (mapcar (lambda (blob) (org-element-type blob
))
153 (org-element-contents
154 (org-element-map tree
'bold
'identity nil t
)))))))
158 (org-test-with-temp-text "* Headline\n *a*"
159 (let ((tree (org-element-parse-buffer)))
160 (org-element-adopt-elements
161 (org-element-map tree
'bold
'identity nil t
) "b")
162 (org-element-contents
163 (org-element-map tree
'bold
'identity nil t
)))))))
165 (ert-deftest test-org-element
/extract-element
()
166 "Test `org-element-extract-element' specifications."
167 ;; Extract a greater element.
169 (equal '(org-data nil
)
170 (org-test-with-temp-text "* Headline"
171 (let* ((tree (org-element-parse-buffer))
172 (element (org-element-map tree
'headline
'identity nil t
)))
173 (org-element-extract-element element
)
175 ;; Extract an element.
178 (org-test-with-temp-text "Paragraph"
179 (let* ((tree (org-element-parse-buffer))
180 (element (org-element-map tree
'paragraph
'identity nil t
)))
181 (org-element-extract-element element
)
185 ;; Extract an object, even in a secondary string.
188 (org-test-with-temp-text "*bold*"
189 (let* ((tree (org-element-parse-buffer))
190 (element (org-element-map tree
'bold
'identity nil t
)))
191 (org-element-extract-element element
)
197 (org-test-with-temp-text "* Headline *bold*"
198 (let* ((tree (org-element-parse-buffer))
199 (element (org-element-map tree
'bold
'identity nil t
)))
200 (org-element-extract-element element
)
204 ;; Return value doesn't have any :parent set.
206 (org-element-property
208 (org-test-with-temp-text "* Headline\n Paragraph with *bold* text."
209 (let* ((tree (org-element-parse-buffer))
210 (element (org-element-map tree
'bold
'identity nil t
)))
211 (org-element-extract-element element
))))))
213 (ert-deftest test-org-element
/insert-before
()
214 "Test `org-element-insert-before' specifications."
218 '(italic entity bold
)
219 (org-test-with-temp-text "/some/ *paragraph*"
220 (let* ((tree (org-element-parse-buffer))
221 (paragraph (org-element-map tree
'paragraph
'identity nil t
))
222 (bold (org-element-map tree
'bold
'identity nil t
)))
223 (org-element-insert-before '(entity (:name
"\\alpha")) bold
)
224 (org-element-map tree
'(bold entity italic
) #'org-element-type nil
)))))
225 ;; Insert an object in a secondary string.
229 (org-test-with-temp-text "* /A/\n Paragraph."
230 (let* ((tree (org-element-parse-buffer))
231 (headline (org-element-map tree
'headline
'identity nil t
))
232 (italic (org-element-map tree
'italic
'identity nil t
)))
233 (org-element-insert-before '(entity (:name
"\\alpha")) italic
)
234 (org-element-map (org-element-property :title headline
) '(entity italic
)
235 #'org-element-type
))))))
237 (ert-deftest test-org-element
/set-element
()
238 "Test `org-element-set-element' specifications."
239 ;; Check if new element is inserted.
241 (org-test-with-temp-text "* Headline\n*a*"
242 (let* ((tree (org-element-parse-buffer))
243 (bold (org-element-map tree
'bold
'identity nil t
)))
244 (org-element-set-element bold
'(italic nil
"b"))
245 (org-element-map tree
'italic
'identity
))))
246 ;; Check if old element is removed.
248 (org-test-with-temp-text "* Headline\n*a*"
249 (let* ((tree (org-element-parse-buffer))
250 (bold (org-element-map tree
'bold
'identity nil t
)))
251 (org-element-set-element bold
'(italic nil
"b"))
252 (org-element-map tree
'bold
'identity
))))
253 ;; Check if :parent property is correctly set.
256 (org-test-with-temp-text "* Headline\n*a*"
257 (let* ((tree (org-element-parse-buffer))
258 (bold (org-element-map tree
'bold
'identity nil t
)))
259 (org-element-set-element bold
'(italic nil
"b"))
261 (org-element-property
262 :parent
(org-element-map tree
'italic
'identity nil t
)))))))
263 ;; Allow to replace strings with elements.
266 (org-test-with-temp-text "* Headline"
267 (let* ((tree (org-element-parse-buffer))
268 (text (org-element-map tree
'plain-text
'identity nil t
)))
269 (org-element-set-element text
(list 'bold nil
"b"))
270 (org-element-map tree
'plain-text
'identity
)))))
271 ;; Allow to replace elements with strings.
274 (org-test-with-temp-text "* =verbatim="
275 (let* ((tree (org-element-parse-buffer))
276 (verb (org-element-map tree
'verbatim
'identity nil t
)))
277 (org-element-set-element verb
"a")
278 (org-element-map tree
'plain-text
'identity nil t
)))))
279 ;; Allow to replace strings with strings.
282 (org-test-with-temp-text "a"
283 (let* ((tree (org-element-parse-buffer))
284 (text (org-element-map tree
'plain-text
'identity nil t
)))
285 (org-element-set-element text
"b")
286 (org-element-map tree
'plain-text
'identity nil t
))))))
288 (ert-deftest test-org-element
/copy
()
289 "Test `org-element-copy' specifications."
292 (org-test-with-temp-text "*bold*"
293 (org-element-type (org-element-copy (org-element-context))))))
294 (should (eq 'plain-text
295 (org-test-with-temp-text "*bold*"
297 (org-element-map (org-element-parse-buffer) 'plain-text
298 #'org-element-copy nil t
)))))
299 ;; Preserve properties except `:parent'.
301 (org-test-with-temp-text "*bold*"
302 (org-element-property
303 :end
(org-element-copy (org-element-context))))))
305 (org-test-with-temp-text "*bold*"
306 (org-element-property
307 :parent
(org-element-copy (org-element-context)))))
309 (org-test-with-temp-text "*bold*"
310 (org-element-property
312 (org-element-map (org-element-parse-buffer) 'plain-text
313 #'org-element-copy nil t
))))
314 ;; Copying nil returns nil.
315 (should-not (org-element-copy nil
))
316 ;; Return a copy secondary strings.
317 (should (equal '("text") (org-element-copy '("text"))))
318 (should-not (eq '("text") (org-element-copy '("text")))))
324 ;;;; Affiliated Keywords
326 (ert-deftest test-org-element
/affiliated-keywords-parser
()
327 "Test affiliated keywords parsing."
328 ;; Read simple keywords.
331 (org-element-property
333 (org-test-with-temp-text "#+NAME: para\nParagraph"
334 (org-element-at-point)))))
337 (org-element-property
339 (org-test-with-temp-text "#+NAME: para\nParagraph"
340 (org-element-at-point)))))
341 ;; Parse multiple keywords.
345 (org-element-property
347 (org-test-with-temp-text
348 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
349 (org-element-at-point)))))
350 ;; Parse "parsed" keywords.
354 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
355 (car (org-element-property :caption
(org-element-at-point))))))
356 ;; Parse dual keywords.
359 '((("long") "short"))
360 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
361 (org-element-property :caption
(org-element-at-point)))))
362 ;; Allow multiple caption keywords.
365 '((("l2") "s2") (("l1") "s1"))
366 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
367 (org-element-property :caption
(org-element-at-point)))))
370 '((("l1")) (nil "s1"))
371 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
372 (org-element-property :caption
(org-element-at-point)))))
373 ;; Corner case: orphaned keyword at the end of an element.
376 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
377 (progn (search-forward "name")
378 (org-element-type (org-element-at-point))))))
380 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
381 (progn (search-forward "Some")
382 (org-element-property :name
(org-element-at-point))))))
387 (ert-deftest test-org-element
/babel-call-parser
()
388 "Test `babel-call' parsing."
392 (org-test-with-temp-text "#+CALL: test()"
393 (org-element-type (org-element-at-point)))))
397 (org-test-with-temp-text "#+call: test()"
398 (org-element-type (org-element-at-point)))))
399 ;; Handle non-empty blank line at the end of buffer.
401 (org-test-with-temp-text "#+CALL: test()\n "
402 (= (org-element-property :end
(org-element-at-point)) (point-max))))
406 (org-test-with-temp-text "#+CALL: test()"
407 (org-element-property :call
(org-element-at-point)))))
408 ;; Parse inside header.
410 (equal ":results output"
411 (org-test-with-temp-text "#+CALL: test[:results output]()"
412 (org-element-property :inside-header
(org-element-at-point)))))
413 ;; Parse arguments, which can be nested.
416 (org-test-with-temp-text "#+CALL: test(n=4)"
417 (org-element-property :arguments
(org-element-at-point)))))
420 (org-test-with-temp-text "#+CALL: test(test())"
421 (org-element-property :arguments
(org-element-at-point)))))
424 (equal ":results html"
425 (org-test-with-temp-text "#+CALL: test() :results html"
426 (org-element-property :end-header
(org-element-at-point))))))
431 (ert-deftest test-org-element
/bold-parser
()
432 "Test `bold' parser."
435 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
436 (org-test-with-temp-text "*bold*"
437 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
438 ;; Multi-line markup.
441 (org-element-contents
442 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
443 (org-test-with-temp-text "*first line\nsecond line*"
444 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
445 '("first line\nsecond line"))))
450 (ert-deftest test-org-element
/center-block-parser
()
451 "Test `center-block' parser."
454 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
455 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
458 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
459 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
460 ;; Ignore incomplete block.
462 (org-test-with-temp-text "#+BEGIN_CENTER"
463 (org-element-map (org-element-parse-buffer) 'center-block
465 ;; Handle non-empty blank line at the end of buffer.
467 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
468 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
473 (ert-deftest test-org-element
/clock-parser
()
474 "Test `clock' parser."
476 (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
477 (org-element-at-point))))
478 (should (eq (org-element-property :status clock
) 'running
))
480 (equal (org-element-property :raw-value
481 (org-element-property :value clock
))
482 "[2012-01-01 sun. 00:01]"))
483 (should-not (org-element-property :duration clock
)))
486 (org-test-with-temp-text
487 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
488 (org-element-at-point))))
489 (should (eq (org-element-property :status clock
) 'closed
))
490 (should (equal (org-element-property :raw-value
491 (org-element-property :value clock
))
492 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
493 (should (equal (org-element-property :duration clock
) "0:01"))))
498 (ert-deftest test-org-element
/code-parser
()
499 "Test `code' parser."
502 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
503 (org-test-with-temp-text "~code~"
504 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
505 ;; Multi-line markup.
508 (org-element-property
510 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
511 (org-test-with-temp-text "~first line\nsecond line~"
513 (org-element-parse-buffer) 'code
'identity nil t
))))
514 "first line\nsecond line")))
519 (ert-deftest test-org-element
/comment-parser
()
520 "Test `comment' parser."
523 (org-test-with-temp-text "# Comment"
524 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
527 (org-test-with-temp-text " # Comment"
528 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
529 ;; Preserve indentation.
532 (org-element-property
534 (org-test-with-temp-text "# No blank\n# One blank"
535 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
536 "No blank\n One blank"))
537 ;; Comment with blank lines.
540 (org-element-property
542 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
543 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
544 "First part\n\n\nSecond part"))
545 ;; Do not mix comments and keywords.
548 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
549 (length (org-element-map (org-element-parse-buffer) 'comment
553 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
554 (org-element-property
556 (org-element-map (org-element-parse-buffer) 'comment
558 ;; Correctly handle non-empty blank lines at the end of buffer.
560 (org-test-with-temp-text "# A\n "
561 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
566 (ert-deftest test-org-element
/comment-block-parser
()
567 "Test `comment-block' parser."
570 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
571 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
574 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
575 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
576 ;; Ignore incomplete block.
578 (org-test-with-temp-text "#+BEGIN_COMMENT"
579 (org-element-map (org-element-parse-buffer) 'comment-block
581 ;; Handle non-empty blank line at the end of buffer.
583 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
584 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
589 (ert-deftest test-org-element
/diary-sexp-parser
()
590 "Test `diary-sexp' parser."
594 (org-test-with-temp-text
595 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
596 (org-element-type (org-element-at-point)))))
597 ;; Diary sexp must live at beginning of line
600 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
601 (org-element-type (org-element-at-point)))))
602 ;; Handle non-empty blank line at the end of buffer.
604 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
605 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
610 (ert-deftest test-org-element
/drawer-parser
()
611 "Test `drawer' parser."
614 (org-test-with-temp-text ":TEST:\nText\n:END:"
615 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
616 ;; Ignore incomplete drawer.
618 (org-test-with-temp-text ":TEST:"
619 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
620 ;; Handle non-empty blank line at the end of buffer.
622 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
623 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
628 (ert-deftest test-org-element
/dynamic-block-parser
()
629 "Test `dynamic-block' parser."
632 (org-test-with-temp-text
633 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
634 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
637 (org-test-with-temp-text
638 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
639 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
640 ;; Ignore incomplete block.
642 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
643 (org-element-map (org-element-parse-buffer) 'dynamic-block
645 ;; Handle non-empty blank line at the end of buffer.
647 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
648 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
653 (ert-deftest test-org-element
/entity-parser
()
654 "Test `entity' parser."
657 (org-test-with-temp-text "\\sin"
658 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
661 (org-element-property
663 (org-test-with-temp-text "\\alpha{}text"
664 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
665 ;; User-defined entity.
668 (org-element-property
670 (let ((org-entities-user
671 '(("test" "test" nil
"test" "test" "test" "test"))))
672 (org-test-with-temp-text "\\test"
673 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
675 ;; Special case: entity at the end of a container.
678 (org-test-with-temp-text "*\\alpha \\beta*"
679 (search-forward "be")
680 (org-element-type (org-element-context))))))
685 (ert-deftest test-org-element
/example-block-parser
()
686 "Test `example-block' parser."
689 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
690 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
691 ;; Ignore incomplete block.
694 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
695 (org-element-type (org-element-at-point)))))
696 ;; Properly un-escape code.
698 (equal "* Headline\n #+keyword\nText\n"
699 (org-test-with-temp-text
700 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
701 (org-element-property :value
(org-element-at-point)))))
702 ;; Handle non-empty blank line at the end of buffer.
704 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
705 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
707 (ert-deftest test-org-element
/block-switches
()
708 "Test `example-block' and `src-block' switches parsing."
709 (let ((org-coderef-label-format "(ref:%s)"))
710 ;; 1. Test "-i" switch.
712 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
713 (org-element-property :preserve-indent
(org-element-at-point))))
715 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
716 (org-element-property :preserve-indent
(org-element-at-point))))
718 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
719 (org-element-property :preserve-indent
(org-element-at-point))))
721 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
722 (org-element-property :preserve-indent
(org-element-at-point))))
723 ;; 2. "-n -r -k" combination should number lines, retain labels but
724 ;; not use them in coderefs.
725 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
726 (let ((element (org-element-at-point)))
727 (should (org-element-property :number-lines element
))
728 (should (org-element-property :retain-labels element
))
729 (should-not (org-element-property :use-labels element
))))
730 (org-test-with-temp-text
731 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
732 (let ((element (org-element-at-point)))
733 (should (org-element-property :number-lines element
))
734 (should (org-element-property :retain-labels element
))
735 (should-not (org-element-property :use-labels element
))))
736 ;; 3. "-n -r" combination should number-lines remove labels and not
737 ;; use them in coderefs.
738 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
739 (let ((element (org-element-at-point)))
740 (should (org-element-property :number-lines element
))
741 (should-not (org-element-property :retain-labels element
))
742 (should-not (org-element-property :use-labels element
))))
743 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
744 (let ((element (org-element-at-point)))
745 (should (org-element-property :number-lines element
))
746 (should-not (org-element-property :retain-labels element
))
747 (should-not (org-element-property :use-labels element
))))
748 ;; 4. "-n" or "+n" should number lines, retain labels and use them
751 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
752 (let ((element (org-element-at-point)))
753 (and (org-element-property :number-lines element
)
754 (org-element-property :retain-labels element
)
755 (org-element-property :use-labels element
)))))
757 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
758 (let ((element (org-element-at-point)))
759 (and (org-element-property :number-lines element
)
760 (org-element-property :retain-labels element
)
761 (org-element-property :use-labels element
)))))
763 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
764 (let ((element (org-element-at-point)))
765 (and (org-element-property :number-lines element
)
766 (org-element-property :retain-labels element
)
767 (org-element-property :use-labels element
)))))
769 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
770 (let ((element (org-element-at-point)))
771 (and (org-element-property :number-lines element
)
772 (org-element-property :retain-labels element
)
773 (org-element-property :use-labels element
)))))
774 ;; 5. No switch should not number lines, but retain labels and use
776 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
777 (let ((element (org-element-at-point)))
778 (should (not (org-element-property :number-lines element
)))
779 (should (org-element-property :retain-labels element
))
780 (should (org-element-property :use-labels element
))))
781 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
782 (let ((element (org-element-at-point)))
783 (should (not (org-element-property :number-lines element
)))
784 (should (org-element-property :retain-labels element
))
785 (should (org-element-property :use-labels element
))))
786 ;; 6. "-r" switch only: do not number lines, remove labels, and
787 ;; don't use labels in coderefs.
788 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
789 (let ((element (org-element-at-point)))
790 (should (not (org-element-property :number-lines element
)))
791 (should (not (org-element-property :retain-labels element
)))
792 (should (not (org-element-property :use-labels element
)))))
793 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
794 (let ((element (org-element-at-point)))
795 (should (not (org-element-property :number-lines element
)))
796 (should (not (org-element-property :retain-labels element
)))
797 (should (not (org-element-property :use-labels element
)))))
798 ;; 7. Recognize coderefs with user-defined syntax.
802 (org-test-with-temp-text
803 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
804 (org-element-property :label-fmt
(org-element-at-point)))))
808 (org-test-with-temp-text
809 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
810 (org-element-property :label-fmt
(org-element-at-point)))))))
815 (ert-deftest test-org-element
/export-block-parser
()
816 "Test `export-block' parser."
820 (org-test-with-temp-text "#+BEGIN_EXPORT LATEX\nText\n#+END_EXPORT"
821 (org-element-type (org-element-at-point)))))
824 (org-test-with-temp-text "#+BEGIN_EXPORT LATEX\nText\n#+END_EXPORT"
825 (org-element-property :type
(org-element-at-point)))))
829 (org-test-with-temp-text "#+begin_export latex\nText\n#+end_export"
830 (org-element-type (org-element-at-point)))))
831 ;; Ignore incomplete block.
834 (org-test-with-temp-text "#+BEGIN_EXPORT"
835 (org-element-type (org-element-at-point)))))
836 ;; Handle non-empty blank line at the end of buffer.
838 (org-test-with-temp-text "#+BEGIN_EXPORT latex\nC\n#+END_EXPORT\n "
839 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
844 (ert-deftest test-org-element
/export-snippet-parser
()
845 "Test `export-snippet' parser."
848 '("back-end" .
"contents")
849 (org-test-with-temp-text "@@back-end:contents@@"
851 (org-element-parse-buffer) 'export-snippet
852 (lambda (snippet) (cons (org-element-property :back-end snippet
)
853 (org-element-property :value snippet
)))
859 (ert-deftest test-org-element
/fixed-width-parser
()
860 "Test fixed-width area parsing."
861 ;; Preserve indentation.
863 (org-test-with-temp-text ": no blank\n: one blank"
864 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
865 ;; Fixed-width with empty lines.
867 (org-test-with-temp-text ": first part\n:\n: \n: second part"
868 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
869 ;; Parse indented fixed-width markers.
871 (org-test-with-temp-text "Text\n : no blank\n : one blank"
872 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
873 ;; Distinguish fixed-width areas within a list and outside of it.
877 (org-test-with-temp-text "
880 : fixed-width outside"
881 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
882 ;; Handle non-empty blank line at the end of buffer.
884 (org-test-with-temp-text ": A\n "
885 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
888 ;;;; Footnote Definition
890 (ert-deftest test-org-element
/footnote-definition-parser
()
891 "Test `footnote-definition' parser."
893 (org-test-with-temp-text "[fn:1] Definition"
894 (org-element-map (org-element-parse-buffer) 'footnote-definition
896 ;; Footnote with more contents
899 (org-element-property
901 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
902 (org-element-map (org-element-parse-buffer) 'footnote-definition
904 ;; Footnote starting with special syntax.
906 (org-test-with-temp-text "[fn:1] - no item"
907 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
908 ;; Correctly handle footnote starting with an empty line.
911 (org-test-with-temp-text "[fn:1]\n\n Body"
912 (org-element-property :contents-begin
(org-element-at-point)))))
913 ;; Handle non-empty blank line at the end of buffer.
915 (org-test-with-temp-text "[fn:1] Definition\n "
916 (= (org-element-property :end
(org-element-at-point)) (point-max))))
917 ;; Footnote with attributes.
920 (org-test-with-temp-text "#+attr_latex: :offset 0in\n[fn:1] A footnote."
922 (org-element-map (org-element-parse-buffer) 'footnote-definition
925 (org-test-with-temp-text "[fn:1] 1\n\n#+attr_latex: :offset 0in\n[fn:2] 2"
926 (goto-char (org-element-property :end
(org-element-at-point)))
930 ;;;; Footnotes Reference.
932 (ert-deftest test-org-element
/footnote-reference-parser
()
933 "Test `footnote-reference' parser."
934 ;; Parse a standard reference.
936 (org-test-with-temp-text "Text[fn:label]"
938 (org-element-parse-buffer) 'footnote-reference
'identity
)))
939 ;; Parse an inline reference.
941 (org-test-with-temp-text "Text[fn:test:def]"
943 (org-element-parse-buffer) 'footnote-reference
'identity
)))
944 ;; Parse an anonymous reference.
946 (org-test-with-temp-text "Text[fn::def]"
948 (org-element-parse-buffer) 'footnote-reference
'identity
)))
949 ;; Parse nested footnotes.
953 (org-test-with-temp-text "Text[fn::def [fn:label]]"
955 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
956 ;; Parse adjacent footnotes.
958 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
962 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
963 ;; Only properly closed footnotes are recognized as such.
965 (org-test-with-temp-text "Text[fn:label"
967 (org-element-parse-buffer) 'footnote-reference
'identity
))))
972 (ert-deftest test-org-element
/headline-comment-keyword
()
973 "Test COMMENT keyword recognition."
975 (org-test-with-temp-text "* Headline"
976 (let ((org-comment-string "COMMENT"))
977 (should-not (org-element-property :commentedp
(org-element-at-point)))))
978 ;; Standard position.
979 (org-test-with-temp-text "* COMMENT Headline"
980 (let ((org-comment-string "COMMENT")
981 (headline (org-element-at-point)))
982 (should (org-element-property :commentedp headline
))
983 (should (equal (org-element-property :raw-value headline
) "Headline"))))
985 (org-test-with-temp-text "* COMMENT Headline"
986 (let* ((org-comment-string "Comment")
987 (headline (org-element-at-point)))
988 (should-not (org-element-property :commentedp headline
))
989 (should (equal (org-element-property :raw-value headline
)
990 "COMMENT Headline"))))
991 ;; With another keyword.
992 (org-test-with-temp-text "* TODO COMMENT Headline"
993 (let* ((org-comment-string "COMMENT")
994 (org-todo-keywords '((sequence "TODO" "DONE")))
995 (headline (org-element-at-point)))
996 (should (org-element-property :commentedp headline
))
997 (should (equal (org-element-property :raw-value headline
) "Headline"))))
998 ;; With the keyword only.
999 (org-test-with-temp-text "* COMMENT"
1000 (let* ((org-comment-string "COMMENT")
1001 (headline (org-element-at-point)))
1002 (should (org-element-property :commentedp headline
))
1003 (should (equal (org-element-property :raw-value headline
) "")))))
1005 (ert-deftest test-org-element
/headline-archive-tag
()
1006 "Test ARCHIVE tag recognition."
1009 (org-test-with-temp-text "* Headline"
1010 (let ((org-archive-tag "ARCHIVE"))
1011 (org-element-property :archivedp
(org-element-at-point)))))
1013 (org-test-with-temp-text "* Headline :ARCHIVE:"
1014 (let ((org-archive-tag "ARCHIVE"))
1015 (let ((headline (org-element-at-point)))
1016 (should (org-element-property :archivedp headline
)))))
1018 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
1019 (let ((org-archive-tag "ARCHIVE"))
1020 (let ((headline (org-element-at-point)))
1021 (should (org-element-property :archivedp headline
)))))
1022 ;; Tag is case-sensitive.
1024 (org-test-with-temp-text "* Headline :ARCHIVE:"
1025 (let ((org-archive-tag "Archive"))
1026 (org-element-property :archivedp
(org-element-at-point))))))
1028 (ert-deftest test-org-element
/headline-properties
()
1029 "Test properties from property drawer."
1030 ;; All properties from property drawer have their symbol upper
1033 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1034 (org-element-property :FOO
(org-element-at-point))))
1036 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1037 (org-element-property :foo
(org-element-at-point))))
1038 ;; Also parse properties associated in inlinetasks.
1039 (when (featurep 'org-inlinetask
)
1041 (org-test-with-temp-text "*************** Inlinetask
1045 *************** END"
1046 (org-element-property :FOO
(org-element-at-point)))))
1047 ;; Do not find property drawer in a verbatim area.
1049 (org-test-with-temp-text
1056 (org-element-property :FOO
(org-element-at-point))))
1057 ;; Do not use properties from a drawer associated to an inlinetask.
1058 (when (featurep 'org-inlinetask
)
1060 (org-test-with-temp-text
1062 *************** Inlinetask
1066 *************** END"
1067 (org-element-property
1068 :FOO
(let ((org-inlinetask-min-level 15)) (org-element-at-point))))))
1069 ;; Do not find incomplete drawers.
1071 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar"
1072 (org-element-property :FOO
(org-element-at-point)))))
1075 ;;;; Horizontal Rule
1077 (ert-deftest test-org-element
/horizontal-rule-parser
()
1078 "Test `horizontal-rule' parser."
1081 (org-test-with-temp-text "-----"
1082 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1085 (org-test-with-temp-text " -----"
1086 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1087 ;; Hyphen must be alone on the line.
1089 (org-test-with-temp-text "-----wrong"
1090 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1091 ;; 4 hyphens is too small.
1093 (org-test-with-temp-text "----"
1094 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1095 ;; Handle non-empty blank line at the end of buffer.
1097 (org-test-with-temp-text "-----\n "
1098 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1101 ;;;; Inline Babel Call
1103 (ert-deftest test-org-element
/inline-babel-call-parser
()
1104 "Test `inline-babel-call' parser."
1107 (eq 'inline-babel-call
1108 (org-test-with-temp-text "call_test()"
1109 (org-element-type (org-element-context)))))
1111 (eq 'inline-babel-call
1112 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1113 (org-element-type (org-element-context)))))
1118 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1119 (org-element-property :call
(org-element-context)))))
1120 ;; Parse inside header.
1124 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1125 (org-element-property :inside-header
(org-element-context)))))
1130 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1131 (org-element-property :arguments
(org-element-context)))))
1132 ;; Parse end header.
1136 (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1137 (org-element-property :end-header
(org-element-context)))))
1138 ;; Handle multi-line babel calls.
1140 (eq 'inline-babel-call
1141 (org-test-with-temp-text
1142 "call_test[:results\noutput](x=2)[:results html]"
1143 (org-element-type (org-element-context)))))
1145 (eq 'inline-babel-call
1146 (org-test-with-temp-text
1147 "call_test[:results output](x=2\ny=3)[:results html]"
1148 (org-element-type (org-element-context)))))
1150 (eq 'inline-babel-call
1151 (org-test-with-temp-text
1152 "call_test[:results output](x=2)[:results\nhtml]"
1153 (org-element-type (org-element-context))))))
1156 ;;;; Inline Src Block
1158 (ert-deftest test-org-element
/inline-src-block-parser
()
1159 "Test `inline-src-block' parser."
1161 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1162 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1165 (org-test-with-temp-text "src_emacs-lisp[:foo bar]{(+ 1 1)}"
1166 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1168 (org-test-with-temp-text "src_emacs-lisp[ :foo bar]{(+ 1 1)}"
1169 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1172 (org-test-with-temp-text "src_emacs-lisp[]{(+ 1 1)}"
1173 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1176 (org-test-with-temp-text "foosrc_emacs-lisp[]{(+ 1 1)}"
1177 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1179 (org-test-with-temp-text "src_emacs-lisp[]foo{(+ 1 1)}"
1180 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1181 ;; Invalid language name
1183 (org-test-with-temp-text "src_emacs-\tlisp{(+ 1 1)}"
1184 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1185 ;; Test parsing at the beginning of an item.
1187 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1188 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1189 ;; Test parsing multi-line source blocks.
1191 (eq 'inline-src-block
1192 (org-test-with-temp-text "src_emacs-lisp{(+ 1\n 1)}"
1193 (org-element-type (org-element-context)))))
1195 (eq 'inline-src-block
1196 (org-test-with-temp-text "src_emacs-lisp[\n:foo bar]{(+ 1 1)}"
1197 (org-element-type (org-element-context)))))
1199 (eq 'inline-src-block
1200 (org-test-with-temp-text "src_emacs-lisp[:foo\nbar]{(+ 1 1)}"
1201 (org-element-type (org-element-context)))))
1202 ;; Besides curly brackets, ignore any other bracket type.
1205 (org-test-with-temp-text "src_emacs-lisp{[foo}"
1206 (org-element-property :value
(org-element-context)))))
1209 (org-test-with-temp-text "src_emacs-lisp{foo]}"
1210 (org-element-property :value
(org-element-context)))))
1213 (org-test-with-temp-text "src_emacs-lisp{(foo}"
1214 (org-element-property :value
(org-element-context)))))
1217 (org-test-with-temp-text "src_emacs-lisp{foo)}"
1218 (org-element-property :value
(org-element-context))))))
1223 (ert-deftest test-org-element
/inlinetask-parser
()
1224 "Test `inlinetask' parser."
1225 (when (featurep 'org-inlinetask
)
1226 (let ((org-inlinetask-min-level 15))
1227 ;; Regular inlinetask.
1230 (org-test-with-temp-text
1231 "*************** Task\nTest\n*************** END"
1232 (org-element-type (org-element-at-point)))))
1233 ;; Degenerate inlinetask.
1236 (org-test-with-temp-text "*************** Task"
1237 (org-element-type (org-element-at-point)))))
1238 ;; Mixed inlinetasks.
1240 (org-test-with-temp-text
1242 *************** Task
1243 *************** Task2
1245 *************** END"
1247 (goto-char (org-element-property :end
(org-element-at-point)))
1253 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1254 (org-test-with-temp-text "*************** TODO Task"
1255 (org-element-property :todo-keyword
(org-element-at-point))))))
1258 (org-test-with-temp-text "
1259 *************** Task<point>
1260 DEADLINE: <2012-03-29 thu.>
1261 *************** END"
1262 (org-element-property :deadline
(org-element-at-point))))
1265 (org-test-with-temp-text "
1266 *************** Task
1267 <point>DEADLINE: <2012-03-29 thu.>
1268 *************** END"
1269 (org-element-type (org-element-at-point)))))
1271 (org-test-with-temp-text "
1272 *************** Task<point>
1273 DEADLINE: <2012-03-29 thu.>"
1274 (org-element-property :deadline
(org-element-at-point))))
1277 (org-test-with-temp-text "
1278 *************** Task
1279 <point>DEADLINE: <2012-03-29 thu.>"
1280 (org-element-type (org-element-at-point)))))
1285 (org-test-with-temp-text "
1286 *************** [#A] Task"
1288 (org-element-property :priority
(org-element-at-point)))))
1293 (org-test-with-temp-text "
1294 *************** Task :test:"
1296 (org-element-property :tags
(org-element-at-point)))))
1297 ;; Regular properties are accessed through upper case keywords.
1299 (org-test-with-temp-text "
1300 *************** Task
1304 *************** END"
1306 (org-element-property :FOO
(org-element-at-point))))
1308 (org-test-with-temp-text "
1309 *************** Task
1313 *************** END"
1315 (org-element-property :foo
(org-element-at-point))))
1316 ;; Handle non-empty blank line at the end of buffer.
1318 (org-test-with-temp-text "*************** Task\n*************** END\n "
1319 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1324 (ert-deftest test-org-element
/italic-parser
()
1325 "Test `italic' parser."
1328 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1329 (org-test-with-temp-text "/italic/"
1330 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1331 ;; Multi-line markup.
1334 (org-element-contents
1335 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1336 (org-test-with-temp-text "/first line\nsecond line/"
1337 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1338 '("first line\nsecond line"))))
1343 (ert-deftest test-org-element
/item-parser
()
1344 "Test `item' parser."
1347 (org-test-with-temp-text "- item"
1348 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1352 (org-element-property
1354 (org-test-with-temp-text "6. [@6] item"
1355 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1360 (org-element-property
1362 (org-test-with-temp-text "- tag :: description"
1363 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1364 ;; No tags in ordered lists.
1366 (org-element-property
1368 (org-test-with-temp-text "1. tag :: description"
1369 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1374 (org-test-with-temp-text "
1379 (org-element-parse-buffer) 'item
1380 (lambda (item) (org-element-property :checkbox item
))))))
1381 ;; Item starting with special syntax.
1383 (equal '(("- item"))
1384 (org-test-with-temp-text "- - item"
1385 (org-element-map (org-element-parse-buffer) 'paragraph
1386 'org-element-contents
))))
1387 ;; Block in an item: ignore indentation within the block.
1389 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1391 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1396 (ert-deftest test-org-element
/keyword-parser
()
1397 "Test `keyword' parser."
1400 (org-test-with-temp-text "#+KEYWORD: value"
1401 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1402 ;; Keywords are case-insensitive.
1404 (org-test-with-temp-text "#+keyword: value"
1405 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1406 ;; Affiliated keywords are not keywords.
1408 (org-test-with-temp-text "#+NAME: value
1410 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1411 ;; Do not mix keywords with Babel calls and dynamic blocks.
1413 (org-test-with-temp-text "#+CALL: fun()"
1414 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1416 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1417 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1418 ;; Handle non-empty blank line at the end of buffer.
1420 (org-test-with-temp-text "#+KEYWORD: value\n "
1421 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1424 ;;;; Latex Environment
1426 (ert-deftest test-org-element
/latex-environment-parser
()
1427 "Test `latex-environment' parser."
1429 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1430 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1431 ;; Allow nested environments.
1439 (org-test-with-temp-text "
1445 (org-element-property
1448 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1449 ;; Allow environments with options and arguments.
1451 (eq 'latex-environment
1452 (org-test-with-temp-text
1453 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1454 (org-element-type (org-element-at-point)))))
1456 (eq 'latex-environment
1457 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1458 (org-element-type (org-element-at-point)))))
1459 ;; Allow environments without newline after \begin{.}.
1461 (eq 'latex-environment
1462 (org-test-with-temp-text "\\begin{env}{arg}something\nvalue\n\\end{env}"
1463 (org-element-type (org-element-at-point)))))
1464 ;; Allow one-line environments.
1466 (eq 'latex-environment
1467 (org-test-with-temp-text "\\begin{env}{arg}something\\end{env}"
1468 (org-element-type (org-element-at-point)))))
1469 ;; Should not allow different tags.
1471 (eq 'latex-environment
1472 (org-test-with-temp-text "\\begin{env*}{arg}something\\end{env}"
1473 (org-element-type (org-element-at-point)))))
1474 ;; LaTeX environments must be on separate lines.
1476 (eq 'latex-environment
1477 (org-test-with-temp-text "\\begin{env} x \\end{env} y"
1478 (org-element-type (org-element-at-point)))))
1480 (eq 'latex-environment
1481 (org-test-with-temp-text "y \\begin{env} x<point> \\end{env}"
1482 (org-element-type (org-element-at-point)))))
1483 ;; Handle non-empty blank line at the end of buffer.
1485 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1486 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1491 (ert-deftest test-org-element
/latex-fragment-parser
()
1492 "Test `latex-fragment' parser."
1495 (org-test-with-temp-text "$a$"
1496 (org-element-type (org-element-context)))))
1499 (org-test-with-temp-text "$a$!"
1500 (org-element-type (org-element-context)))))
1503 (org-test-with-temp-text "$a$,"
1504 (org-element-type (org-element-context)))))
1507 (org-test-with-temp-text "$a$\""
1508 (org-element-type (org-element-context)))))
1511 (org-test-with-temp-text "$a$)"
1512 (org-element-type (org-element-context)))))
1515 (org-test-with-temp-text "$a$ "
1516 (org-element-type (org-element-context)))))
1519 (org-test-with-temp-text "$a$a"
1520 (org-element-type (org-element-context)))))
1523 (org-test-with-temp-text "$$a$$"
1524 (org-element-type (org-element-context)))))
1527 (org-test-with-temp-text "\\(a\\)"
1528 (org-element-type (org-element-context)))))
1531 (org-test-with-temp-text "\\[a\\]"
1532 (org-element-type (org-element-context)))))
1533 ;; Test fragment at the beginning of an item.
1536 (org-test-with-temp-text "- $<point>x$"
1537 (org-element-type (org-element-context))))))
1542 (ert-deftest test-org-element
/line-break-parser
()
1543 "Test `line-break' parser."
1546 (org-test-with-temp-text "Text \\\\"
1547 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1548 ;; Line break with trailing white spaces.
1550 (org-test-with-temp-text "Text \\\\ "
1551 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1552 ;; Three backslashes are too much.
1554 (org-test-with-temp-text "Text \\\\\\"
1555 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1560 (ert-deftest test-org-element
/link-parser
()
1561 "Test `link' parser."
1566 (org-test-with-temp-text "<<<radio>>>A radio link"
1567 (org-update-radio-target-regexp)
1568 (org-element-property
1570 (org-element-map (org-element-parse-buffer) 'link
#'identity nil t
)))))
1573 ;; ... with description.
1577 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1578 (org-element-contents
1579 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1580 ;; ... without description.
1584 (org-test-with-temp-text "[[http://orgmode.org]]"
1585 (org-element-property
1587 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1588 ;; ... with expansion.
1591 "//orgmode.org/worg"
1592 (org-test-with-temp-text "[[Org:worg]]"
1593 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1594 (org-element-property
1596 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1597 ;; ... with translation.
1601 (org-test-with-temp-text "[[http://orgmode.org]]"
1602 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1603 (let ((org-link-translation-function 'link-translate
))
1604 (org-element-property
1606 (org-element-map (org-element-parse-buffer) 'link
1607 'identity nil t
)))))))
1612 (org-test-with-temp-text "[[id:aaaa]]"
1613 (org-element-property
1615 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1616 ;; ... custom-id link.
1620 (org-test-with-temp-text "[[#some-id]]"
1621 (org-element-property
1623 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1624 ;; ... coderef link.
1628 (org-test-with-temp-text "[[(reference)]]"
1629 (org-element-property
1631 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1636 (org-test-with-temp-text "[[target-or-title]]"
1637 (org-element-property
1639 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1640 ;; ... file-type link with search option.
1643 '(("file" "projects.org" "*task title"))
1644 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1645 (org-element-map (org-element-parse-buffer) 'link
1646 (lambda (l) (list (org-element-property :type l
)
1647 (org-element-property :path l
)
1648 (org-element-property :search-option l
)))))))
1649 ;; ... file-type link with application...
1652 '("file" "projects.org" "emacs")
1653 (org-test-with-temp-text "[[file+emacs:projects.org]]"
1654 (let ((l (org-element-context)))
1655 (list (org-element-property :type l
)
1656 (org-element-property :path l
)
1657 (org-element-property :application l
))))))
1658 ;; ... `:path' in a file-type link must be compatible with "file"
1659 ;; scheme in URI syntax, even if Org syntax isn't...
1661 (org-test-with-temp-text-in-file ""
1662 (let ((file (expand-file-name (buffer-file-name))))
1663 (insert (format "[[file://%s]]" file
))
1664 (equal (org-element-property :path
(org-element-context)) file
))))
1666 (org-test-with-temp-text-in-file ""
1667 (let ((file (expand-file-name (buffer-file-name))))
1668 (insert (format "[[file:%s]]" file
))
1669 (equal (org-element-property :path
(org-element-context)) file
))))
1671 (org-test-with-temp-text-in-file ""
1672 (let ((file (expand-file-name (buffer-file-name))))
1673 (insert (format "[[file:%s]]" file
))
1674 (equal (org-element-property :path
(org-element-context)) file
))))
1675 ;; ... multi-line link.
1678 (org-test-with-temp-text "[[shell:ls\n*.org]]"
1679 (org-element-property :path
(org-element-context)))))
1682 (org-test-with-temp-text "A link: http://orgmode.org"
1683 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1684 ;; Angular link. Follow RFC 3986.
1687 (org-test-with-temp-text "A link: <point><http://orgmode.org>"
1688 (org-element-type (org-element-context)))))
1690 (equal "//orgmode.org"
1691 (org-test-with-temp-text "A link: <point><http://orgmode\n.org>"
1692 (org-element-property :path
(org-element-context)))))
1693 ;; Link abbreviation.
1696 (org-test-with-temp-text
1697 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1698 (progn (org-mode-restart)
1699 (goto-char (1- (point-max)))
1700 (org-element-property :type
(org-element-context))))))
1701 ;; Link abbreviation in a secondary string.
1704 (org-test-with-temp-text
1705 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1706 (progn (org-mode-restart)
1707 (org-element-map (org-element-parse-buffer) 'link
1708 (lambda (link) (org-element-property :type link
))
1710 ;; Plain links are allowed as description of regular links.
1713 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1714 (search-forward "file:")
1715 (org-element-property :type
(org-element-context)))))
1716 ;; So are angular links.
1719 (org-test-with-temp-text "[[http://orgmode.org][<file:unicorn.jpg>]]"
1720 (search-forward "file:")
1721 (org-element-property :type
(org-element-context))))))
1726 (ert-deftest test-org-element
/macro-parser
()
1727 "Test `macro' parser."
1728 ;; Without arguments.
1730 (org-test-with-temp-text "{{{macro}}}"
1731 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1734 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1735 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1736 ;; Properly handle protected commas in arguments...
1740 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1741 (org-element-property :args
(org-element-context))))))
1742 ;; ... even when last argument ends with a protected comma.
1745 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1746 (org-element-property :args
(org-element-context)))))
1747 ;; Allow to escape escaping character.
1750 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1751 (org-element-property :args
(org-element-context)))))
1752 ;; No need to escape backslashes elsewhere.
1755 (org-test-with-temp-text "{{{macro(\\)}}}"
1756 (org-element-property :args
(org-element-context))))))
1761 (ert-deftest test-org-element
/node-property
()
1762 "Test `node-property' parser."
1765 (equal '("abc" "value")
1766 (org-test-with-temp-text "* H\n:PROPERTIES:\n<point>:abc: value\n:END:"
1767 (let ((element (org-element-at-point)))
1768 (list (org-element-property :key element
)
1769 (org-element-property :value element
))))))
1770 ;; Value should be trimmed.
1773 (org-test-with-temp-text
1774 "* H\n:PROPERTIES:\n<point>:abc: value \n:END:"
1775 (org-element-property :value
(org-element-at-point)))))
1776 ;; A node property requires to be wrapped within a property drawer.
1779 (org-test-with-temp-text ":abc: value"
1780 (org-element-type (org-element-at-point)))))
1781 ;; Accept empty properties.
1783 (equal '(("foo" "value") ("bar" ""))
1784 (org-test-with-temp-text "* H\n:PROPERTIES:\n:foo: value\n:bar:\n:END:"
1785 (org-element-map (org-element-parse-buffer) 'node-property
1787 (list (org-element-property :key p
)
1788 (org-element-property :value p
))))))))
1793 (ert-deftest test-org-element
/paragraph-parser
()
1794 "Test `paragraph' parser."
1797 (org-test-with-temp-text "Paragraph"
1798 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1799 ;; Property find end of a paragraph stuck to another element.
1802 (org-test-with-temp-text "Paragraph\n# Comment"
1803 (org-element-map (org-element-parse-buffer) 'paragraph
1804 (lambda (p) (char-after (org-element-property :end p
)))
1806 ;; Include ill-formed Keywords.
1808 (org-test-with-temp-text "#+wrong_keyword something"
1809 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1810 ;; Include incomplete-drawers.
1812 (org-test-with-temp-text ":TEST:\nParagraph"
1813 (let ((elem (org-element-at-point)))
1814 (and (eq (org-element-type elem
) 'paragraph
)
1815 (= (point-max) (org-element-property :end elem
))))))
1816 ;; Include incomplete blocks.
1818 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1819 (let ((elem (org-element-at-point)))
1820 (and (eq (org-element-type elem
) 'paragraph
)
1821 (= (point-max) (org-element-property :end elem
))))))
1822 ;; Include incomplete dynamic blocks.
1824 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1825 (let ((elem (org-element-at-point)))
1826 (and (eq (org-element-type elem
) 'paragraph
)
1827 (= (point-max) (org-element-property :end elem
))))))
1828 ;; Include incomplete latex environments.
1830 (org-test-with-temp-text "\begin{equation}\nParagraph"
1831 (let ((elem (org-element-at-point)))
1832 (and (eq (org-element-type elem
) 'paragraph
)
1833 (= (point-max) (org-element-property :end elem
))))))
1835 (org-test-with-temp-text "Paragraph\n\begin{equation}"
1836 (let ((elem (org-element-at-point)))
1837 (and (eq (org-element-type elem
) 'paragraph
)
1838 (= (point-max) (org-element-property :end elem
))))))
1839 ;; Stop at affiliated keywords.
1841 (org-test-with-temp-text "Paragraph\n#+NAME: test\n| table |"
1842 (let ((elem (org-element-at-point)))
1843 (and (eq (org-element-type elem
) 'paragraph
)
1844 (not (org-element-property :name elem
))
1845 (= (org-element-property :end elem
) (line-beginning-position 2))))))
1847 (org-test-with-temp-text
1848 "Paragraph\n#+CAPTION[with short caption]: test\n| table |"
1849 (let ((elem (org-element-at-point)))
1850 (and (eq (org-element-type elem
) 'paragraph
)
1851 (not (org-element-property :name elem
))
1852 (= (org-element-property :end elem
) (line-beginning-position 2))))))
1853 ;; Do not steal affiliated keywords from container.
1855 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item<point> 1"
1856 (let ((elem (org-element-at-point)))
1857 (and (eq (org-element-type elem
) 'paragraph
)
1858 (not (org-element-property :attr_latex elem
))
1859 (/= (org-element-property :begin elem
) 1)))))
1860 ;; Handle non-empty blank line at the end of buffer.
1862 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1863 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1868 (ert-deftest test-org-element
/plain-list-parser
()
1869 "Test `plain-list' parser."
1870 (org-test-with-temp-text "- item"
1871 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1872 ;; Blank lines after the list only belong to outer plain list.
1876 (org-test-with-temp-text "
1881 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1882 (lambda (pl) (org-element-property :end pl
)))))
1884 ;; Move to ending of outer list.
1885 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1886 ;; Move to ending of inner list.
1887 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1888 ;; Correctly compute end of list if it doesn't end at a line
1891 (org-test-with-temp-text "- list\n \n "
1892 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1897 (ert-deftest test-org-element
/planning-parser
()
1898 "Test `planning' parser."
1899 ;; Test various keywords.
1901 (org-element-property
1903 (org-test-with-temp-text "* H\n<point>CLOSED: [2012-03-29 thu.]"
1904 (org-element-at-point))))
1906 (org-element-property
1908 (org-test-with-temp-text "* H\n<point>DEADLINE: <2012-03-29 thu.>"
1909 (org-element-at-point))))
1911 (org-element-property
1913 (org-test-with-temp-text "* H\n<point>SCHEDULED: <2012-03-29 thu.>"
1914 (org-element-at-point))))
1915 ;; Planning line only exists right after a headline.
1918 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1919 (org-element-type (org-element-at-point)))))
1922 (org-test-with-temp-text
1923 "* H\n# Comment\n<point>DEADLINE: <2012-03-29 thu.>"
1924 (org-element-type (org-element-at-point))))))
1927 ;;;; Property Drawer
1929 (ert-deftest test-org-element
/property-drawer-parser
()
1930 "Test `property-drawer' parser."
1933 (eq 'property-drawer
1934 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value\n:END:"
1935 (org-element-type (org-element-at-point)))))
1937 (eq 'property-drawer
1938 (org-test-with-temp-text
1939 "* H\nDEADLINE: <2014-03-04 tue.>\n<point>:PROPERTIES:\n:prop: value\n:END:"
1940 (org-element-type (org-element-at-point)))))
1941 ;; Allow properties without value and no property at all.
1943 (eq 'property-drawer
1944 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop:\n:END:"
1945 (org-element-type (org-element-at-point)))))
1947 (eq 'property-drawer
1948 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:"
1949 (org-element-type (org-element-at-point)))))
1950 ;; Ignore incomplete drawer, drawer at a wrong location or with
1953 (eq 'property-drawer
1954 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value"
1955 (org-element-type (org-element-at-point)))))
1957 (eq 'property-drawer
1958 (org-test-with-temp-text
1959 "* H\nParagraph\n<point>:PROPERTIES:\n:prop: value\n:END:"
1960 (org-element-type (org-element-at-point)))))
1962 (eq 'property-drawer
1963 (org-test-with-temp-text
1964 "* H\nParagraph\n<point>:PROPERTIES:\nparagraph\n:END:"
1965 (org-element-type (org-element-at-point)))))
1966 ;; Handle non-empty blank line at the end of buffer.
1968 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:\n "
1969 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1974 (ert-deftest test-org-element
/quote-block-parser
()
1975 "Test `quote-block' parser."
1978 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1979 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1980 ;; Ignore incomplete block.
1982 (org-test-with-temp-text "#+BEGIN_QUOTE"
1983 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1984 ;; Handle non-empty blank line at the end of buffer.
1986 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1987 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1992 (ert-deftest test-org-element
/radio-target-parser
()
1993 "Test `radio-target' parser."
1997 (org-test-with-temp-text "<<<radio>>>"
1998 (org-element-type (org-element-context)))))
1999 ;; Radio targets with objects.
2002 (org-test-with-temp-text "<<<radio \\alpha>>>"
2003 (org-element-type (org-element-context)))))
2004 ;; Radio targets starting with an object.
2007 (org-test-with-temp-text "<<<\\alpha radio>>>"
2008 (org-element-type (org-element-context)))))
2009 ;; Radio targets cannot begin or end with white space.
2012 (org-test-with-temp-text "<<< radio>>>"
2013 (org-element-type (org-element-context)))))
2016 (org-test-with-temp-text "<<<radio >>>"
2017 (org-element-type (org-element-context))))))
2022 (ert-deftest test-org-element
/section-parser
()
2023 "Test `section' parser."
2026 (org-test-with-temp-text "* Headline\nText"
2027 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2028 ;; There's a section before the first headline.
2030 (org-test-with-temp-text "Text"
2031 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2032 ;; A section cannot be empty.
2034 (org-test-with-temp-text "* Headline 1\n* Headline 2"
2035 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
2036 ;; A section doesn't contain sub-trees.
2038 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
2040 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
2041 'headline
'identity
))))
2046 (ert-deftest test-org-element
/special-block-parser
()
2047 "Test `special-block' parser."
2051 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
2052 (org-element-property :type
(org-element-at-point)))))
2053 ;; Special blocks are case sensitive.
2056 (org-test-with-temp-text "#+BEGIN_CaSe\nText\n#+END_CaSe"
2057 (org-element-property :type
(org-element-at-point)))))
2058 ;; Special blocks can contain paragraphs.
2061 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
2063 (org-element-type (org-element-at-point)))))
2064 ;; Ignore incomplete block.
2067 (org-test-with-temp-text "#+BEGIN_SPECIAL"
2068 (org-element-type (org-element-at-point)))))
2069 ;; Allow special characters in type.
2071 (equal '(special-block "SPECIAL*")
2072 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
2073 (let ((element (org-element-at-point)))
2074 (list (org-element-type element
)
2075 (org-element-property :type element
))))))
2076 ;; Handle non-empty blank line at the end of buffer.
2078 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
2079 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2084 (ert-deftest test-org-element
/src-block-parser
()
2085 "Test `src-block' parser."
2088 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
2089 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
2090 ;; Ignore incomplete block.
2092 (org-test-with-temp-text "#+BEGIN_SRC"
2093 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
2094 ;; Properly un-escape code.
2096 (equal "* Headline\n #+keyword\nText\n"
2097 (org-test-with-temp-text
2098 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
2099 (org-element-property :value
(org-element-at-point)))))
2100 ;; Handle non-empty blank line at the end of buffer.
2102 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
2103 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2106 ;;;; Statistics Cookie
2108 (ert-deftest test-org-element
/statistics-cookie
()
2109 "Test `statistics-cookie' parser."
2112 (org-test-with-temp-text "[1/2]"
2113 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
2116 (org-test-with-temp-text "[33%]"
2118 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
2123 (ert-deftest test-org-element
/strike-through-parser
()
2124 "Test `strike-through' parser."
2127 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2128 (org-test-with-temp-text "+strike-through+"
2129 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
2130 ;; Multi-line markup.
2133 (org-element-contents
2134 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2135 (org-test-with-temp-text "+first line\nsecond line+"
2137 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
2138 '("first line\nsecond line"))))
2143 (ert-deftest test-org-element
/subscript-parser
()
2144 "Test `subscript' parser."
2147 (org-test-with-temp-text "a_b"
2148 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
2151 (org-test-with-temp-text "a_{b}"
2152 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
2153 ;; Multiple subscripts in a paragraph.
2156 (org-test-with-temp-text "a_b and c_d"
2158 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
2163 (ert-deftest test-org-element
/superscript-parser
()
2164 "Test `superscript' parser."
2167 (org-test-with-temp-text "a^b"
2168 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2171 (org-test-with-temp-text "a^{b}"
2172 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2173 ;; Multiple superscript in a paragraph.
2176 (org-test-with-temp-text "a^b and c^d"
2179 (org-element-parse-buffer) 'superscript
'identity
))))))
2184 (ert-deftest test-org-element
/table-parser
()
2185 "Test `table' parser."
2187 (org-test-with-temp-text "| a |"
2188 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
2189 ;; TBLFM keyword is case insensitive.
2191 (org-test-with-temp-text "| a |\n#+tblfm: test"
2192 (org-element-property
2194 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
2195 ;; Handle multiple TBLFM lines.
2198 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
2199 (length (org-element-property
2202 (org-element-parse-buffer) 'table
'identity nil t
))))))
2203 ;; Handle non-empty blank line at the end of buffer.
2205 (org-test-with-temp-text "| a |\n "
2206 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2211 (ert-deftest test-org-element
/table-cell-parser
()
2212 "Test `table-cell' parser."
2213 ;; Regular table cell.
2215 (org-test-with-temp-text "| a |"
2216 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
)))
2217 ;; Last vertical bar may be omitted.
2219 (org-test-with-temp-text "| a "
2220 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
2225 (ert-deftest test-org-element
/table-row-parser
()
2226 "Test `table-row' parser."
2228 (equal '(standard rule
)
2229 (org-test-with-temp-text "| a |\n|---|"
2231 (org-element-parse-buffer) 'table-row
2232 (lambda (row) (org-element-property :type row
)))))))
2237 (ert-deftest test-org-element
/target-parser
()
2238 "Test `target' parser."
2240 (org-test-with-temp-text "<<target>>"
2241 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
2246 (ert-deftest test-org-element
/timestamp
()
2247 "Test `timestamp' parser."
2248 ;; Active timestamp.
2250 (org-test-with-temp-text "<2012-03-29 16:40>"
2251 (eq (org-element-property :type
(org-element-context)) 'active
)))
2253 (org-test-with-temp-text "<2012-03-29 Thu>"
2254 (let ((timestamp (org-element-context)))
2255 (or (org-element-property :hour-start timestamp
)
2256 (org-element-property :minute-start timestamp
)))))
2258 (equal '(2012 3 29 16 40)
2259 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
2260 (let ((object (org-element-context)))
2261 (list (org-element-property :year-start object
)
2262 (org-element-property :month-start object
)
2263 (org-element-property :day-start object
)
2264 (org-element-property :hour-start object
)
2265 (org-element-property :minute-start object
))))))
2266 ;; Inactive timestamp.
2268 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
2269 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
2272 (equal '(2012 3 29 16 40 7 30)
2273 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2274 (let ((object (org-element-context)))
2275 (list (org-element-property :year-end object
)
2276 (org-element-property :month-end object
)
2277 (org-element-property :day-end object
)
2278 (org-element-property :hour-end object
)
2279 (org-element-property :minute-end object
)
2280 (org-element-property :hour-start object
)
2281 (org-element-property :minute-start object
))))))
2284 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2285 (org-element-property :type
(org-element-context)))))
2288 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
2289 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
2291 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
2292 (let ((timestamp (org-element-context)))
2293 (or (org-element-property :hour-end timestamp
)
2294 (org-element-property :minute-end timestamp
)))))
2295 ;; With repeater, warning delay and both.
2298 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
2299 (org-element-property :repeater-type
(org-element-context)))))
2302 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
2303 (org-element-property :warning-type
(org-element-context)))))
2305 (equal '(cumulate all
)
2306 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
2307 (let ((ts (org-element-context)))
2308 (list (org-element-property :repeater-type ts
)
2309 (org-element-property :warning-type ts
)))))))
2314 (ert-deftest test-org-element
/underline-parser
()
2315 "Test `underline' parser."
2318 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2319 (org-test-with-temp-text "_underline_"
2320 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
2321 ;; Multi-line markup.
2324 (org-element-contents
2325 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2326 (org-test-with-temp-text "_first line\nsecond line_"
2328 (org-element-parse-buffer) 'underline
'identity nil t
))))
2329 '("first line\nsecond line"))))
2334 (ert-deftest test-org-element
/verbatim-parser
()
2335 "Test `verbatim' parser."
2338 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2339 (org-test-with-temp-text "=verbatim="
2340 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
2341 ;; Multi-line markup.
2344 (org-element-property
2346 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2347 (org-test-with-temp-text "=first line\nsecond line="
2349 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
2350 "first line\nsecond line")))
2355 (ert-deftest test-org-element
/verse-block-parser
()
2356 "Test `verse-block' parser."
2359 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2360 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2363 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2364 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2365 ;; Parse objects in verse blocks.
2367 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2368 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
2369 ;; Ignore incomplete verse block.
2371 (org-test-with-temp-text "#+BEGIN_VERSE"
2372 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
2373 ;; Handle non-empty blank line at the end of buffer.
2375 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2376 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2380 ;;; Test Interpreters.
2382 (ert-deftest test-org-element
/interpret-data
()
2383 "Test `org-element-interpret-data' specifications."
2384 ;; Interpret simple affiliated keywords.
2387 (org-element-interpret-data
2388 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2389 "#+NAME: para\nParagraph\n"))
2390 ;; Interpret multiple affiliated keywords.
2393 (org-element-interpret-data
2394 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2395 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2396 ;; Interpret parsed affiliated keywords.
2399 (org-element-interpret-data
2400 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2401 "#+CAPTION: caption\nParagraph\n"))
2402 ;; Interpret dual affiliated keywords.
2405 (org-element-interpret-data
2406 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2407 "#+CAPTION[short]: long\nParagraph\n"))
2408 ;; Interpret multiple parsed dual keywords.
2411 (org-element-interpret-data
2412 '(org-data nil
(paragraph
2413 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2414 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2415 ;; Pseudo objects and elements are transparent.
2419 (org-element-interpret-data
2420 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")))))
2423 (org-element-interpret-data
2425 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2426 (paragraph nil
"B"))))))
2428 (ert-deftest test-org-element
/center-block-interpreter
()
2429 "Test center block interpreter."
2431 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2432 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2434 (ert-deftest test-org-element
/drawer-interpreter
()
2435 "Test drawer interpreter."
2437 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2438 ":TEST:\nTest\n:END:\n")))
2440 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2441 "Test dynamic block interpreter."
2443 (equal (org-test-parse-and-interpret
2444 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2445 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2447 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2448 "Test footnote definition interpreter."
2449 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2451 (ert-deftest test-org-element
/headline-interpreter
()
2452 "Test headline and section interpreters."
2453 ;; 1. Standard test.
2454 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2455 ;; 2. With TODO keywords.
2457 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2458 (org-test-parse-and-interpret "* TODO Headline"))
2459 "* TODO Headline\n"))
2462 ;; 3.1. ... and a positive `org-tags-column' value.
2464 (equal (let ((org-tags-column 20))
2465 (org-test-parse-and-interpret "* Headline :tag:"))
2466 "* Headline :tag:\n"))
2467 ;; 3.2. ... and a negative `org-tags-column' value.
2469 (equal (let ((org-tags-column -
20))
2470 (org-test-parse-and-interpret "* Headline :tag:"))
2471 "* Headline :tag:\n"))
2472 ;; 3.3. ... and a null `org-tags-column' value.
2474 (equal (let ((org-tags-column 0))
2475 (org-test-parse-and-interpret "* Headline :tag:"))
2476 "* Headline :tag:\n"))
2477 ;; 4. With priority cookie.
2479 (equal (org-test-parse-and-interpret "* [#B] Headline")
2480 "* [#B] Headline\n"))
2481 ;; 5. With comment keyword.
2483 (equal (let ((org-comment-string "COMMENT"))
2484 (org-test-parse-and-interpret "* COMMENT Headline"))
2485 "* COMMENT Headline\n"))
2486 ;; 6. Keep same number of blank lines before body.
2488 (equal (org-test-parse-and-interpret
2489 "* Headline\n\n\nText after two blank lines.")
2490 "* Headline\n\n\nText after two blank lines.\n"))
2491 ;; 8. Preserve `org-odd-levels-only' state.
2493 (equal "* H\n*** H2\n"
2494 (let ((org-odd-levels-only t
))
2495 (org-test-parse-and-interpret "* H\n*** H2")))))
2497 (ert-deftest test-org-element
/inlinetask-interpreter
()
2498 "Test inlinetask interpretation."
2499 (when (featurep 'org-inlinetask
)
2500 (let ((org-inlinetask-min-level 15))
2501 ;; 1. Regular inlinetask.
2502 (should (equal (org-test-parse-and-interpret
2503 "*************** Task\nTest\n*************** END")
2504 "*************** Task\nTest\n*************** END\n"))
2505 ;; 2. Degenerate inlinetask.
2506 (should (equal (org-test-parse-and-interpret "*************** Task")
2507 "*************** Task\n"))
2508 ;; 3. Prefer degenerate form when there are no contents.
2509 (should (equal (org-test-parse-and-interpret
2510 "*************** Task\n*************** END")
2511 "*************** Task\n"))
2512 ;; 4. With TODO keywords.
2514 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2515 (org-test-parse-and-interpret "*************** TODO Task"))
2516 "*************** TODO Task\n"))
2519 ;; 5.1. ... and a positive `org-tags-column' value.
2521 (equal (let ((org-tags-column 30))
2522 (org-test-parse-and-interpret "*************** Task :tag:"))
2523 "*************** Task :tag:\n"))
2524 ;; 5.2. ... and a negative `org-tags-column' value.
2526 (equal (let ((org-tags-column -
30))
2527 (org-test-parse-and-interpret "*************** Task :tag:"))
2528 "*************** Task :tag:\n"))
2529 ;; 5.3. ... and a null `org-tags-column' value.
2531 (equal (let ((org-tags-column 0))
2532 (org-test-parse-and-interpret "*************** Task :tag:"))
2533 "*************** Task :tag:\n"))
2534 ;; 6. With priority cookie.
2536 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2537 "*************** [#B] Task\n")))))
2539 (ert-deftest test-org-element
/plain-list-interpreter
()
2540 "Test plain-list and item interpreters."
2541 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2543 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2544 ;; Description list.
2546 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2549 (equal (let ((org-plain-list-ordered-item-terminator t
))
2550 (org-test-parse-and-interpret "1. Item"))
2553 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2554 (org-test-parse-and-interpret "1) Item"))
2556 ;; Ordered list with counter.
2558 (equal (let ((org-plain-list-ordered-item-terminator t
))
2559 (org-test-parse-and-interpret "1. [@5] Item"))
2561 ;; List with check-boxes.
2563 (equal (org-test-parse-and-interpret
2564 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2565 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2566 ;; Item not starting with a paragraph.
2568 (equal (org-test-parse-and-interpret "-\n | a | b |")
2569 "- \n | a | b |\n"))
2570 ;; Special case: correctly handle "*" bullets.
2571 (should (org-test-parse-and-interpret " * item"))
2572 ;; Special case: correctly handle empty items.
2573 (should (org-test-parse-and-interpret "-"))))
2575 (ert-deftest test-org-element
/quote-block-interpreter
()
2576 "Test quote block interpreter."
2577 (should (equal (org-test-parse-and-interpret
2578 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2579 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2581 (ert-deftest test-org-element
/special-block-interpreter
()
2582 "Test special block interpreter."
2583 (should (equal (org-test-parse-and-interpret
2584 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2585 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2587 (ert-deftest test-org-element
/babel-call-interpreter
()
2588 "Test Babel call interpreter."
2589 ;; Without argument.
2590 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2591 "#+CALL: test()\n"))
2593 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2594 "#+CALL: test(x=2)\n"))
2595 ;; With header arguments.
2596 (should (equal (org-test-parse-and-interpret
2597 "#+CALL: test[:results output]() :results html")
2598 "#+CALL: test[:results output]() :results html\n")))
2600 (ert-deftest test-org-element
/clock-interpreter
()
2601 "Test clock interpreter."
2605 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2606 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2610 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2611 (org-test-parse-and-interpret "
2612 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))))
2614 (ert-deftest test-org-element
/comment-interpreter
()
2615 "Test comment interpreter."
2617 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2619 (should (equal (org-test-parse-and-interpret " # Comment")
2621 ;; Preserve indentation.
2622 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2623 "# No blank\n# One blank\n")))
2625 (ert-deftest test-org-element
/comment-block-interpreter
()
2626 "Test comment block interpreter."
2627 (should (equal (org-test-parse-and-interpret
2628 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2629 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"))
2630 ;; Accept missing final newline in value.
2633 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"
2634 (org-element-interpret-data '(comment-block (:value
"Test"))))))
2636 (ert-deftest test-org-element
/diary-sexp
()
2637 "Test diary-sexp interpreter."
2640 (org-test-parse-and-interpret
2641 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2642 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2644 (ert-deftest test-org-element
/example-block-interpreter
()
2645 "Test example block interpreter."
2646 ;; Without switches.
2647 (should (equal (org-test-parse-and-interpret
2648 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2649 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2652 (equal (org-test-parse-and-interpret
2653 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2654 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2655 ;; Preserve code escaping.
2657 (equal (org-test-parse-and-interpret
2658 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2659 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n"))
2660 ;; Accept missing final newline in value.
2663 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"
2664 (org-element-interpret-data '(example-block (:value
"Test"))))))
2666 (ert-deftest test-org-element
/export-block-interpreter
()
2667 "Test export block interpreter."
2668 (should (equal (org-test-parse-and-interpret
2669 "#+BEGIN_EXPORT HTML\nTest\n#+END_EXPORT")
2670 "#+BEGIN_EXPORT HTML\nTest\n#+END_EXPORT\n")))
2672 (ert-deftest test-org-element
/fixed-width-interpreter
()
2673 "Test fixed width interpreter."
2675 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2676 ;; Preserve indentation.
2677 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2678 ": 2 blanks\n: 1 blank\n"))
2679 ;; Remove last newline character
2681 (equal (org-element-fixed-width-interpreter
2682 '(fixed-width (:value
"Test\n")) nil
)
2685 (equal (org-element-fixed-width-interpreter
2686 '(fixed-width (:value
"Test")) nil
)
2688 ;; Handle empty string.
2690 (equal (org-element-fixed-width-interpreter
2691 '(fixed-width (:value
"")) nil
)
2693 ;; Handle nil value.
2695 (org-element-fixed-width-interpreter
2696 '(fixed-width (:value nil
)) nil
)))
2698 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2699 "Test horizontal rule interpreter."
2700 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2702 (ert-deftest test-org-element
/keyword-interpreter
()
2703 "Test keyword interpreter."
2704 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2705 "#+KEYWORD: value\n")))
2707 (ert-deftest test-org-element
/latex-environment-interpreter
()
2708 "Test latex environment interpreter."
2709 (should (equal (org-test-parse-and-interpret
2710 "\\begin{equation}\n1+1=2\n\\end{equation}")
2711 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2712 (should (equal (org-test-parse-and-interpret
2713 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2714 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2716 (ert-deftest test-org-element
/planning-interpreter
()
2717 "Test planning interpreter."
2721 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2722 (org-test-parse-and-interpret
2724 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2726 (ert-deftest test-org-element
/property-drawer-interpreter
()
2727 "Test property drawer interpreter."
2728 (should (equal (let ((org-property-format "%-10s %s"))
2729 (org-test-parse-and-interpret
2730 "* H\n:PROPERTIES:\n:prop: value\n:END:"))
2731 "* H\n:PROPERTIES:\n:prop: value\n:END:\n")))
2733 (ert-deftest test-org-element
/src-block-interpreter
()
2734 "Test src block interpreter."
2737 (equal (let ((org-edit-src-content-indentation 2)
2738 (org-src-preserve-indentation nil
))
2739 (org-test-parse-and-interpret
2740 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2741 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2744 (equal (let ((org-edit-src-content-indentation 2)
2745 (org-src-preserve-indentation nil
))
2746 (org-test-parse-and-interpret
2747 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2748 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2749 ;; Preserve code escaping.
2751 (equal (let ((org-edit-src-content-indentation 2)
2752 (org-src-preserve-indentation nil
))
2753 (org-test-parse-and-interpret
2754 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2755 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2756 ;; Do not apply `org-edit-src-content-indentation' when preserving
2759 (equal (let ((org-edit-src-content-indentation 2)
2760 (org-src-preserve-indentation t
))
2761 (org-test-parse-and-interpret
2762 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2763 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2765 (equal (let ((org-edit-src-content-indentation 2)
2766 (org-src-preserve-indentation nil
))
2767 (org-test-parse-and-interpret
2768 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2769 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n"))
2770 ;; Accept missing final newline in value.
2773 "#+BEGIN_SRC emacs-lisp\n Test\n#+END_SRC\n"
2774 (let ((org-edit-src-content-indentation 2)
2775 (org-src-preserve-indentation nil
))
2776 (org-element-interpret-data
2777 '(src-block (:language
"emacs-lisp" :value
"Test")))))))
2779 (ert-deftest test-org-element
/table-interpreter
()
2780 "Test table, table-row and table-cell interpreters."
2782 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2783 "| a | b |\n| c | d |\n"))
2784 ;; 2. With horizontal rules.
2785 (should (equal (org-test-parse-and-interpret
2786 "| a | b |\n|---+---|\n| c | d |")
2787 "| a | b |\n|---+---|\n| c | d |\n"))
2788 ;; 3. With meta-data.
2789 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2790 "| / | < | > |\n| * | 1 | 2 |\n"))
2791 ;; 4. With a formula.
2793 (equal (org-test-parse-and-interpret
2794 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2795 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2796 ;; 5. With multiple formulas.
2798 (equal (org-test-parse-and-interpret
2799 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2800 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2802 (ert-deftest test-org-element
/timestamp-interpreter
()
2803 "Test timestamp interpreter."
2806 (string-match "<2012-03-29 .* 16:40>"
2807 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2809 (string-match "<2012-03-29 .* 16:40>"
2810 (org-element-timestamp-interpreter
2812 (:type active
:year-start
2012 :month-start
3 :day-start
29
2813 :hour-start
16 :minute-start
40)) nil
)))
2816 (string-match "\\[2012-03-29 .* 16:40\\]"
2817 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2820 "\\[2012-03-29 .* 16:40\\]"
2821 (org-element-timestamp-interpreter
2823 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2824 :hour-start
16 :minute-start
40)) nil
)))
2827 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2828 (org-test-parse-and-interpret
2829 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2832 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2833 (org-element-timestamp-interpreter
2835 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2836 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2837 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2840 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2841 (org-test-parse-and-interpret
2842 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2845 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2846 (org-element-timestamp-interpreter
2848 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2849 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2850 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2852 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2853 "<%%diary-float t 4 2>\n"))
2854 ;; Timestamp with repeater interval, with delay, with both.
2856 (string-match "<2012-03-29 .* \\+1y>"
2857 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2860 "<2012-03-29 .* \\+1y>"
2861 (org-element-timestamp-interpreter
2863 (:type active
:year-start
2012 :month-start
3 :day-start
29
2864 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2868 "<2012-03-29 .* -1y>"
2869 (org-element-timestamp-interpreter
2871 (:type active
:year-start
2012 :month-start
3 :day-start
29
2872 :warning-type all
:warning-value
1 :warning-unit year
))
2876 "<2012-03-29 .* \\+1y -1y>"
2877 (org-element-timestamp-interpreter
2879 (:type active
:year-start
2012 :month-start
3 :day-start
29
2880 :warning-type all
:warning-value
1 :warning-unit year
2881 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2883 ;; Timestamp range with repeater interval
2885 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2886 (org-test-parse-and-interpret
2887 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2890 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2891 (org-element-timestamp-interpreter
2893 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2894 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2895 :repeater-value
1 :repeater-unit year
))
2898 (ert-deftest test-org-element
/verse-block-interpreter
()
2899 "Test verse block interpretation."
2901 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2902 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2904 (ert-deftest test-org-element
/bold-interpreter
()
2905 "Test bold interpreter."
2906 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2908 (ert-deftest test-org-element
/code-interpreter
()
2909 "Test code interpreter."
2910 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2912 (ert-deftest test-org-element
/entity-interpreter
()
2913 "Test entity interpreter."
2914 ;; 1. Without brackets.
2916 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2917 ;; 2. With brackets.
2919 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2921 (ert-deftest test-org-element
/export-snippet-interpreter
()
2922 "Test export snippet interpreter."
2923 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2924 "@@back-end:contents@@\n")))
2926 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2927 "Test footnote reference interpreter."
2928 ;; Regular reference.
2929 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2931 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2932 "Text[fn:label]\n"))
2933 ;; Inline reference.
2934 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2935 "Text[fn:label:def]\n"))
2936 ;; Anonymous reference.
2937 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2938 "Text[fn::def]\n")))
2940 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2941 "Test inline babel call interpreter."
2942 ;; Without arguments.
2943 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2945 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2946 "call_test(x=2)\n"))
2947 ;; With header arguments.
2948 (should (equal (org-test-parse-and-interpret
2949 "call_test[:results output]()[:results html]")
2950 "call_test[:results output]()[:results html]\n")))
2952 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2953 "Test inline src block interpreter."
2954 ;; 1. Without header argument.
2955 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2956 "src_emacs-lisp{(+ 1 1)}\n"))
2957 ;; 2. With header arguments.
2958 (should (equal (org-test-parse-and-interpret
2959 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2960 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2962 (ert-deftest test-org-element
/italic-interpreter
()
2963 "Test italic interpreter."
2964 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2966 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2967 "Test latex fragment interpreter."
2968 (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
2969 (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
2970 (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
2971 (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
2972 (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
2973 (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
2975 (ert-deftest test-org-element
/line-break-interpreter
()
2976 "Test line break interpreter."
2977 (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
2978 "First line \\\\\nSecond line\n")))
2980 (ert-deftest test-org-element
/link-interpreter
()
2981 "Test link interpreter."
2982 ;; Links targeted from a radio target.
2983 (should (equal (let ((org-target-link-regexp "radio-target"))
2984 (org-test-parse-and-interpret "a radio-target"))
2985 "a radio-target\n"))
2986 ;; Links without description.
2987 (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
2988 "[[http://orgmode.org]]\n"))
2989 ;; Links with a description.
2990 (should (equal (org-test-parse-and-interpret
2991 "[[http://orgmode.org][Org mode]]")
2992 "[[http://orgmode.org][Org mode]]\n"))
2995 (equal (org-test-parse-and-interpret "[[file+emacs:todo.org]]")
2996 "[[file+emacs:todo.org]]\n"))
2998 (equal (org-test-parse-and-interpret "[[file:todo.org::*task]]")
2999 "[[file:todo.org::*task]]\n"))
3001 (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
3003 (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
3005 (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
3006 ;; Normalize plain links.
3007 (should (equal (org-test-parse-and-interpret "http://orgmode.org")
3008 "[[http://orgmode.org]]\n"))
3009 ;; Normalize angular links.
3010 (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
3011 "[[http://orgmode.org]]\n")))
3013 (ert-deftest test-org-element
/macro-interpreter
()
3014 "Test macro interpreter."
3015 ;; 1. Without argument.
3016 (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
3017 ;; 2. With arguments.
3018 (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
3019 "{{{test(arg1,arg2)}}}\n")))
3021 (ert-deftest test-org-element
/radio-target-interpreter
()
3022 "Test radio target interpreter."
3023 (should (equal (org-test-parse-and-interpret "<<<some text>>>")
3024 "<<<some text>>>\n")))
3026 (ert-deftest test-org-element
/statistics-cookie-interpreter
()
3027 "Test statistics cookie interpreter."
3028 ;; 1. Without percent
3029 (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
3031 (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
3033 (ert-deftest test-org-element
/strike-through-interpreter
()
3034 "Test strike through interpreter."
3035 (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
3037 (ert-deftest test-org-element
/subscript-interpreter
()
3038 "Test subscript interpreter."
3039 ;; 1. Without brackets.
3040 (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
3041 ;; 2. With brackets.
3042 (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
3044 (ert-deftest test-org-element
/superscript-interpreter
()
3045 "Test superscript interpreter."
3046 ;; 1. Without brackets.
3047 (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
3048 ;; 2. With brackets.
3049 (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
3051 (ert-deftest test-org-element
/target-interpreter
()
3052 "Test target interpreter."
3053 (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
3055 (ert-deftest test-org-element
/underline-interpreter
()
3056 "Test underline interpreter."
3057 (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
3059 (ert-deftest test-org-element
/verbatim-interpreter
()
3060 "Test verbatim interpreter."
3061 (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
3065 ;;; Test Granularity
3067 (ert-deftest test-org-element
/granularity
()
3068 "Test granularity impact on buffer parsing."
3069 (org-test-with-temp-text "
3076 ;; 1.1. Granularity set to `headline' should parse every headline
3077 ;; in buffer, and only them.
3078 (let ((tree (org-element-parse-buffer 'headline
)))
3079 (should (= 2 (length (org-element-map tree
'headline
'identity
))))
3080 (should-not (org-element-map tree
'paragraph
'identity
)))
3081 ;; 1.2. Granularity set to `greater-element' should not enter
3082 ;; greater elements excepted headlines and sections.
3083 (let ((tree (org-element-parse-buffer 'greater-element
)))
3084 (should (= 1 (length (org-element-map tree
'center-block
'identity
))))
3085 (should (= 1 (length (org-element-map tree
'paragraph
'identity
))))
3086 (should-not (org-element-map tree
'entity
'identity
)))
3087 ;; 1.3. Granularity set to `element' should enter every
3089 (let ((tree (org-element-parse-buffer 'element
)))
3090 (should (= 2 (length (org-element-map tree
'paragraph
'identity
))))
3091 (should-not (org-element-map tree
'entity
'identity
)))
3092 ;; 1.4. Granularity set to `object' can see everything.
3093 (let ((tree (org-element-parse-buffer 'object
)))
3094 (should (= 1 (length (org-element-map tree
'entity
'identity
)))))))
3096 (ert-deftest test-org-element
/secondary-string-parsing
()
3097 "Test if granularity correctly toggles secondary strings parsing."
3098 ;; With a granularity bigger than `object', no secondary string
3099 ;; should be parsed.
3102 (org-test-with-temp-text "* Headline"
3104 (org-element-map (org-element-parse-buffer 'headline
) 'headline
3105 #'identity nil
'first-match
)))
3106 (org-element-property :title headline
)))))
3109 (org-test-with-temp-text "* Headline\n- tag :: item"
3110 (let ((item (org-element-map (org-element-parse-buffer 'element
) 'item
3111 #'identity nil
'first-match
)))
3112 (org-element-property :tag item
)))))
3113 (when (featurep 'org-inlinetask
)
3116 (let ((org-inlinetask-min-level 15))
3117 (org-test-with-temp-text "*************** Inlinetask"
3118 (let ((inlinetask (org-element-map (org-element-parse-buffer 'element
)
3120 #'identity nil
'first-match
)))
3121 (org-element-property :title inlinetask
)))))))
3122 ;; With a default granularity, secondary strings should be parsed.
3125 (org-test-with-temp-text "* Headline"
3127 (org-element-map (org-element-parse-buffer) 'headline
3128 #'identity nil
'first-match
)))
3129 (org-element-property :title headline
)))))
3130 ;; `org-element-at-point' should never parse a secondary string.
3133 (org-test-with-temp-text "* Headline"
3134 (org-element-property :title
(org-element-at-point)))))
3135 ;; Preserve current local variables when parsing a secondary string.
3137 (let ((org-entities nil
)
3138 (org-entities-user nil
))
3139 (org-test-with-temp-text "
3143 # org-entities-user: ((\"foo\"))
3145 (let ((safe-local-variable-values '((org-entities-user .
(("foo"))))))
3146 (hack-local-variables))
3147 (org-element-map (org-element-parse-buffer) 'entity
3148 #'identity nil nil nil t
)))))
3152 ;;; Test Visible Only Parsing
3154 (ert-deftest test-org-element
/parse-buffer-visible
()
3155 "Test `org-element-parse-buffer' with visible only argument."
3157 (equal '("H1" "H3" "H5")
3158 (org-test-with-temp-text
3159 "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
3160 (org-occur ":visible:")
3161 (org-element-map (org-element-parse-buffer nil t
) 'headline
3162 (lambda (hl) (org-element-property :raw-value hl
)))))))
3166 ;;; Test `:parent' Property
3168 (ert-deftest test-org-element
/parent-property
()
3169 "Test `:parent' property."
3171 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
3172 (let* ((tree (org-element-parse-buffer))
3173 (parent (org-element-property
3175 (org-element-map tree
'paragraph
'identity nil t
))))
3177 (should (eq (org-element-map tree
'center-block
'identity nil t
)
3180 (org-test-with-temp-text "a_{/b/}"
3181 (let* ((tree (org-element-parse-buffer))
3182 (parent (org-element-property
3184 (org-element-map tree
'italic
'identity nil t
))))
3187 (org-element-map tree
'subscript
'identity nil t
)))))
3188 ;; Secondary strings
3189 (org-test-with-temp-text "* /italic/"
3190 (let* ((tree (org-element-parse-buffer))
3191 (parent (org-element-property
3192 :parent
(org-element-map tree
'italic
'identity nil t
))))
3195 (org-element-map tree
'headline
'identity nil t
))))))
3199 ;;; Test Normalize Contents
3201 (ert-deftest test-org-element
/normalize-contents
()
3202 "Test `org-element-normalize-contents' specifications."
3203 ;; Remove maximum common indentation from element's contents.
3206 (org-element-normalize-contents
3207 '(paragraph nil
" Two spaces\n Three spaces"))
3208 '(paragraph nil
"Two spaces\n Three spaces")))
3209 ;; Ignore objects within contents when computing maximum common
3210 ;; indentation. However, if contents start with an object, common
3211 ;; indentation is 0.
3214 (org-element-normalize-contents
3215 '(paragraph nil
" One " (emphasis nil
"space") "\n Two spaces"))
3216 '(paragraph nil
"One " (emphasis nil
"space") "\n Two spaces")))
3219 (org-element-normalize-contents
3220 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three"))
3221 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three")))
3222 ;; Ignore blank lines.
3225 (org-element-normalize-contents
3226 '(paragraph nil
" Two spaces\n\n \n Two spaces"))
3227 '(paragraph nil
"Two spaces\n\n\nTwo spaces")))
3230 '(paragraph nil
" Two spaces\n" (verbatim nil
"V") "\n Two spaces")
3231 (org-element-normalize-contents
3232 '(paragraph nil
" Two spaces\n " (verbatim nil
"V") "\n Two spaces"))))
3235 '(verse-block nil
"line 1\n\nline 2")
3236 (org-element-normalize-contents
3237 '(verse-block nil
" line 1\n\n line 2"))))
3238 ;; Recursively enter objects in order to compute common indentation.
3241 (org-element-normalize-contents
3242 '(paragraph nil
" Two spaces " (bold nil
" and\n One space")))
3243 '(paragraph nil
" Two spaces " (bold nil
" and\nOne space"))))
3244 ;; When optional argument is provided, ignore first line
3248 (org-element-normalize-contents
3249 '(paragraph nil
"No space\n Two spaces\n Three spaces") t
)
3250 '(paragraph nil
"No space\nTwo spaces\n Three spaces")))
3253 (org-element-normalize-contents
3254 '(paragraph nil
(verbatim nil
"V") "No space\n Two\n Three") t
)
3255 '(paragraph nil
(verbatim nil
"V") "No space\nTwo\n Three")))
3256 ;; Corner case: do not ignore indentation of string right after
3260 (org-element-normalize-contents
3261 '(paragraph nil
" 1 space" (line-break) " 2 spaces"))
3262 '(paragraph nil
"1 space" (line-break) " 2 spaces"))))
3266 ;;; Test Navigation Tools.
3268 (ert-deftest test-org-element
/at-point
()
3269 "Test `org-element-at-point' specifications."
3270 ;; Return closest element containing point.
3273 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3274 (progn (search-forward "A")
3275 (org-element-type (org-element-at-point))))))
3276 ;; Correctly set `:parent' property.
3279 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3280 (progn (search-forward "A")
3282 (org-element-property :parent
(org-element-at-point)))))))
3283 ;; Special case: at a blank line just below a headline, return that
3286 (equal "H1" (org-test-with-temp-text "* H1\n \n* H2\n"
3288 (org-element-property :title
(org-element-at-point)))))
3289 ;; Special case: at the very beginning of a table, return `table'
3290 ;; object instead of `table-row'.
3293 (org-test-with-temp-text "| a | b |"
3294 (org-element-type (org-element-at-point)))))
3295 ;; Special case: at the very beginning of a list or sub-list, return
3296 ;; `plain-list' object instead of `item'.
3299 (org-test-with-temp-text "- item"
3300 (org-element-type (org-element-at-point)))))
3301 ;; Special case: at the closing line of a greater element, be sure
3302 ;; to return it instead of the last element in its contents.
3305 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
3306 (progn (forward-line 2)
3307 (org-element-type (org-element-at-point))))))
3308 ;; Special case: at a blank line between two items, be sure to
3309 ;; return item above instead of the last element of its contents.
3312 (org-test-with-temp-text "- Para1\n\n- Para2"
3314 (org-element-type (org-element-at-point)))))
3315 ;; Special case: at the last blank line in a plain list, return it
3316 ;; instead of the last item.
3319 (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
3320 (progn (forward-line 2)
3321 (org-element-type (org-element-at-point))))))
3322 ;; Special case: when a list ends at the end of buffer and there's
3323 ;; no final newline, return last element in last item.
3326 (org-test-with-temp-text "- a"
3328 (org-element-type (org-element-at-point)))))
3329 ;; Parse a list within a block itself contained in a list.
3332 (org-test-with-temp-text
3333 "- outer\n #+begin_center\n - inner\n #+end_center"
3334 (search-forward "inner")
3336 (org-element-type (org-element-at-point)))))
3337 ;; Do not error at eob on an empty line.
3339 (org-test-with-temp-text "* H\n"
3341 (or (org-element-at-point) t
))))
3343 (ert-deftest test-org-element
/context
()
3344 "Test `org-element-context' specifications."
3345 ;; Return closest object containing point.
3348 (org-test-with-temp-text "Some *text with _under<point>line_ text*"
3349 (org-element-type (org-element-context)))))
3350 ;; Find objects in secondary strings.
3353 (org-test-with-temp-text "* Headline _<point>with_ underlining"
3354 (org-element-type (org-element-context)))))
3355 ;; Find objects in objects.
3358 (org-test-with-temp-text "| a | {<point>{{macro}}} |"
3359 (org-element-type (org-element-context)))))
3362 (org-test-with-temp-text "| a | b<point> {{{macro}}} |"
3363 (org-element-type (org-element-context)))))
3364 ;; Find objects in planning lines.
3367 (org-test-with-temp-text "* H\n SCHEDULED: <2012<point>-03-29 thu.>"
3368 (org-element-type (org-element-context)))))
3371 (org-test-with-temp-text "* H\n SCHEDULED<point>: <2012-03-29 thu.>"
3372 (org-element-type (org-element-context)))))
3373 ;; Find objects in item tags.
3376 (org-test-with-temp-text "- *bo<point>ld* ::"
3377 (org-element-type (org-element-context)))))
3380 (org-test-with-temp-text "- *bold* ::<point>"
3381 (org-element-type (org-element-context)))))
3384 (org-test-with-temp-text "- *bold* ::\n<point>"
3385 (org-element-type (org-element-context)))))
3386 ;; Do not find objects in table rules.
3389 (org-test-with-temp-text "| a | b |\n|-<point>--|---|\n| c | d |"
3390 (org-element-type (org-element-context)))))
3391 ;; Find objects in parsed affiliated keywords.
3394 (org-test-with-temp-text "#+CAPTION: {<point>{{macro}}}\n| a | b |"
3395 (org-element-type (org-element-context)))))
3398 (org-test-with-temp-text "#+caption: *<point>bold*\nParagraph"
3399 (org-element-type (org-element-context)))))
3400 ;; Find objects at the end of buffer.
3403 (org-test-with-temp-text "*bold*"
3404 (goto-char (point-max))
3405 (org-element-type (org-element-context)))))
3406 ;; Correctly set `:parent' property.
3409 (org-test-with-temp-text "Some *bold<point>* text"
3411 (org-element-property :parent
(org-element-context))))))
3412 ;; Between two objects, return the second one.
3415 (org-test-with-temp-text "<<target>><point>{{{test}}}"
3416 (org-element-type (org-element-context)))))
3417 ;; Test optional argument.
3420 (org-test-with-temp-text "Some *text with _under<point>line_ text*"
3421 (org-element-type (org-element-context (org-element-at-point))))))
3422 ;; Special case: bold object at the beginning of a headline.
3425 (org-test-with-temp-text "* *bo<point>ld*"
3426 (org-element-type (org-element-context)))))
3427 ;; Special case: incomplete cell at the end of a table row.
3430 (org-test-with-temp-text "|a|b|c<point>"
3431 (org-element-type (org-element-context)))))
3432 ;; Special case: objects in inline footnotes.
3435 (org-test-with-temp-text "[fn::[[<point>http://orgmode.org]]]"
3436 (org-element-type (org-element-context)))))
3437 ;; Special case: tags looking like a link.
3440 (org-test-with-temp-text "* Headline :file<point>:tags:"
3441 (org-element-type (org-element-context)))))
3444 (org-test-with-temp-text "* Headline :file<point>:tags: :real:tag:"
3445 (org-element-type (org-element-context))))))
3451 (ert-deftest test-org-element
/lineage
()
3452 "Test `org-element-lineage' specifications."
3453 ;; Regular tests. When applied to an element or object returned by
3454 ;; `org-element-at-point' or `org-element-context', the list is
3455 ;; limited to the current section.
3457 (equal '(paragraph center-block
)
3458 (org-test-with-temp-text
3459 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3460 (mapcar #'car
(org-element-lineage (org-element-context))))))
3462 (equal '(paragraph center-block section headline headline org-data
)
3463 (org-test-with-temp-text
3464 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3466 (org-element-lineage
3467 (org-element-map (org-element-parse-buffer) 'bold
3468 #'identity nil t
))))))
3469 ;; Test TYPES optional argument.
3472 (org-test-with-temp-text
3473 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3475 (org-element-lineage (org-element-context) '(center-block))))))
3477 (org-test-with-temp-text
3478 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3479 (org-element-lineage (org-element-context) '(example-block))))
3480 ;; Test WITH-SELF optional argument.
3482 (equal '(bold paragraph center-block
)
3483 (org-test-with-temp-text
3484 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3485 (mapcar #'car
(org-element-lineage (org-element-context) nil t
)))))
3486 ;; When TYPES and WITH-SELF are provided, the latter is also checked
3487 ;; against the former.
3489 (org-test-with-temp-text
3490 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3491 (org-element-lineage (org-element-context) '(bold) t
))))
3497 (ert-deftest test-org-element
/cache
()
3498 "Test basic expectations and common pitfalls for cache."
3502 (org-test-with-temp-text "para1\n\npara2\n\npara3"
3503 (let ((org-element-use-cache t
))
3504 (save-excursion (goto-char (point-max)) (org-element-at-point))
3507 (let ((element (org-element-at-point)))
3508 (cons (org-element-property :begin element
)
3509 (org-element-property :end element
)))))))
3510 ;; Partial shifting: when the contents of a greater element are
3511 ;; modified, only shift ending positions.
3513 (org-test-with-temp-text
3514 "#+BEGIN_CENTER\nPara1\n\nPara2\n\nPara3\n#+END_CENTER"
3515 (let ((org-element-use-cache t
))
3516 (save-excursion (search-forward "3") (org-element-at-point))
3517 (search-forward "Para2")
3519 (let ((element (org-element-property :parent
(org-element-at-point))))
3520 (equal (cons (org-element-property :begin element
)
3521 (org-element-property :end element
))
3522 (cons (point-min) (point-max)))))))
3523 ;; Re-parent shifted elements.
3526 (org-test-with-temp-text "- item\n\n\n para1\n para2"
3527 (let ((org-element-use-cache t
))
3529 (org-element-at-point)
3530 (save-excursion (goto-char (point-max)) (org-element-at-point))
3533 (goto-char (point-max))
3535 (org-element-property :parent
(org-element-at-point)))))))
3536 ;; Preserve local structures when re-parenting.
3539 (org-test-with-temp-text
3540 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n| c | d |\n#+end_center"
3541 (let ((org-element-use-cache t
))
3542 (save-excursion (search-forward "| c |") (org-element-at-point))
3544 (search-forward "| c |")
3547 (org-element-property :parent
(org-element-at-point)))))))
3550 (org-test-with-temp-text
3551 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n#+end_center"
3552 (let ((org-element-use-cache t
))
3553 (save-excursion (search-forward "| a |") (org-element-at-point))
3555 (search-forward "| a |")
3558 (org-element-property :parent
(org-element-at-point)))))))
3559 ;; When re-parenting, also propagate changes to list structures.
3562 (org-test-with-temp-text "\n Para\n - item<point>"
3563 (let ((org-element-use-cache t
))
3564 (org-element-at-point)
3565 (goto-char (point-min))
3567 (search-forward "- item")
3569 (length (org-element-property :structure
(org-element-at-point)))))))
3570 ;; Modifying the last line of an element alters the element below.
3572 (org-test-with-temp-text "para1\n\npara2"
3573 (let ((org-element-use-cache t
))
3574 (goto-char (point-max))
3575 (org-element-at-point)
3578 (let ((element (org-element-at-point)))
3579 (equal (cons (org-element-property :begin element
)
3580 (org-element-property :end element
))
3581 (cons (point-min) (point-max)))))))
3582 ;; Modifying the first line of an element alters the element above.
3584 (org-test-with-temp-text ": fixed-width\n:not-fixed-width"
3585 (let ((org-element-use-cache t
))
3586 (goto-char (point-max))
3587 (org-element-at-point)
3588 (search-backward ":")
3591 (let ((element (org-element-at-point)))
3592 (equal (cons (org-element-property :begin element
)
3593 (org-element-property :end element
))
3594 (cons (point-min) (point-max)))))))
3595 ;; Sensitive change: adding a line alters document structure both
3599 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n"
3600 (let ((org-element-use-cache t
))
3601 (goto-char (point-max))
3602 (org-element-at-point)
3603 (insert "#+END_EXAMPLE")
3604 (search-backward "Para1")
3605 (org-element-type (org-element-at-point))))))
3608 (org-test-with-temp-text "Para1\n\nPara2\n#+END_EXAMPLE"
3609 (let ((org-element-use-cache t
))
3610 (save-excursion (goto-char (point-max)) (org-element-at-point))
3611 (insert "#+BEGIN_EXAMPLE\n")
3612 (search-forward "Para2")
3613 (org-element-type (org-element-at-point))))))
3614 ;; Sensitive change: removing a line alters document structure both
3618 (org-test-with-temp-text
3619 "# +BEGIN_EXAMPLE\nPara1\n\nPara2\n#+END_EXAMPLE"
3620 (let ((org-element-use-cache t
))
3621 (save-excursion (goto-char (point-max)) (org-element-at-point))
3624 (search-forward "Para2")
3625 (org-element-type (org-element-at-point))))))
3628 (org-test-with-temp-text
3629 "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n# +END_EXAMPLE"
3630 (let ((org-element-use-cache t
))
3631 (save-excursion (goto-char (point-max)) (org-element-at-point))
3632 (search-forward "# ")
3634 (search-backward "Para1")
3635 (org-element-type (org-element-at-point))))))
3636 ;; Corner case: watch out drawers named "PROPERTIES" as they are
3637 ;; fragile, unlike to other drawers.
3640 (org-test-with-temp-text "* H\n:PROPERTIES:\n:A: 1\n:A<point>\n:END:"
3641 (let ((org-element-use-cache t
))
3642 (org-element-at-point)
3644 (org-element-type (org-element-at-point))))))
3645 ;; Properly handle elements not altered by modifications but whose
3646 ;; parents were removed from cache.
3648 (org-test-with-temp-text
3649 "Paragraph\n\n\n\n#+begin_center\n<point>contents\n#+end_center"
3650 (let ((org-element-use-cache t
)
3651 (parent-end (point-max)))
3652 (org-element-at-point)
3653 (save-excursion (search-backward "Paragraph")
3656 (eq (org-element-property
3657 :end
(org-element-property :parent
(org-element-at-point)))
3658 (+ parent-end
3))))))
3661 (provide 'test-org-element
)
3663 ;;; test-org-element.el ends here