testing/lisp/test-org-element.el

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