testing/lisp/test-org-element.el

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