diff options
Diffstat (limited to 'modules')
| -rw-r--r-- | modules/mod-test/Makefile | 45 | ||||
| -rw-r--r-- | modules/mod-test/mod-test.c | 268 | ||||
| -rw-r--r-- | modules/mod-test/test.el | 134 | ||||
| -rwxr-xr-x | modules/modhelp.py | 207 |
4 files changed, 654 insertions, 0 deletions
diff --git a/modules/mod-test/Makefile b/modules/mod-test/Makefile new file mode 100644 index 00000000000..04529db9795 --- /dev/null +++ b/modules/mod-test/Makefile @@ -0,0 +1,45 @@ +# Test GNU Emacs modules. + +# Copyright 2015 Free Software Foundation, Inc. + +# This file is part of GNU Emacs. + +# GNU Emacs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# GNU Emacs is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +ROOT = ../.. +EMACS = $(ROOT)/src/emacs + +CC = gcc +LD = gcc +LDFLAGS = + +# On MS-Windows, say "make SO=dll" to build the module +SO = so +# -fPIC is a no-op on Windows, but causes a compiler warning +ifeq ($(SO),dll) +CFLAGS = -std=gnu99 -ggdb3 -Wall +else +CFLAGS = -std=gnu99 -ggdb3 -Wall -fPIC +endif + +all: mod-test.$(SO) + +%.$(SO): %.o + $(LD) -shared $(LDFLAGS) -o $@ $< + +%.o: %.c + $(CC) $(CFLAGS) -I$(ROOT)/src -c $< + +check: + $(EMACS) -batch -l ert -l test.el -f ert-run-tests-batch-and-exit diff --git a/modules/mod-test/mod-test.c b/modules/mod-test/mod-test.c new file mode 100644 index 00000000000..862bb81288b --- /dev/null +++ b/modules/mod-test/mod-test.c @@ -0,0 +1,268 @@ +/* Test GNU Emacs modules. + +Copyright 2015 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <emacs-module.h> + +int plugin_is_GPL_compatible; + +/* Always return symbol 't'. */ +static emacs_value +Fmod_test_return_t (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + return env->intern (env, "t"); +} + +/* Expose simple sum function. */ +static intmax_t +sum (intmax_t a, intmax_t b) +{ + return a + b; +} + +static emacs_value +Fmod_test_sum (emacs_env *env, ptrdiff_t nargs, emacs_value args[], void *data) +{ + assert (nargs == 2); + + intmax_t a = env->extract_integer (env, args[0]); + intmax_t b = env->extract_integer (env, args[1]); + + intmax_t r = sum (a, b); + + return env->make_integer (env, r); +} + + +/* Signal '(error 56). */ +static emacs_value +Fmod_test_signal (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + assert (env->non_local_exit_check (env) == emacs_funcall_exit_return); + env->non_local_exit_signal (env, env->intern (env, "error"), + env->make_integer (env, 56)); + return env->intern (env, "nil"); +} + + +/* Throw '(tag 65). */ +static emacs_value +Fmod_test_throw (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + assert (env->non_local_exit_check (env) == emacs_funcall_exit_return); + env->non_local_exit_throw (env, env->intern (env, "tag"), + env->make_integer (env, 65)); + return env->intern (env, "nil"); +} + + +/* Call argument function, catch all non-local exists and return + either normal result or a list describing the non-local exit. */ +static emacs_value +Fmod_test_non_local_exit_funcall (emacs_env *env, ptrdiff_t nargs, + emacs_value args[], void *data) +{ + assert (nargs == 1); + emacs_value result = env->funcall (env, args[0], 0, NULL); + emacs_value non_local_exit_symbol, non_local_exit_data; + enum emacs_funcall_exit code + = env->non_local_exit_get (env, &non_local_exit_symbol, + &non_local_exit_data); + switch (code) + { + case emacs_funcall_exit_return: + return result; + case emacs_funcall_exit_signal: + { + env->non_local_exit_clear (env); + emacs_value Flist = env->intern (env, "list"); + emacs_value list_args[] = {env->intern (env, "signal"), + non_local_exit_symbol, non_local_exit_data}; + return env->funcall (env, Flist, 3, list_args); + } + case emacs_funcall_exit_throw: + { + env->non_local_exit_clear (env); + emacs_value Flist = env->intern (env, "list"); + emacs_value list_args[] = {env->intern (env, "throw"), + non_local_exit_symbol, non_local_exit_data}; + return env->funcall (env, Flist, 3, list_args); + } + } + + /* Never reached. */ + return env->intern (env, "nil");; +} + + +/* Return a global reference. */ +static emacs_value +Fmod_test_globref_make (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + /* Make a big string and make it global. */ + char str[26 * 100]; + for (int i = 0; i < sizeof str; i++) + str[i] = 'a' + (i % 26); + + /* We don't need to null-terminate str. */ + emacs_value lisp_str = env->make_string (env, str, sizeof str); + return env->make_global_ref (env, lisp_str); +} + + +/* Return a copy of the argument string where every 'a' is replaced + with 'b'. */ +static emacs_value +Fmod_test_string_a_to_b (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + emacs_value lisp_str = args[0]; + ptrdiff_t size = 0; + char * buf = NULL; + + env->copy_string_contents (env, lisp_str, buf, &size); + buf = malloc (size); + env->copy_string_contents (env, lisp_str, buf, &size); + + for (ptrdiff_t i = 0; i + 1 < size; i++) + if (buf[i] == 'a') + buf[i] = 'b'; + + return env->make_string (env, buf, size - 1); +} + + +/* Embedded pointers in lisp objects. */ + +/* C struct (pointer to) that will be embedded. */ +struct super_struct +{ + int amazing_int; + char large_unused_buffer[512]; +}; + +/* Return a new user-pointer to a super_struct, with amazing_int set + to the passed parameter. */ +static emacs_value +Fmod_test_userptr_make (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + struct super_struct *p = calloc (1, sizeof *p); + p->amazing_int = env->extract_integer (env, args[0]); + return env->make_user_ptr (env, free, p); +} + +/* Return the amazing_int of a passed 'user-pointer to a super_struct'. */ +static emacs_value +Fmod_test_userptr_get (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + struct super_struct *p = env->get_user_ptr (env, args[0]); + return env->make_integer (env, p->amazing_int); +} + + +/* Fill vector in args[0] with value in args[1]. */ +static emacs_value +Fmod_test_vector_fill (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + emacs_value vec = args[0]; + emacs_value val = args[1]; + ptrdiff_t size = env->vec_size (env, vec); + for (ptrdiff_t i = 0; i < size; i++) + env->vec_set (env, vec, i, val); + return env->intern (env, "t"); +} + + +/* Return whether all elements of vector in args[0] are 'eq' to value + in args[1]. */ +static emacs_value +Fmod_test_vector_eq (emacs_env *env, ptrdiff_t nargs, emacs_value args[], + void *data) +{ + emacs_value vec = args[0]; + emacs_value val = args[1]; + ptrdiff_t size = env->vec_size (env, vec); + for (ptrdiff_t i = 0; i < size; i++) + if (!env->eq (env, env->vec_get (env, vec, i), val)) + return env->intern (env, "nil"); + return env->intern (env, "t"); +} + + +/* Lisp utilities for easier readability (simple wrappers). */ + +/* Provide FEATURE to Emacs. */ +static void +provide (emacs_env *env, const char *feature) +{ + emacs_value Qfeat = env->intern (env, feature); + emacs_value Qprovide = env->intern (env, "provide"); + emacs_value args[] = { Qfeat }; + + env->funcall (env, Qprovide, 1, args); +} + +/* Bind NAME to FUN. */ +static void +bind_function (emacs_env *env, const char *name, emacs_value Sfun) +{ + emacs_value Qfset = env->intern (env, "fset"); + emacs_value Qsym = env->intern (env, name); + emacs_value args[] = { Qsym, Sfun }; + + env->funcall (env, Qfset, 2, args); +} + +/* Module init function. */ +int +emacs_module_init (struct emacs_runtime *ert) +{ + emacs_env *env = ert->get_environment (ert); + +#define DEFUN(lsym, csym, amin, amax, doc, data) \ + bind_function (env, lsym, \ + env->make_function (env, amin, amax, csym, doc, data)) + + DEFUN ("mod-test-return-t", Fmod_test_return_t, 1, 1, NULL, NULL); + DEFUN ("mod-test-sum", Fmod_test_sum, 2, 2, "Return A + B", NULL); + DEFUN ("mod-test-signal", Fmod_test_signal, 0, 0, NULL, NULL); + DEFUN ("mod-test-throw", Fmod_test_throw, 0, 0, NULL, NULL); + DEFUN ("mod-test-non-local-exit-funcall", Fmod_test_non_local_exit_funcall, + 1, 1, NULL, NULL); + DEFUN ("mod-test-globref-make", Fmod_test_globref_make, 0, 0, NULL, NULL); + DEFUN ("mod-test-string-a-to-b", Fmod_test_string_a_to_b, 1, 1, NULL, NULL); + DEFUN ("mod-test-userptr-make", Fmod_test_userptr_make, 1, 1, NULL, NULL); + DEFUN ("mod-test-userptr-get", Fmod_test_userptr_get, 1, 1, NULL, NULL); + DEFUN ("mod-test-vector-fill", Fmod_test_vector_fill, 2, 2, NULL, NULL); + DEFUN ("mod-test-vector-eq", Fmod_test_vector_eq, 2, 2, NULL, NULL); + +#undef DEFUN + + provide (env, "mod-test"); + return 0; +} diff --git a/modules/mod-test/test.el b/modules/mod-test/test.el new file mode 100644 index 00000000000..69bf933c7f9 --- /dev/null +++ b/modules/mod-test/test.el @@ -0,0 +1,134 @@ +;;; Test GNU Emacs modules. + +;; Copyright 2015 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ + +(require 'ert) + +(add-to-list 'load-path + (file-name-directory (or #$ (expand-file-name (buffer-file-name))))) +(require 'mod-test) + +;; +;; Basic tests. +;; + +(ert-deftest mod-test-sum-test () + (should (= (mod-test-sum 1 2) 3)) + (let ((descr (should-error (mod-test-sum 1 2 3)))) + (should (eq (car descr) 'wrong-number-of-arguments)) + (should (stringp (nth 1 descr))) + (should (eq 0 + (string-match + (concat "#<module function " + "\\(at \\(0x\\)?[0-9a-fA-F]+\\( from .*\\)?" + "\\|Fmod_test_sum from .*\\)>") + (nth 1 descr)))) + (should (= (nth 2 descr) 3))) + (should-error (mod-test-sum "1" 2) :type 'wrong-type-argument) + (should-error (mod-test-sum 1 "2") :type 'wrong-type-argument) + ;; The following tests are for 32-bit build --with-wide-int. + (should (= (mod-test-sum -1 most-positive-fixnum) + (1- most-positive-fixnum))) + (should (= (mod-test-sum 1 most-negative-fixnum) + (1+ most-negative-fixnum))) + (when (< #x1fffffff most-positive-fixnum) + (should (= (mod-test-sum 1 #x1fffffff) + (1+ #x1fffffff))) + (should (= (mod-test-sum -1 #x20000000) + #x1fffffff))) + (should-error (mod-test-sum 1 most-positive-fixnum) + :type 'overflow-error) + (should-error (mod-test-sum -1 most-negative-fixnum) + :type 'overflow-error)) + +(ert-deftest mod-test-sum-docstring () + (should (string= (documentation 'mod-test-sum) "Return A + B"))) + +;; +;; Non-local exists (throw, signal). +;; + +(ert-deftest mod-test-non-local-exit-signal-test () + (should-error (mod-test-signal))) + +(ert-deftest mod-test-non-local-exit-throw-test () + (should (equal + (catch 'tag + (mod-test-throw) + (ert-fail "expected throw")) + 65))) + +(ert-deftest mod-test-non-local-exit-funcall-normal () + (should (equal (mod-test-non-local-exit-funcall (lambda () 23)) + 23))) + +(ert-deftest mod-test-non-local-exit-funcall-signal () + (should (equal (mod-test-non-local-exit-funcall + (lambda () (signal 'error '(32)))) + '(signal error (32))))) + +(ert-deftest mod-test-non-local-exit-funcall-throw () + (should (equal (mod-test-non-local-exit-funcall (lambda () (throw 'tag 32))) + '(throw tag 32)))) + +;; +;; String tests. +;; + +(defun multiply-string (s n) + (let ((res "")) + (dotimes (i n res) + (setq res (concat res s))))) + +(ert-deftest mod-test-globref-make-test () + (let ((mod-str (mod-test-globref-make)) + (ref-str (multiply-string "abcdefghijklmnopqrstuvwxyz" 100))) + (garbage-collect) ;; XXX: not enough to really test but it's something.. + (should (string= ref-str mod-str)))) + +(ert-deftest mod-test-string-a-to-b-test () + (should (string= (mod-test-string-a-to-b "aaa") "bbb"))) + +;; +;; User-pointer tests. +;; + +(ert-deftest mod-test-userptr-fun-test () + (let* ((n 42) + (v (mod-test-userptr-make n)) + (r (mod-test-userptr-get v))) + + (should (eq (type-of v) 'user-ptr)) + (should (integerp r)) + (should (= r n)))) + +;; TODO: try to test finalizer + +;; +;; Vector tests. +;; + +(ert-deftest mod-test-vector-test () + (dolist (s '(2 10 100 1000)) + (dolist (e '(42 foo "foo")) + (let* ((v-ref (make-vector 2 e)) + (eq-ref (eq (aref v-ref 0) (aref v-ref 1))) + (v-test (make-vector s nil))) + + (should (eq (mod-test-vector-fill v-test e) t)) + (should (eq (mod-test-vector-eq v-test e) eq-ref)))))) diff --git a/modules/modhelp.py b/modules/modhelp.py new file mode 100755 index 00000000000..7c96f27fee1 --- /dev/null +++ b/modules/modhelp.py @@ -0,0 +1,207 @@ +#!/usr/bin/env python + +# Module helper script. + +# Copyright 2015 Free Software Foundation, Inc. + +# This file is part of GNU Emacs. + +# GNU Emacs is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# GNU Emacs is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +import os +import string +import subprocess as sp +import argparse +import re + +EMACS = os.path.join('..', 'src', 'emacs') + +def find_modules(): + modpaths = [] + for (dirname, dirs, files) in os.walk('.'): + if 'Makefile' in files: + modpaths.append(dirname) + return modpaths + +def cmd_test(args): + mods = args.module + if not mods: + mods = find_modules() + + make_cmd = ['make'] + if args.force: + make_cmd.append('-B') + + failed = [] + for m in mods: + print '[*] %s: ------- start -------' % m + print '[*] %s: running make' % m + r = sp.call(make_cmd, cwd=m) + if r != 0: + print '[E] %s: make failed' % m + failed += [m] + continue + + print '[*] %s: running test' % m + testpath = os.path.join(m, 'test.el') + if os.path.isfile(testpath): + emacs_cmd = [EMACS, '-batch', '-L', '.', '-l', 'ert', + '-l', testpath, '-f', 'ert-run-tests-batch-and-exit'] + print ' '.join(emacs_cmd) + r = sp.call(emacs_cmd) + if r != 0: + print '[E] %s: test failed' % m + failed += [m] + continue + else: + print '[W] %s: no test to run' % m + + print '\n[*] %d/%d MODULES OK' % (len(mods)-len(failed), len(mods)) + for m in failed: + print '\tfailed: %s' % m + +def to_lisp_sym(sym): + sym = re.sub('[_ ]', '-', sym) + return sym + +def to_c_sym(sym): + sym = re.sub('[- ]', '_', sym) + return sym + +def cmd_init(args): + if os.path.exists(args.module): + print "%s: file/dir '%s' already exists" % (__file__, args.module) + return + + os.mkdir(args.module) + + template_vars = { + 'module': args.module, + 'func': args.fun, + 'c_file': '%s.c' % args.module, + 'c_func': 'F%s_%s' % (to_c_sym(args.module), to_c_sym(args.fun)), + 'lisp_func': '%s-%s' % (args.module, to_lisp_sym(args.fun)), + } + + for path, t in TEMPLATES.items(): + if isinstance(path, string.Template): + path = path.substitute(template_vars) + path = os.path.join(args.module, path) + print "writing %s..." % path + with open(path, "w+") as f: + f.write(t.substitute(template_vars)) + print "done! you can run %s test %s" % (__file__, args.module) + + +def main(): + # path always written relative to this file + os.chdir(os.path.dirname(os.path.realpath(__file__))) + + mainp = argparse.ArgumentParser() + subp = mainp.add_subparsers() + + testp = subp.add_parser('test', help='run tests') + testp.add_argument('-f', '--force', action='store_true', + help='force regeneration (make -B)') + testp.add_argument('module', nargs='*', + help='path to module to test (default all)') + testp.set_defaults(func=cmd_test) + + initp = subp.add_parser('init', help='create a test module from a template') + initp.add_argument('module', help='name of the new module') + initp.add_argument('-f', '--fun', default='fun', + help='override name of the default function') + initp.set_defaults(func=cmd_init) + + args = mainp.parse_args() + args.func(args) + + +# double the $ to escape python template syntax +TEMPLATES = { + 'Makefile': string.Template(''' +ROOT = ../.. + +CC = gcc +LD = gcc +CFLAGS = -ggdb3 -Wall +LDFLAGS = + +all: ${module}.so ${module}.doc + +%.so: %.o + $$(LD) -shared $$(LDFLAGS) -o $$@ $$< + +%.o: %.c + $$(CC) $$(CFLAGS) -I$$(ROOT)/src -fPIC -c $$< + +'''), + + string.Template('${c_file}'): string.Template(''' +#include <emacs-module.h> + +int plugin_is_GPL_compatible; + +static emacs_value +${c_func} (emacs_env *env, int nargs, emacs_value args[], void *data) +{ + return env->intern (env, "t"); +} + +/* Bind NAME to FUN. */ +static void +bind_function (emacs_env *env, const char *name, emacs_value Sfun) +{ + emacs_value Qfset = env->intern (env, "fset"); + emacs_value Qsym = env->intern (env, name); + emacs_value args[] = { Qsym, Sfun }; + + env->funcall (env, Qfset, 2, args); +} + +/* Provide FEATURE to Emacs. */ +static void +provide (emacs_env *env, const char *feature) +{ + emacs_value Qfeat = env->intern (env, feature); + emacs_value Qprovide = env->intern (env, "provide"); + emacs_value args[] = { Qfeat }; + + env->funcall (env, Qprovide, 1, args); +} + +int +emacs_module_init (struct emacs_runtime *ert) +{ + emacs_env *env = ert->get_environment (ert); + bind_function (env, "${lisp_func}", + env->make_function (env, 1, 1, ${c_func}, "doc", NULL)); + provide (env, "${module}"); + return 0; +} +'''), + 'test.el': string.Template(''' +(require 'ert) +(require 'module-test-common) + +;; #$$ works when loading, buffer-file-name when evaluating from emacs +(module-load (module-path (or #$$ (expand-file-name (buffer-file-name))))) + +(ert-deftest ${lisp_func}-test () + (should (eq (${lisp_func} 42) t))) +''') +} + +if __name__ == '__main__': + main() |