1 ;;; test-ob.el --- tests for ob.el
3 ;; Copyright (c) 2010-2015 Eric Schulte
4 ;; Authors: Eric Schulte, Martyn Jago
6 ;; This file is not part of GNU Emacs.
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.
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.
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/>.
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?
28 org-babel-multi-line-header-regexp
29 " \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))
32 "blah1 blah2 blah3 \t"
35 " \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n")))
37 ;;TODO Check - should this fail?
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"))))
43 (ert-deftest test-org-babel
/src-block-regexp
()
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"
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
)))
62 (should (org-test-string-exact-match
63 org-babel-src-block-regexp
64 (replace-regexp-in-string flags
"" test-block
)))
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
)))))
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"))
79 org-babel-default-header-args
:session
)))
80 (should(equal '((:session .
"none"))
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"))
87 org-babel-default-header-args
:tangle
)))
89 (should (equal org-babel-default-header-args
91 org-babel-default-header-args
:doesnt-exist
'others
)))
92 (should (equal org-babel-default-header-args
94 org-babel-default-header-args nil
'others
)))
98 org-babel-default-header-args
:noweb
'others
)))))
100 (ert-deftest test-org-babel
/default-inline-header-args
()
102 '((:session .
"none")
103 (:results .
"replace")
104 (:exports .
"results")
106 org-babel-default-inline-header-args
)))
108 (ert-deftest ob-test
/org-babel-combine-header-arg-lists
()
109 (let ((results (org-babel-combine-header-arg-lists
112 (baz .
((foo bar
) (baz)))
113 (qux .
((foo bar baz qux
)))
114 (quux .
((foo bar
))))
118 (dolist (pair '((foo .
:any
)
122 (qux .
((foo bar baz qux
)))))
123 (should (equal (cdr pair
)
124 (cdr (assoc (car pair
) results
)))))))
126 ;;; ob-get-src-block-info
127 (ert-deftest test-org-babel
/get-src-block-info-language
()
128 (org-test-at-marker nil org-test-file-ob-anchor
129 (let ((info (org-babel-get-src-block-info)))
130 (should (string= "emacs-lisp" (nth 0 info
))))))
132 (ert-deftest test-org-babel
/get-src-block-info-body
()
133 (org-test-at-marker nil org-test-file-ob-anchor
134 (let ((info (org-babel-get-src-block-info)))
135 (should (string-match (regexp-quote org-test-file-ob-anchor
)
138 (ert-deftest test-org-babel
/get-src-block-info-tangle
()
139 (org-test-at-marker nil org-test-file-ob-anchor
140 (let ((info (org-babel-get-src-block-info)))
141 (should (string= "no" (cdr (assoc :tangle
(nth 2 info
))))))))
143 (ert-deftest test-org-babel
/elisp-in-header-arguments
()
144 "Test execution of elisp forms in header arguments."
145 (org-test-with-temp-text-in-file "
147 * elisp forms in header arguments
151 #+begin_src emacs-lisp
154 (goto-char (point-min))
155 (org-babel-next-src-block)
156 (let ((info (org-babel-get-src-block-info)))
157 (should (= 42 (org-babel-execute-src-block))))))
159 (ert-deftest test-org-babel
/simple-named-code-block
()
160 "Test that simple named code blocks can be evaluated."
161 (org-test-with-temp-text-in-file "
163 #+name: i-have-a-name
164 #+begin_src emacs-lisp
167 (org-babel-next-src-block 1)
168 (should (= 42 (org-babel-execute-src-block)))))
170 (ert-deftest test-org-babel
/simple-variable-resolution
()
171 "Test that simple variable resolution is working."
172 (org-test-with-temp-text-in-file "
175 #+begin_src emacs-lisp
179 #+begin_src emacs-lisp :var four=four
183 (org-babel-next-src-block 2)
184 (should (= 4 (org-babel-execute-src-block)))
186 (should (string= ": 4" (buffer-substring
190 (ert-deftest test-org-babel
/multi-line-header-arguments
()
191 "Test that multi-line header arguments and can be read."
192 (org-test-with-temp-text-in-file "
194 #+headers: :var letters='(a b c d e f g)
195 #+begin_src emacs-lisp :var numbers='(1 2 3 4 5 6 7)
197 (defalias 'my-map (if (org-version-check \"24.2.50\" \"cl\" :predicate)
200 (my-map 'list #'list numbers letters)
203 (org-babel-next-src-block)
204 (let ((results (org-babel-execute-src-block)))
205 (should(equal 'a
(cadr (assoc 1 results
))))
206 (should(equal 'd
(cadr (assoc 4 results
)))))))
208 (ert-deftest test-org-babel
/parse-header-args
()
209 (org-test-with-temp-text-in-file "
211 #+begin_src example-lang :session :results output :var num=9
215 (org-babel-next-src-block)
216 (let* ((info (org-babel-get-src-block-info))
217 (params (nth 2 info
)))
218 (message "%S" params
)
219 (should (equal "example-lang" (nth 0 info
)))
220 (should (string= "the body" (org-babel-trim (nth 1 info
))))
221 (should-not (member '(:session\ \ \ \
) params
))
222 (should (equal '(:session
) (assoc :session params
)))
223 (should (equal '(:result-type . output
) (assoc :result-type params
)))
224 (should (equal '(num .
9) (cdr (assoc :var params
)))))))
226 (ert-deftest test-org-babel
/parse-header-args2
()
227 (org-test-with-temp-text-in-file "
229 * resolving sub-trees as references
231 #+begin_src emacs-lisp :var text=d4faa7b3-072b-4dcf-813c-dd7141c633f3
235 #+begin_src org :noweb yes
237 <<d4faa7b3-072b-4dcf-813c-dd7141c633f3>>
240 ** simple subtree with custom ID
242 :CUSTOM_ID: simple-subtree
246 (should (string-match (regexp-quote "this is simple")
247 (org-babel-ref-resolve "simple-subtree")))
248 (org-babel-next-src-block)
249 (should (= 14 (org-babel-execute-src-block)))))
251 (ert-deftest test-org-babel
/inline-src-blocks
()
252 (macrolet ((at-next (&rest body
)
255 (re-search-forward org-babel-inline-src-block-regexp nil t
)
256 (goto-char (match-beginning 1))
257 (save-match-data ,@body
))))
259 "54cb8dc3-298c-4883-a933-029b3c9d4b18"
260 (at-next (should (equal 1 (org-babel-execute-src-block))))
261 (at-next (should (equal 2 (org-babel-execute-src-block))))
262 (at-next (should (equal 3 (org-babel-execute-src-block)))))
264 "cd54fc88-1b6b-45b6-8511-4d8fa7fc8076"
265 (at-next (should (equal 1 (org-babel-execute-src-block))))
266 (at-next (should (equal 2 (org-babel-execute-src-block))))
267 (at-next (should (equal 3 (org-babel-execute-src-block))))
268 (at-next (should (equal 4 (org-babel-execute-src-block)))))))
270 (ert-deftest test-org-babel
/org-babel-get-inline-src-block-matches
()
271 (flet ((test-at-id (id)
274 (let ((test-point (point)))
275 (should (fboundp 'org-babel-get-inline-src-block-matches
))
276 (should (re-search-forward "src_" nil t
)) ;; 1
277 (should (org-babel-get-inline-src-block-matches))
278 (should (re-search-forward " b" nil
(point-at-bol))) ;; 1
279 (should-not (org-babel-get-inline-src-block-matches))
280 (should (re-search-forward "in" nil t
)) ;; 2
281 (should-not (org-babel-get-inline-src-block-matches))
282 (should (re-search-forward "echo" nil t
)) ;; 2
283 (should (org-babel-get-inline-src-block-matches))
284 (should (re-search-forward "blocks" nil t
)) ;; 3
285 (backward-char 7) ;; 3
286 (should (org-babel-get-inline-src-block-matches))
288 (should-not (org-babel-get-inline-src-block-matches))
289 (should (re-search-forward ":results" nil t
)) ;; 4
290 (should (org-babel-get-inline-src-block-matches))
292 (should-not (org-babel-get-inline-src-block-matches))))))
293 (test-at-id "0D0983D4-DE33-400A-8A05-A225A567BC74")
294 (test-at-id "d55dada7-de0e-4340-8061-787cccbedee5")))
296 (ert-deftest test-org-babel
/inline-src_blk-default-results-replace-line-1
()
297 (let ((test-line "src_sh{echo 1}")
298 (org-babel-inline-result-wrap "=%s="))
299 ;; src_ at bol line 1...
300 (org-test-with-temp-text
302 (goto-char (point-min)) (org-babel-execute-maybe)
304 (concat test-line
" {{{results(=1=)}}}")
305 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
306 (forward-char) (org-babel-execute-maybe)
308 (concat test-line
" {{{results(=1=)}}}")
309 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
310 (re-search-forward "{{{")
311 ;;(should-error (org-ctrl-c-ctrl-c))
312 (backward-char 4) ;; last char of block body
313 (org-babel-execute-maybe)
315 (concat test-line
" {{{results(=1=)}}}")
316 (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
317 ;; src_ follows space line 1...
318 (let ((test-line " src_emacs-lisp{ 1 }"))
319 (org-test-with-temp-text
321 (should-error (org-ctrl-c-ctrl-c))
322 (forward-char) (org-babel-execute-maybe)
324 (concat test-line
" {{{results(=1=)}}}")
325 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
326 (re-search-forward "{ 1 ") (org-babel-execute-maybe)
328 (concat test-line
" {{{results(=1=)}}}")
329 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
331 (should-error (org-ctrl-c-ctrl-c))
334 (ert-deftest test-org-babel
/inline-src_blk-default-results-replace-line-2
()
335 ;; src_ at bol line 2...
336 (let ((test-line " src_emacs-lisp{ \"x\" }")
337 (org-babel-inline-result-wrap "=%s="))
338 (org-test-with-temp-text
339 (concat "\n" test-line
)
340 (should-error (org-ctrl-c-ctrl-c))
341 (goto-char (point-min))
342 (should-error (org-ctrl-c-ctrl-c))
344 (should-error (org-ctrl-c-ctrl-c))
345 (forward-char) (org-babel-execute-maybe)
347 (concat test-line
" {{{results(=x=)}}}")
348 (buffer-substring-no-properties
349 (point-at-bol) (point-at-eol))))))
350 (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }")
351 (org-babel-inline-result-wrap "=%s="))
352 (org-test-with-temp-text
354 (goto-char (point-max))
355 (insert (concat "\n" test-line
" end"))
356 (re-search-backward "src") (org-babel-execute-maybe)
358 (concat test-line
" {{{results(=y=)}}} end")
359 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
360 (re-search-forward "\" ") (org-babel-execute-maybe)
362 (concat test-line
" {{{results(=y=)}}} end")
363 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
365 (should-error (org-ctrl-c-ctrl-c)))))
367 (ert-deftest test-org-babel
/inline-src_blk-manual-results-replace
()
368 (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }")
369 (org-babel-inline-result-wrap "=%s="))
370 (org-test-with-temp-text
371 (concat "\n" test-line
)
372 (should-error (org-ctrl-c-ctrl-c))
373 (goto-char (point-max))
374 (org-babel-execute-maybe)
376 (should-error (org-ctrl-c-ctrl-c))
377 (forward-char) (org-babel-execute-maybe)
379 (concat test-line
" {{{results(=x=)}}}")
380 (buffer-substring-no-properties
381 (point-at-bol) (point-at-eol))))))
382 (let ((test-line (concat " Some text prior to block "
383 "src_emacs-lisp[:results replace]{ \"y\" }"))
384 (org-babel-inline-result-wrap "=%s="))
385 (org-test-with-temp-text test-line
386 (goto-char (point-max))
387 (insert (concat "\n" test-line
" end"))
388 (re-search-backward "src") (org-babel-execute-maybe)
390 (concat test-line
" {{{results(=y=)}}} end")
391 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
392 (re-search-forward "\" ") (org-babel-execute-maybe)
394 (concat test-line
" {{{results(=y=)}}} end")
395 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
397 (should-error (org-ctrl-c-ctrl-c)))))
399 (ert-deftest test-org-babel
/inline-src_blk-results-silent
()
400 (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
401 (org-test-with-temp-text test-line
402 (org-babel-execute-maybe)
403 (should (string= test-line
404 (buffer-substring-no-properties
405 (point-at-bol) (point-at-eol))))))
406 (let ((test-line (concat " Some text prior to block src_emacs-lisp"
407 "[ :results silent ]{ \"y\" }")))
408 (org-test-with-temp-text
410 (goto-char (point-max))
411 (insert (concat "\n" test-line
" end"))
412 (re-search-backward "src_") (org-babel-execute-maybe)
413 (should (string= (concat test-line
" end")
414 (buffer-substring-no-properties
415 (point-at-bol) (point-at-eol))))
416 (re-search-forward "\" ") (org-babel-execute-maybe)
417 (should (string= (concat test-line
" end")
418 (buffer-substring-no-properties
419 (point-at-bol) (point-at-eol))))
421 (should-error (org-ctrl-c-ctrl-c)))))
423 (ert-deftest test-org-babel
/inline-src_blk-results-raw
()
424 (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
425 (org-test-with-temp-text test-line
426 (org-babel-execute-maybe)
427 (should (string= (concat test-line
" x")
429 (let ((test-line (concat " Some text prior to block "
430 "src_emacs-lisp[ :results raw ]{ \"the\" }")))
431 (org-test-with-temp-text (concat test-line
" end")
432 (re-search-forward "src_") (org-babel-execute-maybe)
433 (should (string= (concat test-line
" the end")
434 (buffer-substring-no-properties
435 (point-at-bol) (point-at-eol))))
436 (re-search-forward "\" ") (org-babel-execute-maybe)
437 (should (string= (concat test-line
" the the end")
438 (buffer-substring-no-properties
439 (point-at-bol) (point-at-eol))))
441 (should-error (org-ctrl-c-ctrl-c)))))
443 (ert-deftest test-org-babel
/inline-src_blk-results-file
()
444 (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\" }"))
445 (org-test-with-temp-text
447 (org-babel-execute-maybe)
448 (should (string= (concat test-line
" {{{results([[file:~/test-file]])}}}")
449 (buffer-substring-no-properties
450 (point-min) (point-max)))))))
452 (ert-deftest test-org-babel
/inline-src_blk-results-scalar
()
453 (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\" }")
454 (org-babel-inline-result-wrap "=%s="))
455 (org-test-with-temp-text
457 (org-babel-execute-maybe)
458 (should (string= (concat test-line
" {{{results(=\"x\"=)}}}")
459 (buffer-substring-no-properties
460 (point-min) (point-max)))))))
462 (ert-deftest test-org-babel
/inline-src_blk-results-verbatim
()
463 (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\" }")
464 (org-babel-inline-result-wrap "=%s="))
465 (org-test-with-temp-text
467 (org-babel-execute-maybe)
468 (should (string= (concat test-line
" {{{results(=\"x\"=)}}}")
469 (buffer-substring-no-properties
470 (point-min) (point-max)))))))
472 (ert-deftest test-org-babel
/combining-scalar-and-raw-result-types
()
473 (org-test-with-temp-text-in-file "
475 #+begin_src sh :results scalar
476 echo \"[[file:./cv.cls]]\"
482 #+begin_src sh :results raw scalar
483 echo \"[[file:./cv.cls]]\"
486 (flet ((next-result ()
487 (org-babel-next-src-block)
488 (org-babel-execute-src-block)
489 (goto-char (org-babel-where-is-src-block-result))
491 (goto-char (point-min))
493 (should (org-babel-in-example-or-verbatim))
495 (should (not (org-babel-in-example-or-verbatim))))))
497 (ert-deftest test-org-babel
/no-defaut-value-for-var
()
498 "Test that the absence of a default value for a variable DOES THROW
500 (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
501 (org-babel-next-src-block)
503 (should-error (org-babel-execute-src-block) :type
'error
)))
507 "Variable \"x\" must be assigned a default value")
510 (ert-deftest test-org-babel
/just-one-results-block
()
511 "Test that evaluating two times the same code block does not result in a
512 duplicate results block."
513 (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
514 (org-babel-execute-src-block)
515 (org-babel-execute-src-block) ; second code block execution
516 (should (search-forward "Hello")) ; the string inside the source code block
517 (should (search-forward "Hello")) ; the same string in the results block
518 (should-error (search-forward "Hello"))))
520 (ert-deftest test-org-babel
/nested-code-block
()
521 "Test nested code blocks inside code blocks don't cause problems."
523 (string= "#+begin_src emacs-lisp\n 'foo\n#+end_src"
524 (org-test-with-temp-text "#+begin_src org :results silent
525 ,#+begin_src emacs-lisp
529 (let ((org-edit-src-content-indentation 2)
530 (org-src-preserve-indentation nil
))
531 (org-babel-execute-src-block))))))
533 (ert-deftest test-org-babel
/partial-nested-code-block
()
534 "Test nested code blocks inside code blocks don't cause problems."
535 (org-test-with-temp-text "#+begin_src org :results silent
536 ,#+begin_src emacs-lisp
538 (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
540 (ert-deftest test-ob
/does-not-replace-a-block-with-the-results
()
541 (org-test-with-temp-text "#+NAME: foo
542 #+BEGIN_SRC emacs-lisp
545 (org-babel-next-src-block 1)
546 (should (eq 'foo
(org-babel-execute-src-block)))
547 (goto-char (point-min))
548 (org-babel-next-src-block 1)
549 (should (looking-at org-babel-src-block-regexp
))))
551 (ert-deftest test-ob
/catches-all-references
()
552 (org-test-with-temp-text "
553 #+NAME: literal-example
559 #+NAME: read-literal-example
560 #+BEGIN_SRC emacs-lisp :var x=literal-example
561 (concatenate 'string x \" for me.\")
563 (org-babel-next-src-block 1)
564 (should (string= (org-babel-execute-src-block)
565 "A literal example\non two lines\n for me."))))
567 (ert-deftest test-ob
/resolve-code-blocks-before-data-blocks
()
568 (org-test-with-temp-text "
573 #+begin_src emacs-lisp
577 #+begin_src emacs-lisp :var foo=foo
580 (org-babel-next-src-block 2)
581 (should (string= (org-babel-execute-src-block) "baz"))))
583 (ert-deftest test-ob
/do-not-resolve-to-partial-names-data
()
584 (org-test-with-temp-text "
593 #+begin_src emacs-lisp :var x=base
596 (org-babel-next-src-block 1)
597 (should (equal (org-babel-execute-src-block) '((3) (4))))))
599 (ert-deftest test-ob
/do-not-resolve-to-partial-names-code
()
600 (org-test-with-temp-text "
602 #+begin_src emacs-lisp
607 #+begin_src emacs-lisp
611 #+begin_src emacs-lisp :var x=base
614 (org-babel-next-src-block 3)
615 (should (equal (org-babel-execute-src-block) "foo"))))
617 (ert-deftest test-ob
/allow-spaces-around-
=-in-var-specs
()
618 (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
622 (should (= 10 (org-babel-execute-src-block)))))
624 (ert-deftest test-ob
/org-babel-update-intermediate
()
625 (org-test-with-temp-text "#+name: foo
626 #+begin_src emacs-lisp
633 #+begin_src emacs-lisp :var it=foo
636 (let ((org-babel-update-intermediate nil
))
637 (goto-char (point-min))
638 (org-babel-next-src-block 2)
639 (should (= 3 (org-babel-execute-src-block)))
640 (goto-char (point-min))
642 (should (looking-at ": 4")))
643 (let ((org-babel-update-intermediate t
))
644 (goto-char (point-min))
645 (org-babel-next-src-block 2)
646 (should (= 3 (org-babel-execute-src-block)))
647 (goto-char (point-min))
649 (should (looking-at ": 2")))))
651 (ert-deftest test-ob
/eval-header-argument
()
652 (flet ((check-eval (eval runp
)
653 (org-test-with-temp-text (format "#+begin_src emacs-lisp :eval %s
656 (let ((foo :not-run
))
658 (progn (should (org-babel-execute-src-block))
659 (should (eq foo
:evald
)))
660 (progn (should-not (org-babel-execute-src-block))
661 (should-not (eq foo
:evald
))))))))
662 (check-eval "never" nil
)
663 (check-eval "no" nil
)
664 (check-eval "never-export" t
)
665 (check-eval "no-export" t
)
666 (let ((org-babel-exp-reference-buffer (current-buffer)))
667 (check-eval "never" nil
)
668 (check-eval "no" nil
)
669 (check-eval "never-export" nil
)
670 (check-eval "no-export" nil
))))
672 (ert-deftest test-ob
/noweb-expansion-1
()
673 (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
681 (should (string= (org-babel-expand-noweb-references) "bar"))))
683 (ert-deftest test-ob
/noweb-expansion-2
()
684 (org-test-with-temp-text "#+begin_src sh :results output :tangle yes
689 #+begin_src sh :noweb-sep \"\"
693 #+begin_src sh :noweb-ref foo :noweb-sep \"\"
696 (should (string= (org-babel-expand-noweb-references) "barbaz"))))
698 (ert-deftest test-ob
/splitting-variable-lists-in-references
()
699 (org-test-with-temp-text ""
700 (should (= 1 (length (org-babel-ref-split-args
701 "a=\"this, no work\""))))
702 (should (= 2 (length (org-babel-ref-split-args
703 "a=\"this, no work\", b=1"))))))
705 (ert-deftest test-ob
/org-babel-balanced-split
()
707 '(":a 1" "b [2 3]" "c (4 :d (5 6))")
708 (org-babel-balanced-split ":a 1 :b [2 3] :c (4 :d (5 6))"
711 (ert-deftest test-ob
/commented-last-block-line-no-var
()
712 (org-test-with-temp-text-in-file "
713 #+begin_src emacs-lisp
716 (org-babel-next-src-block)
717 (org-babel-execute-maybe)
718 (should (re-search-forward "\\#\\+results:" nil t
))
723 (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
724 (org-test-with-temp-text-in-file "
725 #+begin_src emacs-lisp
728 (org-babel-next-src-block)
729 (org-babel-execute-maybe)
730 (should (re-search-forward "\\#\\+results:" nil t
))
735 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
737 (ert-deftest test-ob
/commented-last-block-line-with-var
()
738 (org-test-with-temp-text-in-file "
739 #+begin_src emacs-lisp :var a=1
742 (org-babel-next-src-block)
743 (org-babel-execute-maybe)
744 (re-search-forward "\\#\\+results:" nil t
)
748 (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
749 (org-test-with-temp-text-in-file "
750 #+begin_src emacs-lisp :var a=2
753 (org-babel-next-src-block)
754 (org-babel-execute-maybe)
755 (re-search-forward "\\#\\+results:" nil t
)
759 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
761 (ert-deftest test-ob
/remove-inline-result
()
762 "Test `org-babel-remove-inline-result' honors whitespace."
764 ((inline-sb "src_emacs-lisp{(+ 1 2)}")
765 (inline-res " {{{results(=3=)}}}")
766 (inline-sb-dot (concat inline-sb
"."))
767 (inline-sb-res-dot (concat inline-sb inline-res
".")))
768 (org-test-with-temp-text
769 ;; Insert inline_src_block followed by dot.
771 ;; Insert result before dot.
772 (org-babel-execute-maybe)
773 (should (string= inline-sb-res-dot
774 (buffer-substring-no-properties
775 (point-at-bol) (point-at-eol))))
776 ;; Delete whitespace and result.
777 (org-babel-remove-inline-result)
778 (should (string= inline-sb-dot
779 (buffer-substring-no-properties
780 (point-at-bol) (point-at-eol))))
781 ;; Add whitespace and result before dot.
782 (search-forward inline-sb
)
783 (insert " " inline-res
)
784 (goto-char (point-at-bol))
785 ;; Remove whitespace and result.
786 (org-babel-remove-inline-result)
787 (should (string= inline-sb-dot
788 (buffer-substring-no-properties
789 (point-at-bol) (point-at-eol))))
790 ;; Add whitespace before dot.
791 (search-forward inline-sb
)
793 (goto-char (point-at-bol))
794 ;; Add result before whitespace.
795 (org-babel-execute-maybe)
796 ;; Remove result - leave trailing whitespace and dot.
797 (org-babel-remove-inline-result)
798 (should (string= (concat inline-sb
" .")
799 (buffer-substring-no-properties
800 (point-at-bol) (point-at-eol)))))))
802 (defun test-ob-verify-result-and-removed-result (result buffer-text
)
803 "Test helper function to test `org-babel-remove-result'.
804 A temp buffer is populated with BUFFER-TEXT, the first block is executed,
805 and the result of execution is verified against RESULT.
807 The block is actually executed /twice/ to ensure result
808 replacement happens correctly."
809 (org-test-with-temp-text
811 (org-babel-next-src-block) (org-babel-execute-maybe) (org-babel-execute-maybe)
812 (should (re-search-forward "\\#\\+results:" nil t
))
814 (should (string= result
815 (buffer-substring-no-properties
817 (- (point-max) 16))))
818 (org-babel-previous-src-block) (org-babel-remove-result)
819 (should (string= buffer-text
820 (buffer-substring-no-properties
821 (point-min) (point-max))))))
823 (ert-deftest test-ob
/org-babel-remove-result--results-default
()
824 "Test `org-babel-remove-result' with default :results."
825 (mapcar (lambda (language)
826 (test-ob-verify-result-and-removed-result
829 "* org-babel-remove-result
830 #+begin_src " language
"
834 '("sh" "emacs-lisp")))
836 (ert-deftest test-ob
/org-babel-remove-result--results-list
()
837 "Test `org-babel-remove-result' with :results list."
838 (test-ob-verify-result-and-removed-result
844 "* org-babel-remove-result
845 #+begin_src emacs-lisp :results list
851 (ert-deftest test-ob
/org-babel-results-indented-wrap
()
852 "Ensure that wrapped results are inserted correction when indented.
853 If not inserted correctly then the second evaluation will fail
854 trying to find the :END: marker."
855 (org-test-with-temp-text
857 #+begin_src sh :results file wrap
860 (org-babel-next-src-block 1)
861 (org-babel-execute-src-block)
862 (org-babel-execute-src-block)))
864 (ert-deftest test-ob
/file-desc-header-argument
()
865 "Test that the :file-desc header argument is used."
866 (org-test-with-temp-text "#+begin_src emacs-lisp :results file :file-desc bar
870 #+begin_src emacs-lisp :results file :file-desc
873 (org-babel-execute-src-block)
874 (org-babel-next-src-block 1)
875 (org-babel-execute-src-block)
876 (goto-char (point-min))
877 (should (search-forward "[[file:foo][bar]]" nil t
))
878 (should (search-forward "[[file:foo][foo]]" nil t
))))
880 (ert-deftest test-ob
/org-babel-remove-result--results-pp
()
881 "Test `org-babel-remove-result' with :results pp."
882 (test-ob-verify-result-and-removed-result
883 ": \"I /am/ working!\""
885 "* org-babel-remove-result
886 #+begin_src emacs-lisp :results pp
892 (ert-deftest test-org-babel
/inline-src_blk-preceded-punct-preceded-by-point
()
893 (let ((test-line ".src_emacs-lisp[ :results verbatim ]{ \"x\" }")
894 (org-babel-inline-result-wrap "=%s="))
895 (org-test-with-temp-text
898 (org-babel-execute-maybe)
899 (should (re-search-forward "=\"x\"=" nil t
))
902 (ert-deftest test-ob
/commented-last-block-line-with-var
()
903 (org-test-with-temp-text-in-file "
904 #+begin_src emacs-lisp :var a=1
907 (org-babel-next-src-block)
908 (org-babel-execute-maybe)
909 (re-search-forward "\\#\\+results:" nil t
)
913 (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
914 (org-test-with-temp-text-in-file "
915 #+begin_src emacs-lisp :var a=2
918 (org-babel-next-src-block)
919 (org-babel-execute-maybe)
920 (re-search-forward "\\#\\+results:" nil t
)
924 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))))
926 (defun test-ob-verify-result-and-removed-result (result buffer-text
)
927 "Test helper function to test `org-babel-remove-result'.
928 A temp buffer is populated with BUFFER-TEXT, the first block is executed,
929 and the result of execution is verified against RESULT.
931 The block is actually executed /twice/ to ensure result
932 replacement happens correctly."
933 (org-test-with-temp-text
935 (org-babel-next-src-block) (org-babel-execute-maybe) (org-babel-execute-maybe)
936 (should (re-search-forward "\\#\\+results:" nil t
))
938 (should (string= result
939 (buffer-substring-no-properties
941 (- (point-max) 16))))
942 (org-babel-previous-src-block) (org-babel-remove-result)
943 (should (string= buffer-text
944 (buffer-substring-no-properties
945 (point-min) (point-max))))))
947 (ert-deftest test-ob
/org-babel-remove-result--results-default
()
948 "Test `org-babel-remove-result' with default :results."
949 (mapcar (lambda (language)
950 (test-ob-verify-result-and-removed-result
953 "* org-babel-remove-result
954 #+begin_src " language
"
958 '("sh" "emacs-lisp")))
960 (ert-deftest test-ob
/org-babel-remove-result--results-list
()
961 "Test `org-babel-remove-result' with :results list."
962 (test-ob-verify-result-and-removed-result
968 "* org-babel-remove-result
969 #+begin_src emacs-lisp :results list
975 (ert-deftest test-ob
/org-babel-remove-result--results-wrap
()
976 "Test `org-babel-remove-result' with :results wrap."
977 (test-ob-verify-result-and-removed-result
982 "* org-babel-remove-result
984 #+begin_src emacs-lisp :results wrap
990 (ert-deftest test-ob
/org-babel-remove-result--results-org
()
991 "Test `org-babel-remove-result' with :results org."
992 (test-ob-verify-result-and-removed-result
999 "* org-babel-remove-result
1000 #+begin_src emacs-lisp :results org
1008 (ert-deftest test-ob
/org-babel-remove-result--results-html
()
1009 "Test `org-babel-remove-result' with :results html."
1010 (test-ob-verify-result-and-removed-result
1012 <head><body></body></head>
1015 "* org-babel-remove-result
1016 #+begin_src emacs-lisp :results html
1017 \"<head><body></body></head>\"
1022 (ert-deftest test-ob
/org-babel-remove-result--results-latex
()
1023 "Test `org-babel-remove-result' with :results latex."
1024 (test-ob-verify-result-and-removed-result
1031 "* org-babel-remove-result
1032 #+begin_src emacs-lisp :results latex
1040 (ert-deftest test-ob
/org-babel-remove-result--results-code
()
1041 "Test `org-babel-remove-result' with :results code."
1043 (test-ob-verify-result-and-removed-result
1044 "#+BEGIN_SRC emacs-lisp
1048 "* org-babel-remove-result
1049 #+begin_src emacs-lisp :results code
1050 (message \"I am working!\")
1055 (ert-deftest test-ob
/org-babel-remove-result--results-pp
()
1056 "Test `org-babel-remove-result' with :results pp."
1057 (test-ob-verify-result-and-removed-result
1058 ": \"I /am/ working!\""
1060 "* org-babel-remove-result
1061 #+begin_src emacs-lisp :results pp
1062 \"I /am/ working!\")
1067 (ert-deftest test-ob
/results-do-not-replace-code-blocks
()
1068 (org-test-with-temp-text "Block two has a space after the name.
1071 #+begin_src emacs-lisp
1076 #+begin_src emacs-lisp
1081 #+begin_src emacs-lisp
1088 (dolist (num '(1 2 3))
1089 ;; execute the block
1090 (goto-char (point-min))
1091 (org-babel-next-src-block num
) (org-babel-execute-src-block)
1092 ;; check the results
1093 (goto-char (point-max))
1094 (move-beginning-of-line 0)
1095 (should (looking-at (format ": %d" num
))))))
1097 (ert-deftest test-ob
/blocks-with-spaces
()
1098 "Test expansion of blocks followed by blank lines."
1100 (equal "#+BEGIN_SRC emacs-lisp
1106 (org-test-with-temp-text "#+BEGIN_SRC emacs-lisp
1109 (let ((org-babel-next-src-block "RESULTS"))
1110 (org-babel-execute-src-block))
1113 (ert-deftest test-ob
/results-in-narrowed-buffer
()
1114 "Test block execution in a narrowed buffer."
1115 ;; If results don't exist, they should be inserted in visible part
1119 "#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\n#+RESULTS:\n: 3"
1120 (org-test-with-temp-text
1121 "#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\nParagraph"
1122 (narrow-to-region (point) (save-excursion (forward-line 3) (point)))
1123 (let ((org-babel-results-keyword "RESULTS"))
1124 (org-babel-execute-src-block))
1125 (org-trim (buffer-string)))))
1128 "#+NAME: test\n#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\n#+RESULTS: test\n: 3"
1129 (org-test-with-temp-text
1130 "#+NAME: test\n#+BEGIN_SRC emacs-lisp\n(+ 1 2)\n#+END_SRC\n\nParagraph"
1131 (narrow-to-region (point) (save-excursion (forward-line 4) (point)))
1132 (let ((org-babel-results-keyword "RESULTS"))
1133 (org-babel-execute-src-block))
1134 (org-trim (buffer-string)))))
1135 ;; Results in visible part of buffer, should be updated here.
1139 #+BEGIN_SRC emacs-lisp
1145 (org-test-with-temp-text
1147 #+BEGIN_SRC emacs-lisp
1155 (narrow-to-region (point) (save-excursion (forward-line 7) (point)))
1156 (let ((org-babel-results-keyword "RESULTS"))
1157 (org-babel-execute-src-block))
1158 (org-trim (buffer-string)))))
1159 ;; Results in invisible part of buffer, should be updated there.
1160 (org-test-with-temp-text
1162 #+BEGIN_SRC emacs-lisp
1170 (narrow-to-region (point) (save-excursion (forward-line 4) (point)))
1171 (let ((org-babel-results-keyword "RESULTS"))
1172 (org-babel-execute-src-block))
1173 (should-not (re-search-forward "^#\\+RESULTS:" nil t
))
1175 (should (should (re-search-forward "^: 3" nil t
)))))
1177 (ert-deftest test-ob
/specific-colnames
()
1178 "Test passing specific column names."
1180 (equal "#+name: input-table
1186 #+begin_src sh :var data=input-table :exports results :colnames '(Rev Author)
1197 (org-test-with-temp-text
1198 "#+name: input-table
1204 #+begin_src sh :var data=input-table :exports results :colnames '(Rev Author)
1208 ;; we should find a code block
1209 (should (re-search-forward org-babel-src-block-regexp nil t
))
1210 (goto-char (match-beginning 0))
1211 ;; now that we've located the code block, it may be evaluated
1212 (let ((org-babel-execute-src-block "RESULTS"))
1213 (org-babel-execute-src-block))
1216 (ert-deftest test-ob
/location-of-header-arg-eval
()
1217 "Test location of header argument evaluation."
1218 (org-test-with-temp-text "
1220 #+begin_src emacs-lisp :var pt=(point)
1224 #+name: bottom-block
1225 #+begin_src emacs-lisp :var pt=top-block()
1229 ;; the value of the second block should be greater than the first
1231 (< (progn (re-search-forward org-babel-src-block-regexp nil t
)
1232 (goto-char (match-beginning 0))
1233 (prog1 (save-match-data (org-babel-execute-src-block))
1234 (goto-char (match-end 0))))
1235 (progn (re-search-forward org-babel-src-block-regexp nil t
)
1236 (goto-char (match-beginning 0))
1237 (org-babel-execute-src-block))))))
1239 (ert-deftest test-ob
/preserve-results-indentation
()
1240 "Preserve indentation when executing a src block."
1243 (org-test-with-temp-text
1244 " #+begin_src emacs-lisp\n (+ 1 1)\n #+end_src"
1245 (org-babel-execute-src-block)
1247 (let ((case-fold-search t
)) (search-forward "#+results:"))
1248 ;; Check if both #+RESULTS: keyword and actual results are
1249 ;; indented by 2 columns.
1250 (list (org-get-indentation)
1251 (progn (forward-line) (org-get-indentation)))))))
1253 (ert-deftest test-ob
/safe-header-args
()
1254 "Detect safe and unsafe header args."
1255 (let ((safe-args '((:cache .
"foo")
1256 (:results .
"output")
1259 (unsafe-args '((:eval .
"yes")
1260 (:results .
"output file")
1262 (malformed-args '((bar .
"foo")
1265 (safe-p (org-babel-header-args-safe-fn org-babel-safe-header-args
)))
1266 (dolist (arg safe-args
)
1267 (should (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args
)))
1268 (dolist (arg unsafe-args
)
1269 (should (not (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args
))))
1270 (dolist (arg malformed-args
)
1271 (should (not (org-babel-one-header-arg-safe-p arg org-babel-safe-header-args
))))
1272 (should (not (funcall safe-p
(append safe-args unsafe-args
))))))
1274 (ert-deftest test-ob
/noweb-expansions-in-cache
()
1275 "Ensure that noweb expansions are expanded before caching."
1276 (let ((noweb-expansions-in-cache-var 0))
1277 (org-test-with-temp-text "
1279 #+begin_src emacs-lisp
1284 #+begin_src emacs-lisp :noweb yes :cache yes
1285 (setq noweb-expansions-in-cache-var
1286 (+ 1 noweb-expansions-in-cache-var))
1287 (concat <<foo>> \" check noweb expansions\")
1290 ;; run the second block to create the cache
1291 (goto-char (point-min))
1292 (re-search-forward (regexp-quote "#+name: bar"))
1293 (should (string= "I said check noweb expansions"
1294 (org-babel-execute-src-block)))
1295 (should (= noweb-expansions-in-cache-var
1))
1296 ;; change the value of the first block
1297 (goto-char (point-min))
1298 (re-search-forward (regexp-quote "said"))
1299 (goto-char (match-beginning 0))
1301 (re-search-forward (regexp-quote "#+name: bar"))
1302 (should (string= "I haven't said check noweb expansions"
1303 (org-babel-execute-src-block)))
1304 (should (= noweb-expansions-in-cache-var
2)))))
1306 (ert-deftest test-org-babel
/file-ext-and-output-dir
()
1307 (org-test-at-id "93573e1d-6486-442e-b6d0-3fedbdc37c9b"
1308 (org-babel-next-src-block)
1309 (should (equal "file-ext-basic.txt"
1310 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1311 (org-babel-next-src-block)
1312 (should (equal "foo/file-ext-dir-relative.txt"
1313 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1314 (org-babel-next-src-block)
1315 (should (equal "foo/file-ext-dir-relative-slash.txt"
1316 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1317 (org-babel-next-src-block)
1318 (should (equal "/tmp/file-ext-dir-absolute.txt"
1319 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1320 (org-babel-next-src-block)
1321 (should (equal "foo.bar"
1322 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1323 (org-babel-next-src-block)
1324 (should (equal "xxx/foo.bar"
1325 (cdr (assq :file
(nth 2 (org-babel-get-src-block-info t
))))))
1328 (ert-deftest test-org-babel
/script-escape
()
1329 ;; Delimited lists of numbers
1330 (should (equal '(1 2 3)
1331 (org-babel-script-escape "[1 2 3]")))
1332 (should (equal '(1 2 3)
1333 (org-babel-script-escape "{1 2 3}")))
1334 (should (equal '(1 2 3)
1335 (org-babel-script-escape "(1 2 3)")))
1336 ;; Delimited lists of double-quoted strings
1337 (should (equal '("foo" "bar")
1338 (org-babel-script-escape "(\"foo\" \"bar\")")))
1339 (should (equal '("foo" "bar")
1340 (org-babel-script-escape "[\"foo\" \"bar\"]")))
1341 (should (equal '("foo" "bar")
1342 (org-babel-script-escape "{\"foo\" \"bar\"}")))
1344 (should (equal '("foo" "bar")
1345 (org-babel-script-escape "(\"foo\", \"bar\")")))
1346 (should (equal '("foo" "bar")
1347 (org-babel-script-escape "[\"foo\", \"bar\"]")))
1348 (should (equal '("foo" "bar")
1349 (org-babel-script-escape "{\"foo\", \"bar\"}")))
1350 ;; Delimited lists of single-quoted strings
1351 (should (equal '("foo" "bar")
1352 (org-babel-script-escape "('foo' 'bar')")))
1353 (should (equal '("foo" "bar")
1354 (org-babel-script-escape "['foo' 'bar']")))
1355 (should (equal '("foo" "bar")
1356 (org-babel-script-escape "{'foo' 'bar'}")))
1358 (should (equal '("foo" "bar")
1359 (org-babel-script-escape "('foo', 'bar')")))
1360 (should (equal '("foo" "bar")
1361 (org-babel-script-escape "['foo', 'bar']")))
1362 (should (equal '("foo" "bar")
1363 (org-babel-script-escape "{'foo', 'bar'}")))
1364 ;; Single quoted strings
1365 (should (equal "foo"
1366 (org-babel-script-escape "'foo'")))
1367 ;; ... with internal double quote
1368 (should (equal "foo\"bar"
1369 (org-babel-script-escape "'foo\"bar'")))
1370 ;; ... with internal backslash
1371 (should (equal "foo\\bar"
1372 (org-babel-script-escape "'foo\\bar'")))
1373 ;; ... with internal escaped backslash
1374 (should (equal "foo\\bar"
1375 (org-babel-script-escape "'foo\\\\bar'")))
1376 ;; ... with internal backslash-double quote
1377 (should (equal "foo\\\"bar"
1378 (org-babel-script-escape "'foo\\\"bar'")))
1379 ;; ... with internal escaped backslash-double quote
1380 (should (equal "foo\\\"bar"
1381 (org-babel-script-escape "'foo\\\\\"bar'")))
1382 ;; ... with internal escaped single quote
1383 (should (equal "foo'bar"
1384 (org-babel-script-escape "'foo\\'bar'")))
1385 ;; ... with internal escaped backslash-escaped single quote
1386 (should (equal "foo\\'bar"
1387 (org-babel-script-escape "'foo\\\\\\'bar'")))
1388 ;; Double quoted strings
1389 (should (equal "foo"
1390 (org-babel-script-escape "\"foo\"")))
1391 ;; ... with internal single quote
1392 (should (equal "foo'bar"
1393 (org-babel-script-escape "\"foo'bar\"")))
1394 ;; ... with internal backslash
1395 (should (equal "foo\\bar"
1396 (org-babel-script-escape "\"foo\\bar\"")))
1397 ;; ... with internal escaped backslash
1398 (should (equal "foo\\bar"
1399 (org-babel-script-escape "\"foo\\\\bar\"")))
1400 ;; ... with internal backslash-single quote
1401 (should (equal "foo\\'bar"
1402 (org-babel-script-escape "\"foo\\'bar\"")))
1403 ;; ... with internal escaped backslash-single quote
1404 (should (equal "foo\\'bar"
1405 (org-babel-script-escape "\"foo\\\\'bar\"")))
1406 ;; ... with internal escaped double quote
1407 (should (equal "foo\"bar"
1408 (org-babel-script-escape "\"foo\\\"bar\"")))
1409 ;; ... with internal escaped backslash-escaped double quote
1410 (should (equal "foo\\\"bar"
1411 (org-babel-script-escape "\"foo\\\\\\\"bar\""))))
1415 ;;; test-ob ends here