testing/lisp/test-ob.el

   1 ;;; test-ob.el --- tests for ob.el
   2
   3 ;; Copyright (c) 2010, 2011 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   ;; at the babel.org:elisp-forms-in-header-arguments header
 118   (org-test-at-id "22d67284-bf14-4cdc-8319-f4bd876829d7"
 119     (org-babel-next-src-block)
 120     (let ((info (org-babel-get-src-block-info)))
 121       (should (= 4 (org-babel-execute-src-block))))))
 122
 123 (ert-deftest test-org-babel/simple-named-code-block ()
 124   "Test that simple named code blocks can be evaluated."
 125   (org-test-at-id "0d82b52d-1bb9-4916-816b-2c67c8108dbb"
 126     (org-babel-next-src-block 1)
 127     (should (= 42 (org-babel-execute-src-block)))))
 128
 129 (ert-deftest test-org-babel/simple-variable-resolution ()
 130   "Test that simple variable resolution is working."
 131   (org-test-at-id "f68821bc-7f49-4389-85b5-914791ee3718"
 132     (org-babel-next-src-block 2)
 133     (should (= 4 (org-babel-execute-src-block)))))
 134
 135 (ert-deftest test-org-babel/multi-line-header-arguments ()
 136   "Test that multi-line header arguments and can be read."
 137   (org-test-at-id "b77c8857-6c76-4ea9-8a61-ddc2648d96c4"
 138     (org-babel-next-src-block)
 139     (let ((results (org-babel-execute-src-block)))
 140       (should(equal 'a (cadr (assoc 1 results))))
 141       (should(equal 'd (cadr (assoc 4 results)))))))
 142
 143 (ert-deftest test-org-babel/parse-header-args ()
 144   (org-test-at-id "7eb0dc6e-1c53-4275-88b3-b22f3113b9c3"
 145     (org-babel-next-src-block)
 146     (let* ((info (org-babel-get-src-block-info))
 147            (params (nth 2 info)))
 148       (message "%S" params)
 149       (should(equal "example-lang" (nth 0 info)))
 150       (should(string= "the body" (org-babel-trim (nth 1 info))))
 151       (should-not (member '(:session\ \ \ \ ) params))
 152       (should(equal '(:session) (assoc :session params)))
 153       (should(equal '(:result-type . output) (assoc :result-type params)))
 154       (should(equal '(num . 9) (cdr (assoc :var params)))))))
 155
 156 (ert-deftest test-org-babel/parse-header-args2 ()
 157   (org-test-at-id "2409e8ba-7b5f-4678-8888-e48aa02d8cb4"
 158     (should (string-match (regexp-quote "this is simple")
 159                           (org-babel-ref-resolve "simple-subtree")))
 160     (org-babel-next-src-block)
 161     (should (= 14 (org-babel-execute-src-block)))))
 162
 163 (ert-deftest test-org-babel/inline-src-blocks ()
 164   (org-test-at-id "54cb8dc3-298c-4883-a933-029b3c9d4b18"
 165     (macrolet ((at-next (&rest body)
 166                  `(progn
 167                     (move-end-of-line 1)
 168                     (re-search-forward org-babel-inline-src-block-regexp nil t)
 169                     (goto-char (match-beginning 1))
 170                     (save-match-data ,@body))))
 171       (at-next (should (equal 1 (org-babel-execute-src-block))))
 172       (at-next (should (equal 2 (org-babel-execute-src-block))))
 173       (at-next (should (equal 3 (org-babel-execute-src-block)))))))
 174
 175 (ert-deftest test-org-babel/org-babel-get-inline-src-block-matches ()
 176   (org-test-at-id "0D0983D4-DE33-400A-8A05-A225A567BC74"
 177     (let ((test-point (point)))
 178       (should (fboundp 'org-babel-get-inline-src-block-matches))
 179       (should (re-search-forward "src_" nil t)) ;; 1
 180       (should (= (+ test-point 140) (match-end 0)))
 181       (should (org-babel-get-inline-src-block-matches))
 182       (should (re-search-forward "}" nil (point-at-bol))) ;; 1
 183       (should-not (org-babel-get-inline-src-block-matches))
 184       (should (re-search-forward "in" nil t)) ;; 2
 185       (should-not (org-babel-get-inline-src-block-matches))
 186       (should (re-search-forward "echo" nil t)) ;; 2
 187       (should (org-babel-get-inline-src-block-matches))
 188       (should (re-search-forward "blocks" nil t)) ;; 3
 189       (backward-char 8) ;; 3
 190       (should (org-babel-get-inline-src-block-matches))
 191       (forward-char 1) ;;3
 192       (should-not (org-babel-get-inline-src-block-matches))
 193       (should (re-search-forward ":results" nil t)) ;; 4
 194       (should (org-babel-get-inline-src-block-matches))
 195       (end-of-line)
 196       (should-not (org-babel-get-inline-src-block-matches))
 197     )))
 198
 199 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-1 ()
 200   (let ((test-line "src_sh{echo 1}"))
 201     ;; src_ at bol line 1...
 202     (org-test-with-temp-text
 203         test-line
 204       (goto-char (point-min)) (org-ctrl-c-ctrl-c)
 205       (should (string=
 206                (concat test-line " =1=")
 207                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 208       (forward-char) (org-ctrl-c-ctrl-c)
 209       (should (string=
 210                (concat test-line " =1= =1=")
 211                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 212       (re-search-forward "1}")
 213       (should-error (org-ctrl-c-ctrl-c))
 214       (backward-char) ;; last char of block body
 215       (org-ctrl-c-ctrl-c)
 216       (should (string=
 217                (concat test-line " =1= =1= =1=")
 218                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 219     ;; src_ follows space line 1...
 220     (let ((test-line " src_emacs-lisp{ 1 }"))
 221     (org-test-with-temp-text
 222         test-line
 223       (should-error (org-ctrl-c-ctrl-c))
 224       (forward-char) (org-ctrl-c-ctrl-c)
 225       (should (string=
 226                (concat test-line " =1=")
 227                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 228       (re-search-forward "{ 1 ") (org-ctrl-c-ctrl-c)
 229       (should (string=
 230                (concat test-line " =1= =1=")
 231                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 232       (forward-char)
 233       (should-error (org-ctrl-c-ctrl-c)))))
 234
 235 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-2 ()
 236   ;; src_ at bol line 2...
 237   (let ((test-line " src_emacs-lisp{ \"x\" }"))
 238     (org-test-with-temp-text
 239         (concat "\n" test-line)
 240       (should-error (org-ctrl-c-ctrl-c))
 241       (goto-char (point-min))
 242       (should-error (org-ctrl-c-ctrl-c))
 243       (forward-line)
 244       (should-error (org-ctrl-c-ctrl-c))
 245       (forward-char) (org-ctrl-c-ctrl-c)
 246       (should (string=
 247                (concat test-line " =x=")
 248                (buffer-substring-no-properties
 249                 (point-at-bol) (point-at-eol))))))
 250
 251   (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }"))
 252     (org-test-with-temp-text
 253         test-line
 254       (goto-char (point-max))
 255       (insert (concat "\n" test-line " end"))
 256       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 257       (should (string=
 258                (concat test-line " =y= end")
 259                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 260       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 261       (should (string=
 262                (concat test-line " =y= =y= end")
 263                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 264       (forward-char)
 265       (should-error (org-ctrl-c-ctrl-c))))))
 266
 267 (ert-deftest test-org-babel/inline-src_blk-manual-results-replace ()
 268   (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }"))
 269     (org-test-with-temp-text
 270         (concat "\n" test-line)
 271       (should-error (org-ctrl-c-ctrl-c))
 272       (goto-char (point-max))
 273       (should-error (org-ctrl-c-ctrl-c))
 274       (beginning-of-line)
 275       (should-error (org-ctrl-c-ctrl-c))
 276       (forward-char) (org-ctrl-c-ctrl-c)
 277       (should (string=
 278                (concat test-line " =x=")
 279                (buffer-substring-no-properties
 280                 (point-at-bol) (point-at-eol))))))
 281
 282   (let ((test-line (concat " Some text prior to block "
 283                            "src_emacs-lisp[:results replace]{ \"y\" }")))
 284     (org-test-with-temp-text test-line
 285       (goto-char (point-max))
 286       (insert (concat "\n" test-line " end"))
 287       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 288       (should (string=
 289                (concat test-line " =y= end")
 290                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 291       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 292       (should (string=
 293                (concat test-line " =y= =y= end")
 294                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 295       (forward-char)
 296       (should-error (org-ctrl-c-ctrl-c)))))
 297
 298 (ert-deftest test-org-babel/inline-src_blk-results-silent ()
 299   (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
 300     (org-test-with-temp-text test-line
 301       (org-ctrl-c-ctrl-c)
 302       (should (string= test-line
 303                        (buffer-substring-no-properties
 304                         (point-at-bol) (point-at-eol))))
 305       (end-of-buffer)
 306       (should-error (org-ctrl-c-ctrl-c))))
 307   (let ((test-line (concat " Some text prior to block src_emacs-lisp"
 308                            "[ :results silent ]{ \"y\" }")))
 309     (org-test-with-temp-text
 310         test-line
 311       (goto-char (point-max))
 312       (insert (concat "\n" test-line " end"))
 313       (re-search-backward "src_") (org-ctrl-c-ctrl-c)
 314       (should (string= (concat test-line " end")
 315                        (buffer-substring-no-properties
 316                         (point-at-bol) (point-at-eol))))
 317       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 318       (should (string= (concat test-line " end")
 319                        (buffer-substring-no-properties
 320                         (point-at-bol) (point-at-eol))))
 321       (forward-char)
 322       (should-error (org-ctrl-c-ctrl-c)))))
 323
 324 (ert-deftest test-org-babel/inline-src_blk-results-raw ()
 325   (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
 326     (org-test-with-temp-text test-line
 327       (org-ctrl-c-ctrl-c)
 328       (should (string= (concat test-line " x")
 329                        (buffer-string)))))
 330   (let ((test-line (concat " Some text prior to block "
 331                            "src_emacs-lisp[ :results raw ]{ \"the\" }")))
 332     (org-test-with-temp-text (concat test-line " end")
 333       (re-search-forward "src_") (org-ctrl-c-ctrl-c)
 334       (should (string= (concat test-line " the end")
 335                        (buffer-substring-no-properties
 336                         (point-at-bol) (point-at-eol))))
 337       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 338       (should (string= (concat test-line " the the end")
 339                        (buffer-substring-no-properties
 340                         (point-at-bol) (point-at-eol))))
 341       (forward-char)
 342       (should-error (org-ctrl-c-ctrl-c)))))
 343
 344 (ert-deftest test-org-babel/inline-src_blk-results-file ()
 345   (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\"  }"))
 346     (org-test-with-temp-text
 347         test-line
 348       (org-ctrl-c-ctrl-c)
 349       (should (string= (concat test-line " [[file:~/test-file]]")
 350                        (buffer-substring-no-properties
 351                         (point-min) (point-max)))))))
 352
 353 (ert-deftest test-org-babel/inline-src_blk-results-scalar ()
 354   (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\"  }"))
 355     (org-test-with-temp-text
 356         test-line
 357       (org-ctrl-c-ctrl-c)
 358       (should (string= (concat test-line  " =\"x\"=")
 359                        (buffer-substring-no-properties
 360                         (point-min) (point-max)))))))
 361
 362 (ert-deftest test-org-babel/inline-src_blk-results-verbatim ()
 363   (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\"  }"))
 364     (org-test-with-temp-text
 365         test-line
 366       (org-ctrl-c-ctrl-c)
 367       (should (string= (concat test-line " =\"x\"=")
 368                        (buffer-substring-no-properties
 369                         (point-min) (point-max)))))))
 370
 371 (ert-deftest test-org-babel/combining-scalar-and-raw-result-types ()
 372   (flet ((next-result ()
 373                       (org-babel-next-src-block)
 374                       (org-babel-execute-src-block)
 375                       (goto-char (org-babel-where-is-src-block-result))
 376                       (forward-line 1)))
 377     (org-test-at-id "a73a2ab6-b8b2-4c0e-ae7f-23ad14eab7bc"
 378       (next-result)
 379       (should (org-babel-in-example-or-verbatim))
 380       (next-result)
 381       (should (not (org-babel-in-example-or-verbatim))))))
 382
 383 (ert-deftest test-org-babel/no-defaut-value-for-var ()
 384   "Test that the absence of a default value for a variable DOES THROW
 385   a proper error."
 386   (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
 387     (org-babel-next-src-block)
 388     (let ((err
 389            (should-error (org-babel-execute-src-block) :type 'error)))
 390       (should
 391        (equal
 392         '(error
 393           "variable \"x\" in block \"carre\" must be assigned a default value")
 394         err)))))
 395
 396 (ert-deftest test-org-babel/just-one-results-block ()
 397   "Test that evaluating two times the same code block does not result in a
 398 duplicate results block."
 399   (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
 400     (org-babel-execute-src-block)
 401     (org-babel-execute-src-block)     ; second code block execution
 402     (should (search-forward "Hello")) ; the string inside the source code block
 403     (should (search-forward "Hello")) ; the same string in the results block
 404     (should-error (search-forward "Hello"))))
 405
 406 (ert-deftest test-org-babel/nested-code-block ()
 407   "Test nested code blocks inside code blocks don't cause problems."
 408   (org-test-with-temp-text "#+begin_src org :results silent
 409   ,#+begin_src emacs-lisp
 410   ,  'foo
 411   ,#+end_src
 412 #+end_src"
 413     (should (string= (org-babel-execute-src-block)
 414                      "#+begin_src emacs-lisp\n  'foo\n#+end_src"))))
 415
 416 (ert-deftest test-org-babel/partial-nested-code-block ()
 417   "Test nested code blocks inside code blocks don't cause problems."
 418   (org-test-with-temp-text "#+begin_src org :results silent
 419   ,#+begin_src emacs-lisp
 420 #+end_src"
 421     (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
 422
 423 (ert-deftest test-ob/does-not-replace-a-block-with-the-results ()
 424   (org-test-with-temp-text "#+NAME: foo
 425 #+BEGIN_SRC emacs-lisp
 426  'foo
 427 #+END_SRC\n"
 428     (org-babel-next-src-block 1)
 429     (should (eq 'foo (org-babel-execute-src-block)))
 430     (goto-char (point-min))
 431     (org-babel-next-src-block 1)
 432     (should (looking-at org-babel-src-block-regexp))))
 433
 434 (ert-deftest test-ob/catches-all-references ()
 435   (org-test-with-temp-text "
 436 #+NAME: literal-example
 437 #+BEGIN_EXAMPLE
 438 A literal example
 439 on two lines
 440 #+END_EXAMPLE
 441
 442 #+NAME: read-literal-example
 443 #+BEGIN_SRC emacs-lisp :var x=literal-example
 444   (concatenate 'string x \" for me.\")
 445 #+END_SRC"
 446     (org-babel-next-src-block 1)
 447     (should (string= (org-babel-execute-src-block)
 448                      "A literal example\non two lines for me."))))
 449
 450 (ert-deftest test-ob/resolve-code-blocks-before-data-blocks ()
 451   (org-test-with-temp-text "
 452 #+name: foo
 453 : bar
 454
 455 #+name: foo
 456 #+begin_src emacs-lisp
 457   \"baz\"
 458 #+end_src
 459
 460 #+begin_src emacs-lisp :var foo=foo
 461   foo
 462 #+end_src"
 463     (org-babel-next-src-block 2)
 464     (should (string= (org-babel-execute-src-block) "baz"))))
 465
 466 (ert-deftest test-ob/do-not-resolve-to-partial-names-data ()
 467   (org-test-with-temp-text "
 468 #+tblname: base_plus
 469 | 1 |
 470 | 2 |
 471
 472 #+tblname: base
 473 | 3 |
 474 | 4 |
 475
 476 #+begin_src emacs-lisp :var x=base
 477   x
 478 #+end_src"
 479     (org-babel-next-src-block 1)
 480     (should (equal (org-babel-execute-src-block) '((3) (4))))))
 481
 482 (ert-deftest test-ob/do-not-resolve-to-partial-names-code ()
 483   (org-test-with-temp-text "
 484 #+name: base_plus
 485 #+begin_src emacs-lisp
 486   'bar
 487 #+end_src
 488
 489 #+name: base
 490 #+begin_src emacs-lisp
 491   'foo
 492 #+end_src
 493
 494 #+begin_src emacs-lisp :var x=base
 495   x
 496 #+end_src"
 497     (org-babel-next-src-block 3)
 498     (should (equal (org-babel-execute-src-block) "foo"))))
 499
 500 (ert-deftest test-ob/allow-spaces-around-=-in-var-specs ()
 501   (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
 502   (+ a b c d)
 503 #+end_src
 504 "
 505     (should (= 10 (org-babel-execute-src-block)))))
 506
 507 (ert-deftest test-ob/org-babel-update-intermediate ()
 508   (org-test-with-temp-text "#+name: foo
 509 #+begin_src emacs-lisp
 510   2
 511 #+end_src
 512
 513 #+results: foo
 514 : 4
 515
 516 #+begin_src emacs-lisp :var it=foo
 517   (+ it 1)
 518 #+end_src"
 519     (let ((org-babel-update-intermediate nil))
 520       (goto-char (point-min))
 521       (org-babel-next-src-block 2)
 522       (should (= 3 (org-babel-execute-src-block)))
 523       (goto-char (point-min))
 524       (forward-line 6)
 525       (should (looking-at ": 4")))
 526     (let ((org-babel-update-intermediate t))
 527       (goto-char (point-min))
 528       (org-babel-next-src-block 2)
 529       (should (= 3 (org-babel-execute-src-block)))
 530       (goto-char (point-min))
 531       (forward-line 6)
 532       (should (looking-at ": 2")))))
 533
 534 (ert-deftest test-ob/eval-header-argument ()
 535   (flet ((check-eval (eval runp)
 536            (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
 537   (setq foo :evald)
 538 #+end_src" eval)
 539              (let ((foo :not-run))
 540                (if runp
 541                    (progn (should (org-babel-execute-src-block))
 542                           (should (eq foo :evald)))
 543                  (progn (should-not (org-babel-execute-src-block))
 544                         (should-not (eq foo :evald))))))))
 545     (check-eval "never" nil)
 546     (check-eval "no" nil)
 547     (check-eval "never-export" t)
 548     (check-eval "no-export" t)
 549     (let ((org-current-export-file "something"))
 550       (check-eval "never" nil)
 551       (check-eval "no" nil)
 552       (check-eval "never-export" nil)
 553       (check-eval "no-export" nil))))
 554
 555 (ert-deftest test-ob/noweb-expansion ()
 556   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 557   <<foo>>
 558 #+end_src
 559
 560 #+name: foo
 561 #+begin_src sh
 562   bar
 563 #+end_src"
 564     (should (string= (org-babel-expand-noweb-references) "bar")))
 565   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 566   <<foo>>
 567 #+end_src
 568
 569 #+name: foo
 570 #+begin_src sh
 571   bar
 572 #+end_src
 573
 574 #+begin_src sh :noweb-ref foo
 575   baz
 576 #+end_src"
 577     (should (string= (org-babel-expand-noweb-references) "barbaz"))))
 578
 579 (ert-deftest test-ob/splitting-variable-lists-in-references ()
 580   (org-test-with-temp-text ""
 581     (should (= 1 (length (org-babel-ref-split-args
 582                           "a=\"this, no work\""))))
 583     (should (= 2 (length (org-babel-ref-split-args
 584                           "a=\"this, no work\", b=1"))))))
 585
 586 (provide 'test-ob)
 587
 588 ;;; test-ob ends here