testing/lisp/test-ob.el

   1 ;;; test-ob.el --- tests for ob.el
   2
   3 ;; Copyright (c) 2010-2012 Eric Schulte
   4 ;; Authors: Eric Schulte, Martyn Jago
   5
   6 ;; Released under the GNU General Public License version 3
   7 ;; see: http://www.gnu.org/licenses/gpl-3.0.html
   8
   9 (let ((load-path (cons (expand-file-name
  10                         ".." (file-name-directory
  11                               (or load-file-name buffer-file-name)))
  12                        load-path)))
  13   (require 'org-test)
  14   (require 'org-test-ob-consts))
  15
  16 (ert-deftest test-org-babel/multi-line-header-regexp ()
  17   (should(equal "^[ \t]*#\\+headers?:[ \t]*\\([^\n]*\\)$"
  18                 org-babel-multi-line-header-regexp))
  19   ;;TODO can be optimised - and what about blah4 blah5 blah6?
  20   (should (string-match
  21            org-babel-multi-line-header-regexp
  22            "   \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))
  23   (should
  24    (equal
  25     "blah1 blah2 blah3 \t"
  26     (match-string
  27      1
  28      "   \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n")))
  29
  30   ;;TODO Check - should this fail?
  31   (should
  32    (not (org-test-string-exact-match
  33          org-babel-multi-line-header-regexp
  34          "   \t #+headers : blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))))
  35
  36 (ert-deftest test-org-babel/src-block-regexp ()
  37   (let ((test-block
  38          (concat
  39           "#+begin_src language -n-r-a-b -c :argument-1 yes :argument-2 no\n"
  40           "echo this is a test\n"
  41           "echo Currently in ' $PWD\n"
  42           "#+end_src"))
  43         (language "language")
  44         (flags "-n-r-a-b -c ")
  45         (arguments ":argument-1 yes :argument-2 no")
  46         (body "echo this is a test\necho Currently in ' $PWD\n"))
  47     (should (string-match org-babel-src-block-regexp test-block))
  48     (should (string-match org-babel-src-block-regexp (upcase test-block)))
  49     (should (equal language (match-string 2 test-block)))
  50     ;;TODO Consider refactoring
  51     (should (equal flags (match-string 3 test-block)))
  52     (should (equal arguments (match-string 4 test-block)))
  53     (should (equal body (match-string 5 test-block)))
  54     ;;no switches
  55     (should (org-test-string-exact-match
  56              org-babel-src-block-regexp
  57              (replace-regexp-in-string flags "" test-block)))
  58     ;;no header arguments
  59     (should (org-test-string-exact-match
  60              org-babel-src-block-regexp
  61              (replace-regexp-in-string arguments "" test-block)))
  62     ;; should be valid with no body
  63     (should (org-test-string-exact-match
  64              org-babel-src-block-regexp
  65              (replace-regexp-in-string body "" test-block)))))
  66
  67 (ert-deftest test-org-babel/get-header ()
  68   (should (not (org-babel-get-header
  69                 org-babel-default-header-args :doesnt-exist)))
  70   (should(equal '((:session . "none"))
  71                 (org-babel-get-header
  72                  org-babel-default-header-args :session)))
  73   (should(equal '((:session . "none"))
  74                 (org-babel-get-header
  75                  org-babel-default-header-args :session nil)))
  76   (should (not (org-babel-get-header
  77                 org-babel-default-header-args :SESSION)))
  78   (should (equal '((:tangle . "no"))
  79                  (org-babel-get-header
  80                   org-babel-default-header-args :tangle)))
  81   ;; with OTHERS option
  82   (should (equal org-babel-default-header-args
  83                  (org-babel-get-header
  84                   org-babel-default-header-args :doesnt-exist 'others)))
  85   (should (equal org-babel-default-header-args
  86                  (org-babel-get-header
  87                   org-babel-default-header-args nil 'others)))
  88   (should (null
  89            (assoc :noweb
  90                   (org-babel-get-header
  91                    org-babel-default-header-args :noweb 'others)))))
  92
  93 (ert-deftest test-org-babel/default-inline-header-args ()
  94   (should(equal
  95           '((:session . "none") (:results . "replace") (:exports . "results"))
  96           org-babel-default-inline-header-args)))
  97
  98 ;;; ob-get-src-block-info
  99 (ert-deftest test-org-babel/get-src-block-info-language ()
 100   (org-test-at-marker nil org-test-file-ob-anchor
 101     (let ((info (org-babel-get-src-block-info)))
 102       (should (string= "emacs-lisp" (nth 0 info))))))
 103
 104 (ert-deftest test-org-babel/get-src-block-info-body ()
 105   (org-test-at-marker nil org-test-file-ob-anchor
 106     (let ((info (org-babel-get-src-block-info)))
 107       (should (string-match (regexp-quote org-test-file-ob-anchor)
 108                             (nth 1 info))))))
 109
 110 (ert-deftest test-org-babel/get-src-block-info-tangle ()
 111   (org-test-at-marker nil org-test-file-ob-anchor
 112     (let ((info (org-babel-get-src-block-info)))
 113       (should (string= "no" (cdr (assoc :tangle (nth 2 info))))))))
 114
 115 (ert-deftest test-org-babel/elisp-in-header-arguments ()
 116   "Test execution of elisp forms in header arguments."
 117   (org-test-with-temp-text-in-file "
 118
 119 * elisp forms in header arguments
 120   :PROPERTIES:
 121   :var:      prop = (* 7 6)
 122   :END:
 123 #+begin_src emacs-lisp
 124   prop
 125 #+end_src"
 126
 127     (progn
 128       (goto-char (point-min))
 129       (org-babel-next-src-block)
 130       (let ((info (org-babel-get-src-block-info)))
 131         (should (= 42 (org-babel-execute-src-block)))))))
 132
 133 (ert-deftest test-org-babel/simple-named-code-block ()
 134   "Test that simple named code blocks can be evaluated."
 135   (org-test-with-temp-text-in-file "
 136
 137 #+name: i-have-a-name
 138 #+begin_src emacs-lisp
 139   42
 140 #+end_src
 141
 142 #+name:
 143 : 42
 144
 145 #+name: i-have-a-name
 146 : 42"
 147
 148     (progn
 149       (org-babel-next-src-block 1)
 150       (should (= 42 (org-babel-execute-src-block))))))
 151
 152 (ert-deftest test-org-babel/simple-variable-resolution ()
 153   "Test that simple variable resolution is working."
 154   (org-test-with-temp-text-in-file "
 155
 156 #+name: four
 157 #+begin_src emacs-lisp
 158   (list 1 2 3 4)
 159 #+end_src
 160
 161 #+begin_src emacs-lisp :var four=four
 162   (length four)
 163 #+end_src"
 164
 165     (progn
 166       (org-babel-next-src-block 2)
 167       (should (= 4 (org-babel-execute-src-block)))
 168       (forward-line 5)
 169       (should (string= ": 4" (buffer-substring
 170                               (point-at-bol)
 171                               (point-at-eol)))))))
 172
 173 (ert-deftest test-org-babel/multi-line-header-arguments ()
 174   "Test that multi-line header arguments and can be read."
 175   (org-test-with-temp-text-in-file "
 176
 177 #+headers: :var letters='(a b c d e f g)
 178 #+begin_src emacs-lisp :var numbers='(1 2 3 4 5 6 7)
 179   (map 'list #'list numbers letters)
 180 #+end_src"
 181
 182     (progn
 183       (org-babel-next-src-block)
 184       (let ((results (org-babel-execute-src-block)))
 185         (should(equal 'a (cadr (assoc 1 results))))
 186         (should(equal 'd (cadr (assoc 4 results))))))))
 187
 188 (ert-deftest test-org-babel/parse-header-args ()
 189   (org-test-with-temp-text-in-file "
 190
 191 #+begin_src example-lang :session     :results output :var num=9
 192   the body
 193 #+end_src"
 194
 195     (progn
 196       (org-babel-next-src-block)
 197       (let* ((info (org-babel-get-src-block-info))
 198              (params (nth 2 info)))
 199         (message "%S" params)
 200         (should(equal "example-lang" (nth 0 info)))
 201         (should(string= "the body" (org-babel-trim (nth 1 info))))
 202         (should-not (member '(:session\ \ \ \ ) params))
 203         (should(equal '(:session) (assoc :session params)))
 204         (should(equal '(:result-type . output) (assoc :result-type params)))
 205         (should(equal '(num . 9) (cdr (assoc :var params))))))))
 206
 207 (ert-deftest test-org-babel/parse-header-args2 ()
 208   (org-test-with-temp-text-in-file "
 209
 210 * resolving sub-trees as references
 211
 212 #+begin_src emacs-lisp :var text=d4faa7b3-072b-4dcf-813c-dd7141c633f3
 213   (length text)
 214 #+end_src
 215
 216 #+begin_src org :noweb yes
 217   <<simple-subtree>>
 218   <<d4faa7b3-072b-4dcf-813c-dd7141c633f3>>
 219 #+end_src
 220
 221 ** simple subtree with custom ID
 222    :PROPERTIES:
 223    :CUSTOM_ID: simple-subtree
 224    :END:
 225 this is simple"
 226
 227     (progn
 228       (should (string-match (regexp-quote "this is simple")
 229                             (org-babel-ref-resolve "simple-subtree")))
 230       (org-babel-next-src-block)
 231       (should (= 14 (org-babel-execute-src-block))))))
 232
 233 (ert-deftest test-org-babel/inline-src-blocks ()
 234   (org-test-at-id "54cb8dc3-298c-4883-a933-029b3c9d4b18"
 235     (macrolet ((at-next (&rest body)
 236                  `(progn
 237                     (move-end-of-line 1)
 238                     (re-search-forward org-babel-inline-src-block-regexp nil t)
 239                     (goto-char (match-beginning 1))
 240                     (save-match-data ,@body))))
 241       (at-next (should (equal 1 (org-babel-execute-src-block))))
 242       (at-next (should (equal 2 (org-babel-execute-src-block))))
 243       (at-next (should (equal 3 (org-babel-execute-src-block)))))))
 244
 245 (ert-deftest test-org-babel/org-babel-get-inline-src-block-matches ()
 246   (org-test-at-id "0D0983D4-DE33-400A-8A05-A225A567BC74"
 247     (let ((test-point (point)))
 248       (should (fboundp 'org-babel-get-inline-src-block-matches))
 249       (should (re-search-forward "src_" nil t)) ;; 1
 250       (should (= (+ test-point 140) (match-end 0)))
 251       (should (org-babel-get-inline-src-block-matches))
 252       (should (re-search-forward "}" nil (point-at-bol))) ;; 1
 253       (should-not (org-babel-get-inline-src-block-matches))
 254       (should (re-search-forward "in" nil t)) ;; 2
 255       (should-not (org-babel-get-inline-src-block-matches))
 256       (should (re-search-forward "echo" nil t)) ;; 2
 257       (should (org-babel-get-inline-src-block-matches))
 258       (should (re-search-forward "blocks" nil t)) ;; 3
 259       (backward-char 8) ;; 3
 260       (should (org-babel-get-inline-src-block-matches))
 261       (forward-char 1) ;;3
 262       (should-not (org-babel-get-inline-src-block-matches))
 263       (should (re-search-forward ":results" nil t)) ;; 4
 264       (should (org-babel-get-inline-src-block-matches))
 265       (end-of-line)
 266       (should-not (org-babel-get-inline-src-block-matches)))))
 267
 268 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-1 ()
 269   (let ((test-line "src_sh{echo 1}"))
 270     ;; src_ at bol line 1...
 271     (org-test-with-temp-text
 272         test-line
 273       (goto-char (point-min)) (org-ctrl-c-ctrl-c)
 274       (should (string=
 275                (concat test-line " =1=")
 276                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 277       (forward-char) (org-ctrl-c-ctrl-c)
 278       (should (string=
 279                (concat test-line " =1= =1=")
 280                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 281       (re-search-forward "1}")
 282       (should-error (org-ctrl-c-ctrl-c))
 283       (backward-char) ;; last char of block body
 284       (org-ctrl-c-ctrl-c)
 285       (should (string=
 286                (concat test-line " =1= =1= =1=")
 287                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 288     ;; src_ follows space line 1...
 289     (let ((test-line " src_emacs-lisp{ 1 }"))
 290     (org-test-with-temp-text
 291         test-line
 292       (should-error (org-ctrl-c-ctrl-c))
 293       (forward-char) (org-ctrl-c-ctrl-c)
 294       (should (string=
 295                (concat test-line " =1=")
 296                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 297       (re-search-forward "{ 1 ") (org-ctrl-c-ctrl-c)
 298       (should (string=
 299                (concat test-line " =1= =1=")
 300                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 301       (forward-char)
 302       (should-error (org-ctrl-c-ctrl-c)))))
 303
 304 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-2 ()
 305   ;; src_ at bol line 2...
 306   (let ((test-line " src_emacs-lisp{ \"x\" }"))
 307     (org-test-with-temp-text
 308         (concat "\n" test-line)
 309       (should-error (org-ctrl-c-ctrl-c))
 310       (goto-char (point-min))
 311       (should-error (org-ctrl-c-ctrl-c))
 312       (forward-line)
 313       (should-error (org-ctrl-c-ctrl-c))
 314       (forward-char) (org-ctrl-c-ctrl-c)
 315       (should (string=
 316                (concat test-line " =x=")
 317                (buffer-substring-no-properties
 318                 (point-at-bol) (point-at-eol))))))
 319
 320   (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }"))
 321     (org-test-with-temp-text
 322         test-line
 323       (goto-char (point-max))
 324       (insert (concat "\n" test-line " end"))
 325       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 326       (should (string=
 327                (concat test-line " =y= end")
 328                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 329       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 330       (should (string=
 331                (concat test-line " =y= =y= end")
 332                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 333       (forward-char)
 334       (should-error (org-ctrl-c-ctrl-c))))))
 335
 336 (ert-deftest test-org-babel/inline-src_blk-manual-results-replace ()
 337   (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }"))
 338     (org-test-with-temp-text
 339         (concat "\n" test-line)
 340       (should-error (org-ctrl-c-ctrl-c))
 341       (goto-char (point-max))
 342       (should-error (org-ctrl-c-ctrl-c))
 343       (beginning-of-line)
 344       (should-error (org-ctrl-c-ctrl-c))
 345       (forward-char) (org-ctrl-c-ctrl-c)
 346       (should (string=
 347                (concat test-line " =x=")
 348                (buffer-substring-no-properties
 349                 (point-at-bol) (point-at-eol))))))
 350
 351   (let ((test-line (concat " Some text prior to block "
 352                            "src_emacs-lisp[:results replace]{ \"y\" }")))
 353     (org-test-with-temp-text test-line
 354       (goto-char (point-max))
 355       (insert (concat "\n" test-line " end"))
 356       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 357       (should (string=
 358                (concat test-line " =y= end")
 359                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 360       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 361       (should (string=
 362                (concat test-line " =y= =y= end")
 363                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 364       (forward-char)
 365       (should-error (org-ctrl-c-ctrl-c)))))
 366
 367 (ert-deftest test-org-babel/inline-src_blk-results-silent ()
 368   (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
 369     (org-test-with-temp-text test-line
 370       (org-ctrl-c-ctrl-c)
 371       (should (string= test-line
 372                        (buffer-substring-no-properties
 373                         (point-at-bol) (point-at-eol))))
 374       (end-of-buffer)
 375       (should-error (org-ctrl-c-ctrl-c))))
 376   (let ((test-line (concat " Some text prior to block src_emacs-lisp"
 377                            "[ :results silent ]{ \"y\" }")))
 378     (org-test-with-temp-text
 379         test-line
 380       (goto-char (point-max))
 381       (insert (concat "\n" test-line " end"))
 382       (re-search-backward "src_") (org-ctrl-c-ctrl-c)
 383       (should (string= (concat test-line " end")
 384                        (buffer-substring-no-properties
 385                         (point-at-bol) (point-at-eol))))
 386       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 387       (should (string= (concat test-line " end")
 388                        (buffer-substring-no-properties
 389                         (point-at-bol) (point-at-eol))))
 390       (forward-char)
 391       (should-error (org-ctrl-c-ctrl-c)))))
 392
 393 (ert-deftest test-org-babel/inline-src_blk-results-raw ()
 394   (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
 395     (org-test-with-temp-text test-line
 396       (org-ctrl-c-ctrl-c)
 397       (should (string= (concat test-line " x")
 398                        (buffer-string)))))
 399   (let ((test-line (concat " Some text prior to block "
 400                            "src_emacs-lisp[ :results raw ]{ \"the\" }")))
 401     (org-test-with-temp-text (concat test-line " end")
 402       (re-search-forward "src_") (org-ctrl-c-ctrl-c)
 403       (should (string= (concat test-line " the end")
 404                        (buffer-substring-no-properties
 405                         (point-at-bol) (point-at-eol))))
 406       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 407       (should (string= (concat test-line " the the end")
 408                        (buffer-substring-no-properties
 409                         (point-at-bol) (point-at-eol))))
 410       (forward-char)
 411       (should-error (org-ctrl-c-ctrl-c)))))
 412
 413 (ert-deftest test-org-babel/inline-src_blk-results-file ()
 414   (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\"  }"))
 415     (org-test-with-temp-text
 416         test-line
 417       (org-ctrl-c-ctrl-c)
 418       (should (string= (concat test-line " [[file:~/test-file]]")
 419                        (buffer-substring-no-properties
 420                         (point-min) (point-max)))))))
 421
 422 (ert-deftest test-org-babel/inline-src_blk-results-scalar ()
 423   (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\"  }"))
 424     (org-test-with-temp-text
 425         test-line
 426       (org-ctrl-c-ctrl-c)
 427       (should (string= (concat test-line  " =\"x\"=")
 428                        (buffer-substring-no-properties
 429                         (point-min) (point-max)))))))
 430
 431 (ert-deftest test-org-babel/inline-src_blk-results-verbatim ()
 432   (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\"  }"))
 433     (org-test-with-temp-text
 434         test-line
 435       (org-ctrl-c-ctrl-c)
 436       (should (string= (concat test-line " =\"x\"=")
 437                        (buffer-substring-no-properties
 438                         (point-min) (point-max)))))))
 439
 440 (ert-deftest test-org-babel/combining-scalar-and-raw-result-types ()
 441   (org-test-with-temp-text-in-file "
 442
 443 #+begin_src sh :results scalar
 444 echo \"[[file:./cv.cls]]\"
 445 #+end_src
 446
 447 #+name:
 448 : [[file:./cv.cls]]
 449
 450 #+begin_src sh :results raw scalar
 451    echo \"[[file:./cv.cls]]\"
 452 #+end_src
 453 "
 454     (flet ((next-result ()
 455                         (org-babel-next-src-block)
 456                         (org-babel-execute-src-block)
 457                         (goto-char (org-babel-where-is-src-block-result))
 458                         (forward-line 1)))
 459       (goto-char (point-min))
 460       (next-result)
 461       (should (org-babel-in-example-or-verbatim))
 462       (next-result)
 463       (should (not (org-babel-in-example-or-verbatim))))))
 464
 465 (ert-deftest test-org-babel/no-defaut-value-for-var ()
 466   "Test that the absence of a default value for a variable DOES THROW
 467   a proper error."
 468   (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
 469     (org-babel-next-src-block)
 470     (let ((err
 471            (should-error (org-babel-execute-src-block) :type 'error)))
 472       (should
 473        (equal
 474         '(error
 475           "variable \"x\" in block \"carre\" must be assigned a default value")
 476         err)))))
 477
 478 (ert-deftest test-org-babel/just-one-results-block ()
 479   "Test that evaluating two times the same code block does not result in a
 480 duplicate results block."
 481   (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
 482     (org-babel-execute-src-block)
 483     (org-babel-execute-src-block)     ; second code block execution
 484     (should (search-forward "Hello")) ; the string inside the source code block
 485     (should (search-forward "Hello")) ; the same string in the results block
 486     (should-error (search-forward "Hello"))))
 487
 488 (ert-deftest test-org-babel/nested-code-block ()
 489   "Test nested code blocks inside code blocks don't cause problems."
 490   (org-test-with-temp-text "#+begin_src org :results silent
 491   ,#+begin_src emacs-lisp
 492   ,  'foo
 493   ,#+end_src
 494 #+end_src"
 495     (should (string= (org-babel-execute-src-block)
 496                      "#+begin_src emacs-lisp\n  'foo\n#+end_src"))))
 497
 498 (ert-deftest test-org-babel/partial-nested-code-block ()
 499   "Test nested code blocks inside code blocks don't cause problems."
 500   (org-test-with-temp-text "#+begin_src org :results silent
 501   ,#+begin_src emacs-lisp
 502 #+end_src"
 503     (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
 504
 505 (ert-deftest test-ob/does-not-replace-a-block-with-the-results ()
 506   (org-test-with-temp-text "#+NAME: foo
 507 #+BEGIN_SRC emacs-lisp
 508  'foo
 509 #+END_SRC\n"
 510     (org-babel-next-src-block 1)
 511     (should (eq 'foo (org-babel-execute-src-block)))
 512     (goto-char (point-min))
 513     (org-babel-next-src-block 1)
 514     (should (looking-at org-babel-src-block-regexp))))
 515
 516 (ert-deftest test-ob/catches-all-references ()
 517   (org-test-with-temp-text "
 518 #+NAME: literal-example
 519 #+BEGIN_EXAMPLE
 520 A literal example
 521 on two lines
 522 #+END_EXAMPLE
 523
 524 #+NAME: read-literal-example
 525 #+BEGIN_SRC emacs-lisp :var x=literal-example
 526   (concatenate 'string x \" for me.\")
 527 #+END_SRC"
 528     (org-babel-next-src-block 1)
 529     (should (string= (org-babel-execute-src-block)
 530                      "A literal example\non two lines for me."))))
 531
 532 (ert-deftest test-ob/resolve-code-blocks-before-data-blocks ()
 533   (org-test-with-temp-text "
 534 #+name: foo
 535 : bar
 536
 537 #+name: foo
 538 #+begin_src emacs-lisp
 539   \"baz\"
 540 #+end_src
 541
 542 #+begin_src emacs-lisp :var foo=foo
 543   foo
 544 #+end_src"
 545     (org-babel-next-src-block 2)
 546     (should (string= (org-babel-execute-src-block) "baz"))))
 547
 548 (ert-deftest test-ob/do-not-resolve-to-partial-names-data ()
 549   (org-test-with-temp-text "
 550 #+tblname: base_plus
 551 | 1 |
 552 | 2 |
 553
 554 #+tblname: base
 555 | 3 |
 556 | 4 |
 557
 558 #+begin_src emacs-lisp :var x=base
 559   x
 560 #+end_src"
 561     (org-babel-next-src-block 1)
 562     (should (equal (org-babel-execute-src-block) '((3) (4))))))
 563
 564 (ert-deftest test-ob/do-not-resolve-to-partial-names-code ()
 565   (org-test-with-temp-text "
 566 #+name: base_plus
 567 #+begin_src emacs-lisp
 568   'bar
 569 #+end_src
 570
 571 #+name: base
 572 #+begin_src emacs-lisp
 573   'foo
 574 #+end_src
 575
 576 #+begin_src emacs-lisp :var x=base
 577   x
 578 #+end_src"
 579     (org-babel-next-src-block 3)
 580     (should (equal (org-babel-execute-src-block) "foo"))))
 581
 582 (ert-deftest test-ob/allow-spaces-around-=-in-var-specs ()
 583   (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
 584   (+ a b c d)
 585 #+end_src
 586 "
 587     (should (= 10 (org-babel-execute-src-block)))))
 588
 589 (ert-deftest test-ob/org-babel-update-intermediate ()
 590   (org-test-with-temp-text "#+name: foo
 591 #+begin_src emacs-lisp
 592   2
 593 #+end_src
 594
 595 #+results: foo
 596 : 4
 597
 598 #+begin_src emacs-lisp :var it=foo
 599   (+ it 1)
 600 #+end_src"
 601     (let ((org-babel-update-intermediate nil))
 602       (goto-char (point-min))
 603       (org-babel-next-src-block 2)
 604       (should (= 3 (org-babel-execute-src-block)))
 605       (goto-char (point-min))
 606       (forward-line 6)
 607       (should (looking-at ": 4")))
 608     (let ((org-babel-update-intermediate t))
 609       (goto-char (point-min))
 610       (org-babel-next-src-block 2)
 611       (should (= 3 (org-babel-execute-src-block)))
 612       (goto-char (point-min))
 613       (forward-line 6)
 614       (should (looking-at ": 2")))))
 615
 616 (ert-deftest test-ob/eval-header-argument ()
 617   (flet ((check-eval (eval runp)
 618            (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
 619   (setq foo :evald)
 620 #+end_src" eval)
 621              (let ((foo :not-run))
 622                (if runp
 623                    (progn (should (org-babel-execute-src-block))
 624                           (should (eq foo :evald)))
 625                  (progn (should-not (org-babel-execute-src-block))
 626                         (should-not (eq foo :evald))))))))
 627     (check-eval "never" nil)
 628     (check-eval "no" nil)
 629     (check-eval "never-export" t)
 630     (check-eval "no-export" t)
 631     (let ((org-current-export-file "something"))
 632       (check-eval "never" nil)
 633       (check-eval "no" nil)
 634       (check-eval "never-export" nil)
 635       (check-eval "no-export" nil))))
 636
 637 (ert-deftest test-ob/noweb-expansion ()
 638   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 639   <<foo>>
 640 #+end_src
 641
 642 #+name: foo
 643 #+begin_src sh
 644   bar
 645 #+end_src"
 646     (should (string= (org-babel-expand-noweb-references) "bar")))
 647   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 648   <<foo>>
 649 #+end_src
 650
 651 #+name: foo
 652 #+begin_src sh
 653   bar
 654 #+end_src
 655
 656 #+begin_src sh :noweb-ref foo
 657   baz
 658 #+end_src"
 659     (should (string= (org-babel-expand-noweb-references) "barbaz"))))
 660
 661 (ert-deftest test-ob/splitting-variable-lists-in-references ()
 662   (org-test-with-temp-text ""
 663     (should (= 1 (length (org-babel-ref-split-args
 664                           "a=\"this, no work\""))))
 665     (should (= 2 (length (org-babel-ref-split-args
 666                           "a=\"this, no work\", b=1"))))))
 667
 668 (ert-deftest test-ob/org-babel-balanced-split ()
 669   (should (equal
 670            '(":a 1" "b [2 3]" "c (4 :d (5 6))")
 671            (org-babel-balanced-split ":a 1 :b [2 3] :c (4 :d (5 6))"
 672                                      '((32 9) . 58)))))
 673
 674 (provide 'test-ob)
 675
 676 ;;; test-ob ends here