Introduce test framework for LITMUS^RT.

This is the beginning of the LITMUS^RT testsuite.
The main design goals are flexibility and ease of test writing.

To create a new test, simply write a test case in any C file in the
tests/ subdirectory. The buildsystem will find the test and hook it
up with the testrunner.

Have a look at tests/fdso.c and include/tests.h to get an idea for what
tests look like.

Tests can be executed with the 'runtests' tool. Each testcase is executed
in a separate process in order to ensure that tests do not influence
each other.

3 files changed, 254 insertions, 0 deletions

diff --git a/tests/fdso.c b/tests/fdso.c
new file mode 100644
index 0000000..fb8a5bd
--- /dev/null
+++ b/tests/fdso.c
@@ -0,0 +1,82 @@
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <stdio.h>
+
+
+#include "tests.h"
+
+#include "litmus.h"
+
+
+TESTCASE(fmlp_not_active, C_EDF | PFAIR | LINUX,
+         "don't open FMLP semaphores if FMLP is not supported")
+{
+        int fd;
+
+        SYSCALL( fd = open(".fmlp_locks", O_RDONLY | O_CREAT) );
+
+        ASSERT(fd != -1);
+
+        SYSCALL_FAILS(EBUSY, open_fmlp_sem(fd, 0) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".fmlp_locks") );
+}
+
+
+TESTCASE(invalid_od, ALL,
+         "reject invalid object descriptors")
+{
+        SYSCALL_FAILS( EINVAL, fmlp_down(3) );
+
+        SYSCALL_FAILS( EINVAL, fmlp_up(3) );
+
+        SYSCALL_FAILS( EINVAL, od_close(3) );
+
+
+        SYSCALL_FAILS( EINVAL, fmlp_down(-1) );
+
+        SYSCALL_FAILS( EINVAL, fmlp_up(-1) );
+
+        SYSCALL_FAILS( EINVAL, od_close(-1) );
+}
+
+TESTCASE(not_inherit_od, GSN_EDF | PSN_EDF,
+         "don't inherit FDSO handles across fork")
+{
+        int fd, od, pid, status;
+
+        SYSCALL( fd = open(".fmlp_locks", O_RDONLY | O_CREAT) );
+
+        SYSCALL( od = open_fmlp_sem(fd, 0) );
+
+        SYSCALL( fmlp_down(od) );
+
+        SYSCALL( fmlp_up(od) );
+
+        pid = fork();
+
+        ASSERT( pid != -1 );
+
+        if (pid == 0) {
+                /* child */
+                SYSCALL_FAILS(EINVAL, fmlp_down(od) );
+                SYSCALL_FAILS(EINVAL, fmlp_up(od) );
+                exit(0);
+        } else {
+                SYSCALL( fmlp_down(od) );
+                SYSCALL( fmlp_up(od) );
+                SYSCALL( waitpid(pid, &status, 0) );
+                ASSERT(WEXITSTATUS(status) == 0);
+        }
+
+        SYSCALL( od_close(od) );
+
+        SYSCALL( close(fd) );
+
+        SYSCALL( remove(".fmlp_locks") );
+}
+
+
diff --git a/tests/make_catalog.py b/tests/make_catalog.py
new file mode 100755
index 0000000..75b6aca
--- /dev/null
+++ b/tests/make_catalog.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+import re
+import sys
+
+class TestCase(object):
+    def __init__(self, function, plugins, desc):
+        self.function = function
+        self.plugins  = plugins
+        self.desc     = desc
+
+    def __str__(self):
+        return 'TESTCASE(%s, %s, "%s")' % \
+            (self.function, " | ".join(self.plugins), self.desc)
+
+
+class Finder(object):
+    def __init__(self):
+        self.found = []
+        self.regex = re.compile(
+            "TESTCASE\\("
+            "\\s*([a-zA-z_0-9]+)\\s*,"    # function name
+            "\\s*([- |a-zA-z_0-9]+)\\s*," # plugins
+            "\\s*\"([^\"]*)\"\\s*"        # description
+            "\\)"
+            , re.MULTILINE)
+
+    def search_file(self, fname):
+        f = open(fname, "r")
+        src = ''.join(f)
+        f.close()
+        matches = self.regex.findall(src)
+        del src
+
+        for m in matches:
+            name    = m[0]
+            plugins = m[1].split('|')
+            desc    = m[2]
+            plugins = [p.strip() for p in plugins]
+            self.found.append(TestCase(name, plugins, desc))
+
+
+def search_files(args=sys.argv[1:]):
+    f = Finder()
+    for fname in args:
+        try:
+            f.search_file(fname)
+        except IOError, msg:
+            sys.stderr.write("%s: %s\n" % (fname, msg))
+            sys.exit(1)
+    return f.found
+
+
+def create_tc_tables(out=sys.stdout):
+    def _(o):
+        out.write("%s\n" % str(o))
+
+    tests   = search_files()
+
+    plugins = set()
+    for tc in tests:
+        for p in tc.plugins:
+            plugins.add(p)
+
+    plugins.discard('ALL')
+
+    _('#include "tests.h"')
+
+    for tc in tests:
+        _('void test_%s(void);' % tc.function)
+
+    _('struct testcase test_catalog[] = {')
+    for tc in tests:
+        _('\t{test_%s, "%s"},' % (tc.function, tc.desc))
+    _('};')
+
+    for p in plugins:
+        count = 0
+        _('int %s_TESTS[] = {' % p)
+        for (i, tc) in enumerate(tests):
+            if p in tc.plugins or 'ALL' in tc.plugins:
+                _('\t%d,' % i)
+                count += 1
+        _('};')
+        _('#define NUM_%s_TESTS %d' % (p, count))
+
+    _('struct testsuite testsuite[] = {')
+    for p in plugins:
+        _('\t{"%s", %s_TESTS, NUM_%s_TESTS},' % (p.replace('_', '-'), p, p))
+    _('};')
+    _('#define NUM_PLUGINS %s' % len(plugins))
+
+if __name__ == '__main__':
+    create_tc_tables()
+
diff --git a/tests/runner.c b/tests/runner.c
new file mode 100644
index 0000000..f2e42b2
--- /dev/null
+++ b/tests/runner.c
@@ -0,0 +1,77 @@
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <sys/wait.h>
+
+#include <string.h>
+#include <stdio.h>
+
+
+/* auto generated by SConstruct */
+#include "__test_catalog.inc"
+
+#include "litmus.h"
+
+int run_test(struct testcase *tc) {
+        int status;
+        pid_t pid;
+
+        printf("** Testing: %s... ", tc->description);
+        fflush(stdout);
+        SYSCALL( pid = fork() );
+        if (pid == 0) {
+                /* child: init liblitmus and carry out test */
+                SYSCALL( init_litmus() );
+                tc->function();
+                exit(0);
+        } else {
+                /* parent: wait for completion of test */
+                SYSCALL( waitpid(pid, &status, 0) );
+                if (WEXITSTATUS(status) == 0)
+                        printf("ok.\n");
+        }
+        return WEXITSTATUS(status) == 0;
+}
+
+int run_tests(int* testidx, int num_tests, const char* plugin)
+{
+        int idx, i;
+        int ok = 0;
+
+        printf("** Running tests for %s.\n", plugin);
+        for (i = 0; i < num_tests; i++) {
+                idx = testidx[i];
+                ok += run_test(test_catalog + idx);
+        }
+        return ok;
+}
+
+#define streq(s1, s2) (!strcmp(s1, s2))
+
+int main(int argc, char** argv)
+{
+        int ok, i;
+
+        printf("** LITMUS^RT test suite.\n");
+
+        if (argc == 2) {
+                for (i = 0; i < NUM_PLUGINS; i++)
+                        if (streq(testsuite[i].plugin, argv[1])) {
+                                ok = run_tests(testsuite[i].testcases,
+                                               testsuite[i].num_cases,
+                                               testsuite[i].plugin);
+                                printf("** Result: %d ok, %d failed.\n",
+                                       ok, testsuite[i].num_cases - ok);
+                                return ok == testsuite[i].num_cases ? 0 : 3;
+                        }
+                fprintf(stderr, "** Unknown plugin: '%s'\n", argv[1]);
+                return 1;
+        } else {
+                fprintf(stderr, "Usage: %s <plugin name>\n", argv[0]);
+                fprintf(stderr, "Supported plugins: ");
+                for (i = 0; i < NUM_PLUGINS; i++)
+                        fprintf(stderr, "%s ", testsuite[i].plugin);
+                fprintf(stderr, "\n");
+                return 2;
+        }
+}