clar: update to latest version

Update to the latest version (in HEAD) of clar. This affords us improved
test directory creation, and the `cl_invoke` helper macro.

diff --git a/tests/clar/clar.c b/tests/clar/clar.c
index 9695dc9..f28d6af 100644 (file)
--- a/tests/clar/clar.c
+++ b/tests/clar/clar.c
@@ -4,7 +4,12 @@
  * This file is part of clar, distributed under the ISC license.
  * For full terms see the included COPYING file.
  */
-#include <assert.h>
+
+#define _BSD_SOURCE
+#define _DARWIN_C_SOURCE
+#define _DEFAULT_SOURCE
+
+#include <errno.h>
 #include <setjmp.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -13,21 +18,35 @@
 #include <stdarg.h>
 #include <wchar.h>
 #include <time.h>
+#include <inttypes.h>
 
 /* required for sandboxing */
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#if defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_WCHAR__)
+       /*
+        * uClibc can optionally be built without wchar support, in which case
+        * the installed <wchar.h> is a stub that only defines the `whar_t`
+        * type but none of the functions typically declared by it.
+        */
+#else
+#      define CLAR_HAVE_WCHAR
+#endif
+
 #ifdef _WIN32
+#      define WIN32_LEAN_AND_MEAN
 #      include <windows.h>
 #      include <io.h>
-#      include <shellapi.h>
 #      include <direct.h>
 
 #      define _MAIN_CC __cdecl
 
 #      ifndef stat
 #              define stat(path, st) _stat(path, st)
+               typedef struct _stat STAT_T;
+#      else
+               typedef struct stat STAT_T;
 #      endif
 #      ifndef mkdir
 #              define mkdir(path, mode) _mkdir(path)
@@ -41,6 +60,9 @@
 #      ifndef strdup
 #              define strdup(str) _strdup(str)
 #      endif
+#      ifndef strcasecmp
+#              define strcasecmp(a,b) _stricmp(a,b)
+#      endif
 
 #      ifndef __MINGW32__
 #              pragma comment(lib, "shell32")
@@ -57,30 +79,11 @@
 #      else
 #              define p_snprintf snprintf
 #      endif
-
-#      ifndef PRIuZ
-#              define PRIuZ "Iu"
-#      endif
-#      ifndef PRIxZ
-#              define PRIxZ "Ix"
-#      endif
-
-#      if defined(_MSC_VER) || defined(__MINGW32__)
-       typedef struct stat STAT_T;
-#      else
-       typedef struct _stat STAT_T;
-#      endif
 #else
 #      include <sys/wait.h> /* waitpid(2) */
 #      include <unistd.h>
 #      define _MAIN_CC
 #      define p_snprintf snprintf
-#      ifndef PRIuZ
-#              define PRIuZ "zu"
-#      endif
-#      ifndef PRIxZ
-#              define PRIxZ "zx"
-#      endif
        typedef struct stat STAT_T;
 #endif
 
@@ -99,7 +102,7 @@ fixture_path(const char *base, const char *fixture_name);
 struct clar_error {
        const char *file;
        const char *function;
-       size_t line_number;
+       uintmax_t line_number;
        const char *error_msg;
        char *description;
 
@@ -161,6 +164,10 @@ static struct {
        struct clar_report *reports;
        struct clar_report *last_report;
 
+       const char *invoke_file;
+       const char *invoke_func;
+       size_t invoke_line;
+
        void (*local_cleanup)(void *);
        void *local_cleanup_payload;
 
@@ -192,11 +199,14 @@ static void clar_print_shutdown(int test_count, int suite_count, int error_count
 static void clar_print_error(int num, const struct clar_report *report, const struct clar_error *error);
 static void clar_print_ontest(const char *suite_name, const char *test_name, int test_number, enum cl_test_status failed);
 static void clar_print_onsuite(const char *suite_name, int suite_index);
+static void clar_print_onabortv(const char *msg, va_list argp);
 static void clar_print_onabort(const char *msg, ...);
 
 /* From clar_sandbox.c */
-static void clar_unsandbox(void);
-static int clar_sandbox(void);
+static void clar_tempdir_init(void);
+static void clar_tempdir_shutdown(void);
+static int clar_sandbox_create(const char *suite_name, const char *test_name);
+static int clar_sandbox_cleanup(void);
 
 /* From summary.h */
 static struct clar_summary *clar_summary_init(const char *filename);
@@ -215,6 +225,15 @@ static int clar_summary_shutdown(struct clar_summary *fp);
                                                           _clar.trace_payload);                                        \
        } while (0)
 
+static void clar_abort(const char *msg, ...)
+{
+       va_list argp;
+       va_start(argp, msg);
+       clar_print_onabortv(msg, argp);
+       va_end(argp);
+       exit(-1);
+}
+
 void cl_trace_register(cl_trace_cb *cb, void *payload)
 {
        _clar.pfn_trace_cb = cb;
@@ -268,9 +287,7 @@ static double clar_time_diff(clar_time *start, clar_time *end)
 
 static void clar_time_now(clar_time *out)
 {
-       struct timezone tz;
-
-       gettimeofday(out, &tz);
+       gettimeofday(out, NULL);
 }
 
 static double clar_time_diff(clar_time *start, clar_time *end)
@@ -293,6 +310,8 @@ clar_run_test(
 
        CL_TRACE(CL_TRACE__TEST__BEGIN);
 
+       clar_sandbox_create(suite->name, test->name);
+
        _clar.last_report->start = time(NULL);
        clar_time_now(&start);
 
@@ -317,9 +336,13 @@ clar_run_test(
        if (_clar.local_cleanup != NULL)
                _clar.local_cleanup(_clar.local_cleanup_payload);
 
+       clar__clear_invokepoint();
+
        if (cleanup->ptr != NULL)
                cleanup->ptr();
 
+       clar_sandbox_cleanup();
+
        CL_TRACE(CL_TRACE__TEST__END);
 
        _clar.tests_ran++;
@@ -383,7 +406,8 @@ clar_run_suite(const struct clar_suite *suite, const char *filter)
 
                _clar.active_test = test[i].name;
 
-               report = calloc(1, sizeof(struct clar_report));
+               if ((report = calloc(1, sizeof(*report))) == NULL)
+                       clar_abort("Failed to allocate report.\n");
                report->suite = _clar.active_suite;
                report->test = _clar.active_test;
                report->test_number = _clar.tests_ran;
@@ -421,7 +445,7 @@ clar_usage(const char *arg)
        printf("  -t            Display results in tap format\n");
        printf("  -l            Print suite names\n");
        printf("  -r[filename]  Write summary file (to the optional filename)\n");
-       exit(-1);
+       exit(1);
 }
 
 static void
@@ -429,18 +453,11 @@ clar_parse_args(int argc, char **argv)
 {
        int i;
 
-       /* Verify options before execute */
        for (i = 1; i < argc; ++i) {
                char *argument = argv[i];
 
-               if (argument[0] != '-' || argument[1] == '\0'
-                   || strchr("sixvqQtlr", argument[1]) == NULL) {
+               if (argument[0] != '-' || argument[1] == '\0')
                        clar_usage(argv[0]);
-               }
-       }
-
-       for (i = 1; i < argc; ++i) {
-               char *argument = argv[i];
 
                switch (argument[1]) {
                case 's':
@@ -453,8 +470,13 @@ clar_parse_args(int argc, char **argv)
                        argument += offset;
                        arglen = strlen(argument);
 
-                       if (arglen == 0)
-                               clar_usage(argv[0]);
+                       if (arglen == 0) {
+                               if (i + 1 == argc)
+                                       clar_usage(argv[0]);
+
+                               argument = argv[++i];
+                               arglen = strlen(argument);
+                       }
 
                        for (j = 0; j < _clar_suite_count; ++j) {
                                suitelen = strlen(_clar_suites[j].name);
@@ -471,14 +493,12 @@ clar_parse_args(int argc, char **argv)
 
                                        ++found;
 
-                                       if (!exact)
-                                               _clar.verbosity = MAX(_clar.verbosity, 1);
-
                                        switch (action) {
                                        case 's': {
-                                               struct clar_explicit *explicit =
-                                                       calloc(1, sizeof(struct clar_explicit));
-                                               assert(explicit);
+                                               struct clar_explicit *explicit;
+
+                                               if ((explicit = calloc(1, sizeof(*explicit))) == NULL)
+                                                       clar_abort("Failed to allocate explicit test.\n");
 
                                                explicit->suite_idx = j;
                                                explicit->filter = argument;
@@ -502,27 +522,39 @@ clar_parse_args(int argc, char **argv)
                                }
                        }
 
-                       if (!found) {
-                               clar_print_onabort("No suite matching '%s' found.\n", argument);
-                               exit(-1);
-                       }
+                       if (!found)
+                               clar_abort("No suite matching '%s' found.\n", argument);
+
                        break;
                }
 
                case 'q':
+                       if (argument[2] != '\0')
+                               clar_usage(argv[0]);
+
                        _clar.report_errors_only = 1;
                        break;
 
                case 'Q':
+                       if (argument[2] != '\0')
+                               clar_usage(argv[0]);
+
                        _clar.exit_on_error = 1;
                        break;
 
                case 't':
+                       if (argument[2] != '\0')
+                               clar_usage(argv[0]);
+
                        _clar.output_format = CL_OUTPUT_TAP;
                        break;
 
                case 'l': {
                        size_t j;
+
+                       if (argument[2] != '\0')
+                               clar_usage(argv[0]);
+
                        printf("Test suites (use -s<name> to run just one):\n");
                        for (j = 0; j < _clar_suite_count; ++j)
                                printf(" %3d: %s\n", (int)j, _clar_suites[j].name);
@@ -531,17 +563,27 @@ clar_parse_args(int argc, char **argv)
                }
 
                case 'v':
+                       if (argument[2] != '\0')
+                               clar_usage(argv[0]);
+
                        _clar.verbosity++;
                        break;
 
                case 'r':
                        _clar.write_summary = 1;
                        free(_clar.summary_filename);
-                       _clar.summary_filename = *(argument + 2) ? strdup(argument + 2) : NULL;
+
+                       if (*(argument + 2)) {
+                               if ((_clar.summary_filename = strdup(argument + 2)) == NULL)
+                                       clar_abort("Failed to allocate summary filename.\n");
+                       } else {
+                               _clar.summary_filename = NULL;
+                       }
+
                        break;
 
                default:
-                       assert(!"Unexpected commandline argument!");
+                       clar_usage(argv[0]);
                }
        }
 }
@@ -563,22 +605,18 @@ clar_test_init(int argc, char **argv)
        if (!_clar.summary_filename &&
            (summary_env = getenv("CLAR_SUMMARY")) != NULL) {
                _clar.write_summary = 1;
-               _clar.summary_filename = strdup(summary_env);
+               if ((_clar.summary_filename = strdup(summary_env)) == NULL)
+                       clar_abort("Failed to allocate summary filename.\n");
        }
 
        if (_clar.write_summary && !_clar.summary_filename)
-               _clar.summary_filename = strdup("summary.xml");
+               if ((_clar.summary_filename = strdup("summary.xml")) == NULL)
+                       clar_abort("Failed to allocate summary filename.\n");
 
-       if (_clar.write_summary &&
-           !(_clar.summary = clar_summary_init(_clar.summary_filename))) {
-               clar_print_onabort("Failed to open the summary file\n");
-               exit(-1);
-       }
+       if (_clar.write_summary)
+           _clar.summary = clar_summary_init(_clar.summary_filename);
 
-       if (clar_sandbox() < 0) {
-               clar_print_onabort("Failed to sandbox the test runner.\n");
-               exit(-1);
-       }
+       clar_tempdir_init();
 }
 
 int
@@ -610,12 +648,11 @@ clar_test_shutdown(void)
                _clar.total_errors
        );
 
-       clar_unsandbox();
+       clar_tempdir_shutdown();
 
-       if (_clar.write_summary && clar_summary_shutdown(_clar.summary) < 0) {
-               clar_print_onabort("Failed to write the summary file\n");
-               exit(-1);
-       }
+       if (_clar.write_summary && clar_summary_shutdown(_clar.summary) < 0)
+               clar_abort("Failed to write the summary file '%s: %s.\n",
+                          _clar.summary_filename, strerror(errno));
 
        for (explicit = _clar.explicit; explicit; explicit = explicit_next) {
                explicit_next = explicit->next;
@@ -623,6 +660,14 @@ clar_test_shutdown(void)
        }
 
        for (report = _clar.reports; report; report = report_next) {
+               struct clar_error *error, *error_next;
+
+               for (error = report->errors; error; error = error_next) {
+                       free(error->description);
+                       error_next = error->next;
+                       free(error);
+               }
+
                report_next = report->next;
                free(report);
        }
@@ -646,9 +691,9 @@ static void abort_test(void)
 {
        if (!_clar.trampoline_enabled) {
                clar_print_onabort(
-                               "Fatal error: a cleanup method raised an exception.");
+                               "Fatal error: a cleanup method raised an exception.\n");
                clar_report_errors(_clar.last_report);
-               exit(-1);
+               exit(1);
        }
 
        CL_TRACE(CL_TRACE__TEST__LONGJMP);
@@ -670,7 +715,10 @@ void clar__fail(
        const char *description,
        int should_abort)
 {
-       struct clar_error *error = calloc(1, sizeof(struct clar_error));
+       struct clar_error *error;
+
+       if ((error = calloc(1, sizeof(*error))) == NULL)
+               clar_abort("Failed to allocate error.\n");
 
        if (_clar.last_report->errors == NULL)
                _clar.last_report->errors = error;
@@ -680,13 +728,14 @@ void clar__fail(
 
        _clar.last_report->last_error = error;
 
-       error->file = file;
-       error->function = function;
-       error->line_number = line;
+       error->file = _clar.invoke_file ? _clar.invoke_file : file;
+       error->function = _clar.invoke_func ? _clar.invoke_func : function;
+       error->line_number = _clar.invoke_line ? _clar.invoke_line : line;
        error->error_msg = error_msg;
 
-       if (description != NULL)
-               error->description = strdup(description);
+       if (description != NULL &&
+           (error->description = strdup(description)) == NULL)
+               clar_abort("Failed to allocate description.\n");
 
        _clar.total_errors++;
        _clar.last_report->status = CL_TEST_FAILURE;
@@ -760,6 +809,7 @@ void clar__assert_equal(
                        }
                }
        }
+#ifdef CLAR_HAVE_WCHAR
        else if (!strcmp("%ls", fmt)) {
                const wchar_t *wcs1 = va_arg(args, const wchar_t *);
                const wchar_t *wcs2 = va_arg(args, const wchar_t *);
@@ -795,8 +845,9 @@ void clar__assert_equal(
                        }
                }
        }
-       else if (!strcmp("%"PRIuZ, fmt) || !strcmp("%"PRIxZ, fmt)) {
-               size_t sz1 = va_arg(args, size_t), sz2 = va_arg(args, size_t);
+#endif /* CLAR_HAVE_WCHAR */
+       else if (!strcmp("%"PRIuMAX, fmt) || !strcmp("%"PRIxMAX, fmt)) {
+               uintmax_t sz1 = va_arg(args, uintmax_t), sz2 = va_arg(args, uintmax_t);
                is_equal = (sz1 == sz2);
                if (!is_equal) {
                        int offset = p_snprintf(buf, sizeof(buf), fmt, sz1);
@@ -808,7 +859,8 @@ void clar__assert_equal(
                void *p1 = va_arg(args, void *), *p2 = va_arg(args, void *);
                is_equal = (p1 == p2);
                if (!is_equal)
-                       p_snprintf(buf, sizeof(buf), "%p != %p", p1, p2);
+                       p_snprintf(buf, sizeof(buf), "0x%"PRIxPTR" != 0x%"PRIxPTR,
+                                  (uintptr_t)p1, (uintptr_t)p2);
        }
        else {
                int i1 = va_arg(args, int), i2 = va_arg(args, int);
@@ -832,6 +884,23 @@ void cl_set_cleanup(void (*cleanup)(void *), void *opaque)
        _clar.local_cleanup_payload = opaque;
 }
 
+void clar__set_invokepoint(
+       const char *file,
+       const char *func,
+       size_t line)
+{
+       _clar.invoke_file = file;
+       _clar.invoke_func = func;
+       _clar.invoke_line = line;
+}
+
+void clar__clear_invokepoint(void)
+{
+       _clar.invoke_file = NULL;
+       _clar.invoke_func = NULL;
+       _clar.invoke_line = 0;
+}
+
 #include "clar/sandbox.h"
 #include "clar/fixtures.h"
 #include "clar/fs.h"

diff --git a/tests/clar/clar.h b/tests/clar/clar.h
index 8c22382..ca72292 100644 (file)
--- a/tests/clar/clar.h
+++ b/tests/clar/clar.h
@@ -8,6 +8,25 @@
 #define __CLAR_TEST_H__
 
 #include <stdlib.h>
+#include <limits.h>
+
+#if defined(_WIN32) && defined(CLAR_WIN32_LONGPATHS)
+# define CLAR_MAX_PATH 4096
+#elif defined(_WIN32)
+# define CLAR_MAX_PATH MAX_PATH
+#else
+# define CLAR_MAX_PATH PATH_MAX
+#endif
+
+#ifndef CLAR_SELFTEST
+# define CLAR_CURRENT_FILE __FILE__
+# define CLAR_CURRENT_LINE __LINE__
+# define CLAR_CURRENT_FUNC __func__
+#else
+# define CLAR_CURRENT_FILE "file"
+# define CLAR_CURRENT_LINE 42
+# define CLAR_CURRENT_FUNC "func"
+#endif
 
 enum cl_test_status {
        CL_TEST_OK,
@@ -30,6 +49,7 @@ void clar_test_shutdown(void);
 int clar_test(int argc, char *argv[]);
 
 const char *clar_sandbox_path(void);
+const char *clar_tempdir_path(void);
 
 void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
 void cl_fs_cleanup(void);
@@ -84,18 +104,32 @@ const char *cl_fixture_basename(const char *fixture_name);
 #endif
 
 /**
+ * Invoke a helper function, which itself will use `cl_assert`
+ * constructs. This will preserve the stack information of the
+ * current call point, so that function name and line number
+ * information is shown from the line of the test, instead of
+ * the helper function.
+ */
+#define cl_invoke(expr) \
+       do { \
+               clar__set_invokepoint(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE); \
+               expr; \
+               clar__clear_invokepoint(); \
+       } while(0)
+
+/**
  * Assertion macros with explicit error message
  */
-#define cl_must_pass_(expr, desc) clar__assert((expr) >= 0, __FILE__, __func__, __LINE__, "Function call failed: " #expr, desc, 1)
-#define cl_must_fail_(expr, desc) clar__assert((expr) < 0, __FILE__, __func__, __LINE__, "Expected function call to fail: " #expr, desc, 1)
-#define cl_assert_(expr, desc) clar__assert((expr) != 0, __FILE__, __func__, __LINE__, "Expression is not true: " #expr, desc, 1)
+#define cl_must_pass_(expr, desc) clar__assert((expr) >= 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Function call failed: " #expr, desc, 1)
+#define cl_must_fail_(expr, desc) clar__assert((expr) < 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expected function call to fail: " #expr, desc, 1)
+#define cl_assert_(expr, desc) clar__assert((expr) != 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expression is not true: " #expr, desc, 1)
 
 /**
  * Check macros with explicit error message
  */
-#define cl_check_pass_(expr, desc) clar__assert((expr) >= 0, __FILE__, __func__, __LINE__, "Function call failed: " #expr, desc, 0)
-#define cl_check_fail_(expr, desc) clar__assert((expr) < 0, __FILE__, __func__, __LINE__, "Expected function call to fail: " #expr, desc, 0)
-#define cl_check_(expr, desc) clar__assert((expr) != 0, __FILE__, __func__, __LINE__, "Expression is not true: " #expr, desc, 0)
+#define cl_check_pass_(expr, desc) clar__assert((expr) >= 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Function call failed: " #expr, desc, 0)
+#define cl_check_fail_(expr, desc) clar__assert((expr) < 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expected function call to fail: " #expr, desc, 0)
+#define cl_check_(expr, desc) clar__assert((expr) != 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expression is not true: " #expr, desc, 0)
 
 /**
  * Assertion macros with no error message
@@ -114,33 +148,33 @@ const char *cl_fixture_basename(const char *fixture_name);
 /**
  * Forced failure/warning
  */
-#define cl_fail(desc) clar__fail(__FILE__, __func__, __LINE__, "Test failed.", desc, 1)
-#define cl_warning(desc) clar__fail(__FILE__, __func__, __LINE__, "Warning during test execution:", desc, 0)
+#define cl_fail(desc) clar__fail(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Test failed.", desc, 1)
+#define cl_warning(desc) clar__fail(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Warning during test execution:", desc, 0)
 
 #define cl_skip() clar__skip()
 
 /**
  * Typed assertion macros
  */
-#define cl_assert_equal_s(s1,s2) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
-#define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
+#define cl_assert_equal_s(s1,s2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
+#define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
 
-#define cl_assert_equal_wcs(wcs1,wcs2) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2, 1, "%ls", (wcs1), (wcs2))
-#define cl_assert_equal_wcs_(wcs1,wcs2,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%ls", (wcs1), (wcs2))
+#define cl_assert_equal_wcs(wcs1,wcs2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2, 1, "%ls", (wcs1), (wcs2))
+#define cl_assert_equal_wcs_(wcs1,wcs2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%ls", (wcs1), (wcs2))
 
-#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (int)(len))
-#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (int)(len))
+#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (int)(len))
+#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (int)(len))
 
-#define cl_assert_equal_wcsn(wcs1,wcs2,len) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2, 1, "%.*ls", (wcs1), (wcs2), (int)(len))
-#define cl_assert_equal_wcsn_(wcs1,wcs2,len,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%.*ls", (wcs1), (wcs2), (int)(len))
+#define cl_assert_equal_wcsn(wcs1,wcs2,len) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2, 1, "%.*ls", (wcs1), (wcs2), (int)(len))
+#define cl_assert_equal_wcsn_(wcs1,wcs2,len,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%.*ls", (wcs1), (wcs2), (int)(len))
 
-#define cl_assert_equal_i(i1,i2) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
-#define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
-#define cl_assert_equal_i_fmt(i1,i2,fmt) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2, 1, (fmt), (int)(i1), (int)(i2))
+#define cl_assert_equal_i(i1,i2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
+#define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
+#define cl_assert_equal_i_fmt(i1,i2,fmt) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2, 1, (fmt), (int)(i1), (int)(i2))
 
-#define cl_assert_equal_b(b1,b2) clar__assert_equal(__FILE__,__func__,__LINE__,#b1 " != " #b2, 1, "%d", (int)((b1) != 0),(int)((b2) != 0))
+#define cl_assert_equal_b(b1,b2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#b1 " != " #b2, 1, "%d", (int)((b1) != 0),(int)((b2) != 0))
 
-#define cl_assert_equal_p(p1,p2) clar__assert_equal(__FILE__,__func__,__LINE__,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))
+#define cl_assert_equal_p(p1,p2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))
 
 void clar__skip(void);
 
@@ -170,4 +204,11 @@ void clar__assert_equal(
        const char *fmt,
        ...);
 
+void clar__set_invokepoint(
+       const char *file,
+       const char *func,
+       size_t line);
+
+void clar__clear_invokepoint(void);
+
 #endif

diff --git a/tests/clar/clar/fixtures.h b/tests/clar/clar/fixtures.h
index 6ec6423..9f1023d 100644 (file)
--- a/tests/clar/clar/fixtures.h
+++ b/tests/clar/clar/fixtures.h
@@ -2,7 +2,7 @@
 static const char *
 fixture_path(const char *base, const char *fixture_name)
 {
-       static char _path[4096];
+       static char _path[CLAR_MAX_PATH];
        size_t root_len;
 
        root_len = strlen(base);
@@ -28,7 +28,7 @@ const char *cl_fixture(const char *fixture_name)
 
 void cl_fixture_sandbox(const char *fixture_name)
 {
-       fs_copy(cl_fixture(fixture_name), _clar_path);
+       fs_copy(cl_fixture(fixture_name), clar_sandbox_path());
 }
 
 const char *cl_fixture_basename(const char *fixture_name)
@@ -45,6 +45,6 @@ const char *cl_fixture_basename(const char *fixture_name)
 
 void cl_fixture_cleanup(const char *fixture_name)
 {
-       fs_rm(fixture_path(_clar_path, cl_fixture_basename(fixture_name)));
+       fs_rm(fixture_path(clar_sandbox_path(), cl_fixture_basename(fixture_name)));
 }
 #endif

diff --git a/tests/clar/clar/fs.h b/tests/clar/clar/fs.h
index a6eda5e..42fa471 100644 (file)
--- a/tests/clar/clar/fs.h
+++ b/tests/clar/clar/fs.h
@@ -8,12 +8,6 @@
 
 #ifdef _WIN32
 
-#ifdef CLAR_WIN32_LONGPATHS
-# define CLAR_MAX_PATH 4096
-#else
-# define CLAR_MAX_PATH MAX_PATH
-#endif
-
 #define RM_RETRY_COUNT 5
 #define RM_RETRY_DELAY 10
 
@@ -146,7 +140,7 @@ fs_rm_wait(WCHAR *_wpath)
                        ERROR_PATH_NOT_FOUND == last_error)
                        return 0;
 
-               Sleep(RM_RETRY_DELAY * retries * retries);      
+               Sleep(RM_RETRY_DELAY * retries * retries);
        }
        while (retries++ <= RM_RETRY_COUNT);
 
@@ -296,7 +290,9 @@ void
 cl_fs_cleanup(void)
 {
 #ifdef CLAR_FIXTURE_PATH
-       fs_rm(fixture_path(_clar_path, "*"));
+       fs_rm(fixture_path(clar_tempdir_path(), "*"));
+#else
+       ((void)fs_copy); /* unused */
 #endif
 }
 
@@ -516,7 +512,7 @@ fs_rm(const char *path)
 void
 cl_fs_cleanup(void)
 {
-       clar_unsandbox();
-       clar_sandbox();
+       clar_tempdir_shutdown();
+       clar_tempdir_init();
 }
 #endif

diff --git a/tests/clar/clar/print.h b/tests/clar/clar/print.h
index c17e2f6..f577c01 100644 (file)
--- a/tests/clar/clar/print.h
+++ b/tests/clar/clar/print.h
@@ -21,7 +21,7 @@ static void clar_print_clap_error(int num, const struct clar_report *report, con
 {
        printf("  %d) Failure:\n", num);
 
-       printf("%s::%s [%s:%"PRIuZ"]\n",
+       printf("%s::%s [%s:%"PRIuMAX"]\n",
                report->suite,
                report->test,
                error->file,
@@ -47,8 +47,8 @@ static void clar_print_clap_ontest(const char *suite_name, const char *test_name
                switch (status) {
                case CL_TEST_OK: printf("ok\n"); break;
                case CL_TEST_FAILURE: printf("fail\n"); break;
-               case CL_TEST_SKIP: printf("skipped"); break;
-               case CL_TEST_NOTRUN: printf("notrun"); break;
+               case CL_TEST_SKIP: printf("skipped\n"); break;
+               case CL_TEST_NOTRUN: printf("notrun\n"); break;
                }
        } else {
                switch (status) {
@@ -136,7 +136,7 @@ static void clar_print_tap_ontest(const char *suite_name, const char *test_name,
 
                printf("    at:\n");
                printf("      file: '"); print_escaped(error->file); printf("'\n");
-               printf("      line: %" PRIuZ "\n", error->line_number);
+               printf("      line: %" PRIuMAX "\n", error->line_number);
                printf("      function: '%s'\n", error->function);
                printf("    ---\n");
 
@@ -202,10 +202,15 @@ static void clar_print_onsuite(const char *suite_name, int suite_index)
        PRINT(onsuite, suite_name, suite_index);
 }
 
+static void clar_print_onabortv(const char *msg, va_list argp)
+{
+       PRINT(onabort, msg, argp);
+}
+
 static void clar_print_onabort(const char *msg, ...)
 {
        va_list argp;
        va_start(argp, msg);
-       PRINT(onabort, msg, argp);
+       clar_print_onabortv(msg, argp);
        va_end(argp);
 }

diff --git a/tests/clar/clar/sandbox.h b/tests/clar/clar/sandbox.h
index 0688374..ff43159 100644 (file)
--- a/tests/clar/clar/sandbox.h
+++ b/tests/clar/clar/sandbox.h
@@ -2,8 +2,17 @@
 #include <sys/syslimits.h>
 #endif
 
-#define CLAR_PATH_MAX 4096
-static char _clar_path[CLAR_PATH_MAX];
+/*
+ * The tempdir is the temporary directory for the entirety of the clar
+ * process execution. The sandbox is an individual temporary directory
+ * for the execution of an individual test. Sandboxes are deleted
+ * entirely after test execution to avoid pollution across tests.
+ */
+
+static char _clar_tempdir[CLAR_MAX_PATH];
+static size_t _clar_tempdir_len;
+
+static char _clar_sandbox[CLAR_MAX_PATH];
 
 static int
 is_valid_tmp_path(const char *path)
@@ -16,7 +25,10 @@ is_valid_tmp_path(const char *path)
        if (!S_ISDIR(st.st_mode))
                return 0;
 
-       return (access(path, W_OK) == 0);
+       if (access(path, W_OK) != 0)
+               return 0;
+
+       return (strlen(path) < CLAR_MAX_PATH);
 }
 
 static int
@@ -26,19 +38,17 @@ find_tmp_path(char *buffer, size_t length)
        static const size_t var_count = 5;
        static const char *env_vars[] = {
                "CLAR_TMP", "TMPDIR", "TMP", "TEMP", "USERPROFILE"
-       };
+       };
 
-       size_t i;
+       size_t i;
 
        for (i = 0; i < var_count; ++i) {
                const char *env = getenv(env_vars[i]);
+
                if (!env)
                        continue;
 
                if (is_valid_tmp_path(env)) {
-                       if (strlen(env) + 1 > CLAR_PATH_MAX)
-                               return -1;
-
                        strncpy(buffer, env, length - 1);
                        buffer[length - 1] = '\0';
                        return 0;
@@ -53,11 +63,12 @@ find_tmp_path(char *buffer, size_t length)
        }
 
 #else
-       DWORD env_len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
-       if (env_len > 0 && env_len < (DWORD)length)
+       DWORD len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
+       if (len > 0 && len < (DWORD)length)
                return 0;
 
-       if (GetTempPath((DWORD)length, buffer))
+       len = GetTempPath((DWORD)length, buffer);
+       if (len > 0 && len < (DWORD)length)
                return 0;
 #endif
 
@@ -74,42 +85,50 @@ find_tmp_path(char *buffer, size_t length)
 static int canonicalize_tmp_path(char *buffer)
 {
 #ifdef _WIN32
-       char tmp[CLAR_PATH_MAX];
+       char tmp[CLAR_MAX_PATH], *p;
        DWORD ret;
 
-       ret = GetFullPathName(buffer, CLAR_PATH_MAX, tmp, NULL);
+       ret = GetFullPathName(buffer, CLAR_MAX_PATH, tmp, NULL);
 
-       if (ret == 0 || ret > CLAR_PATH_MAX)
+       if (ret == 0 || ret > CLAR_MAX_PATH)
                return -1;
 
-       ret = GetLongPathName(tmp, buffer, CLAR_PATH_MAX);
+       ret = GetLongPathName(tmp, buffer, CLAR_MAX_PATH);
 
-       if (ret == 0 || ret > CLAR_PATH_MAX)
+       if (ret == 0 || ret > CLAR_MAX_PATH)
                return -1;
 
+       /* normalize path to POSIX forward slashes */
+       for (p = buffer; *p; p++)
+               if (*p == '\\')
+                       *p = '/';
+
        return 0;
-#else
-       char tmp[CLAR_PATH_MAX];
+#elif defined(CLAR_HAS_REALPATH)
+       char tmp[CLAR_MAX_PATH];
 
        if (realpath(buffer, tmp) == NULL)
                return -1;
 
        strcpy(buffer, tmp);
        return 0;
+#else
+       (void)buffer;
+       return 0;
 #endif
 }
 
-static void clar_unsandbox(void)
+static void clar_tempdir_shutdown(void)
 {
-       if (_clar_path[0] == '\0')
+       if (_clar_tempdir[0] == '\0')
                return;
 
        cl_must_pass(chdir(".."));
 
-       fs_rm(_clar_path);
+       fs_rm(_clar_tempdir);
 }
 
-static int build_sandbox_path(void)
+static int build_tempdir_path(void)
 {
 #ifdef CLAR_TMPDIR
        const char path_tail[] = CLAR_TMPDIR "_XXXXXX";
@@ -119,61 +138,153 @@ static int build_sandbox_path(void)
 
        size_t len;
 
-       if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0 ||
-           canonicalize_tmp_path(_clar_path) < 0)
+       if (find_tmp_path(_clar_tempdir, sizeof(_clar_tempdir)) < 0 ||
+           canonicalize_tmp_path(_clar_tempdir) < 0)
                return -1;
 
-       len = strlen(_clar_path);
+       len = strlen(_clar_tempdir);
 
-#ifdef _WIN32
-       { /* normalize path to POSIX forward slashes */
-               size_t i;
-               for (i = 0; i < len; ++i) {
-                       if (_clar_path[i] == '\\')
-                               _clar_path[i] = '/';
-               }
-       }
-#endif
+       if (len + strlen(path_tail) + 2 > CLAR_MAX_PATH)
+               return -1;
 
-       if (_clar_path[len - 1] != '/') {
-               _clar_path[len++] = '/';
-       }
+       if (_clar_tempdir[len - 1] != '/')
+               _clar_tempdir[len++] = '/';
 
-       strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
+       strncpy(_clar_tempdir + len, path_tail, sizeof(_clar_tempdir) - len);
 
 #if defined(__MINGW32__)
-       if (_mktemp(_clar_path) == NULL)
+       if (_mktemp(_clar_tempdir) == NULL)
                return -1;
 
-       if (mkdir(_clar_path, 0700) != 0)
+       if (mkdir(_clar_tempdir, 0700) != 0)
                return -1;
 #elif defined(_WIN32)
-       if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0)
+       if (_mktemp_s(_clar_tempdir, sizeof(_clar_tempdir)) != 0)
                return -1;
 
-       if (mkdir(_clar_path, 0700) != 0)
+       if (mkdir(_clar_tempdir, 0700) != 0)
+               return -1;
+#elif defined(__sun) || defined(__TANDEM)
+       if (mktemp(_clar_tempdir) == NULL)
+               return -1;
+
+       if (mkdir(_clar_tempdir, 0700) != 0)
                return -1;
 #else
-       if (mkdtemp(_clar_path) == NULL)
+       if (mkdtemp(_clar_tempdir) == NULL)
                return -1;
 #endif
 
+       _clar_tempdir_len = strlen(_clar_tempdir);
        return 0;
 }
 
-static int clar_sandbox(void)
+static void clar_tempdir_init(void)
 {
-       if (_clar_path[0] == '\0' && build_sandbox_path() < 0)
+       if (_clar_tempdir[0] == '\0' && build_tempdir_path() < 0)
+               clar_abort("Failed to build tempdir path.\n");
+
+       if (chdir(_clar_tempdir) != 0)
+               clar_abort("Failed to change into tempdir '%s': %s.\n",
+                          _clar_tempdir, strerror(errno));
+
+#if !defined(CLAR_SANDBOX_TEST_NAMES) && defined(_WIN32)
+       srand(clock() ^ (unsigned int)time(NULL) ^ GetCurrentProcessId() ^ GetCurrentThreadId());
+#elif !defined(CLAR_SANDBOX_TEST_NAMES)
+       srand(clock() ^ time(NULL) ^ (getpid() << 16));
+#endif
+}
+
+static void append(char *dst, const char *src)
+{
+       char *d;
+       const char *s;
+
+       for (d = dst; *d; d++)
+               ;
+
+       for (s = src; *s; d++, s++)
+               if (*s == ':')
+                       *d = '_';
+               else
+                       *d = *s;
+
+       *d = '\0';
+}
+
+static int clar_sandbox_create(const char *suite_name, const char *test_name)
+{
+#ifndef CLAR_SANDBOX_TEST_NAMES
+       char alpha[] = "0123456789abcdef";
+       int num = rand();
+#endif
+
+       cl_assert(_clar_sandbox[0] == '\0');
+
+       /*
+        * We may want to use test names as sandbox directory names for
+        * readability, _however_ on platforms with restrictions for short
+        * file / folder names (eg, Windows), this may be too long.
+        */
+#ifdef CLAR_SANDBOX_TEST_NAMES
+       cl_assert(strlen(_clar_tempdir) + strlen(suite_name) + strlen(test_name) + 3 < CLAR_MAX_PATH);
+
+       strcpy(_clar_sandbox, _clar_tempdir);
+       _clar_sandbox[_clar_tempdir_len] = '/';
+       _clar_sandbox[_clar_tempdir_len + 1] = '\0';
+
+       append(_clar_sandbox, suite_name);
+       append(_clar_sandbox, "__");
+       append(_clar_sandbox, test_name);
+#else
+       ((void)suite_name);
+       ((void)test_name);
+       ((void)append);
+
+       cl_assert(strlen(_clar_tempdir) + 9 < CLAR_MAX_PATH);
+
+       strcpy(_clar_sandbox, _clar_tempdir);
+       _clar_sandbox[_clar_tempdir_len] = '/';
+
+       _clar_sandbox[_clar_tempdir_len + 1] = alpha[(num & 0xf0000000) >> 28];
+       _clar_sandbox[_clar_tempdir_len + 2] = alpha[(num & 0x0f000000) >> 24];
+       _clar_sandbox[_clar_tempdir_len + 3] = alpha[(num & 0x00f00000) >> 20];
+       _clar_sandbox[_clar_tempdir_len + 4] = alpha[(num & 0x000f0000) >> 16];
+       _clar_sandbox[_clar_tempdir_len + 5] = alpha[(num & 0x0000f000) >> 12];
+       _clar_sandbox[_clar_tempdir_len + 6] = alpha[(num & 0x00000f00) >> 8];
+       _clar_sandbox[_clar_tempdir_len + 7] = alpha[(num & 0x000000f0) >> 4];
+       _clar_sandbox[_clar_tempdir_len + 8] = alpha[(num & 0x0000000f) >> 0];
+       _clar_sandbox[_clar_tempdir_len + 9] = '\0';
+#endif
+
+       if (mkdir(_clar_sandbox, 0700) != 0)
                return -1;
 
-       if (chdir(_clar_path) != 0)
+       if (chdir(_clar_sandbox) != 0)
                return -1;
 
        return 0;
 }
 
-const char *clar_sandbox_path(void)
+static int clar_sandbox_cleanup(void)
+{
+       cl_assert(_clar_sandbox[0] != '\0');
+
+       if (chdir(_clar_tempdir) != 0)
+               return -1;
+
+       fs_rm(_clar_sandbox);
+       _clar_sandbox[0] = '\0';
+
+       return 0;
+}
+
+const char *clar_tempdir_path(void)
 {
-       return _clar_path;
+       return _clar_tempdir;
 }
 
+const char *clar_sandbox_path(void)
+{
+       return _clar_sandbox;
+}

diff --git a/tests/clar/clar/summary.h b/tests/clar/clar/summary.h
index 4dd352e..0d0b646 100644 (file)
--- a/tests/clar/clar/summary.h
+++ b/tests/clar/clar/summary.h
@@ -66,16 +66,12 @@ struct clar_summary *clar_summary_init(const char *filename)
        struct clar_summary *summary;
        FILE *fp;
 
-       if ((fp = fopen(filename, "w")) == NULL) {
-               perror("fopen");
-               return NULL;
-       }
+       if ((fp = fopen(filename, "w")) == NULL)
+               clar_abort("Failed to open the summary file '%s': %s.\n",
+                          filename, strerror(errno));
 
-       if ((summary = malloc(sizeof(struct clar_summary))) == NULL) {
-               perror("malloc");
-               fclose(fp);
-               return NULL;
-       }
+       if ((summary = malloc(sizeof(struct clar_summary))) == NULL)
+               clar_abort("Failed to allocate summary.\n");
 
        summary->filename = filename;
        summary->fp = fp;

diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c
index a1b92fc..c4a2dfc 100644 (file)
--- a/tests/clar/clar_libgit2.c
+++ b/tests/clar/clar_libgit2.c
@@ -649,7 +649,7 @@ void cl_sandbox_set_homedir(const char *home)
        if (home) {
                git_libgit2_opts(GIT_OPT_SET_HOMEDIR, home);
        } else {
-               git_str_joinpath(&path, clar_sandbox_path(), "__home");
+               git_str_joinpath(&path, clar_tempdir_path(), "__home");
 
                if (!git_fs_path_exists(path.ptr))
                        cl_must_pass(p_mkdir(path.ptr, 0777));
@@ -664,7 +664,7 @@ void cl_sandbox_set_search_path_defaults(void)
 {
        git_str path = GIT_STR_INIT;
 
-       git_str_joinpath(&path, clar_sandbox_path(), "__config");
+       git_str_joinpath(&path, clar_tempdir_path(), "__config");
 
        if (!git_fs_path_exists(path.ptr))
                cl_must_pass(p_mkdir(path.ptr, 0777));

diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt
index f058b6e..7a4bb47 100644 (file)
--- a/tests/libgit2/CMakeLists.txt
+++ b/tests/libgit2/CMakeLists.txt
@@ -18,6 +18,7 @@ set(TEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
 add_definitions(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\")
 add_definitions(-DCLAR_TMPDIR=\"libgit2_tests\")
 add_definitions(-DCLAR_WIN32_LONGPATHS)
+add_definitions(-DCLAR_HAS_REALPATH)
 add_definitions(-D_FILE_OFFSET_BITS=64)
 
 # Ensure that we do not use deprecated functions internally

diff --git a/tests/util/CMakeLists.txt b/tests/util/CMakeLists.txt
index 20a95a2..425c27d 100644 (file)
--- a/tests/util/CMakeLists.txt
+++ b/tests/util/CMakeLists.txt
@@ -18,6 +18,7 @@ set(TEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
 add_definitions(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\")
 add_definitions(-DCLAR_TMPDIR=\"libgit2_tests\")
 add_definitions(-DCLAR_WIN32_LONGPATHS)
+add_definitions(-DCLAR_HAS_REALPATH)
 add_definitions(-D_FILE_OFFSET_BITS=64)
 
 # Ensure that we do not use deprecated functions internally