1 ;;; test-ox.el --- Tests for ox.el -*- lexical-binding: t; -*-
3 ;; Copyright (C) 2012-2015 Nicolas Goaziou
5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
7 ;; This file is not part of GNU Emacs.
9 ;; This program is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation, either version 3 of the License, or
12 ;; (at your option) any later version.
14 ;; This program is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with this program. If not, see <http://www.gnu.org/licenses/>.
24 (unless (featurep 'ox
)
25 (signal 'missing-test-dependency
"org-export"))
27 (defun org-test-default-backend ()
28 "Return a default export back-end.
29 This back-end simply returns parsed data as Org syntax."
30 (org-export-create-backend
32 (mapcar (lambda (type)
36 (intern (format "org-element-%s-interpreter" type
))
38 (append org-element-all-elements org-element-all-objects
))))
40 (defmacro org-test-with-parsed-data
(data &rest body
)
41 "Execute body with parsed data available.
42 DATA is a string containing the data to be parsed. BODY is the
43 body to execute. Parse tree is available under the `tree'
44 variable, and communication channel under `info'."
45 (declare (debug (form body
)) (indent 1))
46 `(org-test-with-temp-text ,data
47 (org-export--delete-comments)
48 (let* ((tree (org-element-parse-buffer))
49 (info (org-export-get-environment)))
50 (org-export--prune-tree tree info
)
51 (org-export--remove-uninterpreted-data tree info
)
52 (let ((info (org-combine-plists
53 info
(org-export-collect-tree-properties tree info
))))
60 (ert-deftest test-org-export
/bind-keyword
()
61 "Test reading #+BIND: keywords."
62 ;; Test with `org-export-allow-bind-keywords' set to t.
64 (org-test-with-temp-text "#+BIND: test-ox-var value"
65 (let ((org-export-allow-bind-keywords t
))
66 (org-export-get-environment)
67 (eq test-ox-var
'value
))))
68 ;; Test with `org-export-allow-bind-keywords' set to nil.
70 (org-test-with-temp-text "#+BIND: test-ox-var value"
71 (let ((org-export-allow-bind-keywords nil
))
72 (org-export-get-environment)
73 (boundp 'test-ox-var
))))
74 ;; BIND keywords are case-insensitive.
76 (org-test-with-temp-text "#+bind: test-ox-var value"
77 (let ((org-export-allow-bind-keywords t
))
78 (org-export-get-environment)
79 (eq test-ox-var
'value
))))
80 ;; Preserve order of BIND keywords.
82 (org-test-with-temp-text "#+BIND: test-ox-var 1\n#+BIND: test-ox-var 2"
83 (let ((org-export-allow-bind-keywords t
))
84 (org-export-get-environment)
86 ;; Read BIND keywords in setup files.
88 (org-test-with-temp-text
89 (format "#+SETUPFILE: \"%s/examples/setupfile.org\"" org-test-dir
)
90 (let ((org-export-allow-bind-keywords t
))
91 (org-export-get-environment)
92 (eq variable
'value
))))
93 ;; Verify that bound variables are seen during export.
96 (org-test-with-temp-text "#+BIND: test-ox-var value"
97 (let ((org-export-allow-bind-keywords t
))
99 (org-export-create-backend
101 '((section .
(lambda (s c i
)
102 (if (eq test-ox-var
'value
) "Yes" "No")))))))))))
104 (ert-deftest test-org-export
/parse-option-keyword
()
105 "Test reading all standard #+OPTIONS: items."
108 (org-export--parse-option-keyword
109 "H:1 num:t \\n:t timestamp:t arch:t author:t creator:t d:t email:t \
110 *:t e:t ::t f:t pri:t -:t ^:t toc:t |:t tags:t tasks:t <:t todo:t inline:nil \
112 (and (eq (plist-get options
:headline-levels
) 1)
113 (eq (plist-get options
:section-numbers
) t
)
114 (eq (plist-get options
:preserve-breaks
) t
)
115 (eq (plist-get options
:time-stamp-file
) t
)
116 (eq (plist-get options
:with-archived-trees
) t
)
117 (eq (plist-get options
:with-author
) t
)
118 (eq (plist-get options
:with-drawers
) t
)
119 (eq (plist-get options
:with-email
) t
)
120 (eq (plist-get options
:with-emphasize
) t
)
121 (eq (plist-get options
:with-entities
) t
)
122 (eq (plist-get options
:with-fixed-width
) t
)
123 (eq (plist-get options
:with-footnotes
) t
)
124 (eq (plist-get options
:with-priority
) t
)
125 (eq (plist-get options
:with-special-strings
) t
)
126 (eq (plist-get options
:with-sub-superscript
) t
)
127 (eq (plist-get options
:with-toc
) t
)
128 (eq (plist-get options
:with-tables
) t
)
129 (eq (plist-get options
:with-tags
) t
)
130 (eq (plist-get options
:with-tasks
) t
)
131 (eq (plist-get options
:with-timestamps
) t
)
132 (eq (plist-get options
:with-todo-keywords
) t
)
133 (eq (plist-get options
:with-inlinetasks
) nil
)
134 (eq (plist-get options
:with-statistics-cookies
) t
)
135 (eq (plist-get options
:with-title
) t
))))
136 ;; Test some special values.
139 (org-export--parse-option-keyword
140 "arch:headline d:(\"TEST\") ^:{} toc:1 tags:not-in-toc tasks:todo \
142 (and (eq (plist-get options
:with-archived-trees
) 'headline
)
143 (eq (plist-get options
:with-sub-superscript
) '{})
144 (eq (plist-get options
:with-toc
) 1)
145 (eq (plist-get options
:with-tags
) 'not-in-toc
)
146 (eq (plist-get options
:with-tasks
) 'todo
)
147 (eq (plist-get options
:section-numbers
) 2)
148 (eq (plist-get options
:with-timestamps
) 'active
)
149 (equal (plist-get options
:with-drawers
) '("TEST")))))
150 ;; Test back-end specific values.
153 (org-export--parse-option-keyword
154 "opt:t" (org-export-create-backend :options
'((:option nil
"opt"))))
156 ;; More than one property can refer to the same option item.
158 (equal '(:opt1 t
:opt2 t
)
159 (org-export--parse-option-keyword
161 (org-export-create-backend
162 :options
'((:opt1 nil
"opt") (:opt2 nil
"opt")))))))
164 (ert-deftest test-org-export
/get-inbuffer-options
()
165 "Test reading all standard export keywords."
166 ;; Properties should follow buffer order.
169 (org-test-with-temp-text "#+LANGUAGE: fr\n#+CREATOR: Me\n#+EMAIL: email"
170 (org-export--get-inbuffer-options))
171 '(:language
"fr" :creator
"Me" :email
"email")))
172 ;; Test `space' behaviour.
175 (let ((back-end (org-export-create-backend
176 :options
'((:keyword
"KEYWORD" nil nil space
)))))
177 (org-test-with-temp-text "#+KEYWORD: With\n#+KEYWORD: spaces"
178 (org-export--get-inbuffer-options back-end
)))
179 '(:keyword
"With spaces")))
180 ;; Test `newline' behaviour.
183 (let ((back-end (org-export-create-backend
184 :options
'((:keyword
"KEYWORD" nil nil newline
)))))
185 (org-test-with-temp-text "#+KEYWORD: With\n#+KEYWORD: two lines"
186 (org-export--get-inbuffer-options back-end
)))
187 '(:keyword
"With\ntwo lines")))
188 ;; Test `split' behaviour.
191 (org-test-with-temp-text "#+SELECT_TAGS: a\n#+SELECT_TAGS: b"
192 (org-export--get-inbuffer-options))
193 '(:select-tags
("a" "b"))))
194 ;; Test `parse' behaviour. `parse' implies `space' but preserve
195 ;; line breaks. Multi-line objects are allowed.
198 (org-test-with-temp-text "#+TITLE: *bold*"
199 (plist-get (org-export--get-inbuffer-options) :title
))
200 'bold
#'identity nil t
))
203 (org-test-with-temp-text "#+TITLE: Some title\n#+TITLE: with spaces"
204 (plist-get (org-export--get-inbuffer-options) :title
))
205 '("Some title with spaces")))
208 (org-test-with-temp-text "#+TITLE: Some title\\\\\n#+TITLE: with spaces"
209 (plist-get (org-export--get-inbuffer-options) :title
))
210 'line-break
#'identity nil t
))
213 (org-test-with-temp-text "#+TITLE: *bold\n#+TITLE: sentence*"
214 (plist-get (org-export--get-inbuffer-options) :title
))
215 'bold
#'identity nil t
))
216 ;; Options set through SETUPFILE.
219 (org-test-with-temp-text
220 (format "#+DESCRIPTION: l1
224 #+SETUPFILE: \"%s/examples/setupfile.org\"
229 (org-export--get-inbuffer-options))
230 '(:language
"fr" :select-tags
("a" "b" "c") :title
("a b c"))))
231 ;; More than one property can refer to the same buffer keyword.
233 (equal '(:k2
"value" :k1
"value")
234 (let ((backend (org-export-create-backend
235 :options
'((:k1
"KEYWORD")
237 (org-test-with-temp-text "#+KEYWORD: value"
238 (org-export--get-inbuffer-options backend
)))))
239 ;; Keywords in commented subtrees are ignored.
242 (org-test-with-parsed-data "* COMMENT H1\n#+AUTHOR: Me"
243 (plist-get info
:author
))))
246 (org-test-with-parsed-data "* COMMENT H1\n** H2\n#+EMAIL: Mine"
247 (plist-get info
:email
)))))
249 (ert-deftest test-org-export
/get-subtree-options
()
250 "Test setting options from headline's properties."
253 (equal '("Subtree Title")
254 (org-test-with-temp-text "#+TITLE: Title
257 :EXPORT_TITLE: Subtree Title
260 (plist-get (org-export-get-environment nil t
) :title
))))
264 (org-test-with-temp-text "#+OPTIONS: H:1
270 (plist-get (org-export-get-environment nil t
) :headline-levels
))))
273 (equal '("29-03-2012")
274 (org-test-with-temp-text "#+DATE: today
277 :EXPORT_DATE: 29-03-2012
280 (plist-get (org-export-get-environment nil t
) :date
))))
281 ;; Properties with `split' behaviour are stored as a list of
285 (org-test-with-temp-text "#+EXCLUDE_TAGS: noexport
288 :EXPORT_EXCLUDE_TAGS: a b
291 (plist-get (org-export-get-environment nil t
) :exclude-tags
))))
292 ;; Handle :PROPERTY+: syntax.
295 (org-test-with-temp-text "#+EXCLUDE_TAGS: noexport
298 :EXPORT_EXCLUDE_TAGS: a
299 :EXPORT_EXCLUDE_TAGS+: b
302 (plist-get (org-export-get-environment nil t
) :exclude-tags
))))
303 ;; Export properties are case-insensitive.
305 (equal '("29-03-2012")
306 (org-test-with-temp-text "* Headline
308 :EXPORT_Date: 29-03-2012
311 (plist-get (org-export-get-environment nil t
) :date
))))
312 ;; Still grab correct options when section above is empty.
315 (org-test-with-temp-text "* H1\n** H11\n** H12<point>"
316 (plist-get (org-export-get-environment nil t
) :title
))))
317 ;; More than one property can refer to the same node property.
320 (org-test-with-temp-text
321 "* H\n:PROPERTIES:\n:EXPORT_A: 1\n:END:\n<point>"
322 (let* ((backend (org-export-create-backend
325 (options (org-export-get-environment backend t
)))
326 (list (plist-get options
:k1
) (plist-get options
:k2
)))))))
328 (ert-deftest test-org-export
/set-title
()
329 "Test title setting."
330 ;; Without TITLE keyword.
334 (let (org-export-filter-body-functions
335 org-export-filter-final-output-functions
)
336 (org-test-with-temp-text "Test"
338 (org-export-create-backend
340 '((template .
(lambda (text info
)
341 (org-element-interpret-data
342 (plist-get info
:title
)))))))))))
343 ;; With a blank TITLE keyword.
347 (let (org-export-filter-body-functions
348 org-export-filter-final-output-functions
)
349 (org-test-with-temp-text "#+TITLE:\nTest"
351 (org-export-create-backend
353 '((template .
(lambda (text info
)
354 (org-element-interpret-data
355 (plist-get info
:title
)))))))))))
356 ;; With a non-empty TITLE keyword.
360 (org-test-with-temp-text "#+TITLE: Title\nTest"
362 (org-export-create-backend
364 '((template .
(lambda (text info
)
365 (org-element-interpret-data
366 (plist-get info
:title
))))))))))
367 ;; When exporting a subtree, its heading becomes the headline of the
372 (org-test-with-temp-text "* Headline\nBody"
374 (org-export-create-backend
376 '((template .
(lambda (text info
)
377 (org-element-interpret-data
378 (plist-get info
:title
))))))
380 ;; ... unless there is an EXPORT_TITLE property at the root of the
385 (org-test-with-temp-text
386 "* A\n :PROPERTIES:\n :EXPORT_TITLE: B\n :END:\nBody"
388 (org-export-create-backend
390 '((template .
(lambda (text info
)
391 (org-element-interpret-data
392 (plist-get info
:title
))))))
395 (ert-deftest test-org-export
/handle-options
()
396 "Test if export options have an impact on output."
397 ;; Test exclude tags for headlines and inlinetasks.
400 (let (org-export-filter-body-functions
401 org-export-filter-final-output-functions
)
402 (org-test-with-temp-text "* Head1 :noexp:"
403 (org-export-as (org-test-default-backend)
404 nil nil nil
'(:exclude-tags
("noexp")))))))
405 ;; Test include tags for headlines and inlinetasks.
407 (equal "* H2\n** Sub :exp:\n*** Sub Sub\n"
408 (org-test-with-temp-text "* H1\n* H2\n** Sub :exp:\n*** Sub Sub\n* H3"
409 (let ((org-tags-column 0))
410 (org-export-as (org-test-default-backend)
411 nil nil nil
'(:select-tags
("exp")))))))
412 ;; If there is an include tag, ignore the section before the first
415 (equal "* H1 :exp:\nBody\n"
416 (org-test-with-temp-text "First section\n* H1 :exp:\nBody"
417 (let ((org-tags-column 0))
418 (org-export-as (org-test-default-backend)
419 nil nil nil
'(:select-tags
("exp")))))))
421 (equal "* H1 :exp:\n"
422 (org-test-with-temp-text "* H1 :exp:\nBody"
423 (let ((org-tags-column 0))
424 (org-export-as (org-test-default-backend)
425 nil nil nil
'(:select-tags
("exp")))))))
426 ;; Test mixing include tags and exclude tags.
429 "\\* Head1[ \t]+:export:\n\\*\\* Sub-Head2\n"
430 (org-test-with-temp-text "
432 ** Sub-Head1 :noexport:
435 ** Sub-Head1 :export:"
436 (org-export-as (org-test-default-backend) nil nil nil
437 '(:select-tags
("export") :exclude-tags
("noexport"))))))
441 (let ((org-todo-keywords '((sequence "TODO" "DONE")))
442 org-export-filter-body-functions
443 org-export-filter-final-output-functions
)
444 (org-test-with-temp-text "* TODO Head1"
445 (org-export-as (org-test-default-backend)
446 nil nil nil
'(:with-tasks nil
))))))
448 (equal "* TODO Head1\n"
449 (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
450 (org-test-with-temp-text "* TODO Head1"
451 (org-export-as (org-test-default-backend)
452 nil nil nil
'(:with-tasks t
))))))
456 (let (org-export-filter-body-functions
457 org-export-filter-final-output-functions
)
458 (org-test-with-temp-text "* Head1 :archive:"
459 (let ((org-archive-tag "archive"))
460 (org-export-as (org-test-default-backend)
461 nil nil nil
'(:with-archived-trees nil
)))))))
464 "\\* Head1[ \t]+:archive:"
465 (org-test-with-temp-text "* Head1 :archive:\nbody\n** Sub-head 2"
466 (let ((org-archive-tag "archive"))
467 (org-export-as (org-test-default-backend) nil nil nil
468 '(:with-archived-trees headline
))))))
471 "\\`\\* Head1[ \t]+:archive:\n\\'"
472 (org-test-with-temp-text "* Head1 :archive:"
473 (let ((org-archive-tag "archive"))
474 (org-export-as (org-test-default-backend)
475 nil nil nil
'(:with-archived-trees t
))))))
478 (string-match "CLOCK: \\[2012-04-29 .* 10:45\\]"
479 (org-test-with-temp-text "CLOCK: [2012-04-29 sun. 10:45]"
480 (org-export-as (org-test-default-backend)
481 nil nil nil
'(:with-clocks t
)))))
484 (let (org-export-filter-body-functions
485 org-export-filter-final-output-functions
)
486 (org-test-with-temp-text "CLOCK: [2012-04-29 sun. 10:45]"
487 (org-export-as (org-test-default-backend)
488 nil nil nil
'(:with-clocks nil
))))))
492 (let (org-export-filter-body-functions
493 org-export-filter-final-output-functions
)
494 (org-test-with-temp-text ":TEST:\ncontents\n:END:"
495 (org-export-as (org-test-default-backend)
496 nil nil nil
'(:with-drawers nil
))))))
498 (equal ":TEST:\ncontents\n:END:\n"
499 (org-test-with-temp-text ":TEST:\ncontents\n:END:"
500 (org-export-as (org-test-default-backend)
501 nil nil nil
'(:with-drawers t
)))))
503 (equal ":FOO:\nkeep\n:END:\n"
504 (org-test-with-temp-text ":FOO:\nkeep\n:END:\n:BAR:\nremove\n:END:"
505 (org-export-as (org-test-default-backend)
506 nil nil nil
'(:with-drawers
("FOO"))))))
508 (equal ":FOO:\nkeep\n:END:\n"
509 (org-test-with-temp-text ":FOO:\nkeep\n:END:\n:BAR:\nremove\n:END:"
510 (org-export-as (org-test-default-backend)
511 nil nil nil
'(:with-drawers
(not "BAR"))))))
515 (org-test-with-temp-text ": A"
516 (org-export-as (org-test-default-backend) nil nil nil
517 '(:with-fixed-width t
)))))
520 (let (org-export-filter-body-functions
521 org-export-filter-final-output-functions
)
522 (org-test-with-temp-text ": A"
523 (org-export-as (org-test-default-backend) nil nil nil
524 '(:with-fixed-width nil
))))))
528 (let ((org-footnote-section nil
))
529 (org-test-with-temp-text "Footnote?[fn:1]\n\n[fn:1] Def"
530 (org-trim (org-export-as (org-test-default-backend)
531 nil nil nil
'(:with-footnotes nil
)))))))
533 (equal "Footnote?[fn:1]\n\n[fn:1] Def"
534 (let ((org-footnote-section nil
))
535 (org-test-with-temp-text "Footnote?[fn:1]\n\n[fn:1] Def"
536 (org-trim (org-export-as (org-test-default-backend)
537 nil nil nil
'(:with-footnotes t
)))))))
539 (when (featurep 'org-inlinetask
)
543 (let ((org-inlinetask-min-level 15)
544 org-export-filter-body-functions
545 org-export-filter-final-output-functions
)
546 (org-test-with-temp-text "*************** Task"
547 (org-export-as (org-test-default-backend)
548 nil nil nil
'(:with-inlinetasks nil
))))))
552 (let ((org-inlinetask-min-level 15)
553 org-export-filter-body-functions
554 org-export-filter-final-output-functions
)
555 (org-test-with-temp-text
556 "*************** Task\nContents\n*************** END"
557 (org-export-as (org-test-default-backend)
558 nil nil nil
'(:with-inlinetasks nil
)))))))
562 "* H\nCLOSED: \\[2012-04-29 .* 10:45\\]"
563 (let ((org-closed-string "CLOSED:"))
564 (org-test-with-temp-text "* H\nCLOSED: [2012-04-29 sun. 10:45]"
565 (org-export-as (org-test-default-backend)
566 nil nil nil
'(:with-planning t
))))))
569 (let ((org-closed-string "CLOSED:"))
570 (org-test-with-temp-text "* H\nCLOSED: [2012-04-29 sun. 10:45]"
571 (org-export-as (org-test-default-backend)
572 nil nil nil
'(:with-planning nil
))))))
576 (org-test-with-temp-text
577 "* H1\n :PROPERTIES:\n :PROP: value\n :END:"
578 (org-export-as (org-test-default-backend)
579 nil nil nil
'(:with-properties nil
)))))
581 (equal "* H1\n:PROPERTIES:\n:PROP: value\n:END:\n"
582 (org-test-with-temp-text
583 "* H1\n :PROPERTIES:\n :PROP: value\n :END:"
584 (org-export-as (org-test-default-backend)
585 nil nil nil
'(:with-properties t
)))))
587 (equal "* H1\n:PROPERTIES:\n:B: 2\n:END:\n"
588 (org-test-with-temp-text
589 "* H1\n :PROPERTIES:\n :A: 1\n :B: 2\n:END:"
590 (org-export-as (org-test-default-backend)
591 nil nil nil
'(:with-properties
("B"))))))
592 ;; Statistics cookies.
595 (let (org-export-filter-body-functions
596 org-export-filter-final-output-functions
)
598 (org-test-with-temp-text "[0/0]"
599 (org-export-as (org-test-default-backend)
600 nil nil nil
'(:with-statistics-cookies nil
)))))))
604 (org-test-with-temp-text "| A |"
605 (org-export-as (org-test-default-backend) nil nil nil
606 '(:with-tables t
)))))
609 (let (org-export-filter-body-functions
610 org-export-filter-final-output-functions
)
611 (org-test-with-temp-text "| A |"
612 (org-export-as (org-test-default-backend) nil nil nil
613 '(:with-tables nil
)))))))
615 (ert-deftest test-org-export
/with-timestamps
()
616 "Test `org-export-with-timestamps' specifications."
620 "\\[2012-04-29 .*? 10:45\\]<2012-04-29 .*? 10:45>"
621 (org-test-with-temp-text "[2012-04-29 sun. 10:45]<2012-04-29 sun. 10:45>"
622 (org-export-as (org-test-default-backend)
623 nil nil nil
'(:with-timestamps t
)))))
628 (let (org-export-filter-body-functions
629 org-export-filter-final-output-functions
)
631 (org-test-with-temp-text "[2012-04-29 sun. 10:45]<2012-04-29 sun. 10:45>"
632 (org-export-as (org-test-default-backend)
633 nil nil nil
'(:with-timestamps nil
)))))))
637 "<2012-03-29 .*?>\n\nParagraph <2012-03-29 .*?>\\[2012-03-29 .*?\\]"
638 (org-test-with-temp-text
639 "<2012-03-29 Thu>[2012-03-29 Thu]
641 Paragraph <2012-03-29 Thu>[2012-03-29 Thu]"
642 (org-export-as (org-test-default-backend)
643 nil nil nil
'(:with-timestamps active
)))))
647 "\\[2012-03-29 .*?\\]\n\nParagraph <2012-03-29 .*?>\\[2012-03-29 .*?\\]"
648 (org-test-with-temp-text
649 "<2012-03-29 Thu>[2012-03-29 Thu]
651 Paragraph <2012-03-29 Thu>[2012-03-29 Thu]"
652 (org-export-as (org-test-default-backend)
653 nil nil nil
'(:with-timestamps inactive
))))))
655 (ert-deftest test-org-export
/comment-tree
()
656 "Test if export process ignores commented trees."
659 (let (org-export-filter-body-functions
660 org-export-filter-final-output-functions
)
661 (org-test-with-temp-text "* COMMENT Head1"
662 (org-export-as (org-test-default-backend)))))))
664 (ert-deftest test-org-export
/uninterpreted
()
665 "Test handling of uninterpreted elements."
669 (org-test-with-temp-text "\\alpha"
671 (org-export-create-backend
672 :transcoders
'((entity .
(lambda (e c i
) "dummy"))
673 (paragraph .
(lambda (p c i
) c
))
674 (section .
(lambda (s c i
) c
))))
675 nil nil nil
'(:with-entities t
)))))
678 (org-test-with-temp-text "\\alpha"
680 (org-export-create-backend
681 :transcoders
'((entity .
(lambda (e c i
) "dummy"))
682 (paragraph .
(lambda (p c i
) c
))
683 (section .
(lambda (s c i
) c
))))
684 nil nil nil
'(:with-entities nil
)))))
688 (org-test-with-temp-text "*bold*"
690 (org-export-create-backend
691 :transcoders
'((bold .
(lambda (b c i
) "dummy"))
692 (paragraph .
(lambda (p c i
) c
))
693 (section .
(lambda (s c i
) c
))))
694 nil nil nil
'(:with-emphasize t
)))))
697 (org-test-with-temp-text "*bold*"
699 (org-export-create-backend
700 :transcoders
'((bold .
(lambda (b c i
) "dummy"))
701 (paragraph .
(lambda (p c i
) c
))
702 (section .
(lambda (s c i
) c
))))
703 nil nil nil
'(:with-emphasize nil
)))))
704 ;; LaTeX environment.
707 (org-test-with-temp-text "\\begin{equation}\n1+1=2\n\\end{equation}"
709 (org-export-create-backend
710 :transcoders
'((latex-environment .
(lambda (l c i
) "dummy"))
711 (section .
(lambda (s c i
) c
))))
712 nil nil nil
'(:with-latex t
)))))
714 (equal "\\begin{equation}\n1+1=2\n\\end{equation}\n"
715 (org-test-with-temp-text "\\begin{equation}\n1+1=2\n\\end{equation}"
717 (org-export-create-backend
718 :transcoders
'((latex-environment .
(lambda (l c i
) "dummy"))
719 (section .
(lambda (s c i
) c
))))
720 nil nil nil
'(:with-latex verbatim
)))))
724 (org-test-with-temp-text "$1$"
726 (org-export-create-backend
727 :transcoders
'((latex-fragment .
(lambda (l c i
) "dummy"))
728 (paragraph .
(lambda (p c i
) c
))
729 (section .
(lambda (s c i
) c
))))
730 nil nil nil
'(:with-latex t
)))))
733 (org-test-with-temp-text "$1$"
735 (org-export-create-backend
736 :transcoders
'((latex-fragment .
(lambda (l c i
) "dummy"))
737 (paragraph .
(lambda (p c i
) c
))
738 (section .
(lambda (s c i
) c
))))
739 nil nil nil
'(:with-latex verbatim
)))))
743 (org-test-with-temp-text "a_b"
745 (org-export-create-backend
746 :transcoders
'((subscript .
(lambda (s c i
) "dummy"))
747 (paragraph .
(lambda (p c i
) c
))
748 (section .
(lambda (s c i
) c
))))
749 nil nil nil
'(:with-sub-superscript t
)))))
752 (org-test-with-temp-text "a_b"
754 (org-export-create-backend
755 :transcoders
'((subscript .
(lambda (s c i
) "dummy"))
756 (paragraph .
(lambda (p c i
) c
))
757 (section .
(lambda (s c i
) c
))))
758 nil nil nil
'(:with-sub-superscript nil
)))))
761 (org-test-with-temp-text "a_b"
763 (org-export-create-backend
764 :transcoders
'((subscript .
(lambda (s c i
) "dummy"))
765 (paragraph .
(lambda (p c i
) c
))
766 (section .
(lambda (s c i
) c
))))
767 nil nil nil
'(:with-sub-superscript
{})))))
770 (org-test-with-temp-text "a_{b}"
772 (org-export-create-backend
773 :transcoders
'((subscript .
(lambda (s c i
) "dummy"))
774 (paragraph .
(lambda (p c i
) c
))
775 (section .
(lambda (s c i
) c
))))
776 nil nil nil
'(:with-sub-superscript
{})))))
777 ;; Also handle uninterpreted objects in title.
780 (org-test-with-temp-text "#+TITLE: a_b"
782 (org-export-create-backend
784 '((subscript .
(lambda (s c i
) "dummy"))
785 (template .
(lambda (c i
) (org-export-data
786 (plist-get i
:title
) i
)))
787 (section .
(lambda (s c i
) c
))))
788 nil nil nil
'(:with-sub-superscript nil
)))))
789 ;; Handle uninterpreted objects in captions.
792 (org-test-with-temp-text "#+CAPTION: a_b\nParagraph"
794 (org-export-create-backend
796 '((subscript .
(lambda (s c i
) "dummy"))
797 (paragraph .
(lambda (p c i
)
798 (org-export-data (org-export-get-caption p
) i
)))
799 (section .
(lambda (s c i
) c
))))
800 nil nil nil
'(:with-sub-superscript t
)))))
803 (org-test-with-temp-text "#+CAPTION: a_b\nParagraph"
805 (org-export-create-backend
807 '((subscript .
(lambda (s c i
) "dummy"))
808 (paragraph .
(lambda (p c i
)
809 (org-export-data (org-export-get-caption p
) i
)))
810 (section .
(lambda (s c i
) c
))))
811 nil nil nil
'(:with-sub-superscript nil
)))))
812 ;; Special case: multiples uninterpreted objects in a row.
815 (org-test-with-temp-text "a_b_c_d"
817 (org-export-create-backend
818 :transcoders
'((subscript .
(lambda (s c i
) "dummy"))
819 (paragraph .
(lambda (p c i
) c
))
820 (section .
(lambda (s c i
) c
))))
821 nil nil nil
'(:with-sub-superscript
{}))))))
823 (ert-deftest test-org-export
/export-scope
()
824 "Test all export scopes."
825 (org-test-with-temp-text "
832 (should (equal (org-export-as (org-test-default-backend) 'subtree
)
833 "text\n*** Head3\n"))
835 (goto-char (point-min))
838 (should (equal (org-export-as (org-test-default-backend) nil
'visible
)
841 (goto-char (point-min))
843 (transient-mark-mode 1)
844 (push-mark (point) t t
)
845 (goto-char (point-at-eol))
846 (should (equal (org-export-as (org-test-default-backend)) "text\n")))
847 ;; Subtree with a code block calling another block outside.
848 (let ((org-export-babel-evaluate t
))
851 (org-test-with-temp-text "
853 #+BEGIN_SRC emacs-lisp :noweb yes :exports results
858 #+BEGIN_SRC emacs-lisp
862 (org-export-as (org-test-default-backend) 'subtree
)))))
864 (let ((backend (org-test-default-backend)))
865 (setf (org-export-backend-transcoders backend
)
866 (cons '(template .
(lambda (body i
)
867 (format "BEGIN\n%sEND" body
)))
868 (org-export-backend-transcoders backend
)))
869 (org-test-with-temp-text "Text"
870 (should (equal (org-export-as backend nil nil
'body-only
)
872 (should (equal (org-export-as backend
) "BEGIN\nText\nEND")))))
874 (ert-deftest test-org-export
/output-file-name
()
875 "Test `org-export-output-file-name' specifications."
876 ;; Export from a file: name is built from original file name.
878 (org-test-with-temp-text-in-file "Test"
879 (equal (concat (file-name-as-directory ".")
880 (file-name-nondirectory
881 (file-name-sans-extension (buffer-file-name))))
882 (file-name-sans-extension (org-export-output-file-name ".ext")))))
883 ;; When exporting to subtree, check EXPORT_FILE_NAME property first.
885 (org-test-with-temp-text-in-file
886 "* Test\n :PROPERTIES:\n :EXPORT_FILE_NAME: test\n :END:"
887 (equal (org-export-output-file-name ".ext" t
) "./test.ext")))
888 ;; From a buffer not associated to a file, too.
890 (org-test-with-temp-text
891 "* Test\n :PROPERTIES:\n :EXPORT_FILE_NAME: test\n :END:"
892 (equal (org-export-output-file-name ".ext" t
) "./test.ext")))
893 ;; When provided name is absolute, preserve it.
895 (org-test-with-temp-text
896 (format "* Test\n :PROPERTIES:\n :EXPORT_FILE_NAME: %s\n :END:"
897 (expand-file-name "test"))
898 (file-name-absolute-p (org-export-output-file-name ".ext" t
))))
899 ;; When PUB-DIR argument is provided, use it.
901 (org-test-with-temp-text-in-file "Test"
902 (equal (file-name-directory
903 (org-export-output-file-name ".ext" nil
"dir/"))
905 ;; When returned name would overwrite original file, add EXTENSION
908 (org-test-at-id "75282ba2-f77a-4309-a970-e87c149fe125"
909 (equal (org-export-output-file-name ".org") "./normal.org.org"))))
911 (ert-deftest test-org-export
/expand-include
()
912 "Test file inclusion in an Org buffer."
913 ;; Error when file isn't specified.
915 (org-test-with-temp-text "#+INCLUDE: dummy.org"
916 (org-export-expand-include-keyword)))
917 ;; Full insertion with recursive inclusion.
922 (expand-file-name "examples/include.org" org-test-dir
))
923 (replace-regexp-in-string
924 (regexp-quote "#+INCLUDE: \"include2.org\"")
925 "Success!" (buffer-string)))
926 (org-test-with-temp-text
927 (format "#+INCLUDE: \"%s/examples/include.org\"" org-test-dir
)
928 (org-export-expand-include-keyword)
930 ;; Localized insertion.
931 (org-test-with-temp-text
932 (format "#+INCLUDE: \"%s/examples/include.org\" :lines \"1-2\""
934 (org-export-expand-include-keyword)
935 (should (equal (buffer-string)
936 "Small Org file with an include keyword.\n")))
937 ;; Insertion with constraints on headlines level.
940 "* Top heading\n** Heading\nbody\n"
941 (org-test-with-temp-text
943 "* Top heading\n#+INCLUDE: \"%s/examples/include.org\" :lines \"9-11\""
945 (org-export-expand-include-keyword)
949 "* Top heading\n* Heading\nbody\n"
950 (org-test-with-temp-text
952 "* Top heading\n#+INCLUDE: \"%s/examples/include.org\" :lines \"9-11\" :minlevel 1"
954 (org-export-expand-include-keyword)
956 ;; Inclusion within an example block.
959 "#+BEGIN_EXAMPLE\nSmall Org file with an include keyword.\n#+END_EXAMPLE\n"
960 (org-test-with-temp-text
961 (format "#+INCLUDE: \"%s/examples/include.org\" :lines \"1-2\" EXAMPLE"
963 (org-export-expand-include-keyword)
965 ;; Inclusion within a src-block.
968 "#+BEGIN_SRC emacs-lisp\n(+ 2 1)\n#+END_SRC\n"
969 (org-test-with-temp-text
971 "#+INCLUDE: \"%s/examples/include.org\" :lines \"4-5\" SRC emacs-lisp"
973 (org-export-expand-include-keyword)
975 ;; Inclusion within an html export-block.
978 "#+BEGIN_HTML\n<p>HTML!</p>\n#+END_HTML\n"
979 (org-test-with-temp-text
981 "#+INCLUDE: \"%s/examples/include.html\" HTML"
983 (org-export-expand-include-keyword)
985 ;; Inclusion within an center paragraph
988 "#+BEGIN_CENTER\nSuccess!\n#+END_CENTER\n"
989 (org-test-with-temp-text
991 "#+INCLUDE: \"%s/examples/include2.org\" CENTER"
993 (org-export-expand-include-keyword)
995 ;; Footnotes labels are local to each included file.
1001 Footnotes[fn:1], [fn:test], [fn:test] and [fn:inline:anonymous footnote].
1003 \[fn:test] Footnote \"test\""))
1004 (org-test-with-temp-text-in-file contents
1005 (let ((file1 (buffer-file-name)))
1006 (org-test-with-temp-text-in-file contents
1007 (let ((file2 (buffer-file-name)))
1008 (org-test-with-temp-text
1009 (format "#+INCLUDE: \"%s\"\n#+INCLUDE: \"%s\""
1011 (org-export-expand-include-keyword)
1012 (org-element-map (org-element-parse-buffer)
1014 (lambda (r) (org-element-property :label r
)))))))))))))
1015 ;; Footnotes labels are not local to each include keyword.
1021 Footnotes[fn:1], [fn:test], [2] and [fn:inline:anonymous footnote].
1024 \[fn:test] Footnote \"test\""))
1025 (org-test-with-temp-text-in-file contents
1026 (let ((file (buffer-file-name)))
1027 (org-test-with-temp-text
1028 (format "#+INCLUDE: \"%s\"\n#+INCLUDE: \"%s\"" file file
)
1029 (org-export-expand-include-keyword)
1030 (org-element-map (org-element-parse-buffer)
1032 (lambda (ref) (org-element-property :label ref
)))))))))))
1033 ;; Footnotes are supported by :lines-like elements and unnecessary
1034 ;; footnotes are dropped.
1043 Footnotes[fn:2], foot[fn:test], digit only[3], and [fn:inline:anonymous footnote]
1048 \[fn:test] Footnote \"test\"
1051 (org-test-with-temp-text-in-file contents
1052 (let ((file (buffer-file-name)))
1053 (org-test-with-temp-text
1054 (format "#+INCLUDE: \"%s::*bar\"
1056 (org-export-expand-include-keyword)
1057 (org-element-map (org-element-parse-buffer)
1058 'footnote-definition
1059 (lambda (ref) (org-element-property :label ref
)))))))))))
1060 ;; If only-contents is non-nil only include contents of element.
1064 (org-test-with-temp-text
1066 (format "#+INCLUDE: \"%s/examples/include.org::*Heading\" " org-test-dir
)
1068 (org-export-expand-include-keyword)
1070 ;; Headings can be included via CUSTOM_ID.
1072 (org-test-with-temp-text
1073 (format "#+INCLUDE: \"%s/examples/include.org::#ah\"" org-test-dir
)
1074 (org-export-expand-include-keyword)
1075 (goto-char (point-min))
1076 (looking-at "* Another heading")))
1077 ;; Named objects can be included.
1081 (org-test-with-temp-text
1082 (format "#+INCLUDE: \"%s/examples/include.org::tbl\" :only-contents t" org-test-dir
)
1083 (org-export-expand-include-keyword)
1085 ;; Including non-existing elements should result in an error.
1087 (org-test-with-temp-text
1088 (format "#+INCLUDE: \"%s/examples/include.org::*non-existing heading\"" org-test-dir
)
1089 (org-export-expand-include-keyword)))
1090 ;; Lines work relatively to an included element.
1094 (org-test-with-temp-text
1095 (format "#+INCLUDE: \"%s/examples/include.org::#ah\" :only-contents t :lines \"2-3\"" org-test-dir
)
1096 (org-export-expand-include-keyword)
1098 ;; Properties should be dropped from headlines.
1101 (org-test-with-temp-text
1102 (format "#+INCLUDE: \"%s/examples/include.org::#ht\" :only-contents t" org-test-dir
)
1103 (org-export-expand-include-keyword)
1105 (org-test-with-temp-text
1106 (format "#+INCLUDE: \"%s/examples/include.org::tbl\"" org-test-dir
)
1107 (org-export-expand-include-keyword)
1109 ;; Properties should be dropped, drawers should not be.
1112 ":LOGBOOK:\ndrawer\n:END:\ncontent\n"
1113 (org-test-with-temp-text
1114 (format "#+INCLUDE: \"%s/examples/include.org::#dh\" :only-contents t" org-test-dir
)
1115 (org-export-expand-include-keyword)
1117 ;; Adjacent INCLUDE-keywords should have the same :minlevel if unspecified.
1119 (org-every (lambda (level) (zerop (1- level
)))
1120 (org-test-with-temp-text
1122 (format "#+INCLUDE: \"%s/examples/include.org::#ah\"\n" org-test-dir
)
1123 (format "#+INCLUDE: \"%s/examples/include.org::*Heading\"" org-test-dir
))
1124 (org-export-expand-include-keyword)
1125 (org-element-map (org-element-parse-buffer) 'headline
1126 (lambda (head) (org-element-property :level head
))))))
1127 ;; INCLUDE does not insert induced :minlevel for src-blocks.
1130 (org-test-with-temp-text
1131 (format "#+INCLUDE: \"%s/examples/include2.org\" src emacs-lisp" org-test-dir
)
1132 (org-export-expand-include-keyword)
1134 (org-test-with-temp-text
1135 (format "#+INCLUDE: \"%s/examples/include2.org\" src emacs-lisp :minlevel 1" org-test-dir
)
1136 (org-export-expand-include-keyword)
1138 ;; INCLUDE assigns the relative :minlevel conditional on narrowing.
1140 (org-test-with-temp-text-in-file
1141 (format "* h1\n<point>#+INCLUDE: \"%s/examples/include.org::#ah\"" org-test-dir
)
1142 (narrow-to-region (point) (point-max))
1143 (org-export-expand-include-keyword)
1144 (eq 1 (org-current-level))))
1145 ;; If :minlevel is present do not alter it.
1147 (org-test-with-temp-text
1148 (format "* h1\n<point>#+INCLUDE: \"%s/examples/include.org::#ah\" :minlevel 3" org-test-dir
)
1149 (narrow-to-region (point) (point-max))
1150 (org-export-expand-include-keyword)
1151 (eq 3 (org-current-level)))))
1153 (ert-deftest test-org-export
/expand-macro
()
1154 "Test macro expansion in an Org buffer."
1155 ;; Standard macro expansion.
1157 (equal "#+MACRO: macro1 value\nvalue\n"
1158 (org-test-with-temp-text "#+MACRO: macro1 value\n{{{macro1}}}"
1159 (org-export-as (org-test-default-backend)))))
1160 ;; Allow macro in parsed keywords and associated properties.
1161 ;; Standard macro expansion.
1165 (let ((backend (org-export-create-backend
1167 :options
'((:k
"K" nil nil parse
)))))
1168 (org-test-with-temp-text "#+MACRO: macro value\n#+K: {{{macro}}}"
1169 (org-export-as backend
)))))
1173 (let ((backend (org-export-create-backend
1175 :options
'((:k
"K" nil nil parse
)))))
1176 (org-test-with-temp-text
1177 "#+MACRO: m v\n* H\n:PROPERTIES:\n:EXPORT_K: {{{m}}}\n:END:"
1178 (org-export-as backend nil nil nil
'(:with-properties t
))))))
1179 ;; Expand specific macros.
1181 (equal "me 2012-03-29 me@here Title\n"
1182 (org-test-with-temp-text
1188 {{{author}}} {{{date}}} {{{email}}} {{{title}}}"
1189 (let ((output (org-export-as (org-test-default-backend))))
1190 (substring output
(string-match ".*\n\\'" output
))))))
1191 ;; Expand specific macros when property contained a regular macro
1195 (org-test-with-temp-text "
1196 #+MACRO: macro1 value
1197 #+TITLE: {{{macro1}}}
1199 (let ((output (org-export-as (org-test-default-backend))))
1200 (substring output
(string-match ".*\n\\'" output
))))))
1201 ;; Expand macros with templates in included files.
1204 (org-test-with-temp-text
1205 (format "#+INCLUDE: \"%s/examples/macro-templates.org\"
1206 {{{included-macro}}}" org-test-dir
)
1207 (let ((output (org-export-as (org-test-default-backend))))
1208 (substring output
(string-match ".*\n\\'" output
))))))
1209 ;; Date macro takes a optional formatting argument
1212 (org-test-with-temp-text "{{{date(%d-%m-%y)}}}\n* d :noexport:\n#+DATE: <2015-02-09>"
1213 (org-export-as (org-test-default-backend)))))
1214 ;; Only single timestamps are formatted
1216 (equal "<2015-02x-09>\n"
1217 (org-test-with-temp-text "{{{date(%d-%m-%y)}}}\n* d :noexport:\n#+DATE: <2015-02x-09>"
1218 (org-export-as (org-test-default-backend)))))
1219 ;; Throw an error when a macro definition is missing.
1221 (org-test-with-temp-text "{{{missing}}}"
1222 (org-export-as (org-test-default-backend))))
1223 ;; Macros defined in commented subtrees are ignored.
1225 (org-test-with-temp-text
1226 "* COMMENT H\n#+MACRO: macro1\n* H2\nvalue\n{{{macro1}}}"
1227 (org-export-as (org-test-default-backend))))
1229 (org-test-with-temp-text
1230 "* COMMENT H\n** H2\n#+MACRO: macro1\n* H3\nvalue\n{{{macro1}}}"
1231 (org-export-as (org-test-default-backend)))))
1233 (ert-deftest test-org-export
/before-processing-hook
()
1234 "Test `org-export-before-processing-hook'."
1237 "#+MACRO: mac val\nTest\n"
1238 (org-test-with-temp-text "#+MACRO: mac val\n{{{mac}}} Test"
1239 (let ((org-export-before-processing-hook
1241 (while (re-search-forward "{{{" nil t
)
1242 (let ((object (org-element-context)))
1243 (when (eq (org-element-type object
) 'macro
)
1245 (org-element-property :begin object
)
1246 (org-element-property :end object
)))))))))
1247 (org-export-as (org-test-default-backend)))))))
1249 (ert-deftest test-org-export
/before-parsing-hook
()
1250 "Test `org-export-before-parsing-hook'."
1252 (equal "Body 1\nBody 2\n"
1253 (org-test-with-temp-text "* Headline 1\nBody 1\n* Headline 2\nBody 2"
1254 (let ((org-export-before-parsing-hook
1256 (goto-char (point-min))
1257 (while (re-search-forward org-outline-regexp-bol nil t
)
1259 (point-at-bol) (progn (forward-line) (point))))))))
1260 (org-export-as (org-test-default-backend)))))))
1264 ;;; Affiliated Keywords
1266 (ert-deftest test-org-export
/read-attribute
()
1267 "Test `org-export-read-attribute' specifications."
1271 (org-export-read-attribute
1273 (org-test-with-temp-text "#+ATTR_HTML: :a 1 :b 2\nParagraph"
1274 (org-element-at-point)))
1276 ;; Return nil on empty attribute.
1278 (org-export-read-attribute
1280 (org-test-with-temp-text "Paragraph" (org-element-at-point))))
1281 ;; Return nil on "nil" string.
1283 (equal '(:a nil
:b nil
)
1284 (org-export-read-attribute
1286 (org-test-with-temp-text "#+ATTR_HTML: :a nil :b nil\nParagraph"
1287 (org-element-at-point)))))
1288 ;; Return nil on empty string.
1290 (equal '(:a nil
:b nil
)
1291 (org-export-read-attribute
1293 (org-test-with-temp-text "#+ATTR_HTML: :a :b\nParagraph"
1294 (org-element-at-point)))))
1295 ;; Return empty string when value is "".
1298 (org-export-read-attribute
1300 (org-test-with-temp-text "#+ATTR_HTML: :a \"\"\nParagraph"
1301 (org-element-at-point)))))
1302 ;; Return \"\" when value is """".
1305 (org-export-read-attribute
1307 (org-test-with-temp-text "#+ATTR_HTML: :a \"\"\"\"\nParagraph"
1308 (org-element-at-point)))))
1309 ;; Ignore text before first property.
1312 (org-export-read-attribute
1314 (org-test-with-temp-text "#+ATTR_HTML: ignore :a 1\nParagraph"
1315 (org-element-at-point))))))
1317 (ert-deftest test-org-export
/get-caption
()
1318 "Test `org-export-get-caption' specifications."
1319 ;; Without optional argument, return long caption
1323 (org-test-with-temp-text "#+CAPTION[s]: l\nPara"
1324 (org-export-get-caption (org-element-at-point)))))
1325 ;; With optional argument, return short caption.
1329 (org-test-with-temp-text "#+CAPTION[s]: l\nPara"
1330 (org-export-get-caption (org-element-at-point) t
))))
1331 ;; Multiple lines are separated by white spaces.
1335 (org-test-with-temp-text "#+CAPTION: a\n#+CAPTION: b\nPara"
1336 (org-export-get-caption (org-element-at-point))))))
1342 (ert-deftest test-org-export
/define-backend
()
1343 "Test back-end definition and accessors."
1346 (equal '((headline . my-headline-test
))
1347 (let (org-export-registered-backends)
1348 (org-export-define-backend 'test
'((headline . my-headline-test
)))
1349 (org-export-get-all-transcoders 'test
))))
1352 (equal '((:filter-headline . my-filter
))
1353 (let (org-export-registered-backends)
1354 (org-export-define-backend 'test
1355 '((headline . my-headline-test
))
1356 :filters-alist
'((:filter-headline . my-filter
)))
1357 (org-export-backend-filters (org-export-get-backend 'test
)))))
1360 (equal '((:prop value
))
1361 (let (org-export-registered-backends)
1362 (org-export-define-backend 'test
1363 '((headline . my-headline-test
))
1364 :options-alist
'((:prop value
)))
1365 (org-export-backend-options (org-export-get-backend 'test
)))))
1368 (equal '(?k
"Test Export" test
)
1369 (let (org-export-registered-backends)
1370 (org-export-define-backend 'test
1371 '((headline . my-headline-test
))
1372 :menu-entry
'(?k
"Test Export" test
))
1373 (org-export-backend-menu (org-export-get-backend 'test
)))))
1376 (equal '(("TEST" . org-element-export-block-parser
))
1377 (let (org-export-registered-backends org-element-block-name-alist
)
1378 (org-export-define-backend 'test
1379 '((headline . my-headline-test
))
1380 :export-block
'("test"))
1381 org-element-block-name-alist
))))
1383 (ert-deftest test-org-export
/define-derived-backend
()
1384 "Test `org-export-define-derived-backend' specifications."
1385 ;; Error when parent back-end is not defined.
1387 (let (org-export-registered-backends)
1388 (org-export-define-derived-backend 'test
'parent
)))
1389 ;; Append translation table to parent's.
1391 (equal '((:headline . test
) (:headline . parent
))
1392 (let (org-export-registered-backends)
1393 (org-export-define-backend 'parent
'((:headline . parent
)))
1394 (org-export-define-derived-backend 'test
'parent
1395 :translate-alist
'((:headline . test
)))
1396 (org-export-get-all-transcoders 'test
))))
1397 ;; Options defined in the new back have priority over those defined
1401 (let (org-export-registered-backends)
1402 (org-export-define-backend 'parent
1403 '((:headline . parent
))
1404 :options-alist
'((:a nil nil
'parent
)))
1405 (org-export-define-derived-backend 'test
'parent
1406 :options-alist
'((:a nil nil
'test
)))
1407 (plist-get (org-export--get-global-options
1408 (org-export-get-backend 'test
))
1411 (ert-deftest test-org-export
/derived-backend-p
()
1412 "Test `org-export-derived-backend-p' specifications."
1413 ;; Non-nil with direct match.
1415 (let (org-export-registered-backends)
1416 (org-export-define-backend 'test
'((headline . test
)))
1417 (org-export-derived-backend-p 'test
'test
)))
1419 (let (org-export-registered-backends)
1420 (org-export-define-backend 'test
'((headline . test
)))
1421 (org-export-define-derived-backend 'test2
'test
)
1422 (org-export-derived-backend-p 'test2
'test2
)))
1423 ;; Non-nil with a direct parent.
1425 (let (org-export-registered-backends)
1426 (org-export-define-backend 'test
'((headline . test
)))
1427 (org-export-define-derived-backend 'test2
'test
)
1428 (org-export-derived-backend-p 'test2
'test
)))
1429 ;; Non-nil with an indirect parent.
1431 (let (org-export-registered-backends)
1432 (org-export-define-backend 'test
'((headline . test
)))
1433 (org-export-define-derived-backend 'test2
'test
)
1434 (org-export-define-derived-backend 'test3
'test2
)
1435 (org-export-derived-backend-p 'test3
'test
)))
1438 (let (org-export-registered-backends)
1439 (org-export-define-backend 'test
'((headline . test
)))
1440 (org-export-define-backend 'test2
'((headline . test2
)))
1441 (org-export-derived-backend-p 'test2
'test
)))
1443 (let (org-export-registered-backends)
1444 (org-export-define-backend 'test
'((headline . test
)))
1445 (org-export-define-backend 'test2
'((headline . test2
)))
1446 (org-export-define-derived-backend 'test3
'test2
)
1447 (org-export-derived-backend-p 'test3
'test
))))
1449 (ert-deftest test-org-export
/get-all-transcoders
()
1450 "Test `org-export-get-all-transcoders' specifications."
1451 ;; Return nil when back-end cannot be found.
1452 (should-not (org-export-get-all-transcoders nil
))
1453 ;; Same as `org-export-transcoders' if no parent.
1455 (equal '((headline . ignore
))
1456 (org-export-get-all-transcoders
1457 (org-export-create-backend
1458 :transcoders
'((headline . ignore
))))))
1459 ;; But inherit from all ancestors whenever possible.
1461 (equal '((section . ignore
) (headline . ignore
))
1462 (let (org-export-registered-backends)
1463 (org-export-define-backend 'b1
'((headline . ignore
)))
1464 (org-export-get-all-transcoders
1465 (org-export-create-backend
1466 :parent
'b1
:transcoders
'((section . ignore
)))))))
1468 (equal '((paragraph . ignore
) (section . ignore
) (headline . ignore
))
1469 (let (org-export-registered-backends)
1470 (org-export-define-backend 'b1
'((headline . ignore
)))
1471 (org-export-define-derived-backend 'b2
'b1
1472 :translate-alist
'((section . ignore
)))
1473 (org-export-get-all-transcoders
1474 (org-export-create-backend
1475 :parent
'b2
:transcoders
'((paragraph . ignore
)))))))
1476 ;; Back-end transcoders overrule inherited ones.
1479 (let (org-export-registered-backends)
1480 (org-export-define-backend 'b1
'((headline . a
)))
1481 (cdr (assq 'headline
1482 (org-export-get-all-transcoders
1483 (org-export-create-backend
1484 :parent
'b1
:transcoders
'((headline . b
))))))))))
1486 (ert-deftest test-org-export
/get-all-options
()
1487 "Test `org-export-get-all-options' specifications."
1488 ;; Return nil when back-end cannot be found.
1489 (should-not (org-export-get-all-options nil
))
1490 ;; Same as `org-export-options' if no parent.
1492 (equal '((headline . ignore
))
1493 (org-export-get-all-options
1494 (org-export-create-backend
1495 :options
'((headline . ignore
))))))
1496 ;; But inherit from all ancestors whenever possible.
1498 (equal '((:key2 value2
) (:key1 value1
))
1499 (let (org-export-registered-backends)
1500 (org-export-define-backend 'b1 nil
:options-alist
'((:key1 value1
)))
1501 (org-export-get-all-options
1502 (org-export-create-backend
1503 :parent
'b1
:options
'((:key2 value2
)))))))
1505 (equal '((:key3 value3
) (:key2 value2
) (:key1 value1
))
1506 (let (org-export-registered-backends)
1507 (org-export-define-backend 'b1 nil
:options-alist
'((:key1 value1
)))
1508 (org-export-define-derived-backend 'b2
'b1
1509 :options-alist
'((:key2 value2
)))
1510 (org-export-get-all-options
1511 (org-export-create-backend
1512 :parent
'b2
:options
'((:key3 value3
)))))))
1513 ;; Back-end options overrule inherited ones.
1516 (let (org-export-registered-backends)
1517 (org-export-define-backend 'b1 nil
:options-alist
'((:key1 . a
)))
1519 (org-export-get-all-options
1520 (org-export-create-backend
1521 :parent
'b1
:options
'((:key1 . b
))))))))))
1523 (ert-deftest test-org-export
/get-all-filters
()
1524 "Test `org-export-get-all-filters' specifications."
1525 ;; Return nil when back-end cannot be found.
1526 (should-not (org-export-get-all-filters nil
))
1527 ;; Same as `org-export-filters' if no parent.
1529 (equal '((:filter-headline . ignore
))
1530 (org-export-get-all-filters
1531 (org-export-create-backend
1532 :filters
'((:filter-headline . ignore
))))))
1533 ;; But inherit from all ancestors whenever possible.
1535 (equal '((:filter-section . ignore
) (:filter-headline . ignore
))
1536 (let (org-export-registered-backends)
1537 (org-export-define-backend 'b1
1538 nil
:filters-alist
'((:filter-headline . ignore
)))
1539 (org-export-get-all-filters
1540 (org-export-create-backend
1541 :parent
'b1
:filters
'((:filter-section . ignore
)))))))
1543 (equal '((:filter-paragraph . ignore
)
1544 (:filter-section . ignore
)
1545 (:filter-headline . ignore
))
1546 (let (org-export-registered-backends)
1547 (org-export-define-backend 'b1
1548 nil
:filters-alist
'((:filter-headline . ignore
)))
1549 (org-export-define-derived-backend 'b2
'b1
1550 :filters-alist
'((:filter-section . ignore
)))
1551 (org-export-get-all-filters
1552 (org-export-create-backend
1553 :parent
'b2
:filters
'((:filter-paragraph . ignore
)))))))
1554 ;; Back-end filters overrule inherited ones.
1557 (let (org-export-registered-backends)
1558 (org-export-define-backend 'b1
'((:filter-headline . a
)))
1559 (cdr (assq :filter-headline
1560 (org-export-get-all-filters
1561 (org-export-create-backend
1562 :parent
'b1
:filters
'((:filter-headline . b
))))))))))
1564 (ert-deftest test-org-export
/with-backend
()
1565 "Test `org-export-with-backend' definition."
1566 ;; Error when calling an undefined back-end
1567 (should-error (org-export-with-backend nil
"Test"))
1568 ;; Error when called back-end doesn't have an appropriate
1571 (org-export-with-backend
1572 (org-export-create-backend :transcoders
'((headline . ignore
)))
1574 ;; Otherwise, export using correct transcoder
1577 (let (org-export-registered-backends)
1578 (org-export-define-backend 'test
1579 '((plain-text .
(lambda (text contents info
) "Failure"))))
1580 (org-export-define-backend 'test2
1581 '((plain-text .
(lambda (text contents info
) "Success"))))
1582 (org-export-with-backend 'test2
"Test"))))
1583 ;; Provide correct back-end if transcoder needs to use recursive
1587 (let ((test-back-end
1588 (org-export-create-backend
1590 (list (cons 'headline
1591 (lambda (headline contents info
)
1593 (org-element-property :title headline
)
1595 (cons 'plain-text
(lambda (text info
) "Success"))))))
1596 (org-export-string-as
1598 (org-export-create-backend
1600 (list (cons 'headline
1601 (lambda (headline contents info
)
1602 (org-export-with-backend
1603 test-back-end headline contents info
))))))))))
1605 (ert-deftest test-org-export
/data-with-backend
()
1606 "Test `org-export-data-with-backend' specifications."
1607 ;; Error when calling an undefined back-end.
1608 (should-error (org-export-data-with-backend nil
"nil" nil
))
1609 ;; Otherwise, export data recursively, using correct back-end.
1613 (org-export-data-with-backend
1615 (org-export-create-backend
1617 '((plain-text .
(lambda (text info
) "Success"))
1618 (bold .
(lambda (bold contents info
) (concat contents
"!")))))
1619 '(:with-emphasize t
)))))
1625 (ert-deftest test-org-export
/export-snippet
()
1626 "Test export snippets transcoding."
1628 (org-test-with-temp-text "@@test:A@@@@t:B@@"
1629 (let ((backend (org-test-default-backend)))
1630 (setf (org-export-backend-name backend
) 'test
)
1631 (setf (org-export-backend-transcoders backend
)
1632 (cons (cons 'export-snippet
1633 (lambda (snippet contents info
)
1634 (when (eq (org-export-snippet-backend snippet
) 'test
)
1635 (org-element-property :value snippet
))))
1636 (org-export-backend-transcoders backend
)))
1637 (let ((org-export-snippet-translation-alist nil
))
1638 (should (equal (org-export-as backend
) "A\n")))
1639 (let ((org-export-snippet-translation-alist '(("t" .
"test"))))
1640 (should (equal (org-export-as backend
) "AB\n")))))
1641 ;; Ignored export snippets do not remove any blank.
1643 (equal "begin end\n"
1644 (org-test-with-parsed-data "begin @@test:A@@ end"
1645 (org-export-data-with-backend
1647 (org-export-create-backend
1649 '((paragraph .
(lambda (paragraph contents info
) contents
))
1650 (section .
(lambda (section contents info
) contents
))))
1657 (ert-deftest test-org-export
/footnote-first-reference-p
()
1658 "Test `org-export-footnote-first-reference-p' specifications."
1662 (org-test-with-temp-text "Text[fn:1][fn:1]\n\n[fn:1] Definition"
1665 (org-export-create-backend
1667 `(,(cons 'footnote-reference
1669 (push (org-export-footnote-first-reference-p f i
)
1672 (section .
(lambda (s c i
) c
))
1673 (paragraph .
(lambda (p c i
) c
))))
1674 nil nil nil
'(:with-footnotes t
))
1675 (nreverse result
)))))
1676 ;; Limit check to DATA, when non-nil.
1680 (org-test-with-parsed-data "Text[fn:1]\n* H\nText[fn:1]\n\n[fn:1] D1"
1682 (org-element-map tree
'footnote-reference
1685 (org-export-footnote-first-reference-p
1686 ref info
(org-element-map tree
'headline
#'identity info t
))
1689 (nreverse result
)))))
1693 (org-test-with-parsed-data "Text[fn:1]\n* H\nText[fn:1]\n\n[fn:1] D1"
1695 (org-element-map tree
'footnote-reference
1697 (push (org-export-footnote-first-reference-p ref info
) result
))
1699 (nreverse result
)))))
1700 ;; If optional argument BODY-FIRST is non-nil, first find footnote
1701 ;; in the main body of the document. Otherwise, enter footnote
1702 ;; definitions when they are encountered.
1706 (org-test-with-temp-text
1707 ":BODY:\nText[fn:1][fn:2]\n:END:\n\n[fn:1] Definition[fn:2]\n\n[fn:2] Inner"
1710 (org-export-create-backend
1712 `(,(cons 'footnote-reference
1714 (when (org-element-lineage f
'(drawer))
1715 (push (org-export-footnote-first-reference-p f i nil
)
1718 (drawer .
(lambda (d c i
) c
))
1719 (footnote-definition .
(lambda (d c i
) c
))
1720 (section .
(lambda (s c i
) c
))
1721 (paragraph .
(lambda (p c i
) c
))))
1722 nil nil nil
'(:with-footnotes t
))
1723 (nreverse result
)))))
1727 (org-test-with-temp-text
1728 ":BODY:\nText[fn:1][fn:2]\n:END:\n\n[fn:1] Definition[fn:2]\n\n[fn:2] Inner"
1731 (org-export-create-backend
1733 `(,(cons 'footnote-reference
1735 (when (org-element-lineage f
'(drawer))
1736 (push (org-export-footnote-first-reference-p f i nil t
)
1739 (drawer .
(lambda (d c i
) c
))
1740 (footnote-definition .
(lambda (d c i
) c
))
1741 (section .
(lambda (s c i
) c
))
1742 (paragraph .
(lambda (p c i
) c
))))
1743 nil nil nil
'(:with-footnotes t
))
1744 (nreverse result
))))))
1746 (ert-deftest test-org-export
/get-footnote-number
()
1747 "Test `org-export-get-footnote-number' specifications."
1750 (org-test-with-parsed-data
1751 "Text[fn:1][fn:2][fn:1]\n\n[fn:1] Def\n[fn:2] Def"
1752 (org-element-map tree
'footnote-reference
1753 (lambda (ref) (org-export-get-footnote-number ref info
))
1755 ;; Anonymous footnotes all get a new number.
1758 (org-test-with-parsed-data
1759 "Text[fn::anon1][fn::anon2]"
1760 (org-element-map tree
'footnote-reference
1761 (lambda (ref) (org-export-get-footnote-number ref info
))
1763 ;; Test nested footnotes order.
1766 '((1 .
"fn:1") (2 .
"fn:2") (3 .
"fn:3") (3 .
"fn:3") (4))
1767 (org-test-with-parsed-data
1768 "Text[fn:1:A[fn:2]] [fn:3].\n\n[fn:2] B [fn:3] [fn::D].\n\n[fn:3] C."
1769 (org-element-map tree
'footnote-reference
1771 (cons (org-export-get-footnote-number ref info
)
1772 (org-element-property :label ref
)))
1774 ;; Limit number to provided DATA, when non-nil.
1778 (org-test-with-parsed-data
1779 "Text[fn:1]\n* H\nText[fn:2]\n\n[fn:1] D1\n[fn:2] D2"
1780 (org-element-map tree
'footnote-reference
1782 (org-export-get-footnote-number
1783 ref info
(org-element-map tree
'headline
#'identity info t
)))
1788 (org-test-with-parsed-data
1789 "Text[fn:1]\n* H\nText[fn:2]\n\n[fn:1] D1\n[fn:2]"
1790 (org-element-map tree
'footnote-reference
1791 (lambda (ref) (org-export-get-footnote-number ref info
))
1793 ;; With a non-nil BODY-FIRST optional argument, first check body,
1794 ;; then footnote definitions.
1797 '(("fn:1" .
1) ("fn:2" .
2) ("fn:3" .
3) ("fn:3" .
3))
1798 (org-test-with-parsed-data
1799 "Text[fn:1][fn:2][fn:3]\n\n[fn:1] Def[fn:3]\n[fn:2] Def\n[fn:3] Def"
1800 (org-element-map tree
'footnote-reference
1802 (cons (org-element-property :label ref
)
1803 (org-export-get-footnote-number ref info nil t
)))
1807 '(("fn:1" .
1) ("fn:2" .
3) ("fn:3" .
2) ("fn:3" .
2))
1808 (org-test-with-parsed-data
1809 "Text[fn:1][fn:2][fn:3]\n\n[fn:1] Def[fn:3]\n[fn:2] Def\n[fn:3] Def"
1810 (org-element-map tree
'footnote-reference
1812 (cons (org-element-property :label ref
)
1813 (org-export-get-footnote-number ref info nil
)))
1816 (ert-deftest test-org-export
/collect-footnote-definitions
()
1817 "Test `org-export-collect-footnote-definitions' specifications."
1820 (org-test-with-parsed-data "Text[fn:1:A[fn:2]] [fn:3].
1822 \[fn:2] B [fn:3] [fn::D].
1825 (length (org-export-collect-footnote-definitions info
)))))
1826 ;; Limit number to provided DATA, when non-nil.
1830 (org-test-with-parsed-data
1831 "Text[fn:1]\n* H\nText[fn:2]\n\n[fn:1] D1\n[fn:2] D2"
1833 (org-export-collect-footnote-definitions
1834 info
(org-element-map tree
'headline
#'identity info t
))))))
1837 '((1 "fn:1") (2 "fn:2"))
1838 (org-test-with-parsed-data
1839 "Text[fn:1]\n* H\nText[fn:2]\n\n[fn:1] D1\n[fn:2] D2"
1840 (mapcar #'butlast
(org-export-collect-footnote-definitions info
)))))
1841 ;; With optional argument BODY-FIRST, first check body, then
1842 ;; footnote definitions.
1844 (equal '("fn:1" "fn:3" "fn:2" nil
)
1845 (org-test-with-parsed-data "Text[fn:1:A[fn:2]] [fn:3].
1847 \[fn:2] B [fn:3] [fn::D].
1850 (mapcar (lambda (e) (nth 1 e
))
1851 (org-export-collect-footnote-definitions info nil t
)))))
1853 (equal '("fn:1" "fn:3" "fn:2" nil
)
1854 (org-test-with-parsed-data "Text[fn:1:A[fn:2]] [fn:3].
1856 \[fn:2] B [fn:3] [fn::D].
1859 (mapcar (lambda (e) (nth 1 e
))
1860 (org-export-collect-footnote-definitions info
))))))
1862 (ert-deftest test-org-export
/footnotes
()
1863 "Miscellaneous tests on footnotes."
1864 (let ((org-footnote-section nil
)
1865 (org-export-with-footnotes t
))
1866 ;; Read every type of footnote.
1869 '((1 .
"A\n") (2 .
"B") (3 .
"C") (4 .
"D"))
1870 (org-test-with-parsed-data
1871 "Text[fn:1] [1] [fn:label:C] [fn::D]\n\n[fn:1] A\n\n[1] B"
1872 (org-element-map tree
'footnote-reference
1874 (let ((def (org-export-get-footnote-definition ref info
)))
1875 (cons (org-export-get-footnote-number ref info
)
1876 (if (eq (org-element-property :type ref
) 'inline
) (car def
)
1877 (car (org-element-contents
1878 (car (org-element-contents def
))))))))
1880 ;; Test nested footnote in invisible definitions.
1883 (org-test-with-temp-text "Text[1]\n\n[1] B [2]\n\n[2] C."
1884 (narrow-to-region (point) (line-end-position))
1887 (org-export-create-backend
1892 (throw 'exit
(length
1893 (org-export-collect-footnote-definitions
1895 ;; Test export of footnotes defined outside parsing scope.
1898 "ParagraphOut of scope\n"
1899 (org-test-with-temp-text "[fn:1] Out of scope
1901 <point>Paragraph[fn:1]"
1902 (let ((backend (org-test-default-backend)))
1903 (setf (org-export-backend-transcoders backend
)
1905 (list (cons 'footnote-reference
1906 (lambda (fn contents info
)
1907 (org-element-interpret-data
1908 (org-export-get-footnote-definition fn info
))))
1909 (cons 'footnote-definition
#'ignore
)
1910 (cons 'headline
#'ignore
))
1911 (org-export-backend-transcoders backend
)))
1912 (org-export-as backend
'subtree
)))))
1913 ;; Footnotes without a definition should throw an error.
1915 (org-test-with-parsed-data "Text[fn:1]"
1916 (org-export-get-footnote-definition
1917 (org-element-map tree
'footnote-reference
#'identity info t
) info
)))
1918 ;; Footnote section should be ignored in TOC and in headlines
1921 (= 1 (let ((org-footnote-section "Footnotes"))
1922 (length (org-test-with-parsed-data "* H1\n* Footnotes\n"
1923 (org-export-collect-headlines info
))))))
1926 (let ((org-footnote-section "Footnotes"))
1927 (org-test-with-parsed-data "* H1\n* Footnotes\n* H2"
1928 (org-element-map tree
'headline
1930 (when (equal (org-element-property :raw-value hl
) "H2")
1931 (org-export-get-headline-number hl info
)))
1936 ;;; Headlines and Inlinetasks
1938 (ert-deftest test-org-export
/get-relative-level
()
1939 "Test `org-export-get-relative-level' specifications."
1943 (let ((org-odd-levels-only nil
))
1944 (org-test-with-parsed-data "* Headline 1\n** Headline 2"
1945 (org-element-map tree
'headline
1946 (lambda (h) (org-export-get-relative-level h info
))
1951 (let ((org-odd-levels-only nil
))
1952 (org-test-with-parsed-data "** Headline 1\n**** Headline 2"
1953 (org-element-map tree
'headline
1954 (lambda (h) (org-export-get-relative-level h info
))
1957 (ert-deftest test-org-export
/low-level-p
()
1958 "Test `org-export-low-level-p' specifications."
1962 (let ((org-odd-levels-only nil
))
1963 (org-test-with-parsed-data "* Headline 1\n** Headline 2"
1964 (org-element-map tree
'headline
1965 (lambda (h) (if (org-export-low-level-p h info
) 'yes
'no
))
1966 (plist-put info
:headline-levels
1)))))))
1968 (ert-deftest test-org-export
/get-headline-number
()
1969 "Test `org-export-get-headline-number' specifications."
1974 (let ((org-odd-levels-only nil
))
1975 (org-test-with-parsed-data "* Headline 1\n** Headline 2"
1976 (org-element-map tree
'headline
1977 (lambda (h) (org-export-get-headline-number h info
))
1979 ;; Missing levels are replaced with 0.
1983 (let ((org-odd-levels-only nil
))
1984 (org-test-with-parsed-data "* Headline 1\n*** Headline 2"
1985 (org-element-map tree
'headline
1986 (lambda (h) (org-export-get-headline-number h info
))
1989 (ert-deftest test-org-export
/numbered-headline-p
()
1990 "Test `org-export-numbered-headline-p' specifications."
1991 ;; If `:section-numbers' is nil, never number headlines.
1993 (org-test-with-parsed-data "* Headline"
1994 (org-element-map tree
'headline
1995 (lambda (h) (org-export-numbered-headline-p h info
))
1996 (plist-put info
:section-numbers nil
))))
1997 ;; If `:section-numbers' is a number, only number headlines with
1998 ;; a level greater that it.
2002 (org-test-with-parsed-data "* Headline 1\n** Headline 2"
2003 (org-element-map tree
'headline
2004 (lambda (h) (if (org-export-numbered-headline-p h info
) 'yes
'no
))
2005 (plist-put info
:section-numbers
1)))))
2006 ;; Otherwise, headlines are always numbered.
2008 (org-test-with-parsed-data "* Headline"
2009 (org-element-map tree
'headline
2010 (lambda (h) (org-export-numbered-headline-p h info
))
2011 (plist-put info
:section-numbers t
))))
2012 ;; With #+OPTIONS: num:nil all headlines are unnumbered.
2014 (org-test-with-parsed-data "* H\n#+OPTIONS: num:nil"
2015 (org-export-numbered-headline-p
2016 (org-element-map tree
'headline
'identity info t
)
2018 ;; Headlines with a non-nil UNNUMBERED property are not numbered.
2020 (org-test-with-parsed-data "* H\n:PROPERTIES:\n:UNNUMBERED: t\n:END:"
2021 (org-export-numbered-headline-p
2022 (org-element-map tree
'headline
#'identity info t
)
2024 ;; UNNUMBERED ignores inheritance. Any non-nil value among
2025 ;; ancestors disables numbering.
2027 (org-test-with-parsed-data
2038 (lambda (h) (not (org-export-numbered-headline-p h info
)))
2039 (org-element-map tree
'headline
#'identity info
)))))
2041 (ert-deftest test-org-export
/number-to-roman
()
2042 "Test `org-export-number-to-roman' specifications."
2043 ;; If number is negative, return it as a string.
2044 (should (equal (org-export-number-to-roman -
1) "-1"))
2045 ;; Otherwise, return it as a roman number.
2046 (should (equal (org-export-number-to-roman 1449) "MCDXLIX")))
2048 (ert-deftest test-org-export
/get-optional-title
()
2049 "Test `org-export-get-alt-title' specifications."
2050 ;; If ALT_TITLE property is defined, use it.
2053 (org-test-with-parsed-data
2054 "* Headline\n:PROPERTIES:\n:ALT_TITLE: opt\n:END:"
2055 (org-export-get-alt-title
2056 (org-element-map tree
'headline
'identity info t
)
2058 ;; Otherwise, fall-back to regular title.
2060 (equal '("Headline")
2061 (org-test-with-parsed-data "* Headline"
2062 (org-export-get-alt-title
2063 (org-element-map tree
'headline
'identity info t
)
2066 (ert-deftest test-org-export
/get-tags
()
2067 "Test `org-export-get-tags' specifications."
2068 (let ((org-export-exclude-tags '("noexport"))
2069 (org-export-select-tags '("export")))
2070 ;; Standard test: tags which are not a select tag, an exclude tag,
2071 ;; or specified as optional argument shouldn't be ignored.
2073 (org-test-with-parsed-data "* Headline :tag:"
2074 (org-export-get-tags (org-element-map tree
'headline
'identity info t
)
2076 ;; Exclude tags are removed.
2078 (org-test-with-parsed-data "* Headline :noexport:"
2079 (org-export-get-tags (org-element-map tree
'headline
'identity info t
)
2081 ;; Select tags are removed.
2083 (org-test-with-parsed-data "* Headline :export:"
2084 (org-export-get-tags (org-element-map tree
'headline
'identity info t
)
2089 (org-test-with-parsed-data "* Headline :tag:export:"
2090 (org-export-get-tags (org-element-map tree
'headline
'identity info t
)
2092 ;; Tags provided in the optional argument are also ignored.
2094 (org-test-with-parsed-data "* Headline :ignore:"
2095 (org-export-get-tags (org-element-map tree
'headline
'identity info t
)
2097 ;; Allow tag inheritance.
2101 (org-test-with-parsed-data "* Headline :tag:\n** Sub-heading"
2102 (org-element-map tree
'headline
2103 (lambda (hl) (org-export-get-tags hl info nil t
)) info
))))
2104 ;; Tag inheritance checks FILETAGS keywords.
2108 (org-test-with-parsed-data "#+FILETAGS: :a:b:\n* Headline :tag:"
2109 (org-element-map tree
'headline
2110 (lambda (hl) (org-export-get-tags hl info nil t
)) info
))))))
2112 (ert-deftest test-org-export
/get-node-property
()
2113 "Test`org-export-get-node-property' specifications."
2117 (org-test-with-parsed-data "* Headline
2121 (org-export-get-node-property
2122 :PROP
(org-element-map tree
'headline
'identity nil t
)))))
2123 ;; Test inheritance.
2126 (org-test-with-parsed-data "* Parent
2132 (org-export-get-node-property
2133 :PROP
(org-element-map tree
'paragraph
'identity nil t
) t
))))
2134 ;; Cannot return a value before the first headline.
2136 (org-test-with-parsed-data "Paragraph
2141 (org-export-get-node-property
2142 :PROP
(org-element-map tree
'paragraph
'identity nil t
)))))
2144 (ert-deftest test-org-export
/get-category
()
2145 "Test `org-export-get-category' specifications."
2149 (org-test-with-parsed-data "* Headline
2153 (org-export-get-category
2154 (org-element-map tree
'headline
'identity nil t
) info
))))
2155 ;; Test inheritance from a parent headline.
2157 (equal '("value" "value")
2158 (org-test-with-parsed-data "* Headline1
2163 (org-element-map tree
'headline
2164 (lambda (hl) (org-export-get-category hl info
)) info
))))
2165 ;; Test inheritance from #+CATEGORY keyword
2168 (org-test-with-parsed-data "#+CATEGORY: value
2170 (org-export-get-category
2171 (org-element-map tree
'headline
'identity nil t
) info
))))
2172 ;; Test inheritance from file name.
2175 (org-test-with-parsed-data "* Headline"
2176 (let ((info (plist-put info
:input-file
"~/test.org")))
2177 (org-export-get-category
2178 (org-element-map tree
'headline
'identity nil t
) info
)))))
2182 (org-test-with-parsed-data "* Headline"
2183 (org-export-get-category
2184 (org-element-map tree
'headline
'identity nil t
) info
)))))
2186 (ert-deftest test-org-export
/first-sibling-p
()
2187 "Test `org-export-first-sibling-p' specifications."
2192 (org-test-with-parsed-data "* H\n** H 2\n** H 3"
2193 (org-element-map tree
'headline
2194 (lambda (h) (if (org-export-first-sibling-p h info
) 'yes
'no
))
2198 (org-test-with-parsed-data "- item\n\n para"
2199 (org-element-map tree
'paragraph
2200 (lambda (h) (if (org-export-first-sibling-p h info
) 'yes
'no
))
2202 ;; Ignore sections for headlines.
2205 (org-test-with-parsed-data "* H\nSection\n** H 2"
2206 (org-element-map tree
'headline
2207 (lambda (h) (if (org-export-first-sibling-p h info
) 'yes
'no
))
2209 ;; Ignore headlines not exported.
2213 (let ((org-export-exclude-tags '("ignore")))
2214 (org-test-with-parsed-data "* Headline :ignore:\n* Headline 2"
2215 (org-element-map tree
'headline
2216 (lambda (h) (if (org-export-first-sibling-p h info
) 'yes
'no
))
2219 (ert-deftest test-org-export
/last-sibling-p
()
2220 "Test `org-export-last-sibling-p' specifications."
2225 (org-test-with-parsed-data "* Headline\n** Headline 2\n** Headline 3"
2226 (org-element-map tree
'headline
2227 (lambda (h) (if (org-export-last-sibling-p h info
) 'yes
'no
))
2231 (org-test-with-parsed-data "- item\n\n para"
2232 (org-element-map tree
'paragraph
2233 (lambda (h) (if (org-export-last-sibling-p h info
) 'yes
'no
))
2235 ;; Ignore headlines not exported.
2239 (let ((org-export-exclude-tags '("ignore")))
2240 (org-test-with-parsed-data "* Headline\n* Headline 2 :ignore:"
2241 (org-element-map tree
'headline
2242 (lambda (h) (if (org-export-last-sibling-p h info
) 'yes
'no
))
2245 (ert-deftest test-org-export
/handle-inlinetasks
()
2246 "Test inlinetask export."
2247 ;; Inlinetask with an exclude tag.
2248 (when (featurep 'org-inlinetask
)
2252 (let ((org-inlinetask-min-level 3)
2253 org-export-filter-body-functions
2254 org-export-filter-final-output-functions
)
2255 (org-test-with-temp-text "*** Inlinetask :noexp:\nContents\n*** end"
2256 (org-export-as (org-test-default-backend)
2257 nil nil nil
'(:exclude-tags
("noexp")))))))
2258 ;; Inlinetask with an include tag.
2261 "* H2\n*** Inline :exp:\n"
2262 (let ((org-inlinetask-min-level 3)
2263 (org-tags-column 0))
2264 (org-test-with-temp-text "* H1\n* H2\n*** Inline :exp:"
2265 (org-export-as (org-test-default-backend)
2266 nil nil nil
'(:select-tags
("exp")))))))
2267 ;; Ignore inlinetask with a TODO keyword and tasks excluded.
2270 (let ((org-todo-keywords '((sequence "TODO" "DONE")))
2271 (org-inlinetask-min-level 3)
2272 org-export-filter-body-functions
2273 org-export-filter-final-output-functions
)
2274 (org-test-with-temp-text "*** TODO Inline"
2275 (org-export-as (org-test-default-backend)
2276 nil nil nil
'(:with-tasks nil
))))))))
2282 (ert-deftest test-org-export
/get-date
()
2283 "Test `org-export-get-date' specifications."
2284 ;; Return a properly formatted string when
2285 ;; `org-export-date-timestamp-format' is non-nil and DATE keyword
2286 ;; consists in a single timestamp.
2289 (let ((org-export-date-timestamp-format "%d %m %Y"))
2290 (org-test-with-parsed-data "#+DATE: <2012-03-29 Thu>"
2291 (org-export-get-date info
)))))
2292 ;; Return a secondary string otherwise.
2295 (let ((org-export-date-timestamp-format nil
))
2296 (org-test-with-parsed-data "#+DATE: <2012-03-29 Thu>"
2297 (org-export-get-date info
)))))
2300 (org-test-with-parsed-data "#+DATE: Date"
2301 (org-export-get-date info
))))
2302 ;; Optional argument has precedence over
2303 ;; `org-export-date-timestamp-format'.
2306 (let ((org-export-date-timestamp-format "%d %m %Y"))
2307 (org-test-with-parsed-data "#+DATE: <2012-03-29 Thu>"
2308 (org-export-get-date info
"%d %m"))))))
2314 (ert-deftest test-org-export
/custom-protocol-maybe
()
2315 "Test `org-export-custom-protocol-maybe' specifications."
2319 (let ((org-link-types (copy-sequence org-link-types
)))
2320 (org-add-link-type "foo" nil
(lambda (p d f
) "success"))
2321 (org-export-string-as
2323 (org-export-create-backend
2326 '((section .
(lambda (s c i
) c
))
2327 (paragraph .
(lambda (p c i
) c
))
2328 (link .
(lambda (l c i
)
2329 (or (org-export-custom-protocol-maybe l c
'test
)
2334 (let ((org-link-types (copy-sequence org-link-types
)))
2336 "foo" nil
(lambda (p d f
) (and (eq f
'test
) "success")))
2337 (org-export-string-as
2339 (org-export-create-backend
2342 '((section .
(lambda (s c i
) c
))
2343 (paragraph .
(lambda (p c i
) c
))
2344 (link .
(lambda (l c i
)
2345 (or (org-export-custom-protocol-maybe l c
'no-test
)
2347 ;; Ignore anonymous back-ends.
2351 (let ((org-link-types (copy-sequence org-link-types
)))
2353 "foo" nil
(lambda (p d f
) (and (eq f
'test
) "success")))
2354 (org-export-string-as
2356 (org-export-create-backend
2358 '((section .
(lambda (s c i
) c
))
2359 (paragraph .
(lambda (p c i
) c
))
2360 (link .
(lambda (l c i
)
2361 (or (org-export-custom-protocol-maybe l c nil
)
2364 (ert-deftest test-org-export
/get-coderef-format
()
2365 "Test `org-export-get-coderef-format' specifications."
2366 ;; A link without description returns "%s"
2367 (should (equal (org-export-get-coderef-format "(ref:line)" nil
)
2369 ;; Return "%s" when path is matched within description.
2370 (should (equal (org-export-get-coderef-format "path" "desc (path)")
2372 ;; Otherwise return description.
2373 (should (equal (org-export-get-coderef-format "path" "desc")
2376 (ert-deftest test-org-export
/inline-image-p
()
2377 "Test `org-export-inline-image-p' specifications."
2379 (org-export-inline-image-p
2380 (org-test-with-temp-text "[[#id]]"
2381 (org-element-map (org-element-parse-buffer) 'link
'identity nil t
))
2382 '(("custom-id" .
"id")))))
2384 (ert-deftest test-org-export
/fuzzy-link
()
2385 "Test fuzzy links specifications."
2386 ;; Link to an headline should return headline's number.
2387 (org-test-with-parsed-data
2388 "Paragraph.\n* Head1\n* Head2\n* Head3\n[[Head2]]"
2390 ;; Note: Headline's number is in fact a list of numbers.
2392 (org-element-map tree
'link
2394 (org-export-get-ordinal
2395 (org-export-resolve-fuzzy-link link info
) info
)) info t
))))
2396 ;; Link to a target in an item should return item's number.
2397 (org-test-with-parsed-data
2398 "- Item1\n - Item11\n - <<test>>Item12\n- Item2\n\n\n[[test]]"
2400 ;; Note: Item's number is in fact a list of numbers.
2402 (org-element-map tree
'link
2404 (org-export-get-ordinal
2405 (org-export-resolve-fuzzy-link link info
) info
)) info t
))))
2406 ;; Link to a target in a footnote should return footnote's number.
2407 (org-test-with-parsed-data "
2408 Paragraph[1][2][fn:lbl3:C<<target>>][[test]][[target]]\n[1] A\n\n[2] <<test>>B"
2411 (org-element-map tree
'link
2413 (org-export-get-ordinal
2414 (org-export-resolve-fuzzy-link link info
) info
)) info
))))
2415 ;; Link to a named element should return sequence number of that
2417 (org-test-with-parsed-data
2418 "#+NAME: tbl1\n|1|2|\n#+NAME: tbl2\n|3|4|\n#+NAME: tbl3\n|5|6|\n[[tbl2]]"
2421 (org-element-map tree
'link
2423 (org-export-get-ordinal
2424 (org-export-resolve-fuzzy-link link info
) info
)) info t
))))
2425 ;; Link to a target not within an item, a table, a footnote
2426 ;; reference or definition should return section number.
2427 (org-test-with-parsed-data
2428 "* Head1\n* Head2\nParagraph<<target>>\n* Head3\n[[target]]"
2431 (org-element-map tree
'link
2433 (org-export-get-ordinal
2434 (org-export-resolve-fuzzy-link link info
) info
)) info t
))))
2435 ;; Space are not significant when matching a fuzzy link.
2437 (org-test-with-parsed-data "* Head 1\n[[Head\n 1]]"
2438 (org-element-map tree
'link
2439 (lambda (link) (org-export-resolve-fuzzy-link link info
))
2441 ;; Statistics cookies are ignored for headline match.
2443 (org-test-with-parsed-data "* Head [0/0]\n[[Head]]"
2444 (org-element-map tree
'link
2445 (lambda (link) (org-export-resolve-fuzzy-link link info
))
2448 (org-test-with-parsed-data "* Head [100%]\n[[Head]]"
2449 (org-element-map tree
'link
2450 (lambda (link) (org-export-resolve-fuzzy-link link info
))
2453 (ert-deftest test-org-export
/resolve-coderef
()
2454 "Test `org-export-resolve-coderef' specifications."
2455 (let ((org-coderef-label-format "(ref:%s)"))
2456 ;; A link to a "-n -k -r" block returns line number.
2459 (org-test-with-parsed-data
2460 "#+BEGIN_EXAMPLE -n -k -r\nText (ref:coderef)\n#+END_EXAMPLE"
2461 (org-export-resolve-coderef "coderef" info
))))
2464 (org-test-with-parsed-data
2465 "#+BEGIN_SRC emacs-lisp -n -k -r\n(+ 1 1) (ref:coderef)\n#+END_SRC"
2466 (org-export-resolve-coderef "coderef" info
))))
2467 ;; A link to a "-n -r" block returns line number.
2470 (org-test-with-parsed-data
2471 "#+BEGIN_EXAMPLE -n -r\nText (ref:coderef)\n#+END_EXAMPLE"
2472 (org-export-resolve-coderef "coderef" info
))))
2475 (org-test-with-parsed-data
2476 "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1) (ref:coderef)\n#+END_SRC"
2477 (org-export-resolve-coderef "coderef" info
))))
2478 ;; A link to a "-n" block returns coderef.
2481 (org-test-with-parsed-data
2482 "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1) (ref:coderef)\n#+END_SRC"
2483 (org-export-resolve-coderef "coderef" info
))))
2486 (org-test-with-parsed-data
2487 "#+BEGIN_EXAMPLE -n\nText (ref:coderef)\n#+END_EXAMPLE"
2488 (org-export-resolve-coderef "coderef" info
))))
2489 ;; A link to a "-r" block returns line number.
2492 (org-test-with-parsed-data
2493 "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1) (ref:coderef)\n#+END_SRC"
2494 (org-export-resolve-coderef "coderef" info
))))
2497 (org-test-with-parsed-data
2498 "#+BEGIN_EXAMPLE -r\nText (ref:coderef)\n#+END_EXAMPLE"
2499 (org-export-resolve-coderef "coderef" info
))))
2500 ;; A link to a block without a switch returns coderef.
2503 (org-test-with-parsed-data
2504 "#+BEGIN_SRC emacs-lisp\n(+ 1 1) (ref:coderef)\n#+END_SRC"
2505 (org-export-resolve-coderef "coderef" info
))))
2506 (org-test-with-parsed-data
2507 "#+BEGIN_EXAMPLE\nText (ref:coderef)\n#+END_EXAMPLE"
2508 (should (equal (org-export-resolve-coderef "coderef" info
) "coderef")))
2509 ;; Correctly handle continued line numbers. A "+n" switch should
2510 ;; resume numbering from previous block with numbered lines,
2511 ;; ignoring blocks not numbering lines in the process. A "-n"
2512 ;; switch resets count.
2515 (org-test-with-parsed-data "
2520 #+BEGIN_SRC emacs-lisp
2524 #+BEGIN_SRC emacs-lisp +n -r
2525 \(+ 1 1) (ref:addition)
2528 #+BEGIN_EXAMPLE -n -r
2529 Another text. (ref:text)
2531 (list (org-export-resolve-coderef "addition" info
)
2532 (org-export-resolve-coderef "text" info
)))))
2533 ;; Recognize coderef with user-specified syntax.
2536 (org-test-with-parsed-data
2537 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText. [ref:text]\n#+END_EXAMPLE"
2538 (org-export-resolve-coderef "text" info
))))
2539 ;; Unresolved coderefs throw an error.
2541 (org-test-with-parsed-data "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
2542 (org-export-resolve-coderef "unknown" info
)))))
2544 (ert-deftest test-org-export
/resolve-fuzzy-link
()
2545 "Test `org-export-resolve-fuzzy-link' specifications."
2546 ;; Match target objects.
2548 (org-test-with-parsed-data "<<target>> [[target]]"
2549 (org-export-resolve-fuzzy-link
2550 (org-element-map tree
'link
'identity info t
) info
)))
2551 ;; Match named elements.
2553 (org-test-with-parsed-data "#+NAME: target\nParagraph\n\n[[target]]"
2554 (org-export-resolve-fuzzy-link
2555 (org-element-map tree
'link
'identity info t
) info
)))
2556 ;; Match exact headline's name.
2558 (org-test-with-parsed-data "* My headline\n[[My headline]]"
2559 (org-export-resolve-fuzzy-link
2560 (org-element-map tree
'link
'identity info t
) info
)))
2561 ;; Targets objects have priority over named elements and headline
2565 (org-test-with-parsed-data
2566 "* target\n#+NAME: target\n<<target>>\n\n[[target]]"
2568 (org-export-resolve-fuzzy-link
2569 (org-element-map tree
'link
'identity info t
) info
)))))
2570 ;; Named elements have priority over headline titles.
2573 (org-test-with-parsed-data
2574 "* target\n#+NAME: target\nParagraph\n\n[[target]]"
2576 (org-export-resolve-fuzzy-link
2577 (org-element-map tree
'link
'identity info t
) info
)))))
2578 ;; If link's path starts with a "*", only match headline titles,
2582 (org-test-with-parsed-data
2583 "* target\n#+NAME: target\n<<target>>\n\n[[*target]]"
2585 (org-export-resolve-fuzzy-link
2586 (org-element-map tree
'link
'identity info t
) info
)))))
2587 ;; Error if no match.
2589 (org-test-with-parsed-data "[[target]]"
2590 (org-export-resolve-fuzzy-link
2591 (org-element-map tree
'link
'identity info t
) info
)))
2592 ;; Match fuzzy link even when before first headline.
2595 (org-test-with-parsed-data "[[hl]]\n* hl"
2597 (org-export-resolve-fuzzy-link
2598 (org-element-map tree
'link
'identity info t
) info
)))))
2599 ;; Handle url-encoded fuzzy links.
2601 (org-test-with-parsed-data "* A B\n[[A%20B]]"
2602 (org-export-resolve-fuzzy-link
2603 (org-element-map tree
'link
#'identity info t
) info
))))
2605 (ert-deftest test-org-export
/resolve-id-link
()
2606 "Test `org-export-resolve-id-link' specifications."
2607 ;; Regular test for custom-id link.
2609 (equal '("Headline1")
2610 (org-test-with-parsed-data "* Headline1
2616 (org-element-property
2618 (org-export-resolve-id-link
2619 (org-element-map tree
'link
'identity info t
) info
)))))
2620 ;; Throw an error on failing searches.
2622 (org-test-with-parsed-data "* Headline1
2628 (org-export-resolve-id-link
2629 (org-element-map tree
'link
'identity info t
) info
)))
2630 ;; Test for internal id target.
2632 (equal '("Headline1")
2633 (org-test-with-parsed-data "* Headline1
2639 (org-element-property
2641 (org-export-resolve-id-link
2642 (org-element-map tree
'link
'identity info t
) info
)))))
2643 ;; Test for external id target.
2647 (org-test-with-parsed-data "[[id:aaaa]]"
2648 (org-export-resolve-id-link
2649 (org-element-map tree
'link
'identity info t
)
2650 (org-combine-plists info
'(:id-alist
(("aaaa" .
"external-file")))))))))
2652 (ert-deftest test-org-export
/resolve-radio-link
()
2653 "Test `org-export-resolve-radio-link' specifications."
2656 (org-test-with-temp-text "<<<radio>>> radio"
2657 (org-update-radio-target-regexp)
2658 (let* ((tree (org-element-parse-buffer))
2659 (info `(:parse-tree
,tree
)))
2660 (org-export-resolve-radio-link
2661 (org-element-map tree
'link
'identity info t
)
2663 ;; Radio targets are case-insensitive.
2665 (org-test-with-temp-text "<<<RADIO>>> radio"
2666 (org-update-radio-target-regexp)
2667 (let* ((tree (org-element-parse-buffer))
2668 (info `(:parse-tree
,tree
)))
2669 (org-export-resolve-radio-link
2670 (org-element-map tree
'link
'identity info t
)
2672 ;; Radio target with objects.
2674 (org-test-with-temp-text "<<<radio \\alpha>>> radio \\alpha"
2675 (org-update-radio-target-regexp)
2676 (let* ((tree (org-element-parse-buffer))
2677 (info `(:parse-tree
,tree
)))
2678 (org-export-resolve-radio-link
2679 (org-element-map tree
'link
'identity info t
)
2681 ;; Radio target with objects at its beginning.
2683 (org-test-with-temp-text "<<<\\alpha radio>>> \\alpha radio"
2684 (org-update-radio-target-regexp)
2685 (let* ((tree (org-element-parse-buffer))
2686 (info `(:parse-tree
,tree
)))
2687 (org-export-resolve-radio-link
2688 (org-element-map tree
'link
'identity info t
)
2690 ;; Radio link next to an apostrophe.
2692 (org-test-with-temp-text "<<<radio>>> radio's"
2693 (org-update-radio-target-regexp)
2694 (let* ((tree (org-element-parse-buffer))
2695 (info `(:parse-tree
,tree
)))
2696 (org-export-resolve-radio-link
2697 (org-element-map tree
'link
'identity info t
)
2699 ;; Multiple radio targets.
2701 (equal '("radio1" "radio2")
2702 (org-test-with-temp-text "<<<radio1>>> <<<radio2>>> radio1 radio2"
2703 (org-update-radio-target-regexp)
2704 (let* ((tree (org-element-parse-buffer))
2705 (info `(:parse-tree
,tree
)))
2706 (org-element-map tree
'link
2708 (org-element-property
2709 :value
(org-export-resolve-radio-link link info
)))
2711 ;; Radio target is whitespace insensitive.
2713 (org-test-with-temp-text "<<<a radio>>> a\n radio"
2714 (org-update-radio-target-regexp)
2715 (let* ((tree (org-element-parse-buffer))
2716 (info `(:parse-tree
,tree
)))
2717 (org-element-map tree
'link
2718 (lambda (link) (org-export-resolve-radio-link link info
)) info t
)))))
2720 (ert-deftest test-org-export
/file-uri
()
2721 "Test `org-export-file-uri' specifications."
2722 ;; Preserve relative filenames.
2723 (should (equal "relative.org" (org-export-file-uri "relative.org")))
2724 ;; Local files start with "file:///"
2725 (should (equal "file:///local.org" (org-export-file-uri "/local.org")))
2726 ;; Remote files start with "file://"
2727 (should (equal "file://myself@some.where:papers/last.pdf"
2728 (org-export-file-uri "/myself@some.where:papers/last.pdf")))
2729 ;; Expand filename starting with "~".
2730 (should (equal (org-export-file-uri "~/file.org")
2731 (concat "file://" (expand-file-name "~/file.org")))))
2735 ;;; Src-block and example-block
2737 (ert-deftest test-org-export
/unravel-code
()
2738 "Test `org-export-unravel-code' function."
2739 ;; Code without reference.
2741 (equal '("(+ 1 1)\n")
2742 (org-test-with-temp-text "#+BEGIN_EXAMPLE\n(+ 1 1)\n#+END_EXAMPLE"
2743 (org-export-unravel-code (org-element-at-point)))))
2744 ;; Code with reference.
2746 (equal '("(+ 1 1)\n" (1 .
"test"))
2747 (org-test-with-temp-text
2748 "#+BEGIN_EXAMPLE\n(+ 1 1) (ref:test)\n#+END_EXAMPLE"
2749 (let ((org-coderef-label-format "(ref:%s)"))
2750 (org-export-unravel-code (org-element-at-point))))))
2751 ;; Code with user-defined reference.
2754 '("(+ 1 1)\n" (1 .
"test"))
2755 (org-test-with-temp-text
2756 "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\n(+ 1 1) [ref:test]\n#+END_EXAMPLE"
2757 (let ((org-coderef-label-format "(ref:%s)"))
2758 (org-export-unravel-code (org-element-at-point))))))
2759 ;; Code references keys are relative to the current block.
2761 (equal '("(+ 2 2)\n(+ 3 3)\n" (2 .
"one"))
2762 (org-test-with-temp-text "
2771 (let ((org-coderef-label-format "(ref:%s)"))
2772 (org-export-unravel-code (org-element-at-point)))))))
2774 (ert-deftest test-org-export
/format-code-default
()
2775 "Test `org-export-format-code-default' specifications."
2776 ;; Return the empty string when code is empty.
2779 (org-test-with-parsed-data "#+BEGIN_SRC emacs-lisp\n\n\n#+END_SRC"
2780 (org-export-format-code-default
2781 (org-element-map tree
'src-block
'identity info t
) info
))))
2782 ;; Number lines, two whitespace characters before the actual loc.
2785 (org-test-with-parsed-data
2786 "#+BEGIN_SRC emacs-lisp +n\na\nb\n#+END_SRC"
2787 (org-export-format-code-default
2788 (org-element-map tree
'src-block
'identity info t
) info
))))
2789 ;; Put references 6 whitespace characters after the widest line,
2790 ;; wrapped within parenthesis.
2792 (equal "123 (a)\n1 (b)\n"
2793 (let ((org-coderef-label-format "(ref:%s)"))
2794 (org-test-with-parsed-data
2795 "#+BEGIN_SRC emacs-lisp\n123 (ref:a)\n1 (ref:b)\n#+END_SRC"
2796 (org-export-format-code-default
2797 (org-element-map tree
'src-block
'identity info t
) info
))))))
2803 (ert-deftest test-org-export
/activate-smart-quotes
()
2804 "Test `org-export-activate-smart-quotes' specifications."
2805 ;; Double quotes: standard test.
2808 '("some “quoted” text")
2809 (let ((org-export-default-language "en"))
2810 (org-test-with-parsed-data "some \"quoted\" text"
2811 (org-element-map tree
'plain-text
2812 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2814 ;; Opening quotes: at the beginning of a paragraph.
2818 (let ((org-export-default-language "en"))
2819 (org-test-with-parsed-data "\"begin"
2820 (org-element-map tree
'plain-text
2821 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2823 ;; Opening quotes: after an object.
2826 '("“quoted” text")
2827 (let ((org-export-default-language "en"))
2828 (org-test-with-parsed-data "=verb= \"quoted\" text"
2829 (org-element-map tree
'plain-text
2830 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2832 ;; Closing quotes: at the end of a paragraph.
2835 '("Quoted “text”")
2836 (let ((org-export-default-language "en"))
2837 (org-test-with-parsed-data "Quoted \"text\""
2838 (org-element-map tree
'plain-text
2839 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2841 ;; Inner quotes: standard test.
2843 (equal '("« outer « inner » outer »")
2844 (let ((org-export-default-language "fr"))
2845 (org-test-with-parsed-data "\"outer 'inner' outer\""
2846 (org-element-map tree
'plain-text
2847 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2849 ;; Inner quotes: close to special symbols.
2851 (equal '("« outer (« inner ») outer »")
2852 (let ((org-export-default-language "fr"))
2853 (org-test-with-parsed-data "\"outer ('inner') outer\""
2854 (org-element-map tree
'plain-text
2855 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2858 (equal '("« « inner » »")
2859 (let ((org-export-default-language "fr"))
2860 (org-test-with-parsed-data "\"'inner'\""
2861 (org-element-map tree
'plain-text
2862 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2864 ;; Apostrophe: standard test.
2866 (equal '("It « shouldn’t » fail")
2867 (let ((org-export-default-language "fr"))
2868 (org-test-with-parsed-data "It \"shouldn't\" fail"
2869 (org-element-map tree
'plain-text
2870 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2873 (equal '("It shouldn’t fail")
2874 (let ((org-export-default-language "fr"))
2875 (org-test-with-parsed-data "It shouldn't fail"
2876 (org-element-map tree
'plain-text
2877 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2879 ;; Apostrophe: before an object.
2882 '("« a’" " »")
2883 (let ((org-export-default-language "fr"))
2884 (org-test-with-parsed-data "\"a'=b=\""
2885 (org-element-map tree
'plain-text
2886 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2888 ;; Apostrophe: after an object.
2890 (equal '("« " "’s »")
2891 (let ((org-export-default-language "fr"))
2892 (org-test-with-parsed-data "\"=code='s\""
2893 (org-element-map tree
'plain-text
2894 (lambda (s) (org-export-activate-smart-quotes s
:utf-8 info
))
2896 ;; Special case: isolated quotes.
2898 (equal '("“" "”")
2899 (let ((org-export-default-language "en"))
2900 (org-test-with-parsed-data "\"$x$\""
2901 (org-element-map tree
'plain-text
2902 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2904 ;; Smart quotes in secondary strings.
2906 (equal '("“" "”")
2907 (let ((org-export-default-language "en"))
2908 (org-test-with-parsed-data "* \"$x$\""
2909 (org-element-map tree
'plain-text
2910 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2912 ;; Smart quotes in document keywords.
2914 (equal '("“" "”")
2915 (let ((org-export-default-language "en"))
2916 (org-test-with-parsed-data "#+TITLE: \"$x$\""
2917 (org-element-map (plist-get info
:title
) 'plain-text
2918 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2920 ;; Smart quotes in parsed affiliated keywords.
2922 (equal '("“" "”" "Paragraph")
2923 (let ((org-export-default-language "en"))
2924 (org-test-with-parsed-data "#+CAPTION: \"$x$\"\nParagraph"
2925 (org-element-map tree
'plain-text
2926 (lambda (s) (org-export-activate-smart-quotes s
:html info
))
2927 info nil nil t
))))))
2933 (ert-deftest test-org-export
/special-column
()
2934 "Test if the table's special column is properly recognized."
2935 ;; 1. First column is special if it contains only a special marking
2936 ;; characters or empty cells.
2937 (org-test-with-temp-text "
2941 (org-export-table-has-special-column-p
2943 (org-element-parse-buffer) 'table
'identity nil
'first-match
))))
2944 ;; 2. If the column contains anything else, it isn't special.
2945 (org-test-with-temp-text "
2949 (org-export-table-has-special-column-p
2951 (org-element-parse-buffer) 'table
'identity nil
'first-match
))))
2952 ;; 3. Special marking characters are "#", "^", "*", "_", "/", "$"
2954 (org-test-with-temp-text "
2963 (org-export-table-has-special-column-p
2965 (org-element-parse-buffer) 'table
'identity nil
'first-match
))))
2966 ;; 4. A first column with only empty cells isn't considered as
2968 (org-test-with-temp-text "
2972 (org-export-table-has-special-column-p
2974 (org-element-parse-buffer) 'table
'identity nil
'first-match
)))))
2976 (ert-deftest test-org-export
/table-row-is-special-p
()
2977 "Test `org-export-table-row-is-special-p' specifications."
2978 ;; 1. A row is special if it has a special marking character in the
2980 (org-test-with-parsed-data "| ! | 1 |"
2982 (org-export-table-row-is-special-p
2983 (org-element-map tree
'table-row
'identity nil
'first-match
) info
)))
2984 ;; 2. A row is special when its first field is "/"
2985 (org-test-with-parsed-data "
2989 (org-export-table-row-is-special-p
2990 (org-element-map tree
'table-row
'identity nil
'first-match
) info
)))
2991 ;; 3. A row only containing alignment cookies is also considered as
2993 (org-test-with-parsed-data "| <5> | | <l> | <l22> |"
2995 (org-export-table-row-is-special-p
2996 (org-element-map tree
'table-row
'identity nil
'first-match
) info
)))
2997 ;; 4. Everything else isn't considered as special.
2998 (org-test-with-parsed-data "| \alpha | | c |"
3000 (org-export-table-row-is-special-p
3001 (org-element-map tree
'table-row
'identity nil
'first-match
) info
)))
3002 ;; 5. Table's rules are never considered as special rows.
3003 (org-test-with-parsed-data "|---+---|"
3005 (org-export-table-row-is-special-p
3006 (org-element-map tree
'table-row
'identity nil
'first-match
) info
))))
3008 (ert-deftest test-org-export
/has-header-p
()
3009 "Test `org-export-table-has-header-p' specifications."
3010 ;; 1. With an header.
3011 (org-test-with-parsed-data "
3016 (org-export-table-has-header-p
3017 (org-element-map tree
'table
'identity info
'first-match
)
3019 ;; 2. Without an header.
3020 (org-test-with-parsed-data "
3024 (org-export-table-has-header-p
3025 (org-element-map tree
'table
'identity info
'first-match
)
3027 ;; 3. Don't get fooled with starting and ending rules.
3028 (org-test-with-parsed-data "
3034 (org-export-table-has-header-p
3035 (org-element-map tree
'table
'identity info
'first-match
)
3038 (ert-deftest test-org-export
/table-row-group
()
3039 "Test `org-export-table-row-group' specifications."
3040 ;; 1. A rule creates a new group.
3043 (org-test-with-parsed-data "
3047 (org-element-map tree
'table-row
3049 (if (eq (org-element-property :type row
) 'rule
) 'rule
3050 (org-export-table-row-group row info
)))))))
3051 ;; 2. Special rows are ignored in count.
3055 (org-test-with-parsed-data "
3059 (org-element-map tree
'table-row
3061 (if (eq (org-element-property :type row
) 'rule
) 'rule
3062 (org-export-table-row-group row info
)))
3064 ;; 3. Double rules also are ignored in count.
3066 (equal '(1 rule rule
2)
3067 (org-test-with-parsed-data "
3072 (org-element-map tree
'table-row
3074 (if (eq (org-element-property :type row
) 'rule
) 'rule
3075 (org-export-table-row-group row info
))))))))
3077 (ert-deftest test-org-export
/table-row-number
()
3078 "Test `org-export-table-row-number' specifications."
3079 ;; Standard test. Number is 0-indexed.
3082 (org-test-with-parsed-data "| a | b | c |\n| d | e | f |"
3083 (org-element-map tree
'table-row
3084 (lambda (row) (org-export-table-row-number row info
)) info
))))
3085 ;; Number ignores separators.
3088 (org-test-with-parsed-data "
3092 (org-element-map tree
'table-row
3093 (lambda (row) (org-export-table-row-number row info
)) info
))))
3094 ;; Number ignores special rows.
3097 (org-test-with-parsed-data "
3103 (org-element-map tree
'table-row
3104 (lambda (row) (org-export-table-row-number row info
)) info
)))))
3106 (ert-deftest test-org-export
/table-cell-width
()
3107 "Test `org-export-table-cell-width' specifications."
3108 ;; 1. Width is primarily determined by width cookies. If no cookie
3109 ;; is found, cell's width is nil.
3110 (org-test-with-parsed-data "
3111 | / | <l> | <6> | <l7> |
3116 (mapcar (lambda (cell) (org-export-table-cell-width cell info
))
3117 (org-element-map tree
'table-cell
'identity info
)))))
3118 ;; 2. The last width cookie has precedence.
3119 (org-test-with-parsed-data "
3126 (mapcar (lambda (cell) (org-export-table-cell-width cell info
))
3127 (org-element-map tree
'table-cell
'identity info
)))))
3128 ;; 3. Valid width cookies must have a specific row.
3129 (org-test-with-parsed-data "| <6> | cell |"
3133 (mapcar (lambda (cell) (org-export-table-cell-width cell info
))
3134 (org-element-map tree
'table-cell
'identity
))))))
3136 (ert-deftest test-org-export
/table-cell-alignment
()
3137 "Test `org-export-table-cell-alignment' specifications."
3138 ;; 1. Alignment is primarily determined by alignment cookies.
3140 (equal '(left center right
)
3141 (let ((org-table-number-fraction 0.5)
3142 (org-table-number-regexp "^[0-9]+$"))
3143 (org-test-with-parsed-data "| <l> | <c> | <r> |"
3144 (mapcar (lambda (cell)
3145 (org-export-table-cell-alignment cell info
))
3146 (org-element-map tree
'table-cell
'identity
))))))
3147 ;; 2. The last alignment cookie has precedence.
3149 (equal '(right right right
)
3150 (org-test-with-parsed-data "
3154 (mapcar (lambda (cell) (org-export-table-cell-alignment cell info
))
3155 (org-element-map tree
'table-cell
'identity
)))))
3156 ;; 3. If there's no cookie, cell's contents determine alignment.
3157 ;; A column mostly made of cells containing numbers will align
3158 ;; its cells to the right.
3160 (equal '(right right right
)
3161 (let ((org-table-number-fraction 0.5)
3162 (org-table-number-regexp "^[0-9]+$"))
3163 (org-test-with-parsed-data "
3167 (mapcar (lambda (cell)
3168 (org-export-table-cell-alignment cell info
))
3169 (org-element-map tree
'table-cell
'identity
))))))
3170 ;; 4. Otherwise, they will be aligned to the left.
3172 (equal '(left left left
)
3173 (org-test-with-parsed-data "
3177 (mapcar (lambda (cell)
3178 (org-export-table-cell-alignment cell info
))
3179 (org-element-map tree
'table-cell
'identity info
))))))
3181 (ert-deftest test-org-export
/table-cell-borders
()
3182 "Test `org-export-table-cell-borders' specifications."
3183 ;; 1. Recognize various column groups indicators.
3184 (org-test-with-parsed-data "| / | < | > | <> |"
3187 '((right bottom top
) (left bottom top
) (right bottom top
)
3188 (right left bottom top
))
3189 (mapcar (lambda (cell)
3190 (org-export-table-cell-borders cell info
))
3191 (org-element-map tree
'table-cell
'identity
)))))
3192 ;; 2. Accept shortcuts to define column groups.
3193 (org-test-with-parsed-data "| / | < | < |"
3196 '((right bottom top
) (right left bottom top
) (left bottom top
))
3197 (mapcar (lambda (cell)
3198 (org-export-table-cell-borders cell info
))
3199 (org-element-map tree
'table-cell
'identity
)))))
3200 ;; 3. A valid column groups row must start with a "/".
3201 (org-test-with-parsed-data "
3205 (equal '((top) (top) (bottom) (bottom))
3206 (mapcar (lambda (cell)
3207 (org-export-table-cell-borders cell info
))
3208 (org-element-map tree
'table-cell
'identity
)))))
3209 ;; 4. Take table rules into consideration.
3210 (org-test-with-parsed-data "
3215 (equal '((below top
) (bottom above
))
3216 (mapcar (lambda (cell)
3217 (org-export-table-cell-borders cell info
))
3218 (org-element-map tree
'table-cell
'identity
)))))
3219 ;; 5. Top and (resp. bottom) rules induce both `top' and `above'
3220 ;; (resp. `bottom' and `below') borders. Any special row is
3222 (org-test-with-parsed-data "
3228 (equal '((bottom below top above
))
3230 (mapcar (lambda (cell)
3231 (org-export-table-cell-borders cell info
))
3232 (org-element-map tree
'table-cell
'identity
)))))))
3234 (ert-deftest test-org-export
/table-dimensions
()
3235 "Test `org-export-table-dimensions' specifications."
3236 ;; 1. Standard test.
3237 (org-test-with-parsed-data "
3242 (org-export-table-dimensions
3243 (org-element-map tree
'table
'identity info
'first-match
) info
))))
3244 ;; 2. Ignore horizontal rules and special columns.
3245 (org-test-with-parsed-data "
3252 (org-export-table-dimensions
3253 (org-element-map tree
'table
'identity info
'first-match
) info
)))))
3255 (ert-deftest test-org-export
/table-cell-address
()
3256 "Test `org-export-table-cell-address' specifications."
3257 ;; 1. Standard test: index is 0-based.
3258 (org-test-with-parsed-data "| a | b |"
3260 (equal '((0 .
0) (0 .
1))
3261 (org-element-map tree
'table-cell
3262 (lambda (cell) (org-export-table-cell-address cell info
))
3264 ;; 2. Special column isn't counted, nor are special rows.
3265 (org-test-with-parsed-data "
3270 (org-export-table-cell-address
3271 (car (last (org-element-map tree
'table-cell
'identity info
)))
3273 ;; 3. Tables rules do not count either.
3274 (org-test-with-parsed-data "
3282 (org-export-table-cell-address
3283 (car (last (org-element-map tree
'table-cell
'identity info
)))
3285 ;; 4. Return nil for special cells.
3286 (org-test-with-parsed-data "| / | a |"
3288 (org-export-table-cell-address
3289 (org-element-map tree
'table-cell
'identity nil
'first-match
)
3292 (ert-deftest test-org-export
/get-table-cell-at
()
3293 "Test `org-export-get-table-cell-at' specifications."
3294 ;; 1. Address ignores special columns, special rows and rules.
3295 (org-test-with-parsed-data "
3302 (org-element-contents
3303 (org-export-get-table-cell-at
3305 (org-element-map tree
'table
'identity info
'first-match
)
3307 ;; 2. Return value for a non-existent address is nil.
3308 (org-test-with-parsed-data "| a |"
3310 (org-export-get-table-cell-at
3312 (org-element-map tree
'table
'identity info
'first-match
)
3314 (org-test-with-parsed-data "| / |"
3316 (org-export-get-table-cell-at
3318 (org-element-map tree
'table
'identity info
'first-match
)
3321 (ert-deftest test-org-export
/table-cell-starts-colgroup-p
()
3322 "Test `org-export-table-cell-starts-colgroup-p' specifications."
3323 ;; 1. A cell at a beginning of a row always starts a column group.
3324 (org-test-with-parsed-data "| a |"
3326 (org-export-table-cell-starts-colgroup-p
3327 (org-element-map tree
'table-cell
'identity info
'first-match
)
3329 ;; 2. Special column should be ignored when determining the
3330 ;; beginning of the row.
3331 (org-test-with-parsed-data "
3335 (org-export-table-cell-starts-colgroup-p
3336 (org-element-map tree
'table-cell
'identity info
'first-match
)
3338 ;; 2. Explicit column groups.
3339 (org-test-with-parsed-data "
3345 (org-element-map tree
'table-cell
3347 (if (org-export-table-cell-starts-colgroup-p cell info
) 'yes
'no
))
3350 (ert-deftest test-org-export
/table-cell-ends-colgroup-p
()
3351 "Test `org-export-table-cell-ends-colgroup-p' specifications."
3352 ;; 1. A cell at the end of a row always ends a column group.
3353 (org-test-with-parsed-data "| a |"
3355 (org-export-table-cell-ends-colgroup-p
3356 (org-element-map tree
'table-cell
'identity info
'first-match
)
3358 ;; 2. Special column should be ignored when determining the
3359 ;; beginning of the row.
3360 (org-test-with-parsed-data "
3364 (org-export-table-cell-ends-colgroup-p
3365 (org-element-map tree
'table-cell
'identity info
'first-match
)
3367 ;; 3. Explicit column groups.
3368 (org-test-with-parsed-data "
3374 (org-element-map tree
'table-cell
3376 (if (org-export-table-cell-ends-colgroup-p cell info
) 'yes
'no
))
3379 (ert-deftest test-org-export
/table-row-starts-rowgroup-p
()
3380 "Test `org-export-table-row-starts-rowgroup-p' specifications."
3381 ;; 1. A row at the beginning of a table always starts a row group.
3382 ;; So does a row following a table rule.
3383 (org-test-with-parsed-data "
3390 (org-element-map tree
'table-row
3392 (if (org-export-table-row-starts-rowgroup-p row info
) 'yes
'no
))
3394 ;; 2. Special rows should be ignored when determining the beginning
3396 (org-test-with-parsed-data "
3405 (org-element-map tree
'table-row
3407 (if (org-export-table-row-starts-rowgroup-p row info
) 'yes
'no
))
3410 (ert-deftest test-org-export
/table-row-ends-rowgroup-p
()
3411 "Test `org-export-table-row-ends-rowgroup-p' specifications."
3412 ;; 1. A row at the end of a table always ends a row group. So does
3413 ;; a row preceding a table rule.
3414 (org-test-with-parsed-data "
3421 (org-element-map tree
'table-row
3423 (if (org-export-table-row-ends-rowgroup-p row info
) 'yes
'no
))
3425 ;; 2. Special rows should be ignored when determining the beginning
3427 (org-test-with-parsed-data "
3436 (org-element-map tree
'table-row
3438 (if (org-export-table-row-ends-rowgroup-p row info
) 'yes
'no
))
3441 (ert-deftest test-org-export
/table-row-in-header-p
()
3442 "Test `org-export-table-row-in-header-p' specifications."
3443 ;; Standard test. Separators are always nil.
3447 (org-test-with-parsed-data "| a |\n|---|\n| b |"
3448 (org-element-map tree
'table-row
3450 (if (org-export-table-row-in-header-p row info
) 'yes
'no
)) info
))))
3451 ;; Nil when there is no header.
3455 (org-test-with-parsed-data "| a |\n| b |"
3456 (org-element-map tree
'table-row
3458 (if (org-export-table-row-in-header-p row info
) 'yes
'no
)) info
)))))
3460 (ert-deftest test-org-export
/table-row-starts-header-p
()
3461 "Test `org-export-table-row-starts-header-p' specifications."
3462 ;; 1. Only the row starting the first row group starts the table
3464 (org-test-with-parsed-data "
3472 (org-element-map tree
'table-row
3474 (if (org-export-table-row-starts-header-p row info
) 'yes
'no
))
3476 ;; 2. A row cannot start an header if there's no header in the
3478 (org-test-with-parsed-data "
3482 (org-export-table-row-starts-header-p
3483 (org-element-map tree
'table-row
'identity info
'first-match
)
3486 (ert-deftest test-org-export
/table-row-ends-header-p
()
3487 "Test `org-export-table-row-ends-header-p' specifications."
3488 ;; 1. Only the row starting the first row group starts the table
3490 (org-test-with-parsed-data "
3498 (org-element-map tree
'table-row
3500 (if (org-export-table-row-ends-header-p row info
) 'yes
'no
))
3502 ;; 2. A row cannot start an header if there's no header in the
3504 (org-test-with-parsed-data "
3508 (org-export-table-row-ends-header-p
3509 (org-element-map tree
'table-row
'identity info
'first-match
)
3514 ;;; Tables of Contents
3516 (ert-deftest test-org-export
/collect-headlines
()
3517 "Test `org-export-collect-headlines' specifications."
3522 (org-test-with-parsed-data "* H1\n** H2"
3523 (org-export-collect-headlines info
)))))
3524 ;; Do not collect headlines below optional argument.
3528 (org-test-with-parsed-data "* H1\n** H2"
3529 (org-export-collect-headlines info
1)))))
3530 ;; Never collect headlines below maximum headline level.
3534 (org-test-with-parsed-data "#+OPTIONS: H:1\n* H1\n** H2"
3535 (org-export-collect-headlines info
)))))
3539 (org-test-with-parsed-data "#+OPTIONS: H:1\n* H1\n** H2"
3540 (org-export-collect-headlines info
2)))))
3541 ;; Collect headlines locally.
3544 (org-test-with-parsed-data "* H1\n** H2\n** H3"
3545 (let ((scope (org-element-map tree
'headline
#'identity info t
)))
3546 (length (org-export-collect-headlines info nil scope
))))))
3547 ;; When collecting locally, optional level is relative.
3550 (org-test-with-parsed-data "* H1\n** H2\n*** H3"
3551 (let ((scope (org-element-map tree
'headline
#'identity info t
)))
3552 (length (org-export-collect-headlines info
1 scope
)))))))
3558 (ert-deftest test-org-export
/inner-template
()
3559 "Test `inner-template' translator specifications."
3562 (org-test-with-temp-text "* Headline"
3564 (org-export-create-backend
3566 '((inner-template .
(lambda (contents info
) "Success!"))
3567 (headline .
(lambda (h c i
) "Headline"))))))))
3568 ;; Inner template is applied even in a "body-only" export.
3571 (org-test-with-temp-text "* Headline"
3573 (org-export-create-backend
3574 :transcoders
'((inner-template .
(lambda (c i
) "Success!"))
3575 (headline .
(lambda (h c i
) "Headline"))))
3576 nil nil
'body-only
)))))
3578 (ert-deftest test-org-export
/template
()
3579 "Test `template' translator specifications."
3582 (org-test-with-temp-text "* Headline"
3584 (org-export-create-backend
3585 :transcoders
'((template .
(lambda (contents info
) "Success!"))
3586 (headline .
(lambda (h c i
) "Headline"))))))))
3587 ;; Template is not applied in a "body-only" export.
3590 (org-test-with-temp-text "* Headline"
3592 (org-export-create-backend
3593 :transcoders
'((template .
(lambda (contents info
) "Success!"))
3594 (headline .
(lambda (h c i
) "Headline"))))
3595 nil nil
'body-only
)))))
3601 (ert-deftest test-org-export
/get-next-element
()
3602 "Test `org-export-get-next-element' specifications."
3606 (org-test-with-parsed-data "* Headline\n*a* b"
3607 (org-export-get-next-element
3608 (org-element-map tree
'bold
'identity info t
) info
))))
3609 ;; Return nil when no previous element.
3611 (org-test-with-parsed-data "* Headline\na *b*"
3612 (org-export-get-next-element
3613 (org-element-map tree
'bold
'identity info t
) info
)))
3614 ;; Non-exportable elements are ignored.
3616 (let ((org-export-with-timestamps nil
))
3617 (org-test-with-parsed-data "\alpha <2012-03-29 Thu>"
3618 (org-export-get-next-element
3619 (org-element-map tree
'entity
'identity info t
) info
))))
3620 ;; Find next element in secondary strings.
3623 (org-test-with-parsed-data "* a =verb="
3625 (org-export-get-next-element
3626 (org-element-map tree
'plain-text
'identity info t
) info
)))))
3629 (org-test-with-parsed-data "* /italic/ =verb="
3631 (org-export-get-next-element
3632 (org-element-map tree
'italic
'identity info t
) info
)))))
3633 ;; Find next element in document keywords.
3636 (org-test-with-parsed-data "#+TITLE: a =verb="
3638 (org-export-get-next-element
3640 (plist-get info
:title
) 'plain-text
'identity info t
) info
)))))
3641 ;; Find next element in parsed affiliated keywords.
3644 (org-test-with-parsed-data "#+CAPTION: a =verb=\nParagraph"
3646 (org-export-get-next-element
3647 (org-element-map tree
'plain-text
'identity info t nil t
) info
)))))
3648 ;; With optional argument N, return a list containing all the
3649 ;; following elements.
3652 '(bold code underline
)
3653 (org-test-with-parsed-data "_a_ /b/ *c* ~d~ _e_"
3655 (org-export-get-next-element
3656 (org-element-map tree
'italic
'identity info t
) info t
)))))
3657 ;; When N is a positive integer, return a list containing up to
3658 ;; N following elements.
3662 (org-test-with-parsed-data "_a_ /b/ *c* ~d~ _e_"
3664 (org-export-get-next-element
3665 (org-element-map tree
'italic
'identity info t
) info
2))))))
3667 (ert-deftest test-org-export
/get-previous-element
()
3668 "Test `org-export-get-previous-element' specifications."
3672 (org-test-with-parsed-data "* Headline\na *b*"
3673 (org-export-get-previous-element
3674 (org-element-map tree
'bold
'identity info t
) info
))))
3675 ;; Return nil when no previous element.
3677 (org-test-with-parsed-data "* Headline\n*a* b"
3678 (org-export-get-previous-element
3679 (org-element-map tree
'bold
'identity info t
) info
)))
3680 ;; Non-exportable elements are ignored.
3682 (let ((org-export-with-timestamps nil
))
3683 (org-test-with-parsed-data "<2012-03-29 Thu> \alpha"
3684 (org-export-get-previous-element
3685 (org-element-map tree
'entity
'identity info t
) info
))))
3686 ;; Find previous element in secondary strings.
3689 (org-test-with-parsed-data "* =verb= a"
3691 (org-export-get-previous-element
3692 (org-element-map tree
'plain-text
'identity info t
) info
)))))
3695 (org-test-with-parsed-data "* =verb= /italic/"
3697 (org-export-get-previous-element
3698 (org-element-map tree
'italic
'identity info t
) info
)))))
3699 ;; Find previous element in document keywords.
3702 (org-test-with-parsed-data "#+TITLE: =verb= a"
3704 (org-export-get-previous-element
3706 (plist-get info
:title
) 'plain-text
'identity info t
) info
)))))
3707 ;; Find previous element in parsed affiliated keywords.
3710 (org-test-with-parsed-data "#+CAPTION: =verb= a\nParagraph"
3712 (org-export-get-previous-element
3713 (org-element-map tree
'plain-text
'identity info t nil t
) info
)))))
3714 ;; With optional argument N, return a list containing up to
3715 ;; N previous elements.
3717 (equal '(underline italic bold
)
3718 (org-test-with-parsed-data "_a_ /b/ *c* ~d~"
3720 (org-export-get-previous-element
3721 (org-element-map tree
'code
'identity info t
) info t
)))))
3722 ;; When N is a positive integer, return a list containing up to
3723 ;; N previous elements.
3725 (equal '(italic bold
)
3726 (org-test-with-parsed-data "_a_ /b/ *c* ~d~"
3728 (org-export-get-previous-element
3729 (org-element-map tree
'code
'identity info t
) info
2))))))
3733 ;;; test-org-export.el end here