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 (unless (featurep 'org-element)
  21   (signal 'missing-test-dependency "org-element"))
  22
  23 (defun org-test-parse-and-interpret (text)
  24   "Parse TEXT as Org syntax and interpret it.
  25 Return interpreted string."
  26   (with-temp-buffer
  27     (org-mode)
  28     (insert text)
  29     (org-element-interpret-data (org-element-parse-buffer))))
  30
  31
  32 \f
  33 ;;; Test `org-element-map'
  34
  35 (ert-deftest test-org-element/map ()
  36   "Test `org-element-map'."
  37   ;; Can map to `plain-text' objects.
  38   (should
  39    (= 2
  40       (org-test-with-temp-text "Some text \alpha
  41 #+BEGIN_CENTER
  42 Some other text
  43 #+END_CENTER"
  44         (let ((count 0))
  45           (org-element-map
  46            (org-element-parse-buffer) 'plain-text
  47            (lambda (s) (when (string-match "text" s) (incf count))))
  48           count))))
  49   ;; Applies to secondary strings
  50   (should
  51    (org-element-map '("some " (bold nil "bold") "text") 'bold 'identity))
  52   ;; Enter secondary strings before entering contents.
  53   (should
  54    (equal
  55     "alpha"
  56     (org-element-property
  57      :name
  58      (org-test-with-temp-text "* Some \\alpha headline\n\\beta entity."
  59        (org-element-map (org-element-parse-buffer) 'entity 'identity nil t)))))
  60   ;; Apply NO-RECURSION argument.
  61   (should-not
  62    (org-test-with-temp-text "#+BEGIN_CENTER\n\\alpha\n#+END_CENTER"
  63      (org-element-map
  64       (org-element-parse-buffer) 'entity 'identity nil nil 'center-block))))
  65
  66
  67 \f
  68 ;;; Test Setters
  69
  70 (ert-deftest test-org-element/put-property ()
  71   "Test `org-element-put-property' specifications."
  72   (org-test-with-temp-text "* Headline\n *a*"
  73     (let ((tree (org-element-parse-buffer)))
  74       (org-element-put-property
  75        (org-element-map tree 'bold 'identity nil t) :test 1)
  76       (should (org-element-property
  77                :test (org-element-map tree 'bold 'identity nil t))))))
  78
  79 (ert-deftest test-org-element/set-contents ()
  80   "Test `org-element-set-contents' specifications."
  81   ;; Accept multiple entries.
  82   (should
  83    (equal '("b" (italic nil "a"))
  84           (org-test-with-temp-text "* Headline\n *a*"
  85             (let ((tree (org-element-parse-buffer)))
  86               (org-element-set-contents
  87                (org-element-map tree 'bold 'identity nil t) "b" '(italic nil "a"))
  88               (org-element-contents
  89                (org-element-map tree 'bold 'identity nil t))))))
  90   ;; Accept atoms and elements.
  91   (should
  92    (equal '("b")
  93           (org-test-with-temp-text "* Headline\n *a*"
  94             (let ((tree (org-element-parse-buffer)))
  95               (org-element-set-contents
  96                (org-element-map tree 'bold 'identity nil t) "b")
  97               (org-element-contents
  98                (org-element-map tree 'bold 'identity nil t))))))
  99   (should
 100    (equal '((italic nil "b"))
 101           (org-test-with-temp-text "* Headline\n *a*"
 102             (let ((tree (org-element-parse-buffer)))
 103               (org-element-set-contents
 104                (org-element-map tree 'bold 'identity nil t) '(italic nil "b"))
 105               (org-element-contents
 106                (org-element-map tree 'bold 'identity nil t))))))
 107   ;; Allow nil contents.
 108   (should-not
 109    (org-test-with-temp-text "* Headline\n *a*"
 110      (let ((tree (org-element-parse-buffer)))
 111        (org-element-set-contents (org-element-map tree 'bold 'identity nil t))
 112        (org-element-contents (org-element-map tree 'bold 'identity nil t))))))
 113
 114 (ert-deftest test-org-element/set-element ()
 115   "Test `org-element-set-element' specifications."
 116   (org-test-with-temp-text "* Headline\n*a*"
 117     (let ((tree (org-element-parse-buffer)))
 118       (org-element-set-element
 119        (org-element-map tree 'bold 'identity nil t)
 120        '(italic nil "b"))
 121       ;; Check if object is correctly replaced.
 122       (should (org-element-map tree 'italic 'identity))
 123       (should-not (org-element-map tree 'bold 'identity))
 124       ;; Check if new object's parent is correctly set.
 125       (should
 126        (eq
 127         (org-element-property :parent
 128                               (org-element-map tree 'italic 'identity nil t))
 129         (org-element-map tree 'paragraph 'identity nil t))))))
 130
 131 (ert-deftest test-org-element/adopt-elements ()
 132   "Test `org-element-adopt-elements' specifications."
 133   ;; Adopt an element.
 134   (should
 135    (equal '(plain-text italic)
 136           (org-test-with-temp-text "* Headline\n *a*"
 137             (let ((tree (org-element-parse-buffer)))
 138               (org-element-adopt-elements
 139                (org-element-map tree 'bold 'identity nil t) '(italic nil "a"))
 140               (mapcar (lambda (blob) (org-element-type blob))
 141                       (org-element-contents
 142                        (org-element-map tree 'bold 'identity nil t)))))))
 143   ;; Adopt a string.
 144   (should
 145    (equal '("a" "b")
 146           (org-test-with-temp-text "* Headline\n *a*"
 147             (let ((tree (org-element-parse-buffer)))
 148               (org-element-adopt-elements
 149                (org-element-map tree 'bold 'identity nil t) "b")
 150               (org-element-contents
 151                (org-element-map tree 'bold 'identity nil t)))))))
 152
 153
 154 \f
 155 ;;; Test Parsers
 156
 157 ;;;; Affiliated Keywords
 158
 159 (ert-deftest test-org-element/affiliated-keywords-parser ()
 160   "Test affiliated keywords parsing."
 161   ;; Read simple keywords.
 162   (should
 163    (equal "para"
 164           (org-element-property
 165            :name
 166            (org-test-with-temp-text "#+NAME: para\nParagraph"
 167              (org-element-at-point)))))
 168   ;; Parse multiple keywords.
 169   (should
 170    (equal
 171     '("line1" "line2")
 172     (org-element-property
 173      :attr_ascii
 174      (org-test-with-temp-text
 175          "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
 176        (org-element-at-point)))))
 177   ;; Parse "parsed" keywords.
 178   (should
 179    (equal
 180     '("caption")
 181     (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
 182       (car (org-element-property :caption (org-element-at-point))))))
 183   ;; Parse dual keywords.
 184   (should
 185    (equal
 186     '(("long") "short")
 187     (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
 188       (org-element-property :caption (org-element-at-point))))))
 189
 190
 191 ;;;; Babel Call
 192
 193 (ert-deftest test-org-element/babel-call-parser ()
 194   "Test `babel-call' parsing."
 195   ;; Standard test.
 196   (should
 197    (org-test-with-temp-text "#+CALL: test()"
 198      (org-element-map (org-element-parse-buffer) 'babel-call 'identity)))
 199   ;; Ignore case.
 200   (should
 201    (org-test-with-temp-text "#+call: test()"
 202      (org-element-map (org-element-parse-buffer) 'babel-call 'identity))))
 203
 204
 205 ;;;; Bold
 206
 207 (ert-deftest test-org-element/bold-parser ()
 208   "Test `bold' parser."
 209   ;; Standard test.
 210   (should
 211    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 212      (org-test-with-temp-text "*bold*"
 213        (org-element-map (org-element-parse-buffer) 'bold 'identity nil t))))
 214   ;; Multi-line markup.
 215   (should
 216    (equal
 217     (org-element-contents
 218      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 219        (org-test-with-temp-text "*first line\nsecond line*"
 220          (org-element-map (org-element-parse-buffer) 'bold 'identity nil t))))
 221     '("first line\nsecond line"))))
 222
 223
 224 ;;;; Center Block
 225
 226 (ert-deftest test-org-element/center-block-parser ()
 227   "Test `center-block' parser."
 228   ;; Standard test.
 229   (should
 230    (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
 231      (org-element-map (org-element-parse-buffer) 'center-block 'identity)))
 232   ;; Ignore case.
 233   (should
 234    (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
 235      (org-element-map (org-element-parse-buffer) 'center-block 'identity)))
 236   ;; Test folded block.
 237   (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
 238     (org-cycle)
 239     (should
 240      (org-element-property
 241       :hiddenp
 242       (org-element-map
 243        (org-element-parse-buffer) 'center-block 'identity nil t))))
 244   ;; Ignore incomplete block.
 245   (should-not
 246    (org-test-with-temp-text "#+BEGIN_CENTER"
 247      (org-element-map
 248       (org-element-parse-buffer) 'center-block 'identity nil t))))
 249
 250
 251 ;;;; Clock
 252
 253 (ert-deftest test-org-element/clock-parser ()
 254   "Test `clock' parser."
 255   ;; Running clock.
 256   (let* ((org-clock-string "CLOCK:")
 257          (clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
 258                   (org-element-map
 259                    (org-element-parse-buffer) 'clock 'identity nil t))))
 260     (should (eq (org-element-property :status clock) 'running))
 261     (should (equal (org-element-property :value clock)
 262                    "[2012-01-01 sun. 00:01]"))
 263     (should-not (org-element-property :time clock)))
 264   ;; Closed clock.
 265   (let* ((org-clock-string "CLOCK:")
 266          (clock (org-test-with-temp-text "
 267 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] =>  0:01"
 268                   (org-element-map
 269                    (org-element-parse-buffer) 'clock 'identity nil t))))
 270     (should (eq (org-element-property :status clock) 'closed))
 271     (should (equal (org-element-property :value clock)
 272                    "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
 273     (should (equal (org-element-property :time clock) "0:01"))))
 274
 275
 276 ;;;; Code
 277
 278 (ert-deftest test-org-element/code-parser ()
 279   "Test `code' parser."
 280   ;; Regular test.
 281   (should
 282    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 283      (org-test-with-temp-text "~code~"
 284        (org-element-map (org-element-parse-buffer) 'code 'identity))))
 285   ;; Multi-line markup.
 286   (should
 287    (equal
 288     (org-element-property
 289      :value
 290      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 291        (org-test-with-temp-text "~first line\nsecond line~"
 292          (org-element-map
 293           (org-element-parse-buffer) 'code 'identity nil t))))
 294     "first line\nsecond line")))
 295
 296
 297 ;;;; Comment
 298
 299 (ert-deftest test-org-element/comment-parser ()
 300   "Test `comment' parser."
 301   ;; Regular comment.
 302   (should
 303    (org-test-with-temp-text "# Comment"
 304      (org-element-map (org-element-parse-buffer) 'comment 'identity)))
 305   ;; Inline comment.
 306   (should
 307    (org-test-with-temp-text "  # Comment"
 308      (org-element-map (org-element-parse-buffer) 'comment 'identity)))
 309   ;; Preserve indentation.
 310   (should
 311    (equal
 312     (org-element-property
 313      :value
 314      (org-test-with-temp-text "# No blank\n#  One blank"
 315        (org-element-map (org-element-parse-buffer) 'comment 'identity nil t)))
 316     "No blank\n One blank"))
 317   ;; Comment with blank lines.
 318   (should
 319    (equal
 320     (org-element-property
 321      :value
 322      (org-test-with-temp-text "# First part\n# \n#\n# Second part"
 323        (org-element-map (org-element-parse-buffer) 'comment 'identity nil t)))
 324     "First part\n\n\nSecond part"))
 325   ;; Do not mix comments and keywords.
 326   (should
 327    (eq 1
 328        (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
 329          (length (org-element-map
 330                   (org-element-parse-buffer) 'comment 'identity)))))
 331   (should
 332    (equal "comment"
 333           (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
 334             (org-element-property
 335              :value
 336              (org-element-map
 337               (org-element-parse-buffer) 'comment 'identity nil t))))))
 338
 339
 340 ;;;; Comment Block
 341
 342 (ert-deftest test-org-element/comment-block-parser ()
 343   "Test `comment-block' parser."
 344   ;; Standard test.
 345   (should
 346    (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
 347      (org-element-map
 348       (org-element-parse-buffer) 'comment-block 'identity)))
 349   ;; Ignore case.
 350   (should
 351    (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
 352      (org-element-map
 353       (org-element-parse-buffer) 'comment-block 'identity)))
 354   ;; Test folded block.
 355   (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
 356     (org-cycle)
 357     (should
 358      (org-element-property
 359       :hiddenp
 360       (org-element-map
 361        (org-element-parse-buffer) 'comment-block 'identity nil t))))
 362   ;; Ignore incomplete block.
 363   (should-not
 364    (org-test-with-temp-text "#+BEGIN_COMMENT"
 365      (org-element-map
 366       (org-element-parse-buffer) 'comment-block 'identity nil t))))
 367
 368
 369 ;;;; Drawer
 370
 371 (ert-deftest test-org-element/drawer-parser ()
 372   "Test `drawer' parser."
 373   ;; Standard test.
 374   (should
 375    (let ((org-drawers '("TEST")))
 376      (org-test-with-temp-text ":TEST:\nText\n:END:"
 377        (org-element-map (org-element-parse-buffer) 'drawer 'identity))))
 378   ;; Do not mix regular drawers and property drawers.
 379   (should-not
 380    (let ((org-drawers '("PROPERTIES")))
 381      (org-test-with-temp-text ":PROPERTIES:\n:prop: value\n:END:"
 382        (org-element-map
 383         (org-element-parse-buffer) 'drawer 'identity nil t))))
 384   ;; Ignore incomplete drawer.
 385   (should-not
 386    (let ((org-drawers '("TEST")))
 387      (org-test-with-temp-text ":TEST:"
 388        (org-element-map
 389         (org-element-parse-buffer) 'drawer 'identity nil t)))))
 390
 391
 392 ;;;; Dynamic Block
 393
 394 (ert-deftest test-org-element/dynamic-block-parser ()
 395   "Test `dynamic-block' parser."
 396   ;; Standard test.
 397   (should
 398    (org-test-with-temp-text
 399        "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
 400      (org-element-map (org-element-parse-buffer) 'dynamic-block 'identity)))
 401   ;; Folded view
 402   (org-test-with-temp-text
 403       "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
 404     (org-cycle)
 405     (should
 406      (org-element-property
 407       :hiddenp
 408       (org-element-map
 409        (org-element-parse-buffer) 'dynamic-block 'identity nil t))))
 410   ;; Ignore case.
 411   (should
 412    (org-test-with-temp-text
 413        "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
 414      (org-element-map (org-element-parse-buffer) 'dynamic-block 'identity)))
 415   ;; Ignore incomplete block.
 416   (should-not
 417    (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
 418      (org-element-map
 419       (org-element-parse-buffer) 'dynamic-block 'identity nil t))))
 420
 421
 422 ;;;; Entity
 423
 424 (ert-deftest test-org-element/entity-parser ()
 425   "Test `entity' parser."
 426   ;; Without brackets.
 427   (should
 428    (org-test-with-temp-text "\\sin"
 429      (org-element-map (org-element-parse-buffer) 'entity 'identity)))
 430   ;; With brackets.
 431   (should
 432    (org-element-property
 433     :use-brackets-p
 434     (org-test-with-temp-text "\\alpha{}text"
 435       (org-element-map (org-element-parse-buffer) 'entity 'identity nil t))))
 436   ;; User-defined entity.
 437   (should
 438    (equal
 439     (org-element-property
 440      :name
 441      (let ((org-entities-user
 442             '(("test" "test" nil "test" "test" "test" "test"))))
 443        (org-test-with-temp-text "\\test"
 444          (org-element-map (org-element-parse-buffer) 'entity 'identity nil t))))
 445     "test")))
 446
 447
 448 ;;;; Example Block
 449
 450 (ert-deftest test-org-element/example-block-parser ()
 451   "Test `example-block' parser."
 452   ;; Standard test.
 453   (should
 454    (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
 455      (org-element-map (org-element-parse-buffer) 'example-block 'identity)))
 456   ;; Test folded block.
 457   (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
 458     (org-cycle)
 459     (should
 460      (org-element-property
 461       :hiddenp
 462       (org-element-map
 463        (org-element-parse-buffer) 'example-block 'identity nil t))))
 464   ;; Ignore incomplete block.
 465   (should-not
 466    (org-test-with-temp-text "#+BEGIN_EXAMPLE"
 467      (org-element-map
 468       (org-element-parse-buffer) 'example-block 'identity nil t)))
 469   ;; Properly un-escape code.
 470   (should
 471    (equal "* Headline\n #+keyword\nText\n"
 472           (org-test-with-temp-text
 473               "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
 474             (org-element-property :value (org-element-at-point))))))
 475
 476 (ert-deftest test-org-element/block-switches ()
 477   "Test `example-block' and `src-block' switches parsing."
 478   (let ((org-coderef-label-format "(ref:%s)"))
 479     ;; 1. Test "-i" switch.
 480     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 481       (should-not
 482        (org-element-property :preserve-indent (org-element-at-point))))
 483     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
 484       (should (org-element-property :preserve-indent (org-element-at-point))))
 485     (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 486       (should-not
 487        (org-element-property :preserve-indent (org-element-at-point))))
 488     (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
 489       (should (org-element-property :preserve-indent (org-element-at-point))))
 490     ;; 2. "-n -r -k" combination should number lines, retain labels but
 491     ;;    not use them in coderefs.
 492     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
 493       (let ((element (org-element-at-point)))
 494         (should (and (org-element-property :number-lines element)
 495                      (org-element-property :retain-labels element)
 496                      (not (org-element-property :use-labels element))))))
 497     (org-test-with-temp-text
 498         "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
 499       (let ((element (org-element-at-point)))
 500         (should (and (org-element-property :number-lines element)
 501                      (org-element-property :retain-labels element)
 502                      (not (org-element-property :use-labels element))))))
 503     ;; 3. "-n -r" combination should number-lines remove labels and not
 504     ;;    use them in coderefs.
 505     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
 506       (let ((element (org-element-at-point)))
 507         (should (and (org-element-property :number-lines element)
 508                      (not (org-element-property :retain-labels element))
 509                      (not (org-element-property :use-labels element))))))
 510     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
 511       (let ((element (org-element-at-point)))
 512         (should (and (org-element-property :number-lines element)
 513                      (not (org-element-property :retain-labels element))
 514                      (not (org-element-property :use-labels element))))))
 515     ;; 4. "-n" or "+n" should number lines, retain labels and use them
 516     ;;    in coderefs.
 517     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
 518       (let ((element (org-element-at-point)))
 519         (should (and (org-element-property :number-lines element)
 520                      (org-element-property :retain-labels element)
 521                      (org-element-property :use-labels element)))))
 522     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
 523       (let ((element (org-element-at-point)))
 524         (should (and (org-element-property :number-lines element)
 525                      (org-element-property :retain-labels element)
 526                      (org-element-property :use-labels element)))))
 527     (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
 528       (let ((element (org-element-at-point)))
 529         (should (and (org-element-property :number-lines element)
 530                      (org-element-property :retain-labels element)
 531                      (org-element-property :use-labels element)))))
 532     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
 533       (let ((element (org-element-at-point)))
 534         (should (and (org-element-property :number-lines element)
 535                      (org-element-property :retain-labels element)
 536                      (org-element-property :use-labels element)))))
 537     ;; 5. No switch should not number lines, but retain labels and use
 538     ;;    them in coderefs.
 539     (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 540       (let ((element (org-element-at-point)))
 541         (should (and (not (org-element-property :number-lines element))
 542                      (org-element-property :retain-labels element)
 543                      (org-element-property :use-labels element)))))
 544     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 545       (let ((element (org-element-at-point)))
 546         (should (and (not (org-element-property :number-lines element))
 547                      (org-element-property :retain-labels element)
 548                      (org-element-property :use-labels element)))))
 549     ;; 6. "-r" switch only: do not number lines, remove labels, and
 550     ;;    don't use labels in coderefs.
 551     (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
 552       (let ((element (org-element-at-point)))
 553         (should (and (not (org-element-property :number-lines element))
 554                      (not (org-element-property :retain-labels element))
 555                      (not (org-element-property :use-labels element))))))
 556     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
 557       (let ((element (org-element-at-point)))
 558         (should (and (not (org-element-property :number-lines element))
 559                      (not (org-element-property :retain-labels element))
 560                      (not (org-element-property :use-labels element))))))
 561     ;; 7. Recognize coderefs with user-defined syntax.
 562     (org-test-with-temp-text
 563         "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
 564       (let ((element (org-element-at-point)))
 565         (should
 566          (equal (org-element-property :label-fmt element) "[ref:%s]"))))
 567     (org-test-with-temp-text
 568         "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
 569       (let ((element (org-element-at-point)))
 570         (should
 571          (equal (org-element-property :label-fmt element) "[ref:%s]"))))))
 572
 573
 574 ;;;; Export Block
 575
 576 (ert-deftest test-org-element/export-block-parser ()
 577   "Test `export-block' parser."
 578   ;; Standard test.
 579   (should
 580    (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
 581      (org-element-map
 582       (let ((org-element-block-name-alist
 583              '(("LATEX" . org-element-export-block-parser))))
 584         (org-element-parse-buffer))
 585       'export-block 'identity)))
 586   ;; Test folded block.
 587   (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
 588     (org-cycle)
 589     (should
 590      (org-element-property
 591       :hiddenp
 592       (org-element-map
 593        (let ((org-element-block-name-alist
 594               '(("LATEX" . org-element-export-block-parser))))
 595          (org-element-parse-buffer))
 596        'export-block 'identity nil t))))
 597   ;; Ignore case.
 598   (should
 599    (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
 600      (org-element-map
 601       (let ((org-element-block-name-alist
 602              '(("LATEX" . org-element-export-block-parser))))
 603         (org-element-parse-buffer))
 604       'export-block 'identity)))
 605   ;; Ignore incomplete block.
 606   (should-not
 607    (org-test-with-temp-text "#+BEGIN_LATEX"
 608      (org-element-map
 609       (let ((org-element-block-name-alist
 610              '(("LATEX" . org-element-export-block-parser))))
 611         (org-element-parse-buffer))
 612       'export-block 'identity nil t))))
 613
 614
 615 ;;;; Export Snippet
 616
 617 (ert-deftest test-org-element/export-snippet-parser ()
 618   "Test `export-snippet' parser."
 619   (should
 620    (equal
 621     '("back-end" . "contents")
 622     (org-test-with-temp-text "@@back-end:contents@@"
 623       (org-element-map
 624        (org-element-parse-buffer) 'export-snippet
 625        (lambda (snippet) (cons (org-element-property :back-end snippet)
 626                           (org-element-property :value snippet)))
 627        nil t)))))
 628
 629
 630 ;;;; Fixed Width
 631
 632 (ert-deftest test-org-element/fixed-width ()
 633   "Test fixed-width area parsing."
 634   ;; Preserve indentation.
 635   (should
 636    (org-test-with-temp-text ": no blank\n:  one blank"
 637      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 638   ;; Fixed-width with empty lines.
 639   (should
 640    (org-test-with-temp-text ": first part\n:\n: \n: second part"
 641      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 642   ;; Parse indented fixed-width markers.
 643   (should
 644    (org-test-with-temp-text "Text\n  : no blank\n  :  one blank"
 645      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 646   ;; Distinguish fixed-width areas within a list and outside of it.
 647   (should
 648    (= 2
 649       (length
 650        (org-test-with-temp-text "
 651 - Item
 652   : fixed-width inside
 653 : fixed-width outside"
 654          (org-element-map
 655           (org-element-parse-buffer) 'fixed-width 'identity))))))
 656
 657
 658 ;;;; Footnote Definition
 659
 660 (ert-deftest test-org-element/footnote-definition-parser ()
 661   "Test `footnote-definition' parser."
 662   (should
 663    (org-test-with-temp-text "[fn:1] Definition"
 664      (org-element-map
 665       (org-element-parse-buffer) 'footnote-definition 'identity nil t)))
 666   ;; Footnote with more contents
 667   (should
 668    (= 28
 669       (org-element-property
 670        :end
 671        (org-test-with-temp-text "[fn:1] Definition\n| a | b |"
 672          (org-element-map
 673           (org-element-parse-buffer)
 674           'footnote-definition 'identity nil t)))))
 675   ;; Footnote starting with special syntax.
 676   (should-not
 677    (org-test-with-temp-text "[fn:1] - no item"
 678      (org-element-map (org-element-parse-buffer) 'item 'identity))))
 679
 680
 681 ;;;; Footnotes Reference.
 682
 683 (ert-deftest test-org-element/footnote-reference-parser ()
 684   "Test `footnote-reference' parser."
 685   ;; 1. Parse a standard reference.
 686   (org-test-with-temp-text "Text[fn:label]"
 687     (should
 688      (org-element-map
 689       (org-element-parse-buffer) 'footnote-reference 'identity)))
 690   ;; 2. Parse a normalized reference.
 691   (org-test-with-temp-text "Text[1]"
 692     (should
 693      (org-element-map
 694       (org-element-parse-buffer) 'footnote-reference 'identity)))
 695   ;; 3. Parse an inline reference.
 696   (org-test-with-temp-text "Text[fn:test:def]"
 697     (should
 698      (org-element-map
 699       (org-element-parse-buffer) 'footnote-reference 'identity)))
 700   ;; 4. Parse an anonymous reference.
 701   (org-test-with-temp-text "Text[fn::def]"
 702     (should
 703      (org-element-map
 704       (org-element-parse-buffer) 'footnote-reference 'identity)))
 705   ;; 5. Parse nested footnotes.
 706   (org-test-with-temp-text "Text[fn::def [fn:label]]"
 707     (should
 708      (= 2
 709         (length
 710          (org-element-map
 711           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 712   ;; 6. Parse adjacent footnotes.
 713   (org-test-with-temp-text "Text[fn:label1][fn:label2]"
 714     (should
 715      (= 2
 716         (length
 717          (org-element-map
 718           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 719   ;; 7. Only properly closed footnotes are recognized as such.
 720   (org-test-with-temp-text "Text[fn:label"
 721     (should-not
 722      (org-element-map
 723       (org-element-parse-buffer) 'footnote-reference 'identity))))
 724
 725
 726 ;;;; Headline
 727
 728 (ert-deftest test-org-element/headline-quote-keyword ()
 729   "Test QUOTE keyword recognition."
 730   ;; Reference test.
 731   (org-test-with-temp-text "* Headline"
 732     (let ((org-quote-string "QUOTE"))
 733       (should-not (org-element-property :quotedp (org-element-at-point)))))
 734   ;; Standard position.
 735   (org-test-with-temp-text "* QUOTE Headline"
 736     (let* ((org-quote-string "QUOTE")
 737            (headline (org-element-at-point)))
 738       (should (org-element-property :quotedp headline))
 739       ;; Test removal from raw value.
 740       (should (equal (org-element-property :raw-value headline) "Headline"))))
 741   ;; Case sensitivity.
 742   (org-test-with-temp-text "* QUOTE Headline"
 743     (let* ((org-quote-string "Quote")
 744            (headline (org-element-at-point)))
 745       (should-not (org-element-property :quotedp headline))
 746       (should (equal (org-element-property :raw-value headline)
 747                      "QUOTE Headline"))))
 748   ;; With another keyword.
 749   (org-test-with-temp-text "* TODO QUOTE Headline"
 750     (let* ((org-quote-string "QUOTE")
 751            (org-todo-keywords '((sequence "TODO" "DONE")))
 752            (headline (org-element-at-point)))
 753       (should (org-element-property :quotedp headline))
 754       (should (equal (org-element-property :raw-value headline) "Headline"))))
 755   ;; With the keyword only.
 756   (org-test-with-temp-text "* QUOTE"
 757     (let* ((org-quote-string "QUOTE")
 758            (headline (org-element-at-point)))
 759       (should (org-element-property :quotedp headline))
 760       (should (equal (org-element-property :raw-value headline) "")))))
 761
 762 (ert-deftest test-org-element/headline-comment-keyword ()
 763   "Test COMMENT keyword recognition."
 764   ;; Reference test.
 765   (org-test-with-temp-text "* Headline"
 766     (let ((org-comment-string "COMMENT"))
 767       (should-not (org-element-property :commentedp (org-element-at-point)))))
 768   ;; Standard position.
 769   (org-test-with-temp-text "* COMMENT Headline"
 770     (let ((org-comment-string "COMMENT")
 771           (headline (org-element-at-point)))
 772       (should (org-element-property :commentedp headline))
 773       (should (equal (org-element-property :raw-value headline) "Headline"))))
 774   ;; Case sensitivity.
 775   (org-test-with-temp-text "* COMMENT Headline"
 776     (let* ((org-comment-string "Comment")
 777            (headline (org-element-at-point)))
 778       (should-not (org-element-property :commentedp headline))
 779       (should (equal (org-element-property :raw-value headline)
 780                      "COMMENT Headline"))))
 781   ;; With another keyword.
 782   (org-test-with-temp-text "* TODO COMMENT Headline"
 783     (let* ((org-comment-string "COMMENT")
 784            (org-todo-keywords '((sequence "TODO" "DONE")))
 785            (headline (org-element-at-point)))
 786       (should (org-element-property :commentedp headline))
 787       (should (equal (org-element-property :raw-value headline) "Headline"))))
 788   ;; With the keyword only.
 789   (org-test-with-temp-text "* COMMENT"
 790     (let* ((org-comment-string "COMMENT")
 791            (headline (org-element-at-point)))
 792       (should (org-element-property :commentedp headline))
 793       (should (equal (org-element-property :raw-value headline) "")))))
 794
 795 (ert-deftest test-org-element/headline-archive-tag ()
 796   "Test ARCHIVE tag recognition."
 797   ;; Reference test.
 798   (org-test-with-temp-text "* Headline"
 799     (let ((org-archive-tag "ARCHIVE"))
 800       (should-not (org-element-property :archivedp (org-element-at-point)))))
 801   ;; Single tag.
 802   (org-test-with-temp-text "* Headline :ARCHIVE:"
 803     (let ((org-archive-tag "ARCHIVE"))
 804       (let ((headline (org-element-at-point)))
 805         (should (org-element-property :archivedp headline))
 806         ;; Test tag removal.
 807         (should-not (org-element-property :tags headline))))
 808     (let ((org-archive-tag "Archive"))
 809       (should-not (org-element-property :archivedp (org-element-at-point)))))
 810   ;; Multiple tags.
 811   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
 812     (let ((org-archive-tag "ARCHIVE"))
 813       (let ((headline (org-element-at-point)))
 814         (should (org-element-property :archivedp headline))
 815         ;; Test tag removal.
 816         (should (equal (org-element-property :tags headline) '("test")))))))
 817
 818
 819 ;;;; Horizontal Rule
 820
 821 (ert-deftest test-org-element/horizontal-rule-parser ()
 822   "Test `horizontal-rule' parser."
 823   ;; Standard.
 824   (should
 825    (org-test-with-temp-text "-----"
 826      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 827   ;; Indented.
 828   (should
 829    (org-test-with-temp-text "  -----"
 830      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 831   ;; Hyphen must be alone on the line.
 832   (should-not
 833    (org-test-with-temp-text "-----wrong"
 834      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 835   ;; 4 hyphens is too small.
 836   (should-not
 837    (org-test-with-temp-text "----"
 838      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity))))
 839
 840
 841 ;;;; Inline Babel Call
 842
 843 (ert-deftest test-org-element/inline-babel-call-parser ()
 844   "Test `inline-babel-call' parser."
 845   (should
 846    (org-test-with-temp-text "call_test()"
 847      (org-element-map
 848       (org-element-parse-buffer) 'inline-babel-call 'identity))))
 849
 850
 851 ;;;; Inline Src Block
 852
 853 (ert-deftest test-org-element/inline-src-block-parser ()
 854   "Test `inline-src-block' parser."
 855   (should
 856    (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
 857      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
 858   ;; Test parsing at the beginning of an item.
 859   (should
 860    (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
 861      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity))))
 862
 863
 864 ;;;; Inlinetask
 865
 866 (ert-deftest test-org-element/inlinetask-parser ()
 867   "Test `inlinetask' parser."
 868   (when (featurep 'org-inlinetask)
 869     (let ((org-inlinetask-min-level 15))
 870       ;; 1. Regular inlinetask.
 871       (should
 872        (org-test-with-temp-text
 873            "*************** Task\nTest\n*************** END"
 874          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 875       ;; 2. Degenerate inlinetask.
 876       (should
 877        (org-test-with-temp-text "*************** Task"
 878          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 879       ;; TODO keyword.
 880       (should
 881        (equal
 882         "TODO"
 883         (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
 884           (org-test-with-temp-text "*************** TODO Task"
 885             (org-element-property
 886              :todo-keyword
 887              (org-element-map
 888               (org-element-parse-buffer) 'inlinetask 'identity nil t))))))
 889       ;; Planning info.
 890       (should
 891        (equal
 892         "2012-03-29 thu."
 893         (org-test-with-temp-text "
 894 *************** Task
 895 DEADLINE: <2012-03-29 thu.>"
 896           (org-element-property
 897            :deadline
 898            (org-element-map
 899             (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
 900       ;; Priority.
 901       (should
 902        (equal
 903         ?A
 904         (org-test-with-temp-text "
 905 *************** [#A] Task"
 906           (org-element-property
 907            :priority
 908            (org-element-map
 909             (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
 910       ;; Tags.
 911       (should
 912        (equal
 913         '("test")
 914         (org-test-with-temp-text "
 915 *************** Task :test:"
 916           (org-element-property
 917            :tags
 918            (org-element-map
 919             (org-element-parse-buffer) 'inlinetask 'identity nil t))))))))
 920
 921
 922 ;;;; Italic
 923
 924 (ert-deftest test-org-element/italic-parser ()
 925   "Test `italic' parser."
 926   ;; Regular test.
 927   (should
 928    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 929      (org-test-with-temp-text "/italic/"
 930        (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
 931   ;; Multi-line markup.
 932   (should
 933    (equal
 934     (org-element-contents
 935      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 936        (org-test-with-temp-text "/first line\nsecond line/"
 937          (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
 938     '("first line\nsecond line"))))
 939
 940
 941 ;;;; Item
 942
 943 (ert-deftest test-org-element/item-parser ()
 944   "Test `item' parser."
 945   ;; Standard test.
 946   (should
 947    (org-test-with-temp-text "- item"
 948      (org-element-map (org-element-parse-buffer) 'item 'identity)))
 949   ;; Counter.
 950   (should
 951    (= 6
 952       (org-element-property
 953        :counter
 954        (org-test-with-temp-text "6. [@6] item"
 955          (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
 956   ;; Tag
 957   (should
 958    (equal
 959     '("tag")
 960     (org-element-property
 961      :tag
 962      (org-test-with-temp-text "- tag :: description"
 963        (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
 964   ;; No tags in ordered lists.
 965   (should-not
 966    (org-element-property
 967     :tag
 968     (org-test-with-temp-text "1. tag :: description"
 969       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
 970   ;; Check-boxes
 971   (should
 972    (equal
 973     '(trans on off)
 974     (org-test-with-temp-text "
 975 - [-] item 1
 976   - [X] item 1.1
 977   - [ ] item 1.2"
 978       (org-element-map
 979        (org-element-parse-buffer) 'item
 980        (lambda (item) (org-element-property :checkbox item))))))
 981   ;; Folded state.
 982   (org-test-with-temp-text "* Headline
 983 - item
 984
 985   paragraph below"
 986     (forward-line)
 987     (let ((org-cycle-include-plain-lists t)) (org-cycle))
 988     (should
 989      (org-element-property
 990       :hiddenp
 991       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
 992   ;; Item starting with special syntax.
 993   (should
 994    (equal '(("- item"))
 995           (org-test-with-temp-text "- - item"
 996             (org-element-map
 997              (org-element-parse-buffer) 'paragraph 'org-element-contents)))))
 998
 999
1000 ;;;; Keyword
1001
1002 (ert-deftest test-org-element/keyword-parser ()
1003   "Test `keyword' parser."
1004   ;; Standard test.
1005   (should
1006    (org-test-with-temp-text "#+KEYWORD: value"
1007      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1008   ;; Keywords are case-insensitive.
1009   (should
1010    (org-test-with-temp-text "#+keyword: value"
1011      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1012   ;; Affiliated keywords are not keywords.
1013   (should-not
1014    (org-test-with-temp-text "#+NAME: value
1015 Paragraph"
1016      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1017   ;; Do not mix keywords with Babel calls and dynamic blocks.
1018   (should-not
1019    (org-test-with-temp-text "#+CALL: fun()"
1020      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1021   (should-not
1022    (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1023      (org-element-map (org-element-parse-buffer) 'keyword 'identity))))
1024
1025
1026 ;;;; Latex Environment
1027
1028 (ert-deftest test-org-element/latex-environment-parser ()
1029   "Test `latex-environment' parser."
1030   (should
1031    (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1032      (org-element-map
1033       (org-element-parse-buffer) 'latex-environment 'identity)))
1034   ;; Allow nested environments.
1035   (should
1036    (equal
1037     "\\begin{outer}
1038 \\begin{inner}
1039 e^{i\\pi}+1=0
1040 \\end{inner}
1041 \\end{outer}"
1042     (org-test-with-temp-text "
1043 \\begin{outer}
1044 \\begin{inner}
1045 e^{i\\pi}+1=0
1046 \\end{inner}
1047 \\end{outer}"
1048       (org-element-property
1049        :value
1050        (org-element-map
1051         (org-element-parse-buffer) 'latex-environment 'identity nil t))))))
1052
1053
1054 ;;;; Latex Fragment
1055
1056 (ert-deftest test-org-element/latex-fragment-parser ()
1057   "Test `latex-fragment' parser."
1058   (let ((org-latex-regexps
1059          '(("begin" "^[         ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^