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