[lttng-ust.git] / tests / tap.c

/*-
 * Copyright (c) 2004 Nik Clayton
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#define _GNU_SOURCE
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

#include "tap.h"

static int no_plan = 0;
static int skip_all = 0;
static int have_plan = 0;
static unsigned int test_count = 0; /* Number of tests that have been run */
static unsigned int e_tests = 0; /* Expected number of tests to run */
static unsigned int failures = 0; /* Number of tests that failed */
static char *todo_msg = NULL;
static char *todo_msg_fixed = "libtap malloc issue";
static int todo = 0;
static int test_died = 0;

/* Encapsulate the pthread code in a conditional.  In the absence of
   libpthread the code does nothing */
#ifdef HAVE_LIBPTHREAD
#include <pthread.h>
static pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
# define LOCK pthread_mutex_lock(&M);
# define UNLOCK pthread_mutex_unlock(&M);
#else
# define LOCK
# define UNLOCK
#endif

static void _expected_tests(unsigned int);
static void _tap_init(void);
static void _cleanup(void);

/*
 * Generate a test result.
 *
 * ok -- boolean, indicates whether or not the test passed.
 * test_name -- the name of the test, may be NULL
 * test_comment -- a comment to print afterwards, may be NULL
 */
unsigned int
_gen_result(int ok, const char *func, char *file, unsigned int line,
	    char *test_name, ...)
{
	va_list ap;
	char *local_test_name = NULL;
	char *c;
	int name_is_digits;

	LOCK;

	test_count++;

	/* Start by taking the test name and performing any printf()
	   expansions on it */
	if(test_name != NULL) {
		va_start(ap, test_name);
		if (vasprintf(&local_test_name, test_name, ap) == -1) {
			local_test_name = NULL;
		}
		va_end(ap);

		/* Make sure the test name contains more than digits
		   and spaces.  Emit an error message and exit if it
		   does */
		if(local_test_name) {
			name_is_digits = 1;
			for(c = local_test_name; *c != '\0'; c++) {
				if(!isdigit(*c) && !isspace(*c)) {
					name_is_digits = 0;
					break;
				}
			}

			if(name_is_digits) {
				diag("    You named your test '%s'.  You shouldn't use numbers for your test names.", local_test_name);
				diag("    Very confusing.");
			}
		}
	}

	if(!ok) {
		printf("not ");
		failures++;
	}

	printf("ok %d", test_count);

	if(test_name != NULL) {
		printf(" - ");

		/* Print the test name, escaping any '#' characters it
		   might contain */
		if(local_test_name != NULL) {
			flockfile(stdout);
			for(c = local_test_name; *c != '\0'; c++) {
				if(*c == '#')
					fputc('\\', stdout);
				fputc((int)*c, stdout);
			}
			funlockfile(stdout);
		} else {	/* vasprintf() failed, use a fixed message */
			printf("%s", todo_msg_fixed);
		}
	}

	/* If we're in a todo_start() block then flag the test as being
	   TODO.  todo_msg should contain the message to print at this
	   point.  If it's NULL then asprintf() failed, and we should
	   use the fixed message.

	   This is not counted as a failure, so decrement the counter if
	   the test failed. */
	if(todo) {
		printf(" # TODO %s", todo_msg ? todo_msg : todo_msg_fixed);
		if(!ok)
			failures--;
	}

	printf("\n");

	if(!ok) {
		if(getenv("HARNESS_ACTIVE") != NULL)
			fputs("\n", stderr);

		diag("    Failed %stest (%s:%s() at line %d)",
		     todo ? "(TODO) " : "", file, func, line);
	}
	free(local_test_name);

	UNLOCK;

	/* We only care (when testing) that ok is positive, but here we
	   specifically only want to return 1 or 0 */
	return ok ? 1 : 0;
}

/*
 * Initialise the TAP library.  Will only do so once, however many times it's
 * called.
 */
void
_tap_init(void)
{
	static int run_once = 0;

	if(!run_once) {
		atexit(_cleanup);

		/* stdout needs to be unbuffered so that the output appears
		   in the same place relative to stderr output as it does
		   with Test::Harness */
		setbuf(stdout, 0);
		run_once = 1;
	}
}

/*
 * Note that there's no plan.
 */
int
plan_no_plan(void)
{

	LOCK;

	_tap_init();

	if(have_plan != 0) {
		fprintf(stderr, "You tried to plan twice!\n");
		test_died = 1;
		UNLOCK;
		exit(255);
	}

	have_plan = 1;
	no_plan = 1;

	UNLOCK;

	return 1;
}

/*
 * Note that the plan is to skip all tests
 */
int
plan_skip_all(char *reason)
{

	LOCK;

	_tap_init();

	skip_all = 1;

	printf("1..0");

	if(reason != NULL)
		printf(" # Skip %s", reason);

	printf("\n");

	UNLOCK;

	exit(0);
}

/*
 * Note the number of tests that will be run.
 */
int
plan_tests(unsigned int tests)
{

	LOCK;

	_tap_init();

	if(have_plan != 0) {
		fprintf(stderr, "You tried to plan twice!\n");
		test_died = 1;
		UNLOCK;
		exit(255);
	}

	if(tests == 0) {
		fprintf(stderr, "You said to run 0 tests!  You've got to run something.\n");
		test_died = 1;
		UNLOCK;
		exit(255);
	}

	have_plan = 1;

	_expected_tests(tests);

	UNLOCK;

	return e_tests;
}

unsigned int
diag(char *fmt, ...)
{
	va_list ap;

	fputs("# ", stderr);

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);

	fputs("\n", stderr);

	return 0;
}

void
_expected_tests(unsigned int tests)
{

	printf("1..%d\n", tests);
	e_tests = tests;
}

int
skip(unsigned int n, char *fmt, ...)
{
	va_list ap;
	char *skip_msg = NULL;

	LOCK;

	va_start(ap, fmt);
	if (asprintf(&skip_msg, fmt, ap) == -1) {
		skip_msg = NULL;
	}
	va_end(ap);

	while(n-- > 0) {
		test_count++;
		printf("ok %d # skip %s\n", test_count,
		       skip_msg != NULL ?
		       skip_msg : "libtap():malloc() failed");
	}

	free(skip_msg);

	UNLOCK;

	return 1;
}

void
todo_start(char *fmt, ...)
{
	va_list ap;

	LOCK;

	va_start(ap, fmt);
	if (vasprintf(&todo_msg, fmt, ap) == -1) {
		todo_msg = NULL;
	}
	va_end(ap);

	todo = 1;

	UNLOCK;
}

void
todo_end(void)
{

	LOCK;

	todo = 0;
	free(todo_msg);

	UNLOCK;
}

int
exit_status(void)
{
	int r;

	LOCK;

	/* If there's no plan, just return the number of failures */
	if(no_plan || !have_plan) {
		UNLOCK;
		return failures;
	}

	/* Ran too many tests?  Return the number of tests that were run
	   that shouldn't have been */
	if(e_tests < test_count) {
		r = test_count - e_tests;
		UNLOCK;
		return r;
	}

	/* Return the number of tests that failed + the number of tests
	   that weren't run */
	r = failures + e_tests - test_count;
	UNLOCK;

	return r;
}

/*
 * Cleanup at the end of the run, produce any final output that might be
 * required.
 */
void
_cleanup(void)
{

	LOCK;

	/* If plan_no_plan() wasn't called, and we don't have a plan,
	   and we're not skipping everything, then something happened
	   before we could produce any output */
	if(!no_plan && !have_plan && !skip_all) {
		diag("Looks like your test died before it could output anything.");
		UNLOCK;
		return;
	}

	if(test_died) {
		diag("Looks like your test died just after %d.", test_count);
		UNLOCK;
		return;
	}


	/* No plan provided, but now we know how many tests were run, and can
	   print the header at the end */
	if(!skip_all && (no_plan || !have_plan)) {
		printf("1..%d\n", test_count);
	}

	if((have_plan && !no_plan) && e_tests < test_count) {
		diag("Looks like you planned %d %s but ran %d extra.",
		     e_tests, e_tests == 1 ? "test" : "tests", test_count - e_tests);
		UNLOCK;
		return;
	}

	if((have_plan || !no_plan) && e_tests > test_count) {
		diag("Looks like you planned %d %s but only ran %d.",
		     e_tests, e_tests == 1 ? "test" : "tests", test_count);
		UNLOCK;
		return;
	}

	if(failures)
		diag("Looks like you failed %d %s of %d.",
		     failures, failures == 1 ? "test" : "tests", test_count);

	UNLOCK;
}
Commit	Line	Data
d23b20e9 JG	1	/*-
	2	* Copyright (c) 2004 Nik Clayton
	3	* All rights reserved.
48beefc9	4	*
d23b20e9 JG	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
48beefc9	13	*
d23b20e9 JG	14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	24	* SUCH DAMAGE.
48beefc9	25	*/
d23b20e9 JG	26
	27	#define _GNU_SOURCE
	28	#include <ctype.h>
48beefc9 NC	29	#include <stdarg.h>
48beefc9 NC	30	#include <stdio.h>
d23b20e9 JG	31	#include <stdlib.h>
	32
	33	#include "tap.h"
	34
	35	static int no_plan = 0;
	36	static int skip_all = 0;
	37	static int have_plan = 0;
	38	static unsigned int test_count = 0; /* Number of tests that have been run */
	39	static unsigned int e_tests = 0; /* Expected number of tests to run */
	40	static unsigned int failures = 0; /* Number of tests that failed */
	41	static char *todo_msg = NULL;
	42	static char *todo_msg_fixed = "libtap malloc issue";
	43	static int todo = 0;
	44	static int test_died = 0;
	45
	46	/* Encapsulate the pthread code in a conditional. In the absence of
	47	libpthread the code does nothing */
	48	#ifdef HAVE_LIBPTHREAD
	49	#include <pthread.h>
	50	static pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
	51	# define LOCK pthread_mutex_lock(&M);
	52	# define UNLOCK pthread_mutex_unlock(&M);
	53	#else
	54	# define LOCK
	55	# define UNLOCK
	56	#endif
	57
	58	static void _expected_tests(unsigned int);
	59	static void _tap_init(void);
	60	static void _cleanup(void);
	61
	62	/*
	63	* Generate a test result.
	64	*
	65	* ok -- boolean, indicates whether or not the test passed.
	66	* test_name -- the name of the test, may be NULL
	67	* test_comment -- a comment to print afterwards, may be NULL
	68	*/
	69	unsigned int
	70	_gen_result(int ok, const char func, char file, unsigned int line,
	71	char *test_name, ...)
	72	{
	73	va_list ap;
	74	char *local_test_name = NULL;
	75	char *c;
	76	int name_is_digits;
	77
	78	LOCK;
	79
	80	test_count++;
	81
	82	/* Start by taking the test name and performing any printf()
	83	expansions on it */
	84	if(test_name != NULL) {
	85	va_start(ap, test_name);
980818a3 JG	86	if (vasprintf(&local_test_name, test_name, ap) == -1) {
	87	local_test_name = NULL;
	88	}
d23b20e9 JG	89	va_end(ap);
	90
	91	/* Make sure the test name contains more than digits
	92	and spaces. Emit an error message and exit if it
	93	does */
	94	if(local_test_name) {
	95	name_is_digits = 1;
	96	for(c = local_test_name; *c != '\0'; c++) {
	97	if(!isdigit(c) && !isspace(c)) {
	98	name_is_digits = 0;
	99	break;
	100	}
	101	}
	102
	103	if(name_is_digits) {
	104	diag(" You named your test '%s'. You shouldn't use numbers for your test names.", local_test_name);
	105	diag(" Very confusing.");
	106	}
	107	}
	108	}
48beefc9	109
d23b20e9 JG	110	if(!ok) {
	111	printf("not ");
	112	failures++;
	113	}
48beefc9	114
d23b20e9 JG	115	printf("ok %d", test_count);
	116
	117	if(test_name != NULL) {
	118	printf(" - ");
	119
	120	/* Print the test name, escaping any '#' characters it
	121	might contain */
	122	if(local_test_name != NULL) {
	123	flockfile(stdout);
	124	for(c = local_test_name; *c != '\0'; c++) {
	125	if(*c == '#')
	126	fputc('\\', stdout);
	127	fputc((int)*c, stdout);
	128	}
	129	funlockfile(stdout);
	130	} else { /* vasprintf() failed, use a fixed message */
	131	printf("%s", todo_msg_fixed);
	132	}
	133	}
48beefc9	134
d23b20e9 JG	135	/* If we're in a todo_start() block then flag the test as being
	136	TODO. todo_msg should contain the message to print at this
	137	point. If it's NULL then asprintf() failed, and we should
	138	use the fixed message.
	139
	140	This is not counted as a failure, so decrement the counter if
	141	the test failed. */
	142	if(todo) {
	143	printf(" # TODO %s", todo_msg ? todo_msg : todo_msg_fixed);
	144	if(!ok)
	145	failures--;
	146	}
48beefc9	147
d23b20e9 JG	148	printf("\n");
	149
	150	if(!ok) {
	151	if(getenv("HARNESS_ACTIVE") != NULL)
	152	fputs("\n", stderr);
	153
	154	diag(" Failed %stest (%s:%s() at line %d)",
	155	todo ? "(TODO) " : "", file, func, line);
48beefc9	156	}
d23b20e9 JG	157	free(local_test_name);
	158
	159	UNLOCK;
	160
	161	/* We only care (when testing) that ok is positive, but here we
	162	specifically only want to return 1 or 0 */
	163	return ok ? 1 : 0;
48beefc9 NC	164	}
48beefc9 NC	165
d23b20e9 JG	166	/*
	167	* Initialise the TAP library. Will only do so once, however many times it's
	168	* called.
	169	*/
	170	void
	171	_tap_init(void)
48beefc9	172	{
d23b20e9	173	static int run_once = 0;
48beefc9	174
d23b20e9 JG	175	if(!run_once) {
d23b20e9 JG	176	atexit(_cleanup);
48beefc9	177
d23b20e9 JG	178	/* stdout needs to be unbuffered so that the output appears
	179	in the same place relative to stderr output as it does
	180	with Test::Harness */
	181	setbuf(stdout, 0);
	182	run_once = 1;
48beefc9	183	}
d23b20e9	184	}
48beefc9	185
d23b20e9 JG	186	/*
	187	* Note that there's no plan.
	188	*/
	189	int
	190	plan_no_plan(void)
	191	{
ee103ff3	192
d23b20e9	193	LOCK;
48beefc9	194
d23b20e9	195	_tap_init();
48beefc9	196
d23b20e9 JG	197	if(have_plan != 0) {
	198	fprintf(stderr, "You tried to plan twice!\n");
	199	test_died = 1;
	200	UNLOCK;
	201	exit(255);
48beefc9 NC	202	}
48beefc9 NC	203
d23b20e9 JG	204	have_plan = 1;
d23b20e9 JG	205	no_plan = 1;
48beefc9	206
d23b20e9	207	UNLOCK;
48beefc9	208
d23b20e9 JG	209	return 1;
d23b20e9 JG	210	}
48beefc9	211
d23b20e9 JG	212	/*
	213	* Note that the plan is to skip all tests
	214	*/
	215	int
	216	plan_skip_all(char *reason)
	217	{
	218
	219	LOCK;
	220
	221	_tap_init();
	222
	223	skip_all = 1;
	224
	225	printf("1..0");
	226
	227	if(reason != NULL)
	228	printf(" # Skip %s", reason);
	229
	230	printf("\n");
	231
	232	UNLOCK;
	233
	234	exit(0);
	235	}
	236
	237	/*
	238	* Note the number of tests that will be run.
	239	*/
	240	int
	241	plan_tests(unsigned int tests)
	242	{
	243
	244	LOCK;
48beefc9	245
d23b20e9 JG	246	_tap_init();
	247
	248	if(have_plan != 0) {
	249	fprintf(stderr, "You tried to plan twice!\n");
	250	test_died = 1;
	251	UNLOCK;
	252	exit(255);
48beefc9 NC	253	}
48beefc9 NC	254
d23b20e9 JG	255	if(tests == 0) {
	256	fprintf(stderr, "You said to run 0 tests! You've got to run something.\n");
	257	test_died = 1;
	258	UNLOCK;
	259	exit(255);
48beefc9 NC	260	}
48beefc9 NC	261
d23b20e9 JG	262	have_plan = 1;
	263
	264	_expected_tests(tests);
	265
	266	UNLOCK;
	267
	268	return e_tests;
	269	}
	270
	271	unsigned int
	272	diag(char *fmt, ...)
	273	{
	274	va_list ap;
	275
	276	fputs("# ", stderr);
	277
	278	va_start(ap, fmt);
	279	vfprintf(stderr, fmt, ap);
	280	va_end(ap);
ee103ff3	281
d23b20e9	282	fputs("\n", stderr);
48beefc9	283
d23b20e9 JG	284	return 0;
	285	}
	286
	287	void
	288	_expected_tests(unsigned int tests)
	289	{
48beefc9	290
d23b20e9 JG	291	printf("1..%d\n", tests);
	292	e_tests = tests;
	293	}
	294
	295	int
	296	skip(unsigned int n, char *fmt, ...)
	297	{
	298	va_list ap;
bbd25c0d	299	char *skip_msg = NULL;
d23b20e9 JG	300
	301	LOCK;
	302
	303	va_start(ap, fmt);
980818a3 JG	304	if (asprintf(&skip_msg, fmt, ap) == -1) {
	305	skip_msg = NULL;
	306	}
d23b20e9 JG	307	va_end(ap);
	308
	309	while(n-- > 0) {
	310	test_count++;
	311	printf("ok %d # skip %s\n", test_count,
	312	skip_msg != NULL ?
	313	skip_msg : "libtap():malloc() failed");
	314	}
	315
	316	free(skip_msg);
	317
	318	UNLOCK;
	319
	320	return 1;
	321	}
48beefc9	322
d23b20e9 JG	323	void
	324	todo_start(char *fmt, ...)
	325	{
	326	va_list ap;
48beefc9	327
d23b20e9	328	LOCK;
48beefc9	329
d23b20e9	330	va_start(ap, fmt);
980818a3 JG	331	if (vasprintf(&todo_msg, fmt, ap) == -1) {
	332	todo_msg = NULL;
	333	}
d23b20e9	334	va_end(ap);
48beefc9	335
d23b20e9	336	todo = 1;
48beefc9	337
d23b20e9	338	UNLOCK;
48beefc9 NC	339	}
48beefc9 NC	340
d23b20e9 JG	341	void
d23b20e9 JG	342	todo_end(void)
48beefc9	343	{
48beefc9	344
d23b20e9	345	LOCK;
48beefc9	346
d23b20e9 JG	347	todo = 0;
d23b20e9 JG	348	free(todo_msg);
48beefc9	349
d23b20e9	350	UNLOCK;
48beefc9 NC	351	}
48beefc9 NC	352
d23b20e9 JG	353	int
d23b20e9 JG	354	exit_status(void)
48beefc9	355	{
d23b20e9 JG	356	int r;
	357
	358	LOCK;
	359
	360	/* If there's no plan, just return the number of failures */
	361	if(no_plan \|\| !have_plan) {
	362	UNLOCK;
	363	return failures;
48beefc9	364	}
d23b20e9 JG	365
	366	/* Ran too many tests? Return the number of tests that were run
	367	that shouldn't have been */
	368	if(e_tests < test_count) {
	369	r = test_count - e_tests;
	370	UNLOCK;
	371	return r;
	372	}
	373
	374	/* Return the number of tests that failed + the number of tests
	375	that weren't run */
	376	r = failures + e_tests - test_count;
	377	UNLOCK;
	378
	379	return r;
48beefc9 NC	380	}
48beefc9 NC	381
d23b20e9 JG	382	/*
	383	* Cleanup at the end of the run, produce any final output that might be
	384	* required.
	385	*/
	386	void
	387	_cleanup(void)
48beefc9	388	{
48beefc9	389
d23b20e9 JG	390	LOCK;
	391
	392	/* If plan_no_plan() wasn't called, and we don't have a plan,
	393	and we're not skipping everything, then something happened
	394	before we could produce any output */
	395	if(!no_plan && !have_plan && !skip_all) {
	396	diag("Looks like your test died before it could output anything.");
	397	UNLOCK;
	398	return;
	399	}
	400
	401	if(test_died) {
	402	diag("Looks like your test died just after %d.", test_count);
	403	UNLOCK;
	404	return;
	405	}
	406
	407
	408	/* No plan provided, but now we know how many tests were run, and can
	409	print the header at the end */
	410	if(!skip_all && (no_plan \|\| !have_plan)) {
	411	printf("1..%d\n", test_count);
	412	}
	413
	414	if((have_plan && !no_plan) && e_tests < test_count) {
	415	diag("Looks like you planned %d %s but ran %d extra.",
	416	e_tests, e_tests == 1 ? "test" : "tests", test_count - e_tests);
	417	UNLOCK;
	418	return;
	419	}
	420
	421	if((have_plan \|\| !no_plan) && e_tests > test_count) {
	422	diag("Looks like you planned %d %s but only ran %d.",
	423	e_tests, e_tests == 1 ? "test" : "tests", test_count);
	424	UNLOCK;
	425	return;
	426	}
48beefc9	427
d23b20e9 JG	428	if(failures)
	429	diag("Looks like you failed %d %s of %d.",
	430	failures, failures == 1 ? "test" : "tests", test_count);
48beefc9	431
d23b20e9	432	UNLOCK;
48beefc9	433	}