* ob-C patch
@ 2014-01-07 21:00 Thierry Banel
0 siblings, 0 replies; only message in thread
From: Thierry Banel @ 2014-01-07 21:00 UTC (permalink / raw)
To: emacs-orgmode; +Cc: Eric Schulte
[-- Attachment #1: Type: text/plain, Size: 273 bytes --]
Hi Org maintainers
Here is a patch to overcome some shortcomings of Babel for C, C++, D
- handle non-homogeneous tables
- support table headers
- easier table iterating
- some new error handling
- simple lists and vectors support for D
- new unit tests
Have fun
Thierry
[-- Attachment #2: 0001-enhanced-table-handling-in-Babel-C-C-D.patch --]
[-- Type: text/x-patch, Size: 22917 bytes --]
From 8fdf544154b1d75ffe877082251cd87b93e8ad9f Mon Sep 17 00:00:00 2001
From: Thierry Banel <tbanelwebmin@free.fr>
Date: Tue, 7 Jan 2014 21:46:05 +0100
Subject: [PATCH] enhanced table handling in Babel C, C++, D
---
lisp/ob-C.el | 285 ++++++++++++++++++++++++++--------------
testing/examples/ob-C-test.org | 88 +++++++++++++
testing/lisp/test-ob-C.el | 103 +++++++++++++--
3 files changed, 369 insertions(+), 107 deletions(-)
diff --git a/lisp/ob-C.el b/lisp/ob-C.el
index 4c2d1ba..f93a967 100644
--- a/lisp/ob-C.el
+++ b/lisp/ob-C.el
@@ -70,40 +70,25 @@ This function calls `org-babel-execute:C++'."
This function is called by `org-babel-execute-src-block'."
(let ((org-babel-c-variant 'cpp)) (org-babel-C-execute body params)))
-;;(defun org-babel-expand-body:C++ (body params) ;; unused
-;; "Expand a block of C++ code with org-babel according to it's
-;;header arguments (calls `org-babel-C-expand')."
-;; (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand body params)))
-
(defun org-babel-execute:D (body params)
"Execute a block of D code with org-babel.
This function is called by `org-babel-execute-src-block'."
(let ((org-babel-c-variant 'd)) (org-babel-C-execute body params)))
-;; (defun org-babel-expand-body:D (body params) ;; unused
-;; "Expand a block of D code with org-babel according to it's
-;;header arguments (calls `org-babel-C-expand')."
-;; (let ((org-babel-c-variant 'd)) (org-babel-C-expand body params)))
-
(defun org-babel-execute:C (body params)
"Execute a block of C code with org-babel.
This function is called by `org-babel-execute-src-block'."
(let ((org-babel-c-variant 'c)) (org-babel-C-execute body params)))
-;; (defun org-babel-expand-body:c (body params) ;; unused
-;; "Expand a block of C code with org-babel according to it's
-;;header arguments (calls `org-babel-C-expand')."
-;; (let ((org-babel-c-variant 'c)) (org-babel-C-expand body params)))
-
(defun org-babel-C-execute (body params)
"This function should only be called by `org-babel-execute:C'
or `org-babel-execute:C++' or `org-babel-execute:D'."
(let* ((tmp-src-file (org-babel-temp-file
"C-src-"
- (cond
- ((equal org-babel-c-variant 'c ) ".c" )
- ((equal org-babel-c-variant 'cpp) ".cpp")
- ((equal org-babel-c-variant 'd ) ".d" ))))
+ (case org-babel-c-variant
+ (c ".c" )
+ (cpp ".cpp")
+ (d ".d" ))))
(tmp-bin-file (org-babel-temp-file "C-bin-" org-babel-exeext)) ;; not used for D
(cmdline (cdr (assoc :cmdline params)))
(cmdline (if cmdline (concat " " cmdline) ""))
@@ -111,43 +96,47 @@ or `org-babel-execute:C++' or `org-babel-execute:D'."
(flags (mapconcat 'identity
(if (listp flags) flags (list flags)) " "))
(full-body
- (cond ((equal org-babel-c-variant 'c ) (org-babel-C-expand-C body params))
- ((equal org-babel-c-variant 'cpp) (org-babel-C-expand-C++ body params))
- ((equal org-babel-c-variant 'd ) (org-babel-C-expand-D body params)))))
+ (case org-babel-c-variant
+ (c (org-babel-C-expand-C body params))
+ (cpp (org-babel-C-expand-C++ body params))
+ (d (org-babel-C-expand-D body params)))))
(with-temp-file tmp-src-file (insert full-body))
- (if (memq org-babel-c-variant '(c cpp)) ;; no separate compilation for D
- (org-babel-eval
- (format "%s -o %s %s %s"
- (cond
- ((equal org-babel-c-variant 'c ) org-babel-C-compiler)
- ((equal org-babel-c-variant 'cpp) org-babel-C++-compiler))
- (org-babel-process-file-name tmp-bin-file)
- flags
- (org-babel-process-file-name tmp-src-file)) ""))
+ (case org-babel-c-variant
+ ((c cpp)
+ (org-babel-eval
+ (format "%s -o %s %s %s"
+ (case org-babel-c-variant
+ (c org-babel-C-compiler)
+ (cpp org-babel-C++-compiler))
+ (org-babel-process-file-name tmp-bin-file)
+ flags
+ (org-babel-process-file-name tmp-src-file)) ""))
+ (d nil)) ;; no separate compilation for D
(let ((results
- (org-babel-trim
- (org-remove-indentation
- (org-babel-eval
- (cond ((memq org-babel-c-variant '(c cpp))
- (concat tmp-bin-file cmdline))
- ((equal org-babel-c-variant 'd)
- (format "%s %s %s %s"
- org-babel-D-compiler
- flags
- (org-babel-process-file-name tmp-src-file)
- cmdline)))
- "")))))
- (org-babel-reassemble-table
- (org-babel-result-cond (cdr (assoc :result-params params))
- (org-babel-read results t)
- (let ((tmp-file (org-babel-temp-file "c-")))
- (with-temp-file tmp-file (insert results))
- (org-babel-import-elisp-from-file tmp-file)))
- (org-babel-pick-name
- (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
- (org-babel-pick-name
- (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
- ))
+ (org-babel-eval
+ (case org-babel-c-variant
+ ((c cpp)
+ (concat tmp-bin-file cmdline))
+ (d
+ (format "%s %s %s %s"
+ org-babel-D-compiler
+ flags
+ (org-babel-process-file-name tmp-src-file)
+ cmdline)))
+ "")))
+ (when results
+ (setq results (org-babel-trim (org-remove-indentation results)))
+ (org-babel-reassemble-table
+ (org-babel-result-cond (cdr (assoc :result-params params))
+ (org-babel-read results t)
+ (let ((tmp-file (org-babel-temp-file "c-")))
+ (with-temp-file tmp-file (insert results))
+ (org-babel-import-elisp-from-file tmp-file)))
+ (org-babel-pick-name
+ (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+ (org-babel-pick-name
+ (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
+ )))
(defun org-babel-C-expand-C++ (body params)
"Expand a block of C or C++ code with org-babel according to
@@ -158,24 +147,34 @@ it's header arguments."
"Expand a block of C or C++ code with org-babel according to
it's header arguments."
(let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+ (colnames (cdar (org-babel-get-header params :colname-names)))
(main-p (not (string= (cdr (assoc :main params)) "no")))
(includes (or (cdr (assoc :includes params))
(org-babel-read (org-entry-get nil "includes" t))))
(defines (org-babel-read
(or (cdr (assoc :defines params))
(org-babel-read (org-entry-get nil "defines" t))))))
+ (unless (listp includes) (setq includes (list includes)))
+ (setq includes (append includes '("<string.h>" "<stdio.h>" "<stdlib.h>")))
(mapconcat 'identity
(list
;; includes
(mapconcat
(lambda (inc) (format "#include %s" inc))
- (if (listp includes) includes (list includes)) "\n")
+ includes "\n")
;; defines
(mapconcat
(lambda (inc) (format "#define %s" inc))
(if (listp defines) defines (list defines)) "\n")
;; variables
(mapconcat 'org-babel-C-var-to-C vars "\n")
+ ;; table sizes
+ (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
+ ;; tables headers utility
+ (when colnames
+ (org-babel-C-utility-header-to-C))
+ ;; tables headers
+ (mapconcat 'org-babel-C-header-to-C colnames "\n")
;; body
(if main-p
(org-babel-C-ensure-main-wrap body)
@@ -185,18 +184,28 @@ it's header arguments."
"Expand a block of D code with org-babel according to
it's header arguments."
(let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+ (colnames (cdar (org-babel-get-header params :colname-names)))
(main-p (not (string= (cdr (assoc :main params)) "no")))
(imports (or (cdr (assoc :imports params))
(org-babel-read (org-entry-get nil "imports" t)))))
+ (unless (listp imports) (setq imports (list imports)))
+ (setq imports (append imports '("std.stdio" "std.conv")))
(mapconcat 'identity
(list
"module mmm;"
;; imports
(mapconcat
(lambda (inc) (format "import %s;" inc))
- (if (listp imports) imports (list imports)) "\n")
+ imports "\n")
;; variables
(mapconcat 'org-babel-C-var-to-C vars "\n")
+ ;; table sizes
+ (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
+ ;; tables headers utility
+ (when colnames
+ (org-babel-C-utility-header-to-C))
+ ;; tables headers
+ (mapconcat 'org-babel-C-header-to-C colnames "\n")
;; body
(if main-p
(org-babel-C-ensure-main-wrap body)
@@ -227,50 +236,72 @@ support for sessions"
(cons "" (format format-data val))
(funcall format-data val))))
+(defun org-babel-C-val-to-base-type (val)
+ "Determine the base type of VAL which may be
+'integerp if all base values are integers
+'floatp if all base values are either floating points or integers
+'stringp otherwise."
+ (cond
+ ((integerp val) 'integerp)
+ ((floatp val) 'floatp)
+ ((or (listp val) (vectorp val))
+ (let ((type nil))
+ (mapc (lambda (v)
+ (case (org-babel-C-val-to-base-type v)
+ (stringp (setq type 'stringp))
+ (floatp
+ (if (or (not type) (eq type 'integerp))
+ (setq type 'floatp)))
+ (integerp
+ (unless type (setq type 'integerp)))))
+ val)
+ type))
+ (t 'stringp)))
+
(defun org-babel-C-val-to-C-type (val)
"Determine the type of VAL.
Return a list (TYPE-NAME FORMAT). TYPE-NAME should be the name of the type.
FORMAT can be either a format string or a function which is called with VAL."
- (cond
- ((integerp val) '("int" "%d"))
- ((floatp val) '("double" "%f"))
- ((or (listp val) (vectorp val))
- (lexical-let ((type (org-babel-C-val-to-C-list-type val)))
- (list (car type)
- (lambda (val)
- (cons
- (format "[%d]%s"
- (length val)
- (car (org-babel-C-format-val type (elt val 0))))
- (concat (if (equal org-babel-c-variant 'd) "[ " "{ ")
- (mapconcat (lambda (v)
- (cdr (org-babel-C-format-val type v)))
- val
- ", ")
- (if (equal org-babel-c-variant 'd) " ]" " }")))))))
- (t ;; treat unknown types as string
- (list
- (if (equal org-babel-c-variant 'd) "string" "const char*")
- "\"%s\""))))
-
-(defun org-babel-C-val-to-C-list-type (val)
- "Determine the C array type of a VAL."
- (let (type)
- (mapc
- #'(lambda (i)
- (let* ((tmp-type (org-babel-C-val-to-C-type i))
- (type-name (car type))
- (tmp-type-name (car tmp-type)))
- (when (and type (not (string= type-name tmp-type-name)))
- (if (and (member type-name '("int" "double" "int32_t"))
- (member tmp-type-name '("int" "double" "int32_t")))
- (setq tmp-type '("double" "" "%f"))
- (error "Only homogeneous lists are supported by C. You can not mix %s and %s"
- type-name
- tmp-type-name)))
- (setq type tmp-type)))
- val)
- type))
+ (let* ((basetype (org-babel-C-val-to-base-type val))
+ (type
+ (case basetype
+ (integerp '("int" "%d"))
+ (floatp '("double" "%f"))
+ (stringp
+ (list
+ (if (equal org-babel-c-variant 'd) "string" "const char*")
+ "\"%s\""))
+ (t (error "unknown type %S" type)))))
+ (cond
+ ((integerp val) type) ;; an integer declared in the #+begin_src line
+ ((floatp val) type) ;; a numeric declared in the #+begin_src line
+ ((and (listp val) (listp (car val))) ;; a table
+ `(,(car type)
+ (lambda (val)
+ (cons
+ (format "[%d][%d]" (length val) (length (car val)))
+ (concat
+ (if (equal org-babel-c-variant 'd) "[\n" "{\n")
+ (mapconcat
+ (lambda (v)
+ (concat
+ (if (equal org-babel-c-variant 'd) " [" " {")
+ (mapconcat (lambda (w) (format ,(cadr type) w)) v ",")
+ (if (equal org-babel-c-variant 'd) "]" "}")))
+ val
+ ",\n")
+ (if (equal org-babel-c-variant 'd) "\n]" "\n}"))))))
+ ((or (listp val) (vectorp val)) ;; a list declared in the #+begin_src line
+ `(,(car type)
+ (lambda (val)
+ (cons
+ (format "[%d]" (length val))
+ (concat
+ (if (equal org-babel-c-variant 'd) "[" "{")
+ (mapconcat (lambda (v) (format ,(cadr type) v)) val ",")
+ (if (equal org-babel-c-variant 'd) "]" "}"))))))
+ (t ;; treat unknown types as string
+ type))))
(defun org-babel-C-var-to-C (pair)
"Convert an elisp val into a string of C code specifying a var
@@ -293,6 +324,68 @@ of the same value."
suffix
data))))
+(defun org-babel-C-table-sizes-to-C (pair)
+ "Create constants of table dimensions, if PAIR is a table."
+ (when (listp (cdr pair))
+ (cond
+ ((listp (cadr pair)) ;; a table
+ (concat
+ (format "const int %s_rows = %d;" (car pair) (length (cdr pair)))
+ "\n"
+ (format "const int %s_cols = %d;" (car pair) (length (cadr pair)))))
+ (t ;; a list declared in the #+begin_src line
+ (format "const int %s_cols = %d;" (car pair) (length (cdr pair)))))))
+
+(defun org-babel-C-utility-header-to-C ()
+ "Generate a utility function to convert a column name
+into a column number."
+ (case org-babel-c-variant
+ ((c cpp)
+ "int get_column_num (int nbcols, const char** header, const char* column)
+{
+ int c;
+ for (c=0; c<nbcols; c++)
+ if (strcmp(header[c],column)==0)
+ return c;
+ return -1;
+}
+"
+ )
+ (d
+ "int get_column_num (string[] header, string column)
+{
+ foreach (c, h; header)
+ if (h==column)
+ return to!int(c);
+ return -1;
+}
+"
+ )))
+
+(defun org-babel-C-header-to-C (head)
+ "Convert an elisp list of header table into a C or D vector
+specifying a variable with the name of the table."
+ (let ((table (car head))
+ (headers (cdr head)))
+ (concat
+ (format
+ (case org-babel-c-variant
+ ((c cpp) "const char* %s_header[%d] = {%s};")
+ (d "string %s_header[%d] = [%s];"))
+ table
+ (length headers)
+ (mapconcat (lambda (h) (format "%S" h)) headers ","))
+ "\n"
+ (case org-babel-c-variant
+ ((c cpp)
+ (format
+ "const char* %s_h (int row, const char* col) { return %s[row][get_column_num(%d,%s_header,col)]; }"
+ table table (length headers) table))
+ (d
+ (format
+ "string %s_h (ulong row, string col) { return %s[row][get_column_num(%s_header,col)]; }"
+ table table table))))))
+
(provide 'ob-C)
;;; ob-C.el ends here
diff --git a/testing/examples/ob-C-test.org b/testing/examples/ob-C-test.org
index 1d0a83f..a8c485d 100644
--- a/testing/examples/ob-C-test.org
+++ b/testing/examples/ob-C-test.org
@@ -10,24 +10,44 @@
return 0;
#+end_src
+#+source: simple
+#+begin_src D :results silent
+ writefln ("%s", 42);
+#+end_src
+
#+source: integer_var
#+begin_src cpp :var q=12 :includes "<iostream>" :results silent
std::cout << q;
return 0;
#+end_src
+#+source: integer_var
+#+begin_src D :var q=12 :results silent
+ writefln ("%s", q);
+#+end_src
+
#+source: two_var
#+begin_src cpp :var q=12 :var p=10 :includes "<iostream>" :results silent
std::cout << p+q;
return 0;
#+end_src
+#+source: two_var
+#+begin_src D :var q=12 :var p=10 :results silent
+ writefln ("%s", p+q);
+#+end_src
+
#+source: string_var
#+begin_src cpp :var q="word" :includes '(<iostream> <cstring>) :results silent
std::cout << q << ' ' << std::strlen(q);
return 0;
#+end_src
+#+source: string_var
+#+begin_src D :var q="word" :results silent
+ writefln ("%s %s", q, q.length);
+#+end_src
+
#+source: define
#+begin_src cpp :defines N 42 :includes "<iostream>" :results silent
std::cout << N;
@@ -45,6 +65,13 @@
}
return 0;
#+end_src
+
+#+source: array
+#+begin_src D :results vector :results silent
+ foreach (i; 1..3)
+ writefln ("%s", i);
+#+end_src
+
* Matrix
:PROPERTIES:
:ID: cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5
@@ -58,13 +85,74 @@
std::cout << a[0] << a[1] << sizeof(a)/sizeof(*a) << '\n';
#+end_src
+#+source: list_var
+#+begin_src D :var a='("abc" "def") :results silent
+ writefln ("%s%s%s", a[0], a[1], a.length);
+#+end_src
+
#+source: vector_var
#+begin_src cpp :var a='[1 2] :includes "<iostream>" :results silent
std::cout << a[0] << a[1] << sizeof(a)/sizeof(*a) << '\n';
#+end_src
+#+source: vector_var
+#+begin_src D :var a='[1 2] :results silent
+ writefln ("%s%s%s", a[0], a[1], a.length);
+#+end_src
+
#+source: list_list_var
#+begin_src cpp :var q=C-matrix :includes "<iostream>" :results silent
std::cout << q[0][0] << ' ' << q[1][0] << '\n'
<< q[0][1] << ' ' << q[1][1] << '\n'; // transpose
#+end_src
+
+#+source: list_list_var
+#+begin_src D :var q=C-matrix :results silent
+ writefln ("%s %s", q[0][0], q[1][0]);
+ writefln ("%s %s", q[0][1], q[1][1]); // transpose
+#+end_src
+
+* Inhomogeneous table
+ :PROPERTIES:
+ :ID: e112bc2e-419a-4890-99c2-7ac4779531cc
+ :END:
+
+#+tblname: tinomogen
+ | day | quty |
+ |-----------+------|
+ | monday | 34 |
+ | tuesday | 41 |
+ | wednesday | 56 |
+ | thursday | 17 |
+ | friday | 12 |
+ | saturday | 7 |
+ | sunday | 4 |
+
+#+source: inhomogeneous_table
+#+BEGIN_SRC C :var tinomogen=tinomogen :results silent
+int main()
+{
+ int i, j;
+ for (i=0; i<tinomogen_rows; i++) {
+ for (j=0; j<tinomogen_cols; j++)
+ printf ("%s ", tinomogen[i][j]);
+ printf ("\n");
+ }
+ printf ("Friday %s\n", tinomogen_h(4,"day"));
+ return 0;
+}
+#+END_SRC
+
+#+source: inhomogeneous_table
+#+BEGIN_SRC D :var tinomogen=tinomogen :results silent
+import std.stdio;
+void main()
+{
+ for (int i=0; i<tinomogen_rows; i++) {
+ for (int j=0; j<tinomogen_cols; j++)
+ writef ("%s ", tinomogen[i][j]);
+ writeln();
+ }
+ writefln ("Friday %s\n", tinomogen_h(4,"day"));
+}
+#+END_SRC
diff --git a/testing/lisp/test-ob-C.el b/testing/lisp/test-ob-C.el
index 42e4dd2..2cc07fc 100644
--- a/testing/lisp/test-ob-C.el
+++ b/testing/lisp/test-ob-C.el
@@ -1,7 +1,7 @@
-;;; test-ob-awk.el --- tests for ob-awk.el
+;;; test-ob-C.el --- tests for ob-C.el
-;; Copyright (c) 2010-2014 Sergey Litvinov
-;; Authors: Sergey Litvinov
+;; Copyright (c) 2010-2014 Sergey Litvinov, Thierry Banel
+;; Authors: Sergey Litvinov, Thierry Banel
;; This file is not part of GNU Emacs.
@@ -28,55 +28,136 @@
(ert-deftest ob-C/simple-program ()
"Hello world program."
(org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
- (org-babel-next-src-block)
+ (org-babel-next-src-block 1)
+ (should (= 42 (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/simple-program ()
+ "Hello world program."
+ (org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
+ (org-babel-next-src-block 2)
(should (= 42 (org-babel-execute-src-block)))))
(ert-deftest ob-C/integer-var ()
"Test of an integer variable."
(org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
- (org-babel-next-src-block 2)
+ (org-babel-next-src-block 3)
+ (should (= 12 (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/integer-var ()
+ "Test of an integer variable."
+ (org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
+ (org-babel-next-src-block 4)
(should (= 12 (org-babel-execute-src-block)))))
(ert-deftest ob-C/two-integer-var ()
"Test of two input variables"
(org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
- (org-babel-next-src-block 3)
+ (org-babel-next-src-block 5)
+ (should (= 22 (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/two-integer-var ()
+ "Test of two input variables"
+ (org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
+ (org-babel-next-src-block 6)
(should (= 22 (org-babel-execute-src-block)))))
(ert-deftest ob-C/string-var ()
"Test of a string input variable"
(org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
- (org-babel-next-src-block 4)
+ (org-babel-next-src-block 7)
+ (should (equal "word 4" (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/string-var ()
+ "Test of a string input variable"
+ (org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
+ (org-babel-next-src-block 8)
(should (equal "word 4" (org-babel-execute-src-block)))))
(ert-deftest ob-C/preprocessor ()
"Test of a string variable"
(org-test-at-id "fa6db330-e960-4ea2-ac67-94bb845b8577"
- (org-babel-next-src-block 5)
+ (org-babel-next-src-block 9)
(should (= 42 (org-babel-execute-src-block)))))
+
(ert-deftest ob-C/table ()
"Test of a table output"
(org-test-at-id "2df1ab83-3fa3-462a-a1f3-3aef6044a874"
- (org-babel-next-src-block)
+ (org-babel-next-src-block 1)
(should (equal '((1) (2)) (org-babel-execute-src-block)))))
+(ert-deftest ob-D/table ()
+ "Test of a table output"
+ (org-test-at-id "2df1ab83-3fa3-462a-a1f3-3aef6044a874"
+ (org-babel-next-src-block 2)
+ (should (equal '((1) (2)) (org-babel-execute-src-block)))))
+
+
(ert-deftest ob-C/list-var ()
"Test of a list input variable"
(org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
(org-babel-next-src-block 1)
(should (string= "abcdef2" (org-babel-execute-src-block)))))
+(ert-deftest ob-D/list-var ()
+"Test of a list input variable"
+ (org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
+ (org-babel-next-src-block 2)
+ (should (string= "abcdef2" (org-babel-execute-src-block)))))
+
(ert-deftest ob-C/vector-var ()
"Test of a vector input variable"
(org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
- (org-babel-next-src-block 2)
+ (org-babel-next-src-block 3)
+ (should (equal 122 (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/vector-var ()
+"Test of a vector input variable"
+ (org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
+ (org-babel-next-src-block 4)
(should (equal 122 (org-babel-execute-src-block)))))
(ert-deftest ob-C/list-list-var ()
"Test of a list list input variable"
(org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
- (org-babel-next-src-block 3)
+ (org-babel-next-src-block 5)
(should (equal '((1 3) (2 4)) (org-babel-execute-src-block)))))
+(ert-deftest ob-D/list-list-var ()
+ "Test of a list list input variable"
+ (org-test-at-id "cc65d6b3-8e8e-4f9c-94cd-f5a00cdeceb5"
+ (org-babel-next-src-block 6)
+ (should (equal '((1 3) (2 4)) (org-babel-execute-src-block)))))
+
+
+(ert-deftest ob-C/inhomogeneous_table ()
+ "Test inhomogeneous input table"
+ (org-test-at-id "e112bc2e-419a-4890-99c2-7ac4779531cc"
+ (org-babel-next-src-block 1)
+ (should (equal
+ '(("monday" 34)
+ ("tuesday" 41)
+ ("wednesday" 56)
+ ("thursday" 17)
+ ("friday" 12)
+ ("saturday" 7)
+ ("sunday" 4)
+ ("Friday" "friday"))
+ (org-babel-execute-src-block)))))
+
+(ert-deftest ob-D/inhomogeneous_table ()
+ "Test inhomogeneous input table"
+ (org-test-at-id "e112bc2e-419a-4890-99c2-7ac4779531cc"
+ (org-babel-next-src-block 2)
+ (should (equal
+ '(("monday" 34)
+ ("tuesday" 41)
+ ("wednesday" 56)
+ ("thursday" 17)
+ ("friday" 12)
+ ("saturday" 7)
+ ("sunday" 4)
+ ("Friday" "friday"))
+ (org-babel-execute-src-block)))))
+
;;; test-ob-C.el ends here
--
1.7.9.5
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2014-01-07 21:00 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-01-07 21:00 ob-C patch Thierry Banel
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).