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