Changeset 740 for vendor/current/lib/torture

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/lib/torture

Files:

• config.mk (deleted)
• subunit.c (modified) (3 diffs)
• torture.c (modified) (17 diffs)
• torture.h (modified) (15 diffs)
• torture.pc.in (modified) (1 diff)
• wscript_build (added)

vendor/current/lib/torture/subunit.c

@@ -20 +20 @@
 #include "includes.h"
 #include "lib/torture/torture.h"
+#include <subunit/child.h>
 
-static void subunit_suite_start(struct torture_context *ctx,
+static void torture_subunit_suite_start(struct torture_context *ctx,
                                 struct torture_suite *suite)
 {
 }
 
-static void subunit_print_testname(struct torture_context *ctx, 
+static char *torture_subunit_test_name(struct torture_context *ctx,
                                    struct torture_tcase *tcase,
                                    struct torture_test *test)
 {
         if (!strcmp(tcase->name, test->name)) {
-                printf("%s", test->name);
+                return talloc_strdup(ctx, test->name);
         } else {
-                printf("%s.%s", tcase->name, test->name);
+                return talloc_asprintf(ctx, "%s.%s", tcase->name, test->name);
         }
 }
 
-static void subunit_test_start(struct torture_context *ctx, 
+static void torture_subunit_report_time(struct torture_context *tctx)
+{
+        struct timespec tp;
+        struct tm *tmp;
+        char timestr[200];
+        if (clock_gettime(CLOCK_REALTIME, &tp) != 0) {
+                perror("clock_gettime");
+                return;
+        }
+
+        tmp = localtime(&tp.tv_sec);
+        if (!tmp) {
+                perror("localtime");
+                return;
+        }
+
+        if (strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", tmp) <= 0) {
+                perror("strftime");
+                return;
+        }
+
+        printf("time: %s.%06ld\n", timestr, tp.tv_nsec / 1000);
+}
+
+static void torture_subunit_test_start(struct torture_context *context, 
                                struct torture_tcase *tcase,
                                struct torture_test *test)
 {
-        printf("test: ");
-        subunit_print_testname(ctx, tcase, test);       
-        printf("\n");
+        char *fullname = torture_subunit_test_name(context, context->active_tcase, context->active_test);
+        subunit_test_start(fullname);
+        torture_subunit_report_time(context);
+        talloc_free(fullname);
 }
 
-static void subunit_test_result(struct torture_context *context, 
+static void torture_subunit_test_result(struct torture_context *context, 
                                 enum torture_result res, const char *reason)
 {
+        char *fullname = torture_subunit_test_name(context, context->active_tcase, context->active_test);
+        torture_subunit_report_time(context);
         switch (res) {
         case TORTURE_OK:
-                printf("success: ");
+                subunit_test_pass(fullname);
                 break;
         case TORTURE_FAIL:
-                printf("failure: ");
+                subunit_test_fail(fullname, reason);
                 break;
         case TORTURE_ERROR:
-                printf("error: ");
+                subunit_test_error(fullname, reason);
                 break;
         case TORTURE_SKIP:
-                printf("skip: ");
+                subunit_test_skip(fullname, reason);
                 break;
         }
-        subunit_print_testname(context, context->active_tcase, context->active_test);   
-
-        if (reason)
-                printf(" [\n%s\n]", reason);
-        printf("\n");
+        talloc_free(fullname);
 }
 
-static void subunit_comment(struct torture_context *test,
+static void torture_subunit_comment(struct torture_context *test,
                             const char *comment)
 {
@@ -76 +100 @@
 }
 
-static void subunit_warning(struct torture_context *test,
+static void torture_subunit_warning(struct torture_context *test,
                             const char *comment)
 {
@@ -82 +106 @@
 }
 
+static void torture_subunit_progress(struct torture_context *tctx, int offset, enum torture_progress_whence whence)
+{
+        switch (whence) {
+        case TORTURE_PROGRESS_SET:
+                printf("progress: %d\n", offset);
+                break;
+        case TORTURE_PROGRESS_CUR:
+                printf("progress: %+-d\n", offset);
+                break;
+        case TORTURE_PROGRESS_POP:
+                printf("progress: pop\n");
+                break;
+        case TORTURE_PROGRESS_PUSH:
+                printf("progress: push\n");
+                break;
+        default:
+                fprintf(stderr, "Invalid call to progress()\n");
+                break;
+        }
+}
+
 const struct torture_ui_ops torture_subunit_ui_ops = {
-        .comment = subunit_comment,
-        .warning = subunit_warning,
-        .test_start = subunit_test_start,
-        .test_result = subunit_test_result,
-        .suite_start = subunit_suite_start
+        .comment = torture_subunit_comment,
+        .warning = torture_subunit_warning,
+        .test_start = torture_subunit_test_start,
+        .test_result = torture_subunit_test_result,
+        .suite_start = torture_subunit_suite_start,
+        .progress = torture_subunit_progress,
+        .report_time = torture_subunit_report_time,
 };

vendor/current/lib/torture/torture.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    SMB torture UI functions
 
    Copyright (C) Jelmer Vernooij 2006-2008
-   
+
    This program 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.
-   
+
    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -24 +24 @@
 #include "param/param.h"
 #include "system/filesys.h"
+#include "system/dir.h"
+
 
 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
@@ -72 +74 @@
 
         return subtorture;
-}       
-
-/**
- create a temporary directory.
+}
+
+/**
+ create a temporary directory under the output dir
 */
-_PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx, 
-                                   const char *prefix, 
-                                   char **tempdir)
+_PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
+                                   const char *prefix, char **tempdir)
 {
         SMB_ASSERT(tctx->outputdir != NULL);
 
-        *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir, 
+        *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir,
                                    prefix);
         NT_STATUS_HAVE_NO_MEMORY(*tempdir);
@@ -91 +92 @@
         }
 
+        return NT_STATUS_OK;
+}
+
+static int local_deltree(const char *path)
+{
+        int ret = 0;
+        struct dirent *dirent;
+        DIR *dir = opendir(path);
+        if (!dir) {
+                char *error = talloc_asprintf(NULL, "Could not open directory %s", path);
+                perror(error);
+                talloc_free(error);
+                return -1;
+        }
+        while ((dirent = readdir(dir))) {
+                char *name;
+                if ((strcmp(dirent->d_name, ".") == 0) || (strcmp(dirent->d_name, "..") == 0)) {
+                        continue;
+                }
+                name = talloc_asprintf(NULL, "%s/%s", path,
+                                       dirent->d_name);
+                if (name == NULL) {
+                        closedir(dir);
+                        return -1;
+                }
+                DEBUG(0, ("About to remove %s\n", name));
+                ret = remove(name);
+                if (ret == 0) {
+                        talloc_free(name);
+                        continue;
+                }
+
+                if (errno == ENOTEMPTY) {
+                        ret = local_deltree(name);
+                        if (ret == 0) {
+                                ret = remove(name);
+                        }
+                }
+                talloc_free(name);
+                if (ret != 0) {
+                        char *error = talloc_asprintf(NULL, "Could not remove %s", path);
+                        perror(error);
+                        talloc_free(error);
+                        break;
+                }
+        }
+        closedir(dir);
+        rmdir(path);
+        return ret;
+}
+
+_PUBLIC_ NTSTATUS torture_deltree_outputdir(struct torture_context *tctx)
+{
+        if (tctx->outputdir == NULL) {
+                return NT_STATUS_OK;
+        }
+        if ((strcmp(tctx->outputdir, "/") == 0)
+            || (strcmp(tctx->outputdir, "") == 0)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+
+        if (local_deltree(tctx->outputdir) == -1) {
+                if (errno != 0) {
+                        return map_nt_error_from_unix(errno);
+                }
+                return NT_STATUS_UNSUCCESSFUL;
+        }
         return NT_STATUS_OK;
 }
@@ -108 +176 @@
         tmp = talloc_vasprintf(context, comment, ap);
         va_end(ap);
-                
+
         context->results->ui_ops->comment(context, tmp);
-        
+
         talloc_free(tmp);
 }
@@ -246 +314 @@
 }
 
+int torture_suite_children_count(const struct torture_suite *suite)
+{
+        int ret = 0;
+        struct torture_tcase *tcase;
+        struct torture_test *test;
+        struct torture_suite *tsuite;
+        for (tcase = suite->testcases; tcase; tcase = tcase->next) {
+                for (test = tcase->tests; test; test = test->next) {
+                        ret++;
+                }
+        }
+        for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
+                ret ++;
+        }
+        return ret;
+}
+
 /**
  * Run a torture test suite.
@@ -251 +336 @@
 bool torture_run_suite(struct torture_context *context, 
                        struct torture_suite *suite)
+{
+        return torture_run_suite_restricted(context, suite, NULL);
+}
+
+bool torture_run_suite_restricted(struct torture_context *context, 
+                       struct torture_suite *suite, const char **restricted)
 {
         bool ret = true;
         struct torture_tcase *tcase;
         struct torture_suite *tsuite;
-        char *old_testname;
 
         if (context->results->ui_ops->suite_start)
                 context->results->ui_ops->suite_start(context, suite);
 
-        old_testname = context->active_testname;
-        if (old_testname != NULL)
-                context->active_testname = talloc_asprintf(context, "%s-%s", 
-                                                           old_testname, suite->name);
-        else
-                context->active_testname = talloc_strdup(context, suite->name);
+        /* FIXME: Adjust torture_suite_children_count if restricted != NULL */
+        context->results->ui_ops->progress(context,
+                torture_suite_children_count(suite), TORTURE_PROGRESS_SET);
 
         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
-                ret &= torture_run_tcase(context, tcase);
+                ret &= torture_run_tcase_restricted(context, tcase, restricted);
         }
 
         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
-                ret &= torture_run_suite(context, tsuite);
-        }
-
-        talloc_free(context->active_testname);
-        context->active_testname = old_testname;
+                context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
+                ret &= torture_run_suite_restricted(context, tsuite, restricted);
+                context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
+        }
 
         if (context->results->ui_ops->suite_finish)
@@ -303 +389 @@
 }
 
+static bool test_needs_running(const char *name, const char **restricted)
+{
+        int i;
+        if (restricted == NULL)
+                return true;
+        for (i = 0; restricted[i]; i++) {
+                if (!strcmp(name, restricted[i]))
+                        return true;
+        }
+        return false;
+}
+
 static bool internal_torture_run_test(struct torture_context *context, 
                                           struct torture_tcase *tcase,
                                           struct torture_test *test,
-                                          bool already_setup)
+                                          bool already_setup,
+                                          const char **restricted)
 {
         bool success;
-        char *old_testname = NULL;
+        char *subunit_testname = NULL;
 
         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
-                old_testname = context->active_testname;
-                context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
-        }
+                subunit_testname = talloc_asprintf(context, "%s.%s", tcase->name, test->name);
+        } else {
+                subunit_testname = talloc_strdup(context, test->name);
+        }
+
+        if (!test_needs_running(subunit_testname, restricted))
+                return true;
 
         context->active_tcase = tcase;
@@ -358 +461 @@
         talloc_free(context->last_reason);
 
-        if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
-                talloc_free(context->active_testname);
-                context->active_testname = old_testname;
-        }
         context->active_test = NULL;
         context->active_tcase = NULL;
@@ -368 +467 @@
 }
 
-bool torture_run_tcase(struct torture_context *context, 
+bool torture_run_tcase(struct torture_context *context,
                        struct torture_tcase *tcase)
 {
+        return torture_run_tcase_restricted(context, tcase, NULL);
+}
+
+bool torture_run_tcase_restricted(struct torture_context *context,
+                       struct torture_tcase *tcase, const char **restricted)
+{
         bool ret = true;
-        char *old_testname;
         struct torture_test *test;
+        bool setup_succeeded = true;
+        const char * setup_reason = "Setup failed";
 
         context->active_tcase = tcase;
@@ -379 +485 @@
                 context->results->ui_ops->tcase_start(context, tcase);
 
-        if (tcase->fixture_persistent && tcase->setup 
-                && !tcase->setup(context, &tcase->data)) {
-                /* FIXME: Use torture ui ops for reporting this error */
-                fprintf(stderr, "Setup failed: ");
-                if (context->last_reason != NULL)
-                        fprintf(stderr, "%s", context->last_reason);
-                fprintf(stderr, "\n");
+        if (tcase->fixture_persistent && tcase->setup) {
+                setup_succeeded = tcase->setup(context, &tcase->data);
+        }
+
+        if (!setup_succeeded) {
+                /* Uh-oh. The setup failed, so we can't run any of the tests
+                 * in this testcase. The subunit format doesn't specify what
+                 * to do here, so we keep the failure reason, and manually
+                 * use it to fail every test.
+                 */
+                if (context->last_reason != NULL) {
+                        setup_reason = talloc_asprintf(context,
+                                "Setup failed: %s", context->last_reason);
+                }
+        }
+
+        for (test = tcase->tests; test; test = test->next) {
+                if (setup_succeeded) {
+                        ret &= internal_torture_run_test(context, tcase, test,
+                                        tcase->fixture_persistent, restricted);
+                } else {
+                        context->active_tcase = tcase;
+                        context->active_test = test;
+                        torture_ui_test_start(context, tcase, test);
+                        torture_ui_test_result(context, TORTURE_FAIL, setup_reason);
+                }
+        }
+
+        if (setup_succeeded && tcase->fixture_persistent && tcase->teardown &&
+                !tcase->teardown(context, tcase->data)) {
                 ret = false;
-                goto done;
-        }
-
-        old_testname = context->active_testname;
-        context->active_testname = talloc_asprintf(context, "%s-%s", 
-                                                   old_testname, tcase->name);
-        for (test = tcase->tests; test; test = test->next) {
-                ret &= internal_torture_run_test(context, tcase, test, 
-                                tcase->fixture_persistent);
-        }
-        talloc_free(context->active_testname);
-        context->active_testname = old_testname;
-
-        if (tcase->fixture_persistent && tcase->teardown &&
-                !tcase->teardown(context, tcase->data))
-                ret = false;
-
-done:
+        }
+
         context->active_tcase = NULL;
+        context->active_test = NULL;
 
         if (context->results->ui_ops->tcase_finish)
                 context->results->ui_ops->tcase_finish(context, tcase);
 
-        return ret;
+        return (!setup_succeeded) ? false : ret;
 }
 
@@ -417 +531 @@
                                           struct torture_test *test)
 {
-        return internal_torture_run_test(context, tcase, test, false);
+        return internal_torture_run_test(context, tcase, test, false, NULL);
+}
+
+bool torture_run_test_restricted(struct torture_context *context, 
+                                          struct torture_tcase *tcase,
+                                          struct torture_test *test,
+                                          const char **restricted)
+{
+        return internal_torture_run_test(context, tcase, test, false, restricted);
 }
 
@@ -423 +545 @@
                                                         int default_value)
 {
-        return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
+}
+
+unsigned long torture_setting_ulong(struct torture_context *test,
+                                    const char *name,
+                                    unsigned long default_value)
+{
+        return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
+                             default_value);
 }
 
@@ -429 +559 @@
                                                         double default_value)
 {
-        return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
 }
 
@@ -435 +565 @@
                                                         bool default_value)
 {
-        return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
 }
 
@@ -447 +577 @@
         SMB_ASSERT(test->lp_ctx != NULL);
         
-        ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
+        ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
 
         if (ret == NULL)
@@ -620 +750 @@
         return test;
 }
+
+void torture_ui_report_time(struct torture_context *context)
+{
+        if (context->results->ui_ops->report_time)
+                context->results->ui_ops->report_time(context);
+}

vendor/current/lib/torture/torture.h

@@ -33 +33 @@
         TORTURE_ERROR=2,
         TORTURE_SKIP=3
+};
+
+enum torture_progress_whence {
+        TORTURE_PROGRESS_SET,
+        TORTURE_PROGRESS_CUR,
+        TORTURE_PROGRESS_POP,
+        TORTURE_PROGRESS_PUSH,
 };
 
@@ -53 +60 @@
         void (*test_result) (struct torture_context *, 
                                                  enum torture_result, const char *reason);
+        void (*progress) (struct torture_context *, int offset, enum torture_progress_whence whence);
+        void (*report_time) (struct torture_context *);
 };
 
@@ -62 +71 @@
                                                                 enum torture_result result,
                                                                 const char *comment);
+
+void torture_ui_report_time(struct torture_context *context);
 
 /*
@@ -77 +88 @@
         struct torture_results *results;
 
-        char *active_testname;
         struct torture_test *active_test;
         struct torture_tcase *active_tcase;
@@ -86 +96 @@
         /** Directory used for temporary test data */
         const char *outputdir;
-        
+
         /** Event context */
         struct tevent_context *ev;
@@ -211 +221 @@
                                            struct torture_suite *suite);
 
+/* Run the specified testsuite recursively, but only the specified 
+ * tests */
+bool torture_run_suite_restricted(struct torture_context *context, 
+                       struct torture_suite *suite, const char **restricted);
+
 /* Run the specified testcase */
 bool torture_run_tcase(struct torture_context *context,
                                            struct torture_tcase *tcase);
+
+bool torture_run_tcase_restricted(struct torture_context *context, 
+                       struct torture_tcase *tcase, const char **restricted);
 
 /* Run the specified test */
@@ -220 +238 @@
                                           struct torture_test *test);
 
+bool torture_run_test_restricted(struct torture_context *context,
+                                          struct torture_tcase *tcase,
+                                          struct torture_test *test,
+                                          const char **restricted);
+
 void torture_comment(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
 void torture_warning(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
@@ -229 +252 @@
                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
                 return false; \
+        }
+
+#define torture_assert_goto(torture_ctx,expr,ret,label,cmt) \
+        if (!(expr)) { \
+                torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
+                ret = false; \
+                goto label; \
         }
 
@@ -278 +308 @@
                                            __location__": "#got" was %s, expected %s: %s", \
                                            __got, __expected, cmt); \
+                return false; \
+        } \
+        } while(0)
+
+#define torture_assert_strn_equal(torture_ctx,got,expected,len,cmt)\
+        do { const char *__got = (got), *__expected = (expected); \
+        if (strncmp(__got, __expected, len) != 0) { \
+                torture_result(torture_ctx, TORTURE_FAIL, \
+                                           __location__": "#got" %s of len %d did not match "#expected" %s: %s", \
+                                           __got, (int)len, __expected, cmt); \
                 return false; \
         } \
@@ -358 +398 @@
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
-                        __location__": "#got" was %d, expected %d: %s", \
-                        __got, __expected, cmt); \
+                        __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
+                        __got, __got, __expected, __expected, cmt); \
                 return false; \
         } \
@@ -368 +408 @@
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
-                        __location__": "#got" was %d, expected %d: %s", \
-                        __got, __expected, cmt); \
+                        __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
+                        __got, __got, __expected, __expected, cmt); \
                 ret = false; \
                 goto label; \
@@ -379 +419 @@
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
-                        __location__": "#got" was %llu, expected %llu: %s", \
-                        (unsigned long long)__got, (unsigned long long)__expected, cmt); \
-                return false; \
+                        __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
+                        (unsigned long long)__got, (unsigned long long)__got, \
+                        (unsigned long long)__expected, (unsigned long long)__expected, \
+                        cmt); \
+                return false; \
+        } \
+        } while(0)
+
+#define torture_assert_u64_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
+        do { uint64_t __got = (got), __expected = (expected); \
+        if (__got != __expected) { \
+                torture_result(torture_ctx, TORTURE_FAIL, \
+                        __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
+                        (unsigned long long)__got, (unsigned long long)__got, \
+                        (unsigned long long)__expected, (unsigned long long)__expected, \
+                        cmt); \
+                ret = false; \
+                goto label; \
         } \
         } while(0)
@@ -396 +451 @@
         } while(0)
 
-
+#define torture_assert_nttime_equal(torture_ctx,got,expected,cmt) \
+        do { NTTIME __got = got, __expected = expected; \
+        if (!nt_time_equal(&__got, &__expected)) { \
+                torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_time_string(tctx, __got), nt_time_string(tctx, __expected), cmt); \
+                return false; \
+        }\
+        } while(0)
 
 #define torture_skip(torture_ctx,cmt) do {\
@@ -450 +511 @@
                                                                                  const char *name);
 
+unsigned long torture_setting_ulong(struct torture_context *test,
+                                    const char *name,
+                                    unsigned long default_value);
+
 NTSTATUS torture_temp_dir(struct torture_context *tctx, 
                                    const char *prefix, 
                                    char **tempdir);
+NTSTATUS torture_deltree_outputdir(struct torture_context *tctx);
 
 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
@@ -462 +528 @@
                               struct torture_tcase *tcase, 
                               const char *name);
+int torture_suite_children_count(const struct torture_suite *suite);
 
 struct torture_context *torture_context_init(struct tevent_context *event_ctx, struct torture_results *results);

vendor/current/lib/torture/torture.pc.in

@@ -9 +9 @@
 Requires: talloc
 Version: 0.0.1
-Libs: -L${libdir} -ltorture 
+Libs: @LIB_RPATH@ -L${libdir} -ltorture
 Cflags: -I${includedir}  -DHAVE_IMMEDIATE_STRUCTURES=1