[urcu.git] / tests / utils / 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;
static int tap_is_disabled = 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;
}

unsigned int
rdiag_start(void)
{
	fputs("# ", stderr);
	return 0;
}

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

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

	return 0;
}

unsigned int
rdiag_end(void)
{
	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 (tap_is_disabled) {
		UNLOCK;
		return;
	}

	/* 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;
}

/* Disable tap for this process. */
void
tap_disable(void)
{
	LOCK;
	tap_is_disabled = 1;
	UNLOCK;
}
Commit	Line	Data
1b387491 MJ	1	/*-
	2	* Copyright (c) 2004 Nik Clayton
	3	* All rights reserved.
	4	*
	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.
	13	*
	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.
	25	*/
	26
	27	#define _GNU_SOURCE
	28	#include <ctype.h>
	29	#include <stdarg.h>
	30	#include <stdio.h>
	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;
ad460058	45	static int tap_is_disabled = 0;
1b387491 MJ	46
	47	/* Encapsulate the pthread code in a conditional. In the absence of
	48	libpthread the code does nothing */
	49	#ifdef HAVE_LIBPTHREAD
	50	#include <pthread.h>
	51	static pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
	52	# define LOCK pthread_mutex_lock(&M);
	53	# define UNLOCK pthread_mutex_unlock(&M);
	54	#else
	55	# define LOCK
	56	# define UNLOCK
	57	#endif
	58
	59	static void _expected_tests(unsigned int);
	60	static void _tap_init(void);
	61	static void _cleanup(void);
	62
	63	/*
	64	* Generate a test result.
	65	*
	66	* ok -- boolean, indicates whether or not the test passed.
	67	* test_name -- the name of the test, may be NULL
	68	* test_comment -- a comment to print afterwards, may be NULL
	69	*/
	70	unsigned int
	71	_gen_result(int ok, const char func, char file, unsigned int line,
	72	char *test_name, ...)
	73	{
	74	va_list ap;
	75	char *local_test_name = NULL;
	76	char *c;
	77	int name_is_digits;
	78
	79	LOCK;
	80
	81	test_count++;
	82
	83	/* Start by taking the test name and performing any printf()
	84	expansions on it */
	85	if(test_name != NULL) {
	86	va_start(ap, test_name);
	87	if (vasprintf(&local_test_name, test_name, ap) == -1) {
	88	local_test_name = NULL;
	89	}
	90	va_end(ap);
	91
	92	/* Make sure the test name contains more than digits
	93	and spaces. Emit an error message and exit if it
	94	does */
	95	if(local_test_name) {
	96	name_is_digits = 1;
	97	for(c = local_test_name; *c != '\0'; c++) {
	98	if(!isdigit(c) && !isspace(c)) {
	99	name_is_digits = 0;
	100	break;
	101	}
	102	}
	103
	104	if(name_is_digits) {
	105	diag(" You named your test '%s'. You shouldn't use numbers for your test names.", local_test_name);
	106	diag(" Very confusing.");
	107	}
	108	}
	109	}
110
111	if(!ok) {
112	printf("not ");
113	failures++;
114	}
115
116	printf("ok %d", test_count);
117
118	if(test_name != NULL) {
119	printf(" - ");
120
121	/* Print the test name, escaping any '#' characters it
122	might contain */
123	if(local_test_name != NULL) {
124	flockfile(stdout);
125	for(c = local_test_name; *c != '\0'; c++) {
126	if(*c == '#')
127	fputc('\\', stdout);
128	fputc((int)*c, stdout);
129	}
130	funlockfile(stdout);
131	} else { /* vasprintf() failed, use a fixed message */
132	printf("%s", todo_msg_fixed);
133	}
134	}
135
136	/* If we're in a todo_start() block then flag the test as being
137	TODO. todo_msg should contain the message to print at this
138	point. If it's NULL then asprintf() failed, and we should
139	use the fixed message.
140
141	This is not counted as a failure, so decrement the counter if
142	the test failed. */
143	if(todo) {
144	printf(" # TODO %s", todo_msg ? todo_msg : todo_msg_fixed);
145	if(!ok)
146	failures--;
147	}
148
149	printf("\n");
150
151	if(!ok) {
152	if(getenv("HARNESS_ACTIVE") != NULL)
153	fputs("\n", stderr);
154
155	diag(" Failed %stest (%s:%s() at line %d)",
156	todo ? "(TODO) " : "", file, func, line);
157	}
158	free(local_test_name);
159
160	UNLOCK;
161
162	/* We only care (when testing) that ok is positive, but here we
163	specifically only want to return 1 or 0 */
164	return ok ? 1 : 0;
165	}
166
167	/*
168	* Initialise the TAP library. Will only do so once, however many times it's
169	* called.
170	*/
171	void
172	_tap_init(void)
173	{
174	static int run_once = 0;
175
176	if(!run_once) {
177	atexit(_cleanup);
178
179	/* stdout needs to be unbuffered so that the output appears
180	in the same place relative to stderr output as it does
181	with Test::Harness */
182	setbuf(stdout, 0);
183	run_once = 1;
184	}
185	}
186
187	/*
188	* Note that there's no plan.
189	*/
190	int
191	plan_no_plan(void)
192	{
193
194	LOCK;
195
196	_tap_init();
197
198	if(have_plan != 0) {
199	fprintf(stderr, "You tried to plan twice!\n");
200	test_died = 1;
201	UNLOCK;
202	exit(255);
203	}
204
205	have_plan = 1;
206	no_plan = 1;
207
208	UNLOCK;
209
210	return 1;
211	}
212
213	/*
214	* Note that the plan is to skip all tests
215	*/
216	int
217	plan_skip_all(char *reason)
218	{
219
220	LOCK;
221
222	_tap_init();
223
224	skip_all = 1;
225
226	printf("1..0");
227
228	if(reason != NULL)
229	printf(" # Skip %s", reason);
230
231	printf("\n");
232
233	UNLOCK;
234
235	exit(0);
236	}
237
238	/*
239	* Note the number of tests that will be run.
240	*/
241	int
242	plan_tests(unsigned int tests)
243	{
244
245	LOCK;
246
247	_tap_init();
248
249	if(have_plan != 0) {
250	fprintf(stderr, "You tried to plan twice!\n");
251	test_died = 1;
252	UNLOCK;
253	exit(255);
254	}
255
256	if(tests == 0) {
257	fprintf(stderr, "You said to run 0 tests! You've got to run something.\n");
258	test_died = 1;
259	UNLOCK;
260	exit(255);
261	}
262
263	have_plan = 1;
264
265	_expected_tests(tests);
266
267	UNLOCK;
268
269	return e_tests;
270	}
271
272	unsigned int
273	diag(char *fmt, ...)
274	{
275	va_list ap;
276
277	fputs("# ", stderr);
278
279	va_start(ap, fmt);
280	vfprintf(stderr, fmt, ap);
281	va_end(ap);
282
283	fputs("\n", stderr);
284
285	return 0;
286	}
287
ad460058 MD	288	unsigned int
	289	rdiag_start(void)
	290	{
	291	fputs("# ", stderr);
	292	return 0;
	293	}
	294
	295	unsigned int
	296	rdiag(char *fmt, ...)
	297	{
	298	va_list ap;
	299
	300	va_start(ap, fmt);
	301	vfprintf(stderr, fmt, ap);
	302	va_end(ap);
	303
	304	return 0;
	305	}
	306
	307	unsigned int
	308	rdiag_end(void)
	309	{
	310	fputs("\n", stderr);
	311	return 0;
	312	}
	313
1b387491 MJ	314	void
	315	_expected_tests(unsigned int tests)
	316	{
	317
	318	printf("1..%d\n", tests);
	319	e_tests = tests;
	320	}
	321
	322	int
	323	skip(unsigned int n, char *fmt, ...)
	324	{
	325	va_list ap;
	326	char *skip_msg = NULL;
	327
	328	LOCK;
	329
	330	va_start(ap, fmt);
	331	if (asprintf(&skip_msg, fmt, ap) == -1) {
	332	skip_msg = NULL;
	333	}
	334	va_end(ap);
	335
	336	while(n-- > 0) {
	337	test_count++;
	338	printf("ok %d # skip %s\n", test_count,
	339	skip_msg != NULL ?
	340	skip_msg : "libtap():malloc() failed");
	341	}
	342
	343	free(skip_msg);
	344
	345	UNLOCK;
	346
	347	return 1;
	348	}
	349
	350	void
	351	todo_start(char *fmt, ...)
	352	{
	353	va_list ap;
	354
	355	LOCK;
	356
	357	va_start(ap, fmt);
	358	if (vasprintf(&todo_msg, fmt, ap) == -1) {
	359	todo_msg = NULL;
	360	}
	361	va_end(ap);
	362
	363	todo = 1;
	364
	365	UNLOCK;
	366	}
	367
	368	void
	369	todo_end(void)
	370	{
	371
	372	LOCK;
	373
	374	todo = 0;
	375	free(todo_msg);
	376
	377	UNLOCK;
378	}
379
380	int
381	exit_status(void)
382	{
383	int r;
384
385	LOCK;
386
387	/* If there's no plan, just return the number of failures */
388	if(no_plan \|\| !have_plan) {
389	UNLOCK;
390	return failures;
391	}
392
393	/* Ran too many tests? Return the number of tests that were run
394	that shouldn't have been */
395	if(e_tests < test_count) {
396	r = test_count - e_tests;
397	UNLOCK;
398	return r;
399	}
400
401	/* Return the number of tests that failed + the number of tests
402	that weren't run */
403	r = failures + e_tests - test_count;
404	UNLOCK;
405
406	return r;
407	}
408
409	/*
410	* Cleanup at the end of the run, produce any final output that might be
411	* required.
412	*/
413	void
414	_cleanup(void)
415	{
416
417	LOCK;
418
ad460058 MD	419	if (tap_is_disabled) {
	420	UNLOCK;
	421	return;
	422	}
	423
1b387491 MJ	424	/* If plan_no_plan() wasn't called, and we don't have a plan,
	425	and we're not skipping everything, then something happened
	426	before we could produce any output */
	427	if(!no_plan && !have_plan && !skip_all) {
	428	diag("Looks like your test died before it could output anything.");
	429	UNLOCK;
	430	return;
	431	}
	432
	433	if(test_died) {
	434	diag("Looks like your test died just after %d.", test_count);
	435	UNLOCK;
	436	return;
	437	}
	438
	439
	440	/* No plan provided, but now we know how many tests were run, and can
	441	print the header at the end */
	442	if(!skip_all && (no_plan \|\| !have_plan)) {
	443	printf("1..%d\n", test_count);
	444	}
	445
	446	if((have_plan && !no_plan) && e_tests < test_count) {
	447	diag("Looks like you planned %d %s but ran %d extra.",
	448	e_tests, e_tests == 1 ? "test" : "tests", test_count - e_tests);
	449	UNLOCK;
	450	return;
	451	}
	452
	453	if((have_plan \|\| !no_plan) && e_tests > test_count) {
	454	diag("Looks like you planned %d %s but only ran %d.",
	455	e_tests, e_tests == 1 ? "test" : "tests", test_count);
	456	UNLOCK;
	457	return;
	458	}
	459
	460	if(failures)
	461	diag("Looks like you failed %d %s of %d.",
	462	failures, failures == 1 ? "test" : "tests", test_count);
	463
	464	UNLOCK;
	465	}
ad460058 MD	466
	467	/* Disable tap for this process. */
	468	void
	469	tap_disable(void)
	470	{
	471	LOCK;
	472	tap_is_disabled = 1;
	473	UNLOCK;
	474	}