1 ;;; test-ob.el --- tests for ob.el
3 ;; Copyright (c) 2010, 2011 Eric Schulte
4 ;; Authors: Eric Schulte, Martyn Jago
6 ;; Released under the GNU General Public License version 3
7 ;; see: http://www.gnu.org/licenses/gpl-3.0.html
9 (let ((load-path (cons (expand-file-name
10 ".." (file-name-directory
11 (or load-file-name buffer-file-name
)))
14 (require 'org-test-ob-consts
))
16 (ert-deftest test-org-babel
/multi-line-header-regexp
()
17 (should(equal "^[ \t]*#\\+headers?:[ \t]*\\([^\n]*\\)$"
18 org-babel-multi-line-header-regexp
))
19 ;;TODO can be optimised - and what about blah4 blah5 blah6?
21 org-babel-multi-line-header-regexp
22 " \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))
25 "blah1 blah2 blah3 \t"
28 " \t #+headers: blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n")))
30 ;;TODO Check - should this fail?
32 (not (org-test-string-exact-match
33 org-babel-multi-line-header-regexp
34 " \t #+headers : blah1 blah2 blah3 \t\n\t\n blah4 blah5 blah6 \n"))))
36 (ert-deftest test-org-babel
/src-block-regexp
()
39 "#+begin_src language -n-r-a-b -c :argument-1 yes :argument-2 no\n"
40 "echo this is a test\n"
41 "echo Currently in ' $PWD\n"
44 (flags "-n-r-a-b -c ")
45 (arguments ":argument-1 yes :argument-2 no")
46 (body "echo this is a test\necho Currently in ' $PWD\n"))
47 (should (string-match org-babel-src-block-regexp test-block
))
48 (should (string-match org-babel-src-block-regexp
(upcase test-block
)))
49 (should (equal language
(match-string 2 test-block
)))
50 ;;TODO Consider refactoring
51 (should (equal flags
(match-string 3 test-block
)))
52 (should (equal arguments
(match-string 4 test-block
)))
53 (should (equal body
(match-string 5 test-block
)))
55 (should (org-test-string-exact-match
56 org-babel-src-block-regexp
57 (replace-regexp-in-string flags
"" test-block
)))
59 (should (org-test-string-exact-match
60 org-babel-src-block-regexp
61 (replace-regexp-in-string arguments
"" test-block
)))
62 ;; should be valid with no body
63 (should (org-test-string-exact-match
64 org-babel-src-block-regexp
65 (replace-regexp-in-string body
"" test-block
)))))
67 (ert-deftest test-org-babel
/get-header
()
68 (should (not (org-babel-get-header
69 org-babel-default-header-args
:doesnt-exist
)))
70 (should(equal '((:session .
"none"))
72 org-babel-default-header-args
:session
)))
73 (should(equal '((:session .
"none"))
75 org-babel-default-header-args
:session nil
)))
76 (should (not (org-babel-get-header
77 org-babel-default-header-args
:SESSION
)))
78 (should (equal '((:tangle .
"no"))
80 org-babel-default-header-args
:tangle
)))
82 (should (equal org-babel-default-header-args
84 org-babel-default-header-args
:doesnt-exist
'others
)))
85 (should (equal org-babel-default-header-args
87 org-babel-default-header-args nil
'others
)))
91 org-babel-default-header-args
:noweb
'others
)))))
93 (ert-deftest test-org-babel
/default-inline-header-args
()
95 '((:session .
"none") (:results .
"replace") (:exports .
"results"))
96 org-babel-default-inline-header-args
)))
98 ;;; ob-get-src-block-info
99 (ert-deftest test-org-babel
/get-src-block-info-language
()
100 (org-test-at-marker nil org-test-file-ob-anchor
101 (let ((info (org-babel-get-src-block-info)))
102 (should (string= "emacs-lisp" (nth 0 info
))))))
104 (ert-deftest test-org-babel
/get-src-block-info-body
()
105 (org-test-at-marker nil org-test-file-ob-anchor
106 (let ((info (org-babel-get-src-block-info)))
107 (should (string-match (regexp-quote org-test-file-ob-anchor
)
110 (ert-deftest test-org-babel
/get-src-block-info-tangle
()
111 (org-test-at-marker nil org-test-file-ob-anchor
112 (let ((info (org-babel-get-src-block-info)))
113 (should (string= "no" (cdr (assoc :tangle
(nth 2 info
))))))))
115 (ert-deftest test-org-babel
/elisp-in-header-arguments
()
116 "Test execution of elisp forms in header arguments."
117 ;; at the babel.org:elisp-forms-in-header-arguments header
118 (org-test-at-id "22d67284-bf14-4cdc-8319-f4bd876829d7"
119 (org-babel-next-src-block)
120 (let ((info (org-babel-get-src-block-info)))
121 (should (= 4 (org-babel-execute-src-block))))))
123 (ert-deftest test-org-babel
/simple-named-code-block
()
124 "Test that simple named code blocks can be evaluated."
125 (org-test-at-id "0d82b52d-1bb9-4916-816b-2c67c8108dbb"
126 (org-babel-next-src-block 1)
127 (should (= 42 (org-babel-execute-src-block)))))
129 (ert-deftest test-org-babel
/simple-variable-resolution
()
130 "Test that simple variable resolution is working."
131 (org-test-at-id "f68821bc-7f49-4389-85b5-914791ee3718"
132 (org-babel-next-src-block 2)
133 (should (= 4 (org-babel-execute-src-block)))))
135 (ert-deftest test-org-babel
/multi-line-header-arguments
()
136 "Test that multi-line header arguments and can be read."
137 (org-test-at-id "b77c8857-6c76-4ea9-8a61-ddc2648d96c4"
138 (org-babel-next-src-block)
139 (let ((results (org-babel-execute-src-block)))
140 (should(equal 'a
(cadr (assoc 1 results
))))
141 (should(equal 'd
(cadr (assoc 4 results
)))))))
143 (ert-deftest test-org-babel
/parse-header-args
()
144 (org-test-at-id "7eb0dc6e-1c53-4275-88b3-b22f3113b9c3"
145 (org-babel-next-src-block)
146 (let* ((info (org-babel-get-src-block-info))
147 (params (nth 2 info
)))
148 (message "%S" params
)
149 (should(equal "example-lang" (nth 0 info
)))
150 (should(string= "the body" (org-babel-trim (nth 1 info
))))
151 (should-not (member '(:session\ \ \ \
) params
))
152 (should(equal '(:session
) (assoc :session params
)))
153 (should(equal '(:result-type . output
) (assoc :result-type params
)))
154 (should(equal '(num .
9) (cdr (assoc :var params
)))))))
156 (ert-deftest test-org-babel
/parse-header-args2
()
157 (org-test-at-id "2409e8ba-7b5f-4678-8888-e48aa02d8cb4"
158 (should (string-match (regexp-quote "this is simple")
159 (org-babel-ref-resolve "simple-subtree")))
160 (org-babel-next-src-block)
161 (should (= 14 (org-babel-execute-src-block)))))
163 (ert-deftest test-org-babel
/inline-src-blocks
()
164 (org-test-at-id "54cb8dc3-298c-4883-a933-029b3c9d4b18"
165 (macrolet ((at-next (&rest body
)
168 (re-search-forward org-babel-inline-src-block-regexp nil t
)
169 (goto-char (match-beginning 1))
170 (save-match-data ,@body
))))
171 (at-next (should (equal 1 (org-babel-execute-src-block))))
172 (at-next (should (equal 2 (org-babel-execute-src-block))))
173 (at-next (should (equal 3 (org-babel-execute-src-block)))))))
175 (ert-deftest test-org-babel
/org-babel-get-inline-src-block-matches
()
176 (org-test-at-id "0D0983D4-DE33-400A-8A05-A225A567BC74"
177 (let ((test-point (point)))
178 (should (fboundp 'org-babel-get-inline-src-block-matches
))
179 (should (re-search-forward "src_" nil t
)) ;; 1
180 (should (= (+ test-point
140) (match-end 0)))
181 (should (org-babel-get-inline-src-block-matches))
182 (should (re-search-forward "}" nil
(point-at-bol))) ;; 1
183 (should-not (org-babel-get-inline-src-block-matches))
184 (should (re-search-forward "in" nil t
)) ;; 2
185 (should-not (org-babel-get-inline-src-block-matches))
186 (should (re-search-forward "echo" nil t
)) ;; 2
187 (should (org-babel-get-inline-src-block-matches))
188 (should (re-search-forward "blocks" nil t
)) ;; 3
189 (backward-char 8) ;; 3
190 (should (org-babel-get-inline-src-block-matches))
192 (should-not (org-babel-get-inline-src-block-matches))
193 (should (re-search-forward ":results" nil t
)) ;; 4
194 (should (org-babel-get-inline-src-block-matches))
196 (should-not (org-babel-get-inline-src-block-matches))
199 (ert-deftest test-org-babel
/inline-src_blk-default-results-replace-line-1
()
200 (let ((test-line "src_sh{echo 1}"))
201 ;; src_ at bol line 1...
202 (org-test-with-temp-text
204 (goto-char (point-min)) (org-ctrl-c-ctrl-c)
206 (concat test-line
" =1=")
207 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
208 (forward-char) (org-ctrl-c-ctrl-c)
210 (concat test-line
" =1= =1=")
211 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
212 (re-search-forward "1}")
213 (should-error (org-ctrl-c-ctrl-c))
214 (backward-char) ;; last char of block body
217 (concat test-line
" =1= =1= =1=")
218 (buffer-substring-no-properties (point-at-bol) (point-at-eol)))))
219 ;; src_ follows space line 1...
220 (let ((test-line " src_emacs-lisp{ 1 }"))
221 (org-test-with-temp-text
223 (should-error (org-ctrl-c-ctrl-c))
224 (forward-char) (org-ctrl-c-ctrl-c)
226 (concat test-line
" =1=")
227 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
228 (re-search-forward "{ 1 ") (org-ctrl-c-ctrl-c)
230 (concat test-line
" =1= =1=")
231 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
233 (should-error (org-ctrl-c-ctrl-c)))))
235 (ert-deftest test-org-babel
/inline-src_blk-default-results-replace-line-2
()
236 ;; src_ at bol line 2...
237 (let ((test-line " src_emacs-lisp{ \"x\" }"))
238 (org-test-with-temp-text
239 (concat "\n" test-line
)
240 (should-error (org-ctrl-c-ctrl-c))
241 (goto-char (point-min))
242 (should-error (org-ctrl-c-ctrl-c))
244 (should-error (org-ctrl-c-ctrl-c))
245 (forward-char) (org-ctrl-c-ctrl-c)
247 (concat test-line
" =x=")
248 (buffer-substring-no-properties
249 (point-at-bol) (point-at-eol))))))
251 (let ((test-line "Some text prior to block src_emacs-lisp{ \"y\" }"))
252 (org-test-with-temp-text
254 (goto-char (point-max))
255 (insert (concat "\n" test-line
" end"))
256 (re-search-backward "src") (org-ctrl-c-ctrl-c)
258 (concat test-line
" =y= end")
259 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
260 (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
262 (concat test-line
" =y= =y= end")
263 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
265 (should-error (org-ctrl-c-ctrl-c))))))
267 (ert-deftest test-org-babel
/inline-src_blk-manual-results-replace
()
268 (let ((test-line " src_emacs-lisp[:results replace]{ \"x\" }"))
269 (org-test-with-temp-text
270 (concat "\n" test-line
)
271 (should-error (org-ctrl-c-ctrl-c))
272 (goto-char (point-max))
273 (should-error (org-ctrl-c-ctrl-c))
275 (should-error (org-ctrl-c-ctrl-c))
276 (forward-char) (org-ctrl-c-ctrl-c)
278 (concat test-line
" =x=")
279 (buffer-substring-no-properties
280 (point-at-bol) (point-at-eol))))))
282 (let ((test-line (concat " Some text prior to block "
283 "src_emacs-lisp[:results replace]{ \"y\" }")))
284 (org-test-with-temp-text test-line
285 (goto-char (point-max))
286 (insert (concat "\n" test-line
" end"))
287 (re-search-backward "src") (org-ctrl-c-ctrl-c)
289 (concat test-line
" =y= end")
290 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
291 (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
293 (concat test-line
" =y= =y= end")
294 (buffer-substring-no-properties (point-at-bol) (point-at-eol))))
296 (should-error (org-ctrl-c-ctrl-c)))))
298 (ert-deftest test-org-babel
/inline-src_blk-results-silent
()
299 (let ((test-line "src_emacs-lisp[ :results silent ]{ \"x\" }"))
300 (org-test-with-temp-text test-line
302 (should (string= test-line
303 (buffer-substring-no-properties
304 (point-at-bol) (point-at-eol))))
306 (should-error (org-ctrl-c-ctrl-c))))
307 (let ((test-line (concat " Some text prior to block src_emacs-lisp"
308 "[ :results silent ]{ \"y\" }")))
309 (org-test-with-temp-text
311 (goto-char (point-max))
312 (insert (concat "\n" test-line
" end"))
313 (re-search-backward "src_") (org-ctrl-c-ctrl-c)
314 (should (string= (concat test-line
" end")
315 (buffer-substring-no-properties
316 (point-at-bol) (point-at-eol))))
317 (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
318 (should (string= (concat test-line
" end")
319 (buffer-substring-no-properties
320 (point-at-bol) (point-at-eol))))
322 (should-error (org-ctrl-c-ctrl-c)))))
324 (ert-deftest test-org-babel
/inline-src_blk-results-raw
()
325 (let ((test-line "src_emacs-lisp[ :results raw ]{ \"x\" }"))
326 (org-test-with-temp-text test-line
328 (should (string= (concat test-line
" x")
330 (let ((test-line (concat " Some text prior to block "
331 "src_emacs-lisp[ :results raw ]{ \"the\" }")))
332 (org-test-with-temp-text (concat test-line
" end")
333 (re-search-forward "src_") (org-ctrl-c-ctrl-c)
334 (should (string= (concat test-line
" the end")
335 (buffer-substring-no-properties
336 (point-at-bol) (point-at-eol))))
337 (re-search-forward "\" ") (org-ctrl-c-ctrl-c)
338 (should (string= (concat test-line
" the the end")
339 (buffer-substring-no-properties
340 (point-at-bol) (point-at-eol))))
342 (should-error (org-ctrl-c-ctrl-c)))))
344 (ert-deftest test-org-babel
/inline-src_blk-results-file
()
345 (let ((test-line "src_emacs-lisp[ :results file ]{ \"~/test-file\" }"))
346 (org-test-with-temp-text
349 (should (string= (concat test-line
" [[file:~/test-file]]")
350 (buffer-substring-no-properties
351 (point-min) (point-max)))))))
353 (ert-deftest test-org-babel
/inline-src_blk-results-scalar
()
354 (let ((test-line "src_emacs-lisp[ :results scalar ]{ \"x\" }"))
355 (org-test-with-temp-text
358 (should (string= (concat test-line
" =\"x\"=")
359 (buffer-substring-no-properties
360 (point-min) (point-max)))))))
362 (ert-deftest test-org-babel
/inline-src_blk-results-verbatim
()
363 (let ((test-line "src_emacs-lisp[ :results verbatim ]{ \"x\" }"))
364 (org-test-with-temp-text
367 (should (string= (concat test-line
" =\"x\"=")
368 (buffer-substring-no-properties
369 (point-min) (point-max)))))))
371 (ert-deftest test-org-babel
/combining-scalar-and-raw-result-types
()
372 (flet ((next-result ()
373 (org-babel-next-src-block)
374 (org-babel-execute-src-block)
375 (goto-char (org-babel-where-is-src-block-result))
377 (org-test-at-id "a73a2ab6-b8b2-4c0e-ae7f-23ad14eab7bc"
379 (should (org-babel-in-example-or-verbatim))
381 (should (not (org-babel-in-example-or-verbatim))))))
383 (ert-deftest test-org-babel
/no-defaut-value-for-var
()
384 "Test that the absence of a default value for a variable DOES THROW
386 (org-test-at-id "f2df5ba6-75fa-4e6b-8441-65ed84963627"
387 (org-babel-next-src-block)
389 (should-error (org-babel-execute-src-block) :type
'error
)))
393 "variable \"x\" in block \"carre\" must be assigned a default value")
396 (ert-deftest test-org-babel
/just-one-results-block
()
397 "Test that evaluating two times the same code block does not result in a
398 duplicate results block."
399 (org-test-with-temp-text "#+begin_src sh\necho Hello\n#+end_src\n"
400 (org-babel-execute-src-block)
401 (org-babel-execute-src-block) ; second code block execution
402 (should (search-forward "Hello")) ; the string inside the source code block
403 (should (search-forward "Hello")) ; the same string in the results block
404 (should-error (search-forward "Hello"))))
406 (ert-deftest test-org-babel
/nested-code-block
()
407 "Test nested code blocks inside code blocks don't cause problems."
408 (org-test-with-temp-text "#+begin_src org :results silent
409 ,#+begin_src emacs-lisp
413 (should (string= (org-babel-execute-src-block)
414 "#+begin_src emacs-lisp\n 'foo\n#+end_src"))))
416 (ert-deftest test-org-babel
/partial-nested-code-block
()
417 "Test nested code blocks inside code blocks don't cause problems."
418 (org-test-with-temp-text "#+begin_src org :results silent
419 ,#+begin_src emacs-lisp
421 (should (string= "#+begin_src emacs-lisp" (org-babel-execute-src-block)))))
423 (ert-deftest test-ob
/does-not-replace-a-block-with-the-results
()
424 (org-test-with-temp-text "#+NAME: foo
425 #+BEGIN_SRC emacs-lisp
428 (org-babel-next-src-block 1)
429 (should (eq 'foo
(org-babel-execute-src-block)))
430 (goto-char (point-min))
431 (org-babel-next-src-block 1)
432 (should (looking-at org-babel-src-block-regexp
))))
434 (ert-deftest test-ob
/catches-all-references
()
435 (org-test-with-temp-text "
436 #+NAME: literal-example
442 #+NAME: read-literal-example
443 #+BEGIN_SRC emacs-lisp :var x=literal-example
444 (concatenate 'string x \" for me.\")
446 (org-babel-next-src-block 1)
447 (should (string= (org-babel-execute-src-block)
448 "A literal example\non two lines for me."))))
450 (ert-deftest test-ob
/resolve-code-blocks-before-data-blocks
()
451 (org-test-with-temp-text "
456 #+begin_src emacs-lisp
460 #+begin_src emacs-lisp :var foo=foo
463 (org-babel-next-src-block 2)
464 (should (string= (org-babel-execute-src-block) "baz"))))
466 (ert-deftest test-ob
/do-not-resolve-to-partial-names-data
()
467 (org-test-with-temp-text "
476 #+begin_src emacs-lisp :var x=base
479 (org-babel-next-src-block 1)
480 (should (equal (org-babel-execute-src-block) '((3) (4))))))
482 (ert-deftest test-ob
/do-not-resolve-to-partial-names-code
()
483 (org-test-with-temp-text "
485 #+begin_src emacs-lisp
490 #+begin_src emacs-lisp
494 #+begin_src emacs-lisp :var x=base
497 (org-babel-next-src-block 3)
498 (should (equal (org-babel-execute-src-block) "foo"))))
500 (ert-deftest test-ob
/allow-spaces-around-
=-in-var-specs
()
501 (org-test-with-temp-text "#+begin_src emacs-lisp :var a = 1 b = 2 c= 3 d =4
505 (should (= 10 (org-babel-execute-src-block)))))
509 ;;; test-ob ends here