testing/lisp/test-org-element.el

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