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   ;; Special case: entity at the end of a container.
 506   (should
 507    (eq 'entity
 508        (org-test-with-temp-text "*\\alpha \\beta*"
 509          (search-forward "be")
 510          (org-element-type (org-element-context))))))
 511
 512
 513 ;;;; Example Block
 514
 515 (ert-deftest test-org-element/example-block-parser ()
 516   "Test `example-block' parser."
 517   ;; Standard test.
 518   (should
 519    (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
 520      (org-element-map (org-element-parse-buffer) 'example-block 'identity)))
 521   ;; Test folded block.
 522   (should
 523    (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
 524      (org-cycle)
 525      (org-element-property :hiddenp (org-element-at-point))))
 526   ;; Ignore incomplete block.
 527   (should-not
 528    (eq 'example-block
 529        (org-test-with-temp-text "#+BEGIN_EXAMPLE"
 530          (org-element-type (org-element-at-point)))))
 531   ;; Properly un-escape code.
 532   (should
 533    (equal "* Headline\n #+keyword\nText\n"
 534           (org-test-with-temp-text
 535               "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
 536             (org-element-property :value (org-element-at-point)))))
 537   ;; Nil `org-src-preserve-indentation': Remove maximum common
 538   ;; indentation.
 539   (should
 540    (equal " L1\nL2\n"
 541           (org-test-with-temp-text "#+BEGIN_EXAMPLE\n  L1\n L2\n#+END_EXAMPLE"
 542             (let ((org-src-preserve-indentation nil))
 543               (org-element-property :value (org-element-at-point))))))
 544   ;; Non-nil `org-src-preserve-indentation': Remove block indentation
 545   ;; only, unless block contents are less indented than block
 546   ;; boundaries.
 547   (should
 548    (equal " L1\nL2\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   (should
 553    (equal
 554     "  L1\n L2\n"
 555     (org-test-with-temp-text "  #+BEGIN_EXAMPLE\n  L1\n L2\n  #+END_EXAMPLE"
 556       (let ((org-src-preserve-indentation t))
 557         (org-element-property :value (org-element-at-point)))))))
 558
 559 (ert-deftest test-org-element/block-switches ()
 560   "Test `example-block' and `src-block' switches parsing."
 561   (let ((org-coderef-label-format "(ref:%s)"))
 562     ;; 1. Test "-i" switch.
 563     (should-not
 564      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 565        (org-element-property :preserve-indent (org-element-at-point))))
 566     (should
 567      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
 568        (org-element-property :preserve-indent (org-element-at-point))))
 569     (should-not
 570      (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 571        (org-element-property :preserve-indent (org-element-at-point))))
 572     (should
 573      (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
 574        (org-element-property :preserve-indent (org-element-at-point))))
 575     ;; 2. "-n -r -k" combination should number lines, retain labels but
 576     ;;    not use them in coderefs.
 577     (should
 578      (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
 579        (let ((element (org-element-at-point)))
 580          (and (org-element-property :number-lines element)
 581               (org-element-property :retain-labels element)
 582               (not (org-element-property :use-labels element))))))
 583     (should
 584      (org-test-with-temp-text
 585          "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
 586        (let ((element (org-element-at-point)))
 587          (and (org-element-property :number-lines element)
 588               (org-element-property :retain-labels element)
 589               (not (org-element-property :use-labels element))))))
 590     ;; 3. "-n -r" combination should number-lines remove labels and not
 591     ;;    use them in coderefs.
 592     (should
 593      (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
 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     (should
 599      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
 600        (let ((element (org-element-at-point)))
 601          (and (org-element-property :number-lines element)
 602               (not (org-element-property :retain-labels element))
 603               (not (org-element-property :use-labels element))))))
 604     ;; 4. "-n" or "+n" should number lines, retain labels and use them
 605     ;;    in coderefs.
 606     (should
 607      (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
 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_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
 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_EXAMPLE +n\nText.\n#+END_EXAMPLE"
 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     (should
 625      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
 626        (let ((element (org-element-at-point)))
 627          (and (org-element-property :number-lines element)
 628               (org-element-property :retain-labels element)
 629               (org-element-property :use-labels element)))))
 630     ;; 5. No switch should not number lines, but retain labels and use
 631     ;;    them in coderefs.
 632     (should
 633      (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 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     (should
 639      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 640        (let ((element (org-element-at-point)))
 641          (and (not (org-element-property :number-lines element))
 642               (org-element-property :retain-labels element)
 643               (org-element-property :use-labels element)))))
 644     ;; 6. "-r" switch only: do not number lines, remove labels, and
 645     ;;    don't use labels in coderefs.
 646     (should
 647      (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
 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     (should
 653      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
 654        (let ((element (org-element-at-point)))
 655          (and (not (org-element-property :number-lines element))
 656               (not (org-element-property :retain-labels element))
 657               (not (org-element-property :use-labels element))))))
 658     ;; 7. Recognize coderefs with user-defined syntax.
 659     (should
 660      (equal
 661       "[ref:%s]"
 662       (org-test-with-temp-text
 663           "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
 664         (org-element-property :label-fmt (org-element-at-point)))))
 665     (should
 666      (equal
 667       "[ref:%s]"
 668       (org-test-with-temp-text
 669           "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
 670         (org-element-property :label-fmt (org-element-at-point)))))))
 671
 672
 673 ;;;; Export Block
 674
 675 (ert-deftest test-org-element/export-block-parser ()
 676   "Test `export-block' parser."
 677   ;; Standard test.
 678   (should
 679    (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
 680      (org-element-map
 681       (let ((org-element-block-name-alist
 682              '(("LATEX" . org-element-export-block-parser))))
 683         (org-element-parse-buffer))
 684       'export-block 'identity)))
 685   ;; Test folded block.
 686   (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
 687     (org-cycle)
 688     (should
 689      (org-element-property
 690       :hiddenp
 691       (org-element-map
 692        (let ((org-element-block-name-alist
 693               '(("LATEX" . org-element-export-block-parser))))
 694          (org-element-parse-buffer))
 695        'export-block 'identity nil t))))
 696   ;; Ignore case.
 697   (should
 698    (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
 699      (org-element-map
 700       (let ((org-element-block-name-alist
 701              '(("LATEX" . org-element-export-block-parser))))
 702         (org-element-parse-buffer))
 703       'export-block 'identity)))
 704   ;; Ignore incomplete block.
 705   (should-not
 706    (org-test-with-temp-text "#+BEGIN_LATEX"
 707      (org-element-map
 708       (let ((org-element-block-name-alist
 709              '(("LATEX" . org-element-export-block-parser))))
 710         (org-element-parse-buffer))
 711       'export-block 'identity nil t))))
 712
 713
 714 ;;;; Export Snippet
 715
 716 (ert-deftest test-org-element/export-snippet-parser ()
 717   "Test `export-snippet' parser."
 718   (should
 719    (equal
 720     '("back-end" . "contents")
 721     (org-test-with-temp-text "@@back-end:contents@@"
 722       (org-element-map
 723        (org-element-parse-buffer) 'export-snippet
 724        (lambda (snippet) (cons (org-element-property :back-end snippet)
 725                           (org-element-property :value snippet)))
 726        nil t)))))
 727
 728
 729 ;;;; Fixed Width
 730
 731 (ert-deftest test-org-element/fixed-width ()
 732   "Test fixed-width area parsing."
 733   ;; Preserve indentation.
 734   (should
 735    (org-test-with-temp-text ": no blank\n:  one blank"
 736      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 737   ;; Fixed-width with empty lines.
 738   (should
 739    (org-test-with-temp-text ": first part\n:\n: \n: second part"
 740      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 741   ;; Parse indented fixed-width markers.
 742   (should
 743    (org-test-with-temp-text "Text\n  : no blank\n  :  one blank"
 744      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 745   ;; Distinguish fixed-width areas within a list and outside of it.
 746   (should
 747    (= 2
 748       (length
 749        (org-test-with-temp-text "
 750 - Item
 751   : fixed-width inside
 752 : fixed-width outside"
 753          (org-element-map
 754           (org-element-parse-buffer) 'fixed-width 'identity))))))
 755
 756
 757 ;;;; Footnote Definition
 758
 759 (ert-deftest test-org-element/footnote-definition-parser ()
 760   "Test `footnote-definition' parser."
 761   (should
 762    (org-test-with-temp-text "[fn:1] Definition"
 763      (org-element-map (org-element-parse-buffer) 'footnote-definition
 764        'identity nil t)))
 765   ;; Footnote with more contents
 766   (should
 767    (= 29
 768       (org-element-property
 769        :end
 770        (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
 771          (org-element-map (org-element-parse-buffer) 'footnote-definition
 772            'identity nil t)))))
 773   ;; Footnote starting with special syntax.
 774   (should-not
 775    (org-test-with-temp-text "[fn:1] - no item"
 776      (org-element-map (org-element-parse-buffer) 'item 'identity)))
 777   ;; Correctly handle footnote starting with an empty line.
 778   (should
 779    (= 9
 780       (org-test-with-temp-text "[fn:1]\n\n  Body"
 781         (org-element-property :contents-begin
 782                               (org-element-at-point))))))
 783
 784
 785 ;;;; Footnotes Reference.
 786
 787 (ert-deftest test-org-element/footnote-reference-parser ()
 788   "Test `footnote-reference' parser."
 789   ;; 1. Parse a standard reference.
 790   (org-test-with-temp-text "Text[fn:label]"
 791     (should
 792      (org-element-map
 793       (org-element-parse-buffer) 'footnote-reference 'identity)))
 794   ;; 2. Parse a normalized reference.
 795   (org-test-with-temp-text "Text[1]"
 796     (should
 797      (org-element-map
 798       (org-element-parse-buffer) 'footnote-reference 'identity)))
 799   ;; 3. Parse an inline reference.
 800   (org-test-with-temp-text "Text[fn:test:def]"
 801     (should
 802      (org-element-map
 803       (org-element-parse-buffer) 'footnote-reference 'identity)))
 804   ;; 4. Parse an anonymous reference.
 805   (org-test-with-temp-text "Text[fn::def]"
 806     (should
 807      (org-element-map
 808       (org-element-parse-buffer) 'footnote-reference 'identity)))
 809   ;; 5. Parse nested footnotes.
 810   (org-test-with-temp-text "Text[fn::def [fn:label]]"
 811     (should
 812      (= 2
 813         (length
 814          (org-element-map
 815           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 816   ;; 6. Parse adjacent footnotes.
 817   (org-test-with-temp-text "Text[fn:label1][fn:label2]"
 818     (should
 819      (= 2
 820         (length
 821          (org-element-map
 822           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 823   ;; 7. Only properly closed footnotes are recognized as such.
 824   (org-test-with-temp-text "Text[fn:label"
 825     (should-not
 826      (org-element-map
 827       (org-element-parse-buffer) 'footnote-reference 'identity))))
 828
 829
 830 ;;;; Headline
 831
 832 (ert-deftest test-org-element/headline-quote-keyword ()
 833   "Test QUOTE keyword recognition."
 834   ;; Reference test.
 835   (org-test-with-temp-text "* Headline"
 836     (let ((org-quote-string "QUOTE"))
 837       (should-not (org-element-property :quotedp (org-element-at-point)))))
 838   ;; Standard position.
 839   (org-test-with-temp-text "* QUOTE Headline"
 840     (let* ((org-quote-string "QUOTE")
 841            (headline (org-element-at-point)))
 842       (should (org-element-property :quotedp headline))
 843       ;; Test removal from raw value.
 844       (should (equal (org-element-property :raw-value headline) "Headline"))))
 845   ;; Case sensitivity.
 846   (org-test-with-temp-text "* QUOTE Headline"
 847     (let* ((org-quote-string "Quote")
 848            (headline (org-element-at-point)))
 849       (should-not (org-element-property :quotedp headline))
 850       (should (equal (org-element-property :raw-value headline)
 851                      "QUOTE Headline"))))
 852   ;; With another keyword.
 853   (org-test-with-temp-text "* TODO QUOTE Headline"
 854     (let* ((org-quote-string "QUOTE")
 855            (org-todo-keywords '((sequence "TODO" "DONE")))
 856            (headline (org-element-at-point)))
 857       (should (org-element-property :quotedp headline))
 858       (should (equal (org-element-property :raw-value headline) "Headline"))))
 859   ;; With the keyword only.
 860   (org-test-with-temp-text "* QUOTE"
 861     (let* ((org-quote-string "QUOTE")
 862            (headline (org-element-at-point)))
 863       (should (org-element-property :quotedp headline))
 864       (should (equal (org-element-property :raw-value headline) "")))))
 865
 866 (ert-deftest test-org-element/headline-comment-keyword ()
 867   "Test COMMENT keyword recognition."
 868   ;; Reference test.
 869   (org-test-with-temp-text "* Headline"
 870     (let ((org-comment-string "COMMENT"))
 871       (should-not (org-element-property :commentedp (org-element-at-point)))))
 872   ;; Standard position.
 873   (org-test-with-temp-text "* COMMENT Headline"
 874     (let ((org-comment-string "COMMENT")
 875           (headline (org-element-at-point)))
 876       (should (org-element-property :commentedp headline))
 877       (should (equal (org-element-property :raw-value headline) "Headline"))))
 878   ;; Case sensitivity.
 879   (org-test-with-temp-text "* COMMENT Headline"
 880     (let* ((org-comment-string "Comment")
 881            (headline (org-element-at-point)))
 882       (should-not (org-element-property :commentedp headline))
 883       (should (equal (org-element-property :raw-value headline)
 884                      "COMMENT Headline"))))
 885   ;; With another keyword.
 886   (org-test-with-temp-text "* TODO COMMENT Headline"
 887     (let* ((org-comment-string "COMMENT")
 888            (org-todo-keywords '((sequence "TODO" "DONE")))
 889            (headline (org-element-at-point)))
 890       (should (org-element-property :commentedp headline))
 891       (should (equal (org-element-property :raw-value headline) "Headline"))))
 892   ;; With the keyword only.
 893   (org-test-with-temp-text "* COMMENT"
 894     (let* ((org-comment-string "COMMENT")
 895            (headline (org-element-at-point)))
 896       (should (org-element-property :commentedp headline))
 897       (should (equal (org-element-property :raw-value headline) "")))))
 898
 899 (ert-deftest test-org-element/headline-archive-tag ()
 900   "Test ARCHIVE tag recognition."
 901   ;; Reference test.
 902   (org-test-with-temp-text "* Headline"
 903     (let ((org-archive-tag "ARCHIVE"))
 904       (should-not (org-element-property :archivedp (org-element-at-point)))))
 905   ;; Single tag.
 906   (org-test-with-temp-text "* Headline :ARCHIVE:"
 907     (let ((org-archive-tag "ARCHIVE"))
 908       (let ((headline (org-element-at-point)))
 909         (should (org-element-property :archivedp headline))
 910         ;; Test tag removal.
 911         (should-not (org-element-property :tags headline))))
 912     (let ((org-archive-tag "Archive"))
 913       (should-not (org-element-property :archivedp (org-element-at-point)))))
 914   ;; Multiple tags.
 915   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
 916     (let ((org-archive-tag "ARCHIVE"))
 917       (let ((headline (org-element-at-point)))
 918         (should (org-element-property :archivedp headline))
 919         ;; Test tag removal.
 920         (should (equal (org-element-property :tags headline) '("test")))))))
 921
 922 (ert-deftest test-org-element/headline-properties ()
 923   "Test properties from property drawer."
 924   ;; All properties from property drawer have their symbol upper
 925   ;; cased.
 926   (should
 927    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
 928      (org-element-property :FOO (org-element-at-point))))
 929   (should-not
 930    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
 931      (org-element-property :foo (org-element-at-point)))))
 932
 933
 934 ;;;; Horizontal Rule
 935
 936 (ert-deftest test-org-element/horizontal-rule-parser ()
 937   "Test `horizontal-rule' parser."
 938   ;; Standard.
 939   (should
 940    (org-test-with-temp-text "-----"
 941      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 942   ;; Indented.
 943   (should
 944    (org-test-with-temp-text "  -----"
 945      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 946   ;; Hyphen must be alone on the line.
 947   (should-not
 948    (org-test-with-temp-text "-----wrong"
 949      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 950   ;; 4 hyphens is too small.
 951   (should-not
 952    (org-test-with-temp-text "----"
 953      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity))))
 954
 955
 956 ;;;; Inline Babel Call
 957
 958 (ert-deftest test-org-element/inline-babel-call-parser ()
 959   "Test `inline-babel-call' parser."
 960   (should
 961    (org-test-with-temp-text "call_test()"
 962      (org-element-map
 963       (org-element-parse-buffer) 'inline-babel-call 'identity))))
 964
 965
 966 ;;;; Inline Src Block
 967
 968 (ert-deftest test-org-element/inline-src-block-parser ()
 969   "Test `inline-src-block' parser."
 970   (should
 971    (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
 972      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
 973   ;; Test parsing at the beginning of an item.
 974   (should
 975    (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
 976      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity))))
 977
 978
 979 ;;;; Inlinetask
 980
 981 (ert-deftest test-org-element/inlinetask-parser ()
 982   "Test `inlinetask' parser."
 983   (when (featurep 'org-inlinetask)
 984     (let ((org-inlinetask-min-level 15))
 985       ;; 1. Regular inlinetask.
 986       (should
 987        (org-test-with-temp-text
 988            "*************** Task\nTest\n*************** END"
 989          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 990       ;; 2. Degenerate inlinetask.
 991       (should
 992        (org-test-with-temp-text "*************** Task"
 993          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 994       ;; TODO keyword.
 995       (should
 996        (equal
 997         "TODO"
 998         (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
 999           (org-test-with-temp-text "*************** TODO Task"
1000             (org-element-property
1001              :todo-keyword
1002              (org-element-map (org-element-parse-buffer) 'inlinetask
1003                'identity nil t))))))
1004       ;; Planning info.
1005       (should
1006        (equal
1007         "2012-03-29 thu."
1008         (org-test-with-temp-text "
1009 *************** Task
1010 DEADLINE: <2012-03-29 thu.>"
1011           (org-element-property
1012            :deadline
1013            (org-element-map (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1014       ;; Priority.
1015       (should
1016        (equal
1017         ?A
1018         (org-test-with-temp-text "
1019 *************** [#A] Task"
1020           (org-element-property
1021            :priority
1022            (org-element-map
1023                (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1024       ;; Tags.
1025       (should
1026        (equal
1027         '("test")
1028         (org-test-with-temp-text "
1029 *************** Task :test:"
1030           (org-element-property
1031            :tags
1032            (org-element-map
1033                (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1034       ;; Regular properties are accessed through upper case keywords.
1035       (should
1036        (org-test-with-temp-text "
1037 *************** Task
1038 :PROPERTIES:
1039 :foo: bar
1040 :END:
1041 *************** END"
1042          (forward-line)
1043          (org-element-property :FOO (org-element-at-point))))
1044       (should-not
1045        (org-test-with-temp-text "
1046 *************** Task
1047 :PROPERTIES:
1048 :foo: bar
1049 :END:
1050 *************** END"
1051          (forward-line)
1052          (org-element-property :foo (org-element-at-point)))))))
1053
1054
1055 ;;;; Italic
1056
1057 (ert-deftest test-org-element/italic-parser ()
1058   "Test `italic' parser."
1059   ;; Regular test.
1060   (should
1061    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1062      (org-test-with-temp-text "/italic/"
1063        (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1064   ;; Multi-line markup.
1065   (should
1066    (equal
1067     (org-element-contents
1068      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1069        (org-test-with-temp-text "/first line\nsecond line/"
1070          (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1071     '("first line\nsecond line"))))
1072
1073
1074 ;;;; Item
1075
1076 (ert-deftest test-org-element/item-parser ()
1077   "Test `item' parser."
1078   ;; Standard test.
1079   (should
1080    (org-test-with-temp-text "- item"
1081      (org-element-map (org-element-parse-buffer) 'item 'identity)))
1082   ;; Counter.
1083   (should
1084    (= 6
1085       (org-element-property
1086        :counter
1087        (org-test-with-temp-text "6. [@6] item"
1088          (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1089   ;; Tag
1090   (should
1091    (equal
1092     '("tag")
1093     (org-element-property
1094      :tag
1095      (org-test-with-temp-text "- tag :: description"
1096        (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1097   ;; No tags in ordered lists.
1098   (should-not
1099    (org-element-property
1100     :tag
1101     (org-test-with-temp-text "1. tag :: description"
1102       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
1103   ;; Check-boxes
1104   (should
1105    (equal
1106     '(trans on off)
1107     (org-test-with-temp-text "
1108 - [-] item 1
1109   - [X] item 1.1
1110   - [ ] item 1.2"
1111       (org-element-map
1112        (org-element-parse-buffer) 'item
1113        (lambda (item) (org-element-property :checkbox item))))))
1114   ;; Folded state.
1115   (org-test-with-temp-text "* Headline
1116 - item
1117
1118   paragraph below"
1119     (forward-line)
1120     (let ((org-cycle-include-plain-lists t)) (org-cycle))
1121     (should
1122      (org-element-property
1123       :hiddenp
1124       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
1125   ;; Item starting with special syntax.
1126   (should
1127    (equal '(("- item"))
1128           (org-test-with-temp-text "- - item"
1129             (org-element-map
1130              (org-element-parse-buffer) 'paragraph 'org-element-contents)))))
1131
1132
1133 ;;;; Keyword
1134
1135 (ert-deftest test-org-element/keyword-parser ()
1136   "Test `keyword' parser."
1137   ;; Standard test.
1138   (should
1139    (org-test-with-temp-text "#+KEYWORD: value"
1140      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1141   ;; Keywords are case-insensitive.
1142   (should
1143    (org-test-with-temp-text "#+keyword: value"
1144      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1145   ;; Affiliated keywords are not keywords.
1146   (should-not
1147    (org-test-with-temp-text "#+NAME: value
1148 Paragraph"
1149      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1150   ;; Do not mix keywords with Babel calls and dynamic blocks.
1151   (should-not
1152    (org-test-with-temp-text "#+CALL: fun()"
1153      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1154   (should-not
1155    (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1156      (org-element-map (org-element-parse-buffer) 'keyword 'identity))))
1157
1158
1159 ;;;; Latex Environment
1160
1161 (ert-deftest test-org-element/latex-environment-parser ()
1162   "Test `latex-environment' parser."
1163   (should
1164    (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1165      (org-element-map (org-element-parse-buffer) 'latex-environment 'identity)))
1166   ;; Allow nested environments.
1167   (should
1168    (equal
1169     "\\begin{outer}
1170 \\begin{inner}
1171 e^{i\\pi}+1=0
1172 \\end{inner}
1173 \\end{outer}"
1174     (org-test-with-temp-text "
1175 \\begin{outer}
1176 \\begin{inner}
1177 e^{i\\pi}+1=0
1178 \\end{inner}
1179 \\end{outer}"
1180       (org-element-property
1181        :value
1182        (org-element-map
1183            (org-element-parse-buffer) 'latex-environment 'identity nil t)))))
1184   ;; Allow environments with options and arguments.
1185   (should
1186    (eq 'latex-environment
1187        (org-test-with-temp-text
1188            "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1189          (org-element-type (org-element-at-point)))))
1190   (should
1191    (eq 'latex-environment
1192        (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1193          (org-element-type (org-element-at-point)))))
1194   (should-not
1195    (eq 'latex-environment
1196        (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1197          (org-element-type (org-element-at-point))))))
1198
1199
1200 ;;;; Latex Fragment
1201
1202 (ert-deftest test-org-element/latex-fragment-parser ()
1203   "Test `latex-fragment' parser."
1204   (let ((org-latex-regexps
1205          '(("begin" "^[         ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^