[argpar.git] / tests / tap / tap.c

/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (C) 2004 Nik Clayton
 * Copyright (C) 2017 Jérémie Galarneau
 */

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <assert.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 const 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 __attribute__((unused))) {
       return;
}

static inline
void funlockfile(FILE * filehandle __attribute__((unused))) {
       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, const char *file, unsigned int line,
	    const 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((unsigned char) *c) && !isspace((unsigned char) *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(const 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(const char *fmt, ...)
{
	va_list ap;

	fputs("# ", stderr);

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

	fputs("\n", stderr);

	return 0;
}

void
diag_multiline(const char *val)
{
	size_t len, i, line_start_idx = 0;

	assert(val);
	len = strlen(val);

	for (i = 0; i < len; i++) {
		int line_length;

		if (val[i] != '\n') {
			continue;
		}

		assert((i - line_start_idx + 1) <= INT_MAX);
		line_length = i - line_start_idx + 1;
		fprintf(stderr, "# %.*s", line_length, &val[line_start_idx]);
		line_start_idx = i + 1;
	}
}

void
_expected_tests(unsigned int tests)
{

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

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

	LOCK;

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