testing/lisp/test-org-element.el

   1 ;;; test-org-element.el --- Tests for org-element.el
   2
   3 ;; Copyright (C) 2012  Nicolas Goaziou
   4
   5 ;; Author: Nicolas Goaziou <n.goaziou at gmail dot com>
   6
   7 ;; This program is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation, either version 3 of the License, or
  10 ;; (at your option) any later version.
  11
  12 ;; This program is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 ;;; Commentary:
  21
  22 ;;; Code:
  23
  24 (unless (featurep 'org-element)
  25   (signal 'missing-test-dependency "org-element"))
  26
  27 (defun org-test-parse-and-interpret (text)
  28   "Parse TEXT as Org syntax and interpret it.
  29 Return interpreted string."
  30   (with-temp-buffer
  31     (org-mode)
  32     (insert text)
  33     (org-element-interpret-data (org-element-parse-buffer))))
  34
  35
  36 \f
  37 ;;; Test Parsers
  38
  39 ;;;; Example-blocks and Src-blocks
  40
  41 (ert-deftest test-org-element/block-switches ()
  42   "Test `example-block' and `src-block' switches parsing."
  43   (let ((org-coderef-label-format "(ref:%s)"))
  44     ;; 1. Test "-i" switch.
  45     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
  46       (let ((element (org-element-current-element)))
  47         (should-not (org-element-property :preserve-indent element))))
  48     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
  49       (let ((element (org-element-current-element)))
  50         (should (org-element-property :preserve-indent element))))
  51     (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
  52       (let ((element (org-element-current-element)))
  53         (should-not (org-element-property :preserve-indent element))))
  54     (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
  55       (let ((element (org-element-current-element)))
  56         (should (org-element-property :preserve-indent element))))
  57     ;; 2. "-n -r -k" combination should number lines, retain labels but
  58     ;;    not use them in coderefs.
  59     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
  60       (let ((element (org-element-current-element)))
  61         (should (and (org-element-property :number-lines element)
  62                      (org-element-property :retain-labels element)
  63                      (not (org-element-property :use-labels element))))))
  64     (org-test-with-temp-text
  65         "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
  66       (let ((element (org-element-current-element)))
  67         (should (and (org-element-property :number-lines element)
  68                      (org-element-property :retain-labels element)
  69                      (not (org-element-property :use-labels element))))))
  70     ;; 3. "-n -r" combination should number-lines remove labels and not
  71     ;;    use them in coderefs.
  72     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
  73       (let ((element (org-element-current-element)))
  74         (should (and (org-element-property :number-lines element)
  75                      (not (org-element-property :retain-labels element))
  76                      (not (org-element-property :use-labels element))))))
  77     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
  78       (let ((element (org-element-current-element)))
  79         (should (and (org-element-property :number-lines element)
  80                      (not (org-element-property :retain-labels element))
  81                      (not (org-element-property :use-labels element))))))
  82     ;; 4. "-n" or "+n" should number lines, retain labels and use them
  83     ;;    in coderefs.
  84     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
  85       (let ((element (org-element-current-element)))
  86         (should (and (org-element-property :number-lines element)
  87                      (org-element-property :retain-labels element)
  88                      (org-element-property :use-labels element)))))
  89     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
  90       (let ((element (org-element-current-element)))
  91         (should (and (org-element-property :number-lines element)
  92                      (org-element-property :retain-labels element)
  93                      (org-element-property :use-labels element)))))
  94     (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
  95       (let ((element (org-element-current-element)))
  96         (should (and (org-element-property :number-lines element)
  97                      (org-element-property :retain-labels element)
  98                      (org-element-property :use-labels element)))))
  99     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
 100       (let ((element (org-element-current-element)))
 101         (should (and (org-element-property :number-lines element)
 102                      (org-element-property :retain-labels element)
 103                      (org-element-property :use-labels element)))))
 104     ;; 5. No switch should not number lines, but retain labels and use
 105     ;;    them in coderefs.
 106     (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 107       (let ((element (org-element-current-element)))
 108         (should (and (not (org-element-property :number-lines element))
 109                      (org-element-property :retain-labels element)
 110                      (org-element-property :use-labels element)))))
 111     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 112       (let ((element (org-element-current-element)))
 113         (should (and (not (org-element-property :number-lines element))
 114                      (org-element-property :retain-labels element)
 115                      (org-element-property :use-labels element)))))
 116     ;; 6. "-r" switch only: do not number lines, remove labels, and
 117     ;;    don't use labels in coderefs.
 118     (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
 119       (let ((element (org-element-current-element)))
 120         (should (and (not (org-element-property :number-lines element))
 121                      (not (org-element-property :retain-labels element))
 122                      (not (org-element-property :use-labels element))))))
 123     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
 124       (let ((element (org-element-current-element)))
 125         (should (and (not (org-element-property :number-lines element))
 126                      (not (org-element-property :retain-labels element))
 127                      (not (org-element-property :use-labels element))))))
 128     ;; 7. Recognize coderefs with user-defined syntax.
 129     (org-test-with-temp-text
 130         "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
 131       (let ((element (org-element-current-element)))
 132         (should
 133          (equal (org-element-property :label-fmt element) "[ref:%s]"))))
 134     (org-test-with-temp-text
 135         "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
 136       (let ((element (org-element-current-element)))
 137         (should
 138          (equal (org-element-property :label-fmt element) "[ref:%s]"))))))
 139
 140
 141 ;;;; Export snippets
 142
 143 (ert-deftest test-org-element/export-snippet ()
 144   "Test export-snippet parsing."
 145   (should
 146    (equal
 147     (org-test-with-temp-text "<back-end@contents>"
 148       (org-element-map
 149        (org-element-parse-buffer) 'export-snippet 'identity nil t))
 150     '(export-snippet
 151       (:back-end "back-end"
 152                  :value "contents" :begin 1 :end 20 :post-blank 0)))))
 153
 154
 155 ;;;; Footnotes references
 156
 157 (ert-deftest test-org-element/footnote-reference ()
 158   "Test footnote-reference parsing."
 159   ;; 1. Parse a standard reference.
 160   (org-test-with-temp-text "[fn:label]"
 161     (should (equal (org-element-footnote-reference-parser)
 162                    '(footnote-reference
 163                      (:label "fn:label" :type standard :inline-definition nil
 164                              :begin 1 :end 11 :post-blank 0)))))
 165   ;; 2. Parse a normalized reference.
 166   (org-test-with-temp-text "[1]"
 167     (should (equal (org-element-footnote-reference-parser)
 168                    '(footnote-reference
 169                      (:label "1" :type standard :inline-definition nil
 170                              :begin 1 :end 4 :post-blank 0)))))
 171   ;; 3. Parse an inline reference.
 172   (org-test-with-temp-text "[fn:test:def]"
 173     (should (equal (org-element-footnote-reference-parser)
 174                    '(footnote-reference
 175                      (:label "fn:test" :type inline :inline-definition ("def")
 176                              :begin 1 :end 14 :post-blank 0)))))
 177   ;; 4. Parse an anonymous reference.
 178   (org-test-with-temp-text "[fn::def]"
 179     (should (equal (org-element-footnote-reference-parser)
 180                    '(footnote-reference
 181                      (:label nil :type inline :inline-definition ("def")
 182                              :begin 1 :end 10 :post-blank 0)))))
 183   ;; 5. Parse nested footnotes.
 184   (org-test-with-temp-text "[fn::def [fn:label]]"
 185     (should
 186      (equal
 187       (org-element-footnote-reference-parser)
 188       '(footnote-reference
 189         (:label nil :type inline
 190                 :inline-definition
 191                 ("def "
 192                  (footnote-reference
 193                   (:label "fn:label" :type standard :inline-definition nil
 194                           :begin 5 :end 15 :post-blank 0)))
 195                 :begin 1 :end 21 :post-blank 0)))))
 196   ;; 6. Parse adjacent footnotes.
 197   (org-test-with-temp-text "[fn:label1][fn:label2]"
 198     (should
 199      (equal
 200       (org-element-footnote-reference-parser)
 201       '(footnote-reference
 202         (:label "fn:label1" :type standard :inline-definition nil :begin 1
 203                 :end 12 :post-blank 0)))))
 204   ;; 7. Only properly closed footnotes are recognized as such.
 205   (org-test-with-temp-text "Text [fn:label"
 206     (should-not
 207      (org-element-map
 208       (org-element-parse-buffer) 'footnote-reference 'identity))))
 209
 210
 211 ;;;; Headlines
 212
 213 (ert-deftest test-org-element/headline-quote-keyword ()
 214   "Test QUOTE keyword recognition."
 215   ;; Reference test.
 216   (org-test-with-temp-text "* Headline"
 217     (let ((org-quote-string "QUOTE"))
 218       (should-not (org-element-property :quotedp (org-element-at-point)))))
 219   ;; Standard position.
 220   (org-test-with-temp-text "* QUOTE Headline"
 221     (let ((org-quote-string "QUOTE"))
 222       (let ((headline (org-element-at-point)))
 223         (should (org-element-property :quotedp headline))
 224         ;; Test removal from raw value.
 225         (should (equal (org-element-property :raw-value headline) "Headline"))))
 226     ;; Case sensitivity.
 227     (let ((org-quote-string "Quote"))
 228       (should-not (org-element-property :quotedp (org-element-at-point)))))
 229   ;; With another keyword.
 230   (org-test-with-temp-text "* TODO QUOTE Headline"
 231     (let ((org-quote-string "QUOTE")
 232           (org-todo-keywords '((sequence "TODO" "DONE"))))
 233       (should (org-element-property :quotedp (org-element-at-point))))))
 234
 235 (ert-deftest test-org-element/headline-comment-keyword ()
 236   "Test COMMENT keyword recognition."
 237   ;; Reference test.
 238   (org-test-with-temp-text "* Headline"
 239     (let ((org-comment-string "COMMENT"))
 240       (should-not (org-element-property :commentedp (org-element-at-point)))))
 241   ;; Standard position.
 242   (org-test-with-temp-text "* COMMENT Headline"
 243     (let ((org-comment-string "COMMENT"))
 244       (let ((headline (org-element-at-point)))
 245         (should (org-element-property :commentedp headline))
 246         ;; Test removal from raw value.
 247         (should (equal (org-element-property :raw-value headline) "Headline"))))
 248     ;; Case sensitivity.
 249     (let ((org-comment-string "Comment"))
 250       (should-not (org-element-property :commentedp (org-element-at-point)))))
 251   ;; With another keyword.
 252   (org-test-with-temp-text "* TODO COMMENT Headline"
 253     (let ((org-comment-string "COMMENT")
 254           (org-todo-keywords '((sequence "TODO" "DONE"))))
 255       (should (org-element-property :commentedp (org-element-at-point))))))
 256
 257 (ert-deftest test-org-element/headline-archive-tag ()
 258   "Test ARCHIVE tag recognition."
 259   ;; Reference test.
 260   (org-test-with-temp-text "* Headline"
 261     (let ((org-archive-tag "ARCHIVE"))
 262       (should-not (org-element-property :archivedp (org-element-at-point)))))
 263   ;; Single tag.
 264   (org-test-with-temp-text "* Headline :ARCHIVE:"
 265     (let ((org-archive-tag "ARCHIVE"))
 266       (let ((headline (org-element-at-point)))
 267         (should (org-element-property :archivedp headline))
 268         ;; Test tag removal.
 269         (should-not (org-element-property :tags headline))))
 270     (let ((org-archive-tag "Archive"))
 271       (should-not (org-element-property :archivedp (org-element-at-point)))))
 272   ;; Multiple tags.
 273   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
 274     (let ((org-archive-tag "ARCHIVE"))
 275       (let ((headline (org-element-at-point)))
 276         (should (org-element-property :archivedp headline))
 277         ;; Test tag removal.
 278         (should (equal (org-element-property :tags headline) ":test:"))))))
 279
 280
 281 ;;;; Verse blocks
 282
 283 (ert-deftest test-org-element/verse-block ()
 284   "Test verse block parsing."
 285   ;; Standard test.
 286   (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
 287     (should
 288      (equal
 289       (org-element-map (org-element-parse-buffer) 'verse-block 'identity nil t)
 290       '(verse-block
 291         (:begin 1 :end 38 :contents-begin 15 :contents-end 27 :hiddenp nil
 292                 :post-blank 0)
 293         "Verse block\n"))))
 294   ;; Ignore case.
 295   (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
 296     (should
 297      (equal
 298       (org-element-map (org-element-parse-buffer) 'verse-block 'identity nil t)
 299       '(verse-block
 300         (:begin 1 :end 38 :contents-begin 15 :contents-end 27 :hiddenp nil
 301                 :post-blank 0)
 302         "Verse block\n"))))
 303   ;; Parse folding.
 304   (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
 305     (org-hide-block-all)
 306     (should
 307      (equal
 308       (org-element-map (org-element-parse-buffer) 'verse-block 'identity nil t)
 309       '(verse-block
 310         (:begin 1 :end 38 :contents-begin 15 :contents-end 27
 311                 :hiddenp org-hide-block :post-blank 0)
 312         "Verse block\n"))))
 313   ;; Parse objects in verse blocks.
 314   (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
 315     (should (org-element-map (org-element-parse-buffer) 'entity 'identity))))
 316
 317
 318 \f
 319 ;;; Test Interpreters.
 320
 321 (ert-deftest test-org-element/interpret-affiliated-keywords ()
 322   "Test if affiliated keywords are correctly interpreted."
 323   ;; Interpret simple keywords.
 324   (should
 325    (equal
 326     (org-element-interpret-data
 327      '(org-data nil (paragraph (:name "para") "Paragraph")))
 328     "#+NAME: para\nParagraph\n"))
 329   ;; Interpret multiple keywords.
 330   (should
 331    (equal
 332     (org-element-interpret-data
 333      '(org-data nil (paragraph (:attr_ascii ("line1" "line2")) "Paragraph")))
 334     "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
 335   ;; Interpret parsed keywords.
 336   (should
 337    (equal
 338     (org-element-interpret-data
 339      '(org-data nil (paragraph (:caption ("caption")) "Paragraph")))
 340     "#+CAPTION: caption\nParagraph\n"))
 341   ;; Interpret dual keywords.
 342   (should
 343    (equal
 344     (org-element-interpret-data
 345      '(org-data nil (paragraph (:caption (("long") "short")) "Paragraph")))
 346     "#+CAPTION[short]: long\nParagraph\n")))
 347
 348 (ert-deftest test-org-element/center-block-interpreter ()
 349   "Test center block interpreter."
 350   (should
 351    (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
 352           "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
 353
 354 (ert-deftest test-org-element/drawer-interpreter ()
 355   "Test drawer interpreter."
 356   (should
 357    (equal (let ((org-drawers '("TEST")))
 358             (org-test-parse-and-interpret ":TEST:\nTest\n:END:"))
 359           ":TEST:\nTest\n:END:\n")))
 360
 361 (ert-deftest test-org-element/dynamic-block-interpreter ()
 362   "Test dynamic block interpreter."
 363   (should
 364    (equal (org-test-parse-and-interpret
 365            "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
 366           "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
 367
 368 (ert-deftest test-org-element/footnote-definition-interpreter ()
 369   "Test footnote definition interpreter."
 370   (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
 371
 372 (ert-deftest test-org-element/headline-interpreter ()
 373   "Test headline and section interpreters."
 374   ;; 1. Standard test.
 375   (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
 376   ;; 2. With TODO keywords.
 377   (should
 378    (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
 379             (org-test-parse-and-interpret "* TODO Headline"))
 380           "* TODO Headline\n"))
 381   ;; 3. With tags...
 382   ;;
 383   ;; 3.1. ... and a positive `org-tags-column' value.
 384   (should
 385    (equal (let ((org-tags-column 20))
 386             (org-test-parse-and-interpret "* Headline :tag:"))
 387           "* Headline          :tag:\n"))
 388   ;; 3.2. ... and a negative `org-tags-column' value.
 389   (should
 390    (equal (let ((org-tags-column -20))
 391             (org-test-parse-and-interpret "* Headline :tag:"))
 392           "* Headline     :tag:\n"))
 393   ;; 3.3. ... and a null `org-tags-column' value.
 394   (should
 395    (equal (let ((org-tags-column 0))
 396             (org-test-parse-and-interpret "* Headline     :tag:"))
 397           "* Headline :tag:\n"))
 398   ;; 4. With priority cookie.
 399   (should
 400    (equal (org-test-parse-and-interpret "* [#B] Headline")
 401           "* [#B] Headline\n"))
 402   ;; 5. With comment keyword.
 403   (should
 404    (equal (let ((org-comment-string "COMMENT"))
 405             (org-test-parse-and-interpret "* COMMENT Headline"))
 406           "* COMMENT Headline\n"))
 407   ;; 6. With quote section.
 408   (should
 409    (equal (let ((org-quote-string "QUOTE"))
 410             (org-test-parse-and-interpret "* QUOTE Headline"))
 411           "* QUOTE Headline\n"))
 412   ;; 7. Keep same number of blank lines before body.
 413   (should
 414    (equal (org-test-parse-and-interpret
 415            "* Headline\n\n\nText after two blank lines.")
 416           "* Headline\n\n\nText after two blank lines.\n")))
 417
 418 (ert-deftest test-org-element/inlinetask-interpreter ()
 419   "Test inlinetask interpretation."
 420   (when (featurep 'org-inlinetask)
 421     (let ((org-inlinetask-min-level 15))
 422       ;; 1. Regular inlinetask.
 423      (should (equal (org-test-parse-and-interpret
 424                      "*************** Task\nTest\n*************** END")
 425                     "*************** Task\nTest\n*************** END\n"))
 426      ;; 2. Degenerate inlinetask.
 427      (should (equal (org-test-parse-and-interpret "*************** Task")
 428                     "*************** Task\n"))
 429      ;; 3. Prefer degenerate form when there are no contents.
 430      (should (equal (org-test-parse-and-interpret
 431                      "*************** Task\n*************** END")
 432                     "*************** Task\n"))
 433      ;; 4. With TODO keywords.
 434      (should
 435       (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
 436                (org-test-parse-and-interpret "*************** TODO Task"))
 437              "*************** TODO Task\n"))
 438      ;; 5. With tags...
 439      ;;
 440      ;; 5.1. ... and a positive `org-tags-column' value.
 441      (should
 442       (equal (let ((org-tags-column 30))
 443                (org-test-parse-and-interpret "*************** Task :tag:"))
 444              "*************** Task          :tag:\n"))
 445      ;; 5.2. ... and a negative `org-tags-column' value.
 446      (should
 447       (equal (let ((org-tags-column -30))
 448                (org-test-parse-and-interpret "*************** Task :tag:"))
 449              "*************** Task     :tag:\n"))
 450      ;; 5.3. ... and a null `org-tags-column' value.
 451      (should
 452       (equal (let ((org-tags-column 0))
 453                (org-test-parse-and-interpret "*************** Task     :tag:"))
 454              "*************** Task :tag:\n"))
 455      ;; 6. With priority cookie.
 456      (should
 457       (equal (org-test-parse-and-interpret "*************** [#B] Task")
 458              "*************** [#B] Task\n")))))
 459
 460 (ert-deftest test-org-element/plain-list-interpreter ()
 461   "Test plain-list and item interpreters."
 462   ;; 1. Unordered list.
 463   (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
 464   ;; 2. Description list.
 465   (should
 466    (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
 467   ;; 3. Ordered list.
 468   (should
 469    (equal (let ((org-plain-list-ordered-item-terminator t))
 470             (org-test-parse-and-interpret "1. Item"))
 471           "1. Item\n"))
 472   ;; 4. Ordered list with counter.
 473   (should
 474    (equal (let ((org-plain-list-ordered-item-terminator t))
 475             (org-test-parse-and-interpret "1. [@5] Item"))
 476           "5. [@5] Item\n"))
 477   ;; 5. List with check-boxes.
 478   (should
 479    (equal (org-test-parse-and-interpret
 480            "- [-] Item 1\n  - [X] Item 2\n  - [ ] Item 3")
 481           "- [-] Item 1\n  - [X] Item 2\n  - [ ] Item 3\n")))
 482
 483 (ert-deftest test-org-element/quote-block-interpreter ()
 484   "Test quote block interpreter."
 485   (should (equal (org-test-parse-and-interpret
 486                   "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
 487                  "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
 488
 489 (ert-deftest test-org-element/special-block-interpreter ()
 490   "Test special block interpreter."
 491   (should (equal (org-test-parse-and-interpret
 492                   "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
 493                  "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
 494
 495 (ert-deftest test-org-element/babel-call-interpreter ()
 496   "Test babel call interpreter."
 497   ;; 1. Without argument.
 498   (should (equal (org-test-parse-and-interpret "#+CALL: test()")
 499                  "#+CALL: test()\n"))
 500   ;; 2. With argument.
 501   (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
 502                  "#+CALL: test(x=2)\n"))
 503   ;; 3. With header arguments.
 504   (should (equal (org-test-parse-and-interpret
 505                   "#+CALL: test[:results output]()[:results html]")
 506                  "#+CALL: test[:results output]()[:results html]\n")))
 507
 508 (ert-deftest test-org-element/clock-interpreter ()
 509   "Test clock interpreter."
 510   ;; Running clock.
 511   (should
 512    (equal (let ((org-clock-string "CLOCK:"))
 513             (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]"))
 514           "CLOCK: [2012-01-01 sun. 00:01]\n"))
 515   ;; Closed clock.
 516   (should
 517    (equal
 518     (let ((org-clock-string "CLOCK:"))
 519       (org-test-parse-and-interpret "
 520 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] =>  0:01"))
 521     "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] =>  0:01\n")))
 522
 523 (ert-deftest test-org-element/comment-interpreter ()
 524   "Test comment interpreter."
 525   ;; Regular comment.
 526   (should (equal (org-test-parse-and-interpret "#Comment") "#Comment\n"))
 527   ;; Inline comment.
 528   (should (equal (org-test-parse-and-interpret "  #+ Comment")
 529                  "  #+ Comment\n")))
 530
 531 (ert-deftest test-org-element/comment-block-interpreter ()
 532   "Test comment block interpreter."
 533   (should (equal (org-test-parse-and-interpret
 534                   "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
 535                  "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n")))
 536
 537 (ert-deftest test-org-element/example-block-interpreter ()
 538   "Test example block interpreter."
 539   (should (equal (org-test-parse-and-interpret
 540                   "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
 541                  "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n")))
 542
 543 (ert-deftest test-org-element/export-block-interpreter ()
 544   "Test export block interpreter."
 545   (should (equal (org-test-parse-and-interpret
 546                   "#+BEGIN_HTML\nTest\n#+END_HTML")
 547                  "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
 548
 549 (ert-deftest test-org-element/fixed-width-interpreter ()
 550   "Test fixed width interpreter."
 551   (should (equal (org-test-parse-and-interpret ": Test") ": Test\n")))
 552
 553 (ert-deftest test-org-element/horizontal-rule-interpreter ()
 554   "Test horizontal rule interpreter."
 555   (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
 556
 557 (ert-deftest test-org-element/keyword-interpreter ()
 558   "Test keyword interpreter."
 559   (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
 560                  "#+KEYWORD: value\n")))
 561
 562 (ert-deftest test-org-element/latex-environment-interpreter ()
 563   "Test latex environment interpreter."
 564   (should (equal (org-test-parse-and-interpret
 565                   "\\begin{equation}\n1+1=2\n\\end{equation}")
 566                  "\\begin{equation}\n1+1=2\n\\end{equation}\n")))
 567
 568 (ert-deftest test-org-element/planning-interpreter ()
 569   "Test planning interpreter."
 570   (let ((org-closed-string "CLOSED:")
 571         (org-deadline-string "DEADLINE:")
 572         (org-scheduled-string "SCHEDULED:"))
 573     (should
 574      (equal
 575       (org-test-parse-and-interpret
 576        "* Headline
 577 CLOSED: <2012-01-01> DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01>")
 578       "* Headline
 579 CLOSED: <2012-01-01> DEADLINE: <2012-01-01> SCHEDULED: <2012-01-01>\n"))))
 580
 581 (ert-deftest test-org-element/property-drawer-interpreter ()
 582   "Test property drawer interpreter."
 583   (should (equal (let ((org-property-format "%-10s %s"))
 584                    (org-test-parse-and-interpret
 585                     ":PROPERTIES:\n:prop: value\n:END:"))
 586                  ":PROPERTIES:\n:prop:     value\n:END:\n")))
 587
 588 (ert-deftest test-org-element/src-block-interpreter ()
 589   "Test src block interpreter."
 590   (should
 591    (equal (org-test-parse-and-interpret
 592            "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC")
 593           "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC\n")))
 594
 595 (ert-deftest test-org-element/table-interpreter ()
 596   "Test table, table-row and table-cell interpreters."
 597   ;; 1. Simple table.
 598   (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
 599                  "| a | b |\n| c | d |\n"))
 600   ;; 2. Table with horizontal rules.
 601   (should (equal (org-test-parse-and-interpret
 602                   "| a | b |\n|---+---|\n| c | d |")
 603                  "| a | b |\n|---+---|\n| c | d |\n"))
 604   ;; 3. Table with meta-data.
 605   (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
 606                  "| / | < | > |\n| * | 1 | 2 |\n")))
 607
 608 (ert-deftest test-org-element/verse-block-interpreter ()
 609   "Test verse block interpretation."
 610   (should
 611    (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
 612           "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
 613
 614 (ert-deftest test-org-element/bold-interpreter ()
 615   "Test bold interpreter."
 616   (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
 617
 618 (ert-deftest test-org-element/code-interpreter ()
 619   "Test code interpreter."
 620   (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
 621
 622 (ert-deftest test-org-element/entity-interpreter ()
 623   "Test entity interpreter."
 624   ;; 1. Without brackets.
 625   (should
 626    (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
 627   ;; 2. With brackets.
 628   (should
 629    (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
 630
 631 (ert-deftest test-org-element/export-snippet-interpreter ()
 632   "Test export snippet interpreter."
 633   (should (equal (org-test-parse-and-interpret "<back-end@contents>")
 634                  "<back-end@contents>\n")))
 635
 636 (ert-deftest test-org-element/footnote-reference-interpreter ()
 637   "Test footnote reference interpreter."
 638   ;; 1. Regular reference.
 639   (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
 640   ;; 2. Normalized reference.
 641   (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
 642   ;; 3. Named reference.
 643   (should (equal (org-test-parse-and-interpret "Text[fn:label]")
 644                  "Text[fn:label]\n"))
 645   ;; 4. Inline reference.
 646   (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
 647                  "Text[fn:label:def]\n"))
 648   ;; 5. Anonymous reference.
 649   (should (equal (org-test-parse-and-interpret "Text[fn::def]")
 650                  "Text[fn::def]\n")))
 651
 652 (ert-deftest test-org-element/inline-babel-call-interpreter ()
 653   "Test inline babel call interpreter."
 654   ;; 1. Without arguments.
 655   (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
 656   ;; 2. With arguments.
 657   (should (equal (org-test-parse-and-interpret "call_test(x=2)")
 658                  "call_test(x=2)\n"))
 659   ;; 3. With header arguments.
 660   (should (equal (org-test-parse-and-interpret
 661                   "call_test[:results output]()[:results html]")
 662                  "call_test[:results output]()[:results html]\n")))
 663
 664 (ert-deftest test-org-element/inline-src-block-interpreter ()
 665   "Test inline src block interpreter."
 666   ;; 1. Without header argument.
 667   (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
 668                  "src_emacs-lisp{(+ 1 1)}\n"))
 669   ;; 2. With header arguments.
 670   (should (equal (org-test-parse-and-interpret
 671                   "src_emacs-lisp[:results silent]{(+ 1 1)}")
 672                  "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
 673
 674 (ert-deftest test-org-element/italic-interpreter ()
 675   "Test italic interpreter."
 676   (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
 677
 678 (ert-deftest test-org-element/latex-fragment-interpreter ()
 679   "Test latex fragment interpreter."
 680   (let ((org-latex-regexps
 681          '(("begin" "^[         ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^