testing/lisp/test-ob.el

   1 ;;; test-ob.el --- tests for ob.el
   2
   3 ;; Copyright (c) 2010-2015 Eric Schulte
   4 ;; Authors: Eric Schulte, Martyn Jago
   5
   6 ;; This file is not part of GNU Emacs.
   7
   8 ;; This program is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation, either version 3 of the License, or
  11 ;; (at your option) any later version.
  12
  13 ;; This program is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 ;;; Code:
  22
  23 (ert-deftest test-ob/indented-cached-org-bracket-link ()
  24   "When the result of a source block is a cached indented link it
  25 should still return the link."
  26   (should
  27    (let ((default-directory temporary-file-directory))
  28      (org-test-with-temp-text
  29          "
  30 * Test
  31   #+<point>BEGIN_SRC emacs-lisp :file test.txt :cache yes
  32     (message \"test\")
  33   #+END_SRC"
  34        ;; Execute twice as the first time creates the cache.
  35        (org-babel-execute-src-block)
  36        (string= (expand-file-name "test.txt")
  37                 (org-babel-execute-src-block))))))
  38
  39 (ert-deftest test-ob/multi-line-header-regexp ()
  40   (should(equal "^[ \t]*#\\+headers?:[ \t]*\\([^\n]*\\)$"
  41                 org-babel-multi-line-header-regexp))
  42   ;;TODO can be optimised - and what about blah4 blah5 blah6?
  43   (should (string-match
  44            org-babel-multi-line-header-regexp
  45            "   \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))
  46   (should
  47    (equal
  48     "blah1 blah2 blah3 \t"
  49     (match-string
  50      1
  51      "   \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n")))
  52
  53   ;;TODO Check - should this fail?
  54   (should
  55    (not (org-test-string-exact-match
  56          org-babel-multi-line-header-regexp
  57          "   \t #+headers : blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))))
  58
  59 (ert-deftest test-ob/src-block-regexp ()
  60   (let ((test-block
  61          (concat
  62           "#+begin_src language -n-r-a-b -c :argument-1 yes :argument-2 no\n"
  63           "echo this is a test\n"
  64           "echo Currently in ' $PWD\n"
  65           "#+end_src"))
  66         (language "language")
  67         (flags "-n-r-a-b -c ")
  68         (arguments ":argument-1 yes :argument-2 no")
  69         (body "echo this is a test\necho Currently in ' $PWD\n"))
  70     (should (string-match org-babel-src-block-regexp test-block))
  71     (should (string-match org-babel-src-block-regexp (upcase test-block)))
  72     (should (equal language (match-string 2 test-block)))
  73     ;;TODO Consider refactoring
  74     (should (equal flags (match-string 3 test-block)))
  75     (should (equal arguments (match-string 4 test-block)))
  76     (should (equal body (match-string 5 test-block)))
  77     ;;no switches
  78     (should (org-test-string-exact-match
  79              org-babel-src-block-regexp
  80              (replace-regexp-in-string flags "" test-block)))
  81     ;;no header arguments
  82     (should (org-test-string-exact-match
  83              org-babel-src-block-regexp
  84              (replace-regexp-in-string arguments "" test-block)))
  85     ;; should be valid with no body
  86     (should (org-test-string-exact-match
  87              org-babel-src-block-regexp
  88              (replace-regexp-in-string body "" test-block)))))
  89
  90 (ert-deftest test-ob/default-inline-header-args ()
  91   (should(equal
  92           '((:session . "none")
  93             (:results . "replace")
  94             (:exports . "results")
  95             (:hlines  . "yes"))
  96           org-babel-default-inline-header-args)))
  97
  98 (ert-deftest ob-test/org-babel-combine-header-arg-lists ()
  99   (let ((results (org-babel-combine-header-arg-lists
 100                   '((foo  . :any)
 101                     (bar)
 102                     (baz  . ((foo bar) (baz)))
 103                     (qux  . ((foo bar baz qux)))
 104                     (quux . ((foo bar))))
 105                   '((bar)
 106                     (baz  . ((baz)))
 107                     (quux . :any)))))
 108     (dolist (pair '((foo  . :any)
 109                     (bar)
 110                     (baz  . ((baz)))
 111                     (quux . :any)
 112                     (qux  . ((foo bar baz qux)))))
 113       (should (equal (cdr pair)
 114                      (cdr (assoc (car pair) results)))))))
 115
 116 ;;; ob-get-src-block-info
 117 (ert-deftest test-ob/get-src-block-info-language ()
 118   (org-test-at-marker nil org-test-file-ob-anchor
 119     (let ((info (org-babel-get-src-block-info)))
 120       (should (string= "emacs-lisp" (nth 0 info))))))
 121
 122 (ert-deftest test-ob/get-src-block-info-body ()
 123   (org-test-at-marker nil org-test-file-ob-anchor
 124     (let ((info (org-babel-get-src-block-info)))
 125       (should (string-match (regexp-quote org-test-file-ob-anchor)
 126                             (nth 1 info))))))
 127
 128 (ert-deftest test-ob/get-src-block-info-tangle ()
 129   (org-test-at-marker nil org-test-file-ob-anchor
 130     (let ((info (org-babel-get-src-block-info)))
 131       (should (string= "no" (cdr (assq :tangle (nth 2 info))))))))
 132
 133 (ert-deftest test-ob/elisp-in-header-arguments ()
 134   "Test execution of elisp forms in header arguments."
 135   (org-test-with-temp-text-in-file "
 136
 137 * elisp forms in header arguments
 138   :PROPERTIES:
 139   :header-args: :var prop = (* 7 6)
 140   :END:
 141 #+begin_src emacs-lisp
 142   prop
 143 #+end_src"
 144     (goto-char (point-min))
 145     (org-babel-next-src-block)
 146     (should (= 42 (org-babel-execute-src-block)))))
 147
 148 (ert-deftest test-ob/simple-named-code-block ()
 149   "Test that simple named code blocks can be evaluated."
 150   (org-test-with-temp-text-in-file "
 151
 152 #+name: i-have-a-name
 153 #+begin_src emacs-lisp
 154   42
 155 #+end_src"
 156     (org-babel-next-src-block 1)
 157     (should (= 42 (org-babel-execute-src-block)))))
 158
 159 (ert-deftest test-ob/simple-variable-resolution ()
 160   "Test that simple variable resolution is working."
 161   (org-test-with-temp-text-in-file "
 162
 163 #+name: four
 164 #+begin_src emacs-lisp
 165   (list 1 2 3 4)
 166 #+end_src
 167
 168 #+begin_src emacs-lisp :var four=four
 169   (length four)
 170 #+end_src"
 171
 172     (org-babel-next-src-block 2)
 173     (should (= 4 (org-babel-execute-src-block)))
 174     (forward-line 5)
 175     (should (string= ": 4" (buffer-substring
 176                             (point-at-bol)
 177                             (point-at-eol))))))
 178
 179 (ert-deftest test-ob/multi-line-header-arguments ()
 180   "Test that multi-line header arguments and can be read."
 181   (org-test-with-temp-text-in-file "
 182
 183 #+headers: :var letters='(a b c d e f g)
 184 #+begin_src emacs-lisp :var numbers='(1 2 3 4 5 6 7)
 185   (require 'cl-lib)
 186   (cl-map 'list #'list numbers letters)
 187 #+end_src"
 188     (org-babel-next-src-block)
 189     (let ((results (org-babel-execute-src-block)))
 190       (should (eq 'a (cadr (assoc 1 results))))
 191       (should (eq 'd (cadr (assoc 4 results)))))))
 192
 193 (ert-deftest test-ob/parse-header-args ()
 194   (org-test-with-temp-text-in-file "
 195
 196 #+begin_src example-lang :session     :results output :var num=9
 197   the body
 198 #+end_src"
 199
 200     (org-babel-next-src-block)
 201     (let* ((info (org-babel-get-src-block-info))
 202            (params (nth 2 info)))
 203       (message "%S" params)
 204       (should (equal "example-lang" (nth 0 info)))
 205       (should (string= "the body" (org-trim (nth 1 info))))
 206       (should-not (member '(:session\ \ \ \ ) params))
 207       (should (equal '(:session) (assq :session params)))
 208       (should (equal '(:result-type . output) (assq :result-type params)))
 209       (should (equal '(num . 9) (cdr (assq :var params)))))))
 210
 211 (ert-deftest test-ob/parse-header-args2 ()
 212   (org-test-with-temp-text-in-file "
 213
 214 * resolving sub-trees as references
 215
 216 #+begin_src emacs-lisp :var text=d4faa7b3-072b-4dcf-813c-dd7141c633f3
 217   (length text)
 218 #+end_src
 219
 220 #+begin_src org :noweb yes
 221   <<simple-subtree>>
 222   <<d4faa7b3-072b-4dcf-813c-dd7141c633f3>>
 223 #+end_src
 224
 225 ** simple subtree with custom ID
 226    :PROPERTIES:
 227    :CUSTOM_ID: simple-subtree
 228    :END:
 229 this is simple"
 230
 231     (should (string-match (regexp-quote "this is simple")
 232                           (org-babel-ref-resolve "simple-subtree")))
 233     (org-babel-next-src-block)
 234     (should (= 14 (org-babel-execute-src-block)))))
 235
 236 (ert-deftest test-ob/inline-src-blocks ()
 237   (should
 238    (= 1
 239       (org-test-with-temp-text
 240           "In the middle <point>src_emacs-lisp{(+ 0 1)} of a line"
 241         (org-babel-execute-src-block))))
 242   (should
 243    (= 2
 244       (org-test-with-temp-text
 245           "One at the end of a line: <point>src_emacs-lisp{(+ 1 1)}"
 246         (org-babel-execute-src-block))))
 247   (should
 248    (= 3
 249       (org-test-with-temp-text
 250           "src_emacs-lisp{(+ 2 1)} at the beginning of a line."
 251         (org-babel-execute-src-block))))
 252   (should
 253    (= 4
 254       (org-test-with-temp-text
 255           "In the middle <point>src_emacs-lisp[:results silent\
 256  :exports code]{(+ 3 1)} of a line"
 257         (org-babel-execute-src-block))))
 258   (should
 259    (= 5
 260       (org-test-with-temp-text
 261           "One at the end of a line: <point>src_emacs-lisp[:results silent\
 262  :exports code]{(+ 4 1)}"
 263         (org-babel-execute-src-block))))
 264   (should
 265    (= 6
 266       (org-test-with-temp-text
 267           "src_emacs-lisp[:results silent :exports code]{(+ 5 1)}\
 268 at the beginning of a line."
 269         (org-babel-execute-src-block))))
 270   (should
 271    (= 7
 272       (org-test-with-temp-text
 273           "One also evaluated: <point>src_emacs-lisp[:exports both\
 274  :results silent]{(+ 6 1)}"
 275         (org-babel-execute-src-block)))))
 276
 277 (ert-deftest test-ob/inline-src_blk-default-results-replace-line-1 ()
 278   (let ((test-line "src_sh{echo 1}")
 279         (org-babel-inline-result-wrap "=%s="))
 280     ;; src_ at bol line 1...
 281     (org-test-with-temp-text
 282         test-line
 283       (goto-char (point-min)) (org-babel-execute-maybe)
 284       (should (string=
 285                       (concat test-line " {{{results(=1=)}}}")
 286                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 287       (forward-char) (org-babel-execute-maybe)
 288       (should (string=
 289                       (concat test-line " {{{results(=1=)}}}")
 290                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 291       (re-search-forward "{{{")
 292      ;;(should-error (org-ctrl-c-ctrl-c))
 293       (backward-char 4) ;; last char of block body
 294       (org-babel-execute-maybe)
 295       (should (string=
 296                       (concat test-line " {{{results(=1=)}}}")
 297                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 298     ;; src_ follows space line 1...
 299     (let ((test-line " src_emacs-lisp{ 1 }"))
 300       (org-test-with-temp-text
 301           test-line
 302         (should-error (org-ctrl-c-ctrl-c))
 303         (forward-char) (org-babel-execute-maybe)
 304         (should (string=
 305                  (concat test-line " {{{results(=1=)}}}")
 306                  (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 307         (re-search-forward "{ 1 ") (org-babel-execute-maybe)
 308         (should (string=
 309                  (concat test-line " {{{results(=1=)}}}")
 310                  (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 311         (forward-char 6)
 312         (should-error (org-ctrl-c-ctrl-c))))
 313     ;; Results on a subsequent line are replaced.
 314     (should
 315      (equal
 316       "src_emacs-lisp{(+ 1 2)}\n  {{{results(=3=)}}}"
 317       (org-test-with-temp-text "src_emacs-lisp{(+ 1 2)}\n  {{{results(=2=)}}}"
 318         (let ((org-babel-inline-result-wrap "=%s=")) (org-babel-execute-maybe))
 319         (buffer-string))))
 320     ;; Also handle results at the beginning of a line.
 321     (should
 322      (equal
 323       "src_emacs-lisp{(+ 1 2)}\n{{{results(=3=)}}}"
 324       (org-test-with-temp-text "src_emacs-lisp{(+ 1 2)}\n{{{results(=2=)}}}"
 325         (let ((org-babel-inline-result-wrap "=%s=")) (org-babel-execute-maybe))
 326         (buffer-string))))))
 327
 328 (ert-deftest test-ob/inline-src_blk-default-results-replace-line-2 ()
 329   ;; src_ at bol line 2...
 330   (let ((test-line " src_emacs-lisp{ \"x\" }")
 331         (org-babel-inline-result-wrap "=%s="))
 332     (org-test-with-temp-text
 333         (concat "\n" test-line)
 334       (should-error (org-ctrl-c-ctrl-c))
 335       (goto-char (point-min))
 336       (should-error (org-ctrl-c-ctrl-c))
 337       (forward-line)
 338       (should-error (org-ctrl-c-ctrl-c))
 339       (forward-char) (org-babel-execute-maybe)
 340       (should (string=
 341                (concat test-line " {{{results(=x=)}}}")
 342                (buffer-substring-no-properties
 343                 (point-at-bol) (point-at-eol))))))
 344   (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }")
 345         (org-babel-inline-result-wrap "=%s="))
 346     (org-test-with-temp-text
 347         test-line
 348       (goto-char (point-max))
 349       (insert (concat "\n" test-line " end"))
 350       (re-search-backward "src") (org-babel-execute-maybe)
 351       (should (string=
 352                (concat test-line " {{{results(=y=)}}} end")
 353                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 354       (re-search-forward "\" ") (org-babel-execute-maybe)
 355       (should (string=
 356                (concat test-line " {{{results(=y=)}}} end")
 357                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 358       (forward-char 3)
 359       (should-error (org-ctrl-c-ctrl-c)))))
 360
 361 (ert-deftest test-ob/inline-src_blk-manual-results-replace ()
 362   (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }")
 363         (org-babel-inline-result-wrap "=%s="))
 364     (org-test-with-temp-text
 365         (concat "\n" test-line)
 366       (should-error (org-ctrl-c-ctrl-c))
 367       (goto-char (point-max))
 368       (org-babel-execute-maybe)
 369       (beginning-of-line)
 370       (should-error (org-ctrl-c-ctrl-c))
 371       (forward-char) (org-babel-execute-maybe)
 372       (should (string=
 373               (concat test-line " {{{results(=x=)}}}")
 374                (buffer-substring-no-properties
 375                 (point-at-bol) (point-at-eol))))))
 376   (let ((test-line (concat " Some text prior to block "
 377                            "src_emacs-lisp[:results replace]{ \"y\" }"))
 378         (org-babel-inline-result-wrap "=%s="))
 379     (org-test-with-temp-text test-line
 380       (goto-char (point-max))
 381       (insert (concat "\n" test-line " end"))
 382       (re-search-backward "src") (org-babel-execute-maybe)
 383       (should (string=
 384               (concat test-line " {{{results(=y=)}}} end")
 385                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 386       (re-search-forward "\" ") (org-babel-execute-maybe)
 387       (should (string=
 388               (concat test-line " {{{results(=y=)}}} end")
 389                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 390       (forward-char 3)
 391       (should-error (org-ctrl-c-ctrl-c)))))
 392
 393 (ert-deftest test-ob/inline-src_blk-results-silent ()
 394   (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
 395     (org-test-with-temp-text test-line
 396       (org-babel-execute-maybe)
 397       (should (string= test-line
 398                        (buffer-substring-no-properties
 399                         (point-at-bol) (point-at-eol))))))
 400   (let ((test-line (concat " Some text prior to block src_emacs-lisp"
 401                            "[ :results silent ]{ \"y\" }")))
 402     (org-test-with-temp-text
 403         test-line
 404       (goto-char (point-max))
 405       (insert (concat "\n" test-line " end"))
 406       (re-search-backward "src_") (org-babel-execute-maybe)
 407       (should (string= (concat test-line " end")
 408                        (buffer-substring-no-properties
 409                         (point-at-bol) (point-at-eol))))
 410       (re-search-forward "\" ") (org-babel-execute-maybe)
 411       (should (string= (concat test-line " end")
 412                        (buffer-substring-no-properties
 413                         (point-at-bol) (point-at-eol))))
 414       (forward-char 2)
 415       (should-error (org-ctrl-c-ctrl-c)))))
 416
 417 (ert-deftest test-ob/inline-src_blk-results-raw ()
 418   (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
 419     (org-test-with-temp-text test-line
 420       (org-babel-execute-maybe)
 421       (should (string= (concat test-line " x")
 422                        (buffer-string)))))
 423   (let ((test-line (concat " Some text prior to block "
 424                            "src_emacs-lisp[ :results raw ]{ \"the\" }")))
 425     (org-test-with-temp-text (concat test-line " end")
 426       (re-search-forward "src_") (org-babel-execute-maybe)
 427       (should (string= (concat test-line " the end")
 428                        (buffer-substring-no-properties
 429                         (point-at-bol) (point-at-eol))))
 430       (re-search-forward "\" ") (org-babel-execute-maybe)
 431       (should (string= (concat test-line " the the end")
 432                        (buffer-substring-no-properties
 433                         (point-at-bol) (point-at-eol))))
 434       (forward-char 2)
 435       (should-error (org-ctrl-c-ctrl-c)))))
 436
 437 (ert-deftest test-ob/inline-src_blk-results-file ()
 438   (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\"  }"))
 439     (org-test-with-temp-text
 440         test-line
 441       (org-babel-execute-maybe)
 442       (should (string= (concat test-line " {{{results([[file:~/test-file]])}}}")
 443                        (buffer-substring-no-properties
 444                         (point-min) (point-max)))))))
 445
 446 (ert-deftest test-ob/inline-src_blk-results-scalar ()
 447   (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\"  }")
 448         (org-babel-inline-result-wrap "=%s="))
 449     (org-test-with-temp-text
 450         test-line
 451       (org-babel-execute-maybe)
 452       (should (string= (concat test-line  " {{{results(=\"x\"=)}}}")
 453                        (buffer-substring-no-properties
 454                         (point-min) (point-max)))))))
 455
 456 (ert-deftest test-ob/inline-src_blk-results-verbatim ()
 457   (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\"  }")
 458         (org-babel-inline-result-wrap "=%s="))
 459     (org-test-with-temp-text
 460         test-line
 461       (org-babel-execute-maybe)
 462       (should (string= (concat test-line " {{{results(=\"x\"=)}}}")
 463                        (buffer-substring-no-properties
 464                         (point-min) (point-max)))))))
 465
 466 (ert-deftest test-ob/combining-scalar-and-raw-result-types ()
 467   (org-test-with-temp-text-in-file "
 468
 469 #+begin_src sh :results scalar
 470 echo \"[[file:./cv.cls]]\"
 471 #+end_src
 472
 473 #+name:
 474 : [[file:./cv.cls]]
 475
 476 #+begin_src sh :results raw scalar
 477    echo \"[[file:./cv.cls]]\"
 478 #+end_src
 479 "
 480     (cl-flet ((next-result ()
 481                            (org-babel-next-src-block)
 482                            (org-babel-execute-src-block)
 483                            (goto-char (org-babel-where-is-src-block-result))
 484                            (forward-line 1)))
 485       (goto-char (point-min))
 486       (next-result)
 487       (should (eq (org-element-type (org-element-at-point)) 'fixed-width))
 488       (next-result)
 489       (should-not
 490        (eq (org-element-type (org-element-at-point)) 'fixed-width)))))
 491
 492 (ert-deftest test-ob/no-defaut-value-for-var ()
 493   "Test that the absence of a default value for a variable DOES THROW
 494   a proper error."
 495   (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
 496     (org-babel-next-src-block)
 497     (let ((err
 498            (should-error (org-babel-execute-src-block) :type 'error)))
 499       (should
 500        (equal
 501         '(error
 502           "Variable \"x\" must be assigned a default value")
 503         err)))))
 504
 505 (ert-deftest test-ob/just-one-results-block ()
 506   "Test that evaluating two times the same code block does not result in a
 507 duplicate results block."
 508   (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
 509     (org-babel-execute-src-block)
 510     (org-babel-execute-src-block)     ; second code block execution
 511     (should (search-forward "Hello")) ; the string inside the source code block
 512     (should (search-forward "Hello")) ; the same string in the results block
 513     (should-error (search-forward "Hello"))))
 514
 515 (ert-deftest test-ob/nested-code-block ()
 516   "Test nested code blocks inside code blocks don't cause problems."
 517   (should
 518    (string= "#+begin_src emacs-lisp\n  'foo\n#+end_src"
 519             (org-test-with-temp-text "#+begin_src org :results silent
 520   ,#+begin_src emacs-lisp
 521     'foo
 522   ,#+end_src
 523 #+end_src"
 524               (let ((org-edit-src-content-indentation 2)
 525                     (org-src-preserve-indentation nil))
 526                 (org-babel-execute-src-block))))))
 527
 528 (ert-deftest test-ob/partial-nested-code-block ()
 529   "Test nested code blocks inside code blocks don't cause problems."
 530   (org-test-with-temp-text "#+begin_src org :results silent
 531   ,#+begin_src emacs-lisp
 532 #+end_src"
 533     (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
 534
 535 (ert-deftest test-ob/does-not-replace-a-block-with-the-results ()
 536   (org-test-with-temp-text "#+NAME: foo
 537 #+BEGIN_SRC emacs-lisp
 538  'foo
 539 #+END_SRC\n"
 540     (org-babel-next-src-block 1)
 541     (should (eq 'foo (org-babel-execute-src-block)))
 542     (goto-char (point-min))
 543     (org-babel-next-src-block 1)
 544     (should (looking-at org-babel-src-block-regexp))))
 545
 546 (ert-deftest test-ob/catches-all-references ()
 547   (org-test-with-temp-text "
 548 #+NAME: literal-example
 549 #+BEGIN_EXAMPLE
 550 A literal example
 551 on two lines
 552 #+END_EXAMPLE
 553
 554 #+NAME: read-literal-example
 555 #+BEGIN_SRC emacs-lisp :var x=literal-example
 556   (concatenate 'string x \" for me.\")
 557 #+END_SRC"
 558     (org-babel-next-src-block 1)
 559     (should (string= (org-babel-execute-src-block)
 560                      "A literal example\non two lines\n for me."))))
 561
 562 (ert-deftest test-ob/ignore-reference-in-commented-headings ()
 563   (should
 564    (= 2
 565       (org-test-with-temp-text
 566           "
 567 * COMMENT H1
 568 #+NAME: n
 569 : 1
 570
 571 * H2
 572 #+NAME: n
 573 : 2
 574
 575 * Code
 576
 577 <point>#+BEGIN_SRC emacs-lisp :var x=n
 578 x
 579 #+END_SRC"
 580         (org-babel-execute-src-block)))))
 581
 582 (ert-deftest test-ob/do-not-resolve-to-partial-names-data ()
 583   (org-test-with-temp-text "
 584 #+name: base_plus
 585 | 1 |
 586 | 2 |
 587
 588 #+name: base
 589 | 3 |
 590 | 4 |
 591
 592 #+begin_src emacs-lisp :var x=base
 593   x
 594 #+end_src"
 595     (org-babel-next-src-block 1)
 596     (should (equal (org-babel-execute-src-block) '((3) (4))))))
 597
 598 (ert-deftest test-ob/do-not-resolve-to-partial-names-code ()
 599   (org-test-with-temp-text "
 600 #+name: base_plus
 601 #+begin_src emacs-lisp
 602   'bar
 603 #+end_src
 604
 605 #+name: base
 606 #+begin_src emacs-lisp
 607   'foo
 608 #+end_src
 609
 610 #+begin_src emacs-lisp :var x=base
 611   x
 612 #+end_src"
 613     (org-babel-next-src-block 3)
 614     (should (equal (org-babel-execute-src-block) "foo"))))
 615
 616 (ert-deftest test-ob/allow-spaces-around-=-in-var-specs ()
 617   (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
 618   (+ a b c d)
 619 #+end_src
 620 "
 621     (should (= 10 (org-babel-execute-src-block)))))
 622
 623 (ert-deftest test-ob/org-babel-update-intermediate ()
 624   (org-test-with-temp-text "#+name: foo
 625 #+begin_src emacs-lisp
 626   2
 627 #+end_src
 628
 629 #+results: foo
 630 : 4
 631
 632 #+begin_src emacs-lisp :var it=foo
 633   (+ it 1)
 634 #+end_src"
 635     (let ((org-babel-update-intermediate nil))
 636       (goto-char (point-min))
 637       (org-babel-next-src-block 2)
 638       (should (= 3 (org-babel-execute-src-block)))
 639       (goto-char (point-min))
 640       (forward-line 6)
 641       (should (looking-at ": 4")))
 642     (let ((org-babel-update-intermediate t))
 643       (goto-char (point-min))
 644       (org-babel-next-src-block 2)
 645       (should (= 3 (org-babel-execute-src-block)))
 646       (goto-char (point-min))
 647       (forward-line 6)
 648       (should (looking-at ": 2")))))
 649
 650 (ert-deftest test-ob/eval-header-argument ()
 651   (cl-flet ((check-eval (eval runp)
 652                         (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
 653   (setq foo :evald)
 654 #+end_src" eval)
 655                           (let ((foo :not-run))
 656                             (if runp
 657                                 (progn (should (org-babel-execute-src-block))
 658                                        (should (eq foo :evald)))
 659                               (progn (should-not (org-babel-execute-src-block))
 660                                      (should-not (eq foo :evald))))))))
 661     (check-eval "never" nil)
 662     (check-eval "no" nil)
 663     (check-eval "never-export" t)
 664     (check-eval "no-export" t)
 665     (let ((org-babel-exp-reference-buffer (current-buffer)))
 666       (check-eval "never" nil)
 667       (check-eval "no" nil)
 668       (check-eval "never-export" nil)
 669       (check-eval "no-export" nil))))
 670
 671 (ert-deftest test-ob/noweb-expansion-1 ()
 672   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 673   <<foo>>
 674 #+end_src
 675
 676 #+name: foo
 677 #+begin_src sh
 678   bar
 679 #+end_src"
 680     (should (string= (org-babel-expand-noweb-references) "bar"))))
 681
 682 (ert-deftest test-ob/noweb-expansion-2 ()
 683   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 684   <<foo>>
 685 #+end_src
 686
 687 #+name: foo
 688 #+begin_src sh :noweb-sep \"\"
 689   bar
 690 #+end_src
 691
 692 #+begin_src sh :noweb-ref foo :noweb-sep \"\"
 693   baz
 694 #+end_src"
 695     (should (string= (org-babel-expand-noweb-references) "barbaz"))))
 696
 697 (ert-deftest test-ob/splitting-variable-lists-in-references ()
 698   (org-test-with-temp-text ""
 699     (should (= 1 (length (org-babel-ref-split-args
 700                           "a=\"this, no work\""))))
 701     (should (= 2 (length (org-babel-ref-split-args
 702                           "a=\"this, no work\", b=1"))))))
 703
 704 (ert-deftest test-ob/balanced-split ()
 705   "Test `org-babel-balanced-split' specifications."
 706   (should (equal
 707            '(":a 1" "b [2 3]" "c (4 :d (5 6))")
 708            (org-babel-balanced-split ":a 1 :b [2 3] :c (4 :d (5 6))"
 709                                      '((32 9) . 58))))
 710   ;; Handle un-balanced parens.
 711   (should
 712    (equal '(":foo ((6)" "bar 1")
 713           (org-babel-balanced-split ":foo ((6) :bar 1" '((32 9) . 58))))
 714   (should
 715    (equal '(":foo \"(foo\"" "bar 2")
 716           (org-babel-balanced-split ":foo \"(foo\" :bar 2" '((32 9) . 58))))
 717   ;; Handle un-balanced quotes.
 718   (should
 719    (equal '(":foo \"1" "bar 3")
 720           (org-babel-balanced-split ":foo \"1 :bar 3" '((32 9) . 58))))
 721   ;; Handle empty string.
 722   (should
 723    (equal '(":foo \"\"")
 724           (org-babel-balanced-split ":foo \"\"" '((32 9) . 58))))
 725   ;; Handle control characters within double quotes.
 726   (should
 727    (equal '(":foo \"\\n\"")
 728           (org-babel-balanced-split ":foo \"\\n\"" '((32 9) . 58)))))
 729
 730 (ert-deftest test-ob/commented-last-block-line-no-var ()
 731   (org-test-with-temp-text-in-file "
 732 #+begin_src emacs-lisp
 733 ;;
 734 #+end_src"
 735     (org-babel-next-src-block)
 736     (org-babel-execute-maybe)
 737     (should (re-search-forward "\\#\\+results:" nil t))
 738     (forward-line)
 739     (should
 740      (string=
 741       ""
 742       (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 743   (org-test-with-temp-text-in-file "
 744 #+begin_src emacs-lisp
 745 \"some text\";;
 746 #+end_src"
 747     (org-babel-next-src-block)
 748     (org-babel-execute-maybe)
 749     (should (re-search-forward "\\#\\+results:" nil t))
 750     (forward-line)
 751     (should
 752      (string=
 753       ": some text"
 754       (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 755
 756 (ert-deftest test-ob/commented-last-block-line-with-var ()
 757   (org-test-with-temp-text-in-file "
 758 #+begin_src emacs-lisp :var a=1
 759 ;;
 760 #+end_src"
 761     (org-babel-next-src-block)
 762     (org-babel-execute-maybe)
 763     (re-search-forward "\\#\\+results:" nil t)
 764     (forward-line)
 765     (should (string=
 766              ""
 767              (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 768   (org-test-with-temp-text-in-file "
 769 #+begin_src emacs-lisp :var a=2
 770 2;;
 771 #+end_src"
 772     (org-babel-next-src-block)
 773     (org-babel-execute-maybe)
 774     (re-search-forward "\\#\\+results:" nil t)
 775     (forward-line)
 776     (should (string=
 777              ": 2"
 778              (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 779
 780 (ert-deftest test-ob/org-babel-insert-result ()
 781   "Test `org-babel-insert-result' specifications."
 782   ;; Do not error when output is an improper list.
 783   (should
 784    (org-test-with-temp-text
 785        "
 786 <point>#+BEGIN_SRC emacs-lisp
 787 '((1 . nil) (2 . 3))
 788 #+END_SRC
 789 "
 790      (org-babel-execute-maybe) t))
 791   ;; Escape headlines when producing an example block.
 792   (should
 793    (string-match-p
 794     ",\\* Not an headline"
 795     (org-test-with-temp-text
 796         "
 797 <point>#+BEGIN_SRC emacs-lisp
 798 \"* Not an headline\"
 799 #+END_SRC
 800 "
 801       (let ((org-babel-min-lines-for-block-output 1)) (org-babel-execute-maybe))
 802       (buffer-string))))
 803   ;; Escape special syntax in example blocks.
 804   (should
 805    (string-match-p
 806     ",#\\+END_SRC"
 807     (org-test-with-temp-text
 808         "
 809 <point>#+BEGIN_SRC emacs-lisp
 810 \"#+END_SRC\"
 811 #+END_SRC
 812 "
 813       (let ((org-babel-min-lines-for-block-output 1)) (org-babel-execute-maybe))
 814       (buffer-string))))
 815   ;; No escaping is done with other blocks or raw type.
 816   (should-not
 817    (string-match-p
 818     ",\\* Not an headline"
 819     (org-test-with-temp-text
 820         "
 821 <point>#+BEGIN_SRC emacs-lisp
 822 \"* Not an headline\"
 823 #+END_SRC
 824 "
 825       (let ((org-babel-min-lines-for-block-output 10))
 826         (org-babel-execute-maybe))
 827       (buffer-string))))
 828   (should-not
 829    (string-match-p
 830     ",\\* Not an headline"
 831     (org-test-with-temp-text
 832         "
 833 <point>#+BEGIN_SRC emacs-lisp :results raw
 834 \"* Not an headline\"
 835 #+END_SRC
 836 "
 837       (org-babel-execute-maybe)
 838       (buffer-string))))
 839   (should-not
 840    (string-match-p
 841     ",\\* Not an headline"
 842     (org-test-with-temp-text
 843         "
 844 <point>#+BEGIN_SRC emacs-lisp :results drawer
 845 \"* Not an headline\"
 846 #+END_SRC
 847 "
 848       (org-babel-execute-maybe)
 849       (buffer-string)))))
 850
 851 (ert-deftest test-ob/remove-inline-result ()
 852   "Test `org-babel-remove-inline-result' honors whitespace."
 853   (let*
 854       ((inline-sb "src_emacs-lisp{(+ 1 2)}")
 855        (inline-res " {{{results(=3=)}}}")
 856        (inline-sb-dot (concat inline-sb "."))
 857        (inline-sb-res-dot (concat inline-sb inline-res ".")))
 858     (org-test-with-temp-text
 859         ;; Insert inline_src_block followed by dot.
 860         inline-sb-dot
 861       ;; Insert result before dot.
 862       (org-babel-execute-maybe)
 863       (should (string= inline-sb-res-dot
 864                        (buffer-substring-no-properties
 865                         (point-at-bol) (point-at-eol))))
 866       ;; Delete whitespace and result.
 867       (org-babel-remove-inline-result)
 868       (should (string= inline-sb-dot
 869                        (buffer-substring-no-properties
 870                         (point-at-bol) (point-at-eol))))
 871       ;; Add whitespace and result before dot.
 872       (search-forward inline-sb)
 873       (insert "     " inline-res)
 874       (goto-char (point-at-bol))
 875       ;; Remove whitespace and result.
 876       (org-babel-remove-inline-result)
 877       (should (string= inline-sb-dot
 878                        (buffer-substring-no-properties
 879                         (point-at-bol) (point-at-eol))))
 880       ;; Add whitespace before dot.
 881       (search-forward inline-sb)
 882       (insert "     ")
 883       (goto-char (point-at-bol))
 884       ;; Add result before whitespace.
 885       (org-babel-execute-maybe)
 886       ;; Remove result - leave trailing whitespace and dot.
 887       (org-babel-remove-inline-result)
 888       (should (string= (concat inline-sb "     .")
 889                        (buffer-substring-no-properties
 890                         (point-at-bol) (point-at-eol)))))))
 891
 892 (ert-deftest test-ob/org-babel-remove-result--results-default ()
 893   "Test `org-babel-remove-result' with default :results."
 894   (mapcar (lambda (language)
 895             (test-ob-verify-result-and-removed-result
 896              "\n"
 897              (concat
 898               "* org-babel-remove-result
 899 #+begin_src " language "
 900 #+end_src
 901
 902 * next heading")))
 903           '("sh" "emacs-lisp")))
 904
 905 (ert-deftest test-ob/org-babel-results-indented-wrap ()
 906   "Ensure that wrapped results are inserted correction when indented.
 907 If not inserted correctly then the second evaluation will fail
 908 trying to find the :END: marker."
 909   (org-test-with-temp-text
 910       "- indented
 911   #+begin_src sh :results file wrap
 912     echo test.txt
 913   #+end_src"
 914     (org-babel-next-src-block 1)
 915     (org-babel-execute-src-block)
 916     (org-babel-execute-src-block)))
 917
 918 (ert-deftest test-ob/file-desc-header-argument ()
 919   "Test that the :file-desc header argument is used."
 920   (org-test-with-temp-text "#+begin_src emacs-lisp :results file :file-desc bar
 921   \"foo\"
 922 #+end_src
 923
 924 #+begin_src emacs-lisp :results file :file-desc
 925   \"foo\"
 926 #+end_src"
 927     (org-babel-execute-src-block)
 928     (org-babel-next-src-block 1)
 929     (org-babel-execute-src-block)
 930     (goto-char (point-min))
 931     (should (search-forward "[[file:foo][bar]]" nil t))
 932     (should (search-forward "[[file:foo][foo]]" nil t))))
 933
 934 (ert-deftest test-ob/inline-src_blk-preceded-punct-preceded-by-point ()
 935   (let ((test-line ".src_emacs-lisp[ :results verbatim ]{ \"x\"  }")
 936         (org-babel-inline-result-wrap "=%s="))
 937     (org-test-with-temp-text
 938         test-line
 939       (forward-char 1)
 940       (org-babel-execute-maybe)
 941       (should (re-search-forward "=\"x\"=" nil t))
 942       (forward-line))))
 943
 944 (ert-deftest test-ob/commented-last-block-line-with-var ()
 945   (org-test-with-temp-text-in-file "
 946 #+begin_src emacs-lisp :var a=1
 947 ;;
 948 #+end_src"
 949     (org-babel-next-src-block)
 950     (org-babel-execute-maybe)
 951     (re-search-forward "\\#\\+results:" nil t)
 952     (forward-line)
 953     (should (string=
 954              ""
 955              (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 956   (org-test-with-temp-text-in-file "
 957 #+begin_src emacs-lisp :var a=2
 958 2;;
 959 #+end_src"
 960     (org-babel-next-src-block)
 961     (org-babel-execute-maybe)
 962     (re-search-forward "\\#\\+results:" nil t)
 963     (forward-line)
 964     (should (string=
 965              ": 2"
 966              (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 967
 968 (defun test-ob-verify-result-and-removed-result (result buffer-text)
 969   "Test helper function to test `org-babel-remove-result'.
 970 A temp buffer is populated with BUFFER-TEXT, the first block is executed,
 971 and the result of execution is verified against RESULT.
 972
 973 The block is actually executed /twice/ to ensure result
 974 replacement happens correctly."
 975   (org-test-with-temp-text
 976       buffer-text
 977     (org-babel-next-src-block) (org-babel-execute-maybe) (org-babel-execute-maybe)
 978     (should (re-search-forward "\\#\\+results:" nil t))
 979     (forward-line)
 980     (should (string= result
 981                      (buffer-substring-no-properties
 982                       (point-at-bol)
 983                       (- (point-max) 16))))
 984     (org-babel-previous-src-block) (org-babel-remove-result)
 985     (should (string= buffer-text
 986                      (buffer-substring-no-properties
 987                       (point-min) (point-max))))))
 988
 989 (ert-deftest test-ob/org-babel-remove-result--results-list ()
 990   "Test `org-babel-remove-result' with :results list."
 991   (test-ob-verify-result-and-removed-result
 992    "- 1
 993 - 2
 994 - 3
 995 - (quote (4 5))"
 996
 997    "* org-babel-remove-result
 998 #+begin_src emacs-lisp :results list
 999 '(1 2 3 '(4 5))
1000 #+end_src
1001
1002 * next heading"))
1003
1004 (ert-deftest test-ob/org-babel-remove-result--results-wrap ()
1005   "Test `org-babel-remove-result' with :results wrap."
1006   (test-ob-verify-result-and-removed-result
1007    ":RESULTS:
1008 hello there
1009 :END:"
1010
1011    "* org-babel-remove-result
1012
1013 #+begin_src emacs-lisp :results wrap
1014 \"hello there\"
1015 #+end_src
1016
1017 * next heading"))
1018
1019 (ert-deftest test-ob/org-babel-remove-result--results-org ()
1020   "Test `org-babel-remove-result' with :results org."
1021   (test-ob-verify-result-and-removed-result
1022    "#+BEGIN_SRC org
1023 ,* heading
1024 ,** subheading
1025 content
1026 #+END_SRC"
1027
1028    "* org-babel-remove-result
1029 #+begin_src emacs-lisp :results org
1030 \"* heading
1031 ,** subheading
1032 content\"
1033 #+end_src
1034
1035 * next heading"))
1036
1037 (ert-deftest test-ob/org-babel-remove-result--results-html ()
1038   "Test `org-babel-remove-result' with :results html."
1039   (test-ob-verify-result-and-removed-result
1040    "#+BEGIN_EXPORT html
1041 <head><body></body></head>
1042 #+END_EXPORT"
1043
1044    "* org-babel-remove-result
1045 #+begin_src emacs-lisp :results html
1046 \"<head><body></body></head>\"
1047 #+end_src
1048
1049 * next heading"))
1050
1051 (ert-deftest test-ob/org-babel-remove-result--results-latex ()
1052   "Test `org-babel-remove-result' with :results latex."
1053   (test-ob-verify-result-and-removed-result
1054    "#+BEGIN_EXPORT latex
1055 Line 1
1056 Line 2
1057 Line 3
1058 #+END_EXPORT"
1059
1060    "* org-babel-remove-result
1061 #+begin_src emacs-lisp :results latex
1062 \"Line 1
1063 Line 2
1064 Line 3\"
1065 #+end_src
1066
1067 * next heading"))
1068
1069 (ert-deftest test-ob/org-babel-remove-result--results-code ()
1070   "Test `org-babel-remove-result' with :results code."
1071
1072   (test-ob-verify-result-and-removed-result
1073    "#+BEGIN_SRC emacs-lisp
1074 \"I am working!\"
1075 #+END_SRC"
1076
1077    "* org-babel-remove-result
1078 #+begin_src emacs-lisp :results code
1079 (message \"I am working!\")
1080 #+end_src
1081
1082 * next heading"))
1083
1084 (ert-deftest test-ob/org-babel-remove-result--results-pp ()
1085   "Test `org-babel-remove-result' with :results pp."
1086   (test-ob-verify-result-and-removed-result
1087    ": \"I /am/ working!\""
1088
1089    "* org-babel-remove-result
1090 #+begin_src emacs-lisp :results pp
1091 \"I /am/ working!\")
1092 #+end_src
1093
1094 * next heading"))
1095
1096 (ert-deftest test-ob/org-babel-remove-result--no-blank-line ()
1097   "Test `org-babel-remove-result' without blank line between code and results."
1098   (should
1099    (equal "
1100 #+begin_src emacs-lisp
1101   (+ 1 1)
1102 #+end_src
1103 #+results:
1104 : 2
1105 * next heading"
1106           (org-test-with-temp-text
1107               "
1108 <point>#+begin_src emacs-lisp
1109   (+ 1 1)
1110 #+end_src
1111 #+results:
1112 : 2
1113 * next heading"
1114             (org-babel-execute-maybe)
1115             (buffer-string)))))
1116
1117 (ert-deftest test-ob/results-do-not-replace-code-blocks ()
1118   (org-test-with-temp-text "Block two has a space after the name.
1119
1120   #+name: foo
1121   #+begin_src emacs-lisp
1122     1
1123   #+end_src
1124
1125 #+name: foo
1126 #+begin_src emacs-lisp
1127   2
1128 #+end_src
1129
1130 #+name: foo
1131 #+begin_src emacs-lisp
1132   3
1133 #+end_src
1134
1135 #+RESULTS: foo
1136 : foo
1137 "
1138     (dolist (num '(1 2 3))
1139       ;; execute the block
1140       (goto-char (point-min))
1141       (org-babel-next-src-block num) (org-babel-execute-src-block)
1142       ;; check the results
1143       (goto-char (point-max))
1144       (move-beginning-of-line 0)
1145       (should (looking-at (format ": %d" num))))))
1146
1147 (ert-deftest test-ob/blocks-with-spaces ()
1148   "Test expansion of blocks followed by blank lines."
1149   ;; Preserve number of blank lines after block.
1150   (should
1151    (equal "#+BEGIN_SRC emacs-lisp
1152 \(+ 1 2)
1153 #+END_SRC
1154
1155 #+RESULTS:
1156 : 3\n\n\n"
1157           (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp
1158 \(+ 1 2)
1159 #+END_SRC\n\n\n"
1160             (let ((org-babel-next-src-block "RESULTS"))
1161               (org-babel-execute-src-block))
1162             (buffer-string))))
1163   ;; Do not add spurious blank lines after results.
1164   (should
1165    (equal
1166     "
1167 - item 1
1168
1169   #+begin_src emacs-lisp
1170   0
1171   #+end_src
1172
1173   #+RESULTS:
1174   : 0
1175
1176 - item 2"
1177     (org-test-with-temp-text "
1178 - item 1
1179
1180   #+begin_src emacs-lisp<point>
1181   0
1182   #+end_src
1183
1184 - item 2"
1185       (org-babel-execute-src-block)
1186       (buffer-string))))
1187   (should
1188    (equal
1189     "
1190 - item 1
1191
1192   #+begin_src emacs-lisp
1193   1
1194   #+end_src
1195
1196   #+RESULTS:
1197   : 1
1198
1199 - item 2"
1200     (org-test-with-temp-text "
1201 - item 1
1202
1203   #+begin_src emacs-lisp<point>
1204   1
1205   #+end_src
1206
1207   #+RESULTS:
1208   : 1
1209
1210 - item 2"
1211       (org-babel-execute-src-block)
1212       (buffer-string)))))
1213
1214 (ert-deftest test-ob/results-in-narrowed-buffer ()
1215   "Test block execution in a narrowed buffer."
1216   ;; If results don't exist, they should be inserted in visible part
1217   ;; of the buffer.
1218   (should
1219    (equal
1220     "#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\n#+RESULTS:\n: 3"
1221     (org-test-with-temp-text
1222         "#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\nParagraph"
1223       (narrow-to-region (point) (save-excursion (forward-line 3) (point)))
1224       (let ((org-babel-results-keyword "RESULTS"))
1225         (org-babel-execute-src-block))
1226       (org-trim (buffer-string)))))
1227   (should
1228    (equal
1229     "#+NAME: test\n#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\n#+RESULTS: test\n: 3"
1230     (org-test-with-temp-text
1231         "#+NAME: test\n#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\nParagraph"
1232       (narrow-to-region (point) (save-excursion (forward-line 4) (point)))
1233       (let ((org-babel-results-keyword "RESULTS"))
1234         (org-babel-execute-src-block))
1235       (org-trim (buffer-string)))))
1236   ;; Results in visible part of buffer, should be updated here.
1237   (should
1238    (equal
1239     "#+NAME: test
1240 #+BEGIN_SRC emacs-lisp
1241 \(+ 1 2)
1242 #+END_SRC
1243
1244 #+RESULTS: test
1245 : 3"
1246     (org-test-with-temp-text
1247         "#+NAME: test
1248 #+BEGIN_SRC emacs-lisp
1249 \(+ 1 2)
1250 #+END_SRC
1251
1252 #+RESULTS: test
1253 : 4
1254 <point>
1255 Paragraph"
1256       (narrow-to-region (point-min) (point))
1257       (goto-char (point-min))
1258       (let ((org-babel-results-keyword "RESULTS"))
1259         (org-babel-execute-src-block))
1260       (org-trim (buffer-string)))))
1261   ;; Results in invisible part of buffer, should be updated there.
1262   (org-test-with-temp-text
1263       "#+NAME: test
1264 #+BEGIN_SRC emacs-lisp
1265 \(+ 1 2)
1266 #+END_SRC
1267
1268 #+RESULTS: test
1269 : 4
1270
1271 Paragraph"
1272     (narrow-to-region (point) (save-excursion (forward-line 4) (point)))
1273     (let ((org-babel-results-keyword "RESULTS"))
1274       (org-babel-execute-src-block))
1275     (should-not (re-search-forward "^#\\+RESULTS:" nil t))
1276     (widen)
1277     (should (re-search-forward "^: 3" nil t))))
1278
1279 (ert-deftest test-ob/specific-colnames ()
1280   "Test passing specific column names."
1281   (should
1282    (equal "#+name: input-table
1283 | id | var1 |
1284 |----+------|
1285 |  1 | bar  |
1286 |  2 | baz  |
1287
1288 #+begin_src sh :var data=input-table :exports results :colnames '(Rev Author)
1289 echo \"$data\"
1290 #+end_src
1291
1292 #+RESULTS:
1293 | Rev | Author |
1294 |-----+--------|
1295 |   1 | bar    |
1296 |   2 | baz    |
1297 "
1298           (org-test-with-temp-text
1299               "#+name: input-table
1300 | id | var1 |
1301 |----+------|
1302 |  1 | bar  |
1303 |  2 | baz  |
1304
1305 #+begin_src sh :var data=input-table :exports results :colnames '(Rev Author)
1306 echo \"$data\"
1307 #+end_src
1308 "
1309             ;; we should find a code block
1310             (should (re-search-forward org-babel-src-block-regexp nil t))
1311             (goto-char (match-beginning 0))
1312             ;; now that we've located the code block, it may be evaluated
1313             (let ((org-babel-execute-src-block "RESULTS"))
1314               (org-babel-execute-src-block))
1315             (buffer-string)))))
1316
1317 (ert-deftest test-ob/location-of-header-arg-eval ()
1318   "Test location of header argument evaluation."
1319   (org-test-with-temp-text "
1320 #+name: top-block
1321 #+begin_src emacs-lisp :var pt=(point)
1322   pt
1323 #+end_src
1324
1325 #+name: bottom-block
1326 #+begin_src emacs-lisp :var pt=top-block()
1327   pt
1328 #+end_src
1329 "
1330     ;; the value of the second block should be greater than the first
1331     (should
1332      (< (progn (re-search-forward org-babel-src-block-regexp nil t)
1333                (goto-char (match-beginning 0))
1334                (prog1 (save-match-data (org-babel-execute-src-block))
1335                  (goto-char (match-end 0))))
1336         (progn (re-search-forward org-babel-src-block-regexp nil t)
1337                (goto-char (match-beginning 0))
1338                (org-babel-execute-src-block))))))
1339
1340 (ert-deftest test-ob/preserve-results-indentation ()
1341   "Preserve indentation when executing a src block."
1342   (should
1343    (equal
1344     '(2 2)
1345     (org-test-with-temp-text "  #+begin_src emacs-lisp\n(+ 1 1)\n  #+end_src"
1346       (org-babel-execute-src-block)
1347       (let ((case-fold-search t)) (search-forward "RESULTS"))
1348       (list (org-get-indentation)
1349             (progn (forward-line) (org-get-indentation))))))
1350   (should
1351    (equal
1352     '(2 2)
1353     (org-test-with-temp-text
1354         "  #+name: block\n  #+begin_src emacs-lisp\n(+ 1 1)\n  #+end_src"
1355       (org-babel-execute-src-block)
1356       (let ((case-fold-search t)) (search-forward "RESULTS"))
1357       (list (org-get-indentation)
1358             (progn (forward-line) (org-get-indentation))))))
1359   ;; Don't get fooled by TAB-based indentation.
1360   (should
1361    (equal
1362     '(6 6)
1363     (org-test-with-temp-text
1364         "\t  #+begin_src emacs-lisp\n\t  (+ 1 1)\n\t  #+end_src"
1365       (setq tab-width 4)
1366       (org-babel-execute-src-block)
1367       (let ((case-fold-search t)) (search-forward "RESULTS"))
1368       (list (org-get-indentation)
1369             (progn (forward-line) (org-get-indentation))))))
1370   ;; Properly indent examplified blocks.
1371   (should
1372    (equal
1373     "   #+begin_example
1374    0
1375    1
1376    2
1377    3
1378    4
1379    5
1380    6
1381    7
1382    8
1383    9
1384    #+end_example
1385 "
1386     (org-test-with-temp-text
1387         "   #+begin_src emacs-lisp :results output
1388    (dotimes (i 10) (princ i) (princ \"\\n\"))
1389    #+end_src"
1390       (org-babel-execute-src-block)
1391       (search-forward "begin_example")
1392       (downcase
1393        (buffer-substring-no-properties (line-beginning-position)
1394                                        (point-max))))))
1395   ;; Properly indent "org" blocks.
1396   (should
1397    (equal
1398     "   #+begin_src org
1399    0
1400    1
1401    2
1402    3
1403    4
1404    5
1405    6
1406    7
1407    8
1408    9
1409    #+end_src
1410 "
1411     (org-test-with-temp-text
1412         "   #+begin_src emacs-lisp :results output org
1413    (dotimes (i 10) (princ i) (princ \"\\n\"))
1414    #+end_src"
1415       (org-babel-execute-src-block)
1416       (search-forward "begin_src org")
1417       (downcase
1418        (buffer-substring-no-properties (line-beginning-position)
1419                                        (point-max)))))))
1420
1421 (ert-deftest test-ob/safe-header-args ()
1422   "Detect safe and unsafe header args."
1423   (let ((safe-args '((:cache . "foo")
1424                      (:results . "output")
1425                      (:eval . "never")
1426                      (:eval . "query")))
1427         (unsafe-args '((:eval . "yes")
1428                        (:results . "output file")
1429                        (:foo . "bar")))
1430         (malformed-args '((bar . "foo")
1431                           ("foo" . "bar")
1432                           :foo))
1433         (safe-p (org-babel-header-args-safe-fn org-babel-safe-header-args)))
1434     (dolist (arg safe-args)
1435       (should (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args)))
1436     (dolist (arg unsafe-args)
1437       (should (not (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args))))
1438     (dolist (arg malformed-args)
1439       (should (not (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args))))
1440     (should (not (funcall safe-p (append safe-args unsafe-args))))))
1441
1442 (ert-deftest test-ob/noweb-expansions-in-cache ()
1443   "Ensure that noweb expansions are expanded before caching."
1444   (let ((noweb-expansions-in-cache-var 0))
1445     (org-test-with-temp-text "
1446 #+name: foo
1447 #+begin_src emacs-lisp
1448   \"I said\"
1449 #+end_src
1450
1451 #+name: bar
1452 #+begin_src emacs-lisp :noweb yes :cache yes
1453   (setq noweb-expansions-in-cache-var
1454         (+ 1 noweb-expansions-in-cache-var))
1455   (concat <<foo>> \" check noweb expansions\")
1456 #+end_src
1457 "
1458       ;; run the second block to create the cache
1459       (goto-char (point-min))
1460       (re-search-forward (regexp-quote "#+name: bar"))
1461       (should (string= "I said check noweb expansions"
1462                        (org-babel-execute-src-block)))
1463       (should (= noweb-expansions-in-cache-var 1))
1464       ;; change the value of the first block
1465       (goto-char (point-min))
1466       (re-search-forward (regexp-quote "said"))
1467       (goto-char (match-beginning 0))
1468       (insert "haven't ")
1469       (re-search-forward (regexp-quote "#+name: bar"))
1470       (should (string= "I haven't said check noweb expansions"
1471                        (org-babel-execute-src-block)))
1472       (should (= noweb-expansions-in-cache-var 2)))))
1473
1474 (ert-deftest test-ob/file-ext-and-output-dir ()
1475   (org-test-at-id "93573e1d-6486-442e-b6d0-3fedbdc37c9b"
1476     (org-babel-next-src-block)
1477     (should (equal  "file-ext-basic.txt"
1478                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1479     (org-babel-next-src-block)
1480     (should (equal "foo/file-ext-dir-relative.txt"
1481                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1482     (org-babel-next-src-block)
1483     (should (equal  "foo/file-ext-dir-relative-slash.txt"
1484                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1485     (org-babel-next-src-block)
1486     (should (equal  "/tmp/file-ext-dir-absolute.txt"
1487                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1488     (org-babel-next-src-block)
1489     (should (equal  "foo.bar"
1490                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1491     (org-babel-next-src-block)
1492     (should (equal "xxx/foo.bar"
1493                    (cdr (assq :file (nth 2 (org-babel-get-src-block-info t))))))
1494     ))
1495
1496 (ert-deftest test-ob/script-escape ()
1497   ;; Delimited lists of numbers
1498   (should (equal '(1 2 3)
1499                  (org-babel-script-escape "[1 2 3]")))
1500   (should (equal '(1 2 3)
1501                  (org-babel-script-escape "{1 2 3}")))
1502   (should (equal '(1 2 3)
1503                  (org-babel-script-escape "(1 2 3)")))
1504   ;; Delimited lists of double-quoted strings
1505   (should (equal '("foo" "bar")
1506                  (org-babel-script-escape "(\"foo\" \"bar\")")))
1507   (should (equal '("foo" "bar")
1508                  (org-babel-script-escape "[\"foo\" \"bar\"]")))
1509   (should (equal '("foo" "bar")
1510                  (org-babel-script-escape "{\"foo\" \"bar\"}")))
1511   ;; ... with commas
1512   (should (equal '("foo" "bar")
1513                  (org-babel-script-escape "(\"foo\", \"bar\")")))
1514   (should (equal '("foo" "bar")
1515                  (org-babel-script-escape "[\"foo\", \"bar\"]")))
1516   (should (equal '("foo" "bar")
1517                  (org-babel-script-escape "{\"foo\", \"bar\"}")))
1518   ;; Delimited lists of single-quoted strings
1519   (should (equal '("foo" "bar")
1520                  (org-babel-script-escape "('foo' 'bar')")))
1521   (should (equal '("foo" "bar")
1522                  (org-babel-script-escape "['foo' 'bar']")))
1523   (should (equal '("foo" "bar")
1524                  (org-babel-script-escape "{'foo' 'bar'}")))
1525   ;; ... with commas
1526   (should (equal '("foo" "bar")
1527                  (org-babel-script-escape "('foo', 'bar')")))
1528   (should (equal '("foo" "bar")
1529                  (org-babel-script-escape "['foo', 'bar']")))
1530   (should (equal '("foo" "bar")
1531                  (org-babel-script-escape "{'foo', 'bar'}")))
1532   ;; Single quoted strings
1533   (should (equal "foo"
1534                  (org-babel-script-escape "'foo'")))
1535   ;; ... with internal double quote
1536   (should (equal "foo\"bar"
1537                  (org-babel-script-escape "'foo\"bar'")))
1538   ;; ... with internal backslash
1539   (should (equal "foo\\bar"
1540                  (org-babel-script-escape "'foo\\bar'")))
1541   ;; ... with internal escaped backslash
1542   (should (equal "foo\\bar"
1543                  (org-babel-script-escape "'foo\\\\bar'")))
1544   ;; ... with internal backslash-double quote
1545   (should (equal "foo\\\"bar"
1546                  (org-babel-script-escape "'foo\\\"bar'")))
1547   ;; ... with internal escaped backslash-double quote
1548   (should (equal "foo\\\"bar"
1549                  (org-babel-script-escape "'foo\\\\\"bar'")))
1550   ;; ... with internal escaped single quote
1551   (should (equal "foo'bar"
1552                  (org-babel-script-escape "'foo\\'bar'")))
1553   ;; ... with internal escaped backslash-escaped single quote
1554   (should (equal "foo\\'bar"
1555                  (org-babel-script-escape "'foo\\\\\\'bar'")))
1556   ;; Double quoted strings
1557   (should (equal "foo"
1558                  (org-babel-script-escape "\"foo\"")))
1559   ;; ... with internal single quote
1560   (should (equal "foo'bar"
1561                  (org-babel-script-escape "\"foo'bar\"")))
1562   ;; ... with internal backslash
1563   (should (equal "foo\\bar"
1564                  (org-babel-script-escape "\"foo\\bar\"")))
1565   ;; ... with internal escaped backslash
1566   (should (equal "foo\\bar"
1567                  (org-babel-script-escape "\"foo\\\\bar\"")))
1568   ;; ... with internal backslash-single quote
1569   (should (equal "foo\\'bar"
1570                  (org-babel-script-escape "\"foo\\'bar\"")))
1571   ;; ... with internal escaped backslash-single quote
1572   (should (equal "foo\\'bar"
1573                  (org-babel-script-escape "\"foo\\\\'bar\"")))
1574   ;; ... with internal escaped double quote
1575   (should (equal "foo\"bar"
1576                  (org-babel-script-escape "\"foo\\\"bar\"")))
1577   ;; ... with internal escaped backslash-escaped double quote
1578   (should (equal "foo\\\"bar"
1579                  (org-babel-script-escape "\"foo\\\\\\\"bar\""))))
1580
1581 (ert-deftest test-ob/process-params-no-duplicates ()
1582   (should
1583    (equal (org-babel-process-params '((:colname-names)
1584                                       (:rowname-names)
1585                                       (:result-params)
1586                                       (:result-type)
1587                                       (:var . "\"foo\"")))
1588           '((:var)
1589             (:colname-names)
1590             (:rowname-names)
1591             (:result-params)
1592             (:result-type . value)))))
1593
1594 (defun org-test-babel-confirm-evaluate (eval-value)
1595   (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
1596   nil
1597 #+end_src" eval-value)
1598         (goto-char (point-min))
1599         (let ((info (org-babel-get-src-block-info)))
1600            (org-babel-check-confirm-evaluate info))))
1601
1602 (ert-deftest test-ob/check-eval ()
1603   (let ((org-confirm-babel-evaluate t))
1604     ;; Non-export tests
1605     (dolist (pair '(("no" . nil)
1606                     ("never" . nil)
1607                     ("query" . query)
1608                     ("yes" . query)))
1609       (should (eq (org-test-babel-confirm-evaluate (car pair)) (cdr pair))))
1610     ;; Export tests
1611     (let ((org-babel-exp-reference-buffer t))
1612       (dolist (pair '(("no" . nil)
1613                       ("never" . nil)
1614                       ("query" . query)
1615                       ("yes" . query)
1616                       ("never-export" . nil)
1617                       ("no-export" . nil)
1618                       ("query-export" . query)))
1619         (message (car pair))
1620         (should (eq (org-test-babel-confirm-evaluate (car pair)) (cdr pair))))))
1621   (let ((org-confirm-babel-evaluate nil))
1622     ;; Non-export tests
1623     (dolist (pair '(("no" . nil)
1624                     ("never" . nil)
1625                     ("query" . query)
1626                     ("yes" . t)))
1627       (should (eq (org-test-babel-confirm-evaluate (car pair)) (cdr pair))))
1628     ;; Export tests
1629     (let ((org-babel-exp-reference-buffer t))
1630       (dolist (pair '(("no" . nil)
1631                       ("never" . nil)
1632                       ("query" . query)
1633                       ("yes" . t)
1634                       ("never-export" . nil)
1635                       ("no-export" . nil)
1636                       ("query-export" . query)))
1637         (message (car pair))
1638         (should (eq (org-test-babel-confirm-evaluate (car pair)) (cdr pair)))))))
1639
1640 (defun org-test-ob/update-block-body ()
1641   "Test `org-babel-update-block-body' specifications."
1642   (should
1643    (equal "#+begin_src elisp\n  2\n#+end_src"
1644           (let ((org-edit-src-content-indentation 2))
1645             (org-test-with-temp-text "#+begin_src elisp\n(+ 1 1)\n#+end_src"
1646               (org-babel-update-block-body "2")
1647               (buffer-string)))))
1648   ;; Preserve block indentation.
1649   (should
1650    (equal "  #+begin_src elisp\n   2\n  #+end_src"
1651           (let ((org-edit-src-content-indentation 1))
1652             (org-test-with-temp-text
1653                 "  #+begin_src elisp\n  (+ 1 1)\n  #+end_src"
1654               (org-babel-update-block-body "2")
1655               (buffer-string)))))
1656   ;; Ignore NEW-BODY global indentation.
1657   (should
1658    (equal "#+begin_src elisp\n  2\n#+end_src"
1659           (let ((org-edit-src-content-indentation 2))
1660             (org-test-with-temp-text "#+begin_src elisp\n(+ 1 1)\n#+end_src"
1661               (org-babel-update-block-body "      2")
1662               (buffer-string)))))
1663   ;; When indentation should be preserved ignore the two rules above.
1664   (should
1665    (equal "  #+begin_src elisp\n2\n  #+end_src"
1666           (let ((org-edit-src-content-indentation 1)
1667                 (org-src-preserve-indentation t))
1668             (org-test-with-temp-text
1669                 "  #+begin_src elisp\n  (+ 1 1)\n  #+end_src"
1670               (org-babel-update-block-body "2")
1671               (buffer-string)))))
1672   (should
1673    (equal "  #+begin_src elisp -i\n2\n  #+end_src"
1674           (let ((org-edit-src-content-indentation 1))
1675             (org-test-with-temp-text
1676                 "  #+begin_src elisp -i\n  (+ 1 1)\n  #+end_src"
1677               (org-babel-update-block-body "2")
1678               (buffer-string)))))
1679   (should
1680    (equal "#+begin_src elisp\n      2\n#+end_src"
1681           (let ((org-edit-src-content-indentation 2)
1682                 (org-src-preserve-indentation t))
1683             (org-test-with-temp-text "#+begin_src elisp\n(+ 1 1)\n#+end_src"
1684               (org-babel-update-block-body "      2")
1685               (buffer-string)))))
1686   (should
1687    (equal "#+begin_src elisp -i\n      2\n#+end_src"
1688           (let ((org-edit-src-content-indentation 2)
1689                 (org-src-preserve-indentation t))
1690             (org-test-with-temp-text "#+begin_src elisp -i\n(+ 1 1)\n#+end_src"
1691               (org-babel-update-block-body "      2")
1692               (buffer-string))))))
1693
1694 (ert-deftest test-ob/find-named-result ()
1695   "Test `org-babel-find-named-result' specifications."
1696   (should
1697    (= 1
1698       (org-test-with-temp-text "#+results: foo\n: result"
1699         (org-babel-find-named-result "foo"))))
1700   (should-not
1701    (org-test-with-temp-text "#+results: foo\n: result"
1702      (org-babel-find-named-result "bar")))
1703   (should-not
1704    (org-test-with-temp-text "#+results: foobar\n: result"
1705      (org-babel-find-named-result "foo")))
1706   ;; Search is case insensitive.
1707   (should
1708    (org-test-with-temp-text "#+RESULTS: FOO\n: result"
1709      (org-babel-find-named-result "foo")))
1710   ;; Handle hash in results keyword.
1711   (should
1712    (org-test-with-temp-text "#+results[hash]: FOO\n: result"
1713      (org-babel-find-named-result "foo")))
1714   ;; Accept orphaned affiliated keywords.
1715   (should
1716    (org-test-with-temp-text "#+results: foo"
1717      (org-babel-find-named-result "foo"))))
1718
1719 (ert-deftest test-ob/where-is-src-block-result ()
1720   "Test `org-babel-where-is-src-block-result' specifications."
1721   ;; Find anonymous results.
1722   (should
1723    (equal "#+RESULTS:"
1724           (org-test-with-temp-text
1725               "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n\n#+RESULTS:\n: 2"
1726             (goto-char (org-babel-where-is-src-block-result))
1727             (buffer-substring-no-properties (point) (line-end-position)))))
1728   ;; Find named results.  Those have priority over anonymous ones.
1729   (should
1730    (equal "#+RESULTS: example"
1731           (org-test-with-temp-text
1732               "
1733 <point>#+NAME: example
1734 #+BEGIN_SRC emacs-lisp
1735 \(+ 1 1)
1736 #+END_SRC
1737
1738 #+RESULTS: example
1739 : 2"
1740             (goto-char (org-babel-where-is-src-block-result))
1741             (buffer-substring-no-properties (point) (line-end-position)))))
1742   (should
1743    (equal "#+RESULTS: example"
1744           (org-test-with-temp-text
1745               "
1746 <point>#+NAME: example
1747 #+BEGIN_SRC emacs-lisp
1748 \(+ 1 1)
1749 #+END_SRC
1750
1751 #+RESULTS:
1752 : fake
1753
1754 #+RESULTS: example
1755 : 2"
1756             (goto-char (org-babel-where-is-src-block-result))
1757             (buffer-substring-no-properties (point) (line-end-position)))))
1758   ;; Return nil when no result is found.
1759   (should-not
1760    (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1761      (org-babel-where-is-src-block-result)))
1762   (should-not
1763    (org-test-with-temp-text
1764        "- item\n  #+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n\n"
1765      (org-babel-where-is-src-block-result)))
1766   ;; When optional argument INSERT is non-nil, add RESULTS keyword
1767   ;; whenever no RESULTS can be found.
1768   (should
1769    (equal
1770     "#+RESULTS:"
1771     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1772       (let ((org-babel-results-keyword "RESULTS"))
1773         (goto-char (org-babel-where-is-src-block-result t)))
1774       (buffer-substring-no-properties (point) (line-end-position)))))
1775   ;; Insert a named RESULTS keyword if possible.
1776   (should
1777    (equal
1778     "#+RESULTS: e"
1779     (org-test-with-temp-text
1780         "#+NAME: e\n#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1781       (let ((org-babel-results-keyword "RESULTS"))
1782         (goto-char (org-babel-where-is-src-block-result t)))
1783       (buffer-substring-no-properties (point) (line-end-position)))))
1784   ;; When optional argument HASH is provided, clear RESULTS keyword
1785   ;; and related contents if they do not match it.
1786   (should
1787    (equal
1788     "#+RESULTS[bbbb]:"
1789     (org-test-with-temp-text
1790         "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n\n#+RESULTS[aaaa]:\n: 3"
1791       (let ((org-babel-results-keyword "RESULTS"))
1792         (goto-char (org-babel-where-is-src-block-result nil nil "bbbb")))
1793       (org-trim (buffer-substring-no-properties (point) (point-max))))))
1794   (should
1795    (equal
1796     "#+RESULTS[bbbb]:"
1797     (org-test-with-temp-text
1798         "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC\n\n#+RESULTS[aaaa]:"
1799       (let ((org-babel-results-keyword "RESULTS"))
1800         (goto-char (org-babel-where-is-src-block-result nil nil "bbbb")))
1801       (org-trim (buffer-substring-no-properties (point) (point-max))))))
1802   ;; Handle hashes with times.
1803   (should
1804    (equal
1805     "#+RESULTS[<2014-03-04 00:41:10> bbbb]:"
1806     (org-test-with-temp-text
1807         "
1808 <point>#+BEGIN_SRC emacs-lisp
1809 \(+ 1 1)
1810 #+END_SRC
1811
1812 #+RESULTS[<2012-03-29 16:40:12> aaaa]:"
1813       (let ((org-babel-results-keyword "RESULTS")
1814             (org-babel-hash-show-time t))
1815         (cl-letf (((symbol-function 'format-time-string)
1816                    (lambda (&rest _) "<2014-03-04 00:41:10>")))
1817           (goto-char (org-babel-where-is-src-block-result nil nil "bbbb"))
1818           (org-trim (buffer-substring-no-properties (point) (point-max))))))))
1819   (should
1820    (equal
1821     "#+RESULTS[<2012-03-29 16:40:12> aaaa]:"
1822     (org-test-with-temp-text
1823         "
1824 <point>#+BEGIN_SRC emacs-lisp
1825 \(+ 1 1)
1826 #+END_SRC
1827
1828 #+RESULTS[<2012-03-29 16:40:12> aaaa]:"
1829       (let ((org-babel-results-keyword "RESULTS")
1830             (org-babel-hash-show-time t))
1831         (cl-letf (((symbol-function 'format-time-string)
1832                    (lambda (&rest _) "<2014-03-04 00:41:10>")))
1833           (goto-char (org-babel-where-is-src-block-result nil nil "aaaa"))
1834           (org-trim (buffer-substring-no-properties (point) (point-max))))))))
1835   ;; RESULTS keyword may not be the last affiliated keyword.
1836   (should
1837    (equal
1838     "#+RESULTS[bbbb]:"
1839     (org-test-with-temp-text
1840         "
1841 <point>#+BEGIN_SRC emacs-lisp
1842 \(+ 1 1)
1843 #+END_SRC
1844
1845 #+RESULTS[aaaa]:
1846 #+NAME: e
1847 : 3"
1848       (let ((org-babel-results-keyword "RESULTS"))
1849         (goto-char (org-babel-where-is-src-block-result nil nil "bbbb")))
1850       (org-trim (buffer-substring-no-properties (point) (point-max))))))
1851   ;; HASH does nothing if no RESULTS can be found.  However, if INSERT
1852   ;; is also non-nil, RESULTS keyword is inserted along with the
1853   ;; expected hash.
1854   (should
1855    (equal
1856     "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1857     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1858       (org-babel-where-is-src-block-result nil nil "bbbb")
1859       (buffer-string))))
1860   (should
1861    (equal
1862     "#+RESULTS[bbbb]:"
1863     (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp\n(+ 1 1)\n#+END_SRC"
1864       (let ((org-babel-results-keyword "RESULTS"))
1865         (goto-char (org-babel-where-is-src-block-result t nil "bbbb")))
1866       (org-trim (buffer-substring-no-properties (point) (point-max)))))))
1867
1868 (ert-deftest test-ob/goto-named-src-block ()
1869     "Test interactive use of `org-babel-goto-named-src-block'."
1870     (org-test-with-temp-text-in-file
1871                 "
1872 #+NAME: abc
1873 #+BEGIN_SRC emacs-lisp :results value
1874 (1+ 1)
1875 #+END_SRC
1876 #+CALL: abc( lorem() ) :results raw :wrap EXAMPLE
1877 #+BEGIN_SRC emacs-lisp
1878 <<abc>>
1879 #+END_SRC
1880 abc
1881 #+RESULTS: abc
1882 : 2
1883 "
1884        ;; non-existent name
1885        (should-not
1886          (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\nno-name\n"))
1887        ;; correct name
1888        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\nabc\n")
1889        (should  (= 14 (point)))
1890        ;; call line   - autocompletion
1891        (forward-line 3)
1892        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\n\n")
1893        (should  (= 14 (point)))
1894        ;; noweb reference  - autocompletion
1895        (forward-line 5)
1896        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\n\n")
1897        (should  (= 14 (point)))
1898        ;; at symbol  - autocompletion
1899        (forward-line 7)
1900        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\n\n")
1901        (should  (= 14 (point)))
1902        ;; in results  - autocompletion
1903        (forward-line 8)
1904        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\n\n")
1905        (should  (= 14 (point)))
1906        (forward-line 9)
1907        (execute-kbd-macro  "\M-xorg-babel-goto-named-src-block\n\n")
1908        (should  (= 14 (point)))))
1909
1910 (ert-deftest test-ob/evaluate-body-with-coderefs ()
1911   (should
1912    (= 2
1913       (org-test-with-temp-text
1914           "#+begin_src emacs-lisp -l \"#(ref:%s)\"\n2 #(ref:foo)\n#+end_src"
1915         (org-babel-execute-src-block))))
1916   (should
1917    (= 3
1918       (org-test-with-temp-text
1919           "#+begin_src emacs-lisp\n3 #(ref:foo)\n#+end_src"
1920         (let ((org-coderef-label-format "#(ref:%s)"))
1921           (org-babel-execute-src-block))))))
1922
1923 (provide 'test-ob)
1924
1925 ;;; test-ob ends here