Introduce clar testing framework

Hi Phillip,

thank you for looping me in; I meant to answer earlier.

I am very, very happy to see that there is a chance to adopt a test framework like clar. Therefore, I am very interested in assisting in every which way I can.

Quoted 4 lines

Johannes - are these format specifiers supported by the version of MSVCRT that is used by git for windows? c.f.
https://lore.kernel.org/git/[email protected]/

The format specifiers _should_ work well both with GCC and Visual C. What did not work well was using struct stat with _stat() (note that the latter has a leading underscore and the former does not).

There were other issues, top of which was the bit tricky part to adapt the CMakeLists.txt definition, in particular the part where clar.suite is generated. But I managed to squeeze in that work somehow and Patrick was kind enough to already integrate the patches.

Ciao,
Johannes

Quoted 2,756 lines · Patrick Steinhardt

t/unit-tests/clar/clar.c line 69

Quoted 10 lines

t/unit-tests/clar/clar.c +7 -0

[...]
+#ifdef _WIN32
[...]
+#	ifndef PRIuZ
+#		define PRIuZ "Iu"
+#	endif
+#	ifndef PRIxZ
+#		define PRIxZ "Ix"
+#	endif

Thanks

Phillip

Quoted 2,739 lines

t/unit-tests/clar/clar.c +123 -0

+#	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
+
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
+
+#include "clar.h"
+
+static void fs_rm(const char *_source);
+static void fs_copy(const char *_source, const char *dest);
+
+#ifdef CLAR_FIXTURE_PATH
+static const char *
+fixture_path(const char *base, const char *fixture_name);
+#endif
+
+struct clar_error {
+	const char *file;
+	const char *function;
+	size_t line_number;
+	const char *error_msg;
+	char *description;
+
+	struct clar_error *next;
+};
+
+struct clar_explicit {
+	size_t suite_idx;
+	const char *filter;
+
+	struct clar_explicit *next;
+};
+
+struct clar_report {
+	const char *test;
+	int test_number;
+	const char *suite;
+
+	enum cl_test_status status;
+	time_t start;
+	double elapsed;
+
+	struct clar_error *errors;
+	struct clar_error *last_error;
+
+	struct clar_report *next;
+};
+
+struct clar_summary {
+	const char *filename;
+	FILE *fp;
+};
+
+static struct {
+	enum cl_test_status test_status;
+
+	const char *active_test;
+	const char *active_suite;
+
+	int total_skipped;
+	int total_errors;
+
+	int tests_ran;
+	int suites_ran;
+
+	enum cl_output_format output_format;
+
+	int report_errors_only;
+	int exit_on_error;
+	int verbosity;
+
+	int write_summary;
+	char *summary_filename;
+	struct clar_summary *summary;
+
+	struct clar_explicit *explicit;
+	struct clar_explicit *last_explicit;
+
+	struct clar_report *reports;
+	struct clar_report *last_report;
+
+	void (*local_cleanup)(void *);
+	void *local_cleanup_payload;
+
+	jmp_buf trampoline;
+	int trampoline_enabled;
+
+	cl_trace_cb *pfn_trace_cb;
+	void *trace_payload;
+
+} _clar;
+
+struct clar_func {
+	const char *name;
+	void (*ptr)(void);
+};
+
+struct clar_suite {
+	const char *name;
+	struct clar_func initialize;
+	struct clar_func cleanup;
+	const struct clar_func *tests;
+	size_t test_count;
+	int enabled;
+};
+
+/* From clar_print_*.c */
+static void clar_print_init(int test_count, int suite_count, const char

*suite_names);
+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);

t/unit-tests/clar/clar.c +16 -0

+static void clar_print_onsuite(const char *suite_name, int suite_index);
+static void clar_print_onabort(const char *msg, ...);
+
+/* From clar_sandbox.c */
+static void clar_unsandbox(void);
+static int clar_sandbox(void);
+
+/* From summary.h */
+static struct clar_summary *clar_summary_init(const char *filename);
+static int clar_summary_shutdown(struct clar_summary *fp);
+
+/* Load the declarations for the test suite */
+#include "clar.suite"
+
+
+#define CL_TRACE(ev)

\

t/unit-tests/clar/clar.c +1 -0

+	do {

\

t/unit-tests/clar/clar.c +1 -0

+		if (_clar.pfn_trace_cb)

\

t/unit-tests/clar/clar.c +1 -0

+			_clar.pfn_trace_cb(ev,

\

t/unit-tests/clar/clar.c +1 -0

+							   _clar.active_suite,

\

t/unit-tests/clar/clar.c +1 -0

+							   _clar.active_test,

\
+
_clar.trace_payload); \

t/unit-tests/clar/clar.c +119 -0

+	} while (0)
+
+void cl_trace_register(cl_trace_cb *cb, void *payload)
+{
+	_clar.pfn_trace_cb = cb;
+	_clar.trace_payload = payload;
+}
+
+
+/* Core test functions */
+static void
+clar_report_errors(struct clar_report *report)
+{
+	struct clar_error *error;
+	int i = 1;
+
+	for (error = report->errors; error; error = error->next)
+		clar_print_error(i++, _clar.last_report, error);
+}
+
+static void
+clar_report_all(void)
+{
+	struct clar_report *report;
+	struct clar_error *error;
+	int i = 1;
+
+	for (report = _clar.reports; report; report = report->next) {
+		if (report->status != CL_TEST_FAILURE)
+			continue;
+
+		for (error = report->errors; error; error = error->next)
+			clar_print_error(i++, report, error);
+	}
+}
+
+#ifdef WIN32
+# define clar_time DWORD
+
+static void clar_time_now(clar_time *out)
+{
+	*out = GetTickCount();
+}
+
+static double clar_time_diff(clar_time *start, clar_time *end)
+{
+	return ((double)*end - (double)*start) / 1000;
+}
+#else
+# include <sys/time.h>
+
+# define clar_time struct timeval
+
+static void clar_time_now(clar_time *out)
+{
+	struct timezone tz;
+
+	gettimeofday(out, &tz);
+}
+
+static double clar_time_diff(clar_time *start, clar_time *end)
+{
+	return ((double)end->tv_sec + (double)end->tv_usec / 1.0E6) -
+	       ((double)start->tv_sec + (double)start->tv_usec / 1.0E6);
+}
+#endif
+
+static void
+clar_run_test(
+	const struct clar_suite *suite,
+	const struct clar_func *test,
+	const struct clar_func *initialize,
+	const struct clar_func *cleanup)
+{
+	clar_time start, end;
+
+	_clar.trampoline_enabled = 1;
+
+	CL_TRACE(CL_TRACE__TEST__BEGIN);
+
+	_clar.last_report->start = time(NULL);
+	clar_time_now(&start);
+
+	if (setjmp(_clar.trampoline) == 0) {
+		if (initialize->ptr != NULL)
+			initialize->ptr();
+
+		CL_TRACE(CL_TRACE__TEST__RUN_BEGIN);
+		test->ptr();
+		CL_TRACE(CL_TRACE__TEST__RUN_END);
+	}
+
+	clar_time_now(&end);
+
+	_clar.trampoline_enabled = 0;
+
+	if (_clar.last_report->status == CL_TEST_NOTRUN)
+		_clar.last_report->status = CL_TEST_OK;
+
+	_clar.last_report->elapsed = clar_time_diff(&start, &end);
+
+	if (_clar.local_cleanup != NULL)
+		_clar.local_cleanup(_clar.local_cleanup_payload);
+
+	if (cleanup->ptr != NULL)
+		cleanup->ptr();
+
+	CL_TRACE(CL_TRACE__TEST__END);
+
+	_clar.tests_ran++;
+
+	/* remove any local-set cleanup methods */
+	_clar.local_cleanup = NULL;
+	_clar.local_cleanup_payload = NULL;
+
+	if (_clar.report_errors_only) {
+		clar_report_errors(_clar.last_report);
+	} else {
+		clar_print_ontest(suite->name, test->name, _clar.tests_ran,

_clar.last_report->status);

t/unit-tests/clar/clar.c +66 -0

+	}
+}
+
+static void
+clar_run_suite(const struct clar_suite *suite, const char *filter)
+{
+	const struct clar_func *test = suite->tests;
+	size_t i, matchlen;
+	struct clar_report *report;
+	int exact = 0;
+
+	if (!suite->enabled)
+		return;
+
+	if (_clar.exit_on_error && _clar.total_errors)
+		return;
+
+	if (!_clar.report_errors_only)
+		clar_print_onsuite(suite->name, ++_clar.suites_ran);
+
+	_clar.active_suite = suite->name;
+	_clar.active_test = NULL;
+	CL_TRACE(CL_TRACE__SUITE_BEGIN);
+
+	if (filter) {
+		size_t suitelen = strlen(suite->name);
+		matchlen = strlen(filter);
+		if (matchlen <= suitelen) {
+			filter = NULL;
+		} else {
+			filter += suitelen;
+			while (*filter == ':')
+				++filter;
+			matchlen = strlen(filter);
+
+			if (matchlen && filter[matchlen - 1] == '$') {
+				exact = 1;
+				matchlen--;
+			}
+		}
+	}
+
+	for (i = 0; i < suite->test_count; ++i) {
+		if (filter && strncmp(test[i].name, filter, matchlen))
+			continue;
+
+		if (exact && strlen(test[i].name) != matchlen)
+			continue;
+
+		_clar.active_test = test[i].name;
+
+		report = calloc(1, sizeof(struct clar_report));
+		report->suite = _clar.active_suite;
+		report->test = _clar.active_test;
+		report->test_number = _clar.tests_ran;
+		report->status = CL_TEST_NOTRUN;
+
+		if (_clar.reports == NULL)
+			_clar.reports = report;
+
+		if (_clar.last_report != NULL)
+			_clar.last_report->next = report;
+
+		_clar.last_report = report;
+
+		clar_run_test(suite, &test[i], &suite->initialize,

&suite->cleanup);

t/unit-tests/clar/clar.c +15 -0

+
+		if (_clar.exit_on_error && _clar.total_errors)
+			return;
+	}
+
+	_clar.active_test = NULL;
+	CL_TRACE(CL_TRACE__SUITE_END);
+}
+
+static void
+clar_usage(const char *arg)
+{
+	printf("Usage: %s [options]\n\n", arg);
+	printf("Options:\n");
+	printf("  -sname        Run only the suite with `name` (can go to

individual test name)\n");

t/unit-tests/clar/clar.c +8 -0

+	printf("  -iname        Include the suite with `name`\n");
+	printf("  -xname        Exclude the suite with `name`\n");
+	printf("  -v            Increase verbosity (show suite names)\n");
+	printf("  -q            Only report tests that had an error\n");
+	printf("  -Q            Quit as soon as a test fails\n");
+	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");

t/unit-tests/clar/clar.c +38 -0

+	exit(-1);
+}
+
+static void
+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) {
+			clar_usage(argv[0]);
+		}
+	}
+
+	for (i = 1; i < argc; ++i) {
+		char *argument = argv[i];
+
+		switch (argument[1]) {
+		case 's':
+		case 'i':
+		case 'x': { /* given suite name */
+			int offset = (argument[2] == '=') ? 3 : 2, found = 0;
+			char action = argument[1];
+			size_t j, arglen, suitelen, cmplen;
+
+			argument += offset;
+			arglen = strlen(argument);
+
+			if (arglen == 0)
+				clar_usage(argv[0]);
+
+			for (j = 0; j < _clar_suite_count; ++j) {
+				suitelen = strlen(_clar_suites[j].name);
+				cmplen = (arglen < suitelen) ? arglen :

suitelen;

t/unit-tests/clar/clar.c +2 -0

+
+				if (strncmp(argument, _clar_suites[j].name,

cmplen) == 0) {

t/unit-tests/clar/clar.c +3 -0

+					int exact = (arglen >= suitelen);
+
+					/* Do we have a real suite prefix

separated by a

t/unit-tests/clar/clar.c +1 -0

+					 * trailing '::' or just a matching

substring? */

t/unit-tests/clar/clar.c +1 -0

+					if (arglen > suitelen &&

(argument[suitelen] != ':'

t/unit-tests/clar/clar.c +1 -0

+						    || argument[suitelen + 1]

!= ':'))

t/unit-tests/clar/clar.c +6 -0

+					    continue;
+
+					++found;
+
+					if (!exact)
+						_clar.verbosity =

MAX(_clar.verbosity, 1);

t/unit-tests/clar/clar.c +4 -0

+
+					switch (action) {
+					case 's': {
+						struct clar_explicit *explicit

=

t/unit-tests/clar/clar.c +1 -0

+							calloc(1,

sizeof(struct clar_explicit));

t/unit-tests/clar/clar.c +7 -0

+						assert(explicit);
+
+						explicit->suite_idx = j;
+						explicit->filter = argument;
+
+						if (_clar.explicit == NULL)
+							_clar.explicit =

explicit;

t/unit-tests/clar/clar.c +2 -0

+
+						if (_clar.last_explicit !=

NULL)
+
_clar.last_explicit->next = explicit;

t/unit-tests/clar/clar.c +3 -0

+
+						_clar_suites[j].enabled = 1;
+						_clar.last_explicit =

explicit;

t/unit-tests/clar/clar.c +3 -0

+						break;
+					}
+					case 'i': _clar_suites[j].enabled = 1;

break;

t/unit-tests/clar/clar.c +1 -0

+					case 'x': _clar_suites[j].enabled = 0;

break;

t/unit-tests/clar/clar.c +9 -0

+					}
+
+					if (exact)
+						break;
+				}
+			}
+
+			if (!found) {
+				clar_print_onabort("No suite matching '%s'

found.\n", argument);

t/unit-tests/clar/clar.c +20 -0

+				exit(-1);
+			}
+			break;
+		}
+
+		case 'q':
+			_clar.report_errors_only = 1;
+			break;
+
+		case 'Q':
+			_clar.exit_on_error = 1;
+			break;
+
+		case 't':
+			_clar.output_format = CL_OUTPUT_TAP;
+			break;
+
+		case 'l': {
+			size_t j;
+			printf("Test suites (use -s<name> to run just

one):\n");

t/unit-tests/clar/clar.c +2 -0

+			for (j = 0; j < _clar_suite_count; ++j)
+				printf(" %3d: %s\n", (int)j,

_clar_suites[j].name);

t/unit-tests/clar/clar.c +12 -0

+
+			exit(0);
+		}
+
+		case 'v':
+			_clar.verbosity++;
+			break;
+
+		case 'r':
+			_clar.write_summary = 1;
+			free(_clar.summary_filename);
+			_clar.summary_filename = *(argument + 2) ?

strdup(argument + 2) : NULL;

t/unit-tests/clar/clar.c +51 -0

+			break;
+
+		default:
+			assert(!"Unexpected commandline argument!");
+		}
+	}
+}
+
+void
+clar_test_init(int argc, char **argv)
+{
+	const char *summary_env;
+
+	if (argc > 1)
+		clar_parse_args(argc, argv);
+
+	clar_print_init(
+		(int)_clar_callback_count,
+		(int)_clar_suite_count,
+		""
+	);
+
+	if (!_clar.summary_filename &&
+	    (summary_env = getenv("CLAR_SUMMARY")) != NULL) {
+		_clar.write_summary = 1;
+		_clar.summary_filename = strdup(summary_env);
+	}
+
+	if (_clar.write_summary && !_clar.summary_filename)
+		_clar.summary_filename = strdup("summary.xml");
+
+	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_sandbox() < 0) {
+		clar_print_onabort("Failed to sandbox the test runner.\n");
+		exit(-1);
+	}
+}
+
+int
+clar_test_run(void)
+{
+	size_t i;
+	struct clar_explicit *explicit;
+
+	if (_clar.explicit) {
+		for (explicit = _clar.explicit; explicit; explicit =

explicit->next)

t/unit-tests/clar/clar.c +1 -0

+			clar_run_suite(&_clar_suites[explicit->suite_idx],

explicit->filter);

t/unit-tests/clar/clar.c +57 -0

+	} else {
+		for (i = 0; i < _clar_suite_count; ++i)
+			clar_run_suite(&_clar_suites[i], NULL);
+	}
+
+	return _clar.total_errors;
+}
+
+void
+clar_test_shutdown(void)
+{
+	struct clar_explicit *explicit, *explicit_next;
+	struct clar_report *report, *report_next;
+
+	clar_print_shutdown(
+		_clar.tests_ran,
+		(int)_clar_suite_count,
+		_clar.total_errors
+	);
+
+	clar_unsandbox();
+
+	if (_clar.write_summary && clar_summary_shutdown(_clar.summary) < 0) {
+		clar_print_onabort("Failed to write the summary file\n");
+		exit(-1);
+	}
+
+	for (explicit = _clar.explicit; explicit; explicit = explicit_next) {
+		explicit_next = explicit->next;
+		free(explicit);
+	}
+
+	for (report = _clar.reports; report; report = report_next) {
+		report_next = report->next;
+		free(report);
+	}
+
+	free(_clar.summary_filename);
+}
+
+int
+clar_test(int argc, char **argv)
+{
+	int errors;
+
+	clar_test_init(argc, argv);
+	errors = clar_test_run();
+	clar_test_shutdown();
+
+	return errors;
+}
+
+static void abort_test(void)
+{
+	if (!_clar.trampoline_enabled) {
+		clar_print_onabort(
+				"Fatal error: a cleanup method raised an

exception.");

t/unit-tests/clar/clar.c +61 -0

+		clar_report_errors(_clar.last_report);
+		exit(-1);
+	}
+
+	CL_TRACE(CL_TRACE__TEST__LONGJMP);
+	longjmp(_clar.trampoline, -1);
+}
+
+void clar__skip(void)
+{
+	_clar.last_report->status = CL_TEST_SKIP;
+	_clar.total_skipped++;
+	abort_test();
+}
+
+void clar__fail(
+	const char *file,
+	const char *function,
+	size_t line,
+	const char *error_msg,
+	const char *description,
+	int should_abort)
+{
+	struct clar_error *error = calloc(1, sizeof(struct clar_error));
+
+	if (_clar.last_report->errors == NULL)
+		_clar.last_report->errors = error;
+
+	if (_clar.last_report->last_error != NULL)
+		_clar.last_report->last_error->next = error;
+
+	_clar.last_report->last_error = error;
+
+	error->file = file;
+	error->function = function;
+	error->line_number = line;
+	error->error_msg = error_msg;
+
+	if (description != NULL)
+		error->description = strdup(description);
+
+	_clar.total_errors++;
+	_clar.last_report->status = CL_TEST_FAILURE;
+
+	if (should_abort)
+		abort_test();
+}
+
+void clar__assert(
+	int condition,
+	const char *file,
+	const char *function,
+	size_t line,
+	const char *error_msg,
+	const char *description,
+	int should_abort)
+{
+	if (condition)
+		return;
+
+	clar__fail(file, function, line, error_msg, description,

should_abort);

t/unit-tests/clar/clar.c +26 -0

+}
+
+void clar__assert_equal(
+	const char *file,
+	const char *function,
+	size_t line,
+	const char *err,
+	int should_abort,
+	const char *fmt,
+	...)
+{
+	va_list args;
+	char buf[4096];
+	int is_equal = 1;
+
+	va_start(args, fmt);
+
+	if (!strcmp("%s", fmt)) {
+		const char *s1 = va_arg(args, const char *);
+		const char *s2 = va_arg(args, const char *);
+		is_equal = (!s1 || !s2) ? (s1 == s2) : !strcmp(s1, s2);
+
+		if (!is_equal) {
+			if (s1 && s2) {
+				int pos;
+				for (pos = 0; s1[pos] == s2[pos] && s1[pos] &&

s2[pos]; ++pos)

t/unit-tests/clar/clar.c +2 -0

+					/* find differing byte offset */;
+				p_snprintf(buf, sizeof(buf), "'%s' != '%s' (at

byte %d)",

t/unit-tests/clar/clar.c +3 -0

+					s1, s2, pos);
+			} else {
+				p_snprintf(buf, sizeof(buf), "'%s' != '%s'",

s1, s2);

t/unit-tests/clar/clar.c +16 -0

+			}
+		}
+	}
+	else if(!strcmp("%.*s", fmt)) {
+		const char *s1 = va_arg(args, const char *);
+		const char *s2 = va_arg(args, const char *);
+		int len = va_arg(args, int);
+		is_equal = (!s1 || !s2) ? (s1 == s2) : !strncmp(s1, s2, len);
+
+		if (!is_equal) {
+			if (s1 && s2) {
+				int pos;
+				for (pos = 0; s1[pos] == s2[pos] && pos < len;
++pos)
+					/* find differing byte offset */;
+				p_snprintf(buf, sizeof(buf), "'%.*s' != '%.*s'

(at byte %d)",

t/unit-tests/clar/clar.c +3 -0

+					len, s1, len, s2, pos);
+			} else {
+				p_snprintf(buf, sizeof(buf), "'%.*s' !=

'%.*s'", len, s1, len, s2);

t/unit-tests/clar/clar.c +7 -0

+			}
+		}
+	}
+	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 *);
+		is_equal = (!wcs1 || !wcs2) ? (wcs1 == wcs2) : !wcscmp(wcs1,

wcs2);

t/unit-tests/clar/clar.c +5 -0

+
+		if (!is_equal) {
+			if (wcs1 && wcs2) {
+				int pos;
+				for (pos = 0; wcs1[pos] == wcs2[pos] &&

wcs1[pos] && wcs2[pos]; ++pos)

t/unit-tests/clar/clar.c +2 -0

+					/* find differing byte offset */;
+				p_snprintf(buf, sizeof(buf), "'%ls' != '%ls'

(at byte %d)",

t/unit-tests/clar/clar.c +3 -0

+					wcs1, wcs2, pos);
+			} else {
+				p_snprintf(buf, sizeof(buf), "'%ls' != '%ls'",

wcs1, wcs2);

t/unit-tests/clar/clar.c +8 -0

+			}
+		}
+	}
+	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 *);
+		int len = va_arg(args, int);
+		is_equal = (!wcs1 || !wcs2) ? (wcs1 == wcs2) : !wcsncmp(wcs1,

wcs2, len);

t/unit-tests/clar/clar.c +5 -0

+
+		if (!is_equal) {
+			if (wcs1 && wcs2) {
+				int pos;
+				for (pos = 0; wcs1[pos] == wcs2[pos] && pos <

len; ++pos)

t/unit-tests/clar/clar.c +2 -0

+					/* find differing byte offset */;
+				p_snprintf(buf, sizeof(buf), "'%.*ls' !=

'%.*ls' (at byte %d)",

t/unit-tests/clar/clar.c +3 -0

+					len, wcs1, len, wcs2, pos);
+			} else {
+				p_snprintf(buf, sizeof(buf), "'%.*ls' !=

'%.*ls'", len, wcs1, len, wcs2);

t/unit-tests/clar/clar.c +10 -0

+			}
+		}
+	}
+	else if (!strcmp("%"PRIuZ, fmt) || !strcmp("%"PRIxZ, fmt)) {
+		size_t sz1 = va_arg(args, size_t), sz2 = va_arg(args, size_t);
+		is_equal = (sz1 == sz2);
+		if (!is_equal) {
+			int offset = p_snprintf(buf, sizeof(buf), fmt, sz1);
+			strncat(buf, " != ", sizeof(buf) - offset);
+			p_snprintf(buf + offset + 4, sizeof(buf) - offset - 4,

fmt, sz2);

t/unit-tests/clar/clar.c +15 -0

+		}
+	}
+	else if (!strcmp("%p", fmt)) {
+		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);
+	}
+	else {
+		int i1 = va_arg(args, int), i2 = va_arg(args, int);
+		is_equal = (i1 == i2);
+		if (!is_equal) {
+			int offset = p_snprintf(buf, sizeof(buf), fmt, i1);
+			strncat(buf, " != ", sizeof(buf) - offset);
+			p_snprintf(buf + offset + 4, sizeof(buf) - offset - 4,

fmt, i2);

t/unit-tests/clar/clar.c +20 -0

+		}
+	}
+
+	va_end(args);
+
+	if (!is_equal)
+		clar__fail(file, function, line, err, buf, should_abort);
+}
+
+void cl_set_cleanup(void (*cleanup)(void *), void *opaque)
+{
+	_clar.local_cleanup = cleanup;
+	_clar.local_cleanup_payload = opaque;
+}
+
+#include "clar/sandbox.h"
+#include "clar/fixtures.h"
+#include "clar/fs.h"
+#include "clar/print.h"
+#include "clar/summary.h"

t/unit-tests/clar/clar.h new file +89 -0

new file mode 100644
index 0000000000..8c22382bd5
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+#ifndef __CLAR_TEST_H__
+#define __CLAR_TEST_H__
+
+#include <stdlib.h>
+
+enum cl_test_status {
+	CL_TEST_OK,
+	CL_TEST_FAILURE,
+	CL_TEST_SKIP,
+	CL_TEST_NOTRUN,
+};
+
+enum cl_output_format {
+	CL_OUTPUT_CLAP,
+	CL_OUTPUT_TAP,
+};
+
+/** Setup clar environment */
+void clar_test_init(int argc, char *argv[]);
+int clar_test_run(void);
+void clar_test_shutdown(void);
+
+/** One shot setup & run */
+int clar_test(int argc, char *argv[]);
+
+const char *clar_sandbox_path(void);
+
+void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
+void cl_fs_cleanup(void);
+
+/**
+ * cl_trace_* is a hook to provide a simple global tracing
+ * mechanism.
+ *
+ * The goal here is to let main() provide clar-proper
+ * with a callback to optionally write log info for
+ * test operations into the same stream used by their
+ * actual tests.  This would let them print test names
+ * and maybe performance data as they choose.
+ *
+ * The goal is NOT to alter the flow of control or to
+ * override test selection/skipping.  (So the callback
+ * does not return a value.)
+ *
+ * The goal is NOT to duplicate the existing
+ * pass/fail/skip reporting.  (So the callback
+ * does not accept a status/errorcode argument.)
+ *
+ */
+typedef enum cl_trace_event {
+	CL_TRACE__SUITE_BEGIN,
+	CL_TRACE__SUITE_END,
+	CL_TRACE__TEST__BEGIN,
+	CL_TRACE__TEST__END,
+	CL_TRACE__TEST__RUN_BEGIN,
+	CL_TRACE__TEST__RUN_END,
+	CL_TRACE__TEST__LONGJMP,
+} cl_trace_event;
+
+typedef void (cl_trace_cb)(
+	cl_trace_event ev,
+	const char *suite_name,
+	const char *test_name,
+	void *payload);
+
+/**
+ * Register a callback into CLAR to send global trace events.
+ * Pass NULL to disable.
+ */
+void cl_trace_register(cl_trace_cb *cb, void *payload);
+
+
+#ifdef CLAR_FIXTURE_PATH
+const char *cl_fixture(const char *fixture_name);
+void cl_fixture_sandbox(const char *fixture_name);
+void cl_fixture_cleanup(const char *fixture_name);
+const char *cl_fixture_basename(const char *fixture_name);
+#endif
+
+/**
+ * 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)

t/unit-tests/clar/clar.h new file +5 -0

+
+/**
+ * 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)

t/unit-tests/clar/clar.h new file +19 -0

+
+/**
+ * Assertion macros with no error message
+ */
+#define cl_must_pass(expr) cl_must_pass_(expr, NULL)
+#define cl_must_fail(expr) cl_must_fail_(expr, NULL)
+#define cl_assert(expr) cl_assert_(expr, NULL)
+
+/**
+ * Check macros with no error message
+ */
+#define cl_check_pass(expr) cl_check_pass_(expr, NULL)
+#define cl_check_fail(expr) cl_check_fail_(expr, NULL)
+#define cl_check(expr) cl_check_(expr, NULL)
+
+/**
+ * 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)

t/unit-tests/clar/clar.h new file +7 -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))

t/unit-tests/clar/clar.h new file +2 -0

+
+#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))

t/unit-tests/clar/clar.h new file +2 -0

+
+#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))

t/unit-tests/clar/clar.h new file +2 -0

+
+#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))

t/unit-tests/clar/clar.h new file +2 -0

+
+#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))

t/unit-tests/clar/clar.h new file +2 -0

+
+#define cl_assert_equal_b(b1,b2)

clar__assert_equal(__FILE__,__func__,__LINE__,#b1 " != " #b2, 1, "%d", (int)((b1) != 0),(int)((b2) != 0))

t/unit-tests/clar/clar.h new file +2 -0

+
+#define cl_assert_equal_p(p1,p2)

clar__assert_equal(__FILE__,__func__,__LINE__,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))

t/unit-tests/clar/clar.h new file +30 -0

+
+void clar__skip(void);
+
+void clar__fail(
+	const char *file,
+	const char *func,
+	size_t line,
+	const char *error,
+	const char *description,
+	int should_abort);
+
+void clar__assert(
+	int condition,
+	const char *file,
+	const char *func,
+	size_t line,
+	const char *error,
+	const char *description,
+	int should_abort);
+
+void clar__assert_equal(
+	const char *file,
+	const char *func,
+	size_t line,
+	const char *err,
+	int should_abort,
+	const char *fmt,
+	...);
+
+#endif

t/unit-tests/clar/clar/fixtures.h new file +50 -0

new file mode 100644
index 0000000000..6ec6423484
@@ -0,0 +1,50 @@
+#ifdef CLAR_FIXTURE_PATH
+static const char *
+fixture_path(const char *base, const char *fixture_name)
+{
+	static char _path[4096];
+	size_t root_len;
+
+	root_len = strlen(base);
+	strncpy(_path, base, sizeof(_path));
+
+	if (_path[root_len - 1] != '/')
+		_path[root_len++] = '/';
+
+	if (fixture_name[0] == '/')
+		fixture_name++;
+
+	strncpy(_path + root_len,
+		fixture_name,
+		sizeof(_path) - root_len);
+
+	return _path;
+}
+
+const char *cl_fixture(const char *fixture_name)
+{
+	return fixture_path(CLAR_FIXTURE_PATH, fixture_name);
+}
+
+void cl_fixture_sandbox(const char *fixture_name)
+{
+	fs_copy(cl_fixture(fixture_name), _clar_path);
+}
+
+const char *cl_fixture_basename(const char *fixture_name)
+{
+	const char *p;
+
+	for (p = fixture_name; *p; p++) {
+		if (p[0] == '/' && p[1] && p[1] != '/')
+			fixture_name = p+1;
+	}
+
+	return fixture_name;
+}
+
+void cl_fixture_cleanup(const char *fixture_name)
+{
+	fs_rm(fixture_path(_clar_path, cl_fixture_basename(fixture_name)));
+}
+#endif

t/unit-tests/clar/clar/fs.h new file +108 -0

new file mode 100644
index 0000000000..3e39890bd3
@@ -0,0 +1,522 @@
+/*
+ * By default, use a read/write loop to copy files on POSIX systems.
+ * On Linux, use sendfile by default as it's slightly faster.  On
+ * macOS, we avoid fcopyfile by default because it's slightly slower.
+ */
+#undef USE_FCOPYFILE
+#define USE_SENDFILE 1
+
+#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
+
+#ifdef __MINGW32__
+
+/* These security-enhanced functions are not available
+ * in MinGW, so just use the vanilla ones */
+#define wcscpy_s(a, b, c) wcscpy((a), (c))
+#define wcscat_s(a, b, c) wcscat((a), (c))
+
+#endif /* __MINGW32__ */
+
+static int
+fs__dotordotdot(WCHAR *_tocheck)
+{
+	return _tocheck[0] == '.' &&
+		(_tocheck[1] == '\0' ||
+		 (_tocheck[1] == '.' && _tocheck[2] == '\0'));
+}
+
+static int
+fs_rmdir_rmdir(WCHAR *_wpath)
+{
+	unsigned retries = 1;
+
+	while (!RemoveDirectoryW(_wpath)) {
+		/* Only retry when we have retries remaining, and the
+		 * error was ERROR_DIR_NOT_EMPTY. */
+		if (retries++ > RM_RETRY_COUNT ||
+			ERROR_DIR_NOT_EMPTY != GetLastError())
+			return -1;
+
+		/* Give whatever has a handle to a child item some time
+		 * to release it before trying again */
+		Sleep(RM_RETRY_DELAY * retries * retries);
+	}
+
+	return 0;
+}
+
+static void translate_path(WCHAR *path, size_t path_size)
+{
+    size_t path_len, i;
+
+    if (wcsncmp(path, L"\\\\?\\", 4) == 0)
+	return;
+
+    path_len = wcslen(path);
+    cl_assert(path_size > path_len + 4);
+
+    for (i = path_len; i > 0; i--) {
+	WCHAR c = path[i - 1];
+
+	if (c == L'/')
+	    path[i + 3] = L'\\';
+	else
+	    path[i + 3] = path[i - 1];
+    }
+
+    path[0] = L'\\';
+    path[1] = L'\\';
+    path[2] = L'?';
+    path[3] = L'\\';
+    path[path_len + 4] = L'\0';
+}
+
+static void
+fs_rmdir_helper(WCHAR *_wsource)
+{
+	WCHAR buffer[CLAR_MAX_PATH];
+	HANDLE find_handle;
+	WIN32_FIND_DATAW find_data;
+	size_t buffer_prefix_len;
+
+	/* Set up the buffer and capture the length */
+	wcscpy_s(buffer, CLAR_MAX_PATH, _wsource);
+	translate_path(buffer, CLAR_MAX_PATH);
+	wcscat_s(buffer, CLAR_MAX_PATH, L"\\");
+	buffer_prefix_len = wcslen(buffer);
+
+	/* FindFirstFile needs a wildcard to match multiple items */
+	wcscat_s(buffer, CLAR_MAX_PATH, L"*");
+	find_handle = FindFirstFileW(buffer, &find_data);
+	cl_assert(INVALID_HANDLE_VALUE != find_handle);
+
+	do {
+		/* FindFirstFile/FindNextFile gives back . and ..
+		 * entries at the beginning */
+		if (fs__dotordotdot(find_data.cFileName))
+			continue;
+
+		wcscpy_s(buffer + buffer_prefix_len, CLAR_MAX_PATH -

buffer_prefix_len, find_data.cFileName);

t/unit-tests/clar/clar/fs.h new file +5 -0

+
+		if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
+			fs_rmdir_helper(buffer);
+		else {
+			/* If set, the +R bit must be cleared before deleting

*/

t/unit-tests/clar/clar/fs.h new file +1 -0

+			if (FILE_ATTRIBUTE_READONLY &

find_data.dwFileAttributes)

t/unit-tests/clar/clar/fs.h new file +1 -0

+				cl_assert(SetFileAttributesW(buffer,

find_data.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY));

t/unit-tests/clar/clar/fs.h new file +69 -0

+
+			cl_assert(DeleteFileW(buffer));
+		}
+	}
+	while (FindNextFileW(find_handle, &find_data));
+
+	/* Ensure that we successfully completed the enumeration */
+	cl_assert(ERROR_NO_MORE_FILES == GetLastError());
+
+	/* Close the find handle */
+	FindClose(find_handle);
+
+	/* Now that the directory is empty, remove it */
+	cl_assert(0 == fs_rmdir_rmdir(_wsource));
+}
+
+static int
+fs_rm_wait(WCHAR *_wpath)
+{
+	unsigned retries = 1;
+	DWORD last_error;
+
+	do {
+		if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(_wpath))
+			last_error = GetLastError();
+		else
+			last_error = ERROR_SUCCESS;
+
+		/* Is the item gone? */
+		if (ERROR_FILE_NOT_FOUND == last_error ||
+			ERROR_PATH_NOT_FOUND == last_error)
+			return 0;
+
+		Sleep(RM_RETRY_DELAY * retries * retries);
+	}
+	while (retries++ <= RM_RETRY_COUNT);
+
+	return -1;
+}
+
+static void
+fs_rm(const char *_source)
+{
+	WCHAR wsource[CLAR_MAX_PATH];
+	DWORD attrs;
+
+	/* The input path is UTF-8. Convert it to wide characters
+	 * for use with the Windows API */
+	cl_assert(MultiByteToWideChar(CP_UTF8,
+				MB_ERR_INVALID_CHARS,
+				_source,
+				-1, /* Indicates NULL termination */
+				wsource,
+				CLAR_MAX_PATH));
+
+	translate_path(wsource, CLAR_MAX_PATH);
+
+	/* Does the item exist? If not, we have no work to do */
+	attrs = GetFileAttributesW(wsource);
+
+	if (INVALID_FILE_ATTRIBUTES == attrs)
+		return;
+
+	if (FILE_ATTRIBUTE_DIRECTORY & attrs)
+		fs_rmdir_helper(wsource);
+	else {
+		/* The item is a file. Strip the +R bit */
+		if (FILE_ATTRIBUTE_READONLY & attrs)
+			cl_assert(SetFileAttributesW(wsource, attrs &

~FILE_ATTRIBUTE_READONLY));

t/unit-tests/clar/clar/fs.h new file +41 -0

+
+		cl_assert(DeleteFileW(wsource));
+	}
+
+	/* Wait for the DeleteFile or RemoveDirectory call to complete */
+	cl_assert(0 == fs_rm_wait(wsource));
+}
+
+static void
+fs_copydir_helper(WCHAR *_wsource, WCHAR *_wdest)
+{
+	WCHAR buf_source[CLAR_MAX_PATH], buf_dest[CLAR_MAX_PATH];
+	HANDLE find_handle;
+	WIN32_FIND_DATAW find_data;
+	size_t buf_source_prefix_len, buf_dest_prefix_len;
+
+	wcscpy_s(buf_source, CLAR_MAX_PATH, _wsource);
+	wcscat_s(buf_source, CLAR_MAX_PATH, L"\\");
+	translate_path(buf_source, CLAR_MAX_PATH);
+	buf_source_prefix_len = wcslen(buf_source);
+
+	wcscpy_s(buf_dest, CLAR_MAX_PATH, _wdest);
+	wcscat_s(buf_dest, CLAR_MAX_PATH, L"\\");
+	translate_path(buf_dest, CLAR_MAX_PATH);
+	buf_dest_prefix_len = wcslen(buf_dest);
+
+	/* Get an enumerator for the items in the source. */
+	wcscat_s(buf_source, CLAR_MAX_PATH, L"*");
+	find_handle = FindFirstFileW(buf_source, &find_data);
+	cl_assert(INVALID_HANDLE_VALUE != find_handle);
+
+	/* Create the target directory. */
+	cl_assert(CreateDirectoryW(_wdest, NULL));
+
+	do {
+		/* FindFirstFile/FindNextFile gives back . and ..
+		 * entries at the beginning */
+		if (fs__dotordotdot(find_data.cFileName))
+			continue;
+
+		wcscpy_s(buf_source + buf_source_prefix_len, CLAR_MAX_PATH -

buf_source_prefix_len, find_data.cFileName);

t/unit-tests/clar/clar/fs.h new file +1 -0

+		wcscpy_s(buf_dest + buf_dest_prefix_len, CLAR_MAX_PATH -

buf_dest_prefix_len, find_data.cFileName);

t/unit-tests/clar/clar/fs.h new file +60 -0

+
+		if (FILE_ATTRIBUTE_DIRECTORY & find_data.dwFileAttributes)
+			fs_copydir_helper(buf_source, buf_dest);
+		else
+			cl_assert(CopyFileW(buf_source, buf_dest, TRUE));
+	}
+	while (FindNextFileW(find_handle, &find_data));
+
+	/* Ensure that we successfully completed the enumeration */
+	cl_assert(ERROR_NO_MORE_FILES == GetLastError());
+
+	/* Close the find handle */
+	FindClose(find_handle);
+}
+
+static void
+fs_copy(const char *_source, const char *_dest)
+{
+	WCHAR wsource[CLAR_MAX_PATH], wdest[CLAR_MAX_PATH];
+	DWORD source_attrs, dest_attrs;
+	HANDLE find_handle;
+	WIN32_FIND_DATAW find_data;
+
+	/* The input paths are UTF-8. Convert them to wide characters
+	 * for use with the Windows API. */
+	cl_assert(MultiByteToWideChar(CP_UTF8,
+				MB_ERR_INVALID_CHARS,
+				_source,
+				-1,
+				wsource,
+				CLAR_MAX_PATH));
+
+	cl_assert(MultiByteToWideChar(CP_UTF8,
+				MB_ERR_INVALID_CHARS,
+				_dest,
+				-1,
+				wdest,
+				CLAR_MAX_PATH));
+
+	translate_path(wsource, CLAR_MAX_PATH);
+	translate_path(wdest, CLAR_MAX_PATH);
+
+	/* Check the source for existence */
+	source_attrs = GetFileAttributesW(wsource);
+	cl_assert(INVALID_FILE_ATTRIBUTES != source_attrs);
+
+	/* Check the target for existence */
+	dest_attrs = GetFileAttributesW(wdest);
+
+	if (INVALID_FILE_ATTRIBUTES != dest_attrs) {
+		/* Target exists; append last path part of source to target.
+		 * Use FindFirstFile to parse the path */
+		find_handle = FindFirstFileW(wsource, &find_data);
+		cl_assert(INVALID_HANDLE_VALUE != find_handle);
+		wcscat_s(wdest, CLAR_MAX_PATH, L"\\");
+		wcscat_s(wdest, CLAR_MAX_PATH, find_data.cFileName);
+		FindClose(find_handle);
+
+		/* Check the new target for existence */
+		cl_assert(INVALID_FILE_ATTRIBUTES ==

GetFileAttributesW(wdest));

t/unit-tests/clar/clar/fs.h new file +108 -0

+	}
+
+	if (FILE_ATTRIBUTE_DIRECTORY & source_attrs)
+		fs_copydir_helper(wsource, wdest);
+	else
+		cl_assert(CopyFileW(wsource, wdest, TRUE));
+}
+
+void
+cl_fs_cleanup(void)
+{
+#ifdef CLAR_FIXTURE_PATH
+	fs_rm(fixture_path(_clar_path, "*"));
+#endif
+}
+
+#else
+
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#if defined(__linux__)
+# include <sys/sendfile.h>
+#endif
+
+#if defined(__APPLE__)
+# include <copyfile.h>
+#endif
+
+static void basename_r(const char **out, int *out_len, const char *in)
+{
+	size_t in_len = strlen(in), start_pos;
+
+	for (in_len = strlen(in); in_len; in_len--) {
+		if (in[in_len - 1] != '/')
+			break;
+	}
+
+	for (start_pos = in_len; start_pos; start_pos--) {
+		if (in[start_pos - 1] == '/')
+			break;
+	}
+
+	cl_assert(in_len - start_pos < INT_MAX);
+
+	if (in_len - start_pos > 0) {
+		*out = &in[start_pos];
+		*out_len = (in_len - start_pos);
+	} else {
+		*out = "/";
+		*out_len = 1;
+	}
+}
+
+static char *joinpath(const char *dir, const char *base, int base_len)
+{
+	char *out;
+	int len;
+
+	if (base_len == -1) {
+		size_t bl = strlen(base);
+
+		cl_assert(bl < INT_MAX);
+		base_len = (int)bl;
+	}
+
+	len = strlen(dir) + base_len + 2;
+	cl_assert(len > 0);
+
+	cl_assert(out = malloc(len));
+	cl_assert(snprintf(out, len, "%s/%.*s", dir, base_len, base) < len);
+
+	return out;
+}
+
+static void
+fs_copydir_helper(const char *source, const char *dest, int dest_mode)
+{
+	DIR *source_dir;
+	struct dirent *d;
+
+	mkdir(dest, dest_mode);
+
+	cl_assert_(source_dir = opendir(source), "Could not open source dir");
+	while ((d = (errno = 0, readdir(source_dir))) != NULL) {
+		char *child;
+
+		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+			continue;
+
+		child = joinpath(source, d->d_name, -1);
+		fs_copy(child, dest);
+		free(child);
+	}
+
+	cl_assert_(errno == 0, "Failed to iterate source dir");
+
+	closedir(source_dir);
+}
+
+static void
+fs_copyfile_helper(const char *source, size_t source_len, const char *dest,

int dest_mode)

t/unit-tests/clar/clar/fs.h new file +14 -0

+{
+	int in, out;
+
+	cl_must_pass((in = open(source, O_RDONLY)));
+	cl_must_pass((out = open(dest, O_WRONLY|O_CREAT|O_TRUNC, dest_mode)));
+
+#if USE_FCOPYFILE && defined(__APPLE__)
+	((void)(source_len)); /* unused */
+	cl_must_pass(fcopyfile(in, out, 0, COPYFILE_DATA));
+#elif USE_SENDFILE && defined(__linux__)
+	{
+		ssize_t ret = 0;
+
+		while (source_len && (ret = sendfile(out, in, NULL,

source_len)) > 0) {

t/unit-tests/clar/clar/fs.h new file +36 -0

+			source_len -= (size_t)ret;
+		}
+		cl_assert(ret >= 0);
+	}
+#else
+	{
+		char buf[131072];
+		ssize_t ret;
+
+		((void)(source_len)); /* unused */
+
+		while ((ret = read(in, buf, sizeof(buf))) > 0) {
+			size_t len = (size_t)ret;
+
+			while (len && (ret = write(out, buf, len)) > 0) {
+				cl_assert(ret <= (ssize_t)len);
+				len -= ret;
+			}
+			cl_assert(ret >= 0);
+		}
+		cl_assert(ret == 0);
+	}
+#endif
+
+	close(in);
+	close(out);
+}
+
+static void
+fs_copy(const char *source, const char *_dest)
+{
+	char *dbuf = NULL;
+	const char *dest = NULL;
+	struct stat source_st, dest_st;
+
+	cl_must_pass_(lstat(source, &source_st), "Failed to stat copy

source");

t/unit-tests/clar/clar/fs.h new file +23 -0

+
+	if (lstat(_dest, &dest_st) == 0) {
+		const char *base;
+		int base_len;
+
+		/* Target exists and is directory; append basename */
+		cl_assert(S_ISDIR(dest_st.st_mode));
+
+		basename_r(&base, &base_len, source);
+		cl_assert(base_len < INT_MAX);
+
+		dbuf = joinpath(_dest, base, base_len);
+		dest = dbuf;
+	} else if (errno != ENOENT) {
+		cl_fail("Cannot copy; cannot stat destination");
+	} else {
+		dest = _dest;
+	}
+
+	if (S_ISDIR(source_st.st_mode)) {
+		fs_copydir_helper(source, dest, source_st.st_mode);
+	} else {
+		fs_copyfile_helper(source, source_st.st_size, dest,

source_st.st_mode);

t/unit-tests/clar/clar/fs.h new file +55 -0

+	}
+
+	free(dbuf);
+}
+
+static void
+fs_rmdir_helper(const char *path)
+{
+	DIR *dir;
+	struct dirent *d;
+
+	cl_assert_(dir = opendir(path), "Could not open dir");
+	while ((d = (errno = 0, readdir(dir))) != NULL) {
+		char *child;
+
+		if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+			continue;
+
+		child = joinpath(path, d->d_name, -1);
+		fs_rm(child);
+		free(child);
+	}
+
+	cl_assert_(errno == 0, "Failed to iterate source dir");
+	closedir(dir);
+
+	cl_must_pass_(rmdir(path), "Could not remove directory");
+}
+
+static void
+fs_rm(const char *path)
+{
+	struct stat st;
+
+	if (lstat(path, &st)) {
+		if (errno == ENOENT)
+			return;
+
+		cl_fail("Cannot copy; cannot stat destination");
+	}
+
+	if (S_ISDIR(st.st_mode)) {
+		fs_rmdir_helper(path);
+	} else {
+		cl_must_pass(unlink(path));
+	}
+}
+
+void
+cl_fs_cleanup(void)
+{
+	clar_unsandbox();
+	clar_sandbox();
+}
+#endif

t/unit-tests/clar/clar/print.h new file +3 -0

new file mode 100644
index 0000000000..c17e2f693b
@@ -0,0 +1,211 @@
+/* clap: clar protocol, the traditional clar output format */
+
+static void clar_print_clap_init(int test_count, int suite_count, const

char *suite_names)

t/unit-tests/clar/clar/print.h new file +4 -0

+{
+	(void)test_count;
+	printf("Loaded %d suites: %s\n", (int)suite_count, suite_names);
+	printf("Started (test status codes: OK='.' FAILURE='F'

SKIPPED='S')\n");

t/unit-tests/clar/clar/print.h new file +3 -0

+}
+
+static void clar_print_clap_shutdown(int test_count, int suite_count, int

error_count)

t/unit-tests/clar/clar/print.h new file +10 -0

+{
+	(void)test_count;
+	(void)suite_count;
+	(void)error_count;
+
+	printf("\n\n");
+	clar_report_all();
+}
+
+static void clar_print_clap_error(int num, const struct clar_report

*report, const struct clar_error *error)

t/unit-tests/clar/clar/print.h new file +19 -0

+{
+	printf("  %d) Failure:\n", num);
+
+	printf("%s::%s [%s:%"PRIuZ"]\n",
+		report->suite,
+		report->test,
+		error->file,
+		error->line_number);
+
+	printf("  %s\n", error->error_msg);
+
+	if (error->description != NULL)
+		printf("  %s\n", error->description);
+
+	printf("\n");
+	fflush(stdout);
+}
+
+static void clar_print_clap_ontest(const char *suite_name, const char

*test_name, int test_number, enum cl_test_status status)

t/unit-tests/clar/clar/print.h new file +26 -0

+{
+	(void)test_name;
+	(void)test_number;
+
+	if (_clar.verbosity > 1) {
+		printf("%s::%s: ", suite_name, 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;
+		}
+	} else {
+		switch (status) {
+		case CL_TEST_OK: printf("."); break;
+		case CL_TEST_FAILURE: printf("F"); break;
+		case CL_TEST_SKIP: printf("S"); break;
+		case CL_TEST_NOTRUN: printf("N"); break;
+		}
+
+		fflush(stdout);
+	}
+}
+
+static void clar_print_clap_onsuite(const char *suite_name, int

suite_index)

t/unit-tests/clar/clar/print.h new file +15 -0

+{
+	if (_clar.verbosity == 1)
+		printf("\n%s", suite_name);
+
+	(void)suite_index;
+}
+
+static void clar_print_clap_onabort(const char *fmt, va_list arg)
+{
+	vfprintf(stderr, fmt, arg);
+}
+
+/* tap: test anywhere protocol format */
+
+static void clar_print_tap_init(int test_count, int suite_count, const char

*suite_names)

t/unit-tests/clar/clar/print.h new file +8 -0

+{
+	(void)test_count;
+	(void)suite_count;
+	(void)suite_names;
+	printf("TAP version 13\n");
+}
+
+static void clar_print_tap_shutdown(int test_count, int suite_count, int

error_count)

t/unit-tests/clar/clar/print.h new file +8 -0

+{
+	(void)suite_count;
+	(void)error_count;
+
+	printf("1..%d\n", test_count);
+}
+
+static void clar_print_tap_error(int num, const struct clar_report *report,

const struct clar_error *error)

t/unit-tests/clar/clar/print.h new file +20 -0

+{
+	(void)num;
+	(void)report;
+	(void)error;
+}
+
+static void print_escaped(const char *str)
+{
+	char *c;
+
+	while ((c = strchr(str, '\'')) != NULL) {
+		printf("%.*s", (int)(c - str), str);
+		printf("''");
+		str = c + 1;
+	}
+
+	printf("%s", str);
+}
+
+static void clar_print_tap_ontest(const char *suite_name, const char

*test_name, int test_number, enum cl_test_status status)

t/unit-tests/clar/clar/print.h new file +9 -0

+{
+	const struct clar_error *error = _clar.last_report->errors;
+
+	(void)test_name;
+	(void)test_number;
+
+	switch(status) {
+	case CL_TEST_OK:
+		printf("ok %d - %s::%s\n", test_number, suite_name,

test_name);

t/unit-tests/clar/clar/print.h new file +3 -0

+		break;
+	case CL_TEST_FAILURE:
+		printf("not ok %d - %s::%s\n", test_number, suite_name,

test_name);

t/unit-tests/clar/clar/print.h new file +10 -0

+
+		printf("    ---\n");
+		printf("    reason: |\n");
+		printf("      %s\n", error->error_msg);
+
+		if (error->description)
+			printf("      %s\n", error->description);
+
+		printf("    at:\n");
+		printf("      file: '"); print_escaped(error->file);

printf("'\n");

t/unit-tests/clar/clar/print.h new file +8 -0

+		printf("      line: %" PRIuZ "\n", error->line_number);
+		printf("      function: '%s'\n", error->function);
+		printf("    ---\n");
+
+		break;
+	case CL_TEST_SKIP:
+	case CL_TEST_NOTRUN:
+		printf("ok %d - # SKIP %s::%s\n", test_number, suite_name,

test_name);

t/unit-tests/clar/clar/print.h new file +34 -0

+		break;
+	}
+
+	fflush(stdout);
+}
+
+static void clar_print_tap_onsuite(const char *suite_name, int suite_index)
+{
+	printf("# start of suite %d: %s\n", suite_index, suite_name);
+}
+
+static void clar_print_tap_onabort(const char *fmt, va_list arg)
+{
+	printf("Bail out! ");
+	vprintf(fmt, arg);
+	fflush(stdout);
+}
+
+/* indirection between protocol output selection */
+
+#define PRINT(FN, ...) do { \
+		switch (_clar.output_format) { \
+			case CL_OUTPUT_CLAP: \
+				clar_print_clap_##FN (__VA_ARGS__); \
+				break; \
+			case CL_OUTPUT_TAP: \
+				clar_print_tap_##FN (__VA_ARGS__); \
+				break; \
+			default: \
+				abort(); \
+		} \
+	} while (0)
+
+static void clar_print_init(int test_count, int suite_count, const char

*suite_names)

t/unit-tests/clar/clar/print.h new file +5 -0

+{
+	PRINT(init, test_count, suite_count, suite_names);
+}
+
+static void clar_print_shutdown(int test_count, int suite_count, int

error_count)

t/unit-tests/clar/clar/print.h new file +5 -0

+{
+	PRINT(shutdown, test_count, suite_count, error_count);
+}
+
+static void clar_print_error(int num, const struct clar_report *report,

const struct clar_error *error)

t/unit-tests/clar/clar/print.h new file +5 -0

+{
+	PRINT(error, num, report, error);
+}
+
+static void clar_print_ontest(const char *suite_name, const char

*test_name, int test_number, enum cl_test_status status)

t/unit-tests/clar/clar/print.h new file +16 -0

+{
+	PRINT(ontest, suite_name, test_name, test_number, status);
+}
+
+static void clar_print_onsuite(const char *suite_name, int suite_index)
+{
+	PRINT(onsuite, suite_name, suite_index);
+}
+
+static void clar_print_onabort(const char *msg, ...)
+{
+	va_list argp;
+	va_start(argp, msg);
+	PRINT(onabort, msg, argp);
+	va_end(argp);
+}

t/unit-tests/clar/clar/sandbox.h new file +39 -0

new file mode 100644
index 0000000000..7c177f3525
@@ -0,0 +1,153 @@
+#ifdef __APPLE__
+#include <sys/syslimits.h>
+#endif
+
+static char _clar_path[4096 + 1];
+
+static int
+is_valid_tmp_path(const char *path)
+{
+	STAT_T st;
+
+	if (stat(path, &st) != 0)
+		return 0;
+
+	if (!S_ISDIR(st.st_mode))
+		return 0;
+
+	return (access(path, W_OK) == 0);
+}
+
+static int
+find_tmp_path(char *buffer, size_t length)
+{
+#ifndef _WIN32
+	static const size_t var_count = 5;
+	static const char *env_vars[] = {
+		"CLAR_TMP", "TMPDIR", "TMP", "TEMP", "USERPROFILE"
+	};
+
+	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)) {
+#ifdef __APPLE__
+			if (length >= PATH_MAX && realpath(env, buffer) !=

NULL)

t/unit-tests/clar/clar/sandbox.h new file +21 -0

+				return 0;
+#endif
+			strncpy(buffer, env, length - 1);
+			buffer[length - 1] = '\0';
+			return 0;
+		}
+	}
+
+	/* If the environment doesn't say anything, try to use /tmp */
+	if (is_valid_tmp_path("/tmp")) {
+#ifdef __APPLE__
+		if (length >= PATH_MAX && realpath("/tmp", buffer) != NULL)
+			return 0;
+#endif
+		strncpy(buffer, "/tmp", length - 1);
+		buffer[length - 1] = '\0';
+		return 0;
+	}
+
+#else
+	DWORD env_len = GetEnvironmentVariable("CLAR_TMP", buffer,

(DWORD)length);

t/unit-tests/clar/clar/sandbox.h new file +93 -0

+	if (env_len > 0 && env_len < (DWORD)length)
+		return 0;
+
+	if (GetTempPath((DWORD)length, buffer))
+		return 0;
+#endif
+
+	/* This system doesn't like us, try to use the current directory */
+	if (is_valid_tmp_path(".")) {
+		strncpy(buffer, ".", length - 1);
+		buffer[length - 1] = '\0';
+		return 0;
+	}
+
+	return -1;
+}
+
+static void clar_unsandbox(void)
+{
+	if (_clar_path[0] == '\0')
+		return;
+
+	cl_must_pass(chdir(".."));
+
+	fs_rm(_clar_path);
+}
+
+static int build_sandbox_path(void)
+{
+#ifdef CLAR_TMPDIR
+	const char path_tail[] = CLAR_TMPDIR "_XXXXXX";
+#else
+	const char path_tail[] = "clar_tmp_XXXXXX";
+#endif
+
+	size_t len;
+
+	if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0)
+		return -1;
+
+	len = strlen(_clar_path);
+
+#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 (_clar_path[len - 1] != '/') {
+		_clar_path[len++] = '/';
+	}
+
+	strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
+
+#if defined(__MINGW32__)
+	if (_mktemp(_clar_path) == NULL)
+		return -1;
+
+	if (mkdir(_clar_path, 0700) != 0)
+		return -1;
+#elif defined(_WIN32)
+	if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0)
+		return -1;
+
+	if (mkdir(_clar_path, 0700) != 0)
+		return -1;
+#else
+	if (mkdtemp(_clar_path) == NULL)
+		return -1;
+#endif
+
+	return 0;
+}
+
+static int clar_sandbox(void)
+{
+	if (_clar_path[0] == '\0' && build_sandbox_path() < 0)
+		return -1;
+
+	if (chdir(_clar_path) != 0)
+		return -1;
+
+	return 0;
+}
+
+const char *clar_sandbox_path(void)
+{
+	return _clar_path;
+}

t/unit-tests/clar/clar/summary.h new file +40 -0

new file mode 100644
index 0000000000..4dd352e28b
@@ -0,0 +1,143 @@
+
+#include <stdio.h>
+#include <time.h>
+
+static int clar_summary_close_tag(
+    struct clar_summary *summary, const char *tag, int indent)
+{
+	const char *indt;
+
+	if (indent == 0) indt = "";
+	else if (indent == 1) indt = "\t";
+	else indt = "\t\t";
+
+	return fprintf(summary->fp, "%s</%s>\n", indt, tag);
+}
+
+static int clar_summary_testsuites(struct clar_summary *summary)
+{
+	return fprintf(summary->fp, "<testsuites>\n");
+}
+
+static int clar_summary_testsuite(struct clar_summary *summary,
+    int idn, const char *name, time_t timestamp,
+    int test_count, int fail_count, int error_count)
+{
+	struct tm *tm = localtime(&timestamp);
+	char iso_dt[20];
+
+	if (strftime(iso_dt, sizeof(iso_dt), "%Y-%m-%dT%H:%M:%S", tm) == 0)
+		return -1;
+
+	return fprintf(summary->fp, "\t<testsuite"
+		       " id=\"%d\""
+		       " name=\"%s\""
+		       " hostname=\"localhost\""
+		       " timestamp=\"%s\""
+		       " tests=\"%d\""
+		       " failures=\"%d\""
+		       " errors=\"%d\">\n",
+		       idn, name, iso_dt, test_count, fail_count,

error_count);

t/unit-tests/clar/clar/summary.h new file +58 -0

+}
+
+static int clar_summary_testcase(struct clar_summary *summary,
+    const char *name, const char *classname, double elapsed)
+{
+	return fprintf(summary->fp,
+	    "\t\t<testcase name=\"%s\" classname=\"%s\" time=\"%.2f\">\n",
+		name, classname, elapsed);
+}
+
+static int clar_summary_failure(struct clar_summary *summary,
+    const char *type, const char *message, const char *desc)
+{
+	return fprintf(summary->fp,
+	    "\t\t\t<failure type=\"%s\"><![CDATA[%s\n%s]]></failure>\n",
+	    type, message, desc);
+}
+
+static int clar_summary_skipped(struct clar_summary *summary)
+{
+	return fprintf(summary->fp, "\t\t\t<skipped />\n");
+}
+
+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 ((summary = malloc(sizeof(struct clar_summary))) == NULL) {
+		perror("malloc");
+		fclose(fp);
+		return NULL;
+	}
+
+	summary->filename = filename;
+	summary->fp = fp;
+
+	return summary;
+}
+
+int clar_summary_shutdown(struct clar_summary *summary)
+{
+	struct clar_report *report;
+	const char *last_suite = NULL;
+
+	if (clar_summary_testsuites(summary) < 0)
+		goto on_error;
+
+	report = _clar.reports;
+	while (report != NULL) {
+		struct clar_error *error = report->errors;
+
+		if (last_suite == NULL || strcmp(last_suite, report->suite) !=

0) {

t/unit-tests/clar/clar/summary.h new file +2 -0

+			if (clar_summary_testsuite(summary, 0, report->suite,
+			    report->start, _clar.tests_ran,

_clar.total_errors, 0) < 0)

t/unit-tests/clar/clar/summary.h new file +6 -0

+				goto on_error;
+		}
+
+		last_suite = report->suite;
+
+		clar_summary_testcase(summary, report->test, report->suite,

report->elapsed);

t/unit-tests/clar/clar/summary.h new file +19 -0

+
+		while (error != NULL) {
+			if (clar_summary_failure(summary, "assert",
+			    error->error_msg, error->description) < 0)
+				goto on_error;
+
+			error = error->next;
+		}
+
+		if (report->status == CL_TEST_SKIP)
+			clar_summary_skipped(summary);
+
+		if (clar_summary_close_tag(summary, "testcase", 2) < 0)
+			goto on_error;
+
+		report = report->next;
+
+		if (!report || strcmp(last_suite, report->suite) != 0) {
+			if (clar_summary_close_tag(summary, "testsuite", 1) <

0)

t/unit-tests/clar/clar/summary.h new file +18 -0

+				goto on_error;
+		}
+	}
+
+	if (clar_summary_close_tag(summary, "testsuites", 0) < 0 ||
+	    fclose(summary->fp) != 0)
+		goto on_error;
+
+	printf("written summary file to %s\n", summary->filename);
+
+	free(summary);
+	return 0;
+
+on_error:
+	fclose(summary->fp);
+	free(summary);
+	return -1;
+}

t/unit-tests/clar/generate.py new file +25 -0

new file mode 100755
index 0000000000..80996ac3e7
@@ -0,0 +1,266 @@
+#!/usr/bin/env python
+#
+# Copyright (c) Vicent Marti. All rights reserved.
+#
+# This file is part of clar, distributed under the ISC license.
+# For full terms see the included COPYING file.
+#
+
+from __future__ import with_statement
+from string import Template
+import re, fnmatch, os, sys, codecs, pickle
+
+class Module(object):
+    class Template(object):
+        def __init__(self, module):
+            self.module = module
+
+        def _render_callback(self, cb):
+            if not cb:
+                return '    { NULL, NULL }'
+            return '    { "%s", &%s }' % (cb['short_name'], cb['symbol'])
+
+    class DeclarationTemplate(Template):
+        def render(self):
+            out = "\n".join("extern %s;" % cb['declaration'] for cb in

self.module.callbacks) + "\n"

t/unit-tests/clar/generate.py new file +12 -0

+
+            for initializer in self.module.initializers:
+                out += "extern %s;\n" % initializer['declaration']
+
+            if self.module.cleanup:
+                out += "extern %s;\n" % self.module.cleanup['declaration']
+
+            return out
+
+    class CallbacksTemplate(Template):
+        def render(self):
+            out = "static const struct clar_func _clar_cb_%s[] = {\n" %

self.module.name
+ out += ",\n".join(self._render_callback(cb) for cb in
self.module.callbacks)

t/unit-tests/clar/generate.py new file +14 -0

+            out += "\n};\n"
+            return out
+
+    class InfoTemplate(Template):
+        def render(self):
+            templates = []
+
+            initializers = self.module.initializers
+            if len(initializers) == 0:
+                initializers = [ None ]
+
+            for initializer in initializers:
+                name = self.module.clean_name()
+                if initializer and

initializer['short_name'].startswith('initialize_'):
+ variant =
initializer['short_name'][len('initialize_'):]

t/unit-tests/clar/generate.py new file +45 -0

+                    name += " (%s)" % variant.replace('_', ' ')
+
+                template = Template(
+            r"""
+    {
+        "${clean_name}",
+    ${initialize},
+    ${cleanup},
+        ${cb_ptr}, ${cb_count}, ${enabled}
+    }"""
+                ).substitute(
+                    clean_name = name,
+                    initialize = self._render_callback(initializer),
+                    cleanup = self._render_callback(self.module.cleanup),
+                    cb_ptr = "_clar_cb_%s" % self.module.name,
+                    cb_count = len(self.module.callbacks),
+                    enabled = int(self.module.enabled)
+                )
+                templates.append(template)
+
+            return ','.join(templates)
+
+    def __init__(self, name):
+        self.name = name
+
+        self.mtime = None
+        self.enabled = True
+        self.modified = False
+
+    def clean_name(self):
+        return self.name.replace("_", "::")
+
+    def _skip_comments(self, text):
+        SKIP_COMMENTS_REGEX = re.compile(
+            r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
+            re.DOTALL | re.MULTILINE)
+
+        def _replacer(match):
+            s = match.group(0)
+            return "" if s.startswith('/') else s
+
+        return re.sub(SKIP_COMMENTS_REGEX, _replacer, text)
+
+    def parse(self, contents):
+        TEST_FUNC_REGEX =

r"^(void\s+(test_%s__(\w+))\s*\(\s*void\s*\))\s*\{"

t/unit-tests/clar/generate.py new file +71 -0

+
+        contents = self._skip_comments(contents)
+        regex = re.compile(TEST_FUNC_REGEX % self.name, re.MULTILINE)
+
+        self.callbacks = []
+        self.initializers = []
+        self.cleanup = None
+
+        for (declaration, symbol, short_name) in regex.findall(contents):
+            data = {
+                "short_name" : short_name,
+                "declaration" : declaration,
+                "symbol" : symbol
+            }
+
+            if short_name.startswith('initialize'):
+                self.initializers.append(data)
+            elif short_name == 'cleanup':
+                self.cleanup = data
+            else:
+                self.callbacks.append(data)
+
+        return self.callbacks != []
+
+    def refresh(self, path):
+        self.modified = False
+
+        try:
+            st = os.stat(path)
+
+            # Not modified
+            if st.st_mtime == self.mtime:
+                return True
+
+            self.modified = True
+            self.mtime = st.st_mtime
+
+            with codecs.open(path, encoding='utf-8') as fp:
+                raw_content = fp.read()
+
+        except IOError:
+            return False
+
+        return self.parse(raw_content)
+
+class TestSuite(object):
+
+    def __init__(self, path, output):
+        self.path = path
+        self.output = output
+
+    def should_generate(self, path):
+        if not os.path.isfile(path):
+            return True
+
+        if any(module.modified for module in self.modules.values()):
+            return True
+
+        return False
+
+    def find_modules(self):
+        modules = []
+        for root, _, files in os.walk(self.path):
+            module_root = root[len(self.path):]
+            module_root = [c for c in module_root.split(os.sep) if c]
+
+            tests_in_module = fnmatch.filter(files, "*.c")
+
+            for test_file in tests_in_module:
+                full_path = os.path.join(root, test_file)
+                module_name = "_".join(module_root +

[test_file[:-2]]).replace("-", "_")

t/unit-tests/clar/generate.py new file +44 -0

+
+                modules.append((full_path, module_name))
+
+        return modules
+
+    def load_cache(self):
+        path = os.path.join(self.output, '.clarcache')
+        cache = {}
+
+        try:
+            fp = open(path, 'rb')
+            cache = pickle.load(fp)
+            fp.close()
+        except (IOError, ValueError):
+            pass
+
+        return cache
+
+    def save_cache(self):
+        path = os.path.join(self.output, '.clarcache')
+        with open(path, 'wb') as cache:
+            pickle.dump(self.modules, cache)
+
+    def load(self, force = False):
+        module_data = self.find_modules()
+        self.modules = {} if force else self.load_cache()
+
+        for path, name in module_data:
+            if name not in self.modules:
+                self.modules[name] = Module(name)
+
+            if not self.modules[name].refresh(path):
+                del self.modules[name]
+
+    def disable(self, excluded):
+        for exclude in excluded:
+            for module in self.modules.values():
+                name = module.clean_name()
+                if name.startswith(exclude):
+                    module.enabled = False
+                    module.modified = True
+
+    def suite_count(self):
+        return sum(max(1, len(m.initializers)) for m in

self.modules.values())

t/unit-tests/clar/generate.py new file +3 -0

+
+    def callback_count(self):
+        return sum(len(module.callbacks) for module in

self.modules.values())

t/unit-tests/clar/generate.py new file +9 -0

+
+    def write(self):
+        output = os.path.join(self.output, 'clar.suite')
+
+        if not self.should_generate(output):
+            return False
+
+        with open(output, 'w') as data:
+            modules = sorted(self.modules.values(), key=lambda module:

module.name)

t/unit-tests/clar/generate.py new file +10 -0

+
+            for module in modules:
+                t = Module.DeclarationTemplate(module)
+                data.write(t.render())
+
+            for module in modules:
+                t = Module.CallbacksTemplate(module)
+                data.write(t.render())
+
+            suites = "static struct clar_suite _clar_suites[] = {" +

','.join(

t/unit-tests/clar/generate.py new file +6 -0

+                Module.InfoTemplate(module).render() for module in modules
+            ) + "\n};\n"
+
+            data.write(suites)
+
+            data.write("static const size_t _clar_suite_count = %d;\n" %

self.suite_count())
+ data.write("static const size_t _clar_callback_count = %d;\n" %
self.callback_count())

t/unit-tests/clar/generate.py new file +9 -0

+
+        self.save_cache()
+        return True
+
+if __name__ == '__main__':
+    from optparse import OptionParser
+
+    parser = OptionParser()
+    parser.add_option('-f', '--force', action="store_true", dest='force',

default=False)
+ parser.add_option('-x', '--exclude', dest='excluded', action='append',
default=[])

t/unit-tests/clar/generate.py new file +14 -0

+    parser.add_option('-o', '--output', dest='output')
+
+    options, args = parser.parse_args()
+    if len(args) > 1:
+        print("More than one path given")
+        sys.exit(1)
+
+    path = args.pop() if args else '.'
+    output = options.output or path
+    suite = TestSuite(path, output)
+    suite.load(options.force)
+    suite.disable(options.excluded)
+    if suite.write():
+        print("Written `clar.suite` (%d tests in %d suites)" %

(suite.callback_count(), suite.suite_count()))

t/unit-tests/clar/test/.gitignore new file +4 -0

new file mode 100644
index 0000000000..a477d0c40c
@@ -0,0 +1,4 @@
+clar.suite
+.clarcache
+clar_test
+*.o

t/unit-tests/clar/test/Makefile new file +39 -0

new file mode 100644
index 0000000000..93c6b2ad32
@@ -0,0 +1,39 @@
+#
+# Copyright (c) Vicent Marti. All rights reserved.
+#
+# This file is part of clar, distributed under the ISC license.
+# For full terms see the included COPYING file.
+#
+
+#
+# Set up the path to the clar sources and to the fixtures directory
+#
+# The fixture path needs to be an absolute path so it can be used
+# even after we have chdir'ed into the test directory while testing.
+#
+CURRENT_MAKEFILE  := $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
+TEST_DIRECTORY    := $(abspath $(dir $(CURRENT_MAKEFILE)))
+CLAR_PATH         := $(dir $(TEST_DIRECTORY))
+CLAR_FIXTURE_PATH := $(TEST_DIRECTORY)/resources/
+
+CFLAGS=-g -I.. -I. -Wall -DCLAR_FIXTURE_PATH=\"$(CLAR_FIXTURE_PATH)\"
+
+.PHONY: clean
+
+# list the objects that go into our test
+objects = main.o sample.o
+
+# build the test executable itself
+clar_test: $(objects) clar_test.h clar.suite $(CLAR_PATH)clar.c
+	$(CC) $(CFLAGS) -o $@ "$(CLAR_PATH)clar.c" $(objects)
+
+# test object files depend on clar macros
+$(objects) : $(CLAR_PATH)clar.h
+
+# build the clar.suite file of test metadata
+clar.suite:
+	python "$(CLAR_PATH)generate.py" .
+
+# remove all generated files
+clean:
+	$(RM) -rf *.o clar.suite .clarcache clar_test clar_test.dSYM

t/unit-tests/clar/test/clar_test.h new file +16 -0

new file mode 100644
index 0000000000..0fcaa639aa
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+#ifndef __CLAR_TEST__
+#define __CLAR_TEST__
+
+/* Import the standard clar helper functions */
+#include "clar.h"
+
+/* Your custom shared includes / defines here */
+extern int global_test_counter;
+
+#endif

t/unit-tests/clar/test/main.c new file +40 -0

new file mode 100644
index 0000000000..59e56ad255
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+
+#include "clar_test.h"
+
+/*
+ * Sample main() for clar tests.
+ *
+ * You should write your own main routine for clar tests that does specific
+ * setup and teardown as necessary for your application.  The only required
+ * line is the call to `clar_test(argc, argv)`, which will execute the test
+ * suite.  If you want to check the return value of the test application,
+ * your main() should return the same value returned by clar_test().
+ */
+
+int global_test_counter = 0;
+
+#ifdef _WIN32
+int __cdecl main(int argc, char *argv[])
+#else
+int main(int argc, char *argv[])
+#endif
+{
+	int ret;
+
+	/* Your custom initialization here */
+	global_test_counter = 0;
+
+	/* Run the test suite */
+	ret = clar_test(argc, argv);
+
+	/* Your custom cleanup here */
+	cl_assert_equal_i(8, global_test_counter);
+
+	return ret;
+}

t/unit-tests/clar/test/main.c.sample new file +13 -0

new file mode 100644
index 0000000000..a4d91b72fa
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Vicent Marti. All rights reserved.
+ *
+ * This file is part of clar, distributed under the ISC license.
+ * For full terms see the included COPYING file.
+ */
+
+#include "clar_test.h"
+
+/*
+ * Minimal main() for clar tests.
+ *
+ * Modify this with any application specific setup or teardown that you

need.
+ * The only required line is the call to clar_test(argc, argv), which will
+ * execute the test suite. If you want to check the return value of the test
+ * application, main() should return the same value returned by clar_test().
+ */

t/unit-tests/clar/test/main.c.sample new file +10 -0

+
+#ifdef _WIN32
+int __cdecl main(int argc, char *argv[])
+#else
+int main(int argc, char *argv[])
+#endif
+{
+	/* Run the test suite */
+	return clar_test(argc, argv);
+}

t/unit-tests/clar/test/resources/test/file new file +1 -0

new file mode 100644
index 0000000000..220f4aa98a
@@ -0,0 +1 @@
+File

t/unit-tests/clar/test/sample.c new file +84 -0

new file mode 100644
index 0000000000..faa1209262
@@ -0,0 +1,84 @@
+#include "clar_test.h"
+#include <sys/stat.h>
+
+static int file_size(const char *filename)
+{
+	struct stat st;
+
+	if (stat(filename, &st) == 0)
+		return (int)st.st_size;
+	return -1;
+}
+
+void test_sample__initialize(void)
+{
+	global_test_counter++;
+}
+
+void test_sample__cleanup(void)
+{
+	cl_fixture_cleanup("test");
+
+	cl_assert(file_size("test/file") == -1);
+}
+
+void test_sample__1(void)
+{
+	cl_assert(1);
+	cl_must_pass(0);  /* 0 == success */
+	cl_must_fail(-1); /* <0 == failure */
+	cl_must_pass(-1); /* demonstrate a failing call */
+}
+
+void test_sample__2(void)
+{
+	cl_fixture_sandbox("test");
+
+	cl_assert(file_size("test/nonexistent") == -1);
+	cl_assert(file_size("test/file") > 0);
+	cl_assert(100 == 101);
+}
+
+void test_sample__strings(void)
+{
+	const char *actual = "expected";
+	cl_assert_equal_s("expected", actual);
+	cl_assert_equal_s_("expected", actual, "second try with annotation");
+	cl_assert_equal_s_("mismatched", actual, "this one fails");
+}
+
+void test_sample__strings_with_length(void)
+{
+	const char *actual = "expected";
+	cl_assert_equal_strn("expected_", actual, 8);
+	cl_assert_equal_strn("exactly", actual, 2);
+	cl_assert_equal_strn_("expected_", actual, 8, "with annotation");
+	cl_assert_equal_strn_("exactly", actual, 3, "this one fails");
+}
+
+void test_sample__int(void)
+{
+	int value = 100;
+	cl_assert_equal_i(100, value);
+	cl_assert_equal_i_(101, value, "extra note on failing test");
+}
+
+void test_sample__int_fmt(void)
+{
+	int value = 100;
+	cl_assert_equal_i_fmt(022, value, "%04o");
+}
+
+void test_sample__bool(void)
+{
+	int value = 100;
+	cl_assert_equal_b(1, value);       /* test equality as booleans */
+	cl_assert_equal_b(0, value);
+}
+
+void test_sample__ptr(void)
+{
+	const char *actual = "expected";
+	cl_assert_equal_p(actual, actual); /* pointers to same object */
+	cl_assert_equal_p(&actual, actual);
+}

t/unit-tests/clar/clar.c line 25

Quoted 12 lines · Patrick Steinhardt

t/unit-tests/clar/clar.c new renamed from t/unit-tests/clar/clar.c +0 -0

file mode 100644 index 0000000000..3fc2c76815

t/unit-tests/clar/clar.c new file +6 -0

@@ -0,0 +1,842 @@
...
+
+#ifdef _WIN32
+#	include <windows.h>
+#	include <io.h>
+#	include <shellapi.h>
+#	include <direct.h>

This seems to break Windows build

In file included from t/unit-tests/clar/clar.c:22:
D:/git-sdk-64-minimal/mingw64/include/windows.h:89:10: fatal error: shellapi.h:
No such file or directory

    89 | #include <shellapi.h>
       |          ^~~~~~~~~~~~

compilation terminated.

https://github.com/git/git/actions/runs/10459342252/job/28963152995

As we have other topics that I do want to do well in 'seen' before merging them to 'next', I'd temporarily drop this topic from 'seen'
and push out the rest of the topics.

Quoted 24 lines · Junio C Hamano

t/unit-tests/clar/clar.c line 25

Quoted 12 lines · Patrick Steinhardt

t/unit-tests/clar/clar.c new renamed from t/unit-tests/clar/clar.c +0 -0

file mode 100644 index 0000000000..3fc2c76815

t/unit-tests/clar/clar.c new file +6 -0

@@ -0,0 +1,842 @@
...
+
+#ifdef _WIN32
+#	include <windows.h>
+#	include <io.h>
+#	include <shellapi.h>
+#	include <direct.h>

This seems to break Windows build

In file included from t/unit-tests/clar/clar.c:22:
D:/git-sdk-64-minimal/mingw64/include/windows.h:89:10: fatal error: shellapi.h:
No such file or directory

    89 | #include <shellapi.h>
       |          ^~~~~~~~~~~~

compilation terminated.

Quoted 5 lines

https://github.com/git/git/actions/runs/10459342252/job/28963152995

As we have other topics that I do want to do well in 'seen' before merging them to 'next', I'd temporarily drop this topic from 'seen'
and push out the rest of the topics.

shellapi.h is not portable. This breaks the NonStop build also.

Quoted 18 lines · <[email protected]> writes:

Quoted 17 lines · Junio C Hamano

t/unit-tests/clar/clar.c line 25

Quoted 12 lines · Patrick Steinhardt

t/unit-tests/clar/clar.c new renamed from t/unit-tests/clar/clar.c +0 -0

file mode 100644 index 0000000000..3fc2c76815

t/unit-tests/clar/clar.c new file +6 -0

@@ -0,0 +1,842 @@
...
+
+#ifdef _WIN32
+#	include <windows.h>
+#	include <io.h>
+#	include <shellapi.h>
+#	include <direct.h>

This seems to break Windows build

Quoted 2 lines

Quoted 2 lines

In file included from t/unit-tests/clar/clar.c:22:
D:/git-sdk-64-minimal/mingw64/include/windows.h:89:10: fatal error:

shellapi.h:

Quoted 7 lines

Quoted 7 lines

No such file or directory

    89 | #include <shellapi.h>
       |          ^~~~~~~~~~~~

compilation terminated.

https://github.com/git/git/actions/runs/10459342252/job/28963152995

Quoted 5 lines

Quoted 3 lines

As we have other topics that I do want to do well in 'seen' before merging them to 'next', I'd temporarily drop this topic from 'seen' and push out the rest of the topics.

shellapi.h is not portable. This breaks the NonStop build also.

Even inside "#ifdef _WIN32"?

t/unit-tests/clar/clar.c line 25

Quoted 13 lines · Patrick Steinhardt

t/unit-tests/clar/clar.c new file +6 -0

new file mode 100644
index 0000000000..3fc2c76815
@@ -0,0 +1,842 @@
...
+
+#ifdef _WIN32
+#	include <windows.h>
+#	include <io.h>
+#	include <shellapi.h>
+#	include <direct.h>

This seems to break Windows build

In file included from t/unit-tests/clar/clar.c:22:
D:/git-sdk-64-minimal/mingw64/include/windows.h:89:10: fatal error: shellapi.h: No such file or directory

     89 | #include <shellapi.h>
        |          ^~~~~~~~~~~~

compilation terminated.

https://github.com/git/git/actions/runs/10459342252/job/28963152995

As we have other topics that I do want to do well in 'seen' before merging them to 'next', I'd temporarily drop this topic from 'seen' and push out the rest of the topics.

Hi Patrick

Quoted 9 lines · Patrick Steinhardt

t/unit-tests/unit-test.c +0 -0

index 32a81299e9..82b7635e6a 100644
@@ -6,10 +6,9 @@ int cmd_main(int argc, const char **argv)
  	int ret;
    	/* Append the "-t" flag such that the tests generate TAP

output. */

t/unit-tests/unit-test.c +0 -1

-	ALLOC_ARRAY(argv_copy, argc + 2);

t/unit-tests/unit-test.c int cmd_main(int argc, const char **argv) · line 12

Quoted 4 lines

t/unit-tests/unit-test.c +1 -1

+	ALLOC_ARRAY(argv_copy, argc + 1);
  	COPY_ARRAY(argv_copy, argv, argc);
  	argv_copy[argc++] = "-t";
-	argv_copy[argc] = NULL;

I'm confused by this - it looks like it belongs in the previous patch but why are we deleting the line that adds the terminating NULL to argv in the first place?

Quoted 12 lines · Phillip Wood

Hi Patrick

Quoted 9 lines · Patrick Steinhardt

t/unit-tests/unit-test.c +0 -0

index 32a81299e9..82b7635e6a 100644
@@ -6,10 +6,9 @@ int cmd_main(int argc, const char **argv)
  	int ret;
    	/* Append the "-t" flag such that the tests generate TAP

output. */

t/unit-tests/unit-test.c +0 -1

-	ALLOC_ARRAY(argv_copy, argc + 2);

Quoted 8 lines

t/unit-tests/unit-test.c int cmd_main(int argc, const char **argv) · line 12

Quoted 4 lines

t/unit-tests/unit-test.c +1 -1

+	ALLOC_ARRAY(argv_copy, argc + 1);
  	COPY_ARRAY(argv_copy, argv, argc);
  	argv_copy[argc++] = "-t";
-	argv_copy[argc] = NULL;

I'm confused by this - it looks like it belongs in the previous patch but why are we deleting the line that adds the terminating NULL to argv in the first place?

I agree with you that it belongs to the previous step. clar_test(), unlike the usual convention used by main(), works solely with argc to tell where the list of argument ends, without requiring argv[] to be an NULL terminated array. I do not know if clar _promises_ that as the calling convention to its users, but if it does so, and if we want to take advantage of that promise and leave the terminating NULL out of argv[], we should do so from the beginning.

A NULL-terminated argv[], as long as we make sure argc only counts the real arguments without counting that terminating NULL, would not harm the clar_test(argc, argv) call, so I actually do not mind the way this caller was originally written, with terminating NULL. It looks a lot more familiar, even though we may be wasting memory at the end of argv[] array.

  #define TEST_CHAR_CLASS(class, string) do { \
  	size_t len = ARRAY_SIZE(string) - 1 + \
  		BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \
  		BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \

t/unit-tests/ctype.c renamed from t/unit-tests/t-ctype.c +0 -1

-	int skip = test__run_begin(); \

t/unit-tests/ctype.c renamed from t/unit-tests/t-ctype.c +55 -3

+	cl_assert(!class(EOF)); \
  } while (0)
 
  #define DIGIT "0123456789"

@@ -33,21 +27,72 @@
  	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \
  	"\x7f"
 
-int cmd_main(int argc, const char **argv) {
+void test_ctype__isspace(void)
+{
  	TEST_CHAR_CLASS(isspace, " \n\r\t");
+}
+
+void test_ctype__isdigit(void)
+{
  	TEST_CHAR_CLASS(isdigit, DIGIT);
+}
+
+void test_ctype__isalpha(void)
+{
  	TEST_CHAR_CLASS(isalpha, LOWER UPPER);
+}
+
+void test_ctype__isalnum(void)
+{
  	TEST_CHAR_CLASS(isalnum, LOWER UPPER DIGIT);
+}
+
+void test_ctype__is_glob_special(void)
+{
  	TEST_CHAR_CLASS(is_glob_special, "*?[\\");
+}
+
+void test_ctype__is_regex_special(void)
+{
  	TEST_CHAR_CLASS(is_regex_special, "$()*+.?[\\^{|");
+}
+
+void test_ctype__is_pathspec_magic(void)
+{
  	TEST_CHAR_CLASS(is_pathspec_magic, "!\"#%&',-/:;<=>@_`~");
+}
+
+void test_ctype__isascii(void)
+{
  	TEST_CHAR_CLASS(isascii, ASCII);
+}
+
+void test_ctype__islower(void)
+{
  	TEST_CHAR_CLASS(islower, LOWER);
+}
+
+void test_ctype__isupper(void)
+{
  	TEST_CHAR_CLASS(isupper, UPPER);
+}
+
+void test_ctype__iscntrl(void)
+{
  	TEST_CHAR_CLASS(iscntrl, CNTRL);
+}
+
+void test_ctype__ispunct(void)
+{
  	TEST_CHAR_CLASS(ispunct, PUNCT);
+}
+
+void test_ctype__isxdigit(void)
+{
  	TEST_CHAR_CLASS(isxdigit, DIGIT "abcdefABCDEF");
-	TEST_CHAR_CLASS(isprint, LOWER UPPER DIGIT PUNCT " ");
+}
 
-	return test_done();
+void test_ctype__isprint(void)
+{
+	TEST_CHAR_CLASS(isprint, LOWER UPPER DIGIT PUNCT " ");
  }

Hi Patrick

Quoted 5 lines · Patrick Steinhardt

  #define TEST_CHAR_CLASS(class, string) do { \
  	size_t len = ARRAY_SIZE(string) - 1 + \
  		BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \
  		BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \

t/unit-tests/ctype.c renamed from t/unit-tests/t-ctype.c +0 -1

-	int skip = test__run_begin(); \

t/unit-tests/ctype.c line 8

Quoted 10 lines

t/unit-tests/ctype.c renamed from t/unit-tests/t-ctype.c +2 -8

-	if (!skip) { \
-		for (int i = 0; i < 256; i++) { \
-			if (!check_int(class(i), ==, !!memchr(string, i, len)))\
-				test_msg("      i: 0x%02x", i); \
-		} \
-		check(!class(EOF)); \
-	} \
-	test__run_end(!skip, TEST_LOCATION(), #class " works"); \
+	for (int i = 0; i < 256; i++) \
+		cl_assert_equal_i(class(i), !!memchr(string, i, len)); \

If this fails how are we supposed to know which character it was checking?

Thanks

Convert the ctype tests to use the new clar unit testing framework.

Signed-off-by Patrick Steinhardt <[email protected]>

---
 Makefile                            |  2 +-
 t/unit-tests/{t-ctype.c => ctype.c} | 71 +++++++++++++++++++++++------
 2 files changed, 59 insertions(+), 14 deletions(-)
 rename t/unit-tests/{t-ctype.c => ctype.c} (71%)

#define TEST_CHAR_CLASS(class, string) do { \

t/unit-tests/ctype.c renamed from t/unit-tests/t-ctype.c +3 -9

 	size_t len = ARRAY_SIZE(string) - 1 + \
 		BUILD_ASSERT_OR_ZERO(ARRAY_SIZE(string) > 0) + \
 		BUILD_ASSERT_OR_ZERO(sizeof(string[0]) == sizeof(char)); \
-	int skip = test__run_begin(); \
-	if (!skip) { \
-		for (int i = 0; i < 256; i++) { \
-			if (!check_int(class(i), ==, !!memchr(string, i, len)))\
-				test_msg("      i: 0x%02x", i); \
-		} \
-		check(!class(EOF)); \
-	} \
-	test__run_end(!skip, TEST_LOCATION(), #class " works"); \
+	for (int i = 0; i < 256; i++) \
+		cl_assert_equal_i(class(i), !!memchr(string, i, len)); \
+	cl_assert(!class(EOF)); \
 } while (0)

Hi,

this is the fifth version of my patch series that introduces the clar testing framework for our unit tests.

Changes compared to v4:

- The whitespace fixes have been merged upstream, so I've updated the embedded copy of clar and dropped the subsequent patch that fixed them in our copy. The NonStop compatibility fixes have not yet been merged as the pull request needs some more work.

- Both "clar-decls.h" and "clar.suite" are now part of GENERATED_H. This brings removal of these files via "make clean" for free.

- The "sparse" target already depends on GENERATED_H, but in a broken way. I've fixed that in a new commit.

- The "sparse" target no longer checks external sources, including the clar sources.

- The "hdr-check" target now depends on GENERATED_H, as well. This avoids having to manually wire up dependencies on generated headers per file, which seems rather unmaintainable to me.

With this, the "hdr-check" and "sparse" targets all work on my machine now.

Thanks!

Patrick

Patrick Steinhardt (9):
t: do not pass GIT_TEST_OPTS to unit tests with prove
t: import the clar unit testing framework t/clar: fix compatibility with NonStop
Makefile: fix sparse dependency on GENERATED_H
Makefile: make hdr-check depend on generated headers
Makefile: do not use sparse on third-party sources
Makefile: wire up the clar unit testing framework t/unit-tests: convert strvec tests to use clar t/unit-tests: convert ctype tests to use clar

  .gitignore                                 |   1 +
  Documentation/technical/unit-tests.txt     |   2 +
  Makefile                                   |  53 +-
  t/Makefile                                 |   4 +-
  t/run-test.sh                              |   2 +-
  t/unit-tests/.gitignore                    |   2 +
  t/unit-tests/clar-generate.awk             |  50 ++
  t/unit-tests/clar/.github/workflows/ci.yml |  23 +
  t/unit-tests/clar/COPYING                  |  15 +
  t/unit-tests/clar/README.md                | 329 ++++++++
  t/unit-tests/clar/clar.c                   | 842 +++++++++++++++++++++
  t/unit-tests/clar/clar.h                   | 173 +++++
  t/unit-tests/clar/clar/fixtures.h          |  50 ++
  t/unit-tests/clar/clar/fs.h                | 522 +++++++++++++
  t/unit-tests/clar/clar/print.h             | 211 ++++++
  t/unit-tests/clar/clar/sandbox.h           | 159 ++++
  t/unit-tests/clar/clar/summary.h           | 143 ++++
  t/unit-tests/clar/generate.py              | 266 +++++++
  t/unit-tests/clar/test/.gitignore          |   4 +
  t/unit-tests/clar/test/Makefile            |  39 +
  t/unit-tests/clar/test/clar_test.h         |  16 +
  t/unit-tests/clar/test/main.c              |  40 +
  t/unit-tests/clar/test/main.c.sample       |  27 +
  t/unit-tests/clar/test/resources/test/file |   1 +
  t/unit-tests/clar/test/sample.c            |  84 ++
  t/unit-tests/{t-ctype.c => ctype.c}        |  71 +-
  t/unit-tests/{t-strvec.c => strvec.c}      | 119 ++-
  t/unit-tests/unit-test.c                   |  17 +
  t/unit-tests/unit-test.h                   |   3 +
  29 files changed, 3166 insertions(+), 102 deletions(-)

create mode 100644 t/unit-tests/clar-generate.awk create mode 100644 t/unit-tests/clar/.github/workflows/ci.yml create mode 100644 t/unit-tests/clar/COPYING
create mode 100644 t/unit-tests/clar/README.md create mode 100644 t/unit-tests/clar/clar.c
create mode 100644 t/unit-tests/clar/clar.h
create mode 100644 t/unit-tests/clar/clar/fixtures.h create mode 100644 t/unit-tests/clar/clar/fs.h create mode 100644 t/unit-tests/clar/clar/print.h create mode 100644 t/unit-tests/clar/clar/sandbox.h create mode 100644 t/unit-tests/clar/clar/summary.h create mode 100755 t/unit-tests/clar/generate.py create mode 100644 t/unit-tests/clar/test/.gitignore create mode 100644 t/unit-tests/clar/test/Makefile create mode 100644 t/unit-tests/clar/test/clar_test.h create mode 100644 t/unit-tests/clar/test/main.c create mode 100644 t/unit-tests/clar/test/main.c.sample create mode 100644 t/unit-tests/clar/test/resources/test/file create mode 100644 t/unit-tests/clar/test/sample.c rename t/unit-tests/{t-ctype.c => ctype.c} (71%) rename t/unit-tests/{t-strvec.c => strvec.c} (54%) create mode 100644 t/unit-tests/unit-test.c
create mode 100644 t/unit-tests/unit-test.h

Range-diff against v4:
1: 086dd728a7 ! 1: 832dc0496f t: do not pass GIT_TEST_OPTS to unit tests with prove
@@ Commit message
environment variable. Like this, we can conditionally forward it to our test scripts, only.

+ Signed-off-by: Patrick Steinhardt <[email protected]>
+
## t/Makefile ##
@@ t/Makefile: failed:
test -z "$$failed" || $(MAKE) $$failed
2: 5c22e0b3b9 ! 2: 3690607933 t: import the clar unit testing framework

     @@ Metadata
       ## Commit message ##
          t: import the clar unit testing framework
      
     -    Import the clar unit testing framework at commit faa8419 (Merge pull
     -    request #93 from clar-test/ethomson/fixtures, 2023-12-14). The framework
     +    Import the clar unit testing framework at commit 1516124 (Merge pull
     +    request #97 from pks-t/pks-whitespace-fixes, 2024-08-15). The framework
          will be wired up in subsequent commits.
      
          Signed-off-by: Patrick Steinhardt <[email protected]>
     @@ t/unit-tests/clar/clar/fs.h (new)
      +			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);
      +
     @@ t/unit-tests/clar/clar/sandbox.h (new)
      +	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]);
     @@ t/unit-tests/clar/clar/sandbox.h (new)
      +{
      +	return _clar_path;
      +}
     -+
      
       ## t/unit-tests/clar/clar/summary.h (new) ##
      @@
     @@ t/unit-tests/clar/generate.py (new)
      +    suite.disable(options.excluded)
      +    if suite.write():
      +        print("Written `clar.suite` (%d tests in %d suites)" % (suite.callback_count(), suite.suite_count()))
     -+
      
       ## t/unit-tests/clar/test/.gitignore (new) ##
      @@
     @@ t/unit-tests/clar/test/.gitignore (new)
      +.clarcache
      +clar_test
      +*.o
     -+
      
       ## t/unit-tests/clar/test/Makefile (new) ##
      @@
  4:  75e097dfa4 =  3:  db53673294 t/clar: fix compatibility with NonStop
  3:  e0f99874cc !  4:  b6199c88dd t/clar: fix whitespace errors

@@ Metadata
Author: Patrick Steinhardt <[email protected]>

## Commit message ##
- t/clar: fix whitespace errors
-
- Fix whitespace errors in the clar that make git-apply(1) unhappy. This
- has been cherry-picked from the upstream pull request at [1].
-
- [1]: https://github.com/clar-test/clar/pull/97
+ Makefile: fix sparse dependency on GENERATED_H
+
+ The "check" Makefile target is essentially an alias around the "sparse"
+ target. The one difference though is that it will tell users to instead
+ run the "test" target in case they do not have sparse(1) installed, as
+ chances are high that they wanted to execute the test suite rather than
+ doing semantic checks.
+
+ But even though the "check" target ultimately just ends up executing
+ make sparse, it still depends on our generated headers. This does not
+ make any sense though: they are irrelevant for the "test" target advice,
+ and if these headers are required for the "sparse" target they must be
+ declared as a dependency on the aliased target, not the alias.
+
+ But even moving the dependency to the "sparse" target is wrong, as
+ concurrent builds may then end up generating the headers and running
+ sparse concurrently. Instead, we make them a dependency of the specific
+ objects. While that is overly broad, it does ensure correct ordering.
+ The alternative, specifying which file depends on what generated header
+ explicitly, feels rather unmaintainable.

Signed-off-by Patrick Steinhardt <[email protected]>

- ## t/unit-tests/clar/clar/fs.h ##
-@@ t/unit-tests/clar/clar/fs.h: 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);
+ ## Makefile ##
+@@ Makefile: check-sha1:: t/helper/test-tool$X

-
- ## t/unit-tests/clar/clar/sandbox.h ##
-@@ t/unit-tests/clar/clar/sandbox.h: 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"
-- };
-+ };
+ SP_OBJ = $(patsubst %.o,%.sp,$(OBJECTS))

-- size_t i;
-+ size_t i;
+-$(SP_OBJ): %.sp: %.c %.o
++$(SP_OBJ): %.sp: %.c %.o $(GENERATED_H)
+ $(QUIET_SP)cgcc -no-compile $(ALL_CFLAGS) $(EXTRA_CPPFLAGS) \
+ -Wsparse-error \
+ $(SPARSE_FLAGS) $(SP_EXTRA_FLAGS) $< && \
+@@ Makefile: style:
+ git clang-format --style file --diff --extensions c,h

- for (i = 0; i < var_count; ++i) {
- const char *env = getenv(env_vars[i]);
-@@ t/unit-tests/clar/clar/sandbox.h: const char *clar_sandbox_path(void)
- {
- return _clar_path;
- }
--
-
- ## t/unit-tests/clar/generate.py ##
-@@ t/unit-tests/clar/generate.py: def write(self):
- suite.disable(options.excluded)
- if suite.write():
- print("Written clar.suite (%d tests in %d suites)" % (suite.callback_count(), suite.suite_count()))
--
-
- ## t/unit-tests/clar/test/.gitignore ##
-@@ t/unit-tests/clar/test/.gitignore: clar.suite
- .clarcache
- clar_test
- *.o
--
+ .PHONY: check
+-check: $(GENERATED_H)
++check:
+ @if sparse; \
+ then \
+ echo >&2 "Use 'make sparse' instead"; \

  -:  ---------- >  5:  06364b2b72 Makefile: make hdr-check depend on generated headers
  -:  ---------- >  6:  88ea94ce16 Makefile: do not use sparse on third-party sources
  5:  5b8a64ae79 !  7:  05bcb5bef6 Makefile: wire up the clar unit testing framework
     @@ .gitignore
       /bin-wrappers/
      
       ## Makefile ##
     +@@ Makefile: REFTABLE_TEST_LIB = reftable/libreftable_test.a
     + GENERATED_H += command-list.h
     + GENERATED_H += config-list.h
     + GENERATED_H += hook-list.h
     ++GENERATED_H += $(UNIT_TEST_DIR)/clar-decls.h
     ++GENERATED_H += $(UNIT_TEST_DIR)/clar.suite
     +
     + .PHONY: generated-hdrs
     + generated-hdrs: $(GENERATED_H)
      @@ Makefile: THIRD_PARTY_SOURCES += sha1dc/%
       THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/%
       THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/%
     @@ Makefile: endif
       
       bin-wrappers/%: wrap-for-bin.sh
       	$(call mkdir_p_parent_template)
     -@@ Makefile: CHK_HDRS = $(filter-out $(EXCEPT_HDRS),$(LIB_H))
     - HCO = $(patsubst %.h,%.hco,$(CHK_HDRS))
     - HCC = $(HCO:hco=hcc)
     -
     -+$(UNIT_TEST_DIR)/unit-test.hcc: $(UNIT_TEST_DIR)/unit-test.h $(UNIT_TEST_DIR)/clar-decls.h
     - %.hcc: %.h
     - 	@echo '#include "git-compat-util.h"' >$@
     - 	@echo '#include "$<"' >>$@
      @@ Makefile: endif
       
       artifacts-tar:: $(ALL_COMMANDS_TO_INSTALL) $(SCRIPT_LIB) $(OTHER_PROGRAMS) \
     @@ Makefile: cocciclean:
       
       clean: profile-clean coverage-clean cocciclean
       	$(RM) -r .build $(UNIT_TEST_BIN)
     -+	$(RM) GIT-TEST-SUITES $(UNIT_TEST_DIR)/clar.suite $(UNIT_TEST_DIR)/clar-decls.h
     ++	$(RM) GIT-TEST-SUITES
       	$(RM) po/git.pot po/git-core.pot
       	$(RM) git.res
       	$(RM) $(OBJECTS)
  6:  bc4e23d666 =  8:  8f56b4d626 t/unit-tests: convert strvec tests to use clar
  7:  0a7fe8775a =  9:  ca09d19fd5 t/unit-tests: convert ctype tests to use clar

base-commit: 406f326d271e0bacecdb00425422c5fa3f314930