1 ;;; test-org-element.el --- Tests for org-element.el
3 ;; Copyright (C) 2012, 2013, 2014 Nicolas Goaziou
5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
7 ;; This program is free software; you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation, either version 3 of the License, or
10 ;; (at your option) any later version.
12 ;; This program is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
22 (unless (featurep 'org-element
)
23 (signal 'missing-test-dependency
"org-element"))
25 (defun org-test-parse-and-interpret (text)
26 "Parse TEXT as Org syntax and interpret it.
27 Return interpreted string."
31 (org-element-interpret-data (org-element-parse-buffer))))
35 ;;; Test `org-element-map'
37 (ert-deftest test-org-element
/map
()
38 "Test `org-element-map'."
39 ;; Can map to `plain-text' objects.
42 (org-test-with-temp-text "Some text \alpha
48 (org-element-parse-buffer) 'plain-text
49 (lambda (s) (when (string-match "text" s
) (incf count
))))
51 ;; Applies to secondary strings
53 (org-element-map '("some " (bold nil
"bold") "text") 'bold
'identity
))
54 ;; Enter secondary strings before entering contents.
60 (org-test-with-temp-text "* Some \\alpha headline\n\\beta entity."
61 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
)))))
62 ;; Apply NO-RECURSION argument.
64 (org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
66 (org-element-parse-buffer) 'entity
'identity nil nil
'center-block
)))
67 ;; Use WITH-AFFILIATED argument.
71 (org-test-with-temp-text "#+CAPTION[a]: 1\n#+CAPTION[b]: 2\nParagraph"
73 (org-element-at-point) 'plain-text
'identity nil nil nil t
)))))
79 (ert-deftest test-org-element
/put-property
()
80 "Test `org-element-put-property' specifications."
82 (org-test-with-temp-text "* Headline\n *a*"
83 (let ((tree (org-element-parse-buffer)))
84 (org-element-put-property
85 (org-element-map tree
'bold
'identity nil t
) :test
1)
86 (should (org-element-property
87 :test
(org-element-map tree
'bold
'identity nil t
)))))
88 ;; Put property on a string.
90 (org-element-property :test
(org-element-put-property "Paragraph" :test t
))))
92 (ert-deftest test-org-element
/set-contents
()
93 "Test `org-element-set-contents' specifications."
94 ;; Accept multiple entries.
96 (equal '("b" (italic nil
"a"))
97 (org-test-with-temp-text "* Headline\n *a*"
98 (let ((tree (org-element-parse-buffer)))
99 (org-element-set-contents
100 (org-element-map tree
'bold
'identity nil t
) "b" '(italic nil
"a"))
101 (org-element-contents
102 (org-element-map tree
'bold
'identity nil t
))))))
103 ;; Accept atoms and elements.
106 (org-test-with-temp-text "* Headline\n *a*"
107 (let ((tree (org-element-parse-buffer)))
108 (org-element-set-contents
109 (org-element-map tree
'bold
'identity nil t
) "b")
110 (org-element-contents
111 (org-element-map tree
'bold
'identity nil t
))))))
113 (equal '((italic nil
"b"))
114 (org-test-with-temp-text "* Headline\n *a*"
115 (let ((tree (org-element-parse-buffer)))
116 (org-element-set-contents
117 (org-element-map tree
'bold
'identity nil t
) '(italic nil
"b"))
118 (org-element-contents
119 (org-element-map tree
'bold
'identity nil t
))))))
120 ;; Allow nil contents.
122 (org-test-with-temp-text "* Headline\n *a*"
123 (let ((tree (org-element-parse-buffer)))
124 (org-element-set-contents (org-element-map tree
'bold
'identity nil t
))
125 (org-element-contents (org-element-map tree
'bold
'identity nil t
))))))
127 (ert-deftest test-org-element
/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
))))))
292 ;;;; Affiliated Keywords
294 (ert-deftest test-org-element
/affiliated-keywords-parser
()
295 "Test affiliated keywords parsing."
296 ;; Read simple keywords.
299 (org-element-property
301 (org-test-with-temp-text "#+NAME: para\nParagraph"
302 (org-element-at-point)))))
305 (org-element-property
307 (org-test-with-temp-text "#+NAME: para\nParagraph"
308 (org-element-at-point)))))
309 ;; Parse multiple keywords.
313 (org-element-property
315 (org-test-with-temp-text
316 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
317 (org-element-at-point)))))
318 ;; Parse "parsed" keywords.
322 (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
323 (car (org-element-property :caption
(org-element-at-point))))))
324 ;; Parse dual keywords.
327 '((("long") "short"))
328 (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
329 (org-element-property :caption
(org-element-at-point)))))
330 ;; Allow multiple caption keywords.
333 '((("l2") "s2") (("l1") "s1"))
334 (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
335 (org-element-property :caption
(org-element-at-point)))))
338 '((("l1")) (nil "s1"))
339 (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
340 (org-element-property :caption
(org-element-at-point)))))
341 ;; Corner case: orphaned keyword at the end of an element.
344 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
345 (progn (search-forward "name")
346 (org-element-type (org-element-at-point))))))
348 (org-test-with-temp-text "- item\n #+name: name\nSome paragraph"
349 (progn (search-forward "Some")
350 (org-element-property :name
(org-element-at-point))))))
355 (ert-deftest test-org-element
/babel-call-parser
()
356 "Test `babel-call' parsing."
359 (org-test-with-temp-text "#+CALL: test()"
360 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
363 (org-test-with-temp-text "#+call: test()"
364 (org-element-map (org-element-parse-buffer) 'babel-call
'identity
)))
365 ;; Handle non-empty blank line at the end of buffer.
367 (org-test-with-temp-text "#+CALL: test()\n "
368 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
373 (ert-deftest test-org-element
/bold-parser
()
374 "Test `bold' parser."
377 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
378 (org-test-with-temp-text "*bold*"
379 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
380 ;; Multi-line markup.
383 (org-element-contents
384 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
385 (org-test-with-temp-text "*first line\nsecond line*"
386 (org-element-map (org-element-parse-buffer) 'bold
'identity nil t
))))
387 '("first line\nsecond line"))))
392 (ert-deftest test-org-element
/center-block-parser
()
393 "Test `center-block' parser."
396 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
397 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
400 (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
401 (org-element-map (org-element-parse-buffer) 'center-block
'identity
)))
402 ;; Ignore incomplete block.
404 (org-test-with-temp-text "#+BEGIN_CENTER"
405 (org-element-map (org-element-parse-buffer) 'center-block
407 ;; Handle non-empty blank line at the end of buffer.
409 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
410 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
415 (ert-deftest test-org-element
/clock-parser
()
416 "Test `clock' parser."
418 (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
419 (org-element-at-point))))
420 (should (eq (org-element-property :status clock
) 'running
))
422 (equal (org-element-property :raw-value
423 (org-element-property :value clock
))
424 "[2012-01-01 sun. 00:01]"))
425 (should-not (org-element-property :duration clock
)))
428 (org-test-with-temp-text
429 "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"
430 (org-element-at-point))))
431 (should (eq (org-element-property :status clock
) 'closed
))
432 (should (equal (org-element-property :raw-value
433 (org-element-property :value clock
))
434 "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
435 (should (equal (org-element-property :duration clock
) "0:01"))))
440 (ert-deftest test-org-element
/code-parser
()
441 "Test `code' parser."
444 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
445 (org-test-with-temp-text "~code~"
446 (org-element-map (org-element-parse-buffer) 'code
'identity
))))
447 ;; Multi-line markup.
450 (org-element-property
452 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
453 (org-test-with-temp-text "~first line\nsecond line~"
455 (org-element-parse-buffer) 'code
'identity nil t
))))
456 "first line\nsecond line")))
461 (ert-deftest test-org-element
/comment-parser
()
462 "Test `comment' parser."
465 (org-test-with-temp-text "# Comment"
466 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
469 (org-test-with-temp-text " # Comment"
470 (org-element-map (org-element-parse-buffer) 'comment
'identity
)))
471 ;; Preserve indentation.
474 (org-element-property
476 (org-test-with-temp-text "# No blank\n# One blank"
477 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
478 "No blank\n One blank"))
479 ;; Comment with blank lines.
482 (org-element-property
484 (org-test-with-temp-text "# First part\n# \n#\n# Second part"
485 (org-element-map (org-element-parse-buffer) 'comment
'identity nil t
)))
486 "First part\n\n\nSecond part"))
487 ;; Do not mix comments and keywords.
490 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
491 (length (org-element-map (org-element-parse-buffer) 'comment
495 (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
496 (org-element-property
498 (org-element-map (org-element-parse-buffer) 'comment
500 ;; Correctly handle non-empty blank lines at the end of buffer.
502 (org-test-with-temp-text "# A\n "
503 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
508 (ert-deftest test-org-element
/comment-block-parser
()
509 "Test `comment-block' parser."
512 (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
513 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
516 (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
517 (org-element-map (org-element-parse-buffer) 'comment-block
'identity
)))
518 ;; Ignore incomplete block.
520 (org-test-with-temp-text "#+BEGIN_COMMENT"
521 (org-element-map (org-element-parse-buffer) 'comment-block
523 ;; Handle non-empty blank line at the end of buffer.
525 (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
526 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
531 (ert-deftest test-org-element
/diary-sexp-parser
()
532 "Test `diary-sexp' parser."
536 (org-test-with-temp-text
537 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old"
538 (org-element-type (org-element-at-point)))))
539 ;; Diary sexp must live at beginning of line
542 (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
543 (org-element-type (org-element-at-point)))))
544 ;; Handle non-empty blank line at the end of buffer.
546 (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
547 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
552 (ert-deftest test-org-element
/drawer-parser
()
553 "Test `drawer' parser."
556 (org-test-with-temp-text ":TEST:\nText\n:END:"
557 (org-element-map (org-element-parse-buffer) 'drawer
'identity
)))
558 ;; Ignore incomplete drawer.
560 (org-test-with-temp-text ":TEST:"
561 (org-element-map (org-element-parse-buffer) 'drawer
'identity nil t
)))
562 ;; Handle non-empty blank line at the end of buffer.
564 (org-test-with-temp-text ":TEST:\nC\n:END:\n "
565 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
570 (ert-deftest test-org-element
/dynamic-block-parser
()
571 "Test `dynamic-block' parser."
574 (org-test-with-temp-text
575 "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
576 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
579 (org-test-with-temp-text
580 "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
581 (org-element-map (org-element-parse-buffer) 'dynamic-block
'identity
)))
582 ;; Ignore incomplete block.
584 (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
585 (org-element-map (org-element-parse-buffer) 'dynamic-block
587 ;; Handle non-empty blank line at the end of buffer.
589 (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n "
590 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
595 (ert-deftest test-org-element
/entity-parser
()
596 "Test `entity' parser."
599 (org-test-with-temp-text "\\sin"
600 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
603 (org-element-property
605 (org-test-with-temp-text "\\alpha{}text"
606 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
607 ;; User-defined entity.
610 (org-element-property
612 (let ((org-entities-user
613 '(("test" "test" nil
"test" "test" "test" "test"))))
614 (org-test-with-temp-text "\\test"
615 (org-element-map (org-element-parse-buffer) 'entity
'identity nil t
))))
617 ;; Special case: entity at the end of a container.
620 (org-test-with-temp-text "*\\alpha \\beta*"
621 (search-forward "be")
622 (org-element-type (org-element-context))))))
627 (ert-deftest test-org-element
/example-block-parser
()
628 "Test `example-block' parser."
631 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
632 (org-element-map (org-element-parse-buffer) 'example-block
'identity
)))
633 ;; Ignore incomplete block.
636 (org-test-with-temp-text "#+BEGIN_EXAMPLE"
637 (org-element-type (org-element-at-point)))))
638 ;; Properly un-escape code.
640 (equal "* Headline\n #+keyword\nText\n"
641 (org-test-with-temp-text
642 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
643 (org-element-property :value
(org-element-at-point)))))
644 ;; Remove block indentation according to block boundaries, unless
645 ;; block contents are less indented than block boundaries.
648 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
649 (let ((org-src-preserve-indentation t
))
650 (org-element-property :value
(org-element-at-point))))))
654 (org-test-with-temp-text " #+BEGIN_EXAMPLE\n L1\n L2\n #+END_EXAMPLE"
655 (let ((org-src-preserve-indentation t
))
656 (org-element-property :value
(org-element-at-point))))))
657 ;; Handle non-empty blank line at the end of buffer.
659 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
660 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
662 (ert-deftest test-org-element
/block-switches
()
663 "Test `example-block' and `src-block' switches parsing."
664 (let ((org-coderef-label-format "(ref:%s)"))
665 ;; 1. Test "-i" switch.
667 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
668 (org-element-property :preserve-indent
(org-element-at-point))))
670 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
671 (org-element-property :preserve-indent
(org-element-at-point))))
673 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
674 (org-element-property :preserve-indent
(org-element-at-point))))
676 (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
677 (org-element-property :preserve-indent
(org-element-at-point))))
678 ;; 2. "-n -r -k" combination should number lines, retain labels but
679 ;; not use them in coderefs.
680 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
681 (let ((element (org-element-at-point)))
682 (should (org-element-property :number-lines element
))
683 (should (org-element-property :retain-labels element
))
684 (should-not (org-element-property :use-labels element
))))
685 (org-test-with-temp-text
686 "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
687 (let ((element (org-element-at-point)))
688 (should (org-element-property :number-lines element
))
689 (should (org-element-property :retain-labels element
))
690 (should-not (org-element-property :use-labels element
))))
691 ;; 3. "-n -r" combination should number-lines remove labels and not
692 ;; use them in coderefs.
693 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
694 (let ((element (org-element-at-point)))
695 (should (org-element-property :number-lines element
))
696 (should-not (org-element-property :retain-labels element
))
697 (should-not (org-element-property :use-labels element
))))
698 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
699 (let ((element (org-element-at-point)))
700 (should (org-element-property :number-lines element
))
701 (should-not (org-element-property :retain-labels element
))
702 (should-not (org-element-property :use-labels element
))))
703 ;; 4. "-n" or "+n" should number lines, retain labels and use them
706 (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
707 (let ((element (org-element-at-point)))
708 (and (org-element-property :number-lines element
)
709 (org-element-property :retain-labels element
)
710 (org-element-property :use-labels element
)))))
712 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
713 (let ((element (org-element-at-point)))
714 (and (org-element-property :number-lines element
)
715 (org-element-property :retain-labels element
)
716 (org-element-property :use-labels element
)))))
718 (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
719 (let ((element (org-element-at-point)))
720 (and (org-element-property :number-lines element
)
721 (org-element-property :retain-labels element
)
722 (org-element-property :use-labels element
)))))
724 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
725 (let ((element (org-element-at-point)))
726 (and (org-element-property :number-lines element
)
727 (org-element-property :retain-labels element
)
728 (org-element-property :use-labels element
)))))
729 ;; 5. No switch should not number lines, but retain labels and use
731 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
732 (let ((element (org-element-at-point)))
733 (should (not (org-element-property :number-lines element
)))
734 (should (org-element-property :retain-labels element
))
735 (should (org-element-property :use-labels element
))))
736 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
737 (let ((element (org-element-at-point)))
738 (should (not (org-element-property :number-lines element
)))
739 (should (org-element-property :retain-labels element
))
740 (should (org-element-property :use-labels element
))))
741 ;; 6. "-r" switch only: do not number lines, remove labels, and
742 ;; don't use labels in coderefs.
743 (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
744 (let ((element (org-element-at-point)))
745 (should (not (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 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
749 (let ((element (org-element-at-point)))
750 (should (not (org-element-property :number-lines element
)))
751 (should (not (org-element-property :retain-labels element
)))
752 (should (not (org-element-property :use-labels element
)))))
753 ;; 7. Recognize coderefs with user-defined syntax.
757 (org-test-with-temp-text
758 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
759 (org-element-property :label-fmt
(org-element-at-point)))))
763 (org-test-with-temp-text
764 "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
765 (org-element-property :label-fmt
(org-element-at-point)))))))
770 (ert-deftest test-org-element
/export-block-parser
()
771 "Test `export-block' parser."
774 (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
776 (let ((org-element-block-name-alist
777 '(("LATEX" . org-element-export-block-parser
))))
778 (org-element-parse-buffer))
779 'export-block
'identity
)))
782 (let ((org-element-block-name-alist
783 '(("LATEX" . org-element-export-block-parser
))))
784 (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
785 (org-element-map (org-element-parse-buffer) 'export-block
'identity
))))
786 ;; Ignore incomplete block.
788 (let ((org-element-block-name-alist
789 '(("LATEX" . org-element-export-block-parser
))))
790 (org-test-with-temp-text "#+BEGIN_LATEX"
791 (org-element-map (org-element-parse-buffer) 'export-block
793 ;; Handle non-empty blank line at the end of buffer.
795 (let ((org-element-block-name-alist
796 '(("LATEX" . org-element-export-block-parser
))))
797 (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
798 (= (org-element-property :end
(org-element-at-point)) (point-max))))))
803 (ert-deftest test-org-element
/export-snippet-parser
()
804 "Test `export-snippet' parser."
807 '("back-end" .
"contents")
808 (org-test-with-temp-text "@@back-end:contents@@"
810 (org-element-parse-buffer) 'export-snippet
811 (lambda (snippet) (cons (org-element-property :back-end snippet
)
812 (org-element-property :value snippet
)))
818 (ert-deftest test-org-element
/fixed-width-parser
()
819 "Test fixed-width area parsing."
820 ;; Preserve indentation.
822 (org-test-with-temp-text ": no blank\n: one blank"
823 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
824 ;; Fixed-width with empty lines.
826 (org-test-with-temp-text ": first part\n:\n: \n: second part"
827 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
828 ;; Parse indented fixed-width markers.
830 (org-test-with-temp-text "Text\n : no blank\n : one blank"
831 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))
832 ;; Distinguish fixed-width areas within a list and outside of it.
836 (org-test-with-temp-text "
839 : fixed-width outside"
840 (org-element-map (org-element-parse-buffer) 'fixed-width
'identity
)))))
841 ;; Handle non-empty blank line at the end of buffer.
843 (org-test-with-temp-text ": A\n "
844 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
847 ;;;; Footnote Definition
849 (ert-deftest test-org-element
/footnote-definition-parser
()
850 "Test `footnote-definition' parser."
852 (org-test-with-temp-text "[fn:1] Definition"
853 (org-element-map (org-element-parse-buffer) 'footnote-definition
855 ;; Footnote with more contents
858 (org-element-property
860 (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
861 (org-element-map (org-element-parse-buffer) 'footnote-definition
863 ;; Footnote starting with special syntax.
865 (org-test-with-temp-text "[fn:1] - no item"
866 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
867 ;; Correctly handle footnote starting with an empty line.
870 (org-test-with-temp-text "[fn:1]\n\n Body"
871 (org-element-property :contents-begin
(org-element-at-point)))))
872 ;; Handle non-empty blank line at the end of buffer.
874 (org-test-with-temp-text "[fn:1] Definition\n "
875 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
878 ;;;; Footnotes Reference.
880 (ert-deftest test-org-element
/footnote-reference-parser
()
881 "Test `footnote-reference' parser."
882 ;; Parse a standard reference.
884 (org-test-with-temp-text "Text[fn:label]"
886 (org-element-parse-buffer) 'footnote-reference
'identity
)))
887 ;; Parse a normalized reference.
889 (org-test-with-temp-text "Text[1]"
891 (org-element-parse-buffer) 'footnote-reference
'identity
)))
892 ;; Parse an inline reference.
894 (org-test-with-temp-text "Text[fn:test:def]"
896 (org-element-parse-buffer) 'footnote-reference
'identity
)))
897 ;; Parse an anonymous reference.
899 (org-test-with-temp-text "Text[fn::def]"
901 (org-element-parse-buffer) 'footnote-reference
'identity
)))
902 ;; Parse nested footnotes.
906 (org-test-with-temp-text "Text[fn::def [fn:label]]"
908 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
909 ;; Parse adjacent footnotes.
911 (org-test-with-temp-text "Text[fn:label1][fn:label2]"
915 (org-element-parse-buffer) 'footnote-reference
'identity
)))))
916 ;; Only properly closed footnotes are recognized as such.
918 (org-test-with-temp-text "Text[fn:label"
920 (org-element-parse-buffer) 'footnote-reference
'identity
))))
925 (ert-deftest test-org-element
/headline-comment-keyword
()
926 "Test COMMENT keyword recognition."
928 (org-test-with-temp-text "* Headline"
929 (let ((org-comment-string "COMMENT"))
930 (should-not (org-element-property :commentedp
(org-element-at-point)))))
931 ;; Standard position.
932 (org-test-with-temp-text "* COMMENT Headline"
933 (let ((org-comment-string "COMMENT")
934 (headline (org-element-at-point)))
935 (should (org-element-property :commentedp headline
))
936 (should (equal (org-element-property :raw-value headline
) "Headline"))))
938 (org-test-with-temp-text "* COMMENT Headline"
939 (let* ((org-comment-string "Comment")
940 (headline (org-element-at-point)))
941 (should-not (org-element-property :commentedp headline
))
942 (should (equal (org-element-property :raw-value headline
)
943 "COMMENT Headline"))))
944 ;; With another keyword.
945 (org-test-with-temp-text "* TODO COMMENT Headline"
946 (let* ((org-comment-string "COMMENT")
947 (org-todo-keywords '((sequence "TODO" "DONE")))
948 (headline (org-element-at-point)))
949 (should (org-element-property :commentedp headline
))
950 (should (equal (org-element-property :raw-value headline
) "Headline"))))
951 ;; With the keyword only.
952 (org-test-with-temp-text "* COMMENT"
953 (let* ((org-comment-string "COMMENT")
954 (headline (org-element-at-point)))
955 (should (org-element-property :commentedp headline
))
956 (should (equal (org-element-property :raw-value headline
) "")))))
958 (ert-deftest test-org-element
/headline-archive-tag
()
959 "Test ARCHIVE tag recognition."
962 (org-test-with-temp-text "* Headline"
963 (let ((org-archive-tag "ARCHIVE"))
964 (org-element-property :archivedp
(org-element-at-point)))))
966 (org-test-with-temp-text "* Headline :ARCHIVE:"
967 (let ((org-archive-tag "ARCHIVE"))
968 (let ((headline (org-element-at-point)))
969 (should (org-element-property :archivedp headline
))
971 (should-not (org-element-property :tags headline
)))))
973 (org-test-with-temp-text "* Headline :test:ARCHIVE:"
974 (let ((org-archive-tag "ARCHIVE"))
975 (let ((headline (org-element-at-point)))
976 (should (org-element-property :archivedp headline
))
978 (should (equal (org-element-property :tags headline
) '("test"))))))
979 ;; Tag is case-sensitive.
981 (org-test-with-temp-text "* Headline :ARCHIVE:"
982 (let ((org-archive-tag "Archive"))
983 (org-element-property :archivedp
(org-element-at-point))))))
985 (ert-deftest test-org-element
/headline-properties
()
986 "Test properties from property drawer."
987 ;; All properties from property drawer have their symbol upper
990 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
991 (org-element-property :FOO
(org-element-at-point))))
993 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
994 (org-element-property :foo
(org-element-at-point))))
995 ;; Also parse properties associated in inlinetasks.
996 (when (featurep 'org-inlinetask
)
998 (org-test-with-temp-text "*************** Inlinetask
1002 *************** END"
1003 (org-element-property :FOO
(org-element-at-point)))))
1004 ;; Do not find property drawer in a verbatim area.
1006 (org-test-with-temp-text
1013 (org-element-property :FOO
(org-element-at-point))))
1014 ;; Do not use properties from a drawer associated to an inlinetask.
1015 (when (featurep 'org-inlinetask
)
1017 (org-test-with-temp-text
1019 *************** Inlinetask
1023 *************** END"
1024 (org-element-property
1025 :FOO
(let ((org-inlinetask-min-level 15)) (org-element-at-point))))))
1026 ;; Do not find incomplete drawers.
1028 (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar"
1029 (org-element-property :FOO
(org-element-at-point)))))
1032 ;;;; Horizontal Rule
1034 (ert-deftest test-org-element
/horizontal-rule-parser
()
1035 "Test `horizontal-rule' parser."
1038 (org-test-with-temp-text "-----"
1039 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1042 (org-test-with-temp-text " -----"
1043 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1044 ;; Hyphen must be alone on the line.
1046 (org-test-with-temp-text "-----wrong"
1047 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1048 ;; 4 hyphens is too small.
1050 (org-test-with-temp-text "----"
1051 (org-element-map (org-element-parse-buffer) 'horizontal-rule
'identity
)))
1052 ;; Handle non-empty blank line at the end of buffer.
1054 (org-test-with-temp-text "-----\n "
1055 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1058 ;;;; Inline Babel Call
1060 (ert-deftest test-org-element
/inline-babel-call-parser
()
1061 "Test `inline-babel-call' parser."
1063 (org-test-with-temp-text "call_test()"
1065 (org-element-parse-buffer) 'inline-babel-call
'identity
))))
1068 ;;;; Inline Src Block
1070 (ert-deftest test-org-element
/inline-src-block-parser
()
1071 "Test `inline-src-block' parser."
1073 (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1074 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1077 (org-test-with-temp-text "src_emacs-lisp[:foo bar]{(+ 1 1)}"
1078 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1080 (org-test-with-temp-text "src_emacs-lisp[ :foo bar]{(+ 1 1)}"
1081 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1084 (org-test-with-temp-text "src_emacs-lisp[]{(+ 1 1)}"
1085 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1088 (org-test-with-temp-text "foosrc_emacs-lisp[]{(+ 1 1)}"
1089 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1091 (org-test-with-temp-text "src_emacs-lisp[]foo{(+ 1 1)}"
1092 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1093 ;; Invalid language name
1095 (org-test-with-temp-text "src_emacs-\tlisp{(+ 1 1)}"
1096 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
)))
1097 ;; Test parsing at the beginning of an item.
1099 (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1100 (org-element-map (org-element-parse-buffer) 'inline-src-block
'identity
))))
1105 (ert-deftest test-org-element
/inlinetask-parser
()
1106 "Test `inlinetask' parser."
1107 (when (featurep 'org-inlinetask
)
1108 (let ((org-inlinetask-min-level 15))
1109 ;; Regular inlinetask.
1112 (org-test-with-temp-text
1113 "*************** Task\nTest\n*************** END"
1114 (org-element-type (org-element-at-point)))))
1115 ;; Degenerate inlinetask.
1118 (org-test-with-temp-text "*************** Task"
1119 (org-element-type (org-element-at-point)))))
1120 ;; Mixed inlinetasks.
1122 (org-test-with-temp-text
1124 *************** Task
1125 *************** Task2
1127 *************** END"
1129 (goto-char (org-element-property :end
(org-element-at-point)))
1135 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1136 (org-test-with-temp-text "*************** TODO Task"
1137 (org-element-property :todo-keyword
(org-element-at-point))))))
1140 (org-test-with-temp-text "
1141 *************** Task
1142 DEADLINE: <2012-03-29 thu.>
1143 *************** END"
1145 (org-element-property :deadline
(org-element-at-point))))
1147 (org-test-with-temp-text "
1148 *************** Task
1149 DEADLINE: <2012-03-29 thu.>"
1151 (org-element-property :deadline
(org-element-at-point))))
1156 (org-test-with-temp-text "
1157 *************** [#A] Task"
1159 (org-element-property :priority
(org-element-at-point)))))
1164 (org-test-with-temp-text "
1165 *************** Task :test:"
1167 (org-element-property :tags
(org-element-at-point)))))
1168 ;; Regular properties are accessed through upper case keywords.
1170 (org-test-with-temp-text "
1171 *************** Task
1175 *************** END"
1177 (org-element-property :FOO
(org-element-at-point))))
1179 (org-test-with-temp-text "
1180 *************** Task
1184 *************** END"
1186 (org-element-property :foo
(org-element-at-point))))
1187 ;; Handle non-empty blank line at the end of buffer.
1189 (org-test-with-temp-text "*************** Task\n*************** END\n "
1190 (= (org-element-property :end
(org-element-at-point)) (point-max)))))))
1195 (ert-deftest test-org-element
/italic-parser
()
1196 "Test `italic' parser."
1199 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1200 (org-test-with-temp-text "/italic/"
1201 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1202 ;; Multi-line markup.
1205 (org-element-contents
1206 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1207 (org-test-with-temp-text "/first line\nsecond line/"
1208 (org-element-map (org-element-parse-buffer) 'italic
'identity nil t
))))
1209 '("first line\nsecond line"))))
1214 (ert-deftest test-org-element
/item-parser
()
1215 "Test `item' parser."
1218 (org-test-with-temp-text "- item"
1219 (org-element-map (org-element-parse-buffer) 'item
'identity
)))
1223 (org-element-property
1225 (org-test-with-temp-text "6. [@6] item"
1226 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1231 (org-element-property
1233 (org-test-with-temp-text "- tag :: description"
1234 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
)))))
1235 ;; No tags in ordered lists.
1237 (org-element-property
1239 (org-test-with-temp-text "1. tag :: description"
1240 (org-element-map (org-element-parse-buffer) 'item
'identity nil t
))))
1245 (org-test-with-temp-text "
1250 (org-element-parse-buffer) 'item
1251 (lambda (item) (org-element-property :checkbox item
))))))
1252 ;; Item starting with special syntax.
1254 (equal '(("- item"))
1255 (org-test-with-temp-text "- - item"
1256 (org-element-map (org-element-parse-buffer) 'paragraph
1257 'org-element-contents
))))
1258 ;; Block in an item: ignore indentation within the block.
1260 (org-test-with-temp-text "- item\n #+begin_src emacs-lisp\n(+ 1 1)\n #+end_src"
1262 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1267 (ert-deftest test-org-element
/keyword-parser
()
1268 "Test `keyword' parser."
1271 (org-test-with-temp-text "#+KEYWORD: value"
1272 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1273 ;; Keywords are case-insensitive.
1275 (org-test-with-temp-text "#+keyword: value"
1276 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1277 ;; Affiliated keywords are not keywords.
1279 (org-test-with-temp-text "#+NAME: value
1281 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1282 ;; Do not mix keywords with Babel calls and dynamic blocks.
1284 (org-test-with-temp-text "#+CALL: fun()"
1285 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1287 (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1288 (org-element-map (org-element-parse-buffer) 'keyword
'identity
)))
1289 ;; Handle non-empty blank line at the end of buffer.
1291 (org-test-with-temp-text "#+KEYWORD: value\n "
1292 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1295 ;;;; Latex Environment
1297 (ert-deftest test-org-element
/latex-environment-parser
()
1298 "Test `latex-environment' parser."
1300 (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1301 (org-element-map (org-element-parse-buffer) 'latex-environment
'identity
)))
1302 ;; Allow nested environments.
1310 (org-test-with-temp-text "
1316 (org-element-property
1319 (org-element-parse-buffer) 'latex-environment
'identity nil t
)))))
1320 ;; Allow environments with options and arguments.
1322 (eq 'latex-environment
1323 (org-test-with-temp-text
1324 "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1325 (org-element-type (org-element-at-point)))))
1327 (eq 'latex-environment
1328 (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1329 (org-element-type (org-element-at-point)))))
1330 ;; Allow environments without newline after \begin{.}.
1332 (eq 'latex-environment
1333 (org-test-with-temp-text "\\begin{env}{arg}something\nvalue\n\\end{env}"
1334 (org-element-type (org-element-at-point)))))
1335 ;; Allow one-line environments.
1337 (eq 'latex-environment
1338 (org-test-with-temp-text "\\begin{env}{arg}something\\end{env}"
1339 (org-element-type (org-element-at-point)))))
1340 ;; Should not allow different tags.
1342 (eq 'latex-environment
1343 (org-test-with-temp-text "\\begin{env*}{arg}something\\end{env}"
1344 (org-element-type (org-element-at-point)))))
1345 ;; LaTeX environments must be on separate lines.
1347 (eq 'latex-environment
1348 (org-test-with-temp-text "\\begin{env} x \\end{env} y"
1349 (org-element-type (org-element-at-point)))))
1351 (eq 'latex-environment
1352 (org-test-with-temp-text "y \\begin{env} x<point> \\end{env}"
1353 (org-element-type (org-element-at-point)))))
1354 ;; Handle non-empty blank line at the end of buffer.
1356 (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1357 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1362 (ert-deftest test-org-element
/latex-fragment-parser
()
1363 "Test `latex-fragment' parser."
1365 (org-test-with-temp-text "$a$"
1366 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1368 (org-test-with-temp-text "$$a$$"
1369 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1371 (org-test-with-temp-text "\\(a\\)"
1372 (org-element-map (org-element-parse-buffer) 'latex-fragment
'identity
)))
1374 (org-test-with-temp-text "\\[a\\]"
1376 (org-element-parse-buffer) 'latex-fragment
'identity
)))
1377 ;; Test fragment at the beginning of an item.
1380 (org-test-with-temp-text "- $x$"
1381 (progn (search-forward "$")
1382 (org-element-type (org-element-context)))))))
1387 (ert-deftest test-org-element
/line-break-parser
()
1388 "Test `line-break' parser."
1391 (org-test-with-temp-text "Text \\\\"
1392 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1393 ;; Line break with trailing white spaces.
1395 (org-test-with-temp-text "Text \\\\ "
1396 (org-element-map (org-element-parse-buffer) 'line-break
'identity
)))
1397 ;; Three backslashes are too much.
1399 (org-test-with-temp-text "Text \\\\\\"
1400 (org-element-map (org-element-parse-buffer) 'line-break
'identity
))))
1405 (ert-deftest test-org-element
/link-parser
()
1406 "Test `link' parser."
1411 (org-test-with-temp-text "<<<radio>>>A radio link"
1412 (org-update-radio-target-regexp)
1413 (org-element-property
1415 (org-element-map (org-element-parse-buffer) 'link
#'identity nil t
)))))
1418 ;; ... with description.
1422 (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1423 (org-element-contents
1424 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1425 ;; ... without description.
1429 (org-test-with-temp-text "[[http://orgmode.org]]"
1430 (org-element-property
1432 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1433 ;; ... with expansion.
1436 "//orgmode.org/worg"
1437 (org-test-with-temp-text "[[Org:worg]]"
1438 (let ((org-link-abbrev-alist '(("Org" .
"http://orgmode.org/"))))
1439 (org-element-property
1441 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))))))
1442 ;; ... with translation.
1446 (org-test-with-temp-text "[[http://orgmode.org]]"
1447 (flet ((link-translate (type path
) (cons type
"127.0.0.1")))
1448 (let ((org-link-translation-function 'link-translate
))
1449 (org-element-property
1451 (org-element-map (org-element-parse-buffer) 'link
1452 'identity nil t
)))))))
1457 (org-test-with-temp-text "[[id:aaaa]]"
1458 (org-element-property
1460 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1461 ;; ... custom-id link.
1465 (org-test-with-temp-text "[[#some-id]]"
1466 (org-element-property
1468 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1469 ;; ... coderef link.
1473 (org-test-with-temp-text "[[(reference)]]"
1474 (org-element-property
1476 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1481 (org-test-with-temp-text "[[target-or-title]]"
1482 (org-element-property
1484 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))))
1485 ;; ... file-type link with search option.
1488 '(("file" "projects.org" "*task title"))
1489 (org-test-with-temp-text "[[file:projects.org::*task title]]"
1490 (org-element-map (org-element-parse-buffer) 'link
1491 (lambda (l) (list (org-element-property :type l
)
1492 (org-element-property :path l
)
1493 (org-element-property :search-option l
)))))))
1494 ;; ... file-type link with application...
1495 (require 'org-docview
)
1498 '("file" "projects.org" "docview")
1499 (org-test-with-temp-text "[[docview:projects.org]]"
1500 (let ((l (org-element-context)))
1501 (list (org-element-property :type l
)
1502 (org-element-property :path l
)
1503 (org-element-property :application l
))))))
1504 ;; ... `:path' in a file-type link must be compatible with "file"
1505 ;; scheme in URI syntax, even if Org syntax isn't...
1507 (org-test-with-temp-text-in-file ""
1508 (let ((file (expand-file-name (buffer-file-name))))
1509 (insert (format "[[file://%s]]" file
))
1510 (equal (org-element-property :path
(org-element-context))
1511 (concat "//" file
)))))
1513 (org-test-with-temp-text-in-file ""
1514 (let ((file (expand-file-name (buffer-file-name))))
1515 (insert (format "[[file:%s]]" file
))
1516 (equal (org-element-property :path
(org-element-context))
1517 (concat "//" file
)))))
1519 (org-test-with-temp-text-in-file ""
1520 (let ((file (file-relative-name (buffer-file-name))))
1521 (insert (format "[[file:%s]]" file
))
1522 (list (org-element-property :path
(org-element-context)) file
))))
1523 ;; ... multi-line link.
1525 (equal "//orgmode.org"
1526 (org-test-with-temp-text "[[http://orgmode.\norg]]"
1527 (org-element-property :path
(org-element-context)))))
1530 (org-test-with-temp-text "A link: http://orgmode.org"
1531 (org-element-map (org-element-parse-buffer) 'link
'identity
)))
1534 (org-test-with-temp-text "A link: <http://orgmode.org>"
1535 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
)))
1536 ;; Link abbreviation.
1539 (org-test-with-temp-text
1540 "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1541 (progn (org-mode-restart)
1542 (goto-char (1- (point-max)))
1543 (org-element-property :type
(org-element-context))))))
1544 ;; Link abbreviation in a secondary string.
1547 (org-test-with-temp-text
1548 "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1549 (progn (org-mode-restart)
1550 (org-element-map (org-element-parse-buffer) 'link
1551 (lambda (link) (org-element-property :type link
))
1553 ;; Plain links are allowed as description of regular links.
1556 (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1557 (search-forward "file:")
1558 (org-element-property :type
(org-element-context))))))
1563 (ert-deftest test-org-element
/macro-parser
()
1564 "Test `macro' parser."
1565 ;; Without arguments.
1567 (org-test-with-temp-text "{{{macro}}}"
1568 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1571 (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1572 (org-element-map (org-element-parse-buffer) 'macro
'identity
)))
1573 ;; Properly handle protected commas in arguments...
1577 (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1578 (org-element-property :args
(org-element-context))))))
1579 ;; ... even when last argument ends with a protected comma.
1582 (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1583 (org-element-property :args
(org-element-context)))))
1584 ;; Allow to escape escaping character.
1587 (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1588 (org-element-property :args
(org-element-context)))))
1589 ;; No need to escape backslashes elsewhere.
1592 (org-test-with-temp-text "{{{macro(\\)}}}"
1593 (org-element-property :args
(org-element-context))))))
1598 (ert-deftest test-org-element
/node-property
()
1599 "Test `node-property' parser."
1602 (equal '("abc" "value")
1603 (org-test-with-temp-text "* H\n:PROPERTIES:\n<point>:abc: value\n:END:"
1604 (let ((element (org-element-at-point)))
1605 (list (org-element-property :key element
)
1606 (org-element-property :value element
))))))
1607 ;; Value should be trimmed.
1610 (org-test-with-temp-text
1611 "* H\n:PROPERTIES:\n<point>:abc: value \n:END:"
1612 (org-element-property :value
(org-element-at-point)))))
1613 ;; A node property requires to be wrapped within a property drawer.
1616 (org-test-with-temp-text ":abc: value"
1617 (org-element-type (org-element-at-point)))))
1618 ;; Accept empty properties.
1620 (equal '(("foo" "value") ("bar" ""))
1621 (org-test-with-temp-text "* H\n:PROPERTIES:\n:foo: value\n:bar:\n:END:"
1622 (org-element-map (org-element-parse-buffer) 'node-property
1624 (list (org-element-property :key p
)
1625 (org-element-property :value p
))))))))
1630 (ert-deftest test-org-element
/paragraph-parser
()
1631 "Test `paragraph' parser."
1634 (org-test-with-temp-text "Paragraph"
1635 (org-element-map (org-element-parse-buffer) 'paragraph
'identity nil t
)))
1636 ;; Property find end of a paragraph stuck to another element.
1639 (org-test-with-temp-text "Paragraph\n# Comment"
1640 (org-element-map (org-element-parse-buffer) 'paragraph
1641 (lambda (p) (char-after (org-element-property :end p
)))
1643 ;; Include ill-formed Keywords.
1645 (org-test-with-temp-text "#+wrong_keyword something"
1646 (org-element-map (org-element-parse-buffer) 'paragraph
'identity
)))
1647 ;; Include incomplete-drawers.
1649 (org-test-with-temp-text ":TEST:\nParagraph"
1650 (let ((elem (org-element-at-point)))
1651 (and (eq (org-element-type elem
) 'paragraph
)
1652 (= (point-max) (org-element-property :end elem
))))))
1653 ;; Include incomplete blocks.
1655 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1656 (let ((elem (org-element-at-point)))
1657 (and (eq (org-element-type elem
) 'paragraph
)
1658 (= (point-max) (org-element-property :end elem
))))))
1659 ;; Include incomplete dynamic blocks.
1661 (org-test-with-temp-text "#+BEGIN: \nParagraph"
1662 (let ((elem (org-element-at-point)))
1663 (and (eq (org-element-type elem
) 'paragraph
)
1664 (= (point-max) (org-element-property :end elem
))))))
1665 ;; Include incomplete latex environments.
1667 (org-test-with-temp-text "\begin{equation}\nParagraph"
1668 (let ((elem (org-element-at-point)))
1669 (and (eq (org-element-type elem
) 'paragraph
)
1670 (= (point-max) (org-element-property :end elem
))))))
1671 ;; Do not steal affiliated keywords from container.
1673 (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1674 (let ((elem (progn (search-forward "item") (org-element-at-point))))
1675 (and (eq (org-element-type elem
) 'paragraph
)
1676 (not (org-element-property :attr_latex elem
))
1677 (/= (org-element-property :begin elem
) 1)))))
1678 ;; Handle non-empty blank line at the end of buffer.
1680 (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
1681 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1686 (ert-deftest test-org-element
/plain-list-parser
()
1687 "Test `plain-list' parser."
1688 (org-test-with-temp-text "- item"
1689 (should (org-element-map (org-element-parse-buffer) 'plain-list
'identity
)))
1690 ;; Blank lines after the list only belong to outer plain list.
1694 (org-test-with-temp-text "
1699 (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1700 (lambda (pl) (org-element-property :end pl
)))))
1702 ;; Move to ending of outer list.
1703 (progn (goto-char (car endings
)) (looking-at "Outside list"))
1704 ;; Move to ending of inner list.
1705 (progn (goto-char (nth 1 endings
)) (looking-at "^$")))))))
1706 ;; Correctly compute end of list if it doesn't end at a line
1709 (org-test-with-temp-text "- list\n \n "
1710 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1715 (ert-deftest test-org-element
/planning-parser
()
1716 "Test `planning' parser."
1717 ;; Test various keywords.
1719 (org-element-property
1721 (org-test-with-temp-text "* H\n<point>CLOSED: [2012-03-29 thu.]"
1722 (org-element-at-point))))
1724 (org-element-property
1726 (org-test-with-temp-text "* H\n<point>DEADLINE: <2012-03-29 thu.>"
1727 (org-element-at-point))))
1729 (org-element-property
1731 (org-test-with-temp-text "* H\n<point>SCHEDULED: <2012-03-29 thu.>"
1732 (org-element-at-point))))
1733 ;; Planning line only exists right after a headline.
1736 (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1737 (org-element-type (org-element-at-point)))))
1740 (org-test-with-temp-text
1741 "* H\n# Comment\n<point>DEADLINE: <2012-03-29 thu.>"
1742 (org-element-type (org-element-at-point))))))
1745 ;;;; Property Drawer
1747 (ert-deftest test-org-element
/property-drawer-parser
()
1748 "Test `property-drawer' parser."
1751 (eq 'property-drawer
1752 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value\n:END:"
1753 (org-element-type (org-element-at-point)))))
1755 (eq 'property-drawer
1756 (org-test-with-temp-text
1757 "* H\nDEADLINE: <2014-03-04 tue.>\n<point>:PROPERTIES:\n:prop: value\n:END:"
1758 (org-element-type (org-element-at-point)))))
1759 ;; Allow properties without value and no property at all.
1761 (eq 'property-drawer
1762 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop:\n:END:"
1763 (org-element-type (org-element-at-point)))))
1765 (eq 'property-drawer
1766 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:"
1767 (org-element-type (org-element-at-point)))))
1768 ;; Ignore incomplete drawer, drawer at a wrong location or with
1771 (eq 'property-drawer
1772 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value"
1773 (org-element-type (org-element-at-point)))))
1775 (eq 'property-drawer
1776 (org-test-with-temp-text
1777 "* H\nParagraph\n<point>:PROPERTIES:\n:prop: value\n:END:"
1778 (org-element-type (org-element-at-point)))))
1780 (eq 'property-drawer
1781 (org-test-with-temp-text
1782 "* H\nParagraph\n<point>:PROPERTIES:\nparagraph\n:END:"
1783 (org-element-type (org-element-at-point)))))
1784 ;; Handle non-empty blank line at the end of buffer.
1786 (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:\n "
1787 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1792 (ert-deftest test-org-element
/quote-block-parser
()
1793 "Test `quote-block' parser."
1796 (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1797 (org-element-map (org-element-parse-buffer) 'quote-block
'identity
)))
1798 ;; Ignore incomplete block.
1800 (org-test-with-temp-text "#+BEGIN_QUOTE"
1801 (org-element-map (org-element-parse-buffer) 'quote-block
'identity nil t
)))
1802 ;; Handle non-empty blank line at the end of buffer.
1804 (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n "
1805 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1810 (ert-deftest test-org-element
/radio-target-parser
()
1811 "Test `radio-target' parser."
1815 (org-test-with-temp-text "<<<radio>>>"
1816 (org-element-type (org-element-context)))))
1817 ;; Radio targets with objects.
1820 (org-test-with-temp-text "<<<radio \\alpha>>>"
1821 (org-element-type (org-element-context)))))
1822 ;; Radio targets starting with an object.
1825 (org-test-with-temp-text "<<<\\alpha radio>>>"
1826 (org-element-type (org-element-context)))))
1827 ;; Radio targets cannot begin or end with white space.
1830 (org-test-with-temp-text "<<< radio>>>"
1831 (org-element-type (org-element-context)))))
1834 (org-test-with-temp-text "<<<radio >>>"
1835 (org-element-type (org-element-context))))))
1840 (ert-deftest test-org-element
/section-parser
()
1841 "Test `section' parser."
1844 (org-test-with-temp-text "* Headline\nText"
1845 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1846 ;; There's a section before the first headline.
1848 (org-test-with-temp-text "Text"
1849 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1850 ;; A section cannot be empty.
1852 (org-test-with-temp-text "* Headline 1\n* Headline 2"
1853 (org-element-map (org-element-parse-buffer) 'section
'identity
)))
1854 ;; A section doesn't contain sub-trees.
1856 (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1858 (org-element-map (org-element-parse-buffer) 'section
'identity nil t
)
1859 'headline
'identity
))))
1864 (ert-deftest test-org-element
/special-block-parser
()
1865 "Test `special-block' parser."
1869 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1870 (org-element-property :type
(org-element-at-point)))))
1871 ;; Special blocks are case sensitive.
1874 (org-test-with-temp-text "#+BEGIN_CaSe\nText\n#+END_CaSe"
1875 (org-element-property :type
(org-element-at-point)))))
1876 ;; Special blocks can contain paragraphs.
1879 (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1881 (org-element-type (org-element-at-point)))))
1882 ;; Ignore incomplete block.
1885 (org-test-with-temp-text "#+BEGIN_SPECIAL"
1886 (org-element-type (org-element-at-point)))))
1887 ;; Allow special characters in type.
1889 (equal '(special-block "SPECIAL*")
1890 (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1891 (let ((element (org-element-at-point)))
1892 (list (org-element-type element
)
1893 (org-element-property :type element
))))))
1894 ;; Handle non-empty blank line at the end of buffer.
1896 (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1897 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1902 (ert-deftest test-org-element
/src-block-parser
()
1903 "Test `src-block' parser."
1906 (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1907 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1908 ;; Ignore incomplete block.
1910 (org-test-with-temp-text "#+BEGIN_SRC"
1911 (org-element-map (org-element-parse-buffer) 'src-block
'identity
)))
1912 ;; Properly un-escape code.
1914 (equal "* Headline\n #+keyword\nText\n"
1915 (org-test-with-temp-text
1916 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1917 (org-element-property :value
(org-element-at-point)))))
1918 ;; Remove block indentation according to block boundaries, unless
1919 ;; block contents are less indented than block boundaries.
1922 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1923 (let ((org-src-preserve-indentation t
))
1924 (org-element-property :value
(org-element-at-point))))))
1928 (org-test-with-temp-text " #+BEGIN_SRC org\n L1\n L2\n #+END_SRC"
1929 (let ((org-src-preserve-indentation t
))
1930 (org-element-property :value
(org-element-at-point))))))
1931 ;; Handle non-empty blank line at the end of buffer.
1933 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
1934 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
1937 ;;;; Statistics Cookie
1939 (ert-deftest test-org-element
/statistics-cookie
()
1940 "Test `statistics-cookie' parser."
1943 (org-test-with-temp-text "[1/2]"
1944 (org-element-map (org-element-parse-buffer) 'statistics-cookie
'identity
)))
1947 (org-test-with-temp-text "[33%]"
1949 (org-element-parse-buffer) 'statistics-cookie
'identity
))))
1954 (ert-deftest test-org-element
/strike-through-parser
()
1955 "Test `strike-through' parser."
1958 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1959 (org-test-with-temp-text "+strike-through+"
1960 (org-element-map (org-element-parse-buffer) 'strike-through
'identity
))))
1961 ;; Multi-line markup.
1964 (org-element-contents
1965 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
1966 (org-test-with-temp-text "+first line\nsecond line+"
1968 (org-element-parse-buffer) 'strike-through
'identity nil t
))))
1969 '("first line\nsecond line"))))
1974 (ert-deftest test-org-element
/subscript-parser
()
1975 "Test `subscript' parser."
1978 (org-test-with-temp-text "a_b"
1979 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1982 (org-test-with-temp-text "a_{b}"
1983 (org-element-map (org-element-parse-buffer) 'subscript
'identity
)))
1984 ;; Multiple subscripts in a paragraph.
1987 (org-test-with-temp-text "a_b and c_d"
1989 (org-element-map (org-element-parse-buffer) 'subscript
'identity
))))))
1994 (ert-deftest test-org-element
/superscript-parser
()
1995 "Test `superscript' parser."
1998 (org-test-with-temp-text "a^b"
1999 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2002 (org-test-with-temp-text "a^{b}"
2003 (org-element-map (org-element-parse-buffer) 'superscript
'identity
)))
2004 ;; Multiple superscript in a paragraph.
2007 (org-test-with-temp-text "a^b and c^d"
2010 (org-element-parse-buffer) 'superscript
'identity
))))))
2015 (ert-deftest test-org-element
/table-parser
()
2016 "Test `table' parser."
2018 (org-test-with-temp-text "| a |"
2019 (org-element-map (org-element-parse-buffer) 'table
'identity
)))
2020 ;; TBLFM keyword is case insensitive.
2022 (org-test-with-temp-text "| a |\n#+tblfm: test"
2023 (org-element-property
2025 (org-element-map (org-element-parse-buffer) 'table
'identity nil t
))))
2026 ;; Handle multiple TBLFM lines.
2029 (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
2030 (length (org-element-property
2033 (org-element-parse-buffer) 'table
'identity nil t
))))))
2034 ;; Handle non-empty blank line at the end of buffer.
2036 (org-test-with-temp-text "| a |\n "
2037 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2042 (ert-deftest test-org-element
/table-cell-parser
()
2043 "Test `table-cell' parser."
2044 ;; Regular table cell.
2046 (org-test-with-temp-text "| a |"
2047 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
)))
2048 ;; Last vertical bar may be omitted.
2050 (org-test-with-temp-text "| a "
2051 (org-element-map (org-element-parse-buffer) 'table-cell
'identity
))))
2056 (ert-deftest test-org-element
/table-row-parser
()
2057 "Test `table-row' parser."
2059 (equal '(standard rule
)
2060 (org-test-with-temp-text "| a |\n|---|"
2062 (org-element-parse-buffer) 'table-row
2063 (lambda (row) (org-element-property :type row
)))))))
2068 (ert-deftest test-org-element
/target-parser
()
2069 "Test `target' parser."
2071 (org-test-with-temp-text "<<target>>"
2072 (org-element-map (org-element-parse-buffer) 'target
'identity
))))
2077 (ert-deftest test-org-element
/timestamp
()
2078 "Test `timestamp' parser."
2079 ;; Active timestamp.
2081 (org-test-with-temp-text "<2012-03-29 16:40>"
2082 (eq (org-element-property :type
(org-element-context)) 'active
)))
2084 (org-test-with-temp-text "<2012-03-29 Thu>"
2085 (let ((timestamp (org-element-context)))
2086 (or (org-element-property :hour-start timestamp
)
2087 (org-element-property :minute-start timestamp
)))))
2089 (equal '(2012 3 29 16 40)
2090 (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
2091 (let ((object (org-element-context)))
2092 (list (org-element-property :year-start object
)
2093 (org-element-property :month-start object
)
2094 (org-element-property :day-start object
)
2095 (org-element-property :hour-start object
)
2096 (org-element-property :minute-start object
))))))
2097 ;; Inactive timestamp.
2099 (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
2100 (eq (org-element-property :type
(org-element-context)) 'inactive
)))
2103 (equal '(2012 3 29 16 40 7 30)
2104 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2105 (let ((object (org-element-context)))
2106 (list (org-element-property :year-end object
)
2107 (org-element-property :month-end object
)
2108 (org-element-property :day-end object
)
2109 (org-element-property :hour-end object
)
2110 (org-element-property :minute-end object
)
2111 (org-element-property :hour-start object
)
2112 (org-element-property :minute-start object
))))))
2115 (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2116 (org-element-property :type
(org-element-context)))))
2119 (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
2120 (eq (org-element-property :type
(org-element-context)) 'inactive-range
)))
2122 (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
2123 (let ((timestamp (org-element-context)))
2124 (or (org-element-property :hour-end timestamp
)
2125 (org-element-property :minute-end timestamp
)))))
2126 ;; With repeater, warning delay and both.
2129 (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
2130 (org-element-property :repeater-type
(org-element-context)))))
2133 (org-test-with-temp-text "<2012-03-29 Thu --1y>"
2134 (org-element-property :warning-type
(org-element-context)))))
2136 (equal '(cumulate all
)
2137 (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
2138 (let ((ts (org-element-context)))
2139 (list (org-element-property :repeater-type ts
)
2140 (org-element-property :warning-type ts
)))))))
2145 (ert-deftest test-org-element
/underline-parser
()
2146 "Test `underline' parser."
2149 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2150 (org-test-with-temp-text "_underline_"
2151 (org-element-map (org-element-parse-buffer) 'underline
'identity
))))
2152 ;; Multi-line markup.
2155 (org-element-contents
2156 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2157 (org-test-with-temp-text "_first line\nsecond line_"
2159 (org-element-parse-buffer) 'underline
'identity nil t
))))
2160 '("first line\nsecond line"))))
2165 (ert-deftest test-org-element
/verbatim-parser
()
2166 "Test `verbatim' parser."
2169 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2170 (org-test-with-temp-text "=verbatim="
2171 (org-element-map (org-element-parse-buffer) 'verbatim
'identity
))))
2172 ;; Multi-line markup.
2175 (org-element-property
2177 (let ((org-emph-re "\\([ ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^
\n,\"']\\|[^
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^
\n,\"']\\)\\3\\)\\([- .,:!?;'\")}\\]\\|$\\)"))
2178 (org-test-with-temp-text "=first line\nsecond line="
2180 (org-element-parse-buffer) 'verbatim
'identity nil t
))))
2181 "first line\nsecond line")))
2186 (ert-deftest test-org-element
/verse-block-parser
()
2187 "Test `verse-block' parser."
2190 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2191 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2194 (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2195 (org-element-map (org-element-parse-buffer) 'verse-block
'identity
)))
2196 ;; Parse objects in verse blocks.
2198 (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2199 (org-element-map (org-element-parse-buffer) 'entity
'identity
)))
2200 ;; Ignore incomplete verse block.
2202 (org-test-with-temp-text "#+BEGIN_VERSE"
2203 (org-element-map (org-element-parse-buffer) 'verse-block
'identity nil t
)))
2204 ;; Handle non-empty blank line at the end of buffer.
2206 (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2207 (= (org-element-property :end
(org-element-at-point)) (point-max)))))
2211 ;;; Test Interpreters.
2213 (ert-deftest test-org-element
/interpret-data
()
2214 "Test `org-element-interpret-data' specifications."
2215 ;; Interpret simple affiliated keywords.
2218 (org-element-interpret-data
2219 '(org-data nil
(paragraph (:name
"para") "Paragraph")))
2220 "#+NAME: para\nParagraph\n"))
2221 ;; Interpret multiple affiliated keywords.
2224 (org-element-interpret-data
2225 '(org-data nil
(paragraph (:attr_ascii
("line2" "line1")) "Paragraph")))
2226 "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2227 ;; Interpret parsed affiliated keywords.
2230 (org-element-interpret-data
2231 '(org-data nil
(paragraph (:caption
(("caption"))) "Paragraph")))
2232 "#+CAPTION: caption\nParagraph\n"))
2233 ;; Interpret dual affiliated keywords.
2236 (org-element-interpret-data
2237 '(org-data nil
(paragraph (:caption
((("long") "short"))) "Paragraph")))
2238 "#+CAPTION[short]: long\nParagraph\n"))
2239 ;; Interpret multiple parsed dual keywords.
2242 (org-element-interpret-data
2243 '(org-data nil
(paragraph
2244 (:caption
((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2245 "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2246 ;; Pseudo objects and elements are transparent.
2249 (org-element-interpret-data
2250 '(paragraph nil
(pseudo-object (:post-blank
1) "A") "B")
2254 (org-element-interpret-data
2256 (pseudo-element (:post-blank
1) (paragraph nil
"A"))
2257 (paragraph nil
"B"))))))
2259 (ert-deftest test-org-element
/center-block-interpreter
()
2260 "Test center block interpreter."
2262 (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2263 "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2265 (ert-deftest test-org-element
/drawer-interpreter
()
2266 "Test drawer interpreter."
2268 (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2269 ":TEST:\nTest\n:END:\n")))
2271 (ert-deftest test-org-element
/dynamic-block-interpreter
()
2272 "Test dynamic block interpreter."
2274 (equal (org-test-parse-and-interpret
2275 "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2276 "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2278 (ert-deftest test-org-element
/footnote-definition-interpreter
()
2279 "Test footnote definition interpreter."
2280 (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2282 (ert-deftest test-org-element
/headline-interpreter
()
2283 "Test headline and section interpreters."
2284 ;; 1. Standard test.
2285 (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2286 ;; 2. With TODO keywords.
2288 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2289 (org-test-parse-and-interpret "* TODO Headline"))
2290 "* TODO Headline\n"))
2293 ;; 3.1. ... and a positive `org-tags-column' value.
2295 (equal (let ((org-tags-column 20))
2296 (org-test-parse-and-interpret "* Headline :tag:"))
2297 "* Headline :tag:\n"))
2298 ;; 3.2. ... and a negative `org-tags-column' value.
2300 (equal (let ((org-tags-column -
20))
2301 (org-test-parse-and-interpret "* Headline :tag:"))
2302 "* Headline :tag:\n"))
2303 ;; 3.3. ... and a null `org-tags-column' value.
2305 (equal (let ((org-tags-column 0))
2306 (org-test-parse-and-interpret "* Headline :tag:"))
2307 "* Headline :tag:\n"))
2308 ;; 4. With priority cookie.
2310 (equal (org-test-parse-and-interpret "* [#B] Headline")
2311 "* [#B] Headline\n"))
2312 ;; 5. With comment keyword.
2314 (equal (let ((org-comment-string "COMMENT"))
2315 (org-test-parse-and-interpret "* COMMENT Headline"))
2316 "* COMMENT Headline\n"))
2317 ;; 6. Keep same number of blank lines before body.
2319 (equal (org-test-parse-and-interpret
2320 "* Headline\n\n\nText after two blank lines.")
2321 "* Headline\n\n\nText after two blank lines.\n"))
2322 ;; 8. Preserve `org-odd-levels-only' state.
2324 (equal "* H\n*** H2\n"
2325 (let ((org-odd-levels-only t
))
2326 (org-test-parse-and-interpret "* H\n*** H2")))))
2328 (ert-deftest test-org-element
/inlinetask-interpreter
()
2329 "Test inlinetask interpretation."
2330 (when (featurep 'org-inlinetask
)
2331 (let ((org-inlinetask-min-level 15))
2332 ;; 1. Regular inlinetask.
2333 (should (equal (org-test-parse-and-interpret
2334 "*************** Task\nTest\n*************** END")
2335 "*************** Task\nTest\n*************** END\n"))
2336 ;; 2. Degenerate inlinetask.
2337 (should (equal (org-test-parse-and-interpret "*************** Task")
2338 "*************** Task\n"))
2339 ;; 3. Prefer degenerate form when there are no contents.
2340 (should (equal (org-test-parse-and-interpret
2341 "*************** Task\n*************** END")
2342 "*************** Task\n"))
2343 ;; 4. With TODO keywords.
2345 (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2346 (org-test-parse-and-interpret "*************** TODO Task"))
2347 "*************** TODO Task\n"))
2350 ;; 5.1. ... and a positive `org-tags-column' value.
2352 (equal (let ((org-tags-column 30))
2353 (org-test-parse-and-interpret "*************** Task :tag:"))
2354 "*************** Task :tag:\n"))
2355 ;; 5.2. ... and a negative `org-tags-column' value.
2357 (equal (let ((org-tags-column -
30))
2358 (org-test-parse-and-interpret "*************** Task :tag:"))
2359 "*************** Task :tag:\n"))
2360 ;; 5.3. ... and a null `org-tags-column' value.
2362 (equal (let ((org-tags-column 0))
2363 (org-test-parse-and-interpret "*************** Task :tag:"))
2364 "*************** Task :tag:\n"))
2365 ;; 6. With priority cookie.
2367 (equal (org-test-parse-and-interpret "*************** [#B] Task")
2368 "*************** [#B] Task\n")))))
2370 (ert-deftest test-org-element
/plain-list-interpreter
()
2371 "Test plain-list and item interpreters."
2372 (let ((org-list-two-spaces-after-bullet-regexp nil
))
2374 (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2375 ;; Description list.
2377 (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2380 (equal (let ((org-plain-list-ordered-item-terminator t
))
2381 (org-test-parse-and-interpret "1. Item"))
2384 (equal (let ((org-plain-list-ordered-item-terminator ?\
)))
2385 (org-test-parse-and-interpret "1) Item"))
2387 ;; Ordered list with counter.
2389 (equal (let ((org-plain-list-ordered-item-terminator t
))
2390 (org-test-parse-and-interpret "1. [@5] Item"))
2392 ;; List with check-boxes.
2394 (equal (org-test-parse-and-interpret
2395 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3")
2396 "- [-] Item 1\n - [X] Item 2\n - [ ] Item 3\n"))
2397 ;; Item not starting with a paragraph.
2399 (equal (org-test-parse-and-interpret "-\n | a | b |")
2400 "- \n | a | b |\n"))
2401 ;; Special case: correctly handle "*" bullets.
2402 (should (org-test-parse-and-interpret " * item"))
2403 ;; Special case: correctly handle empty items.
2404 (should (org-test-parse-and-interpret "-"))))
2406 (ert-deftest test-org-element
/quote-block-interpreter
()
2407 "Test quote block interpreter."
2408 (should (equal (org-test-parse-and-interpret
2409 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2410 "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2412 (ert-deftest test-org-element
/special-block-interpreter
()
2413 "Test special block interpreter."
2414 (should (equal (org-test-parse-and-interpret
2415 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2416 "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2418 (ert-deftest test-org-element
/babel-call-interpreter
()
2419 "Test babel call interpreter."
2420 ;; 1. Without argument.
2421 (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2422 "#+CALL: test()\n"))
2423 ;; 2. With argument.
2424 (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2425 "#+CALL: test(x=2)\n"))
2426 ;; 3. With header arguments.
2427 (should (equal (org-test-parse-and-interpret
2428 "#+CALL: test[:results output]()[:results html]")
2429 "#+CALL: test[:results output]()[:results html]\n")))
2431 (ert-deftest test-org-element
/clock-interpreter
()
2432 "Test clock interpreter."
2436 "CLOCK: \\[2012-01-01 .* 00:01\\]"
2437 (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2441 "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] => 0:01"
2442 (org-test-parse-and-interpret "
2443 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] => 0:01"))))
2445 (ert-deftest test-org-element
/comment-interpreter
()
2446 "Test comment interpreter."
2448 (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2450 (should (equal (org-test-parse-and-interpret " # Comment")
2452 ;; Preserve indentation.
2453 (should (equal (org-test-parse-and-interpret " # No blank\n# One blank")
2454 "# No blank\n# One blank\n")))
2456 (ert-deftest test-org-element
/comment-block-interpreter
()
2457 "Test comment block interpreter."
2458 (should (equal (org-test-parse-and-interpret
2459 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2460 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"))
2461 ;; Accept missing final newline in value.
2464 "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"
2465 (org-element-interpret-data '(comment-block (:value
"Test"))))))
2467 (ert-deftest test-org-element
/diary-sexp
()
2468 "Test diary-sexp interpreter."
2471 (org-test-parse-and-interpret
2472 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old")
2473 "%%(org-anniversary 1956 5 14)(2) Arthur Dent is %d years old\n")))
2475 (ert-deftest test-org-element
/example-block-interpreter
()
2476 "Test example block interpreter."
2477 ;; Without switches.
2478 (should (equal (org-test-parse-and-interpret
2479 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2480 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2483 (equal (org-test-parse-and-interpret
2484 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2485 "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2486 ;; Preserve code escaping.
2488 (equal (org-test-parse-and-interpret
2489 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2490 "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n"))
2491 ;; Accept missing final newline in value.
2494 "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"
2495 (org-element-interpret-data '(example-block (:value
"Test"))))))
2497 (ert-deftest test-org-element
/export-block-interpreter
()
2498 "Test export block interpreter."
2499 (should (equal (org-test-parse-and-interpret
2500 "#+BEGIN_HTML\nTest\n#+END_HTML")
2501 "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2503 (ert-deftest test-org-element
/fixed-width-interpreter
()
2504 "Test fixed width interpreter."
2506 (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2507 ;; Preserve indentation.
2508 (should (equal (org-test-parse-and-interpret ": 2 blanks\n: 1 blank")
2509 ": 2 blanks\n: 1 blank\n"))
2510 ;; Remove last newline character
2512 (equal (org-element-fixed-width-interpreter
2513 '(fixed-width (:value
"Test\n")) nil
)
2516 (equal (org-element-fixed-width-interpreter
2517 '(fixed-width (:value
"Test")) nil
)
2519 ;; Handle empty string.
2521 (equal (org-element-fixed-width-interpreter
2522 '(fixed-width (:value
"")) nil
)
2524 ;; Handle nil value.
2526 (org-element-fixed-width-interpreter
2527 '(fixed-width (:value nil
)) nil
)))
2529 (ert-deftest test-org-element
/horizontal-rule-interpreter
()
2530 "Test horizontal rule interpreter."
2531 (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2533 (ert-deftest test-org-element
/keyword-interpreter
()
2534 "Test keyword interpreter."
2535 (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2536 "#+KEYWORD: value\n")))
2538 (ert-deftest test-org-element
/latex-environment-interpreter
()
2539 "Test latex environment interpreter."
2540 (should (equal (org-test-parse-and-interpret
2541 "\\begin{equation}\n1+1=2\n\\end{equation}")
2542 "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2543 (should (equal (org-test-parse-and-interpret
2544 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2545 "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2547 (ert-deftest test-org-element
/planning-interpreter
()
2548 "Test planning interpreter."
2552 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2553 (org-test-parse-and-interpret
2555 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2557 (ert-deftest test-org-element
/property-drawer-interpreter
()
2558 "Test property drawer interpreter."
2559 (should (equal (let ((org-property-format "%-10s %s"))
2560 (org-test-parse-and-interpret
2561 "* H\n:PROPERTIES:\n:prop: value\n:END:"))
2562 "* H\n:PROPERTIES:\n:prop: value\n:END:\n")))
2564 (ert-deftest test-org-element
/src-block-interpreter
()
2565 "Test src block interpreter."
2568 (equal (let ((org-edit-src-content-indentation 2)
2569 (org-src-preserve-indentation nil
))
2570 (org-test-parse-and-interpret
2571 "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2572 "#+BEGIN_SRC emacs-lisp :results silent\n (+ 1 1)\n#+END_SRC\n"))
2575 (equal (let ((org-edit-src-content-indentation 2)
2576 (org-src-preserve-indentation nil
))
2577 (org-test-parse-and-interpret
2578 "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2579 "#+BEGIN_SRC emacs-lisp -n -k\n (+ 1 1)\n#+END_SRC\n"))
2580 ;; Preserve code escaping.
2582 (equal (let ((org-edit-src-content-indentation 2)
2583 (org-src-preserve-indentation nil
))
2584 (org-test-parse-and-interpret
2585 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2586 "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2587 ;; Do not apply `org-edit-src-content-indentation' when preserving
2590 (equal (let ((org-edit-src-content-indentation 2)
2591 (org-src-preserve-indentation t
))
2592 (org-test-parse-and-interpret
2593 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2594 "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2596 (equal (let ((org-edit-src-content-indentation 2)
2597 (org-src-preserve-indentation nil
))
2598 (org-test-parse-and-interpret
2599 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2600 "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n"))
2601 ;; Accept missing final newline in value.
2604 "#+BEGIN_SRC emacs-lisp\n Test\n#+END_SRC\n"
2605 (let ((org-edit-src-content-indentation 2)
2606 (org-src-preserve-indentation nil
))
2607 (org-element-interpret-data
2608 '(src-block (:language
"emacs-lisp" :value
"Test")))))))
2610 (ert-deftest test-org-element
/table-interpreter
()
2611 "Test table, table-row and table-cell interpreters."
2613 (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2614 "| a | b |\n| c | d |\n"))
2615 ;; 2. With horizontal rules.
2616 (should (equal (org-test-parse-and-interpret
2617 "| a | b |\n|---+---|\n| c | d |")
2618 "| a | b |\n|---+---|\n| c | d |\n"))
2619 ;; 3. With meta-data.
2620 (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2621 "| / | < | > |\n| * | 1 | 2 |\n"))
2622 ;; 4. With a formula.
2624 (equal (org-test-parse-and-interpret
2625 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2626 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2627 ;; 5. With multiple formulas.
2629 (equal (org-test-parse-and-interpret
2630 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2631 "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2633 (ert-deftest test-org-element
/timestamp-interpreter
()
2634 "Test timestamp interpreter."
2637 (string-match "<2012-03-29 .* 16:40>"
2638 (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2640 (string-match "<2012-03-29 .* 16:40>"
2641 (org-element-timestamp-interpreter
2643 (:type active
:year-start
2012 :month-start
3 :day-start
29
2644 :hour-start
16 :minute-start
40)) nil
)))
2647 (string-match "\\[2012-03-29 .* 16:40\\]"
2648 (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2651 "\\[2012-03-29 .* 16:40\\]"
2652 (org-element-timestamp-interpreter
2654 (:type inactive
:year-start
2012 :month-start
3 :day-start
29
2655 :hour-start
16 :minute-start
40)) nil
)))
2658 (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2659 (org-test-parse-and-interpret
2660 "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2663 "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2664 (org-element-timestamp-interpreter
2666 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2667 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2668 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2671 (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2672 (org-test-parse-and-interpret
2673 "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2676 "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2677 (org-element-timestamp-interpreter
2679 (:type inactive-range
:year-start
2012 :month-start
3 :day-start
29
2680 :hour-start
16 :minute-start
40 :year-end
2012 :month-end
3
2681 :day-end
29 :hour-end
16 :minute-end
41)) nil
)))
2683 (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2684 "<%%diary-float t 4 2>\n"))
2685 ;; Timestamp with repeater interval, with delay, with both.
2687 (string-match "<2012-03-29 .* \\+1y>"
2688 (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2691 "<2012-03-29 .* \\+1y>"
2692 (org-element-timestamp-interpreter
2694 (:type active
:year-start
2012 :month-start
3 :day-start
29
2695 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2699 "<2012-03-29 .* -1y>"
2700 (org-element-timestamp-interpreter
2702 (:type active
:year-start
2012 :month-start
3 :day-start
29
2703 :warning-type all
:warning-value
1 :warning-unit year
))
2707 "<2012-03-29 .* \\+1y -1y>"
2708 (org-element-timestamp-interpreter
2710 (:type active
:year-start
2012 :month-start
3 :day-start
29
2711 :warning-type all
:warning-value
1 :warning-unit year
2712 :repeater-type cumulate
:repeater-value
1 :repeater-unit year
))
2714 ;; Timestamp range with repeater interval
2716 (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2717 (org-test-parse-and-interpret
2718 "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2721 "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2722 (org-element-timestamp-interpreter
2724 (:type active-range
:year-start
2012 :month-start
3 :day-start
29
2725 :year-end
2012 :month-end
3 :day-end
30 :repeater-type cumulate
2726 :repeater-value
1 :repeater-unit year
))
2729 (ert-deftest test-org-element
/verse-block-interpreter
()
2730 "Test verse block interpretation."
2732 (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2733 "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2735 (ert-deftest test-org-element
/bold-interpreter
()
2736 "Test bold interpreter."
2737 (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2739 (ert-deftest test-org-element
/code-interpreter
()
2740 "Test code interpreter."
2741 (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2743 (ert-deftest test-org-element
/entity-interpreter
()
2744 "Test entity interpreter."
2745 ;; 1. Without brackets.
2747 (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2748 ;; 2. With brackets.
2750 (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2752 (ert-deftest test-org-element
/export-snippet-interpreter
()
2753 "Test export snippet interpreter."
2754 (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2755 "@@back-end:contents@@\n")))
2757 (ert-deftest test-org-element
/footnote-reference-interpreter
()
2758 "Test footnote reference interpreter."
2759 ;; 1. Regular reference.
2760 (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2761 ;; 2. Normalized reference.
2762 (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2763 ;; 3. Named reference.
2764 (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2765 "Text[fn:label]\n"))
2766 ;; 4. Inline reference.
2767 (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2768 "Text[fn:label:def]\n"))
2769 ;; 5. Anonymous reference.
2770 (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2771 "Text[fn::def]\n")))
2773 (ert-deftest test-org-element
/inline-babel-call-interpreter
()
2774 "Test inline babel call interpreter."
2775 ;; 1. Without arguments.
2776 (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2777 ;; 2. With arguments.
2778 (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2779 "call_test(x=2)\n"))
2780 ;; 3. With header arguments.
2781 (should (equal (org-test-parse-and-interpret
2782 "call_test[:results output]()[:results html]")
2783 "call_test[:results output]()[:results html]\n")))
2785 (ert-deftest test-org-element
/inline-src-block-interpreter
()
2786 "Test inline src block interpreter."
2787 ;; 1. Without header argument.
2788 (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2789 "src_emacs-lisp{(+ 1 1)}\n"))
2790 ;; 2. With header arguments.
2791 (should (equal (org-test-parse-and-interpret
2792 "src_emacs-lisp[:results silent]{(+ 1 1)}")
2793 "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2795 (ert-deftest test-org-element
/italic-interpreter
()
2796 "Test italic interpreter."
2797 (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2799 (ert-deftest test-org-element
/latex-fragment-interpreter
()
2800 "Test latex fragment interpreter."
2801 (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
2802 (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
2803 (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
2804 (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
2805 (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
2806 (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
2808 (ert-deftest test-org-element
/line-break-interpreter
()
2809 "Test line break interpreter."
2810 (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
2811 "First line \\\\\nSecond line\n")))
2813 (ert-deftest test-org-element
/link-interpreter
()
2814 "Test link interpreter."
2815 ;; 1. Links targeted from a radio target.
2816 (should (equal (let ((org-target-link-regexp "radio-target"))
2817 (org-test-parse-and-interpret "a radio-target"))
2818 "a radio-target\n"))
2819 ;; 2. Regular links.
2821 ;; 2.1. Without description.
2822 (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
2823 "[[http://orgmode.org]]\n"))
2824 ;; 2.2. With a description.
2825 (should (equal (org-test-parse-and-interpret
2826 "[[http://orgmode.org][Org mode]]")
2827 "[[http://orgmode.org][Org mode]]\n"))
2829 (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
2830 ;; 2.4. Custom-id links.
2831 (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
2832 ;; 2.5 Code-ref links.
2833 (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
2834 ;; 3. Normalize plain links.
2835 (should (equal (org-test-parse-and-interpret "http://orgmode.org")
2836 "[[http://orgmode.org]]\n"))
2837 ;; 4. Normalize angular links.
2838 (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
2839 "[[http://orgmode.org]]\n")))
2841 (ert-deftest test-org-element
/macro-interpreter
()
2842 "Test macro interpreter."
2843 ;; 1. Without argument.
2844 (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
2845 ;; 2. With arguments.
2846 (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
2847 "{{{test(arg1,arg2)}}}\n")))
2849 (ert-deftest test-org-element
/radio-target-interpreter
()
2850 "Test radio target interpreter."
2851 (should (equal (org-test-parse-and-interpret "<<<some text>>>")
2852 "<<<some text>>>\n")))
2854 (ert-deftest test-org-element
/statistics-cookie-interpreter
()
2855 "Test statistics cookie interpreter."
2856 ;; 1. Without percent
2857 (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
2859 (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
2861 (ert-deftest test-org-element
/strike-through-interpreter
()
2862 "Test strike through interpreter."
2863 (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
2865 (ert-deftest test-org-element
/subscript-interpreter
()
2866 "Test subscript interpreter."
2867 ;; 1. Without brackets.
2868 (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
2869 ;; 2. With brackets.
2870 (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
2872 (ert-deftest test-org-element
/superscript-interpreter
()
2873 "Test superscript interpreter."
2874 ;; 1. Without brackets.
2875 (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
2876 ;; 2. With brackets.
2877 (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
2879 (ert-deftest test-org-element
/target-interpreter
()
2880 "Test target interpreter."
2881 (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
2883 (ert-deftest test-org-element
/underline-interpreter
()
2884 "Test underline interpreter."
2885 (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
2887 (ert-deftest test-org-element
/verbatim-interpreter
()
2888 "Test verbatim interpreter."
2889 (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
2893 ;;; Test Granularity
2895 (ert-deftest test-org-element
/granularity
()
2896 "Test granularity impact on buffer parsing."
2897 (org-test-with-temp-text "
2904 ;; 1.1. Granularity set to `headline' should parse every headline
2905 ;; in buffer, and only them.
2906 (let ((tree (org-element-parse-buffer 'headline
)))
2907 (should (= 2 (length (org-element-map tree
'headline
'identity
))))
2908 (should-not (org-element-map tree
'paragraph
'identity
)))
2909 ;; 1.2. Granularity set to `greater-element' should not enter
2910 ;; greater elements excepted headlines and sections.
2911 (let ((tree (org-element-parse-buffer 'greater-element
)))
2912 (should (= 1 (length (org-element-map tree
'center-block
'identity
))))
2913 (should (= 1 (length (org-element-map tree
'paragraph
'identity
))))
2914 (should-not (org-element-map tree
'entity
'identity
)))
2915 ;; 1.3. Granularity set to `element' should enter every
2917 (let ((tree (org-element-parse-buffer 'element
)))
2918 (should (= 2 (length (org-element-map tree
'paragraph
'identity
))))
2919 (should-not (org-element-map tree
'entity
'identity
)))
2920 ;; 1.4. Granularity set to `object' can see everything.
2921 (let ((tree (org-element-parse-buffer 'object
)))
2922 (should (= 1 (length (org-element-map tree
'entity
'identity
)))))))
2924 (ert-deftest test-org-element
/secondary-string-parsing
()
2925 "Test if granularity correctly toggles secondary strings parsing."
2926 ;; With a granularity bigger than `object', no secondary string
2927 ;; should be parsed.
2930 (org-test-with-temp-text "* Headline"
2932 (org-element-map (org-element-parse-buffer 'headline
) 'headline
2933 #'identity nil
'first-match
)))
2934 (org-element-property :title headline
)))))
2937 (org-test-with-temp-text "* Headline\n- tag :: item"
2938 (let ((item (org-element-map (org-element-parse-buffer 'element
) 'item
2939 #'identity nil
'first-match
)))
2940 (org-element-property :tag item
)))))
2941 (when (featurep 'org-inlinetask
)
2944 (let ((org-inlinetask-min-level 15))
2945 (org-test-with-temp-text "*************** Inlinetask"
2946 (let ((inlinetask (org-element-map (org-element-parse-buffer 'element
)
2948 #'identity nil
'first-match
)))
2949 (org-element-property :title inlinetask
)))))))
2950 ;; With a default granularity, secondary strings should be parsed.
2953 (org-test-with-temp-text "* Headline"
2955 (org-element-map (org-element-parse-buffer) 'headline
2956 #'identity nil
'first-match
)))
2957 (org-element-property :title headline
)))))
2958 ;; `org-element-at-point' should never parse a secondary string.
2961 (org-test-with-temp-text "* Headline"
2962 (org-element-property :title
(org-element-at-point)))))
2963 ;; Preserve current local variables when parsing a secondary string.
2965 (let ((org-entities nil
)
2966 (org-entities-user nil
))
2967 (org-test-with-temp-text "
2971 # org-entities-user: ((\"foo\"))
2973 (let ((safe-local-variable-values '((org-entities-user .
(("foo"))))))
2974 (hack-local-variables))
2975 (org-element-map (org-element-parse-buffer) 'entity
2976 #'identity nil nil nil t
)))))
2980 ;;; Test Visible Only Parsing
2982 (ert-deftest test-org-element
/parse-buffer-visible
()
2983 "Test `org-element-parse-buffer' with visible only argument."
2985 (equal '("H1" "H3" "H5")
2986 (org-test-with-temp-text
2987 "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
2988 (org-occur ":visible:")
2989 (org-element-map (org-element-parse-buffer nil t
) 'headline
2990 (lambda (hl) (org-element-property :raw-value hl
)))))))
2994 ;;; Test `:parent' Property
2996 (ert-deftest test-org-element
/parent-property
()
2997 "Test `:parent' property."
2999 (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
3000 (let* ((tree (org-element-parse-buffer))
3001 (parent (org-element-property
3003 (org-element-map tree
'paragraph
'identity nil t
))))
3005 (should (eq (org-element-map tree
'center-block
'identity nil t
)
3008 (org-test-with-temp-text "a_{/b/}"
3009 (let* ((tree (org-element-parse-buffer))
3010 (parent (org-element-property
3012 (org-element-map tree
'italic
'identity nil t
))))
3015 (org-element-map tree
'subscript
'identity nil t
)))))
3016 ;; Secondary strings
3017 (org-test-with-temp-text "* /italic/"
3018 (let* ((tree (org-element-parse-buffer))
3019 (parent (org-element-property
3020 :parent
(org-element-map tree
'italic
'identity nil t
))))
3023 (org-element-map tree
'headline
'identity nil t
))))))
3027 ;;; Test Normalize Contents
3029 (ert-deftest test-org-element
/normalize-contents
()
3030 "Test `org-element-normalize-contents' specifications."
3031 ;; Remove maximum common indentation from element's contents.
3034 (org-element-normalize-contents
3035 '(paragraph nil
" Two spaces\n Three spaces"))
3036 '(paragraph nil
"Two spaces\n Three spaces")))
3037 ;; Ignore objects within contents when computing maximum common
3041 (org-element-normalize-contents
3042 '(paragraph nil
" One " (emphasis nil
"space") "\n Two spaces"))
3043 '(paragraph nil
"One " (emphasis nil
"space") "\n Two spaces")))
3044 ;; Ignore blank lines.
3047 (org-element-normalize-contents
3048 '(paragraph nil
" Two spaces\n\n \n Two spaces"))
3049 '(paragraph nil
"Two spaces\n\n \nTwo spaces")))
3052 '(paragraph nil
" Two spaces\n" (verbatim nil
"V") "\n Two spaces")
3053 (org-element-normalize-contents
3054 '(paragraph nil
" Two spaces\n " (verbatim nil
"V") "\n Two spaces"))))
3057 '(verse-block nil
"line 1\n\nline 2")
3058 (org-element-normalize-contents
3059 '(verse-block nil
" line 1\n\n line 2"))))
3060 ;; Recursively enter objects in order to compute common indentation.
3063 (org-element-normalize-contents
3064 '(paragraph nil
" Two spaces " (bold nil
" and\n One space")))
3065 '(paragraph nil
" Two spaces " (bold nil
" and\nOne space"))))
3066 ;; When optional argument is provided, ignore first line
3070 (org-element-normalize-contents
3071 '(paragraph nil
"No space\n Two spaces\n Three spaces") t
)
3072 '(paragraph nil
"No space\nTwo spaces\n Three spaces"))))
3076 ;;; Test Navigation Tools.
3078 (ert-deftest test-org-element
/at-point
()
3079 "Test `org-element-at-point' specifications."
3080 ;; Return closest element containing point.
3083 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3084 (progn (search-forward "A")
3085 (org-element-type (org-element-at-point))))))
3086 ;; Correctly set `:parent' property.
3089 (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3090 (progn (search-forward "A")
3092 (org-element-property :parent
(org-element-at-point)))))))
3093 ;; Special case: at a blank line just below a headline, return that
3096 (equal "H1" (org-test-with-temp-text "* H1\n \n* H2\n"
3098 (org-element-property :title
(org-element-at-point)))))
3099 ;; Special case: at the very beginning of a table, return `table'
3100 ;; object instead of `table-row'.
3103 (org-test-with-temp-text "| a | b |"
3104 (org-element-type (org-element-at-point)))))
3105 ;; Special case: at the very beginning of a list or sub-list, return
3106 ;; `plain-list' object instead of `item'.
3109 (org-test-with-temp-text "- item"
3110 (org-element-type (org-element-at-point)))))
3111 ;; Special case: at the closing line of a greater element, be sure
3112 ;; to return it instead of the last element in its contents.
3115 (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
3116 (progn (forward-line 2)
3117 (org-element-type (org-element-at-point))))))
3118 ;; Special case: at a blank line between two items, be sure to
3119 ;; return item above instead of the last element of its contents.
3122 (org-test-with-temp-text "- Para1\n\n- Para2"
3123 (progn (forward-line)
3125 (let ((org-list-empty-line-terminates-plain-lists nil
))
3126 (org-element-at-point)))))))
3127 ;; Special case: at the last blank line in a plain list, return it
3128 ;; instead of the last item.
3131 (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
3132 (progn (forward-line 2)
3133 (org-element-type (org-element-at-point))))))
3134 ;; Special case: when a list ends at the end of buffer and there's
3135 ;; no final newline, return last element in last item.
3138 (org-test-with-temp-text "- a"
3140 (org-element-type (org-element-at-point)))))
3141 ;; Parse a list within a block itself contained in a list.
3144 (org-test-with-temp-text
3145 "- outer\n #+begin_center\n - inner\n #+end_center"
3146 (search-forward "inner")
3148 (org-element-type (org-element-at-point)))))
3149 ;; Do not error at eob on an empty line.
3151 (org-test-with-temp-text "* H\n"
3153 (or (org-element-at-point) t
))))
3155 (ert-deftest test-org-element
/context
()
3156 "Test `org-element-context' specifications."
3157 ;; Return closest object containing point.
3160 (org-test-with-temp-text "Some *text with _underline_ text*"
3161 (progn (search-forward "under")
3162 (org-element-type (org-element-context))))))
3163 ;; Find objects in secondary strings.
3166 (org-test-with-temp-text "* Headline _with_ underlining"
3167 (progn (search-forward "w")
3168 (org-element-type (org-element-context))))))
3169 ;; Find objects in objects.
3172 (org-test-with-temp-text "| a | {{{macro}}} |"
3173 (progn (search-forward "{")
3174 (org-element-type (org-element-context))))))
3177 (org-test-with-temp-text "| a | b {{{macro}}} |"
3178 (progn (search-forward "b")
3179 (org-element-type (org-element-context))))))
3180 ;; Find objects in planning lines.
3183 (org-test-with-temp-text "* H\n SCHEDULED: <2012-03-29 thu.>"
3184 (search-forward "2012")
3185 (org-element-type (org-element-context)))))
3188 (org-test-with-temp-text "* H\n SCHEDULED: <2012-03-29 thu.>"
3189 (search-forward "SCHEDULED")
3190 (org-element-type (org-element-context)))))
3191 ;; Find objects in document keywords.
3194 (org-test-with-temp-text "#+DATE: <point>{{{macro}}}"
3195 (org-element-type (org-element-context)))))
3198 (org-test-with-temp-text "#+DATE: {{{macro}}}\n<point>"
3199 (org-element-type (org-element-context)))))
3202 (org-test-with-temp-text "#+RANDOM_KEYWORD: <point>{{{macro}}}"
3203 (org-element-type (org-element-context)))))
3204 ;; Do not find objects in table rules.
3207 (org-test-with-temp-text "| a | b |\n+---+---+\n| c | d |"
3209 (org-element-type (org-element-context)))))
3210 ;; Find objects in parsed affiliated keywords.
3213 (org-test-with-temp-text "#+CAPTION: {{{macro}}}\n| a | b |."
3214 (progn (search-forward "{")
3215 (org-element-type (org-element-context))))))
3218 (org-test-with-temp-text "#+caption: *bold*\nParagraph"
3219 (progn (search-forward "*")
3220 (org-element-type (org-element-context))))))
3221 ;; Find objects at the end of buffer.
3224 (org-test-with-temp-text "*bold*"
3225 (goto-char (point-max))
3226 (org-element-type (org-element-context)))))
3227 ;; Correctly set `:parent' property.
3230 (org-test-with-temp-text "Some *bold* text"
3231 (progn (search-forward "bold")
3233 (org-element-property :parent
(org-element-context)))))))
3234 ;; Between two objects, return the second one.
3237 (org-test-with-temp-text "<<target>>{{{test}}}"
3238 (progn (search-forward "{")
3240 (org-element-type (org-element-context))))))
3241 ;; Test optional argument.
3244 (org-test-with-temp-text "Some *text with _underline_ text*"
3246 (search-forward "under")
3247 (org-element-type (org-element-context (org-element-at-point)))))))
3248 ;; Special case: bold object at the beginning of a headline.
3251 (org-test-with-temp-text "* *bold*"
3252 (search-forward "bo")
3253 (org-element-type (org-element-context)))))
3254 ;; Special case: incomplete cell at the end of a table row.
3257 (org-test-with-temp-text "|a|b|c"
3258 (goto-char (point-max))
3259 (org-element-type (org-element-context)))))
3260 ;; Special case: objects in inline footnotes.
3263 (org-test-with-temp-text "[fn::[[<point>http://orgmode.org]]]"
3264 (org-element-type (org-element-context))))))
3270 (ert-deftest test-org-element
/lineage
()
3271 "Test `org-element-lineage' specifications."
3272 ;; Regular tests. When applied to an element or object returned by
3273 ;; `org-element-at-point' or `org-element-context', the list is
3274 ;; limited to the current section.
3276 (equal '(paragraph center-block
)
3277 (org-test-with-temp-text
3278 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3279 (mapcar #'car
(org-element-lineage (org-element-context))))))
3281 (equal '(paragraph center-block section headline headline org-data
)
3282 (org-test-with-temp-text
3283 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3285 (org-element-lineage
3286 (org-element-map (org-element-parse-buffer) 'bold
3287 #'identity nil t
))))))
3288 ;; Test TYPES optional argument.
3291 (org-test-with-temp-text
3292 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3294 (org-element-lineage (org-element-context) '(center-block))))))
3296 (org-test-with-temp-text
3297 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3298 (org-element-lineage (org-element-context) '(example-block))))
3299 ;; Test WITH-SELF optional argument.
3301 (equal '(bold paragraph center-block
)
3302 (org-test-with-temp-text
3303 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3304 (mapcar #'car
(org-element-lineage (org-element-context) nil t
)))))
3305 ;; When TYPES and WITH-SELF are provided, the latter is also checked
3306 ;; against the former.
3308 (org-test-with-temp-text
3309 "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3310 (org-element-lineage (org-element-context) '(bold) t
))))
3316 (ert-deftest test-org-element
/cache
()
3317 "Test basic expectations and common pitfalls for cache."
3321 (org-test-with-temp-text "para1\n\npara2\n\npara3"
3322 (let ((org-element-use-cache t
))
3323 (save-excursion (goto-char (point-max)) (org-element-at-point))
3326 (let ((element (org-element-at-point)))
3327 (cons (org-element-property :begin element
)
3328 (org-element-property :end element
)))))))
3329 ;; Partial shifting: when the contents of a greater element are
3330 ;; modified, only shift ending positions.
3332 (org-test-with-temp-text
3333 "#+BEGIN_CENTER\nPara1\n\nPara2\n\nPara3\n#+END_CENTER"
3334 (let ((org-element-use-cache t
))
3335 (save-excursion (search-forward "3") (org-element-at-point))
3336 (search-forward "Para2")
3338 (let ((element (org-element-property :parent
(org-element-at-point))))
3339 (equal (cons (org-element-property :begin element
)
3340 (org-element-property :end element
))
3341 (cons (point-min) (point-max)))))))
3342 ;; Re-parent shifted elements.
3345 (org-test-with-temp-text "- item\n\n\n para1\n para2"
3346 (let ((org-element-use-cache t
))
3348 (org-element-at-point)
3349 (save-excursion (goto-char (point-max)) (org-element-at-point))
3352 (goto-char (point-max))
3354 (org-element-property :parent
(org-element-at-point)))))))
3355 ;; Preserve local structures when re-parenting.
3358 (org-test-with-temp-text
3359 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n| c | d |\n#+end_center"
3360 (let ((org-element-use-cache t
))
3361 (save-excursion (search-forward "| c |") (org-element-at-point))
3363 (search-forward "| c |")
3366 (org-element-property :parent
(org-element-at-point)))))))
3369 (org-test-with-temp-text
3370 "#+begin_center\nP0\n\n<point>\n\n P1\n | a | b |\n#+end_center"
3371 (let ((org-element-use-cache t
))
3372 (save-excursion (search-forward "| a |") (org-element-at-point))
3374 (search-forward "| a |")
3377 (org-element-property :parent
(org-element-at-point)))))))
3378 ;; When re-parenting, also propagate changes to list structures.
3381 (org-test-with-temp-text "\n Para\n - item<point>"
3382 (let ((org-element-use-cache t
))
3383 (org-element-at-point)
3384 (goto-char (point-min))
3386 (search-forward "- item")
3388 (length (org-element-property :structure
(org-element-at-point)))))))
3389 ;; Modifying the last line of an element alters the element below.
3391 (org-test-with-temp-text "para1\n\npara2"
3392 (let ((org-element-use-cache t
))
3393 (goto-char (point-max))
3394 (org-element-at-point)
3397 (let ((element (org-element-at-point)))
3398 (equal (cons (org-element-property :begin element
)
3399 (org-element-property :end element
))
3400 (cons (point-min) (point-max)))))))
3401 ;; Modifying the first line of an element alters the element above.
3403 (org-test-with-temp-text ": fixed-width\n:not-fixed-width"
3404 (let ((org-element-use-cache t
))
3405 (goto-char (point-max))
3406 (org-element-at-point)
3407 (search-backward ":")
3410 (let ((element (org-element-at-point)))
3411 (equal (cons (org-element-property :begin element
)
3412 (org-element-property :end element
))
3413 (cons (point-min) (point-max)))))))
3414 ;; Sensitive change: adding a line alters document structure both
3418 (org-test-with-temp-text "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n"
3419 (let ((org-element-use-cache t
))
3420 (goto-char (point-max))
3421 (org-element-at-point)
3422 (insert "#+END_EXAMPLE")
3423 (search-backward "Para1")
3424 (org-element-type (org-element-at-point))))))
3427 (org-test-with-temp-text "Para1\n\nPara2\n#+END_EXAMPLE"
3428 (let ((org-element-use-cache t
))
3429 (save-excursion (goto-char (point-max)) (org-element-at-point))
3430 (insert "#+BEGIN_EXAMPLE\n")
3431 (search-forward "Para2")
3432 (org-element-type (org-element-at-point))))))
3433 ;; Sensitive change: removing a line alters document structure both
3437 (org-test-with-temp-text
3438 "# +BEGIN_EXAMPLE\nPara1\n\nPara2\n#+END_EXAMPLE"
3439 (let ((org-element-use-cache t
))
3440 (save-excursion (goto-char (point-max)) (org-element-at-point))
3443 (search-forward "Para2")
3444 (org-element-type (org-element-at-point))))))
3447 (org-test-with-temp-text
3448 "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n# +END_EXAMPLE"
3449 (let ((org-element-use-cache t
))
3450 (save-excursion (goto-char (point-max)) (org-element-at-point))
3451 (search-forward "# ")
3453 (search-backward "Para1")
3454 (org-element-type (org-element-at-point)))))))
3457 (provide 'test-org-element
)
3459 ;;; test-org-element.el ends here