/*

 * Copyright (c) 2013-2017, Intel Corporation

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 *  * Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *  * 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.

 *  * Neither the name of Intel Corporation nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.

 */

#ifndef PTUNIT_H

#define PTUNIT_H

#include <stdint.h>

#include <string.h>

#ifdef __cplusplus

extern "C" {

#endif

/* A source location for reporting unit test fails. */

struct ptunit_srcloc {

	/* The source file. */

	const char *file;

	/* The source line. */

	uint32_t line;

};

/* A unit test result type.

 *

 * This distinguishes the various potential results of a unit test.

 */

enum ptunit_result_type {

	/* The test has passed. */

	ptur_passed,

	/* The test has been skipped. */

	ptur_skipped,

	/* The test failed a signed/unsigned integer comparison. */

	ptur_failed_signed_int,

	ptur_failed_unsigned_int,

	/* The test failed a pointer comparison. */

	ptur_failed_pointer,

	/* The test failed a string comparison. */

	ptur_failed_str

};

/* A unit test result.

 *

 * We separate test execution and result reporting. A unit test function

 * returns a structured result that can later be used for reporting.

 */

struct ptunit_failed_signed_int {

	/* The expression that failed. */

	const char *expr;

	/* A string representation of the comparison operation. */

	const char *cmp;

	/* The expected value. */

	int64_t expected;

	/* The actual value. */

	int64_t actual;

};

struct ptunit_failed_unsigned_int {

	/* The expression that failed. */

	const char *expr;

	/* A string representation of the comparison operation. */

	const char *cmp;

	/* The expected value. */

	uint64_t expected;

	/* The actual value. */

	uint64_t actual;

};

struct ptunit_failed_pointer {

	/* The expression that failed. */

	const char *expr;

	/* A string representation of the comparison operation. */

	const char *cmp;

	/* The expected value. */

	const void *expected;

	/* The actual value. */

	const void *actual;

};

struct ptunit_failed_str {

	/* The expression that failed. */

	const char *expr;

	/* A string representation of the comparison operation. */

	const char *cmp;

	/* The expected value. */

	char *expected;

	/* The actual value. */

	char *actual;

};

struct ptunit_result {

	/* The test result type. */

	enum ptunit_result_type type;

	/* Test result details depending on the result type. */

	struct {

		/* The source location of the fail. */

		struct ptunit_srcloc where;

		union {

			struct ptunit_failed_signed_int signed_int;

			struct ptunit_failed_unsigned_int unsigned_int;

			struct ptunit_failed_pointer pointer;

			struct ptunit_failed_str str;

		} variant;

	} failed;

};

/* A unit test function. */

typedef struct ptunit_result (*ptunit_tfun_t)(void);

/* A unit test.

 *

 * This is used for logging and reporting.

 *

 * It is not used for running tests or even for storing tests to be run at a

 * later time.

 */

struct ptunit_test {

	/* The test name. */

	const char *name;

	/* The optional test arguments. */

	const char *args;

	/* The test result. */

	struct ptunit_result result;

};

/* A unit test suite.

 *

 * This is a simple summary of all tests that have been run.

 */

struct ptunit_suite {

	/* An optional suite name. */

	const char *name;

	/* The number of total tests. */

	uint32_t nr_tests;

	/* The number of tests that have been skipped. */

	uint32_t nr_skips;

	/* The number of tests that have failed. */

	uint32_t nr_fails;

};

/* Create a unit test source location. */

extern struct ptunit_srcloc ptunit_mk_srcloc(const char *file, uint32_t line);

#define ptu_here() ptunit_mk_srcloc(__FILE__, __LINE__)

/* Create unit test passed and not run results. */

extern struct ptunit_result ptunit_mk_passed(void);

extern struct ptunit_result ptunit_mk_skipped(void);

/* Create a unit test failed signed int result. */

extern struct ptunit_result ptunit_mk_failed_signed_int(const char *expr,

							const char *cmp,

							struct ptunit_srcloc,

							int64_t actual,

							int64_t expected);

#define ptunit_int_cmp(A, E, C)						\

	do {								\

		int64_t a = (A), e = (E);				\

									\

		if (!(a C e))						\

			return ptunit_mk_failed_signed_int(#A #C #E, #C, \

							   ptu_here(),	\

							   a, e);	\

	} while (0)

/* Create a unit test failed unsigned int result. */

extern struct ptunit_result ptunit_mk_failed_unsigned_int(const char *expr,

							  const char *cmp,

							  struct ptunit_srcloc,

							  int64_t actual,

							  int64_t expected);

#define ptunit_uint_cmp(A, E, C)					\

	do {								\

		uint64_t a = (A), e = (E);				\

									\

		if (!(a C e))						\

			return ptunit_mk_failed_unsigned_int(#A #C #E, #C, \

							     ptu_here(), \

							     a, e);	\

	} while (0)

/* Create a unit test failed pointer result. */

extern struct ptunit_result ptunit_mk_failed_pointer(const char *expr,

						     const char *cmp,

						     struct ptunit_srcloc,

						     const void *actual,

						     const void *expected);

#define ptunit_ptr_cmp(A, E, C)						\

	do {								\

		const void *a = (A), *e = (E);				\

									\

		if (!(a C e))						\

			return ptunit_mk_failed_pointer(#A #C #E, #C,	\

							ptu_here(),	\

							a, e);		\

	} while (0)

/* Create a unit test failed string result. */

extern struct ptunit_result ptunit_mk_failed_str(const char *expr,

						 const char *cmp,

						 struct ptunit_srcloc,

						 const char *actual,

						 const char *expected);

#define ptunit_str_cmp(A, E, C)						\

	do {								\

		const char *a = (A), *e = (E);				\

									\

		if (!a || !e || !(strcmp(a, e) C 0))			\

			return ptunit_mk_failed_str(#A "~"#C #E, "~"#C,	\

						    ptu_here(),		\

						    a, e);		\

	} while (0)

/* Run a sub-unit test; return on fail. */

#define ptunit_subtest(T, ...)				\

	do {						\

		struct ptunit_result result;		\

							\

		result = (T)(__VA_ARGS__);		\

		if (result.type != ptur_passed)		\

			return result;			\

	} while (0)

/* Run a sub-unit test; return on fail from here. */

#define ptunit_check(T, ...)					\

	do {							\

		struct ptunit_result result;			\

								\

		result = (T)(__VA_ARGS__);			\

		if (result.type != ptur_passed) {		\

			result.failed.where = ptu_here();	\

			return result;				\

		}						\

	} while (0)

/* Create a unit test. */

extern struct ptunit_test ptunit_mk_test(const char *name, const char *args);

/* Destroy a unit test. */

extern void ptunit_fini_test(struct ptunit_test *);

/* Create a unit test suite. */

extern struct ptunit_suite ptunit_mk_suite(int argc, char **argv);

/* Log a unit test result.

 *

 * This may also report test fails depending on the configuration.

 */

extern void ptunit_log_test(struct ptunit_suite *, const struct ptunit_test *);

/* Print a summary report for a unit test suite. */

extern void ptunit_report(const struct ptunit_suite *);

/* Run a single simple unit test and log its result. */

#define ptunit_run(S, T)				\

	do {						\

		struct ptunit_test test;		\

							\

		test = ptunit_mk_test(#T, NULL);	\

		test.result = (T)();			\

							\

		ptunit_log_test(S, &test);		\

		ptunit_fini_test(&test);		\

	} while (0)

/* Run a single parameterized unit test and log its result. */

#define ptunit_run_p(S, T, ...)					\

	do {							\

		struct ptunit_test test;			\

								\

		test = ptunit_mk_test(#T, #__VA_ARGS__);	\

		test.result = (T)(__VA_ARGS__);			\

								\

		ptunit_log_test(S, &test);			\

		ptunit_fini_test(&test);			\

	} while (0)

/* Run a single unit test with fixture and an explict argument list.

 *

 * The first argument in the argument list is typically the fixture.

 */

#define ptunit_frun(R, T, F, ...)				\

	do {							\

		struct ptunit_result *pr = &(R);		\

								\

		pr->type = ptur_passed;				\

		if ((F)->init)					\

			*pr = (F)->init(F);			\

								\

		if (pr->type == ptur_passed) {			\

			*pr = (T)(__VA_ARGS__);			\

								\

			if ((F)->fini) {			\

				if (pr->type == ptur_passed)	\

					*pr = (F)->fini(F);	\

				else				\

					(void) (F)->fini(F);	\

			}					\

		}						\

	} while (0)

/* Run a single unit test with fixture and log its result. */

#define ptunit_run_f(S, T, F)					\

	do {							\

		struct ptunit_test test;			\

								\

		test = ptunit_mk_test(#T, #F);			\

								\

		ptunit_frun(test.result, T, &(F), &(F));	\

								\

		ptunit_log_test(S, &test);			\

		ptunit_fini_test(&test);			\

	} while (0)

/* Run a single parameterized unit test with fixture and log its result. */

#define ptunit_run_fp(S, T, F, ...)					\

	do {								\

		struct ptunit_test test;				\

									\

		test = ptunit_mk_test(#T, #F ", " #__VA_ARGS__);	\

									\

		ptunit_frun(test.result, T, &(F), &(F), __VA_ARGS__);	\

									\

		ptunit_log_test(S, &test);				\

		ptunit_fini_test(&test);				\

	} while (0)

/* The actual macros to be used in unit tests.

 *

 * Do not use the above ptunit_ macros directly.

 */

#define ptu_int_eq(A, E) ptunit_int_cmp(A, E, ==)

#define ptu_int_ne(A, E) ptunit_int_cmp(A, E, !=)

#define ptu_int_gt(A, E) ptunit_int_cmp(A, E, >)

#define ptu_int_ge(A, E) ptunit_int_cmp(A, E, >=)

#define ptu_int_lt(A, E) ptunit_int_cmp(A, E, <)

#define ptu_int_le(A, E) ptunit_int_cmp(A, E, <=)

#define ptu_uint_eq(A, E) ptunit_uint_cmp(A, E, ==)

#define ptu_uint_ne(A, E) ptunit_uint_cmp(A, E, !=)

#define ptu_uint_gt(A, E) ptunit_uint_cmp(A, E, >)

#define ptu_uint_ge(A, E) ptunit_uint_cmp(A, E, >=)

#define ptu_uint_lt(A, E) ptunit_uint_cmp(A, E, <)

#define ptu_uint_le(A, E) ptunit_uint_cmp(A, E, <=)

#define ptu_ptr_eq(A, E) ptunit_ptr_cmp(A, E, ==)

#define ptu_ptr_ne(A, E) ptunit_ptr_cmp(A, E, !=)

#define ptu_ptr_gt(A, E) ptunit_ptr_cmp(A, E, >)

#define ptu_ptr_ge(A, E) ptunit_ptr_cmp(A, E, >=)

#define ptu_ptr_lt(A, E) ptunit_ptr_cmp(A, E, <)

#define ptu_ptr_le(A, E) ptunit_ptr_cmp(A, E, <=)

#define ptu_null(A) ptunit_ptr_cmp(A, NULL, ==)

#define ptu_ptr(A) ptunit_ptr_cmp(A, NULL, !=)

#define ptu_str_eq(A, E) ptunit_str_cmp(A, E, ==)

#define ptu_str_ne(A, E) ptunit_str_cmp(A, E, !=)

/* Indicate that a unit test passed. */

#define ptu_passed() ptunit_mk_passed()

/* Skip a unit test. */

#define ptu_skipped() ptunit_mk_skipped()

/* Run a sub-unit test; return on fail. */

#define ptu_test(T, ...) ptunit_subtest(T, __VA_ARGS__)

/* Run a sub-unit test; return on fail from here. */

#define ptu_check(T, ...) ptunit_check(T, __VA_ARGS__)

/* Run a single unit test. */

#define ptu_run(S, T) ptunit_run(&(S), T)

/* Run a single parameterized unit test. */

#define ptu_run_p(S, T, ...) ptunit_run_p(&(S), T, __VA_ARGS__)

/* Run a single unit test with fixture. */

#define ptu_run_f(S, T, F) ptunit_run_f(&(S), T, F)

/* Run a single parameterized unit test with fixture. */

#define ptu_run_fp(S, T, F, ...) ptunit_run_fp(&(S), T, F, __VA_ARGS__)

#ifdef __cplusplus

}

#endif

#endif /* PTUNIT_H */