emacs-orgmode@gnu.org archives
 help / color / mirror / code / Atom feed
From: Eric Schulte <schulte.eric@gmail.com>
To: Thierry Banel <tbanelwebmin@free.fr>
Cc: emacs-orgmode@gnu.org
Subject: Re: babel C, C++, D enhancement
Date: Fri, 06 Jun 2014 12:31:02 -0400	[thread overview]
Message-ID: <877g4uezak.fsf@gmail.com> (raw)
In-Reply-To: 538BA215.2050305@free.fr

Hi Thierry,

This looks wonderful, however after applying this patch I get the
following errors when running "make test-dirty".

> 10 unexpected results:
>    FAILED  ob-C/inhomogeneous_table
>    FAILED  ob-D/inhomogeneous_table
>    FAILED  ob-D/integer-var
>    FAILED  ob-D/list-list-var
>    FAILED  ob-D/list-var
>    FAILED  ob-D/simple-program
>    FAILED  ob-D/string-var
>    FAILED  ob-D/table
>    FAILED  ob-D/two-integer-var
>    FAILED  ob-D/vector-var

Could you update the test suite so that the C tests pass, and the D
tests are not executed when D is not available?

Also, could you flesh out the commit message so that it meets the Emacs
commit message guidelines (http://orgmode.org/worg/org-contribute.html)?

Many Thanks,
Eric

Thierry Banel <tbanelwebmin@free.fr> writes:

> Hi Bastien, hi all
>
> Here is a Babel enhancement for C, C++ and D languages
> - support for non-homogeneous tables (mixing numerics and strings)
> - support for table headers
> - easier iterating over a table
> - added some error handling
> - new D support for simple lists and vectors
> - new unit tests
>
> Current documentation is here :
> http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-C.html
> Draft of future documentation is here :
> http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-C-new.html
>
> Have fun
> Thierry
>
>
> From e66e6545776c0506a1f15db800dfe6424c6f997e Mon Sep 17 00:00:00 2001
> From: Thierry Banel <tbanelwebmin@free.fr>
> Date: Sun, 1 Jun 2014 23:30:20 +0200
> Subject: [PATCH] enhanced table handling in Babel C, C++, D
>
> ---
>  lisp/ob-C.el                   |  302 +++++++++++++++++++++++++++-------------
>  testing/examples/ob-C-test.org |   88 ++++++++++++
>  testing/lisp/test-ob-C.el      |  103 ++++++++++++--
>  3 files changed, 384 insertions(+), 109 deletions(-)
>
> diff --git a/lisp/ob-C.el b/lisp/ob-C.el
> index 793981a..b1846de 100644
> --- a/lisp/ob-C.el
> +++ b/lisp/ob-C.el
> @@ -34,8 +34,6 @@
>    (require 'cl))
>  (require 'ob)
>  (require 'cc-mode)
> -(eval-when-compile
> -  (require 'cl))
>  
>  (declare-function org-entry-get "org"
>  		  (pom property &optional inherit literal-nil))
> @@ -72,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) ""))
> @@ -113,43 +96,62 @@ 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-expand-body:C++ (body params)
> +  "Expand a block of C++ code with org-babel according to it's
> +header arguments."
> +  (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand-C++ body params)))
> +
> +(defun org-babel-expand-body:C (body params)
> +  "Expand a block of C code with org-babel according to it's
> +header arguments."
> +  (let ((org-babel-c-variant 'c)) (org-babel-C-expand-C body params)))
> +
> +(defun org-babel-expand-body:D (body params)
> +  "Expand a block of D code with org-babel according to it's
> +header arguments."
> +  (let ((org-babel-c-variant 'd)) (org-babel-C-expand-D body params)))
>  
>  (defun org-babel-C-expand-C++ (body params)
>    "Expand a block of C or C++ code with org-babel according to
> @@ -160,24 +162,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)
> @@ -187,18 +199,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)
> @@ -229,50 +251,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
> @@ -295,6 +339,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

-- 
Eric Schulte
https://cs.unm.edu/~eschulte
PGP: 0x614CA05D (see https://u.fsf.org/yw)

  reply	other threads:[~2014-06-06 17:14 UTC|newest]

Thread overview: 31+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2014-04-11  1:34 Patch for testing `org-open-at-point' York Zhao
2014-04-11  7:23 ` Nicolas Goaziou
2014-04-11 10:25 ` Bastien
2014-04-12 14:22   ` York Zhao
2014-04-17 18:48     ` Bastien
2014-04-20 19:19       ` Michael Strey
2014-04-20 19:56       ` York Zhao
2014-06-01  1:12         ` York Zhao
2014-06-01  8:53           ` Bastien
2014-06-01 20:15           ` Achim Gratz
2014-06-01 21:14             ` Bastien
2014-06-01 21:58               ` babel C, C++, D enhancement Thierry Banel
2014-06-06 16:31                 ` Eric Schulte [this message]
2014-06-07 18:19                   ` Thierry Banel
2014-06-08 20:19                   ` Thierry Banel
2014-06-08 23:22                     ` Eric Schulte
2014-06-09  9:40                       ` Thierry Banel
2014-06-13  6:51                       ` Achim Gratz
2014-06-13 11:47                         ` Eric Schulte
2014-06-13 22:07                         ` Thierry Banel
2014-06-16 18:28                           ` Achim Gratz
2014-06-16 20:49                             ` Thierry Banel
2014-06-16 21:14                               ` Thomas S. Dye
2014-06-16 22:24                                 ` Nick Dokos
2014-06-17 17:16                               ` Achim Gratz
2014-06-17 20:51                                 ` Thierry Banel
2014-06-13 10:55                       ` Bastien
2014-06-13 11:58                         ` conforming commit messages Was: " Eric Schulte
2014-06-13 14:50                         ` Eric Abrahamsen
2014-06-02 19:13               ` Patch for testing `org-open-at-point' Achim Gratz
2014-06-03  7:22                 ` Bastien

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://www.orgmode.org/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=877g4uezak.fsf@gmail.com \
    --to=schulte.eric@gmail.com \
    --cc=emacs-orgmode@gnu.org \
    --cc=tbanelwebmin@free.fr \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
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).