libsel4test/include/sel4test/test.h - 3p/sel4/sel4_libs - Git at Google

 /*
  * Copyright 2017, Data61
  * Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  * ABN 41 687 119 230.
  *
  * This software may be distributed and modified according to the terms of
  * the BSD 2-Clause license. Note that NO WARRANTY is provided.
  * See "LICENSE_BSD2.txt" for details.
  *
  * @TAG(DATA61_BSD)
  */

 #pragma once

 /* Include Kconfig variables. */
 #include <autoconf.h>
 #include <sel4test/gen_config.h>

 #include <sel4/sel4.h>

 #include <utils/attribute.h>
 #include <sel4test/testutil.h>
 #include <vka/vka.h>
 #include <vspace/vspace.h>
 #include <sel4platsupport/timer.h>
 #include <sync/mutex.h>
 #include <sel4utils/elf.h>
 #include <sel4rpc/client.h>

 #include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>

 /* max test name size */
 #define TEST_NAME_MAX (64 - 4 * sizeof(seL4_Word))

 #define MAX_REGIONS 4

 /* Contains information about the test environment for regular tests, bootstrap tests do
  * not use this environment */
 struct env {
     /* An initialised vka that may be used by the test. */
     vka_t vka;
     /* virtual memory management interface */
     vspace_t vspace;
     /* abstract interface over application init */
     simple_t simple;
     /* notification for timer */
     vka_object_t timer_notification;
     /* RPC client for serial server resource allocation */
     sel4rpc_client_t rpc_client;

     /* caps for the current process */
     seL4_CPtr cspace_root;
     seL4_CPtr page_directory;
     seL4_CPtr endpoint;
     seL4_CPtr tcb;
     seL4_CPtr timer_untyped;
     seL4_CPtr asid_pool;
     seL4_CPtr asid_ctrl;
     seL4_CPtr sched_ctrl;
 #ifdef CONFIG_IOMMU
     seL4_CPtr io_space;
 #endif /* CONFIG_IOMMU */
 #ifdef CONFIG_ARM_SMMU
     seL4_SlotRegion io_space_caps;
 #endif
     seL4_Word cores;
     seL4_CPtr domain;
     seL4_CPtr device_frame;

     int priority;
     int cspace_size_bits;
     int num_regions;
     sel4utils_elf_region_t regions[MAX_REGIONS];
 };
 typedef struct env *env_t;

 /* Prototype of a test function. Returns false on failure. */
 typedef int (*test_fn)(uintptr_t environment);

 /* Test type definitions. */
 typedef enum test_type_name {BOOTSTRAP = 0, BASIC} test_type_name_t;
 typedef struct testcase testcase_t; // Forward type declaration.
 typedef struct test_type {
     /* Represents a single test type. See comment for `struct testcase` for info about ALIGN(32). */
     const char *name;
     test_type_name_t id;
     // Function called before and after all the tests for this test type have been run.
     void (*set_up_test_type)(uintptr_t e);
     void (*tear_down_test_type)(uintptr_t e);
     // Function called before and after each test for this test type.
     void (*set_up)(uintptr_t e);
     void (*tear_down)(uintptr_t e);
     // Run the test. Different tests take different environments
     test_result_t (*run_test)(struct testcase *test, uintptr_t e);
 } ALIGN(32) test_type_t;

 /* Declare a test type.
  * For now, we put the test types in a separate elf section. */
 #define DEFINE_TEST_TYPE(_name, _id, _set_up_test_type, _tear_down_test_type, _set_up, _tear_down, _run_test) \
     __attribute__((used)) __attribute__((section("_test_type"))) struct test_type TEST_TYPE_ ##_name = { \
     .name = #_name, \
     .id = _id, \
     .set_up_test_type = _set_up_test_type, \
     .tear_down_test_type = _tear_down_test_type, \
     .set_up = _set_up, \
     .tear_down = _tear_down, \
     .run_test = _run_test, \
 };

 /* Represents a single testcase.
  * Because this struct is used to declare variables that get
  * placed into custom sections, that we later treat as an array,
  * we need to make sure the struct is aligned and filled to the
  * nearest power of two to avoid gcc placing arbitrary padding between them.
  *
  * The declaration below ensures that the actual size of
  * the objects in the section is the same as the size reported
  * by sizeof(struct testcase), allowing as to treat the items
  * in the section as an array */
 struct testcase {
     char name[TEST_NAME_MAX];
     const char *description;
     test_fn function;
     seL4_Word test_type;
     seL4_Word enabled;
 } PACKED;
 typedef struct testcase ALIGN(sizeof(struct testcase)) testcase_t;

 /* Declare a testcase.
  * Must be declared using C89 style (#_name, _desc, _func...) instead of
  * C99 style (name = _name, desc = _desc, func = _func...) to make sure
  * that it is accepted by C++ compilers.
  */
 #define DEFINE_TEST_WITH_TYPE(_name, _description, _function, _test_type, _enabled) \
     __attribute__((used)) __attribute__((section("_test_case"))) struct testcase TEST_ ## _name = { \
     #_name, \
     _description, \
     (test_fn)_function, \
     _test_type, \
     _enabled, \
 };

 #define DEFINE_TEST(_name, _description, _function, _enabled) DEFINE_TEST_WITH_TYPE(_name, _description, _function, BASIC, _enabled)

 #define DEFINE_TEST_BOOTSTRAP(_name, _description, _function, _enabled) DEFINE_TEST_WITH_TYPE(_name, _description, _function, BOOTSTRAP, _enabled)
 /**/

 /* Definitions so that we can find the test types */
 extern struct test_type __start__test_type[];
 extern struct test_type __stop__test_type[];

 /* Definitions so that we can find the test cases */
 extern testcase_t __start__test_case[];
 extern testcase_t __stop__test_case[];

 static inline int test_type_comparator(const void *a, const void *b)
 {
     const struct test_type **ta = (const struct test_type **) a;
     const struct test_type **tb = (const struct test_type **) b;
     if ((*ta)->id > (*tb)->id) {
         return 1;
     } else if ((*ta)->id < (*tb)->id) {
         return -1;
     }

     return 0;
 }

 static inline int test_comparator(const void *a, const void *b)
 {
     const struct testcase **ta = (const struct testcase **)a;
     const struct testcase **tb = (const struct testcase **)b;
     return strcmp((*ta)->name, (*tb)->name);
 }

 /* Fails a test case, stop running the rest of the test, but keep running other tests. */
 static inline test_result_t _test_fail(const char *condition, const char *file, int line)
 {
     _sel4test_failure(condition, file, line);
     return FAILURE;
 }

 /* Fails a test case, keep running the rest of the test, then keep running other tests. */
 static inline void _test_error(const char *condition, const char *file, int line)
 {

     _sel4test_report_error(condition, file, line);
 }

 /* Fails a test case, stop everything. */
 static inline test_result_t _test_abort(const char *condition, const char *file, int line)
 {
     _sel4test_failure(condition, file, line);
     return ABORT;
 }

 static inline void print_error_in_ipc(seL4_Error e)
 {
 #ifdef CONFIG_KERNEL_INVOCATION_REPORT_ERROR_IPC
     // If it hasnt been printed already
     if (!seL4_CanPrintError() && e != seL4_NoError) {
         printf("%s", seL4_GetDebugError());
     }
 #endif
 }

 #define test_error_eq(e, c) \
     if (!((e) == (c))) { \
         print_error_in_ipc(e); \
         return _test_fail(#e, __FILE__, __LINE__); \
     }
 #define test_assert(e) if (!(e)) return _test_fail(#e, __FILE__, __LINE__)
 #define test_check(e) if (!(e)) _test_error(#e, __FILE__, __LINE__)
 #define test_assert_fatal(e) if (!(e)) return _test_abort(#e, __FILE__, __LINE__)

 #define __TEST_BUFFER_SIZE 200
 #define test_op_type(a, b, op, t, name_a, name_b, cast) \
     do {\
         if (!(a op b)) { \
             int len = snprintf(NULL, 0, "Check %s(" t ") %s %s(" t ") failed.",\
                                #name_a, (cast) a, #op, #name_b, (cast) b) + 1; \
             char buffer[len]; \
             snprintf(buffer, len, "Check %s(" t ") %s %s(" t ") failed.",\
                      #name_a, (cast) a, #op, #name_b, (cast) b); \
             _test_error(buffer, __FILE__, __LINE__); \
         }\
     } while (0)

 #define test_op(a, b, op) \
     do { \
          typeof (a) _a = (a); \
          typeof (b) _b = (b); \
          if (sizeof(_a) != sizeof(_b)) { \
              int len = snprintf(NULL, 0, "%s (size %zu) != %s (size %zu), use of test_eq incorrect", #a,\
                      sizeof(_a), #b, sizeof(_b)) + 1;\
              char buffer[len];\
              snprintf(buffer, len, "%s (size %zu) != %s (size %zu), use of test_eq incorrect", #a, sizeof(_a),\
                      #b, sizeof(_b));\
              _test_error(buffer, __FILE__, __LINE__);\
          } else if (TYPES_COMPATIBLE(typeof(_a), int)) {\
              test_op_type(_a, _b, op, "%d", a, b, int); \
          } else if (TYPES_COMPATIBLE(typeof(_a), long)) {\
              test_op_type(_a, _b, op, "%ld", a, b, long); \
          } else if (TYPES_COMPATIBLE(typeof(_a), long long)) {\
              test_op_type(_a, _b, op, "%lld", a, b, long long); \
          } else if (TYPES_COMPATIBLE(typeof(_a), unsigned int)) {\
              test_op_type(_a, _b, op, "%u", a, b, unsigned int); \
          } else if (TYPES_COMPATIBLE(typeof(_a), unsigned long)) {\
              test_op_type(_a, _b, op, "%lu", a, b, unsigned long); \
          } else if (TYPES_COMPATIBLE(typeof(_a), unsigned long long)) {\
              test_op_type(_a, _b, op, "%llu", a, b, unsigned long long); \
          } else if (TYPES_COMPATIBLE(typeof(_a), char)) {\
              test_op_type(_a, _b, op, "%c", a, b, char); \
          } else if (TYPES_COMPATIBLE(typeof(_a), uintptr_t)) {\
              test_op_type(_a, _b, op, "0x%" PRIxPTR, a, b, uintptr_t);\
          } else { \
              _test_error("Cannot use test_op on this type", __FILE__, __LINE__);\
          }\
     } while (0)

 /* Pretty printed test_check wrapper macros for basic comparisons on base types,
  * which output the values and variable names to aid debugging */
 #define test_eq(a, b)  test_op(a, b, ==)
 #define test_neq(a, b) test_op(a, b, !=)
 #define test_gt(a, b)  test_op(a, b, >)
 #define test_geq(a, b) test_op(a, b, >=)
 #define test_lt(a, b)  test_op(a, b, <)
 #define test_leq(a, b) test_op(a, b, <=)

 #define __TEST_MAX_STRING 50
 #define test_strop(a, b, op) \
      do {\
           if (strnlen(a, __TEST_MAX_STRING) == __TEST_MAX_STRING) {\
               _test_error("String " #a " too long for test_str* macros", __FILE__, __LINE__);\
           } else if (strnlen(b, __TEST_MAX_STRING) == __TEST_MAX_STRING) {\
               _test_error("String " #b " too long for test_str* macros", __FILE__, __LINE__);\
           } else if (!(strncmp(a, b, __TEST_MAX_STRING)) op 0) {\
               char buffer[__TEST_BUFFER_SIZE + 2 * __TEST_MAX_STRING];\
               snprintf(buffer, sizeof(buffer),\
                        "Check %s(%s) %s %s(%s) failed.", #a, a, #op, #b, b);\
               _test_error(buffer, __FILE__, __LINE__); \
           }\
     } while (0)

 /* Pretty printed test_check wrapper macros for basic comparisons on c strings,
  * which output the values and variable names to aid debugging */
 #define test_streq(a, b)  test_strop(a, b, ==)
 #define test_strneq(a, b) test_strop(a, b, !=)
 #define test_strge(a, b)  test_strop(a, b, >)
 #define test_strgeq(a, b) test_strop(a, b, >=)
 #define test_strle(a, b)  test_strop(a, b, <)
 #define test_strleq(a, b) test_strop(a, b, <=)

 env_t sel4test_get_env(void);
	/*
	* Copyright 2017, Data61
	* Commonwealth Scientific and Industrial Research Organisation (CSIRO)
	* ABN 41 687 119 230.
	*
	* This software may be distributed and modified according to the terms of
	* the BSD 2-Clause license. Note that NO WARRANTY is provided.
	* See "LICENSE_BSD2.txt" for details.
	*
	* @TAG(DATA61_BSD)
	*/

	#pragma once

	/* Include Kconfig variables. */
	#include <autoconf.h>
	#include <sel4test/gen_config.h>

	#include <sel4/sel4.h>

	#include <utils/attribute.h>
	#include <sel4test/testutil.h>
	#include <vka/vka.h>
	#include <vspace/vspace.h>
	#include <sel4platsupport/timer.h>
	#include <sync/mutex.h>
	#include <sel4utils/elf.h>
	#include <sel4rpc/client.h>

	#include <inttypes.h>
	#include <stdbool.h>
	#include <stddef.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <string.h>

	/* max test name size */
	#define TEST_NAME_MAX (64 - 4 * sizeof(seL4_Word))

	#define MAX_REGIONS 4

	/* Contains information about the test environment for regular tests, bootstrap tests do
	* not use this environment */
	struct env {
	/* An initialised vka that may be used by the test. */
	vka_t vka;
	/* virtual memory management interface */
	vspace_t vspace;
	/* abstract interface over application init */
	simple_t simple;
	/* notification for timer */
	vka_object_t timer_notification;
	/* RPC client for serial server resource allocation */
	sel4rpc_client_t rpc_client;

	/* caps for the current process */
	seL4_CPtr cspace_root;
	seL4_CPtr page_directory;
	seL4_CPtr endpoint;
	seL4_CPtr tcb;
	seL4_CPtr timer_untyped;
	seL4_CPtr asid_pool;
	seL4_CPtr asid_ctrl;
	seL4_CPtr sched_ctrl;
	#ifdef CONFIG_IOMMU
	seL4_CPtr io_space;
	#endif /* CONFIG_IOMMU */
	#ifdef CONFIG_ARM_SMMU
	seL4_SlotRegion io_space_caps;
	#endif
	seL4_Word cores;
	seL4_CPtr domain;
	seL4_CPtr device_frame;

	int priority;
	int cspace_size_bits;
	int num_regions;
	sel4utils_elf_region_t regions[MAX_REGIONS];
	};
	typedef struct env *env_t;

	/* Prototype of a test function. Returns false on failure. */
	typedef int (*test_fn)(uintptr_t environment);

	/* Test type definitions. */
	typedef enum test_type_name {BOOTSTRAP = 0, BASIC} test_type_name_t;
	typedef struct testcase testcase_t; // Forward type declaration.
	typedef struct test_type {
	/* Represents a single test type. See comment for `struct testcase` for info about ALIGN(32). */
	const char *name;
	test_type_name_t id;
	// Function called before and after all the tests for this test type have been run.
	void (*set_up_test_type)(uintptr_t e);
	void (*tear_down_test_type)(uintptr_t e);
	// Function called before and after each test for this test type.
	void (*set_up)(uintptr_t e);
	void (*tear_down)(uintptr_t e);
	// Run the test. Different tests take different environments
	test_result_t (run_test)(struct testcase test, uintptr_t e);
	} ALIGN(32) test_type_t;

	/* Declare a test type.
	* For now, we put the test types in a separate elf section. */
	#define DEFINE_TEST_TYPE(_name, _id, _set_up_test_type, _tear_down_test_type, _set_up, _tear_down, _run_test) \
	__attribute__((used)) __attribute__((section("_test_type"))) struct test_type TEST_TYPE_ ##_name = { \
	.name = #_name, \
	.id = _id, \
	.set_up_test_type = _set_up_test_type, \
	.tear_down_test_type = _tear_down_test_type, \
	.set_up = _set_up, \
	.tear_down = _tear_down, \
	.run_test = _run_test, \
	};

	/* Represents a single testcase.
	* Because this struct is used to declare variables that get
	* placed into custom sections, that we later treat as an array,
	* we need to make sure the struct is aligned and filled to the
	* nearest power of two to avoid gcc placing arbitrary padding between them.
	*
	* The declaration below ensures that the actual size of
	* the objects in the section is the same as the size reported
	* by sizeof(struct testcase), allowing as to treat the items
	* in the section as an array */
	struct testcase {
	char name[TEST_NAME_MAX];
	const char *description;
	test_fn function;
	seL4_Word test_type;
	seL4_Word enabled;
	} PACKED;
	typedef struct testcase ALIGN(sizeof(struct testcase)) testcase_t;

	/* Declare a testcase.
	* Must be declared using C89 style (#_name, _desc, _func...) instead of
	* C99 style (name = _name, desc = _desc, func = _func...) to make sure
	* that it is accepted by C++ compilers.
	*/
	#define DEFINE_TEST_WITH_TYPE(_name, _description, _function, _test_type, _enabled) \
	__attribute__((used)) __attribute__((section("_test_case"))) struct testcase TEST_ ## _name = { \
	#_name, \
	_description, \
	(test_fn)_function, \
	_test_type, \
	_enabled, \
	};

	#define DEFINE_TEST(_name, _description, _function, _enabled) DEFINE_TEST_WITH_TYPE(_name, _description, _function, BASIC, _enabled)

	#define DEFINE_TEST_BOOTSTRAP(_name, _description, _function, _enabled) DEFINE_TEST_WITH_TYPE(_name, _description, _function, BOOTSTRAP, _enabled)
	/**/

	/* Definitions so that we can find the test types */
	extern struct test_type __start__test_type[];
	extern struct test_type __stop__test_type[];

	/* Definitions so that we can find the test cases */
	extern testcase_t __start__test_case[];
	extern testcase_t __stop__test_case[];

	static inline int test_type_comparator(const void a, const void b)
	{
	const struct test_type ta = (const struct test_type ) a;
	const struct test_type tb = (const struct test_type ) b;
	if ((ta)->id > (tb)->id) {
	return 1;
	} else if ((ta)->id < (tb)->id) {
	return -1;
	}

	return 0;
	}

	static inline int test_comparator(const void a, const void b)
	{
	const struct testcase ta = (const struct testcase )a;
	const struct testcase tb = (const struct testcase )b;
	return strcmp((ta)->name, (tb)->name);
	}

	/* Fails a test case, stop running the rest of the test, but keep running other tests. */
	static inline test_result_t _test_fail(const char condition, const char file, int line)
	{
	_sel4test_failure(condition, file, line);
	return FAILURE;
	}

	/* Fails a test case, keep running the rest of the test, then keep running other tests. */
	static inline void _test_error(const char condition, const char file, int line)
	{

	_sel4test_report_error(condition, file, line);
	}

	/* Fails a test case, stop everything. */
	static inline test_result_t _test_abort(const char condition, const char file, int line)
	{
	_sel4test_failure(condition, file, line);
	return ABORT;
	}

	static inline void print_error_in_ipc(seL4_Error e)
	{
	#ifdef CONFIG_KERNEL_INVOCATION_REPORT_ERROR_IPC
	// If it hasnt been printed already
	if (!seL4_CanPrintError() && e != seL4_NoError) {
	printf("%s", seL4_GetDebugError());
	}
	#endif
	}

	#define test_error_eq(e, c) \
	if (!((e) == (c))) { \
	print_error_in_ipc(e); \
	return _test_fail(#e, __FILE__, __LINE__); \
	}
	#define test_assert(e) if (!(e)) return _test_fail(#e, __FILE__, __LINE__)
	#define test_check(e) if (!(e)) _test_error(#e, __FILE__, __LINE__)
	#define test_assert_fatal(e) if (!(e)) return _test_abort(#e, __FILE__, __LINE__)

	#define __TEST_BUFFER_SIZE 200
	#define test_op_type(a, b, op, t, name_a, name_b, cast) \
	do {\
	if (!(a op b)) { \
	int len = snprintf(NULL, 0, "Check %s(" t ") %s %s(" t ") failed.",\
	#name_a, (cast) a, #op, #name_b, (cast) b) + 1; \
	char buffer[len]; \
	snprintf(buffer, len, "Check %s(" t ") %s %s(" t ") failed.",\
	#name_a, (cast) a, #op, #name_b, (cast) b); \
	_test_error(buffer, __FILE__, __LINE__); \
	}\
	} while (0)

	#define test_op(a, b, op) \
	do { \
	typeof (a) _a = (a); \
	typeof (b) _b = (b); \
	if (sizeof(_a) != sizeof(_b)) { \
	int len = snprintf(NULL, 0, "%s (size %zu) != %s (size %zu), use of test_eq incorrect", #a,\
	sizeof(_a), #b, sizeof(_b)) + 1;\
	char buffer[len];\
	snprintf(buffer, len, "%s (size %zu) != %s (size %zu), use of test_eq incorrect", #a, sizeof(_a),\
	#b, sizeof(_b));\
	_test_error(buffer, __FILE__, __LINE__);\
	} else if (TYPES_COMPATIBLE(typeof(_a), int)) {\
	test_op_type(_a, _b, op, "%d", a, b, int); \
	} else if (TYPES_COMPATIBLE(typeof(_a), long)) {\
	test_op_type(_a, _b, op, "%ld", a, b, long); \
	} else if (TYPES_COMPATIBLE(typeof(_a), long long)) {\
	test_op_type(_a, _b, op, "%lld", a, b, long long); \
	} else if (TYPES_COMPATIBLE(typeof(_a), unsigned int)) {\
	test_op_type(_a, _b, op, "%u", a, b, unsigned int); \
	} else if (TYPES_COMPATIBLE(typeof(_a), unsigned long)) {\
	test_op_type(_a, _b, op, "%lu", a, b, unsigned long); \
	} else if (TYPES_COMPATIBLE(typeof(_a), unsigned long long)) {\
	test_op_type(_a, _b, op, "%llu", a, b, unsigned long long); \
	} else if (TYPES_COMPATIBLE(typeof(_a), char)) {\
	test_op_type(_a, _b, op, "%c", a, b, char); \
	} else if (TYPES_COMPATIBLE(typeof(_a), uintptr_t)) {\
	test_op_type(_a, _b, op, "0x%" PRIxPTR, a, b, uintptr_t);\
	} else { \
	_test_error("Cannot use test_op on this type", __FILE__, __LINE__);\
	}\
	} while (0)

	/* Pretty printed test_check wrapper macros for basic comparisons on base types,
	* which output the values and variable names to aid debugging */
	#define test_eq(a, b) test_op(a, b, ==)
	#define test_neq(a, b) test_op(a, b, !=)
	#define test_gt(a, b) test_op(a, b, >)
	#define test_geq(a, b) test_op(a, b, >=)
	#define test_lt(a, b) test_op(a, b, <)
	#define test_leq(a, b) test_op(a, b, <=)

	#define __TEST_MAX_STRING 50
	#define test_strop(a, b, op) \
	do {\
	if (strnlen(a, __TEST_MAX_STRING) == __TEST_MAX_STRING) {\
	_test_error("String " #a " too long for test_str* macros", __FILE__, __LINE__);\
	} else if (strnlen(b, __TEST_MAX_STRING) == __TEST_MAX_STRING) {\
	_test_error("String " #b " too long for test_str* macros", __FILE__, __LINE__);\
	} else if (!(strncmp(a, b, __TEST_MAX_STRING)) op 0) {\
	char buffer[__TEST_BUFFER_SIZE + 2 * __TEST_MAX_STRING];\
	snprintf(buffer, sizeof(buffer),\
	"Check %s(%s) %s %s(%s) failed.", #a, a, #op, #b, b);\
	_test_error(buffer, __FILE__, __LINE__); \
	}\
	} while (0)

	/* Pretty printed test_check wrapper macros for basic comparisons on c strings,
	* which output the values and variable names to aid debugging */
	#define test_streq(a, b) test_strop(a, b, ==)
	#define test_strneq(a, b) test_strop(a, b, !=)
	#define test_strge(a, b) test_strop(a, b, >)
	#define test_strgeq(a, b) test_strop(a, b, >=)
	#define test_strle(a, b) test_strop(a, b, <)
	#define test_strleq(a, b) test_strop(a, b, <=)

	env_t sel4test_get_env(void);