[babeltrace.git] / tests / utils / tap / 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.
 */

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

#ifdef __MINGW32__
static inline
void flockfile (FILE * filehandle) {
       return;
}

static inline
void funlockfile(FILE * filehandle) {
       return;
}
#endif

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