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