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
 764       (org-element-parse-buffer) 'footnote-definition '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
 772           (org-element-parse-buffer)
 773           'footnote-definition 'identity nil t)))))
 774   ;; Footnote starting with special syntax.
 775   (should-not
 776    (org-test-with-temp-text "[fn:1] - no item"
 777      (org-element-map (org-element-parse-buffer) 'item 'identity))))
 778
 779
 780 ;;;; Footnotes Reference.
 781
 782 (ert-deftest test-org-element/footnote-reference-parser ()
 783   "Test `footnote-reference' parser."
 784   ;; 1. Parse a standard reference.
 785   (org-test-with-temp-text "Text[fn:label]"
 786     (should
 787      (org-element-map
 788       (org-element-parse-buffer) 'footnote-reference 'identity)))
 789   ;; 2. Parse a normalized reference.
 790   (org-test-with-temp-text "Text[1]"
 791     (should
 792      (org-element-map
 793       (org-element-parse-buffer) 'footnote-reference 'identity)))
 794   ;; 3. Parse an inline reference.
 795   (org-test-with-temp-text "Text[fn:test:def]"
 796     (should
 797      (org-element-map
 798       (org-element-parse-buffer) 'footnote-reference 'identity)))
 799   ;; 4. Parse an anonymous reference.
 800   (org-test-with-temp-text "Text[fn::def]"
 801     (should
 802      (org-element-map
 803       (org-element-parse-buffer) 'footnote-reference 'identity)))
 804   ;; 5. Parse nested footnotes.
 805   (org-test-with-temp-text "Text[fn::def [fn:label]]"
 806     (should
 807      (= 2
 808         (length
 809          (org-element-map
 810           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 811   ;; 6. Parse adjacent footnotes.
 812   (org-test-with-temp-text "Text[fn:label1][fn:label2]"
 813     (should
 814      (= 2
 815         (length
 816          (org-element-map
 817           (org-element-parse-buffer) 'footnote-reference 'identity)))))
 818   ;; 7. Only properly closed footnotes are recognized as such.
 819   (org-test-with-temp-text "Text[fn:label"
 820     (should-not
 821      (org-element-map
 822       (org-element-parse-buffer) 'footnote-reference 'identity))))
 823
 824
 825 ;;;; Headline
 826
 827 (ert-deftest test-org-element/headline-quote-keyword ()
 828   "Test QUOTE keyword recognition."
 829   ;; Reference test.
 830   (org-test-with-temp-text "* Headline"
 831     (let ((org-quote-string "QUOTE"))
 832       (should-not (org-element-property :quotedp (org-element-at-point)))))
 833   ;; Standard position.
 834   (org-test-with-temp-text "* QUOTE Headline"
 835     (let* ((org-quote-string "QUOTE")
 836            (headline (org-element-at-point)))
 837       (should (org-element-property :quotedp headline))
 838       ;; Test removal from raw value.
 839       (should (equal (org-element-property :raw-value headline) "Headline"))))
 840   ;; Case sensitivity.
 841   (org-test-with-temp-text "* QUOTE Headline"
 842     (let* ((org-quote-string "Quote")
 843            (headline (org-element-at-point)))
 844       (should-not (org-element-property :quotedp headline))
 845       (should (equal (org-element-property :raw-value headline)
 846                      "QUOTE Headline"))))
 847   ;; With another keyword.
 848   (org-test-with-temp-text "* TODO QUOTE Headline"
 849     (let* ((org-quote-string "QUOTE")
 850            (org-todo-keywords '((sequence "TODO" "DONE")))
 851            (headline (org-element-at-point)))
 852       (should (org-element-property :quotedp headline))
 853       (should (equal (org-element-property :raw-value headline) "Headline"))))
 854   ;; With the keyword only.
 855   (org-test-with-temp-text "* QUOTE"
 856     (let* ((org-quote-string "QUOTE")
 857            (headline (org-element-at-point)))
 858       (should (org-element-property :quotedp headline))
 859       (should (equal (org-element-property :raw-value headline) "")))))
 860
 861 (ert-deftest test-org-element/headline-comment-keyword ()
 862   "Test COMMENT keyword recognition."
 863   ;; Reference test.
 864   (org-test-with-temp-text "* Headline"
 865     (let ((org-comment-string "COMMENT"))
 866       (should-not (org-element-property :commentedp (org-element-at-point)))))
 867   ;; Standard position.
 868   (org-test-with-temp-text "* COMMENT Headline"
 869     (let ((org-comment-string "COMMENT")
 870           (headline (org-element-at-point)))
 871       (should (org-element-property :commentedp headline))
 872       (should (equal (org-element-property :raw-value headline) "Headline"))))
 873   ;; Case sensitivity.
 874   (org-test-with-temp-text "* COMMENT Headline"
 875     (let* ((org-comment-string "Comment")
 876            (headline (org-element-at-point)))
 877       (should-not (org-element-property :commentedp headline))
 878       (should (equal (org-element-property :raw-value headline)
 879                      "COMMENT Headline"))))
 880   ;; With another keyword.
 881   (org-test-with-temp-text "* TODO COMMENT Headline"
 882     (let* ((org-comment-string "COMMENT")
 883            (org-todo-keywords '((sequence "TODO" "DONE")))
 884            (headline (org-element-at-point)))
 885       (should (org-element-property :commentedp headline))
 886       (should (equal (org-element-property :raw-value headline) "Headline"))))
 887   ;; With the keyword only.
 888   (org-test-with-temp-text "* COMMENT"
 889     (let* ((org-comment-string "COMMENT")
 890            (headline (org-element-at-point)))
 891       (should (org-element-property :commentedp headline))
 892       (should (equal (org-element-property :raw-value headline) "")))))
 893
 894 (ert-deftest test-org-element/headline-archive-tag ()
 895   "Test ARCHIVE tag recognition."
 896   ;; Reference test.
 897   (org-test-with-temp-text "* Headline"
 898     (let ((org-archive-tag "ARCHIVE"))
 899       (should-not (org-element-property :archivedp (org-element-at-point)))))
 900   ;; Single tag.
 901   (org-test-with-temp-text "* Headline :ARCHIVE:"
 902     (let ((org-archive-tag "ARCHIVE"))
 903       (let ((headline (org-element-at-point)))
 904         (should (org-element-property :archivedp headline))
 905         ;; Test tag removal.
 906         (should-not (org-element-property :tags headline))))
 907     (let ((org-archive-tag "Archive"))
 908       (should-not (org-element-property :archivedp (org-element-at-point)))))
 909   ;; Multiple tags.
 910   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
 911     (let ((org-archive-tag "ARCHIVE"))
 912       (let ((headline (org-element-at-point)))
 913         (should (org-element-property :archivedp headline))
 914         ;; Test tag removal.
 915         (should (equal (org-element-property :tags headline) '("test")))))))
 916
 917 (ert-deftest test-org-element/headline-properties ()
 918   "Test properties from property drawer."
 919   ;; All properties from property drawer have their symbol upper
 920   ;; cased.
 921   (should
 922    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
 923      (org-element-property :FOO (org-element-at-point))))
 924   (should-not
 925    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
 926      (org-element-property :foo (org-element-at-point)))))
 927
 928
 929 ;;;; Horizontal Rule
 930
 931 (ert-deftest test-org-element/horizontal-rule-parser ()
 932   "Test `horizontal-rule' parser."
 933   ;; Standard.
 934   (should
 935    (org-test-with-temp-text "-----"
 936      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 937   ;; Indented.
 938   (should
 939    (org-test-with-temp-text "  -----"
 940      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 941   ;; Hyphen must be alone on the line.
 942   (should-not
 943    (org-test-with-temp-text "-----wrong"
 944      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
 945   ;; 4 hyphens is too small.
 946   (should-not
 947    (org-test-with-temp-text "----"
 948      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity))))
 949
 950
 951 ;;;; Inline Babel Call
 952
 953 (ert-deftest test-org-element/inline-babel-call-parser ()
 954   "Test `inline-babel-call' parser."
 955   (should
 956    (org-test-with-temp-text "call_test()"
 957      (org-element-map
 958       (org-element-parse-buffer) 'inline-babel-call 'identity))))
 959
 960
 961 ;;;; Inline Src Block
 962
 963 (ert-deftest test-org-element/inline-src-block-parser ()
 964   "Test `inline-src-block' parser."
 965   (should
 966    (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
 967      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
 968   ;; Test parsing at the beginning of an item.
 969   (should
 970    (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
 971      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity))))
 972
 973
 974 ;;;; Inlinetask
 975
 976 (ert-deftest test-org-element/inlinetask-parser ()
 977   "Test `inlinetask' parser."
 978   (when (featurep 'org-inlinetask)
 979     (let ((org-inlinetask-min-level 15))
 980       ;; 1. Regular inlinetask.
 981       (should
 982        (org-test-with-temp-text
 983            "*************** Task\nTest\n*************** END"
 984          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 985       ;; 2. Degenerate inlinetask.
 986       (should
 987        (org-test-with-temp-text "*************** Task"
 988          (org-element-map (org-element-parse-buffer) 'inlinetask 'identity)))
 989       ;; TODO keyword.
 990       (should
 991        (equal
 992         "TODO"
 993         (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
 994           (org-test-with-temp-text "*************** TODO Task"
 995             (org-element-property
 996              :todo-keyword
 997              (org-element-map (org-element-parse-buffer) 'inlinetask
 998                'identity nil t))))))
 999       ;; Planning info.
1000       (should
1001        (equal
1002         "2012-03-29 thu."
1003         (org-test-with-temp-text "
1004 *************** Task
1005 DEADLINE: <2012-03-29 thu.>"
1006           (org-element-property
1007            :deadline
1008            (org-element-map (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1009       ;; Priority.
1010       (should
1011        (equal
1012         ?A
1013         (org-test-with-temp-text "
1014 *************** [#A] Task"
1015           (org-element-property
1016            :priority
1017            (org-element-map
1018                (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1019       ;; Tags.
1020       (should
1021        (equal
1022         '("test")
1023         (org-test-with-temp-text "
1024 *************** Task :test:"
1025           (org-element-property
1026            :tags
1027            (org-element-map
1028                (org-element-parse-buffer) 'inlinetask 'identity nil t)))))
1029       ;; Regular properties are accessed through upper case keywords.
1030       (should
1031        (org-test-with-temp-text "
1032 *************** Task
1033 :PROPERTIES:
1034 :foo: bar
1035 :END:
1036 *************** END"
1037          (forward-line)
1038          (org-element-property :FOO (org-element-at-point))))
1039       (should-not
1040        (org-test-with-temp-text "
1041 *************** Task
1042 :PROPERTIES:
1043 :foo: bar
1044 :END:
1045 *************** END"
1046          (forward-line)
1047          (org-element-property :foo (org-element-at-point)))))))
1048
1049
1050 ;;;; Italic
1051
1052 (ert-deftest test-org-element/italic-parser ()
1053   "Test `italic' parser."
1054   ;; Regular test.
1055   (should
1056    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1057      (org-test-with-temp-text "/italic/"
1058        (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1059   ;; Multi-line markup.
1060   (should
1061    (equal
1062     (org-element-contents
1063      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1064        (org-test-with-temp-text "/first line\nsecond line/"
1065          (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1066     '("first line\nsecond line"))))
1067
1068
1069 ;;;; Item
1070
1071 (ert-deftest test-org-element/item-parser ()
1072   "Test `item' parser."
1073   ;; Standard test.
1074   (should
1075    (org-test-with-temp-text "- item"
1076      (org-element-map (org-element-parse-buffer) 'item 'identity)))
1077   ;; Counter.
1078   (should
1079    (= 6
1080       (org-element-property
1081        :counter
1082        (org-test-with-temp-text "6. [@6] item"
1083          (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1084   ;; Tag
1085   (should
1086    (equal
1087     '("tag")
1088     (org-element-property
1089      :tag
1090      (org-test-with-temp-text "- tag :: description"
1091        (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1092   ;; No tags in ordered lists.
1093   (should-not
1094    (org-element-property
1095     :tag
1096     (org-test-with-temp-text "1. tag :: description"
1097       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
1098   ;; Check-boxes
1099   (should
1100    (equal
1101     '(trans on off)
1102     (org-test-with-temp-text "
1103 - [-] item 1
1104   - [X] item 1.1
1105   - [ ] item 1.2"
1106       (org-element-map
1107        (org-element-parse-buffer) 'item
1108        (lambda (item) (org-element-property :checkbox item))))))
1109   ;; Folded state.
1110   (org-test-with-temp-text "* Headline
1111 - item
1112
1113   paragraph below"
1114     (forward-line)
1115     (let ((org-cycle-include-plain-lists t)) (org-cycle))
1116     (should
1117      (org-element-property
1118       :hiddenp
1119       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
1120   ;; Item starting with special syntax.
1121   (should
1122    (equal '(("- item"))
1123           (org-test-with-temp-text "- - item"
1124             (org-element-map
1125              (org-element-parse-buffer) 'paragraph 'org-element-contents)))))
1126
1127
1128 ;;;; Keyword
1129
1130 (ert-deftest test-org-element/keyword-parser ()
1131   "Test `keyword' parser."
1132   ;; Standard test.
1133   (should
1134    (org-test-with-temp-text "#+KEYWORD: value"
1135      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1136   ;; Keywords are case-insensitive.
1137   (should
1138    (org-test-with-temp-text "#+keyword: value"
1139      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1140   ;; Affiliated keywords are not keywords.
1141   (should-not
1142    (org-test-with-temp-text "#+NAME: value
1143 Paragraph"
1144      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1145   ;; Do not mix keywords with Babel calls and dynamic blocks.
1146   (should-not
1147    (org-test-with-temp-text "#+CALL: fun()"
1148      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1149   (should-not
1150    (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1151      (org-element-map (org-element-parse-buffer) 'keyword 'identity))))
1152
1153
1154 ;;;; Latex Environment
1155
1156 (ert-deftest test-org-element/latex-environment-parser ()
1157   "Test `latex-environment' parser."
1158   (should
1159    (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1160      (org-element-map (org-element-parse-buffer) 'latex-environment 'identity)))
1161   ;; Allow nested environments.
1162   (should
1163    (equal
1164     "\\begin{outer}
1165 \\begin{inner}
1166 e^{i\\pi}+1=0
1167 \\end{inner}
1168 \\end{outer}"
1169     (org-test-with-temp-text "
1170 \\begin{outer}
1171 \\begin{inner}
1172 e^{i\\pi}+1=0
1173 \\end{inner}
1174 \\end{outer}"
1175       (org-element-property
1176        :value
1177        (org-element-map
1178            (org-element-parse-buffer) 'latex-environment 'identity nil t)))))
1179   ;; Allow environments with options and arguments.
1180   (should
1181    (eq 'latex-environment
1182        (org-test-with-temp-text
1183            "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1184          (org-element-type (org-element-at-point)))))
1185   (should
1186    (eq 'latex-environment
1187        (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1188          (org-element-type (org-element-at-point)))))
1189   (should-not
1190    (eq 'latex-environment
1191        (org-test-with-temp-text "\\begin{env}{arg} something\nvalue\n\\end{env}"
1192          (org-element-type (org-element-at-point))))))
1193
1194
1195 ;;;; Latex Fragment
1196
1197 (ert-deftest test-org-element/latex-fragment-parser ()
1198   "Test `latex-fragment' parser."
1199   (let ((org-latex-regexps
1200          '(("begin" "^[         ]*\\(\\\\begin{\\([a-zA-Z0-9\\*]+\\)[^