int
check_zeroes(seL4_Word addr, seL4_Word size_bytes)
{
test_assert_fatal(IS_ALIGNED(addr, sizeof(seL4_Word)));
test_assert_fatal(IS_ALIGNED(size_bytes, sizeof(seL4_Word)));
seL4_Word *p = (void*)addr;
seL4_Word size_words = size_bytes / sizeof(seL4_Word);
while (size_words--) {
if (*p++ != 0) {
LOG_ERROR("Found non-zero at position %d: %d\n", ((int)p) - (addr), p[-1]);
return 0;
}
}
return 1;
}
int
test_timer(driver_env_t env)
{
int error = ltimer_set_timeout(&env->timer.ltimer, 1 * NS_IN_S, TIMEOUT_PERIODIC);
test_assert_fatal(!error);
for (int i = 0; i < 3; i++) {
wait_for_timer_interrupt(env);
ZF_LOGV("Tick\n");
}
error = ltimer_reset(&env->timer.ltimer);
test_assert_fatal(!error);
return sel4test_get_result();
}
int
test_gettime_timeout(driver_env_t env)
{
int error = 0;
uint64_t start, end;
start = timestamp(env);
error = ltimer_set_timeout(&env->timer.ltimer, 1 * NS_IN_MS, TIMEOUT_PERIODIC);
test_assert_fatal(!error);
for (int i = 0; i < 3; i++) {
wait_for_timer_interrupt(env);
ZF_LOGV("Tick\n");
}
end = timestamp(env);
test_gt(end, start);
error = ltimer_reset(&env->timer.ltimer);
test_assert_fatal(!error);
return sel4test_get_result();
}
void
sel4test_run_tests(const char *name, int (*run_test)(struct testcase *t)) {
/* Count how many tests actually exist and allocate space for them */
int max_tests = (int)(__stop__test_case - __start__test_case);
struct testcase *tests[max_tests];
/* Extract and filter the tests based on the regex */
regex_t reg;
int error = regcomp(®, CONFIG_TESTPRINTER_REGEX, REG_EXTENDED | REG_NOSUB);
if (error != 0) {
printf("Error compiling regex \"%s\"\n", CONFIG_TESTPRINTER_REGEX);
return;
}
int num_tests = 0;
for (struct testcase *i = __start__test_case; i < __stop__test_case; i++) {
if (regexec(®, i->name, 0, NULL, 0) == 0) {
tests[num_tests] = i;
num_tests++;
}
}
regfree(®);
/* Sort the tests to remove any non determinism in test ordering */
qsort(tests, num_tests, sizeof(struct testcase*), test_comparator);
/* Now that they are sorted we can easily ensure there are no duplicate tests.
* this just ensures some sanity as if there are duplicates, they could have some
* arbitrary ordering, which might result in difficulty reproducing test failures */
for (int i = 1; i < num_tests; i++) {
test_assert_fatal(strcmp(tests[i]->name, tests[i - 1]->name) != 0);
}
sel4test_start_suite(name);
/* Run tests */
for (int i = 0; i < num_tests; i++) {
sel4test_start_test(tests[i]->name);
int result = run_test(tests[i]);
if (result != SUCCESS) {
current_test_passed = false;
}
sel4test_end_test();
}
/* Run the tests backwards... */
for (int i = num_tests - 1; i >= 0; i--) {
assert(tests[i]->name != NULL);
/* junit doesn't like duplicate test names */
int length = strlen(tests[i]->name);
char name_copy[length + 2];
strncpy(name_copy, tests[i]->name, length);
name_copy[length] = '2';
name_copy[length + 1] = '\0';
sel4test_start_test(name_copy);
int result = run_test(tests[i]);
if (result != SUCCESS) {
current_test_passed = false;
}
sel4test_end_test();
}
sel4test_end_suite();
/* Print closing banner. */
printf("\n");
int tests_run, passes, failures;
sel4_test_get_suite_results(&tests_run, &passes, &failures);
printf("%d/%d tests passed.\n", tests_run - failures, tests_run);
if (failures > 0) {
printf("*** FAILURES DETECTED ***\n");
} else {
printf("All is well in the universe.\n");
}
printf("\n\n");
}
int test_trivial(env_t env)
{
test_assert_fatal(2 > 1);
return sel4test_get_result();
}
