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     (progn
 143       (org-babel-next-src-block 1)
 144       (should (= 42 (org-babel-execute-src-block))))))
 145
 146 (ert-deftest test-org-babel/simple-variable-resolution ()
 147   "Test that simple variable resolution is working."
 148   (org-test-with-temp-text-in-file "
 149
 150 #+name: four
 151 #+begin_src emacs-lisp
 152   (list 1 2 3 4)
 153 #+end_src
 154
 155 #+begin_src emacs-lisp :var four=four
 156   (length four)
 157 #+end_src"
 158
 159     (progn
 160       (org-babel-next-src-block 2)
 161       (should (= 4 (org-babel-execute-src-block)))
 162       (forward-line 5)
 163       (should (string= ": 4" (buffer-substring
 164                               (point-at-bol)
 165                               (point-at-eol)))))))
 166
 167 (ert-deftest test-org-babel/multi-line-header-arguments ()
 168   "Test that multi-line header arguments and can be read."
 169   (org-test-with-temp-text-in-file "
 170
 171 #+headers: :var letters='(a b c d e f g)
 172 #+begin_src emacs-lisp :var numbers='(1 2 3 4 5 6 7)
 173   (map 'list #'list numbers letters)
 174 #+end_src"
 175
 176     (progn
 177       (org-babel-next-src-block)
 178       (let ((results (org-babel-execute-src-block)))
 179         (should(equal 'a (cadr (assoc 1 results))))
 180         (should(equal 'd (cadr (assoc 4 results))))))))
 181
 182 (ert-deftest test-org-babel/parse-header-args ()
 183   (org-test-with-temp-text-in-file "
 184
 185 #+begin_src example-lang :session     :results output :var num=9
 186   the body
 187 #+end_src"
 188
 189     (progn
 190       (org-babel-next-src-block)
 191       (let* ((info (org-babel-get-src-block-info))
 192              (params (nth 2 info)))
 193         (message "%S" params)
 194         (should(equal "example-lang" (nth 0 info)))
 195         (should(string= "the body" (org-babel-trim (nth 1 info))))
 196         (should-not (member '(:session\ \ \ \ ) params))
 197         (should(equal '(:session) (assoc :session params)))
 198         (should(equal '(:result-type . output) (assoc :result-type params)))
 199         (should(equal '(num . 9) (cdr (assoc :var params))))))))
 200
 201 (ert-deftest test-org-babel/parse-header-args2 ()
 202   (org-test-with-temp-text-in-file "
 203
 204 * resolving sub-trees as references
 205
 206 #+begin_src emacs-lisp :var text=d4faa7b3-072b-4dcf-813c-dd7141c633f3
 207   (length text)
 208 #+end_src
 209
 210 #+begin_src org :noweb yes
 211   <<simple-subtree>>
 212   <<d4faa7b3-072b-4dcf-813c-dd7141c633f3>>
 213 #+end_src
 214
 215 ** simple subtree with custom ID
 216    :PROPERTIES:
 217    :CUSTOM_ID: simple-subtree
 218    :END:
 219 this is simple"
 220
 221     (progn
 222       (should (string-match (regexp-quote "this is simple")
 223                             (org-babel-ref-resolve "simple-subtree")))
 224       (org-babel-next-src-block)
 225       (should (= 14 (org-babel-execute-src-block))))))
 226
 227 (ert-deftest test-org-babel/inline-src-blocks ()
 228   (org-test-at-id "54cb8dc3-298c-4883-a933-029b3c9d4b18"
 229     (macrolet ((at-next (&rest body)
 230                  `(progn
 231                     (move-end-of-line 1)
 232                     (re-search-forward org-babel-inline-src-block-regexp nil t)
 233                     (goto-char (match-beginning 1))
 234                     (save-match-data ,@body))))
 235       (at-next (should (equal 1 (org-babel-execute-src-block))))
 236       (at-next (should (equal 2 (org-babel-execute-src-block))))
 237       (at-next (should (equal 3 (org-babel-execute-src-block)))))))
 238
 239 (ert-deftest test-org-babel/org-babel-get-inline-src-block-matches ()
 240   (org-test-at-id "0D0983D4-DE33-400A-8A05-A225A567BC74"
 241     (let ((test-point (point)))
 242       (should (fboundp 'org-babel-get-inline-src-block-matches))
 243       (should (re-search-forward "src_" nil t)) ;; 1
 244       (should (org-babel-get-inline-src-block-matches))
 245       (should (re-search-forward "}" nil (point-at-bol))) ;; 1
 246       (should-not (org-babel-get-inline-src-block-matches))
 247       (should (re-search-forward "in" nil t)) ;; 2
 248       (should-not (org-babel-get-inline-src-block-matches))
 249       (should (re-search-forward "echo" nil t)) ;; 2
 250       (should (org-babel-get-inline-src-block-matches))
 251       (should (re-search-forward "blocks" nil t)) ;; 3
 252       (backward-char 8) ;; 3
 253       (should (org-babel-get-inline-src-block-matches))
 254       (forward-char 1) ;;3
 255       (should-not (org-babel-get-inline-src-block-matches))
 256       (should (re-search-forward ":results" nil t)) ;; 4
 257       (should (org-babel-get-inline-src-block-matches))
 258       (end-of-line)
 259       (should-not (org-babel-get-inline-src-block-matches)))))
 260
 261 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-1 ()
 262   (let ((test-line "src_sh{echo 1}"))
 263     ;; src_ at bol line 1...
 264     (org-test-with-temp-text
 265         test-line
 266       (goto-char (point-min)) (org-ctrl-c-ctrl-c)
 267       (should (string=
 268                (concat test-line " =1=")
 269                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 270       (forward-char) (org-ctrl-c-ctrl-c)
 271       (should (string=
 272                (concat test-line " =1= =1=")
 273                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 274       (re-search-forward "1}")
 275       (should-error (org-ctrl-c-ctrl-c))
 276       (backward-char) ;; last char of block body
 277       (org-ctrl-c-ctrl-c)
 278       (should (string=
 279                (concat test-line " =1= =1= =1=")
 280                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
 281     ;; src_ follows space line 1...
 282     (let ((test-line " src_emacs-lisp{ 1 }"))
 283     (org-test-with-temp-text
 284         test-line
 285       (should-error (org-ctrl-c-ctrl-c))
 286       (forward-char) (org-ctrl-c-ctrl-c)
 287       (should (string=
 288                (concat test-line " =1=")
 289                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 290       (re-search-forward "{ 1 ") (org-ctrl-c-ctrl-c)
 291       (should (string=
 292                (concat test-line " =1= =1=")
 293                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 294       (forward-char)
 295       (should-error (org-ctrl-c-ctrl-c)))))
 296
 297 (ert-deftest test-org-babel/inline-src_blk-default-results-replace-line-2 ()
 298   ;; src_ at bol line 2...
 299   (let ((test-line " src_emacs-lisp{ \"x\" }"))
 300     (org-test-with-temp-text
 301         (concat "\n" test-line)
 302       (should-error (org-ctrl-c-ctrl-c))
 303       (goto-char (point-min))
 304       (should-error (org-ctrl-c-ctrl-c))
 305       (forward-line)
 306       (should-error (org-ctrl-c-ctrl-c))
 307       (forward-char) (org-ctrl-c-ctrl-c)
 308       (should (string=
 309                (concat test-line " =x=")
 310                (buffer-substring-no-properties
 311                 (point-at-bol) (point-at-eol))))))
 312
 313   (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }"))
 314     (org-test-with-temp-text
 315         test-line
 316       (goto-char (point-max))
 317       (insert (concat "\n" test-line " end"))
 318       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 319       (should (string=
 320                (concat test-line " =y= end")
 321                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 322       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 323       (should (string=
 324                (concat test-line " =y= =y= end")
 325                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 326       (forward-char)
 327       (should-error (org-ctrl-c-ctrl-c))))))
 328
 329 (ert-deftest test-org-babel/inline-src_blk-manual-results-replace ()
 330   (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }"))
 331     (org-test-with-temp-text
 332         (concat "\n" test-line)
 333       (should-error (org-ctrl-c-ctrl-c))
 334       (goto-char (point-max))
 335       (should-error (org-ctrl-c-ctrl-c))
 336       (beginning-of-line)
 337       (should-error (org-ctrl-c-ctrl-c))
 338       (forward-char) (org-ctrl-c-ctrl-c)
 339       (should (string=
 340                (concat test-line " =x=")
 341                (buffer-substring-no-properties
 342                 (point-at-bol) (point-at-eol))))))
 343
 344   (let ((test-line (concat " Some text prior to block "
 345                            "src_emacs-lisp[:results replace]{ \"y\" }")))
 346     (org-test-with-temp-text test-line
 347       (goto-char (point-max))
 348       (insert (concat "\n" test-line " end"))
 349       (re-search-backward "src") (org-ctrl-c-ctrl-c)
 350       (should (string=
 351                (concat test-line " =y= end")
 352                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 353       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 354       (should (string=
 355                (concat test-line " =y= =y= end")
 356                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
 357       (forward-char)
 358       (should-error (org-ctrl-c-ctrl-c)))))
 359
 360 (ert-deftest test-org-babel/inline-src_blk-results-silent ()
 361   (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
 362     (org-test-with-temp-text test-line
 363       (org-ctrl-c-ctrl-c)
 364       (should (string= test-line
 365                        (buffer-substring-no-properties
 366                         (point-at-bol) (point-at-eol))))
 367       (end-of-buffer)
 368       (should-error (org-ctrl-c-ctrl-c))))
 369   (let ((test-line (concat " Some text prior to block src_emacs-lisp"
 370                            "[ :results silent ]{ \"y\" }")))
 371     (org-test-with-temp-text
 372         test-line
 373       (goto-char (point-max))
 374       (insert (concat "\n" test-line " end"))
 375       (re-search-backward "src_") (org-ctrl-c-ctrl-c)
 376       (should (string= (concat test-line " end")
 377                        (buffer-substring-no-properties
 378                         (point-at-bol) (point-at-eol))))
 379       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 380       (should (string= (concat test-line " end")
 381                        (buffer-substring-no-properties
 382                         (point-at-bol) (point-at-eol))))
 383       (forward-char)
 384       (should-error (org-ctrl-c-ctrl-c)))))
 385
 386 (ert-deftest test-org-babel/inline-src_blk-results-raw ()
 387   (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
 388     (org-test-with-temp-text test-line
 389       (org-ctrl-c-ctrl-c)
 390       (should (string= (concat test-line " x")
 391                        (buffer-string)))))
 392   (let ((test-line (concat " Some text prior to block "
 393                            "src_emacs-lisp[ :results raw ]{ \"the\" }")))
 394     (org-test-with-temp-text (concat test-line " end")
 395       (re-search-forward "src_") (org-ctrl-c-ctrl-c)
 396       (should (string= (concat test-line " the end")
 397                        (buffer-substring-no-properties
 398                         (point-at-bol) (point-at-eol))))
 399       (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
 400       (should (string= (concat test-line " the the end")
 401                        (buffer-substring-no-properties
 402                         (point-at-bol) (point-at-eol))))
 403       (forward-char)
 404       (should-error (org-ctrl-c-ctrl-c)))))
 405
 406 (ert-deftest test-org-babel/inline-src_blk-results-file ()
 407   (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\"  }"))
 408     (org-test-with-temp-text
 409         test-line
 410       (org-ctrl-c-ctrl-c)
 411       (should (string= (concat test-line " [[file:~/test-file]]")
 412                        (buffer-substring-no-properties
 413                         (point-min) (point-max)))))))
 414
 415 (ert-deftest test-org-babel/inline-src_blk-results-scalar ()
 416   (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\"  }"))
 417     (org-test-with-temp-text
 418         test-line
 419       (org-ctrl-c-ctrl-c)
 420       (should (string= (concat test-line  " =\"x\"=")
 421                        (buffer-substring-no-properties
 422                         (point-min) (point-max)))))))
 423
 424 (ert-deftest test-org-babel/inline-src_blk-results-verbatim ()
 425   (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\"  }"))
 426     (org-test-with-temp-text
 427         test-line
 428       (org-ctrl-c-ctrl-c)
 429       (should (string= (concat test-line " =\"x\"=")
 430                        (buffer-substring-no-properties
 431                         (point-min) (point-max)))))))
 432
 433 (ert-deftest test-org-babel/combining-scalar-and-raw-result-types ()
 434   (org-test-with-temp-text-in-file "
 435
 436 #+begin_src sh :results scalar
 437 echo \"[[file:./cv.cls]]\"
 438 #+end_src
 439
 440 #+name:
 441 : [[file:./cv.cls]]
 442
 443 #+begin_src sh :results raw scalar
 444    echo \"[[file:./cv.cls]]\"
 445 #+end_src
 446 "
 447     (flet ((next-result ()
 448                         (org-babel-next-src-block)
 449                         (org-babel-execute-src-block)
 450                         (goto-char (org-babel-where-is-src-block-result))
 451                         (forward-line 1)))
 452       (goto-char (point-min))
 453       (next-result)
 454       (should (org-babel-in-example-or-verbatim))
 455       (next-result)
 456       (should (not (org-babel-in-example-or-verbatim))))))
 457
 458 (ert-deftest test-org-babel/no-defaut-value-for-var ()
 459   "Test that the absence of a default value for a variable DOES THROW
 460   a proper error."
 461   (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
 462     (org-babel-next-src-block)
 463     (let ((err
 464            (should-error (org-babel-execute-src-block) :type 'error)))
 465       (should
 466        (equal
 467         '(error
 468           "variable \"x\" in block \"carre\" must be assigned a default value")
 469         err)))))
 470
 471 (ert-deftest test-org-babel/just-one-results-block ()
 472   "Test that evaluating two times the same code block does not result in a
 473 duplicate results block."
 474   (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
 475     (org-babel-execute-src-block)
 476     (org-babel-execute-src-block)     ; second code block execution
 477     (should (search-forward "Hello")) ; the string inside the source code block
 478     (should (search-forward "Hello")) ; the same string in the results block
 479     (should-error (search-forward "Hello"))))
 480
 481 (ert-deftest test-org-babel/nested-code-block ()
 482   "Test nested code blocks inside code blocks don't cause problems."
 483   (org-test-with-temp-text "#+begin_src org :results silent
 484   ,#+begin_src emacs-lisp
 485   ,  'foo
 486   ,#+end_src
 487 #+end_src"
 488     (should (string= (org-babel-execute-src-block)
 489                      "#+begin_src emacs-lisp\n  'foo\n#+end_src"))))
 490
 491 (ert-deftest test-org-babel/partial-nested-code-block ()
 492   "Test nested code blocks inside code blocks don't cause problems."
 493   (org-test-with-temp-text "#+begin_src org :results silent
 494   ,#+begin_src emacs-lisp
 495 #+end_src"
 496     (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
 497
 498 (ert-deftest test-ob/does-not-replace-a-block-with-the-results ()
 499   (org-test-with-temp-text "#+NAME: foo
 500 #+BEGIN_SRC emacs-lisp
 501  'foo
 502 #+END_SRC\n"
 503     (org-babel-next-src-block 1)
 504     (should (eq 'foo (org-babel-execute-src-block)))
 505     (goto-char (point-min))
 506     (org-babel-next-src-block 1)
 507     (should (looking-at org-babel-src-block-regexp))))
 508
 509 (ert-deftest test-ob/catches-all-references ()
 510   (org-test-with-temp-text "
 511 #+NAME: literal-example
 512 #+BEGIN_EXAMPLE
 513 A literal example
 514 on two lines
 515 #+END_EXAMPLE
 516
 517 #+NAME: read-literal-example
 518 #+BEGIN_SRC emacs-lisp :var x=literal-example
 519   (concatenate 'string x \" for me.\")
 520 #+END_SRC"
 521     (org-babel-next-src-block 1)
 522     (should (string= (org-babel-execute-src-block)
 523                      "A literal example\non two lines for me."))))
 524
 525 (ert-deftest test-ob/resolve-code-blocks-before-data-blocks ()
 526   (org-test-with-temp-text "
 527 #+name: foo
 528 : bar
 529
 530 #+name: foo
 531 #+begin_src emacs-lisp
 532   \"baz\"
 533 #+end_src
 534
 535 #+begin_src emacs-lisp :var foo=foo
 536   foo
 537 #+end_src"
 538     (org-babel-next-src-block 2)
 539     (should (string= (org-babel-execute-src-block) "baz"))))
 540
 541 (ert-deftest test-ob/do-not-resolve-to-partial-names-data ()
 542   (org-test-with-temp-text "
 543 #+tblname: base_plus
 544 | 1 |
 545 | 2 |
 546
 547 #+tblname: base
 548 | 3 |
 549 | 4 |
 550
 551 #+begin_src emacs-lisp :var x=base
 552   x
 553 #+end_src"
 554     (org-babel-next-src-block 1)
 555     (should (equal (org-babel-execute-src-block) '((3) (4))))))
 556
 557 (ert-deftest test-ob/do-not-resolve-to-partial-names-code ()
 558   (org-test-with-temp-text "
 559 #+name: base_plus
 560 #+begin_src emacs-lisp
 561   'bar
 562 #+end_src
 563
 564 #+name: base
 565 #+begin_src emacs-lisp
 566   'foo
 567 #+end_src
 568
 569 #+begin_src emacs-lisp :var x=base
 570   x
 571 #+end_src"
 572     (org-babel-next-src-block 3)
 573     (should (equal (org-babel-execute-src-block) "foo"))))
 574
 575 (ert-deftest test-ob/allow-spaces-around-=-in-var-specs ()
 576   (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
 577   (+ a b c d)
 578 #+end_src
 579 "
 580     (should (= 10 (org-babel-execute-src-block)))))
 581
 582 (ert-deftest test-ob/org-babel-update-intermediate ()
 583   (org-test-with-temp-text "#+name: foo
 584 #+begin_src emacs-lisp
 585   2
 586 #+end_src
 587
 588 #+results: foo
 589 : 4
 590
 591 #+begin_src emacs-lisp :var it=foo
 592   (+ it 1)
 593 #+end_src"
 594     (let ((org-babel-update-intermediate nil))
 595       (goto-char (point-min))
 596       (org-babel-next-src-block 2)
 597       (should (= 3 (org-babel-execute-src-block)))
 598       (goto-char (point-min))
 599       (forward-line 6)
 600       (should (looking-at ": 4")))
 601     (let ((org-babel-update-intermediate t))
 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 ": 2")))))
 608
 609 (ert-deftest test-ob/eval-header-argument ()
 610   (flet ((check-eval (eval runp)
 611            (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
 612   (setq foo :evald)
 613 #+end_src" eval)
 614              (let ((foo :not-run))
 615                (if runp
 616                    (progn (should (org-babel-execute-src-block))
 617                           (should (eq foo :evald)))
 618                  (progn (should-not (org-babel-execute-src-block))
 619                         (should-not (eq foo :evald))))))))
 620     (check-eval "never" nil)
 621     (check-eval "no" nil)
 622     (check-eval "never-export" t)
 623     (check-eval "no-export" t)
 624     (let ((org-current-export-file "something"))
 625       (check-eval "never" nil)
 626       (check-eval "no" nil)
 627       (check-eval "never-export" nil)
 628       (check-eval "no-export" nil))))
 629
 630 (ert-deftest test-ob/noweb-expansion-1 ()
 631   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 632   <<foo>>
 633 #+end_src
 634
 635 #+name: foo
 636 #+begin_src sh
 637   bar
 638 #+end_src"
 639     (should (string= (org-babel-expand-noweb-references) "bar"))))
 640
 641 (ert-deftest test-ob/noweb-expansion-2 ()
 642   (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
 643   <<foo>>
 644 #+end_src
 645
 646 #+name: foo
 647 #+begin_src sh :noweb-sep \"\"
 648   bar
 649 #+end_src
 650
 651 #+begin_src sh :noweb-ref foo :noweb-sep \"\"
 652   baz
 653 #+end_src"
 654     (should (string= (org-babel-expand-noweb-references) "barbaz"))))
 655
 656 (ert-deftest test-ob/splitting-variable-lists-in-references ()
 657   (org-test-with-temp-text ""
 658     (should (= 1 (length (org-babel-ref-split-args
 659                           "a=\"this, no work\""))))
 660     (should (= 2 (length (org-babel-ref-split-args
 661                           "a=\"this, no work\", b=1"))))))
 662
 663 (ert-deftest test-ob/org-babel-balanced-split ()
 664   (should (equal
 665            '(":a 1" "b [2 3]" "c (4 :d (5 6))")
 666            (org-babel-balanced-split ":a 1 :b [2 3] :c (4 :d (5 6))"
 667                                      '((32 9) . 58)))))
 668
 669 (ert-deftest test-ob/commented-last-block-line-no-var ()
 670   (org-test-with-temp-text-in-file "
 671 #+begin_src emacs-lisp
 672 ;;
 673 #+end_src"
 674     (progn
 675       (org-babel-next-src-block)
 676       (org-ctrl-c-ctrl-c)
 677       (should (re-search-forward "\\#\\+results:" nil t))
 678       (forward-line)
 679       (should
 680        (string=
 681         ""
 682         (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 683   (org-test-with-temp-text-in-file "
 684 #+begin_src emacs-lisp
 685 \"some text\";;
 686 #+end_src"
 687
 688     (progn
 689       (org-babel-next-src-block)
 690       (org-ctrl-c-ctrl-c)
 691       (should (re-search-forward "\\#\\+results:" nil t))
 692       (forward-line)
 693       (should
 694        (string=
 695         ": some text"
 696         (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))))
 697
 698 (ert-deftest test-ob/commented-last-block-line-with-var ()
 699   (org-test-with-temp-text-in-file "
 700 #+begin_src emacs-lisp :var a=1
 701 ;;
 702 #+end_src"
 703     (progn
 704       (org-babel-next-src-block)
 705       (org-ctrl-c-ctrl-c)
 706       (re-search-forward "\\#\\+results:" nil t)
 707       (forward-line)
 708       (should (string=
 709                ""
 710                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 711   (org-test-with-temp-text-in-file "
 712 #+begin_src emacs-lisp :var a=2
 713 2;;
 714 #+end_src"
 715     (progn
 716       (org-babel-next-src-block)
 717       (org-ctrl-c-ctrl-c)
 718       (re-search-forward "\\#\\+results:" nil t)
 719       (forward-line)
 720       (should (string=
 721                ": 2"
 722                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))))
 723
 724 (defun test-ob-verify-result-and-removed-result (result buffer-text)
 725   "Test helper function to test `org-babel-remove-result'.
 726 A temp buffer is populated with BUFFER-TEXT, the first block is executed,
 727 and the result of execution is verified against RESULT.
 728
 729 The block is actually executed /twice/ to ensure result
 730 replacement happens correctly."
 731   (org-test-with-temp-text
 732       buffer-text
 733     (progn
 734       (org-babel-next-src-block) (org-ctrl-c-ctrl-c) (org-ctrl-c-ctrl-c)
 735       (should (re-search-forward "\\#\\+results:" nil t))
 736       (forward-line)
 737       (should (string= result
 738                        (buffer-substring-no-properties
 739                         (point-at-bol)
 740                         (- (point-max) 16))))
 741       (org-babel-previous-src-block) (org-babel-remove-result)
 742       (should (string= buffer-text
 743                        (buffer-substring-no-properties
 744                         (point-min) (point-max)))))))
 745
 746 (ert-deftest test-ob/org-babel-remove-result--results-default ()
 747   "Test `org-babel-remove-result' with default :results."
 748   (mapcar (lambda (language)
 749             (test-ob-verify-result-and-removed-result
 750              "\n"
 751              (concat
 752 "* org-babel-remove-result
 753 #+begin_src " language "
 754 #+end_src
 755
 756 * next heading")))
 757           '("sh" "emacs-lisp")))
 758
 759 (ert-deftest test-ob/org-babel-remove-result--results-list ()
 760   "Test `org-babel-remove-result' with :results list."
 761   (test-ob-verify-result-and-removed-result
 762    "- 1
 763 - 2
 764 - 3
 765 - (quote (4 5))"
 766
 767 "* org-babel-remove-result
 768 #+begin_src emacs-lisp :results list
 769 '(1 2 3 '(4 5))
 770 #+end_src
 771
 772 * next heading"))
 773
 774 (ert-deftest test-ob/org-babel-remove-result--results-wrap ()
 775   "Test `org-babel-remove-result' with :results wrap."
 776   (test-ob-verify-result-and-removed-result
 777    ":RESULTS:
 778 hello there
 779 :END:"
 780
 781  "* org-babel-remove-result
 782
 783 #+begin_src emacs-lisp :results wrap
 784 \"hello there\"
 785 #+end_src
 786
 787 * next heading"))
 788
 789 (ert-deftest test-ob/org-babel-remove-result--results-org ()
 790   "Test `org-babel-remove-result' with :results org."
 791   (test-ob-verify-result-and-removed-result
 792    "#+BEGIN_ORG
 793 * heading
 794 ** subheading
 795 content
 796 #+END_ORG"
 797
 798 "* org-babel-remove-result
 799 #+begin_src emacs-lisp :results org
 800 \"* heading
 801 ** subheading
 802 content\"
 803 #+end_src
 804
 805 * next heading"))
 806
 807 (ert-deftest test-ob/org-babel-remove-result--results-html ()
 808   "Test `org-babel-remove-result' with :results html."
 809   (test-ob-verify-result-and-removed-result
 810    "#+BEGIN_HTML
 811 <head><body></body></head>
 812 #+END_HTML"
 813
 814 "* org-babel-remove-result
 815 #+begin_src emacs-lisp :results html
 816 \"<head><body></body></head>\"
 817 #+end_src
 818
 819 * next heading"))
 820
 821 (ert-deftest test-ob/org-babel-remove-result--results-latex ()
 822   "Test `org-babel-remove-result' with :results latex."
 823   (test-ob-verify-result-and-removed-result
 824    "#+BEGIN_LaTeX
 825 Line 1
 826 Line 2
 827 Line 3
 828 #+END_LaTeX"
 829
 830 "* org-babel-remove-result
 831 #+begin_src emacs-lisp :results latex
 832 \"Line 1
 833 Line 2
 834 Line 3\"
 835 #+end_src
 836
 837 * next heading"))
 838
 839 (ert-deftest test-ob/org-babel-remove-result--results-code ()
 840   "Test `org-babel-remove-result' with :results code."
 841
 842   (test-ob-verify-result-and-removed-result
 843    "#+BEGIN_SRC emacs-lisp
 844 \"I am working!\"
 845 #+END_SRC"
 846
 847 "* org-babel-remove-result
 848 #+begin_src emacs-lisp :results code
 849 (message \"I am working!\")
 850 #+end_src
 851
 852 * next heading"))
 853
 854 (ert-deftest test-ob/org-babel-remove-result--results-pp ()
 855   "Test `org-babel-remove-result' with :results pp."
 856   (test-ob-verify-result-and-removed-result
 857    ": \"I /am/ working!\""
 858
 859 "* org-babel-remove-result
 860 #+begin_src emacs-lisp :results pp
 861 \"I /am/ working!\")
 862 #+end_src
 863
 864 * next heading"))
 865
 866 (ert-deftest test-org-babel/inline-src_blk-preceded-punct-preceded-by-point ()
 867   (let ((test-line ".src_emacs-lisp[ :results verbatim ]{ \"x\"  }"))
 868     (org-test-with-temp-text
 869         test-line
 870       (forward-char 1)
 871       (org-ctrl-c-ctrl-c)
 872       (should (re-search-forward "=\"x\"=" nil t))
 873       (forward-line))))
 874
 875 (ert-deftest test-ob/commented-last-block-line-with-var ()
 876   (org-test-with-temp-text-in-file "
 877 #+begin_src emacs-lisp :var a=1
 878 ;;
 879 #+end_src"
 880     (progn
 881       (org-babel-next-src-block)
 882       (org-ctrl-c-ctrl-c)
 883       (re-search-forward "\\#\\+results:" nil t)
 884       (forward-line)
 885       (should (string=
 886                ""
 887                (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
 888   (org-test-with-temp-text-in-file "
 889 #+begin_src emacs-lisp :var a=2
 890 2;;
 891 #+end_src"
 892     (progn
 893       (org-babel-next-src-block)
 894       (org-ctrl-c-ctrl-c)
 895       (re-search-forward "\\#\\+results:" nil t)
 896       (forward-line)
 897       (should (string=
 898                ": 2"
 899                (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))))
 900
 901 (defun test-ob-verify-result-and-removed-result (result buffer-text)
 902   "Test helper function to test `org-babel-remove-result'.
 903 A temp buffer is populated with BUFFER-TEXT, the first block is executed,
 904 and the result of execution is verified against RESULT.
 905
 906 The block is actually executed /twice/ to ensure result
 907 replacement happens correctly."
 908   (org-test-with-temp-text
 909       buffer-text
 910     (progn
 911       (org-babel-next-src-block) (org-ctrl-c-ctrl-c) (org-ctrl-c-ctrl-c)
 912       (should (re-search-forward "\\#\\+results:" nil t))
 913       (forward-line)
 914       (should (string= result
 915                        (buffer-substring-no-properties
 916                         (point-at-bol)
 917                         (- (point-max) 16))))
 918       (org-babel-previous-src-block) (org-babel-remove-result)
 919       (should (string= buffer-text
 920                        (buffer-substring-no-properties
 921                         (point-min) (point-max)))))))
 922
 923 (ert-deftest test-ob/org-babel-remove-result--results-default ()
 924   "Test `org-babel-remove-result' with default :results."
 925   (mapcar (lambda (language)
 926             (test-ob-verify-result-and-removed-result
 927              "\n"
 928              (concat
 929 "* org-babel-remove-result
 930 #+begin_src " language "
 931 #+end_src
 932
 933 * next heading")))
 934           '("sh" "emacs-lisp")))
 935
 936 (ert-deftest test-ob/org-babel-remove-result--results-list ()
 937   "Test `org-babel-remove-result' with :results list."
 938   (test-ob-verify-result-and-removed-result
 939    "- 1
 940 - 2
 941 - 3
 942 - (quote (4 5))"
 943
 944 "* org-babel-remove-result
 945 #+begin_src emacs-lisp :results list
 946 '(1 2 3 '(4 5))
 947 #+end_src
 948
 949 * next heading"))
 950
 951 (ert-deftest test-ob/org-babel-remove-result--results-wrap ()
 952   "Test `org-babel-remove-result' with :results wrap."
 953   (test-ob-verify-result-and-removed-result
 954    ":RESULTS:
 955 hello there
 956 :END:"
 957
 958  "* org-babel-remove-result
 959
 960 #+begin_src emacs-lisp :results wrap
 961 \"hello there\"
 962 #+end_src
 963
 964 * next heading"))
 965
 966 (ert-deftest test-ob/org-babel-remove-result--results-org ()
 967   "Test `org-babel-remove-result' with :results org."
 968   (test-ob-verify-result-and-removed-result
 969    "#+BEGIN_ORG
 970 * heading
 971 ** subheading
 972 content
 973 #+END_ORG"
 974
 975 "* org-babel-remove-result
 976 #+begin_src emacs-lisp :results org
 977 \"* heading
 978 ** subheading
 979 content\"
 980 #+end_src
 981
 982 * next heading"))
 983
 984 (ert-deftest test-ob/org-babel-remove-result--results-html ()
 985   "Test `org-babel-remove-result' with :results html."
 986   (test-ob-verify-result-and-removed-result
 987    "#+BEGIN_HTML
 988 <head><body></body></head>
 989 #+END_HTML"
 990
 991 "* org-babel-remove-result
 992 #+begin_src emacs-lisp :results html
 993 \"<head><body></body></head>\"
 994 #+end_src
 995
 996 * next heading"))
 997
 998 (ert-deftest test-ob/org-babel-remove-result--results-latex ()
 999   "Test `org-babel-remove-result' with :results latex."
1000   (test-ob-verify-result-and-removed-result
1001    "#+BEGIN_LaTeX
1002 Line 1
1003 Line 2
1004 Line 3
1005 #+END_LaTeX"
1006
1007 "* org-babel-remove-result
1008 #+begin_src emacs-lisp :results latex
1009 \"Line 1
1010 Line 2
1011 Line 3\"
1012 #+end_src
1013
1014 * next heading"))
1015
1016 (ert-deftest test-ob/org-babel-remove-result--results-code ()
1017   "Test `org-babel-remove-result' with :results code."
1018
1019   (test-ob-verify-result-and-removed-result
1020    "#+BEGIN_SRC emacs-lisp
1021 \"I am working!\"
1022 #+END_SRC"
1023
1024 "* org-babel-remove-result
1025 #+begin_src emacs-lisp :results code
1026 (message \"I am working!\")
1027 #+end_src
1028
1029 * next heading"))
1030
1031 (ert-deftest test-ob/org-babel-remove-result--results-pp ()
1032   "Test `org-babel-remove-result' with :results pp."
1033   (test-ob-verify-result-and-removed-result
1034    ": \"I /am/ working!\""
1035
1036 "* org-babel-remove-result
1037 #+begin_src emacs-lisp :results pp
1038 \"I /am/ working!\")
1039 #+end_src
1040
1041 * next heading"))
1042
1043 (provide 'test-ob)
1044
1045 ;;; test-ob ends here