testing/lisp/test-org-element.el

   1 ;;; test-org-element.el --- Tests for org-element.el
   2
   3 ;; Copyright (C) 2012-2015  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/secondary-p ()
 128   "Test `org-element-secondary-p' specifications."
 129   ;; In a secondary string, return property name.
 130   (should
 131    (eq :title
 132        (org-test-with-temp-text "* Headline *object*"
 133          (org-element-map (org-element-parse-buffer) 'bold
 134            (lambda (object) (org-element-secondary-p object))
 135            nil t))))
 136   ;; Outside a secondary string, return nil.
 137   (should-not
 138    (org-test-with-temp-text "Paragraph *object*"
 139      (org-element-map (org-element-parse-buffer) 'bold
 140        (lambda (object) (org-element-type (org-element-secondary-p object)))
 141        nil t))))
 142
 143 (ert-deftest test-org-element/adopt-elements ()
 144   "Test `org-element-adopt-elements' specifications."
 145   ;; Adopt an element.
 146   (should
 147    (equal '(plain-text italic)
 148           (org-test-with-temp-text "* Headline\n *a*"
 149             (let ((tree (org-element-parse-buffer)))
 150               (org-element-adopt-elements
 151                (org-element-map tree 'bold 'identity nil t) '(italic nil "a"))
 152               (mapcar (lambda (blob) (org-element-type blob))
 153                       (org-element-contents
 154                        (org-element-map tree 'bold 'identity nil t)))))))
 155   ;; Adopt a string.
 156   (should
 157    (equal '("a" "b")
 158           (org-test-with-temp-text "* Headline\n *a*"
 159             (let ((tree (org-element-parse-buffer)))
 160               (org-element-adopt-elements
 161                (org-element-map tree 'bold 'identity nil t) "b")
 162               (org-element-contents
 163                (org-element-map tree 'bold 'identity nil t)))))))
 164
 165 (ert-deftest test-org-element/extract-element ()
 166   "Test `org-element-extract-element' specifications."
 167   ;; Extract a greater element.
 168   (should
 169    (equal '(org-data nil)
 170           (org-test-with-temp-text "* Headline"
 171             (let* ((tree (org-element-parse-buffer))
 172                    (element (org-element-map tree 'headline 'identity nil t)))
 173               (org-element-extract-element element)
 174               tree))))
 175   ;; Extract an element.
 176   (should-not
 177    (org-element-map
 178        (org-test-with-temp-text "Paragraph"
 179          (let* ((tree (org-element-parse-buffer))
 180                 (element (org-element-map tree 'paragraph 'identity nil t)))
 181            (org-element-extract-element element)
 182            tree))
 183        'paragraph
 184      'identity))
 185   ;; Extract an object, even in a secondary string.
 186   (should-not
 187    (org-element-map
 188        (org-test-with-temp-text "*bold*"
 189          (let* ((tree (org-element-parse-buffer))
 190                 (element (org-element-map tree 'bold 'identity nil t)))
 191            (org-element-extract-element element)
 192            tree))
 193        'bold
 194      'identity))
 195   (should-not
 196    (org-element-map
 197        (org-test-with-temp-text "* Headline *bold*"
 198          (let* ((tree (org-element-parse-buffer))
 199                 (element (org-element-map tree 'bold 'identity nil t)))
 200            (org-element-extract-element element)
 201            tree))
 202        'bold
 203      'identity))
 204   ;; Return value doesn't have any :parent set.
 205   (should-not
 206    (org-element-property
 207     :parent
 208     (org-test-with-temp-text "* Headline\n  Paragraph with *bold* text."
 209       (let* ((tree (org-element-parse-buffer))
 210              (element (org-element-map tree 'bold 'identity nil t)))
 211         (org-element-extract-element element))))))
 212
 213 (ert-deftest test-org-element/insert-before ()
 214   "Test `org-element-insert-before' specifications."
 215   ;; Standard test.
 216   (should
 217    (equal
 218     '(italic entity bold)
 219     (org-test-with-temp-text "/some/ *paragraph*"
 220       (let* ((tree (org-element-parse-buffer))
 221              (paragraph (org-element-map tree 'paragraph 'identity nil t))
 222              (bold (org-element-map tree 'bold 'identity nil t)))
 223         (org-element-insert-before '(entity (:name "\\alpha")) bold)
 224         (org-element-map tree '(bold entity italic) #'org-element-type nil)))))
 225   ;; Insert an object in a secondary string.
 226   (should
 227    (equal
 228     '(entity italic)
 229     (org-test-with-temp-text "* /A/\n  Paragraph."
 230       (let* ((tree (org-element-parse-buffer))
 231              (headline (org-element-map tree 'headline 'identity nil t))
 232              (italic (org-element-map tree 'italic 'identity nil t)))
 233         (org-element-insert-before '(entity (:name "\\alpha")) italic)
 234         (org-element-map (org-element-property :title headline) '(entity italic)
 235           #'org-element-type))))))
 236
 237 (ert-deftest test-org-element/set-element ()
 238   "Test `org-element-set-element' specifications."
 239   ;; Check if new element is inserted.
 240   (should
 241    (org-test-with-temp-text "* Headline\n*a*"
 242      (let* ((tree (org-element-parse-buffer))
 243             (bold (org-element-map tree 'bold 'identity nil t)))
 244        (org-element-set-element bold '(italic nil "b"))
 245        (org-element-map tree 'italic 'identity))))
 246   ;; Check if old element is removed.
 247   (should-not
 248    (org-test-with-temp-text "* Headline\n*a*"
 249      (let* ((tree (org-element-parse-buffer))
 250             (bold (org-element-map tree 'bold 'identity nil t)))
 251        (org-element-set-element bold '(italic nil "b"))
 252        (org-element-map tree 'bold 'identity))))
 253   ;; Check if :parent property is correctly set.
 254   (should
 255    (eq 'paragraph
 256        (org-test-with-temp-text "* Headline\n*a*"
 257          (let* ((tree (org-element-parse-buffer))
 258                 (bold (org-element-map tree 'bold 'identity nil t)))
 259            (org-element-set-element bold '(italic nil "b"))
 260            (org-element-type
 261             (org-element-property
 262              :parent (org-element-map tree 'italic 'identity nil t)))))))
 263   ;; Allow to replace strings with elements.
 264   (should
 265    (equal '("b")
 266           (org-test-with-temp-text "* Headline"
 267             (let* ((tree (org-element-parse-buffer))
 268                    (text (org-element-map tree 'plain-text 'identity nil t)))
 269               (org-element-set-element text (list 'bold nil "b"))
 270               (org-element-map tree 'plain-text 'identity)))))
 271   ;; Allow to replace elements with strings.
 272   (should
 273    (equal "a"
 274           (org-test-with-temp-text "* =verbatim="
 275             (let* ((tree (org-element-parse-buffer))
 276                    (verb (org-element-map tree 'verbatim 'identity nil t)))
 277               (org-element-set-element verb "a")
 278               (org-element-map tree 'plain-text 'identity nil t)))))
 279   ;; Allow to replace strings with strings.
 280   (should
 281    (equal "b"
 282           (org-test-with-temp-text "a"
 283             (let* ((tree (org-element-parse-buffer))
 284                    (text (org-element-map tree 'plain-text 'identity nil t)))
 285               (org-element-set-element text "b")
 286               (org-element-map tree 'plain-text 'identity nil t))))))
 287
 288 (ert-deftest test-org-element/copy ()
 289   "Test `org-element-copy' specifications."
 290   ;; Preserve type.
 291   (should (eq 'bold
 292               (org-test-with-temp-text "*bold*"
 293                 (org-element-type (org-element-copy (org-element-context))))))
 294   (should (eq 'plain-text
 295               (org-test-with-temp-text "*bold*"
 296                 (org-element-type
 297                  (org-element-map (org-element-parse-buffer) 'plain-text
 298                    #'org-element-copy nil t)))))
 299   ;; Preserve properties except `:parent'.
 300   (should (= 7
 301              (org-test-with-temp-text "*bold*"
 302                (org-element-property
 303                 :end (org-element-copy (org-element-context))))))
 304   (should-not
 305    (org-test-with-temp-text "*bold*"
 306      (org-element-property
 307       :parent (org-element-copy (org-element-context)))))
 308   (should-not
 309    (org-test-with-temp-text "*bold*"
 310      (org-element-property
 311       :parent
 312       (org-element-map (org-element-parse-buffer) 'plain-text
 313         #'org-element-copy nil t))))
 314   ;; Copying nil returns nil.
 315   (should-not (org-element-copy nil))
 316   ;; Return a copy secondary strings.
 317   (should (equal '("text") (org-element-copy '("text"))))
 318   (should-not (eq '("text") (org-element-copy '("text")))))
 319
 320
 321 \f
 322 ;;; Test Parsers
 323
 324 ;;;; Affiliated Keywords
 325
 326 (ert-deftest test-org-element/affiliated-keywords-parser ()
 327   "Test affiliated keywords parsing."
 328   ;; Read simple keywords.
 329   (should
 330    (equal "para"
 331           (org-element-property
 332            :name
 333            (org-test-with-temp-text "#+NAME: para\nParagraph"
 334              (org-element-at-point)))))
 335   (should
 336    (= 1
 337       (org-element-property
 338        :begin
 339        (org-test-with-temp-text "#+NAME: para\nParagraph"
 340          (org-element-at-point)))))
 341   ;; Parse multiple keywords.
 342   (should
 343    (equal
 344     '("line2" "line1")
 345     (org-element-property
 346      :attr_ascii
 347      (org-test-with-temp-text
 348          "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph"
 349        (org-element-at-point)))))
 350   ;; Parse "parsed" keywords.
 351   (should
 352    (equal
 353     '(("caption"))
 354     (org-test-with-temp-text "#+CAPTION: caption\nParagraph"
 355       (car (org-element-property :caption (org-element-at-point))))))
 356   ;; Parse dual keywords.
 357   (should
 358    (equal
 359     '((("long") "short"))
 360     (org-test-with-temp-text "#+CAPTION[short]: long\nParagraph"
 361       (org-element-property :caption (org-element-at-point)))))
 362   ;; Allow multiple caption keywords.
 363   (should
 364    (equal
 365     '((("l2") "s2") (("l1") "s1"))
 366     (org-test-with-temp-text "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph"
 367       (org-element-property :caption (org-element-at-point)))))
 368   (should
 369    (equal
 370     '((("l1")) (nil "s1"))
 371     (org-test-with-temp-text "#+CAPTION[s1]:\n#+CAPTION: l1\nParagraph"
 372       (org-element-property :caption (org-element-at-point)))))
 373   ;; Corner case: orphaned keyword at the end of an element.
 374   (should
 375    (eq 'keyword
 376        (org-test-with-temp-text "- item\n  #+name: name\nSome paragraph"
 377          (progn (search-forward "name")
 378                 (org-element-type (org-element-at-point))))))
 379   (should-not
 380    (org-test-with-temp-text "- item\n  #+name: name\nSome paragraph"
 381      (progn (search-forward "Some")
 382             (org-element-property :name (org-element-at-point))))))
 383
 384
 385 ;;;; Babel Call
 386
 387 (ert-deftest test-org-element/babel-call-parser ()
 388   "Test `babel-call' parsing."
 389   ;; Standard test.
 390   (should
 391    (eq 'babel-call
 392        (org-test-with-temp-text "#+CALL: test()"
 393          (org-element-type (org-element-at-point)))))
 394   ;; Ignore case.
 395   (should
 396    (eq 'babel-call
 397        (org-test-with-temp-text "#+call: test()"
 398          (org-element-type (org-element-at-point)))))
 399   ;; Handle non-empty blank line at the end of buffer.
 400   (should
 401    (org-test-with-temp-text "#+CALL: test()\n "
 402      (= (org-element-property :end (org-element-at-point)) (point-max))))
 403   ;; Parse call name.
 404   (should
 405    (equal "test"
 406           (org-test-with-temp-text "#+CALL: test()"
 407             (org-element-property :call (org-element-at-point)))))
 408   ;; Parse inside header.
 409   (should
 410    (equal ":results output"
 411           (org-test-with-temp-text "#+CALL: test[:results output]()"
 412             (org-element-property :inside-header (org-element-at-point)))))
 413   ;; Parse arguments.
 414   (should
 415    (equal "n=4"
 416           (org-test-with-temp-text "#+CALL: test(n=4)"
 417             (org-element-property :arguments (org-element-at-point)))))
 418   ;; Parse end header.
 419   (should
 420    (equal ":results html"
 421           (org-test-with-temp-text "#+CALL: test() :results html"
 422             (org-element-property :end-header (org-element-at-point))))))
 423
 424
 425 ;;;; Bold
 426
 427 (ert-deftest test-org-element/bold-parser ()
 428   "Test `bold' parser."
 429   ;; Standard test.
 430   (should
 431    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 432      (org-test-with-temp-text "*bold*"
 433        (org-element-map (org-element-parse-buffer) 'bold 'identity nil t))))
 434   ;; Multi-line markup.
 435   (should
 436    (equal
 437     (org-element-contents
 438      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 439        (org-test-with-temp-text "*first line\nsecond line*"
 440          (org-element-map (org-element-parse-buffer) 'bold 'identity nil t))))
 441     '("first line\nsecond line"))))
 442
 443
 444 ;;;; Center Block
 445
 446 (ert-deftest test-org-element/center-block-parser ()
 447   "Test `center-block' parser."
 448   ;; Standard test.
 449   (should
 450    (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
 451      (org-element-map (org-element-parse-buffer) 'center-block 'identity)))
 452   ;; Ignore case.
 453   (should
 454    (org-test-with-temp-text "#+begin_center\nText\n#+end_center"
 455      (org-element-map (org-element-parse-buffer) 'center-block 'identity)))
 456   ;; Ignore incomplete block.
 457   (should-not
 458    (org-test-with-temp-text "#+BEGIN_CENTER"
 459      (org-element-map (org-element-parse-buffer) 'center-block
 460        'identity nil t)))
 461   ;; Handle non-empty blank line at the end of buffer.
 462   (should
 463    (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n "
 464      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 465
 466
 467 ;;;; Clock
 468
 469 (ert-deftest test-org-element/clock-parser ()
 470   "Test `clock' parser."
 471   ;; Running clock.
 472   (let ((clock (org-test-with-temp-text "CLOCK: [2012-01-01 sun. 00:01]"
 473                  (org-element-at-point))))
 474     (should (eq (org-element-property :status clock) 'running))
 475     (should
 476      (equal (org-element-property :raw-value
 477                                   (org-element-property :value clock))
 478             "[2012-01-01 sun. 00:01]"))
 479     (should-not (org-element-property :duration clock)))
 480   ;; Closed clock.
 481   (let ((clock
 482          (org-test-with-temp-text
 483              "CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] =>  0:01"
 484            (org-element-at-point))))
 485     (should (eq (org-element-property :status clock) 'closed))
 486     (should (equal (org-element-property :raw-value
 487                                          (org-element-property :value clock))
 488                    "[2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02]"))
 489     (should (equal (org-element-property :duration clock) "0:01"))))
 490
 491
 492 ;;;; Code
 493
 494 (ert-deftest test-org-element/code-parser ()
 495   "Test `code' parser."
 496   ;; Regular test.
 497   (should
 498    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 499      (org-test-with-temp-text "~code~"
 500        (org-element-map (org-element-parse-buffer) 'code 'identity))))
 501   ;; Multi-line markup.
 502   (should
 503    (equal
 504     (org-element-property
 505      :value
 506      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
 507        (org-test-with-temp-text "~first line\nsecond line~"
 508          (org-element-map
 509           (org-element-parse-buffer) 'code 'identity nil t))))
 510     "first line\nsecond line")))
 511
 512
 513 ;;;; Comment
 514
 515 (ert-deftest test-org-element/comment-parser ()
 516   "Test `comment' parser."
 517   ;; Regular comment.
 518   (should
 519    (org-test-with-temp-text "# Comment"
 520      (org-element-map (org-element-parse-buffer) 'comment 'identity)))
 521   ;; Inline comment.
 522   (should
 523    (org-test-with-temp-text "  # Comment"
 524      (org-element-map (org-element-parse-buffer) 'comment 'identity)))
 525   ;; Preserve indentation.
 526   (should
 527    (equal
 528     (org-element-property
 529      :value
 530      (org-test-with-temp-text "# No blank\n#  One blank"
 531        (org-element-map (org-element-parse-buffer) 'comment 'identity nil t)))
 532     "No blank\n One blank"))
 533   ;; Comment with blank lines.
 534   (should
 535    (equal
 536     (org-element-property
 537      :value
 538      (org-test-with-temp-text "# First part\n# \n#\n# Second part"
 539        (org-element-map (org-element-parse-buffer) 'comment 'identity nil t)))
 540     "First part\n\n\nSecond part"))
 541   ;; Do not mix comments and keywords.
 542   (should
 543    (eq 1
 544        (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
 545          (length (org-element-map (org-element-parse-buffer) 'comment
 546                    'identity)))))
 547   (should
 548    (equal "comment"
 549           (org-test-with-temp-text "#+keyword: value\n# comment\n#+keyword: value"
 550             (org-element-property
 551              :value
 552              (org-element-map (org-element-parse-buffer) 'comment
 553                'identity nil t)))))
 554   ;; Correctly handle non-empty blank lines at the end of buffer.
 555   (should
 556    (org-test-with-temp-text "# A\n "
 557      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 558
 559
 560 ;;;; Comment Block
 561
 562 (ert-deftest test-org-element/comment-block-parser ()
 563   "Test `comment-block' parser."
 564   ;; Standard test.
 565   (should
 566    (org-test-with-temp-text "#+BEGIN_COMMENT\nText\n#+END_COMMENT"
 567      (org-element-map (org-element-parse-buffer) 'comment-block 'identity)))
 568   ;; Ignore case.
 569   (should
 570    (org-test-with-temp-text "#+begin_comment\nText\n#+end_comment"
 571      (org-element-map (org-element-parse-buffer) 'comment-block 'identity)))
 572   ;; Ignore incomplete block.
 573   (should-not
 574    (org-test-with-temp-text "#+BEGIN_COMMENT"
 575      (org-element-map (org-element-parse-buffer) 'comment-block
 576        'identity nil t)))
 577   ;; Handle non-empty blank line at the end of buffer.
 578   (should
 579    (org-test-with-temp-text "#+BEGIN_COMMENT\nC\n#+END_COMMENT\n "
 580      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 581
 582
 583 ;;;; Diary Sexp
 584
 585 (ert-deftest test-org-element/diary-sexp-parser ()
 586   "Test `diary-sexp' parser."
 587   ;; Standard test.
 588   (should
 589    (eq 'diary-sexp
 590        (org-test-with-temp-text
 591            "%%(org-anniversary 1956  5 14)(2) Arthur Dent is %d years old"
 592          (org-element-type (org-element-at-point)))))
 593   ;; Diary sexp must live at beginning of line
 594   (should-not
 595    (eq 'diary-sexp
 596        (org-test-with-temp-text " %%(org-bbdb-anniversaries)"
 597          (org-element-type (org-element-at-point)))))
 598   ;; Handle non-empty blank line at the end of buffer.
 599   (should
 600    (org-test-with-temp-text "%%(org-bbdb-anniversaries)\n "
 601      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 602
 603
 604 ;;;; Drawer
 605
 606 (ert-deftest test-org-element/drawer-parser ()
 607   "Test `drawer' parser."
 608   ;; Standard test.
 609   (should
 610    (org-test-with-temp-text ":TEST:\nText\n:END:"
 611      (org-element-map (org-element-parse-buffer) 'drawer 'identity)))
 612   ;; Ignore incomplete drawer.
 613   (should-not
 614    (org-test-with-temp-text ":TEST:"
 615      (org-element-map (org-element-parse-buffer) 'drawer 'identity nil t)))
 616   ;; Handle non-empty blank line at the end of buffer.
 617   (should
 618    (org-test-with-temp-text ":TEST:\nC\n:END:\n "
 619      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 620
 621
 622 ;;;; Dynamic Block
 623
 624 (ert-deftest test-org-element/dynamic-block-parser ()
 625   "Test `dynamic-block' parser."
 626   ;; Standard test.
 627   (should
 628    (org-test-with-temp-text
 629        "#+BEGIN: myblock :param1 val1 :param2 val2\nText\n#+END:"
 630      (org-element-map (org-element-parse-buffer) 'dynamic-block 'identity)))
 631   ;; Ignore case.
 632   (should
 633    (org-test-with-temp-text
 634        "#+begin: myblock :param1 val1 :param2 val2\nText\n#+end:"
 635      (org-element-map (org-element-parse-buffer) 'dynamic-block 'identity)))
 636   ;; Ignore incomplete block.
 637   (should-not
 638    (org-test-with-temp-text "#+BEGIN: myblock :param1 val1 :param2 val2"
 639      (org-element-map (org-element-parse-buffer) 'dynamic-block
 640        'identity nil t)))
 641   ;; Handle non-empty blank line at the end of buffer.
 642   (should
 643    (org-test-with-temp-text "#+BEGIN: myblock :param val1\nC\n#+END:\n  "
 644      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 645
 646
 647 ;;;; Entity
 648
 649 (ert-deftest test-org-element/entity-parser ()
 650   "Test `entity' parser."
 651   ;; Without brackets.
 652   (should
 653    (org-test-with-temp-text "\\sin"
 654      (org-element-map (org-element-parse-buffer) 'entity 'identity)))
 655   ;; With brackets.
 656   (should
 657    (org-element-property
 658     :use-brackets-p
 659     (org-test-with-temp-text "\\alpha{}text"
 660       (org-element-map (org-element-parse-buffer) 'entity 'identity nil t))))
 661   ;; User-defined entity.
 662   (should
 663    (equal
 664     (org-element-property
 665      :name
 666      (let ((org-entities-user
 667             '(("test" "test" nil "test" "test" "test" "test"))))
 668        (org-test-with-temp-text "\\test"
 669          (org-element-map (org-element-parse-buffer) 'entity 'identity nil t))))
 670     "test"))
 671   ;; Special case: entity at the end of a container.
 672   (should
 673    (eq 'entity
 674        (org-test-with-temp-text "*\\alpha \\beta*"
 675          (search-forward "be")
 676          (org-element-type (org-element-context))))))
 677
 678
 679 ;;;; Example Block
 680
 681 (ert-deftest test-org-element/example-block-parser ()
 682   "Test `example-block' parser."
 683   ;; Standard test.
 684   (should
 685    (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText\n#+END_EXAMPLE"
 686      (org-element-map (org-element-parse-buffer) 'example-block 'identity)))
 687   ;; Ignore incomplete block.
 688   (should-not
 689    (eq 'example-block
 690        (org-test-with-temp-text "#+BEGIN_EXAMPLE"
 691          (org-element-type (org-element-at-point)))))
 692   ;; Properly un-escape code.
 693   (should
 694    (equal "* Headline\n #+keyword\nText\n"
 695           (org-test-with-temp-text
 696               "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText\n#+END_EXAMPLE"
 697             (org-element-property :value (org-element-at-point)))))
 698   ;; Remove block indentation according to block boundaries, unless
 699   ;; block contents are less indented than block boundaries.
 700   (should
 701    (equal " L1\nL2\n"
 702           (org-test-with-temp-text " #+BEGIN_EXAMPLE\n  L1\n L2\n #+END_EXAMPLE"
 703             (let ((org-src-preserve-indentation t))
 704               (org-element-property :value (org-element-at-point))))))
 705   (should
 706    (equal
 707     "  L1\n L2\n"
 708     (org-test-with-temp-text "  #+BEGIN_EXAMPLE\n  L1\n L2\n  #+END_EXAMPLE"
 709       (let ((org-src-preserve-indentation t))
 710         (org-element-property :value (org-element-at-point))))))
 711   ;; Handle non-empty blank line at the end of buffer.
 712   (should
 713    (org-test-with-temp-text "#+BEGIN_EXAMPLE\nC\n#+END_EXAMPLE\n "
 714      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 715
 716 (ert-deftest test-org-element/block-switches ()
 717   "Test `example-block' and `src-block' switches parsing."
 718   (let ((org-coderef-label-format "(ref:%s)"))
 719     ;; 1. Test "-i" switch.
 720     (should-not
 721      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 722        (org-element-property :preserve-indent (org-element-at-point))))
 723     (should
 724      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"
 725        (org-element-property :preserve-indent (org-element-at-point))))
 726     (should-not
 727      (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 728        (org-element-property :preserve-indent (org-element-at-point))))
 729     (should
 730      (org-test-with-temp-text "#+BEGIN_EXAMPLE -i\nText.\n#+END_EXAMPLE"
 731        (org-element-property :preserve-indent (org-element-at-point))))
 732     ;; 2. "-n -r -k" combination should number lines, retain labels but
 733     ;;    not use them in coderefs.
 734     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r -k\nText.\n#+END_EXAMPLE"
 735       (let ((element (org-element-at-point)))
 736         (should (org-element-property :number-lines element))
 737         (should (org-element-property :retain-labels element))
 738         (should-not (org-element-property :use-labels element))))
 739     (org-test-with-temp-text
 740         "#+BEGIN_SRC emacs-lisp -n -r -k\n(+ 1 1)\n#+END_SRC"
 741       (let ((element (org-element-at-point)))
 742         (should (org-element-property :number-lines element))
 743         (should (org-element-property :retain-labels element))
 744         (should-not (org-element-property :use-labels element))))
 745     ;; 3. "-n -r" combination should number-lines remove labels and not
 746     ;;    use them in coderefs.
 747     (org-test-with-temp-text "#+BEGIN_EXAMPLE -n -r\nText.\n#+END_EXAMPLE"
 748       (let ((element (org-element-at-point)))
 749         (should (org-element-property :number-lines element))
 750         (should-not (org-element-property :retain-labels element))
 751         (should-not (org-element-property :use-labels element))))
 752     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n -r\n(+ 1 1)\n#+END_SRC"
 753       (let ((element (org-element-at-point)))
 754         (should (org-element-property :number-lines element))
 755         (should-not (org-element-property :retain-labels element))
 756         (should-not (org-element-property :use-labels element))))
 757     ;; 4. "-n" or "+n" should number lines, retain labels and use them
 758     ;;    in coderefs.
 759     (should
 760      (org-test-with-temp-text "#+BEGIN_EXAMPLE -n\nText.\n#+END_EXAMPLE"
 761        (let ((element (org-element-at-point)))
 762          (and (org-element-property :number-lines element)
 763               (org-element-property :retain-labels element)
 764               (org-element-property :use-labels element)))))
 765     (should
 766      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -n\n(+ 1 1)\n#+END_SRC"
 767        (let ((element (org-element-at-point)))
 768          (and (org-element-property :number-lines element)
 769               (org-element-property :retain-labels element)
 770               (org-element-property :use-labels element)))))
 771     (should
 772      (org-test-with-temp-text "#+BEGIN_EXAMPLE +n\nText.\n#+END_EXAMPLE"
 773        (let ((element (org-element-at-point)))
 774          (and (org-element-property :number-lines element)
 775               (org-element-property :retain-labels element)
 776               (org-element-property :use-labels element)))))
 777     (should
 778      (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp +n\n(+ 1 1)\n#+END_SRC"
 779        (let ((element (org-element-at-point)))
 780          (and (org-element-property :number-lines element)
 781               (org-element-property :retain-labels element)
 782               (org-element-property :use-labels element)))))
 783     ;; 5. No switch should not number lines, but retain labels and use
 784     ;;    them in coderefs.
 785     (org-test-with-temp-text "#+BEGIN_EXAMPLE\nText.\n#+END_EXAMPLE"
 786       (let ((element (org-element-at-point)))
 787         (should (not (org-element-property :number-lines element)))
 788         (should (org-element-property :retain-labels element))
 789         (should (org-element-property :use-labels element))))
 790     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
 791       (let ((element (org-element-at-point)))
 792         (should (not (org-element-property :number-lines element)))
 793         (should (org-element-property :retain-labels element))
 794         (should (org-element-property :use-labels element))))
 795     ;; 6. "-r" switch only: do not number lines, remove labels, and
 796     ;;    don't use labels in coderefs.
 797     (org-test-with-temp-text "#+BEGIN_EXAMPLE -r\nText.\n#+END_EXAMPLE"
 798       (let ((element (org-element-at-point)))
 799         (should (not (org-element-property :number-lines element)))
 800         (should (not (org-element-property :retain-labels element)))
 801         (should (not (org-element-property :use-labels element)))))
 802     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp -r\n(+ 1 1)\n#+END_SRC"
 803       (let ((element (org-element-at-point)))
 804         (should (not (org-element-property :number-lines element)))
 805         (should (not (org-element-property :retain-labels element)))
 806         (should (not (org-element-property :use-labels element)))))
 807     ;; 7. Recognize coderefs with user-defined syntax.
 808     (should
 809      (equal
 810       "[ref:%s]"
 811       (org-test-with-temp-text
 812           "#+BEGIN_EXAMPLE -l \"[ref:%s]\"\nText [ref:text]\n#+END_EXAMPLE"
 813         (org-element-property :label-fmt (org-element-at-point)))))
 814     (should
 815      (equal
 816       "[ref:%s]"
 817       (org-test-with-temp-text
 818           "#+BEGIN_SRC emacs-lisp -l \"[ref:%s]\"\n(+ 1 1) [ref:text]\n#+END_SRC"
 819         (org-element-property :label-fmt (org-element-at-point)))))))
 820
 821
 822 ;;;; Export Block
 823
 824 (ert-deftest test-org-element/export-block-parser ()
 825   "Test `export-block' parser."
 826   ;; Standard test.
 827   (should
 828    (org-test-with-temp-text "#+BEGIN_LATEX\nText\n#+END_LATEX"
 829      (org-element-map
 830       (let ((org-element-block-name-alist
 831              '(("LATEX" . org-element-export-block-parser))))
 832         (org-element-parse-buffer))
 833       'export-block 'identity)))
 834   ;; Ignore case.
 835   (should
 836    (let ((org-element-block-name-alist
 837           '(("LATEX" . org-element-export-block-parser))))
 838      (org-test-with-temp-text "#+begin_latex\nText\n#+end_latex"
 839        (org-element-map (org-element-parse-buffer) 'export-block 'identity))))
 840   ;; Ignore incomplete block.
 841   (should-not
 842    (let ((org-element-block-name-alist
 843           '(("LATEX" . org-element-export-block-parser))))
 844      (org-test-with-temp-text "#+BEGIN_LATEX"
 845        (org-element-map (org-element-parse-buffer) 'export-block
 846          'identity nil t))))
 847   ;; Handle non-empty blank line at the end of buffer.
 848   (should
 849    (let ((org-element-block-name-alist
 850           '(("LATEX" . org-element-export-block-parser))))
 851      (org-test-with-temp-text "#+BEGIN_LATEX\nC\n#+END_LATEX\n "
 852        (= (org-element-property :end (org-element-at-point)) (point-max))))))
 853
 854
 855 ;;;; Export Snippet
 856
 857 (ert-deftest test-org-element/export-snippet-parser ()
 858   "Test `export-snippet' parser."
 859   (should
 860    (equal
 861     '("back-end" . "contents")
 862     (org-test-with-temp-text "@@back-end:contents@@"
 863       (org-element-map
 864        (org-element-parse-buffer) 'export-snippet
 865        (lambda (snippet) (cons (org-element-property :back-end snippet)
 866                           (org-element-property :value snippet)))
 867        nil t)))))
 868
 869
 870 ;;;; Fixed Width
 871
 872 (ert-deftest test-org-element/fixed-width-parser ()
 873   "Test fixed-width area parsing."
 874   ;; Preserve indentation.
 875   (should
 876    (org-test-with-temp-text ": no blank\n:  one blank"
 877      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 878   ;; Fixed-width with empty lines.
 879   (should
 880    (org-test-with-temp-text ": first part\n:\n: \n: second part"
 881      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 882   ;; Parse indented fixed-width markers.
 883   (should
 884    (org-test-with-temp-text "Text\n  : no blank\n  :  one blank"
 885      (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))
 886   ;; Distinguish fixed-width areas within a list and outside of it.
 887   (should
 888    (= 2
 889       (length
 890        (org-test-with-temp-text "
 891 - Item
 892   : fixed-width inside
 893 : fixed-width outside"
 894          (org-element-map (org-element-parse-buffer) 'fixed-width 'identity)))))
 895   ;; Handle non-empty blank line at the end of buffer.
 896   (should
 897    (org-test-with-temp-text ": A\n "
 898      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 899
 900
 901 ;;;; Footnote Definition
 902
 903 (ert-deftest test-org-element/footnote-definition-parser ()
 904   "Test `footnote-definition' parser."
 905   (should
 906    (org-test-with-temp-text "[fn:1] Definition"
 907      (org-element-map (org-element-parse-buffer) 'footnote-definition
 908        'identity nil t)))
 909   ;; Footnote with more contents
 910   (should
 911    (= 29
 912       (org-element-property
 913        :end
 914        (org-test-with-temp-text "[fn:1] Definition\n\n| a | b |"
 915          (org-element-map (org-element-parse-buffer) 'footnote-definition
 916            'identity nil t)))))
 917   ;; Footnote starting with special syntax.
 918   (should-not
 919    (org-test-with-temp-text "[fn:1] - no item"
 920      (org-element-map (org-element-parse-buffer) 'item 'identity)))
 921   ;; Correctly handle footnote starting with an empty line.
 922   (should
 923    (= 9
 924       (org-test-with-temp-text "[fn:1]\n\n  Body"
 925         (org-element-property :contents-begin (org-element-at-point)))))
 926   ;; Handle non-empty blank line at the end of buffer.
 927   (should
 928    (org-test-with-temp-text "[fn:1] Definition\n "
 929      (= (org-element-property :end (org-element-at-point)) (point-max)))))
 930
 931
 932 ;;;; Footnotes Reference.
 933
 934 (ert-deftest test-org-element/footnote-reference-parser ()
 935   "Test `footnote-reference' parser."
 936   ;; Parse a standard reference.
 937   (should
 938    (org-test-with-temp-text "Text[fn:label]"
 939      (org-element-map
 940          (org-element-parse-buffer) 'footnote-reference 'identity)))
 941   ;; Parse a normalized reference.
 942   (should
 943    (org-test-with-temp-text "Text[1]"
 944      (org-element-map
 945          (org-element-parse-buffer) 'footnote-reference 'identity)))
 946   ;; Parse an inline reference.
 947   (should
 948    (org-test-with-temp-text "Text[fn:test:def]"
 949      (org-element-map
 950          (org-element-parse-buffer) 'footnote-reference 'identity)))
 951   ;; Parse an anonymous reference.
 952   (should
 953    (org-test-with-temp-text "Text[fn::def]"
 954      (org-element-map
 955          (org-element-parse-buffer) 'footnote-reference 'identity)))
 956   ;; Parse nested footnotes.
 957   (should
 958    (= 2
 959       (length
 960        (org-test-with-temp-text "Text[fn::def [fn:label]]"
 961          (org-element-map
 962              (org-element-parse-buffer) 'footnote-reference 'identity)))))
 963   ;; Parse adjacent footnotes.
 964   (should
 965    (org-test-with-temp-text "Text[fn:label1][fn:label2]"
 966      (= 2
 967         (length
 968          (org-element-map
 969              (org-element-parse-buffer) 'footnote-reference 'identity)))))
 970   ;; Only properly closed footnotes are recognized as such.
 971   (should-not
 972    (org-test-with-temp-text "Text[fn:label"
 973      (org-element-map
 974          (org-element-parse-buffer) 'footnote-reference 'identity))))
 975
 976
 977 ;;;; Headline
 978
 979 (ert-deftest test-org-element/headline-comment-keyword ()
 980   "Test COMMENT keyword recognition."
 981   ;; Reference test.
 982   (org-test-with-temp-text "* Headline"
 983     (let ((org-comment-string "COMMENT"))
 984       (should-not (org-element-property :commentedp (org-element-at-point)))))
 985   ;; Standard position.
 986   (org-test-with-temp-text "* COMMENT Headline"
 987     (let ((org-comment-string "COMMENT")
 988           (headline (org-element-at-point)))
 989       (should (org-element-property :commentedp headline))
 990       (should (equal (org-element-property :raw-value headline) "Headline"))))
 991   ;; Case sensitivity.
 992   (org-test-with-temp-text "* COMMENT Headline"
 993     (let* ((org-comment-string "Comment")
 994            (headline (org-element-at-point)))
 995       (should-not (org-element-property :commentedp headline))
 996       (should (equal (org-element-property :raw-value headline)
 997                      "COMMENT Headline"))))
 998   ;; With another keyword.
 999   (org-test-with-temp-text "* TODO COMMENT Headline"
1000     (let* ((org-comment-string "COMMENT")
1001            (org-todo-keywords '((sequence "TODO" "DONE")))
1002            (headline (org-element-at-point)))
1003       (should (org-element-property :commentedp headline))
1004       (should (equal (org-element-property :raw-value headline) "Headline"))))
1005   ;; With the keyword only.
1006   (org-test-with-temp-text "* COMMENT"
1007     (let* ((org-comment-string "COMMENT")
1008            (headline (org-element-at-point)))
1009       (should (org-element-property :commentedp headline))
1010       (should (equal (org-element-property :raw-value headline) "")))))
1011
1012 (ert-deftest test-org-element/headline-archive-tag ()
1013   "Test ARCHIVE tag recognition."
1014   ;; Reference test.
1015   (should-not
1016    (org-test-with-temp-text "* Headline"
1017      (let ((org-archive-tag "ARCHIVE"))
1018        (org-element-property :archivedp (org-element-at-point)))))
1019   ;; Single tag.
1020   (org-test-with-temp-text "* Headline :ARCHIVE:"
1021     (let ((org-archive-tag "ARCHIVE"))
1022       (let ((headline (org-element-at-point)))
1023         (should (org-element-property :archivedp headline))
1024         ;; Test tag removal.
1025         (should-not (org-element-property :tags headline)))))
1026   ;; Multiple tags.
1027   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
1028     (let ((org-archive-tag "ARCHIVE"))
1029       (let ((headline (org-element-at-point)))
1030         (should (org-element-property :archivedp headline))
1031         ;; Test tag removal.
1032         (should (equal (org-element-property :tags headline) '("test"))))))
1033   ;; Tag is case-sensitive.
1034   (should-not
1035    (org-test-with-temp-text "* Headline :ARCHIVE:"
1036      (let ((org-archive-tag "Archive"))
1037        (org-element-property :archivedp (org-element-at-point))))))
1038
1039 (ert-deftest test-org-element/headline-properties ()
1040   "Test properties from property drawer."
1041   ;; All properties from property drawer have their symbol upper
1042   ;; cased.
1043   (should
1044    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1045      (org-element-property :FOO (org-element-at-point))))
1046   (should-not
1047    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar\n:END:"
1048      (org-element-property :foo (org-element-at-point))))
1049   ;; Also parse properties associated in inlinetasks.
1050   (when (featurep 'org-inlinetask)
1051     (should
1052      (org-test-with-temp-text "*************** Inlinetask
1053 :PROPERTIES:
1054 :foo: bar
1055 :END:
1056 *************** END"
1057        (org-element-property :FOO (org-element-at-point)))))
1058   ;; Do not find property drawer in a verbatim area.
1059   (should-not
1060    (org-test-with-temp-text
1061        "* Headline
1062 #+BEGIN_EXAMPLE
1063 :PROPERTIES:
1064 :foo: bar
1065 :END:
1066 #+END_EXAMPLE"
1067      (org-element-property :FOO (org-element-at-point))))
1068   ;; Do not use properties from a drawer associated to an inlinetask.
1069   (when (featurep 'org-inlinetask)
1070     (should-not
1071      (org-test-with-temp-text
1072          "* Headline
1073 *************** Inlinetask
1074 :PROPERTIES:
1075 :foo: bar
1076 :END:
1077 *************** END"
1078        (org-element-property
1079         :FOO (let ((org-inlinetask-min-level 15)) (org-element-at-point))))))
1080   ;; Do not find incomplete drawers.
1081   (should-not
1082    (org-test-with-temp-text "* Headline\n:PROPERTIES:\n:foo: bar"
1083      (org-element-property :FOO (org-element-at-point)))))
1084
1085
1086 ;;;; Horizontal Rule
1087
1088 (ert-deftest test-org-element/horizontal-rule-parser ()
1089   "Test `horizontal-rule' parser."
1090   ;; Standard.
1091   (should
1092    (org-test-with-temp-text "-----"
1093      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
1094   ;; Indented.
1095   (should
1096    (org-test-with-temp-text "  -----"
1097      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
1098   ;; Hyphen must be alone on the line.
1099   (should-not
1100    (org-test-with-temp-text "-----wrong"
1101      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
1102   ;; 4 hyphens is too small.
1103   (should-not
1104    (org-test-with-temp-text "----"
1105      (org-element-map (org-element-parse-buffer) 'horizontal-rule 'identity)))
1106   ;; Handle non-empty blank line at the end of buffer.
1107   (should
1108    (org-test-with-temp-text "-----\n "
1109      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1110
1111
1112 ;;;; Inline Babel Call
1113
1114 (ert-deftest test-org-element/inline-babel-call-parser ()
1115   "Test `inline-babel-call' parser."
1116   ;; Standard test.
1117   (should
1118    (eq 'inline-babel-call
1119        (org-test-with-temp-text "call_test()"
1120          (org-element-type (org-element-context)))))
1121   (should
1122    (eq 'inline-babel-call
1123        (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1124          (org-element-type (org-element-context)))))
1125   ;; Parse call name.
1126   (should
1127    (equal
1128     "test"
1129     (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1130       (org-element-property :call (org-element-context)))))
1131   ;; Parse inside header.
1132   (should
1133    (equal
1134     ":results output"
1135     (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1136       (org-element-property :inside-header (org-element-context)))))
1137   ;; Parse arguments.
1138   (should
1139    (equal
1140     "x=2"
1141     (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1142       (org-element-property :arguments (org-element-context)))))
1143   ;; Parse end header.
1144   (should
1145    (equal
1146     ":results html"
1147     (org-test-with-temp-text "call_test[:results output](x=2)[:results html]"
1148       (org-element-property :end-header (org-element-context))))))
1149
1150
1151 ;;;; Inline Src Block
1152
1153 (ert-deftest test-org-element/inline-src-block-parser ()
1154   "Test `inline-src-block' parser."
1155   (should
1156    (org-test-with-temp-text "src_emacs-lisp{(+ 1 1)}"
1157      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1158   ;; With switches.
1159   (should
1160    (org-test-with-temp-text "src_emacs-lisp[:foo bar]{(+ 1 1)}"
1161      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1162   (should
1163    (org-test-with-temp-text "src_emacs-lisp[ :foo bar]{(+ 1 1)}"
1164      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1165   ;; Empty switches.
1166   (should
1167    (org-test-with-temp-text "src_emacs-lisp[]{(+ 1 1)}"
1168      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1169   ;; Invalid syntax.
1170   (should-not
1171    (org-test-with-temp-text "foosrc_emacs-lisp[]{(+ 1 1)}"
1172      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1173   (should-not
1174    (org-test-with-temp-text "src_emacs-lisp[]foo{(+ 1 1)}"
1175      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1176   ;; Invalid language name
1177   (should-not
1178    (org-test-with-temp-text "src_emacs-\tlisp{(+ 1 1)}"
1179      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity)))
1180   ;; Test parsing at the beginning of an item.
1181   (should
1182    (org-test-with-temp-text "- src_emacs-lisp{(+ 1 1)}"
1183      (org-element-map (org-element-parse-buffer) 'inline-src-block 'identity))))
1184
1185
1186 ;;;; Inlinetask
1187
1188 (ert-deftest test-org-element/inlinetask-parser ()
1189   "Test `inlinetask' parser."
1190   (when (featurep 'org-inlinetask)
1191     (let ((org-inlinetask-min-level 15))
1192       ;; Regular inlinetask.
1193       (should
1194        (eq 'inlinetask
1195            (org-test-with-temp-text
1196                "*************** Task\nTest\n*************** END"
1197              (org-element-type (org-element-at-point)))))
1198       ;; Degenerate inlinetask.
1199       (should
1200        (eq 'inlinetask
1201            (org-test-with-temp-text "*************** Task"
1202              (org-element-type (org-element-at-point)))))
1203       ;; Mixed inlinetasks.
1204       (should-not
1205        (org-test-with-temp-text
1206            "
1207 *************** Task
1208 *************** Task2
1209 Contents
1210 *************** END"
1211          (forward-line)
1212          (goto-char (org-element-property :end (org-element-at-point)))
1213          (eobp)))
1214       ;; TODO keyword.
1215       (should
1216        (equal
1217         "TODO"
1218         (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
1219           (org-test-with-temp-text "*************** TODO Task"
1220             (org-element-property :todo-keyword (org-element-at-point))))))
1221       ;; Planning info.
1222       (should
1223        (org-test-with-temp-text "
1224 *************** Task
1225 DEADLINE: <2012-03-29 thu.>
1226 *************** END"
1227          (forward-line)
1228          (org-element-property :deadline (org-element-at-point))))
1229       (should-not
1230        (org-test-with-temp-text "
1231 *************** Task
1232 DEADLINE: <2012-03-29 thu.>"
1233          (forward-line)
1234          (org-element-property :deadline (org-element-at-point))))
1235       ;; Priority.
1236       (should
1237        (eq
1238         ?A
1239         (org-test-with-temp-text "
1240 *************** [#A] Task"
1241           (forward-line)
1242           (org-element-property :priority (org-element-at-point)))))
1243       ;; Tags.
1244       (should
1245        (equal
1246         '("test")
1247         (org-test-with-temp-text "
1248 *************** Task :test:"
1249           (forward-line)
1250           (org-element-property :tags (org-element-at-point)))))
1251       ;; Regular properties are accessed through upper case keywords.
1252       (should
1253        (org-test-with-temp-text "
1254 *************** Task
1255 :PROPERTIES:
1256 :foo: bar
1257 :END:
1258 *************** END"
1259          (forward-line)
1260          (org-element-property :FOO (org-element-at-point))))
1261       (should-not
1262        (org-test-with-temp-text "
1263 *************** Task
1264 :PROPERTIES:
1265 :foo: bar
1266 :END:
1267 *************** END"
1268          (forward-line)
1269          (org-element-property :foo (org-element-at-point))))
1270       ;; Handle non-empty blank line at the end of buffer.
1271       (should
1272        (org-test-with-temp-text "*************** Task\n*************** END\n "
1273          (= (org-element-property :end (org-element-at-point)) (point-max)))))))
1274
1275
1276 ;;;; Italic
1277
1278 (ert-deftest test-org-element/italic-parser ()
1279   "Test `italic' parser."
1280   ;; Regular test.
1281   (should
1282    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1283      (org-test-with-temp-text "/italic/"
1284        (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1285   ;; Multi-line markup.
1286   (should
1287    (equal
1288     (org-element-contents
1289      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
1290        (org-test-with-temp-text "/first line\nsecond line/"
1291          (org-element-map (org-element-parse-buffer) 'italic 'identity nil t))))
1292     '("first line\nsecond line"))))
1293
1294
1295 ;;;; Item
1296
1297 (ert-deftest test-org-element/item-parser ()
1298   "Test `item' parser."
1299   ;; Standard test.
1300   (should
1301    (org-test-with-temp-text "- item"
1302      (org-element-map (org-element-parse-buffer) 'item 'identity)))
1303   ;; Counter.
1304   (should
1305    (= 6
1306       (org-element-property
1307        :counter
1308        (org-test-with-temp-text "6. [@6] item"
1309          (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1310   ;; Tag
1311   (should
1312    (equal
1313     '("tag")
1314     (org-element-property
1315      :tag
1316      (org-test-with-temp-text "- tag :: description"
1317        (org-element-map (org-element-parse-buffer) 'item 'identity nil t)))))
1318   ;; No tags in ordered lists.
1319   (should-not
1320    (org-element-property
1321     :tag
1322     (org-test-with-temp-text "1. tag :: description"
1323       (org-element-map (org-element-parse-buffer) 'item 'identity nil t))))
1324   ;; Check-boxes
1325   (should
1326    (equal
1327     '(trans on off)
1328     (org-test-with-temp-text "
1329 - [-] item 1
1330   - [X] item 1.1
1331   - [ ] item 1.2"
1332       (org-element-map
1333        (org-element-parse-buffer) 'item
1334        (lambda (item) (org-element-property :checkbox item))))))
1335   ;; Item starting with special syntax.
1336   (should
1337    (equal '(("- item"))
1338           (org-test-with-temp-text "- - item"
1339             (org-element-map (org-element-parse-buffer) 'paragraph
1340               'org-element-contents))))
1341   ;; Block in an item: ignore indentation within the block.
1342   (should
1343    (org-test-with-temp-text "- item\n  #+begin_src emacs-lisp\n(+ 1 1)\n  #+end_src"
1344      (forward-char)
1345      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1346
1347
1348 ;;;; Keyword
1349
1350 (ert-deftest test-org-element/keyword-parser ()
1351   "Test `keyword' parser."
1352   ;; Standard test.
1353   (should
1354    (org-test-with-temp-text "#+KEYWORD: value"
1355      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1356   ;; Keywords are case-insensitive.
1357   (should
1358    (org-test-with-temp-text "#+keyword: value"
1359      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1360   ;; Affiliated keywords are not keywords.
1361   (should-not
1362    (org-test-with-temp-text "#+NAME: value
1363 Paragraph"
1364      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1365   ;; Do not mix keywords with Babel calls and dynamic blocks.
1366   (should-not
1367    (org-test-with-temp-text "#+CALL: fun()"
1368      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1369   (should-not
1370    (org-test-with-temp-text "#+BEGIN: my-fun\nBody\n#+END:"
1371      (org-element-map (org-element-parse-buffer) 'keyword 'identity)))
1372   ;; Handle non-empty blank line at the end of buffer.
1373   (should
1374    (org-test-with-temp-text "#+KEYWORD: value\n "
1375      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1376
1377
1378 ;;;; Latex Environment
1379
1380 (ert-deftest test-org-element/latex-environment-parser ()
1381   "Test `latex-environment' parser."
1382   (should
1383    (org-test-with-temp-text "\\begin{equation}\ne^{i\\pi}+1=0\n\\end{equation}"
1384      (org-element-map (org-element-parse-buffer) 'latex-environment 'identity)))
1385   ;; Allow nested environments.
1386   (should
1387    (equal
1388     "\\begin{outer}
1389 \\begin{inner}
1390 e^{i\\pi}+1=0
1391 \\end{inner}
1392 \\end{outer}"
1393     (org-test-with-temp-text "
1394 \\begin{outer}
1395 \\begin{inner}
1396 e^{i\\pi}+1=0
1397 \\end{inner}
1398 \\end{outer}"
1399       (org-element-property
1400        :value
1401        (org-element-map
1402            (org-element-parse-buffer) 'latex-environment 'identity nil t)))))
1403   ;; Allow environments with options and arguments.
1404   (should
1405    (eq 'latex-environment
1406        (org-test-with-temp-text
1407            "\\begin{theorem}[Euler]\ne^{i\\pi}+1=0\n\\end{theorem}"
1408          (org-element-type (org-element-at-point)))))
1409   (should
1410    (eq 'latex-environment
1411        (org-test-with-temp-text "\\begin{env}{arg}\nvalue\n\\end{env}"
1412          (org-element-type (org-element-at-point)))))
1413   ;; Allow environments without newline after \begin{.}.
1414   (should
1415    (eq 'latex-environment
1416        (org-test-with-temp-text "\\begin{env}{arg}something\nvalue\n\\end{env}"
1417          (org-element-type (org-element-at-point)))))
1418   ;; Allow one-line environments.
1419   (should
1420    (eq 'latex-environment
1421        (org-test-with-temp-text "\\begin{env}{arg}something\\end{env}"
1422          (org-element-type (org-element-at-point)))))
1423   ;; Should not allow different tags.
1424   (should-not
1425    (eq 'latex-environment
1426        (org-test-with-temp-text "\\begin{env*}{arg}something\\end{env}"
1427                                 (org-element-type (org-element-at-point)))))
1428   ;; LaTeX environments must be on separate lines.
1429   (should-not
1430    (eq 'latex-environment
1431        (org-test-with-temp-text "\\begin{env} x \\end{env} y"
1432          (org-element-type (org-element-at-point)))))
1433   (should-not
1434    (eq 'latex-environment
1435        (org-test-with-temp-text "y \\begin{env} x<point> \\end{env}"
1436          (org-element-type (org-element-at-point)))))
1437   ;; Handle non-empty blank line at the end of buffer.
1438   (should
1439    (org-test-with-temp-text "\\begin{env}\n\\end{env}\n "
1440      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1441
1442
1443 ;;;; Latex Fragment
1444
1445 (ert-deftest test-org-element/latex-fragment-parser ()
1446   "Test `latex-fragment' parser."
1447   (should
1448    (org-test-with-temp-text "$a$"
1449      (org-element-map (org-element-parse-buffer) 'latex-fragment 'identity)))
1450   (should
1451    (org-test-with-temp-text "$$a$$"
1452      (org-element-map (org-element-parse-buffer) 'latex-fragment 'identity)))
1453   (should
1454    (org-test-with-temp-text "\\(a\\)"
1455      (org-element-map (org-element-parse-buffer) 'latex-fragment 'identity)))
1456   (should
1457    (org-test-with-temp-text "\\[a\\]"
1458      (org-element-map
1459          (org-element-parse-buffer) 'latex-fragment 'identity)))
1460   ;; Test fragment at the beginning of an item.
1461   (should
1462    (eq 'latex-fragment
1463        (org-test-with-temp-text "- $x$"
1464          (progn (search-forward "$")
1465                 (org-element-type (org-element-context)))))))
1466
1467
1468 ;;;; Line Break
1469
1470 (ert-deftest test-org-element/line-break-parser ()
1471   "Test `line-break' parser."
1472   ;; Regular test.
1473   (should
1474    (org-test-with-temp-text "Text \\\\"
1475      (org-element-map (org-element-parse-buffer) 'line-break 'identity)))
1476   ;; Line break with trailing white spaces.
1477   (should
1478    (org-test-with-temp-text "Text \\\\  "
1479      (org-element-map (org-element-parse-buffer) 'line-break 'identity)))
1480   ;; Three backslashes are too much.
1481   (should-not
1482    (org-test-with-temp-text "Text \\\\\\"
1483      (org-element-map (org-element-parse-buffer) 'line-break 'identity))))
1484
1485
1486 ;;;; Link
1487
1488 (ert-deftest test-org-element/link-parser ()
1489   "Test `link' parser."
1490   ;; Radio target.
1491   (should
1492    (equal
1493     "radio"
1494     (org-test-with-temp-text "<<<radio>>>A radio link"
1495       (org-update-radio-target-regexp)
1496       (org-element-property
1497        :type
1498        (org-element-map (org-element-parse-buffer) 'link #'identity nil t)))))
1499   ;; Standard link.
1500   ;;
1501   ;; ... with description.
1502   (should
1503    (equal
1504     '("Orgmode.org")
1505     (org-test-with-temp-text "[[http://orgmode.org][Orgmode.org]]"
1506       (org-element-contents
1507        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1508   ;; ... without description.
1509   (should
1510    (equal
1511     "http"
1512     (org-test-with-temp-text "[[http://orgmode.org]]"
1513       (org-element-property
1514        :type
1515        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1516   ;; ... with expansion.
1517   (should
1518    (equal
1519     "//orgmode.org/worg"
1520     (org-test-with-temp-text "[[Org:worg]]"
1521       (let ((org-link-abbrev-alist '(("Org" . "http://orgmode.org/"))))
1522         (org-element-property
1523          :path
1524          (org-element-map (org-element-parse-buffer) 'link 'identity nil t))))))
1525   ;; ... with translation.
1526   (should
1527    (equal
1528     "127.0.0.1"
1529     (org-test-with-temp-text "[[http://orgmode.org]]"
1530       (flet ((link-translate (type path) (cons type "127.0.0.1")))
1531         (let ((org-link-translation-function 'link-translate))
1532           (org-element-property
1533            :path
1534            (org-element-map (org-element-parse-buffer) 'link
1535              'identity nil t)))))))
1536   ;; ... id link.
1537   (should
1538    (equal
1539     "id"
1540     (org-test-with-temp-text "[[id:aaaa]]"
1541       (org-element-property
1542        :type
1543        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1544   ;; ... custom-id link.
1545   (should
1546    (equal
1547     "custom-id"
1548     (org-test-with-temp-text "[[#some-id]]"
1549       (org-element-property
1550        :type
1551        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1552   ;; ... coderef link.
1553   (should
1554    (equal
1555     "coderef"
1556     (org-test-with-temp-text "[[(reference)]]"
1557       (org-element-property
1558        :type
1559        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1560   ;; ... fuzzy link.
1561   (should
1562    (equal
1563     "fuzzy"
1564     (org-test-with-temp-text "[[target-or-title]]"
1565       (org-element-property
1566        :type
1567        (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))))
1568   ;; ... file-type link with search option.
1569   (should
1570    (equal
1571     '(("file" "projects.org" "*task title"))
1572     (org-test-with-temp-text "[[file:projects.org::*task title]]"
1573       (org-element-map (org-element-parse-buffer) 'link
1574         (lambda (l) (list (org-element-property :type l)
1575                      (org-element-property :path l)
1576                      (org-element-property :search-option l)))))))
1577   ;; ... file-type link with application...
1578   (should
1579    (equal
1580     '("file" "projects.org" "emacs")
1581     (org-test-with-temp-text "[[file+emacs:projects.org]]"
1582       (let ((l (org-element-context)))
1583         (list (org-element-property :type l)
1584               (org-element-property :path l)
1585               (org-element-property :application l))))))
1586   ;; ... `:path' in a file-type link must be compatible with "file"
1587   ;; scheme in URI syntax, even if Org syntax isn't...
1588   (should
1589    (org-test-with-temp-text-in-file ""
1590      (let ((file (expand-file-name (buffer-file-name))))
1591        (insert (format "[[file://%s]]" file))
1592        (equal (org-element-property :path (org-element-context)) file))))
1593   (should
1594    (org-test-with-temp-text-in-file ""
1595      (let ((file (expand-file-name (buffer-file-name))))
1596        (insert (format "[[file:%s]]" file))
1597        (equal (org-element-property :path (org-element-context)) file))))
1598   (should
1599    (org-test-with-temp-text-in-file ""
1600      (let ((file (expand-file-name (buffer-file-name))))
1601        (insert (format "[[file:%s]]" file))
1602        (equal (org-element-property :path (org-element-context)) file))))
1603   ;; ... multi-line link.
1604   (should
1605    (equal "//orgmode.org"
1606           (org-test-with-temp-text "[[http://orgmode.\norg]]"
1607             (org-element-property :path (org-element-context)))))
1608   ;; Plain link.
1609   (should
1610    (org-test-with-temp-text "A link: http://orgmode.org"
1611      (org-element-map (org-element-parse-buffer) 'link 'identity)))
1612   ;; Angular link.
1613   (should
1614    (org-test-with-temp-text "A link: <http://orgmode.org>"
1615      (org-element-map (org-element-parse-buffer) 'link 'identity nil t)))
1616   ;; Link abbreviation.
1617   (should
1618    (equal "http"
1619           (org-test-with-temp-text
1620               "#+LINK: orgmode http://www.orgmode.org/\n[[orgmode:#docs]]"
1621             (progn (org-mode-restart)
1622                    (goto-char (1- (point-max)))
1623                    (org-element-property :type (org-element-context))))))
1624   ;; Link abbreviation in a secondary string.
1625   (should
1626    (equal "http"
1627           (org-test-with-temp-text
1628               "#+LINK: orgmode http://www.orgmode.org/\n* H [[orgmode:#docs]]"
1629             (progn (org-mode-restart)
1630                    (org-element-map (org-element-parse-buffer) 'link
1631                      (lambda (link) (org-element-property :type link))
1632                      nil t nil t)))))
1633   ;; Plain links are allowed as description of regular links.
1634   (should
1635    (equal "file"
1636           (org-test-with-temp-text "[[http://orgmode.org][file:unicorn.jpg]]"
1637             (search-forward "file:")
1638             (org-element-property :type (org-element-context))))))
1639
1640
1641 ;;;; Macro
1642
1643 (ert-deftest test-org-element/macro-parser ()
1644   "Test `macro' parser."
1645   ;; Without arguments.
1646   (should
1647    (org-test-with-temp-text "{{{macro}}}"
1648      (org-element-map (org-element-parse-buffer) 'macro 'identity)))
1649   ;; With arguments.
1650   (should
1651    (org-test-with-temp-text "{{{macro(arg1,arg2)}}}"
1652      (org-element-map (org-element-parse-buffer) 'macro 'identity)))
1653   ;; Properly handle protected commas in arguments...
1654   (should
1655    (= 2
1656       (length
1657        (org-test-with-temp-text "{{{macro(arg1\\,arg1,arg2)}}}"
1658          (org-element-property :args (org-element-context))))))
1659   ;; ... even when last argument ends with a protected comma.
1660   (should
1661    (equal '("C-,")
1662           (org-test-with-temp-text "{{{macro(C-\\,)}}}"
1663             (org-element-property :args (org-element-context)))))
1664   ;; Allow to escape escaping character.
1665   (should
1666    (equal '("C-\\" "")
1667           (org-test-with-temp-text "{{{macro(C-\\\\,)}}}"
1668             (org-element-property :args (org-element-context)))))
1669   ;; No need to escape backslashes elsewhere.
1670   (should
1671    (equal '("\\")
1672           (org-test-with-temp-text "{{{macro(\\)}}}"
1673             (org-element-property :args (org-element-context))))))
1674
1675
1676 ;;;; Node Property
1677
1678 (ert-deftest test-org-element/node-property ()
1679   "Test `node-property' parser."
1680   ;; Standard test.
1681   (should
1682    (equal '("abc" "value")
1683           (org-test-with-temp-text "* H\n:PROPERTIES:\n<point>:abc: value\n:END:"
1684             (let ((element (org-element-at-point)))
1685               (list (org-element-property :key element)
1686                     (org-element-property :value element))))))
1687   ;; Value should be trimmed.
1688   (should
1689    (equal "value"
1690           (org-test-with-temp-text
1691               "* H\n:PROPERTIES:\n<point>:abc: value  \n:END:"
1692             (org-element-property :value (org-element-at-point)))))
1693   ;; A node property requires to be wrapped within a property drawer.
1694   (should-not
1695    (eq 'node-property
1696        (org-test-with-temp-text ":abc: value"
1697          (org-element-type (org-element-at-point)))))
1698   ;; Accept empty properties.
1699   (should
1700    (equal '(("foo" "value") ("bar" ""))
1701           (org-test-with-temp-text "* H\n:PROPERTIES:\n:foo: value\n:bar:\n:END:"
1702             (org-element-map (org-element-parse-buffer) 'node-property
1703               (lambda (p)
1704                 (list (org-element-property :key p)
1705                       (org-element-property :value p))))))))
1706
1707
1708 ;;;; Paragraph
1709
1710 (ert-deftest test-org-element/paragraph-parser ()
1711   "Test `paragraph' parser."
1712   ;; Standard test.
1713   (should
1714    (org-test-with-temp-text "Paragraph"
1715      (org-element-map (org-element-parse-buffer) 'paragraph 'identity nil t)))
1716   ;; Property find end of a paragraph stuck to another element.
1717   (should
1718    (eq ?#
1719        (org-test-with-temp-text "Paragraph\n# Comment"
1720          (org-element-map (org-element-parse-buffer) 'paragraph
1721            (lambda (p) (char-after (org-element-property :end p)))
1722            nil t))))
1723   ;; Include ill-formed Keywords.
1724   (should
1725    (org-test-with-temp-text "#+wrong_keyword something"
1726      (org-element-map (org-element-parse-buffer) 'paragraph 'identity)))
1727   ;; Include incomplete-drawers.
1728   (should
1729    (org-test-with-temp-text ":TEST:\nParagraph"
1730      (let ((elem (org-element-at-point)))
1731        (and (eq (org-element-type elem) 'paragraph)
1732             (= (point-max) (org-element-property :end elem))))))
1733   ;; Include incomplete blocks.
1734   (should
1735    (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph"
1736      (let ((elem (org-element-at-point)))
1737        (and (eq (org-element-type elem) 'paragraph)
1738             (= (point-max) (org-element-property :end elem))))))
1739   ;; Include incomplete dynamic blocks.
1740   (should
1741    (org-test-with-temp-text "#+BEGIN: \nParagraph"
1742      (let ((elem (org-element-at-point)))
1743        (and (eq (org-element-type elem) 'paragraph)
1744             (= (point-max) (org-element-property :end elem))))))
1745   ;; Include incomplete latex environments.
1746   (should
1747    (org-test-with-temp-text "\begin{equation}\nParagraph"
1748      (let ((elem (org-element-at-point)))
1749        (and (eq (org-element-type elem) 'paragraph)
1750             (= (point-max) (org-element-property :end elem))))))
1751   ;; Do not steal affiliated keywords from container.
1752   (should
1753    (org-test-with-temp-text "#+ATTR_LATEX: test\n- item 1"
1754      (let ((elem (progn (search-forward "item") (org-element-at-point))))
1755        (and (eq (org-element-type elem) 'paragraph)
1756             (not (org-element-property :attr_latex elem))
1757             (/= (org-element-property :begin elem) 1)))))
1758   ;; Handle non-empty blank line at the end of buffer.
1759   (should
1760    (org-test-with-temp-text "#+BEGIN_CENTER\nC\n#+END_CENTER\n  "
1761      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1762
1763
1764 ;;;; Plain List
1765
1766 (ert-deftest test-org-element/plain-list-parser ()
1767   "Test `plain-list' parser."
1768   (org-test-with-temp-text "- item"
1769     (should (org-element-map (org-element-parse-buffer) 'plain-list 'identity)))
1770   ;; Blank lines after the list only belong to outer plain list.
1771   (should
1772    (equal
1773     '(t t)
1774     (org-test-with-temp-text "
1775 - outer
1776   - inner
1777
1778 Outside list"
1779       (let ((endings (org-element-map (org-element-parse-buffer) 'plain-list
1780                        (lambda (pl) (org-element-property :end pl)))))
1781         (list
1782          ;; Move to ending of outer list.
1783          (progn (goto-char (car endings)) (looking-at "Outside list"))
1784          ;; Move to ending of inner list.
1785          (progn (goto-char (nth 1 endings)) (looking-at "^$")))))))
1786   ;; Correctly compute end of list if it doesn't end at a line
1787   ;; beginning.
1788   (should
1789    (org-test-with-temp-text "- list\n   \n   "
1790      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1791
1792
1793 ;;;; Planning
1794
1795 (ert-deftest test-org-element/planning-parser ()
1796   "Test `planning' parser."
1797   ;; Test various keywords.
1798   (should
1799    (org-element-property
1800     :closed
1801     (org-test-with-temp-text "* H\n<point>CLOSED: [2012-03-29 thu.]"
1802       (org-element-at-point))))
1803   (should
1804    (org-element-property
1805     :deadline
1806     (org-test-with-temp-text "* H\n<point>DEADLINE: <2012-03-29 thu.>"
1807       (org-element-at-point))))
1808   (should
1809    (org-element-property
1810     :scheduled
1811     (org-test-with-temp-text "* H\n<point>SCHEDULED: <2012-03-29 thu.>"
1812       (org-element-at-point))))
1813   ;; Planning line only exists right after a headline.
1814   (should-not
1815    (eq 'planning
1816        (org-test-with-temp-text "DEADLINE: <2012-03-29 thu.>"
1817          (org-element-type (org-element-at-point)))))
1818   (should-not
1819    (eq 'planning
1820        (org-test-with-temp-text
1821            "* H\n# Comment\n<point>DEADLINE: <2012-03-29 thu.>"
1822          (org-element-type (org-element-at-point))))))
1823
1824
1825 ;;;; Property Drawer
1826
1827 (ert-deftest test-org-element/property-drawer-parser ()
1828   "Test `property-drawer' parser."
1829   ;; Standard test.
1830   (should
1831    (eq 'property-drawer
1832        (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value\n:END:"
1833          (org-element-type (org-element-at-point)))))
1834   (should
1835    (eq 'property-drawer
1836        (org-test-with-temp-text
1837            "* H\nDEADLINE: <2014-03-04 tue.>\n<point>:PROPERTIES:\n:prop: value\n:END:"
1838          (org-element-type (org-element-at-point)))))
1839   ;; Allow properties without value and no property at all.
1840   (should
1841    (eq 'property-drawer
1842        (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop:\n:END:"
1843          (org-element-type (org-element-at-point)))))
1844   (should
1845    (eq 'property-drawer
1846        (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:"
1847          (org-element-type (org-element-at-point)))))
1848   ;; Ignore incomplete drawer, drawer at a wrong location or with
1849   ;; wrong contents.
1850   (should-not
1851    (eq 'property-drawer
1852        (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:prop: value"
1853          (org-element-type (org-element-at-point)))))
1854   (should-not
1855    (eq 'property-drawer
1856        (org-test-with-temp-text
1857            "* H\nParagraph\n<point>:PROPERTIES:\n:prop: value\n:END:"
1858          (org-element-type (org-element-at-point)))))
1859   (should-not
1860    (eq 'property-drawer
1861        (org-test-with-temp-text
1862            "* H\nParagraph\n<point>:PROPERTIES:\nparagraph\n:END:"
1863          (org-element-type (org-element-at-point)))))
1864   ;; Handle non-empty blank line at the end of buffer.
1865   (should
1866    (org-test-with-temp-text "* H\n<point>:PROPERTIES:\n:END:\n "
1867      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1868
1869
1870 ;;;; Quote Block
1871
1872 (ert-deftest test-org-element/quote-block-parser ()
1873   "Test `quote-block' parser."
1874   ;; Regular test.
1875   (should
1876    (org-test-with-temp-text "#+BEGIN_QUOTE\nText\n#+END_QUOTE"
1877      (org-element-map (org-element-parse-buffer) 'quote-block 'identity)))
1878   ;; Ignore incomplete block.
1879   (should-not
1880    (org-test-with-temp-text "#+BEGIN_QUOTE"
1881      (org-element-map (org-element-parse-buffer) 'quote-block 'identity nil t)))
1882   ;; Handle non-empty blank line at the end of buffer.
1883   (should
1884    (org-test-with-temp-text "#+BEGIN_QUOTE\nC\n#+END_QUOTE\n  "
1885      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1886
1887
1888 ;;;; Radio Target
1889
1890 (ert-deftest test-org-element/radio-target-parser ()
1891   "Test `radio-target' parser."
1892   ;; Standard test.
1893   (should
1894    (eq 'radio-target
1895        (org-test-with-temp-text "<<<radio>>>"
1896          (org-element-type (org-element-context)))))
1897   ;; Radio targets with objects.
1898   (should
1899    (eq 'radio-target
1900        (org-test-with-temp-text "<<<radio \\alpha>>>"
1901          (org-element-type (org-element-context)))))
1902   ;; Radio targets starting with an object.
1903   (should
1904    (eq 'radio-target
1905        (org-test-with-temp-text "<<<\\alpha radio>>>"
1906          (org-element-type (org-element-context)))))
1907   ;; Radio targets cannot begin or end with white space.
1908   (should-not
1909    (eq 'radio-target
1910        (org-test-with-temp-text "<<< radio>>>"
1911          (org-element-type (org-element-context)))))
1912   (should-not
1913    (eq 'radio-target
1914        (org-test-with-temp-text "<<<radio >>>"
1915          (org-element-type (org-element-context))))))
1916
1917
1918 ;;;; Section
1919
1920 (ert-deftest test-org-element/section-parser ()
1921   "Test `section' parser."
1922   ;; Standard test.
1923   (should
1924    (org-test-with-temp-text "* Headline\nText"
1925      (org-element-map (org-element-parse-buffer) 'section 'identity)))
1926   ;; There's a section before the first headline.
1927   (should
1928    (org-test-with-temp-text "Text"
1929      (org-element-map (org-element-parse-buffer) 'section 'identity)))
1930   ;; A section cannot be empty.
1931   (should-not
1932    (org-test-with-temp-text "* Headline 1\n* Headline 2"
1933      (org-element-map (org-element-parse-buffer) 'section 'identity)))
1934   ;; A section doesn't contain sub-trees.
1935   (should-not
1936    (org-test-with-temp-text "* Head\nText\n** Sub-Head"
1937      (org-element-map
1938       (org-element-map (org-element-parse-buffer) 'section 'identity nil t)
1939       'headline 'identity))))
1940
1941
1942 ;;;; Special Block
1943
1944 (ert-deftest test-org-element/special-block-parser ()
1945   "Test `special-block' parser."
1946   ;; Standard test.
1947   (should
1948    (equal "SPECIAL"
1949           (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1950             (org-element-property :type (org-element-at-point)))))
1951   ;; Special blocks are case sensitive.
1952   (should
1953    (equal "CaSe"
1954           (org-test-with-temp-text "#+BEGIN_CaSe\nText\n#+END_CaSe"
1955             (org-element-property :type (org-element-at-point)))))
1956   ;; Special blocks can contain paragraphs.
1957   (should
1958    (eq 'paragraph
1959        (org-test-with-temp-text "#+BEGIN_SPECIAL\nText\n#+END_SPECIAL"
1960          (forward-line)
1961          (org-element-type (org-element-at-point)))))
1962   ;; Ignore incomplete block.
1963   (should-not
1964    (eq 'special-block
1965        (org-test-with-temp-text "#+BEGIN_SPECIAL"
1966          (org-element-type (org-element-at-point)))))
1967   ;; Allow special characters in type.
1968   (should
1969    (equal '(special-block "SPECIAL*")
1970           (org-test-with-temp-text "#+BEGIN_SPECIAL*\nContents\n#+END_SPECIAL*"
1971             (let ((element (org-element-at-point)))
1972               (list (org-element-type element)
1973                     (org-element-property :type element))))))
1974   ;; Handle non-empty blank line at the end of buffer.
1975   (should
1976    (org-test-with-temp-text "#+BEGIN_SPECIAL\nC\n#+END_SPECIAL\n "
1977      (= (org-element-property :end (org-element-at-point)) (point-max)))))
1978
1979
1980 ;;;; Src Block
1981
1982 (ert-deftest test-org-element/src-block-parser ()
1983   "Test `src-block' parser."
1984   ;; Regular tests.
1985   (should
1986    (org-test-with-temp-text "#+BEGIN_SRC org\nText\n#+END_SRC"
1987      (org-element-map (org-element-parse-buffer) 'src-block 'identity)))
1988   ;; Ignore incomplete block.
1989   (should-not
1990    (org-test-with-temp-text "#+BEGIN_SRC"
1991      (org-element-map (org-element-parse-buffer) 'src-block 'identity)))
1992   ;; Properly un-escape code.
1993   (should
1994    (equal "* Headline\n #+keyword\nText\n"
1995           (org-test-with-temp-text
1996               "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText\n#+END_SRC"
1997             (org-element-property :value (org-element-at-point)))))
1998   ;; Remove block indentation according to block boundaries, unless
1999   ;; block contents are less indented than block boundaries.
2000   (should
2001    (equal " L1\nL2\n"
2002           (org-test-with-temp-text " #+BEGIN_SRC org\n  L1\n L2\n #+END_SRC"
2003             (let ((org-src-preserve-indentation t))
2004               (org-element-property :value (org-element-at-point))))))
2005   (should
2006    (equal
2007     "  L1\n L2\n"
2008     (org-test-with-temp-text "  #+BEGIN_SRC org\n  L1\n L2\n  #+END_SRC"
2009       (let ((org-src-preserve-indentation t))
2010         (org-element-property :value (org-element-at-point))))))
2011   ;; Handle non-empty blank line at the end of buffer.
2012   (should
2013    (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\nC\n#+END_SRC\n "
2014      (= (org-element-property :end (org-element-at-point)) (point-max)))))
2015
2016
2017 ;;;; Statistics Cookie
2018
2019 (ert-deftest test-org-element/statistics-cookie ()
2020   "Test `statistics-cookie' parser."
2021   ;; With numbers.
2022   (should
2023    (org-test-with-temp-text "[1/2]"
2024      (org-element-map (org-element-parse-buffer) 'statistics-cookie 'identity)))
2025   ;; With percents.
2026   (should
2027    (org-test-with-temp-text "[33%]"
2028      (org-element-map
2029       (org-element-parse-buffer) 'statistics-cookie 'identity))))
2030
2031
2032 ;;;; Strike Through
2033
2034 (ert-deftest test-org-element/strike-through-parser ()
2035   "Test `strike-through' parser."
2036   ;; Regular test.
2037   (should
2038    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2039      (org-test-with-temp-text "+strike-through+"
2040        (org-element-map (org-element-parse-buffer) 'strike-through 'identity))))
2041   ;; Multi-line markup.
2042   (should
2043    (equal
2044     (org-element-contents
2045      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2046        (org-test-with-temp-text "+first line\nsecond line+"
2047          (org-element-map
2048           (org-element-parse-buffer) 'strike-through 'identity nil t))))
2049     '("first line\nsecond line"))))
2050
2051
2052 ;;;; Subscript
2053
2054 (ert-deftest test-org-element/subscript-parser ()
2055   "Test `subscript' parser."
2056   ;; Without braces.
2057   (should
2058    (org-test-with-temp-text "a_b"
2059      (org-element-map (org-element-parse-buffer) 'subscript 'identity)))
2060   ;; With braces.
2061   (should
2062    (org-test-with-temp-text "a_{b}"
2063      (org-element-map (org-element-parse-buffer) 'subscript 'identity)))
2064   ;; Multiple subscripts in a paragraph.
2065   (should
2066    (= 2
2067       (org-test-with-temp-text "a_b and c_d"
2068         (length
2069          (org-element-map (org-element-parse-buffer) 'subscript 'identity))))))
2070
2071
2072 ;;;; Superscript
2073
2074 (ert-deftest test-org-element/superscript-parser ()
2075   "Test `superscript' parser."
2076   ;; Without braces.
2077   (should
2078    (org-test-with-temp-text "a^b"
2079      (org-element-map (org-element-parse-buffer) 'superscript 'identity)))
2080   ;; With braces.
2081   (should
2082    (org-test-with-temp-text "a^{b}"
2083      (org-element-map (org-element-parse-buffer) 'superscript 'identity)))
2084   ;; Multiple superscript in a paragraph.
2085   (should
2086    (= 2
2087       (org-test-with-temp-text "a^b and c^d"
2088         (length
2089          (org-element-map
2090           (org-element-parse-buffer) 'superscript 'identity))))))
2091
2092
2093 ;;;; Table
2094
2095 (ert-deftest test-org-element/table-parser ()
2096   "Test `table' parser."
2097   (should
2098    (org-test-with-temp-text "| a |"
2099      (org-element-map (org-element-parse-buffer) 'table 'identity)))
2100   ;; TBLFM keyword is case insensitive.
2101   (should
2102    (org-test-with-temp-text "| a |\n#+tblfm: test"
2103      (org-element-property
2104       :tblfm
2105       (org-element-map (org-element-parse-buffer) 'table 'identity nil t))))
2106   ;; Handle multiple TBLFM lines.
2107   (should
2108    (= 2
2109       (org-test-with-temp-text "| a |\n#+TBLFM: test1\n#+TBLFM: test2"
2110         (length (org-element-property
2111                  :tblfm
2112                  (org-element-map
2113                      (org-element-parse-buffer) 'table 'identity nil t))))))
2114   ;; Handle non-empty blank line at the end of buffer.
2115   (should
2116    (org-test-with-temp-text "| a |\n "
2117      (= (org-element-property :end (org-element-at-point)) (point-max)))))
2118
2119
2120 ;;;; Table Cell
2121
2122 (ert-deftest test-org-element/table-cell-parser ()
2123   "Test `table-cell' parser."
2124   ;; Regular table cell.
2125   (should
2126    (org-test-with-temp-text "| a |"
2127      (org-element-map (org-element-parse-buffer) 'table-cell 'identity)))
2128   ;; Last vertical bar may be omitted.
2129   (should
2130    (org-test-with-temp-text "| a "
2131      (org-element-map (org-element-parse-buffer) 'table-cell 'identity))))
2132
2133
2134 ;;;; Table Row
2135
2136 (ert-deftest test-org-element/table-row-parser ()
2137   "Test `table-row' parser."
2138   (should
2139    (equal '(standard rule)
2140           (org-test-with-temp-text "| a |\n|---|"
2141             (org-element-map
2142              (org-element-parse-buffer) 'table-row
2143              (lambda (row) (org-element-property :type row)))))))
2144
2145
2146 ;;;; Target
2147
2148 (ert-deftest test-org-element/target-parser ()
2149   "Test `target' parser."
2150   (should
2151    (org-test-with-temp-text "<<target>>"
2152      (org-element-map (org-element-parse-buffer) 'target 'identity))))
2153
2154
2155 ;;;; Timestamp
2156
2157 (ert-deftest test-org-element/timestamp ()
2158   "Test `timestamp' parser."
2159   ;; Active timestamp.
2160   (should
2161    (org-test-with-temp-text "<2012-03-29 16:40>"
2162      (eq (org-element-property :type (org-element-context)) 'active)))
2163   (should-not
2164    (org-test-with-temp-text "<2012-03-29 Thu>"
2165      (let ((timestamp (org-element-context)))
2166        (or (org-element-property :hour-start timestamp)
2167            (org-element-property :minute-start timestamp)))))
2168   (should
2169    (equal '(2012 3 29 16 40)
2170           (org-test-with-temp-text "<2012-03-29 Thu 16:40>"
2171             (let ((object (org-element-context)))
2172               (list (org-element-property :year-start object)
2173                     (org-element-property :month-start object)
2174                     (org-element-property :day-start object)
2175                     (org-element-property :hour-start object)
2176                     (org-element-property :minute-start object))))))
2177   ;; Inactive timestamp.
2178   (should
2179    (org-test-with-temp-text "[2012-03-29 Thu 16:40]"
2180      (eq (org-element-property :type (org-element-context)) 'inactive)))
2181   ;; Time range.
2182   (should
2183    (equal '(2012 3 29 16 40 7 30)
2184           (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2185             (let ((object (org-element-context)))
2186               (list (org-element-property :year-end object)
2187                     (org-element-property :month-end object)
2188                     (org-element-property :day-end object)
2189                     (org-element-property :hour-end object)
2190                     (org-element-property :minute-end object)
2191                     (org-element-property :hour-start object)
2192                     (org-element-property :minute-start object))))))
2193   (should
2194    (eq 'active-range
2195        (org-test-with-temp-text "<2012-03-29 Thu 7:30-16:40>"
2196          (org-element-property :type (org-element-context)))))
2197   ;; Date range.
2198   (should
2199    (org-test-with-temp-text "[2012-03-29 Thu 16:40]--[2012-03-29 Thu 16:41]"
2200      (eq (org-element-property :type (org-element-context)) 'inactive-range)))
2201   (should-not
2202    (org-test-with-temp-text "[2011-07-14 Thu]--[2012-03-29 Thu]"
2203      (let ((timestamp (org-element-context)))
2204        (or (org-element-property :hour-end timestamp)
2205            (org-element-property :minute-end timestamp)))))
2206   ;; With repeater, warning delay and both.
2207   (should
2208    (eq 'catch-up
2209        (org-test-with-temp-text "<2012-03-29 Thu ++1y>"
2210          (org-element-property :repeater-type (org-element-context)))))
2211   (should
2212    (eq 'first
2213        (org-test-with-temp-text "<2012-03-29 Thu --1y>"
2214          (org-element-property :warning-type (org-element-context)))))
2215   (should
2216    (equal '(cumulate all)
2217           (org-test-with-temp-text "<2012-03-29 Thu +1y -1y>"
2218             (let ((ts (org-element-context)))
2219               (list (org-element-property :repeater-type ts)
2220                     (org-element-property :warning-type ts)))))))
2221
2222
2223 ;;;; Underline
2224
2225 (ert-deftest test-org-element/underline-parser ()
2226   "Test `underline' parser."
2227   ;; Regular test.
2228   (should
2229    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2230      (org-test-with-temp-text "_underline_"
2231        (org-element-map (org-element-parse-buffer) 'underline 'identity))))
2232   ;; Multi-line markup.
2233   (should
2234    (equal
2235     (org-element-contents
2236      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2237        (org-test-with-temp-text "_first line\nsecond line_"
2238          (org-element-map
2239           (org-element-parse-buffer) 'underline 'identity nil t))))
2240     '("first line\nsecond line"))))
2241
2242
2243 ;;;; Verbatim
2244
2245 (ert-deftest test-org-element/verbatim-parser ()
2246   "Test `verbatim' parser."
2247   ;; Regular test.
2248   (should
2249    (let ((org-emph-re "\\([     ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2250      (org-test-with-temp-text "=verbatim="
2251        (org-element-map (org-element-parse-buffer) 'verbatim 'identity))))
2252   ;; Multi-line markup.
2253   (should
2254    (equal
2255     (org-element-property
2256      :value
2257      (let ((org-emph-re "\\([   ('\"{]\\|^\\)\\(\\([+*/_=~]\\)\\([^     
\n,\"']\\|[^   
\n,\"'].*?\\(?:\n.*?\\)\\{0,1\\}[^     
\n,\"']\\)\\3\\)\\([-  .,:!?;'\")}\\]\\|$\\)"))
2258        (org-test-with-temp-text "=first line\nsecond line="
2259          (org-element-map
2260           (org-element-parse-buffer) 'verbatim 'identity nil t))))
2261     "first line\nsecond line")))
2262
2263
2264 ;;;; Verse Block
2265
2266 (ert-deftest test-org-element/verse-block-parser ()
2267   "Test `verse-block' parser."
2268   ;; Standard test.
2269   (should
2270    (org-test-with-temp-text "#+BEGIN_VERSE\nVerse block\n#+END_VERSE"
2271      (org-element-map (org-element-parse-buffer) 'verse-block 'identity)))
2272   ;; Ignore case.
2273   (should
2274    (org-test-with-temp-text "#+begin_verse\nVerse block\n#+end_verse"
2275      (org-element-map (org-element-parse-buffer) 'verse-block 'identity)))
2276   ;; Parse objects in verse blocks.
2277   (should
2278    (org-test-with-temp-text "#+BEGIN_VERSE\nVerse \\alpha\n#+END_VERSE"
2279      (org-element-map (org-element-parse-buffer) 'entity 'identity)))
2280   ;; Ignore incomplete verse block.
2281   (should-not
2282    (org-test-with-temp-text "#+BEGIN_VERSE"
2283      (org-element-map (org-element-parse-buffer) 'verse-block 'identity nil t)))
2284   ;; Handle non-empty blank line at the end of buffer.
2285   (should
2286    (org-test-with-temp-text "#+BEGIN_VERSE\nC\n#+END_VERSE\n "
2287      (= (org-element-property :end (org-element-at-point)) (point-max)))))
2288
2289
2290 \f
2291 ;;; Test Interpreters.
2292
2293 (ert-deftest test-org-element/interpret-data ()
2294   "Test `org-element-interpret-data' specifications."
2295   ;; Interpret simple affiliated keywords.
2296   (should
2297    (equal
2298     (org-element-interpret-data
2299      '(org-data nil (paragraph (:name "para") "Paragraph")))
2300     "#+NAME: para\nParagraph\n"))
2301   ;; Interpret multiple affiliated keywords.
2302   (should
2303    (equal
2304     (org-element-interpret-data
2305      '(org-data nil (paragraph (:attr_ascii ("line2" "line1")) "Paragraph")))
2306     "#+ATTR_ASCII: line1\n#+ATTR_ASCII: line2\nParagraph\n"))
2307   ;; Interpret parsed affiliated keywords.
2308   (should
2309    (equal
2310     (org-element-interpret-data
2311      '(org-data nil (paragraph (:caption (("caption"))) "Paragraph")))
2312     "#+CAPTION: caption\nParagraph\n"))
2313   ;; Interpret dual affiliated keywords.
2314   (should
2315    (equal
2316     (org-element-interpret-data
2317      '(org-data nil (paragraph (:caption ((("long") "short"))) "Paragraph")))
2318     "#+CAPTION[short]: long\nParagraph\n"))
2319   ;; Interpret multiple parsed dual keywords.
2320   (should
2321    (equal
2322     (org-element-interpret-data
2323      '(org-data nil (paragraph
2324                      (:caption ((("l2") "s2") (("l1") "s1"))) "Paragraph")))
2325     "#+CAPTION[s1]: l1\n#+CAPTION[s2]: l2\nParagraph\n"))
2326   ;; Pseudo objects and elements are transparent.
2327   (should
2328    (equal "A B"
2329           (org-trim
2330            (org-element-interpret-data
2331             '(paragraph nil (pseudo-object (:post-blank 1) "A") "B")))))
2332   (should
2333    (equal "A\n\nB\n"
2334           (org-element-interpret-data
2335            '(center nil
2336                     (pseudo-element (:post-blank 1) (paragraph nil "A"))
2337                     (paragraph nil "B"))))))
2338
2339 (ert-deftest test-org-element/center-block-interpreter ()
2340   "Test center block interpreter."
2341   (should
2342    (equal (org-test-parse-and-interpret "#+BEGIN_CENTER\nTest\n#+END_CENTER")
2343           "#+BEGIN_CENTER\nTest\n#+END_CENTER\n")))
2344
2345 (ert-deftest test-org-element/drawer-interpreter ()
2346   "Test drawer interpreter."
2347   (should
2348    (equal (org-test-parse-and-interpret ":TEST:\nTest\n:END:")
2349           ":TEST:\nTest\n:END:\n")))
2350
2351 (ert-deftest test-org-element/dynamic-block-interpreter ()
2352   "Test dynamic block interpreter."
2353   (should
2354    (equal (org-test-parse-and-interpret
2355            "#+BEGIN: myblock :parameter value1\nTest\n#+END:")
2356           "#+BEGIN: myblock :parameter value1\nTest\n#+END:\n")))
2357
2358 (ert-deftest test-org-element/footnote-definition-interpreter ()
2359   "Test footnote definition interpreter."
2360   (should (equal (org-test-parse-and-interpret "[fn:1] Test") "[fn:1] Test\n")))
2361
2362 (ert-deftest test-org-element/headline-interpreter ()
2363   "Test headline and section interpreters."
2364   ;; 1. Standard test.
2365   (should (equal (org-test-parse-and-interpret "* Headline") "* Headline\n"))
2366   ;; 2. With TODO keywords.
2367   (should
2368    (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2369             (org-test-parse-and-interpret "* TODO Headline"))
2370           "* TODO Headline\n"))
2371   ;; 3. With tags...
2372   ;;
2373   ;; 3.1. ... and a positive `org-tags-column' value.
2374   (should
2375    (equal (let ((org-tags-column 20))
2376             (org-test-parse-and-interpret "* Headline :tag:"))
2377           "* Headline          :tag:\n"))
2378   ;; 3.2. ... and a negative `org-tags-column' value.
2379   (should
2380    (equal (let ((org-tags-column -20))
2381             (org-test-parse-and-interpret "* Headline :tag:"))
2382           "* Headline     :tag:\n"))
2383   ;; 3.3. ... and a null `org-tags-column' value.
2384   (should
2385    (equal (let ((org-tags-column 0))
2386             (org-test-parse-and-interpret "* Headline     :tag:"))
2387           "* Headline :tag:\n"))
2388   ;; 4. With priority cookie.
2389   (should
2390    (equal (org-test-parse-and-interpret "* [#B] Headline")
2391           "* [#B] Headline\n"))
2392   ;; 5. With comment keyword.
2393   (should
2394    (equal (let ((org-comment-string "COMMENT"))
2395             (org-test-parse-and-interpret "* COMMENT Headline"))
2396           "* COMMENT Headline\n"))
2397   ;; 6. Keep same number of blank lines before body.
2398   (should
2399    (equal (org-test-parse-and-interpret
2400            "* Headline\n\n\nText after two blank lines.")
2401           "* Headline\n\n\nText after two blank lines.\n"))
2402   ;; 8. Preserve `org-odd-levels-only' state.
2403   (should
2404    (equal "* H\n*** H2\n"
2405           (let ((org-odd-levels-only t))
2406             (org-test-parse-and-interpret "* H\n*** H2")))))
2407
2408 (ert-deftest test-org-element/inlinetask-interpreter ()
2409   "Test inlinetask interpretation."
2410   (when (featurep 'org-inlinetask)
2411     (let ((org-inlinetask-min-level 15))
2412       ;; 1. Regular inlinetask.
2413      (should (equal (org-test-parse-and-interpret
2414                      "*************** Task\nTest\n*************** END")
2415                     "*************** Task\nTest\n*************** END\n"))
2416      ;; 2. Degenerate inlinetask.
2417      (should (equal (org-test-parse-and-interpret "*************** Task")
2418                     "*************** Task\n"))
2419      ;; 3. Prefer degenerate form when there are no contents.
2420      (should (equal (org-test-parse-and-interpret
2421                      "*************** Task\n*************** END")
2422                     "*************** Task\n"))
2423      ;; 4. With TODO keywords.
2424      (should
2425       (equal (let ((org-todo-keywords '((sequence "TODO" "DONE"))))
2426                (org-test-parse-and-interpret "*************** TODO Task"))
2427              "*************** TODO Task\n"))
2428      ;; 5. With tags...
2429      ;;
2430      ;; 5.1. ... and a positive `org-tags-column' value.
2431      (should
2432       (equal (let ((org-tags-column 30))
2433                (org-test-parse-and-interpret "*************** Task :tag:"))
2434              "*************** Task          :tag:\n"))
2435      ;; 5.2. ... and a negative `org-tags-column' value.
2436      (should
2437       (equal (let ((org-tags-column -30))
2438                (org-test-parse-and-interpret "*************** Task :tag:"))
2439              "*************** Task     :tag:\n"))
2440      ;; 5.3. ... and a null `org-tags-column' value.
2441      (should
2442       (equal (let ((org-tags-column 0))
2443                (org-test-parse-and-interpret "*************** Task     :tag:"))
2444              "*************** Task :tag:\n"))
2445      ;; 6. With priority cookie.
2446      (should
2447       (equal (org-test-parse-and-interpret "*************** [#B] Task")
2448              "*************** [#B] Task\n")))))
2449
2450 (ert-deftest test-org-element/plain-list-interpreter ()
2451   "Test plain-list and item interpreters."
2452   (let ((org-list-two-spaces-after-bullet-regexp nil))
2453     ;; Unordered list.
2454     (should (equal (org-test-parse-and-interpret "- item 1") "- item 1\n"))
2455     ;; Description list.
2456     (should
2457      (equal (org-test-parse-and-interpret "- tag :: desc") "- tag :: desc\n"))
2458     ;; Ordered list.
2459     (should
2460      (equal (let ((org-plain-list-ordered-item-terminator t))
2461               (org-test-parse-and-interpret "1. Item"))
2462             "1. Item\n"))
2463     (should
2464      (equal (let ((org-plain-list-ordered-item-terminator ?\)))
2465               (org-test-parse-and-interpret "1) Item"))
2466             "1) Item\n"))
2467     ;; Ordered list with counter.
2468     (should
2469      (equal (let ((org-plain-list-ordered-item-terminator t))
2470               (org-test-parse-and-interpret "1. [@5] Item"))
2471             "5. [@5] Item\n"))
2472     ;; List with check-boxes.
2473     (should
2474      (equal (org-test-parse-and-interpret
2475              "- [-] Item 1\n  - [X] Item 2\n  - [ ] Item 3")
2476             "- [-] Item 1\n  - [X] Item 2\n  - [ ] Item 3\n"))
2477     ;; Item not starting with a paragraph.
2478     (should
2479      (equal (org-test-parse-and-interpret "-\n  | a | b |")
2480             "- \n  | a | b |\n"))
2481     ;; Special case: correctly handle "*" bullets.
2482     (should (org-test-parse-and-interpret " * item"))
2483     ;; Special case: correctly handle empty items.
2484     (should (org-test-parse-and-interpret "-"))))
2485
2486 (ert-deftest test-org-element/quote-block-interpreter ()
2487   "Test quote block interpreter."
2488   (should (equal (org-test-parse-and-interpret
2489                   "#+BEGIN_QUOTE\nTest\n#+END_QUOTE")
2490                  "#+BEGIN_QUOTE\nTest\n#+END_QUOTE\n")))
2491
2492 (ert-deftest test-org-element/special-block-interpreter ()
2493   "Test special block interpreter."
2494   (should (equal (org-test-parse-and-interpret
2495                   "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL")
2496                  "#+BEGIN_SPECIAL\nTest\n#+END_SPECIAL\n")))
2497
2498 (ert-deftest test-org-element/babel-call-interpreter ()
2499   "Test Babel call interpreter."
2500   ;; Without argument.
2501   (should (equal (org-test-parse-and-interpret "#+CALL: test()")
2502                  "#+CALL: test()\n"))
2503   ;; With argument.
2504   (should (equal (org-test-parse-and-interpret "#+CALL: test(x=2)")
2505                  "#+CALL: test(x=2)\n"))
2506   ;; With header arguments.
2507   (should (equal (org-test-parse-and-interpret
2508                   "#+CALL: test[:results output]() :results html")
2509                  "#+CALL: test[:results output]() :results html\n")))
2510
2511 (ert-deftest test-org-element/clock-interpreter ()
2512   "Test clock interpreter."
2513   ;; Running clock.
2514   (should
2515    (string-match
2516     "CLOCK: \\[2012-01-01 .* 00:01\\]"
2517     (org-test-parse-and-interpret "CLOCK: [2012-01-01 sun. 00:01]")))
2518   ;; Closed clock.
2519   (should
2520    (string-match
2521     "CLOCK: \\[2012-01-01 .* 00:01\\]--\\[2012-01-01 .* 00:02\\] =>  0:01"
2522     (org-test-parse-and-interpret "
2523 CLOCK: [2012-01-01 sun. 00:01]--[2012-01-01 sun. 00:02] =>  0:01"))))
2524
2525 (ert-deftest test-org-element/comment-interpreter ()
2526   "Test comment interpreter."
2527   ;; Regular comment.
2528   (should (equal (org-test-parse-and-interpret "# Comment") "# Comment\n"))
2529   ;; Inline comment.
2530   (should (equal (org-test-parse-and-interpret "  # Comment")
2531                  "# Comment\n"))
2532   ;; Preserve indentation.
2533   (should (equal (org-test-parse-and-interpret "  # No blank\n#  One blank")
2534                  "# No blank\n#  One blank\n")))
2535
2536 (ert-deftest test-org-element/comment-block-interpreter ()
2537   "Test comment block interpreter."
2538   (should (equal (org-test-parse-and-interpret
2539                   "#+BEGIN_COMMENT\nTest\n#+END_COMMENT")
2540                  "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"))
2541   ;; Accept missing final newline in value.
2542   (should
2543    (equal
2544     "#+BEGIN_COMMENT\nTest\n#+END_COMMENT\n"
2545     (org-element-interpret-data '(comment-block (:value "Test"))))))
2546
2547 (ert-deftest test-org-element/diary-sexp ()
2548   "Test diary-sexp interpreter."
2549   (should
2550    (equal
2551     (org-test-parse-and-interpret
2552      "%%(org-anniversary 1956  5 14)(2) Arthur Dent is %d years old")
2553     "%%(org-anniversary 1956  5 14)(2) Arthur Dent is %d years old\n")))
2554
2555 (ert-deftest test-org-element/example-block-interpreter ()
2556   "Test example block interpreter."
2557   ;; Without switches.
2558   (should (equal (org-test-parse-and-interpret
2559                   "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE")
2560                  "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"))
2561   ;; With switches.
2562   (should
2563    (equal (org-test-parse-and-interpret
2564            "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE")
2565           "#+BEGIN_EXAMPLE -n -k\n(+ 1 1)\n#+END_EXAMPLE\n"))
2566   ;; Preserve code escaping.
2567   (should
2568    (equal (org-test-parse-and-interpret
2569            "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE")
2570           "#+BEGIN_EXAMPLE\n,* Headline\n ,#+keyword\nText #+END_EXAMPLE\n"))
2571   ;; Accept missing final newline in value.
2572   (should
2573    (equal
2574     "#+BEGIN_EXAMPLE\nTest\n#+END_EXAMPLE\n"
2575     (org-element-interpret-data '(example-block (:value "Test"))))))
2576
2577 (ert-deftest test-org-element/export-block-interpreter ()
2578   "Test export block interpreter."
2579   (should (equal (org-test-parse-and-interpret
2580                   "#+BEGIN_HTML\nTest\n#+END_HTML")
2581                  "#+BEGIN_HTML\nTest\n#+END_HTML\n")))
2582
2583 (ert-deftest test-org-element/fixed-width-interpreter ()
2584   "Test fixed width interpreter."
2585   ;; Standard test.
2586   (should (equal (org-test-parse-and-interpret ": Test") ": Test\n"))
2587   ;; Preserve indentation.
2588   (should (equal (org-test-parse-and-interpret ":  2 blanks\n: 1 blank")
2589                  ":  2 blanks\n: 1 blank\n"))
2590   ;; Remove last newline character
2591   (should
2592    (equal (org-element-fixed-width-interpreter
2593            '(fixed-width (:value "Test\n")) nil)
2594           ": Test"))
2595   (should
2596    (equal (org-element-fixed-width-interpreter
2597            '(fixed-width (:value "Test")) nil)
2598           ": Test"))
2599   ;; Handle empty string.
2600   (should
2601    (equal (org-element-fixed-width-interpreter
2602            '(fixed-width (:value "")) nil)
2603           ""))
2604   ;; Handle nil value.
2605   (should-not
2606    (org-element-fixed-width-interpreter
2607     '(fixed-width (:value nil)) nil)))
2608
2609 (ert-deftest test-org-element/horizontal-rule-interpreter ()
2610   "Test horizontal rule interpreter."
2611   (should (equal (org-test-parse-and-interpret "-------") "-----\n")))
2612
2613 (ert-deftest test-org-element/keyword-interpreter ()
2614   "Test keyword interpreter."
2615   (should (equal (org-test-parse-and-interpret "#+KEYWORD: value")
2616                  "#+KEYWORD: value\n")))
2617
2618 (ert-deftest test-org-element/latex-environment-interpreter ()
2619   "Test latex environment interpreter."
2620   (should (equal (org-test-parse-and-interpret
2621                   "\\begin{equation}\n1+1=2\n\\end{equation}")
2622                  "\\begin{equation}\n1+1=2\n\\end{equation}\n"))
2623   (should (equal (org-test-parse-and-interpret
2624                   "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}")
2625                  "\\begin{theorem}[me]\n1+1=2\n\\end{theorem}\n")))
2626
2627 (ert-deftest test-org-element/planning-interpreter ()
2628   "Test planning interpreter."
2629   (should
2630    (string-match
2631     "\\* Headline
2632 DEADLINE: <2012-03-29 .*?> SCHEDULED: <2012-03-29 .*?> CLOSED: \\[2012-03-29 .*?\\]"
2633     (org-test-parse-and-interpret
2634      "* Headline
2635 DEADLINE: <2012-03-29 thu.> SCHEDULED: <2012-03-29 thu.> CLOSED: [2012-03-29 thu.]"))))
2636
2637 (ert-deftest test-org-element/property-drawer-interpreter ()
2638   "Test property drawer interpreter."
2639   (should (equal (let ((org-property-format "%-10s %s"))
2640                    (org-test-parse-and-interpret
2641                     "* H\n:PROPERTIES:\n:prop: value\n:END:"))
2642                  "* H\n:PROPERTIES:\n:prop:     value\n:END:\n")))
2643
2644 (ert-deftest test-org-element/src-block-interpreter ()
2645   "Test src block interpreter."
2646   ;; With arguments.
2647   (should
2648    (equal (let ((org-edit-src-content-indentation 2)
2649                 (org-src-preserve-indentation nil))
2650             (org-test-parse-and-interpret
2651              "#+BEGIN_SRC emacs-lisp :results silent\n(+ 1 1)\n#+END_SRC"))
2652           "#+BEGIN_SRC emacs-lisp :results silent\n  (+ 1 1)\n#+END_SRC\n"))
2653   ;; With switches.
2654   (should
2655    (equal (let ((org-edit-src-content-indentation 2)
2656                 (org-src-preserve-indentation nil))
2657             (org-test-parse-and-interpret
2658              "#+BEGIN_SRC emacs-lisp -n -k\n(+ 1 1)\n#+END_SRC"))
2659           "#+BEGIN_SRC emacs-lisp -n -k\n  (+ 1 1)\n#+END_SRC\n"))
2660   ;; Preserve code escaping.
2661   (should
2662    (equal (let ((org-edit-src-content-indentation 2)
2663                 (org-src-preserve-indentation nil))
2664             (org-test-parse-and-interpret
2665              "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC"))
2666           "#+BEGIN_SRC org\n,* Headline\n ,#+keyword\nText #+END_SRC\n"))
2667   ;; Do not apply `org-edit-src-content-indentation' when preserving
2668   ;; indentation.
2669   (should
2670    (equal (let ((org-edit-src-content-indentation 2)
2671                 (org-src-preserve-indentation t))
2672             (org-test-parse-and-interpret
2673              "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"))
2674           "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n"))
2675   (should
2676    (equal (let ((org-edit-src-content-indentation 2)
2677                 (org-src-preserve-indentation nil))
2678             (org-test-parse-and-interpret
2679              "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC"))
2680           "#+BEGIN_SRC emacs-lisp -i\n(+ 1 1)\n#+END_SRC\n"))
2681   ;; Accept missing final newline in value.
2682   (should
2683    (equal
2684     "#+BEGIN_SRC emacs-lisp\n  Test\n#+END_SRC\n"
2685     (let ((org-edit-src-content-indentation 2)
2686           (org-src-preserve-indentation nil))
2687       (org-element-interpret-data
2688        '(src-block (:language "emacs-lisp" :value "Test")))))))
2689
2690 (ert-deftest test-org-element/table-interpreter ()
2691   "Test table, table-row and table-cell interpreters."
2692   ;; 1. Simple table.
2693   (should (equal (org-test-parse-and-interpret "| a | b |\n| c | d |")
2694                  "| a | b |\n| c | d |\n"))
2695   ;; 2. With horizontal rules.
2696   (should (equal (org-test-parse-and-interpret
2697                   "| a | b |\n|---+---|\n| c | d |")
2698                  "| a | b |\n|---+---|\n| c | d |\n"))
2699   ;; 3. With meta-data.
2700   (should (equal (org-test-parse-and-interpret "| / | < | > |\n| * | 1 | 2 |")
2701                  "| / | < | > |\n| * | 1 | 2 |\n"))
2702   ;; 4. With a formula.
2703   (should
2704    (equal (org-test-parse-and-interpret
2705            "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)")
2706           "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: @3=vmean(@1..@2)\n"))
2707   ;; 5. With multiple formulas.
2708   (should
2709    (equal (org-test-parse-and-interpret
2710            "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2")
2711           "| 2 |\n| 4 |\n| 3 |\n#+TBLFM: test1\n#+TBLFM: test2\n")))
2712
2713 (ert-deftest test-org-element/timestamp-interpreter ()
2714   "Test timestamp interpreter."
2715   ;; Active.
2716   (should
2717    (string-match "<2012-03-29 .* 16:40>"
2718                  (org-test-parse-and-interpret "<2012-03-29 thu. 16:40>")))
2719   (should
2720    (string-match "<2012-03-29 .* 16:40>"
2721                  (org-element-timestamp-interpreter
2722                   '(timestamp
2723                     (:type active :year-start 2012 :month-start 3 :day-start 29
2724                            :hour-start 16 :minute-start 40)) nil)))
2725   ;; Inactive.
2726   (should
2727    (string-match "\\[2012-03-29 .* 16:40\\]"
2728                  (org-test-parse-and-interpret "[2012-03-29 thu. 16:40]")))
2729   (should
2730    (string-match
2731     "\\[2012-03-29 .* 16:40\\]"
2732     (org-element-timestamp-interpreter
2733      '(timestamp
2734        (:type inactive :year-start 2012 :month-start 3 :day-start 29
2735               :hour-start 16 :minute-start 40)) nil)))
2736   ;; Active range.
2737   (should
2738    (string-match "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2739                  (org-test-parse-and-interpret
2740                   "<2012-03-29 thu. 16:40>--<2012-03-29 thu. 16:41>")))
2741   (should
2742    (string-match
2743     "<2012-03-29 .* 16:40>--<2012-03-29 .* 16:41>"
2744     (org-element-timestamp-interpreter
2745      '(timestamp
2746        (:type active-range :year-start 2012 :month-start 3 :day-start 29
2747               :hour-start 16 :minute-start 40 :year-end 2012 :month-end 3
2748               :day-end 29 :hour-end 16 :minute-end 41)) nil)))
2749   ;; Inactive range.
2750   (should
2751    (string-match "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2752                  (org-test-parse-and-interpret
2753                   "[2012-03-29 thu. 16:40]--[2012-03-29 thu. 16:41]")))
2754   (should
2755    (string-match
2756     "\\[2012-03-29 .* 16:40\\]--\\[2012-03-29 .* 16:41\\]"
2757     (org-element-timestamp-interpreter
2758      '(timestamp
2759        (:type inactive-range :year-start 2012 :month-start 3 :day-start 29
2760               :hour-start 16 :minute-start 40 :year-end 2012 :month-end 3
2761               :day-end 29 :hour-end 16 :minute-end 41)) nil)))
2762   ;; Diary.
2763   (should (equal (org-test-parse-and-interpret "<%%diary-float t 4 2>")
2764                  "<%%diary-float t 4 2>\n"))
2765   ;; Timestamp with repeater interval, with delay, with both.
2766   (should
2767    (string-match "<2012-03-29 .* \\+1y>"
2768                  (org-test-parse-and-interpret "<2012-03-29 thu. +1y>")))
2769   (should
2770    (string-match
2771     "<2012-03-29 .* \\+1y>"
2772     (org-element-timestamp-interpreter
2773      '(timestamp
2774        (:type active :year-start 2012 :month-start 3 :day-start 29
2775               :repeater-type cumulate :repeater-value 1 :repeater-unit year))
2776      nil)))
2777   (should
2778    (string-match
2779     "<2012-03-29 .* -1y>"
2780     (org-element-timestamp-interpreter
2781      '(timestamp
2782        (:type active :year-start 2012 :month-start 3 :day-start 29
2783               :warning-type all :warning-value 1 :warning-unit year))
2784      nil)))
2785   (should
2786    (string-match
2787     "<2012-03-29 .* \\+1y -1y>"
2788     (org-element-timestamp-interpreter
2789      '(timestamp
2790        (:type active :year-start 2012 :month-start 3 :day-start 29
2791               :warning-type all :warning-value 1 :warning-unit year
2792               :repeater-type cumulate :repeater-value 1 :repeater-unit year))
2793      nil)))
2794   ;; Timestamp range with repeater interval
2795   (should
2796    (string-match "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2797                  (org-test-parse-and-interpret
2798                   "<2012-03-29 Thu +1y>--<2012-03-30 Thu +1y>")))
2799   (should
2800    (string-match
2801     "<2012-03-29 .* \\+1y>--<2012-03-30 .* \\+1y>"
2802     (org-element-timestamp-interpreter
2803      '(timestamp
2804        (:type active-range :year-start 2012 :month-start 3 :day-start 29
2805               :year-end 2012 :month-end 3 :day-end 30 :repeater-type cumulate
2806               :repeater-value 1 :repeater-unit year))
2807      nil))))
2808
2809 (ert-deftest test-org-element/verse-block-interpreter ()
2810   "Test verse block interpretation."
2811   (should
2812    (equal (org-test-parse-and-interpret "#+BEGIN_VERSE\nTest\n#+END_VERSE")
2813           "#+BEGIN_VERSE\nTest\n#+END_VERSE\n")))
2814
2815 (ert-deftest test-org-element/bold-interpreter ()
2816   "Test bold interpreter."
2817   (should (equal (org-test-parse-and-interpret "*text*") "*text*\n")))
2818
2819 (ert-deftest test-org-element/code-interpreter ()
2820   "Test code interpreter."
2821   (should (equal (org-test-parse-and-interpret "~text~") "~text~\n")))
2822
2823 (ert-deftest test-org-element/entity-interpreter ()
2824   "Test entity interpreter."
2825   ;; 1. Without brackets.
2826   (should
2827    (equal (org-test-parse-and-interpret "\\alpha text") "\\alpha text\n"))
2828   ;; 2. With brackets.
2829   (should
2830    (equal (org-test-parse-and-interpret "\\alpha{}text") "\\alpha{}text\n")))
2831
2832 (ert-deftest test-org-element/export-snippet-interpreter ()
2833   "Test export snippet interpreter."
2834   (should (equal (org-test-parse-and-interpret "@@back-end:contents@@")
2835                  "@@back-end:contents@@\n")))
2836
2837 (ert-deftest test-org-element/footnote-reference-interpreter ()
2838   "Test footnote reference interpreter."
2839   ;; 1. Regular reference.
2840   (should (equal (org-test-parse-and-interpret "Text[fn:1]") "Text[fn:1]\n"))
2841   ;; 2. Normalized reference.
2842   (should (equal (org-test-parse-and-interpret "Text[1]") "Text[1]\n"))
2843   ;; 3. Named reference.
2844   (should (equal (org-test-parse-and-interpret "Text[fn:label]")
2845                  "Text[fn:label]\n"))
2846   ;; 4. Inline reference.
2847   (should (equal (org-test-parse-and-interpret "Text[fn:label:def]")
2848                  "Text[fn:label:def]\n"))
2849   ;; 5. Anonymous reference.
2850   (should (equal (org-test-parse-and-interpret "Text[fn::def]")
2851                  "Text[fn::def]\n")))
2852
2853 (ert-deftest test-org-element/inline-babel-call-interpreter ()
2854   "Test inline babel call interpreter."
2855   ;; Without arguments.
2856   (should (equal (org-test-parse-and-interpret "call_test()") "call_test()\n"))
2857   ;; With arguments.
2858   (should (equal (org-test-parse-and-interpret "call_test(x=2)")
2859                  "call_test(x=2)\n"))
2860   ;; With header arguments.
2861   (should (equal (org-test-parse-and-interpret
2862                   "call_test[:results output]()[:results html]")
2863                  "call_test[:results output]()[:results html]\n")))
2864
2865 (ert-deftest test-org-element/inline-src-block-interpreter ()
2866   "Test inline src block interpreter."
2867   ;; 1. Without header argument.
2868   (should (equal (org-test-parse-and-interpret "src_emacs-lisp{(+ 1 1)}")
2869                  "src_emacs-lisp{(+ 1 1)}\n"))
2870   ;; 2. With header arguments.
2871   (should (equal (org-test-parse-and-interpret
2872                   "src_emacs-lisp[:results silent]{(+ 1 1)}")
2873                  "src_emacs-lisp[:results silent]{(+ 1 1)}\n")))
2874
2875 (ert-deftest test-org-element/italic-interpreter ()
2876   "Test italic interpreter."
2877   (should (equal (org-test-parse-and-interpret "/text/") "/text/\n")))
2878
2879 (ert-deftest test-org-element/latex-fragment-interpreter ()
2880   "Test latex fragment interpreter."
2881   (should (equal (org-test-parse-and-interpret "\\command{}") "\\command{}\n"))
2882   (should (equal (org-test-parse-and-interpret "$x$") "$x$\n"))
2883   (should (equal (org-test-parse-and-interpret "$x+y$") "$x+y$\n"))
2884   (should (equal (org-test-parse-and-interpret "$$x+y$$") "$$x+y$$\n"))
2885   (should (equal (org-test-parse-and-interpret "\\(x+y\\)") "\\(x+y\\)\n"))
2886   (should (equal (org-test-parse-and-interpret "\\[x+y\\]") "\\[x+y\\]\n")))
2887
2888 (ert-deftest test-org-element/line-break-interpreter ()
2889   "Test line break interpreter."
2890   (should (equal (org-test-parse-and-interpret "First line \\\\ \nSecond line")
2891                  "First line \\\\\nSecond line\n")))
2892
2893 (ert-deftest test-org-element/link-interpreter ()
2894   "Test link interpreter."
2895   ;; 1. Links targeted from a radio target.
2896   (should (equal (let ((org-target-link-regexp "radio-target"))
2897                    (org-test-parse-and-interpret "a radio-target"))
2898                  "a radio-target\n"))
2899   ;; 2. Regular links.
2900   ;;
2901   ;; 2.1. Without description.
2902   (should (equal (org-test-parse-and-interpret "[[http://orgmode.org]]")
2903                  "[[http://orgmode.org]]\n"))
2904   ;; 2.2. With a description.
2905   (should (equal (org-test-parse-and-interpret
2906                   "[[http://orgmode.org][Org mode]]")
2907                  "[[http://orgmode.org][Org mode]]\n"))
2908   ;; 2.3. Id links.
2909   (should (equal (org-test-parse-and-interpret "[[id:aaaa]]") "[[id:aaaa]]\n"))
2910   ;; 2.4. Custom-id links.
2911   (should (equal (org-test-parse-and-interpret "[[#id]]") "[[#id]]\n"))
2912   ;; 2.5 Code-ref links.
2913   (should (equal (org-test-parse-and-interpret "[[(ref)]]") "[[(ref)]]\n"))
2914   ;; 3. Normalize plain links.
2915   (should (equal (org-test-parse-and-interpret "http://orgmode.org")
2916                  "[[http://orgmode.org]]\n"))
2917   ;; 4. Normalize angular links.
2918   (should (equal (org-test-parse-and-interpret "<http://orgmode.org>")
2919                  "[[http://orgmode.org]]\n")))
2920
2921 (ert-deftest test-org-element/macro-interpreter ()
2922   "Test macro interpreter."
2923   ;; 1. Without argument.
2924   (should (equal (org-test-parse-and-interpret "{{{test}}}") "{{{test}}}\n"))
2925   ;; 2. With arguments.
2926   (should (equal (org-test-parse-and-interpret "{{{test(arg1,arg2)}}}")
2927                  "{{{test(arg1,arg2)}}}\n")))
2928
2929 (ert-deftest test-org-element/radio-target-interpreter ()
2930   "Test radio target interpreter."
2931   (should (equal (org-test-parse-and-interpret "<<<some text>>>")
2932                  "<<<some text>>>\n")))
2933
2934 (ert-deftest test-org-element/statistics-cookie-interpreter ()
2935   "Test statistics cookie interpreter."
2936   ;; 1. Without percent
2937   (should (equal (org-test-parse-and-interpret "[0/1]") "[0/1]\n"))
2938   ;; 2. With percent.
2939   (should (equal (org-test-parse-and-interpret "[66%]") "[66%]\n")))
2940
2941 (ert-deftest test-org-element/strike-through-interpreter ()
2942   "Test strike through interpreter."
2943   (should (equal (org-test-parse-and-interpret "+target+") "+target+\n")))
2944
2945 (ert-deftest test-org-element/subscript-interpreter ()
2946   "Test subscript interpreter."
2947   ;; 1. Without brackets.
2948   (should (equal (org-test-parse-and-interpret "a_b") "a_b\n"))
2949   ;; 2. With brackets.
2950   (should (equal (org-test-parse-and-interpret "a_{b}") "a_{b}\n")))
2951
2952 (ert-deftest test-org-element/superscript-interpreter ()
2953   "Test superscript interpreter."
2954   ;; 1. Without brackets.
2955   (should (equal (org-test-parse-and-interpret "a^b") "a^b\n"))
2956   ;; 2. With brackets.
2957   (should (equal (org-test-parse-and-interpret "a^{b}") "a^{b}\n")))
2958
2959 (ert-deftest test-org-element/target-interpreter ()
2960   "Test target interpreter."
2961   (should (equal (org-test-parse-and-interpret "<<target>>") "<<target>>\n")))
2962
2963 (ert-deftest test-org-element/underline-interpreter ()
2964   "Test underline interpreter."
2965   (should (equal (org-test-parse-and-interpret "_text_") "_text_\n")))
2966
2967 (ert-deftest test-org-element/verbatim-interpreter ()
2968   "Test verbatim interpreter."
2969   (should (equal (org-test-parse-and-interpret "=text=") "=text=\n")))
2970
2971
2972 \f
2973 ;;; Test Granularity
2974
2975 (ert-deftest test-org-element/granularity ()
2976   "Test granularity impact on buffer parsing."
2977   (org-test-with-temp-text "
2978 * Head 1
2979 ** Head 2
2980 #+BEGIN_CENTER
2981 Centered paragraph.
2982 #+END_CENTER
2983 Paragraph \\alpha."
2984     ;; 1.1. Granularity set to `headline' should parse every headline
2985     ;;      in buffer, and only them.
2986     (let ((tree (org-element-parse-buffer 'headline)))
2987       (should (= 2 (length (org-element-map tree 'headline 'identity))))
2988       (should-not (org-element-map tree 'paragraph 'identity)))
2989     ;; 1.2. Granularity set to `greater-element' should not enter
2990     ;;      greater elements excepted headlines and sections.
2991     (let ((tree (org-element-parse-buffer 'greater-element)))
2992       (should (= 1 (length (org-element-map tree 'center-block 'identity))))
2993       (should (= 1 (length (org-element-map tree 'paragraph 'identity))))
2994       (should-not (org-element-map tree 'entity 'identity)))
2995     ;; 1.3. Granularity set to `element' should enter every
2996     ;;      greater-element.
2997     (let ((tree (org-element-parse-buffer 'element)))
2998       (should (= 2 (length (org-element-map tree 'paragraph 'identity))))
2999       (should-not (org-element-map tree 'entity 'identity)))
3000     ;; 1.4. Granularity set to `object' can see everything.
3001     (let ((tree (org-element-parse-buffer 'object)))
3002       (should (= 1 (length (org-element-map tree 'entity 'identity)))))))
3003
3004 (ert-deftest test-org-element/secondary-string-parsing ()
3005   "Test if granularity correctly toggles secondary strings parsing."
3006   ;; With a granularity bigger than `object', no secondary string
3007   ;; should be parsed.
3008   (should
3009    (stringp
3010     (org-test-with-temp-text "* Headline"
3011       (let ((headline
3012              (org-element-map (org-element-parse-buffer 'headline) 'headline
3013                #'identity nil 'first-match)))
3014         (org-element-property :title headline)))))
3015   (should
3016    (stringp
3017     (org-test-with-temp-text "* Headline\n- tag :: item"
3018       (let ((item (org-element-map (org-element-parse-buffer 'element) 'item
3019                     #'identity nil 'first-match)))
3020         (org-element-property :tag item)))))
3021   (when (featurep 'org-inlinetask)
3022     (should
3023      (stringp
3024       (let ((org-inlinetask-min-level 15))
3025         (org-test-with-temp-text "*************** Inlinetask"
3026           (let ((inlinetask (org-element-map (org-element-parse-buffer 'element)
3027                                 'inlinetask
3028                               #'identity nil 'first-match)))
3029             (org-element-property :title inlinetask)))))))
3030   ;; With a default granularity, secondary strings should be parsed.
3031   (should
3032    (listp
3033     (org-test-with-temp-text "* Headline"
3034       (let ((headline
3035              (org-element-map (org-element-parse-buffer) 'headline
3036                #'identity nil 'first-match)))
3037         (org-element-property :title headline)))))
3038   ;; `org-element-at-point' should never parse a secondary string.
3039   (should-not
3040    (listp
3041     (org-test-with-temp-text "* Headline"
3042       (org-element-property :title (org-element-at-point)))))
3043   ;; Preserve current local variables when parsing a secondary string.
3044   (should
3045    (let ((org-entities nil)
3046          (org-entities-user nil))
3047      (org-test-with-temp-text "
3048 #+CAPTION: \\foo
3049 Text
3050 # Local Variables:
3051 # org-entities-user: ((\"foo\"))
3052 # End:"
3053        (let ((safe-local-variable-values '((org-entities-user . (("foo"))))))
3054          (hack-local-variables))
3055        (org-element-map (org-element-parse-buffer) 'entity
3056          #'identity nil nil nil t)))))
3057
3058
3059 \f
3060 ;;; Test Visible Only Parsing
3061
3062 (ert-deftest test-org-element/parse-buffer-visible ()
3063   "Test `org-element-parse-buffer' with visible only argument."
3064   (should
3065    (equal '("H1" "H3" "H5")
3066       (org-test-with-temp-text
3067           "* H1\n** H2\n** H3 :visible:\n** H4\n** H5 :visible:"
3068         (org-occur ":visible:")
3069         (org-element-map (org-element-parse-buffer nil t) 'headline
3070           (lambda (hl) (org-element-property :raw-value hl)))))))
3071
3072
3073 \f
3074 ;;; Test `:parent' Property
3075
3076 (ert-deftest test-org-element/parent-property ()
3077   "Test `:parent' property."
3078   ;; Elements.
3079   (org-test-with-temp-text "#+BEGIN_CENTER\nText\n#+END_CENTER"
3080     (let* ((tree (org-element-parse-buffer))
3081            (parent (org-element-property
3082                     :parent
3083                     (org-element-map tree 'paragraph 'identity nil t))))
3084       (should parent)
3085       (should (eq (org-element-map tree 'center-block 'identity nil t)
3086                   parent))))
3087   ;; Objects.
3088   (org-test-with-temp-text "a_{/b/}"
3089     (let* ((tree (org-element-parse-buffer))
3090            (parent (org-element-property
3091                     :parent
3092                     (org-element-map tree 'italic 'identity nil t))))
3093       (should parent)
3094       (should (eq parent
3095                   (org-element-map tree 'subscript 'identity nil t)))))
3096   ;; Secondary strings
3097   (org-test-with-temp-text "* /italic/"
3098     (let* ((tree (org-element-parse-buffer))
3099            (parent (org-element-property
3100                     :parent (org-element-map tree 'italic 'identity nil t))))
3101       (should parent)
3102       (should (eq parent
3103                   (org-element-map tree 'headline 'identity nil t))))))
3104
3105
3106 \f
3107 ;;; Test Normalize Contents
3108
3109 (ert-deftest test-org-element/normalize-contents ()
3110   "Test `org-element-normalize-contents' specifications."
3111   ;; Remove maximum common indentation from element's contents.
3112   (should
3113    (equal
3114     (org-element-normalize-contents
3115      '(paragraph nil "  Two spaces\n   Three spaces"))
3116     '(paragraph nil "Two spaces\n Three spaces")))
3117   ;; Ignore objects within contents when computing maximum common
3118   ;; indentation.  However, if contents start with an object, common
3119   ;; indentation is 0.
3120   (should
3121    (equal
3122     (org-element-normalize-contents
3123      '(paragraph nil " One " (emphasis nil "space") "\n  Two spaces"))
3124     '(paragraph nil "One " (emphasis nil "space") "\n Two spaces")))
3125   (should
3126    (equal
3127     (org-element-normalize-contents
3128      '(paragraph nil (verbatim nil "V") "No space\n  Two\n   Three"))
3129     '(paragraph nil (verbatim nil "V") "No space\n  Two\n   Three")))
3130   ;; Ignore blank lines.
3131   (should
3132    (equal
3133     (org-element-normalize-contents
3134      '(paragraph nil "  Two spaces\n\n \n  Two spaces"))
3135     '(paragraph nil "Two spaces\n\n \nTwo spaces")))
3136   (should
3137    (equal
3138     '(paragraph nil " Two spaces\n" (verbatim nil "V") "\n Two spaces")
3139     (org-element-normalize-contents
3140      '(paragraph nil "  Two spaces\n " (verbatim nil "V") "\n  Two spaces"))))
3141   (should
3142    (equal
3143     '(verse-block nil "line 1\n\nline 2")
3144     (org-element-normalize-contents
3145      '(verse-block nil "  line 1\n\n  line 2"))))
3146   ;; Recursively enter objects in order to compute common indentation.
3147   (should
3148    (equal
3149     (org-element-normalize-contents
3150      '(paragraph nil "  Two spaces " (bold nil " and\n One space")))
3151     '(paragraph nil " Two spaces " (bold nil " and\nOne space"))))
3152   ;; When optional argument is provided, ignore first line
3153   ;; indentation.
3154   (should
3155    (equal
3156     (org-element-normalize-contents
3157      '(paragraph nil "No space\n  Two spaces\n   Three spaces") t)
3158     '(paragraph nil "No space\nTwo spaces\n Three spaces")))
3159   (should
3160    (equal
3161     (org-element-normalize-contents
3162      '(paragraph nil (verbatim nil "V") "No space\n  Two\n   Three") t)
3163     '(paragraph nil (verbatim nil "V") "No space\nTwo\n Three")))
3164   ;; Corner case: do not ignore indentation of string right after
3165   ;; a line break.
3166   (should
3167    (equal
3168     (org-element-normalize-contents
3169      '(paragraph nil " 1 space" (line-break) "  2 spaces"))
3170     '(paragraph nil "1 space" (line-break) " 2 spaces"))))
3171
3172
3173 \f
3174 ;;; Test Navigation Tools.
3175
3176 (ert-deftest test-org-element/at-point ()
3177   "Test `org-element-at-point' specifications."
3178   ;; Return closest element containing point.
3179   (should
3180    (eq 'paragraph
3181        (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3182          (progn (search-forward "A")
3183                 (org-element-type (org-element-at-point))))))
3184   ;; Correctly set `:parent' property.
3185   (should
3186    (eq 'center-block
3187        (org-test-with-temp-text "#+BEGIN_CENTER\nA\n#+END_CENTER"
3188          (progn (search-forward "A")
3189                 (org-element-type
3190                  (org-element-property :parent (org-element-at-point)))))))
3191   ;; Special case: at a blank line just below a headline, return that
3192   ;; headline.
3193   (should
3194    (equal "H1" (org-test-with-temp-text "* H1\n  \n* H2\n"
3195                  (forward-line)
3196                  (org-element-property :title (org-element-at-point)))))
3197   ;; Special case: at the very beginning of a table, return `table'
3198   ;; object instead of `table-row'.
3199   (should
3200    (eq 'table
3201        (org-test-with-temp-text "| a | b |"
3202          (org-element-type (org-element-at-point)))))
3203   ;; Special case: at the very beginning of a list or sub-list, return
3204   ;; `plain-list' object instead of `item'.
3205   (should
3206    (eq 'plain-list
3207        (org-test-with-temp-text "- item"
3208          (org-element-type (org-element-at-point)))))
3209   ;; Special case: at the closing line of a greater element, be sure
3210   ;; to return it instead of the last element in its contents.
3211   (should
3212    (eq 'center-block
3213        (org-test-with-temp-text "#+BEGIN_CENTER\nParagraph\n#+END_CENTER"
3214          (progn (forward-line 2)
3215                 (org-element-type (org-element-at-point))))))
3216   ;; Special case: at a blank line between two items, be sure to
3217   ;; return item above instead of the last element of its contents.
3218   (should
3219    (eq 'item
3220        (org-test-with-temp-text "- Para1\n\n- Para2"
3221          (progn (forward-line)
3222                 (org-element-type
3223                  (let ((org-list-empty-line-terminates-plain-lists nil))
3224                    (org-element-at-point)))))))
3225   ;; Special case: at the last blank line in a plain list, return it
3226   ;; instead of the last item.
3227   (should
3228    (eq 'plain-list
3229        (org-test-with-temp-text "- Para1\n- Para2\n\nPara3"
3230          (progn (forward-line 2)
3231                 (org-element-type (org-element-at-point))))))
3232   ;; Special case: when a list ends at the end of buffer and there's
3233   ;; no final newline, return last element in last item.
3234   (should
3235    (eq 'paragraph
3236        (org-test-with-temp-text "- a"
3237          (end-of-line)
3238          (org-element-type (org-element-at-point)))))
3239   ;; Parse a list within a block itself contained in a list.
3240   (should
3241    (eq 'plain-list
3242        (org-test-with-temp-text
3243            "- outer\n  #+begin_center\n  - inner\n  #+end_center"
3244          (search-forward "inner")
3245          (beginning-of-line)
3246          (org-element-type (org-element-at-point)))))
3247   ;; Do not error at eob on an empty line.
3248   (should
3249    (org-test-with-temp-text "* H\n"
3250      (forward-line)
3251      (or (org-element-at-point) t))))
3252
3253 (ert-deftest test-org-element/context ()
3254   "Test `org-element-context' specifications."
3255   ;; Return closest object containing point.
3256   (should
3257    (eq 'underline
3258        (org-test-with-temp-text "Some *text with _underline_ text*"
3259          (progn (search-forward "under")
3260                 (org-element-type (org-element-context))))))
3261   ;; Find objects in secondary strings.
3262   (should
3263    (eq 'underline
3264        (org-test-with-temp-text "* Headline _with_ underlining"
3265          (progn (search-forward "w")
3266                 (org-element-type (org-element-context))))))
3267   ;; Find objects in objects.
3268   (should
3269    (eq 'macro
3270        (org-test-with-temp-text "| a | {{{macro}}} |"
3271          (progn (search-forward "{")
3272                 (org-element-type (org-element-context))))))
3273   (should
3274    (eq 'table-cell
3275        (org-test-with-temp-text "| a | b {{{macro}}} |"
3276          (progn (search-forward "b")
3277                 (org-element-type (org-element-context))))))
3278   ;; Find objects in planning lines.
3279   (should
3280    (eq 'timestamp
3281        (org-test-with-temp-text "* H\n  SCHEDULED: <2012-03-29 thu.>"
3282          (search-forward "2012")
3283          (org-element-type (org-element-context)))))
3284   (should-not
3285    (eq 'timestamp
3286        (org-test-with-temp-text "* H\n  SCHEDULED: <2012-03-29 thu.>"
3287          (search-forward "SCHEDULED")
3288          (org-element-type (org-element-context)))))
3289   ;; Do not find objects in table rules.
3290   (should
3291    (eq 'table-row
3292        (org-test-with-temp-text "| a | b |\n+---+---+\n| c | d |"
3293          (forward-line)
3294          (org-element-type (org-element-context)))))
3295   ;; Find objects in parsed affiliated keywords.
3296   (should
3297    (eq 'macro
3298        (org-test-with-temp-text "#+CAPTION: {{{macro}}}\n| a | b |."
3299          (progn (search-forward "{")
3300                 (org-element-type (org-element-context))))))
3301   (should
3302    (eq 'bold
3303        (org-test-with-temp-text "#+caption: *bold*\nParagraph"
3304          (progn (search-forward "*")
3305                 (org-element-type (org-element-context))))))
3306   ;; Find objects at the end of buffer.
3307   (should
3308    (eq 'bold
3309        (org-test-with-temp-text "*bold*"
3310          (goto-char (point-max))
3311          (org-element-type (org-element-context)))))
3312   ;; Correctly set `:parent' property.
3313   (should
3314    (eq 'paragraph
3315        (org-test-with-temp-text "Some *bold* text"
3316          (progn (search-forward "bold")
3317                 (org-element-type
3318                  (org-element-property :parent (org-element-context)))))))
3319   ;; Between two objects, return the second one.
3320   (should
3321    (eq 'macro
3322        (org-test-with-temp-text "<<target>>{{{test}}}"
3323          (progn (search-forward "{")
3324                 (backward-char)
3325                 (org-element-type (org-element-context))))))
3326   ;; Test optional argument.
3327   (should
3328    (eq 'underline
3329        (org-test-with-temp-text "Some *text with _underline_ text*"
3330          (progn
3331            (search-forward "under")
3332            (org-element-type (org-element-context (org-element-at-point)))))))
3333   ;; Special case: bold object at the beginning of a headline.
3334   (should
3335    (eq 'bold
3336        (org-test-with-temp-text "* *bold*"
3337          (search-forward "bo")
3338          (org-element-type (org-element-context)))))
3339   ;; Special case: incomplete cell at the end of a table row.
3340   (should
3341    (eq 'table-cell
3342        (org-test-with-temp-text "|a|b|c"
3343          (goto-char (point-max))
3344          (org-element-type (org-element-context)))))
3345   ;; Special case: objects in inline footnotes.
3346   (should
3347    (eq 'link
3348        (org-test-with-temp-text "[fn::[[<point>http://orgmode.org]]]"
3349          (org-element-type (org-element-context))))))
3350
3351
3352 \f
3353 ;;; Test Tools
3354
3355 (ert-deftest test-org-element/lineage ()
3356   "Test `org-element-lineage' specifications."
3357   ;; Regular tests.  When applied to an element or object returned by
3358   ;; `org-element-at-point' or `org-element-context', the list is
3359   ;; limited to the current section.
3360   (should
3361    (equal '(paragraph center-block)
3362           (org-test-with-temp-text
3363               "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3364             (mapcar #'car (org-element-lineage (org-element-context))))))
3365   (should
3366    (equal '(paragraph center-block section headline headline org-data)
3367           (org-test-with-temp-text
3368               "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3369             (mapcar #'car
3370                     (org-element-lineage
3371                      (org-element-map (org-element-parse-buffer) 'bold
3372                        #'identity nil t))))))
3373   ;; Test TYPES optional argument.
3374   (should
3375    (eq 'center-block
3376        (org-test-with-temp-text
3377            "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3378          (org-element-type
3379           (org-element-lineage (org-element-context) '(center-block))))))
3380   (should-not
3381    (org-test-with-temp-text
3382        "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3383      (org-element-lineage (org-element-context) '(example-block))))
3384   ;; Test WITH-SELF optional argument.
3385   (should
3386    (equal '(bold paragraph center-block)
3387           (org-test-with-temp-text
3388               "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3389             (mapcar #'car (org-element-lineage (org-element-context) nil t)))))
3390   ;; When TYPES and WITH-SELF are provided, the latter is also checked
3391   ;; against the former.
3392   (should
3393    (org-test-with-temp-text
3394        "* H1\n** H2\n#+BEGIN_CENTER\n*bold<point>*\n#+END_CENTER"
3395      (org-element-lineage (org-element-context) '(bold) t))))
3396
3397
3398 \f
3399 ;;; Test Cache.
3400
3401 (ert-deftest test-org-element/cache ()
3402   "Test basic expectations and common pitfalls for cache."
3403   ;; Shift positions.
3404   (should
3405    (equal '(18 . 23)
3406           (org-test-with-temp-text "para1\n\npara2\n\npara3"
3407             (let ((org-element-use-cache t))
3408               (save-excursion (goto-char (point-max)) (org-element-at-point))
3409               (insert "add")
3410               (forward-line 4)
3411               (let ((element (org-element-at-point)))
3412                 (cons (org-element-property :begin element)
3413                       (org-element-property :end element)))))))
3414   ;; Partial shifting: when the contents of a greater element are
3415   ;; modified, only shift ending positions.
3416   (should
3417    (org-test-with-temp-text
3418        "#+BEGIN_CENTER\nPara1\n\nPara2\n\nPara3\n#+END_CENTER"
3419      (let ((org-element-use-cache t))
3420        (save-excursion (search-forward "3") (org-element-at-point))
3421        (search-forward "Para2")
3422        (insert " ")
3423        (let ((element (org-element-property :parent (org-element-at-point))))
3424          (equal (cons (org-element-property :begin element)
3425                       (org-element-property :end element))
3426                 (cons (point-min) (point-max)))))))
3427   ;; Re-parent shifted elements.
3428   (should
3429    (eq 'item
3430        (org-test-with-temp-text "- item\n\n\n  para1\n  para2"
3431          (let ((org-element-use-cache t))
3432            (end-of-line)
3433            (org-element-at-point)
3434            (save-excursion (goto-char (point-max)) (org-element-at-point))
3435            (forward-line)
3436            (delete-char 1)
3437            (goto-char (point-max))
3438            (org-element-type
3439             (org-element-property :parent (org-element-at-point)))))))
3440   ;; Preserve local structures when re-parenting.
3441   (should
3442    (eq 'table
3443        (org-test-with-temp-text
3444            "#+begin_center\nP0\n\n<point>\n\n  P1\n  | a | b |\n| c | d |\n#+end_center"
3445          (let ((org-element-use-cache t))
3446            (save-excursion (search-forward "| c |") (org-element-at-point))
3447            (insert "- item")
3448            (search-forward "| c |")
3449            (beginning-of-line)
3450            (org-element-type
3451             (org-element-property :parent (org-element-at-point)))))))
3452   (should-not
3453    (eq 'center-block
3454        (org-test-with-temp-text
3455            "#+begin_center\nP0\n\n<point>\n\n  P1\n  | a | b |\n#+end_center"
3456          (let ((org-element-use-cache t))
3457            (save-excursion (search-forward "| a |") (org-element-at-point))
3458            (insert "- item")
3459            (search-forward "| a |")
3460            (beginning-of-line)
3461            (org-element-type
3462             (org-element-property :parent (org-element-at-point)))))))
3463   ;; When re-parenting, also propagate changes to list structures.
3464   (should
3465    (= 2
3466       (org-test-with-temp-text "\n  Para\n  - item<point>"
3467         (let ((org-element-use-cache t))
3468           (org-element-at-point)
3469           (goto-char (point-min))
3470           (insert "- Top\n")
3471           (search-forward "- item")
3472           (beginning-of-line)
3473           (length (org-element-property :structure (org-element-at-point)))))))
3474   ;; Modifying the last line of an element alters the element below.
3475   (should
3476    (org-test-with-temp-text "para1\n\npara2"
3477      (let ((org-element-use-cache t))
3478        (goto-char (point-max))
3479        (org-element-at-point)
3480        (forward-line -1)
3481        (insert "merge")
3482        (let ((element (org-element-at-point)))
3483          (equal (cons (org-element-property :begin element)
3484                       (org-element-property :end element))
3485                 (cons (point-min) (point-max)))))))
3486   ;; Modifying the first line of an element alters the element above.
3487   (should
3488    (org-test-with-temp-text ": fixed-width\n:not-fixed-width"
3489      (let ((org-element-use-cache t))
3490        (goto-char (point-max))
3491        (org-element-at-point)
3492        (search-backward ":")
3493        (forward-char)
3494        (insert " ")
3495        (let ((element (org-element-at-point)))
3496          (equal (cons (org-element-property :begin element)
3497                       (org-element-property :end element))
3498                 (cons (point-min) (point-max)))))))
3499   ;; Sensitive change: adding a line alters document structure both
3500   ;; above and below.
3501   (should
3502    (eq 'example-block
3503        (org-test-with-temp-text "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n"
3504          (let ((org-element-use-cache t))
3505            (goto-char (point-max))
3506            (org-element-at-point)
3507            (insert "#+END_EXAMPLE")
3508            (search-backward "Para1")
3509            (org-element-type (org-element-at-point))))))
3510   (should
3511    (eq 'example-block
3512        (org-test-with-temp-text "Para1\n\nPara2\n#+END_EXAMPLE"
3513          (let ((org-element-use-cache t))
3514            (save-excursion (goto-char (point-max)) (org-element-at-point))
3515            (insert "#+BEGIN_EXAMPLE\n")
3516            (search-forward "Para2")
3517            (org-element-type (org-element-at-point))))))
3518   ;; Sensitive change: removing a line alters document structure both
3519   ;; above and below.
3520   (should
3521    (eq 'example-block
3522        (org-test-with-temp-text
3523            "# +BEGIN_EXAMPLE\nPara1\n\nPara2\n#+END_EXAMPLE"
3524          (let ((org-element-use-cache t))
3525            (save-excursion (goto-char (point-max)) (org-element-at-point))
3526            (forward-char)
3527            (delete-char 1)
3528            (search-forward "Para2")
3529            (org-element-type (org-element-at-point))))))
3530   (should
3531    (eq 'example-block
3532        (org-test-with-temp-text
3533            "#+BEGIN_EXAMPLE\nPara1\n\nPara2\n# +END_EXAMPLE"
3534          (let ((org-element-use-cache t))
3535            (save-excursion (goto-char (point-max)) (org-element-at-point))
3536            (search-forward "# ")
3537            (delete-char -1)
3538            (search-backward "Para1")
3539            (org-element-type (org-element-at-point))))))
3540   ;; Corner case: watch out drawers named "PROPERTIES" as they are
3541   ;; fragile, unlike to other drawers.
3542   (should
3543    (eq 'node-property
3544        (org-test-with-temp-text "* H\n:PROPERTIES:\n:A: 1\n:A<point>\n:END:"
3545          (let ((org-element-use-cache t))
3546            (org-element-at-point)
3547            (insert "+:")
3548            (org-element-type (org-element-at-point)))))))
3549
3550
3551 (provide 'test-org-element)
3552
3553 ;;; test-org-element.el ends here