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