You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1365 lines
39 KiB
1365 lines
39 KiB
#include <dirent.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include "igt.h"
|
|
|
|
#include "settings.h"
|
|
#include "job_list.h"
|
|
#include "executor.h"
|
|
|
|
/*
|
|
* NOTE: this test is using a lot of variables that are changed in igt_fixture,
|
|
* igt_subtest_group and igt_subtests blocks but defined outside of them.
|
|
*
|
|
* Such variables have to be either non-local or volatile, otherwise their
|
|
* contents is undefined due to longjmps the framework performs.
|
|
*/
|
|
|
|
static const char testdatadir[] = TESTDATA_DIRECTORY;
|
|
|
|
static void igt_assert_eqstr(const char *one, const char *two)
|
|
{
|
|
if (one == NULL && two == NULL)
|
|
return;
|
|
|
|
igt_assert_f(one != NULL && two != NULL, "Strings differ (one is NULL): %s vs %s\n", one, two);
|
|
|
|
igt_assert_f(!strcmp(one, two), "Strings differ: '%s' vs '%s'\n", one, two);
|
|
}
|
|
|
|
static void debug_print_executions(struct job_list *list)
|
|
{
|
|
size_t i;
|
|
int k;
|
|
|
|
igt_debug("Executions:\n");
|
|
for (i = 0; i < list->size; i++) {
|
|
struct job_list_entry *entry = &list->entries[i];
|
|
igt_debug(" %s\n", entry->binary);
|
|
for (k = 0; k < entry->subtest_count; ++k) {
|
|
igt_debug(" %s\n", entry->subtests[k]);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static char *dump_file(int dirfd, const char *name)
|
|
{
|
|
int fd = openat(dirfd, name, O_RDONLY);
|
|
ssize_t s;
|
|
char *buf = malloc(256);
|
|
|
|
if (fd < 0) {
|
|
free(buf);
|
|
return NULL;
|
|
}
|
|
|
|
s = read(fd, buf, 255);
|
|
close(fd);
|
|
|
|
if (s < 0) {
|
|
free(buf);
|
|
return NULL;
|
|
}
|
|
|
|
buf[s] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
static void job_list_filter_test(const char *name, const char *filterarg1, const char *filterarg2,
|
|
size_t expected_normal, size_t expected_multiple)
|
|
{
|
|
int multiple;
|
|
struct settings *settings = malloc(sizeof(*settings));
|
|
|
|
igt_fixture
|
|
init_settings(settings);
|
|
|
|
for (multiple = 0; multiple < 2; multiple++) {
|
|
igt_subtest_f("job-list-filters-%s-%s", name, multiple ? "multiple" : "normal") {
|
|
struct job_list list;
|
|
const char *argv[] = { "runner",
|
|
/* Ugly but does the trick */
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
filterarg1, filterarg2,
|
|
testdatadir,
|
|
"path-to-results",
|
|
};
|
|
bool success = false;
|
|
size_t size;
|
|
|
|
init_job_list(&list);
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
success = create_job_list(&list, settings);
|
|
size = list.size;
|
|
|
|
if (success)
|
|
debug_print_executions(&list);
|
|
|
|
free_job_list(&list);
|
|
|
|
igt_assert_f(success, "Job list creation failed\n");
|
|
igt_assert_eq(size, multiple ? expected_multiple : expected_normal);
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
free_settings(settings);
|
|
free(settings);
|
|
}
|
|
}
|
|
|
|
static void clear_directory_fd(int dirfd)
|
|
{
|
|
DIR* d;
|
|
struct dirent *dirent;
|
|
|
|
d = fdopendir(dirfd);
|
|
|
|
if (dirfd < 0 || d == NULL) {
|
|
return;
|
|
}
|
|
|
|
while ((dirent = readdir(d)) != NULL) {
|
|
if (strcmp(dirent->d_name, ".") &&
|
|
strcmp(dirent->d_name, "..")) {
|
|
if (dirent->d_type == DT_REG) {
|
|
unlinkat(dirfd, dirent->d_name, 0);
|
|
} else if (dirent->d_type == DT_DIR) {
|
|
clear_directory_fd(openat(dirfd, dirent->d_name, O_DIRECTORY | O_RDONLY));
|
|
unlinkat(dirfd, dirent->d_name, AT_REMOVEDIR);
|
|
}
|
|
}
|
|
}
|
|
|
|
closedir(d);
|
|
}
|
|
|
|
static void clear_directory(char *name)
|
|
{
|
|
int dirfd = open(name, O_DIRECTORY | O_RDONLY);
|
|
clear_directory_fd(dirfd);
|
|
rmdir(name);
|
|
}
|
|
|
|
static void assert_settings_equal(struct settings *one, struct settings *two)
|
|
{
|
|
/*
|
|
* Regex lists are not serialized, and thus won't be compared
|
|
* here.
|
|
*/
|
|
igt_assert_eq(one->abort_mask, two->abort_mask);
|
|
igt_assert_eqstr(one->test_list, two->test_list);
|
|
igt_assert_eqstr(one->name, two->name);
|
|
igt_assert_eq(one->dry_run, two->dry_run);
|
|
igt_assert_eq(one->sync, two->sync);
|
|
igt_assert_eq(one->log_level, two->log_level);
|
|
igt_assert_eq(one->overwrite, two->overwrite);
|
|
igt_assert_eq(one->multiple_mode, two->multiple_mode);
|
|
igt_assert_eq(one->inactivity_timeout, two->inactivity_timeout);
|
|
igt_assert_eq(one->use_watchdog, two->use_watchdog);
|
|
igt_assert_eqstr(one->test_root, two->test_root);
|
|
igt_assert_eqstr(one->results_path, two->results_path);
|
|
igt_assert_eq(one->piglit_style_dmesg, two->piglit_style_dmesg);
|
|
igt_assert_eq(one->dmesg_warn_level, two->dmesg_warn_level);
|
|
}
|
|
|
|
static void assert_job_list_equal(struct job_list *one, struct job_list *two)
|
|
{
|
|
size_t i, k;
|
|
|
|
igt_assert_eq(one->size, two->size);
|
|
|
|
for (i = 0; i < one->size; i++) {
|
|
struct job_list_entry *eone = &one->entries[i];
|
|
struct job_list_entry *etwo = &two->entries[i];
|
|
|
|
igt_assert_eqstr(eone->binary, etwo->binary);
|
|
igt_assert_eq(eone->subtest_count, etwo->subtest_count);
|
|
|
|
for (k = 0; k < eone->subtest_count; k++) {
|
|
igt_assert_eqstr(eone->subtests[k], etwo->subtests[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void assert_execution_created(int dirfd, const char *name)
|
|
{
|
|
int fd;
|
|
|
|
igt_assert_f((fd = openat(dirfd, name, O_RDONLY)) >= 0,
|
|
"Execute didn't create %s\n", name);
|
|
close(fd);
|
|
}
|
|
|
|
static void assert_execution_results_exist(int dirfd)
|
|
{
|
|
assert_execution_created(dirfd, "journal.txt");
|
|
assert_execution_created(dirfd, "out.txt");
|
|
assert_execution_created(dirfd, "err.txt");
|
|
assert_execution_created(dirfd, "dmesg.txt");
|
|
}
|
|
|
|
igt_main
|
|
{
|
|
struct settings *settings = malloc(sizeof(*settings));
|
|
|
|
igt_fixture {
|
|
int i;
|
|
|
|
/*
|
|
* Let's close all the non-standard fds ahead of executing
|
|
* anything, so we can test for descriptor leakage caused by
|
|
* any of the igt_runner code-paths exercised here.
|
|
*
|
|
* See file-descriptor-leakage subtest at the end.
|
|
*
|
|
* Some libraries (looking at you, GnuTLS) may leave fds opened
|
|
* after the implicitly called library constructor. We don't
|
|
* have full control over them as they may be dependencies of
|
|
* our dependencies and may get pulled in if the user's and
|
|
* distribution's compile/configure/USE are just right.
|
|
*/
|
|
for (i = 3; i < 400; i++)
|
|
close(i);
|
|
|
|
init_settings(settings);
|
|
}
|
|
|
|
igt_subtest("default-settings") {
|
|
const char *argv[] = { "runner",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert_eq(settings->abort_mask, 0);
|
|
igt_assert(!settings->test_list);
|
|
igt_assert_eqstr(settings->name, "path-to-results");
|
|
igt_assert(!settings->dry_run);
|
|
igt_assert_eq(settings->include_regexes.size, 0);
|
|
igt_assert_eq(settings->exclude_regexes.size, 0);
|
|
igt_assert(!settings->sync);
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_NORMAL);
|
|
igt_assert(!settings->overwrite);
|
|
igt_assert(!settings->multiple_mode);
|
|
igt_assert_eq(settings->inactivity_timeout, 0);
|
|
igt_assert_eq(settings->overall_timeout, 0);
|
|
igt_assert(!settings->use_watchdog);
|
|
igt_assert(strstr(settings->test_root, "test-root-dir") != NULL);
|
|
igt_assert(strstr(settings->results_path, "path-to-results") != NULL);
|
|
|
|
igt_assert(!settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 4);
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char *cwd;
|
|
char *path;
|
|
|
|
igt_fixture {
|
|
igt_require((cwd = realpath(".", NULL)) != NULL);
|
|
path = NULL;
|
|
}
|
|
|
|
igt_subtest("absolute-path-converter") {
|
|
char paths[][15] = { "simple-name", "foo/bar", "." };
|
|
size_t i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(paths); i++) {
|
|
free(path);
|
|
path = absolute_path(paths[i]);
|
|
|
|
igt_assert(path[0] == '/');
|
|
igt_debug("Got path %s for %s\n", path, paths[i]);
|
|
igt_assert(strstr(path, cwd) == path);
|
|
if (strcmp(paths[i], ".")) {
|
|
igt_assert(strstr(path, paths[i]) != NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
free(cwd);
|
|
free(path);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
const char tmptestlist[] = "tmp.testlist";
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
char pathtotestlist[64];
|
|
volatile char *path;
|
|
|
|
igt_fixture {
|
|
int dirfd, fd;
|
|
|
|
path = NULL;
|
|
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
igt_require((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_require((fd = openat(dirfd, tmptestlist, O_CREAT | O_EXCL | O_WRONLY, 0660)) >= 0);
|
|
close(fd);
|
|
close(dirfd);
|
|
|
|
strcpy(pathtotestlist, dirname);
|
|
strcat(pathtotestlist, "/");
|
|
strcat(pathtotestlist, tmptestlist);
|
|
}
|
|
|
|
igt_subtest("absolute-path-usage") {
|
|
const char *argv[] = { "runner",
|
|
"--test-list", pathtotestlist,
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
path = realpath(testdatadir, NULL);
|
|
igt_assert(path != NULL);
|
|
igt_assert_eqstr(settings->test_root, (char*)path);
|
|
free((void*)path);
|
|
path = realpath(dirname, NULL);
|
|
igt_assert(path != NULL);
|
|
igt_assert_eqstr(settings->results_path, (char*)path);
|
|
free((void*)path);
|
|
path = realpath(pathtotestlist, NULL);
|
|
igt_assert(path != NULL);
|
|
igt_assert_eqstr(settings->test_list, (char*)path);
|
|
}
|
|
|
|
igt_fixture {
|
|
int dirfd;
|
|
|
|
igt_require((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0);
|
|
unlinkat(dirfd, tmptestlist, 0);
|
|
close(dirfd);
|
|
rmdir(dirname);
|
|
|
|
free((void*)path);
|
|
}
|
|
}
|
|
|
|
igt_subtest("environment-overrides-test-root-flag") {
|
|
const char *argv[] = { "runner",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
setenv("IGT_TEST_ROOT", testdatadir, 1);
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert_eq(settings->abort_mask, 0);
|
|
igt_assert(!settings->test_list);
|
|
igt_assert_eqstr(settings->name, "path-to-results");
|
|
igt_assert(!settings->dry_run);
|
|
igt_assert_eq(settings->include_regexes.size, 0);
|
|
igt_assert_eq(settings->exclude_regexes.size, 0);
|
|
igt_assert(!settings->sync);
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_NORMAL);
|
|
igt_assert(!settings->overwrite);
|
|
igt_assert(!settings->multiple_mode);
|
|
igt_assert_eq(settings->inactivity_timeout, 0);
|
|
igt_assert_eq(settings->overall_timeout, 0);
|
|
igt_assert(!settings->use_watchdog);
|
|
igt_assert(strstr(settings->test_root, testdatadir) != NULL);
|
|
igt_assert(strstr(settings->results_path, "path-to-results") != NULL);
|
|
igt_assert(!settings->piglit_style_dmesg);
|
|
}
|
|
|
|
igt_fixture {
|
|
unsetenv("IGT_TEST_ROOT");
|
|
}
|
|
|
|
igt_subtest("parse-all-settings") {
|
|
char blacklist_name[PATH_MAX], blacklist2_name[PATH_MAX];
|
|
const char *argv[] = { "runner",
|
|
"-n", "foo",
|
|
"--abort-on-monitored-error=taint,lockdep",
|
|
"--test-list", "path-to-test-list",
|
|
"--ignore-missing",
|
|
"--dry-run",
|
|
"-t", "pattern1",
|
|
"-t", "pattern2",
|
|
"-x", "xpattern1",
|
|
"-x", "xpattern2",
|
|
"-b", blacklist_name,
|
|
"--blacklist", blacklist2_name,
|
|
"-s",
|
|
"-l", "verbose",
|
|
"--overwrite",
|
|
"--multiple-mode",
|
|
"--inactivity-timeout", "27",
|
|
"--overall-timeout", "360",
|
|
"--use-watchdog",
|
|
"--piglit-style-dmesg",
|
|
"--dmesg-warn-level=3",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
sprintf(blacklist_name, "%s/test-blacklist.txt", testdatadir);
|
|
sprintf(blacklist2_name, "%s/test-blacklist2.txt", testdatadir);
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert_eq(settings->abort_mask, ABORT_TAINT | ABORT_LOCKDEP);
|
|
igt_assert(strstr(settings->test_list, "path-to-test-list") != NULL);
|
|
igt_assert_eqstr(settings->name, "foo");
|
|
igt_assert(settings->dry_run);
|
|
igt_assert_eq(settings->include_regexes.size, 2);
|
|
igt_assert_eqstr(settings->include_regexes.regex_strings[0], "pattern1");
|
|
igt_assert_eqstr(settings->include_regexes.regex_strings[1], "pattern2");
|
|
igt_assert_eq(settings->exclude_regexes.size, 4);
|
|
igt_assert_eqstr(settings->exclude_regexes.regex_strings[0], "xpattern1");
|
|
igt_assert_eqstr(settings->exclude_regexes.regex_strings[1], "xpattern2");
|
|
igt_assert_eqstr(settings->exclude_regexes.regex_strings[2], "xpattern3"); /* From blacklist */
|
|
igt_assert_eqstr(settings->exclude_regexes.regex_strings[3], "xpattern4"); /* From blacklist2 */
|
|
igt_assert(settings->sync);
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_VERBOSE);
|
|
igt_assert(settings->overwrite);
|
|
igt_assert(settings->multiple_mode);
|
|
igt_assert_eq(settings->inactivity_timeout, 27);
|
|
igt_assert_eq(settings->overall_timeout, 360);
|
|
igt_assert(settings->use_watchdog);
|
|
igt_assert(strstr(settings->test_root, "test-root-dir") != NULL);
|
|
igt_assert(strstr(settings->results_path, "path-to-results") != NULL);
|
|
|
|
igt_assert(settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 3);
|
|
}
|
|
igt_subtest("parse-list-all") {
|
|
const char *argv[] = { "runner",
|
|
"--list-all",
|
|
"test-root-dir"};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->list_all, 1);
|
|
}
|
|
|
|
igt_subtest("dmesg-warn-level-inferred") {
|
|
const char *argv[] = { "runner",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(!settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 4);
|
|
}
|
|
|
|
igt_subtest("dmesg-warn-level-inferred-with-piglit-style") {
|
|
const char *argv[] = { "runner",
|
|
"--piglit-style-dmesg",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 5);
|
|
}
|
|
|
|
igt_subtest("dmesg-warn-level-overridable-with-piglit-style") {
|
|
const char *argv[] = { "runner",
|
|
"--piglit-style-dmesg",
|
|
"--dmesg-warn-level=3",
|
|
"test-root-dir",
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 3);
|
|
}
|
|
|
|
igt_subtest("invalid-option") {
|
|
const char *argv[] = { "runner",
|
|
"--no-such-option",
|
|
"test-root-dir",
|
|
"results-path",
|
|
};
|
|
|
|
igt_assert(!parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
}
|
|
|
|
igt_subtest("paths-missing") {
|
|
const char *argv[] = { "runner",
|
|
"-o",
|
|
};
|
|
igt_assert(!parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
}
|
|
|
|
igt_subtest("log-levels") {
|
|
const char *argv[] = { "runner",
|
|
"-l", "normal",
|
|
"test-root-dir",
|
|
"results-path",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_NORMAL);
|
|
|
|
argv[2] = "quiet";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_QUIET);
|
|
|
|
argv[2] = "verbose";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->log_level, LOG_LEVEL_VERBOSE);
|
|
}
|
|
|
|
igt_subtest("abort-conditions") {
|
|
const char *argv[] = { "runner",
|
|
"--abort-on-monitored-error=taint",
|
|
"test-root-dir",
|
|
"results-path",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_TAINT);
|
|
|
|
argv[1] = "--abort-on-monitored-error=lockdep";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_LOCKDEP);
|
|
|
|
argv[1] = "--abort-on-monitored-error=taint";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_TAINT);
|
|
|
|
argv[1] = "--abort-on-monitored-error=lockdep,taint";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_TAINT | ABORT_LOCKDEP);
|
|
|
|
argv[1] = "--abort-on-monitored-error=taint,lockdep";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_TAINT | ABORT_LOCKDEP);
|
|
|
|
argv[1] = "--abort-on-monitored-error=all";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, ABORT_ALL);
|
|
|
|
argv[1] = "--abort-on-monitored-error=";
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert_eq(settings->abort_mask, 0);
|
|
|
|
argv[1] = "--abort-on-monitored-error=doesnotexist";
|
|
igt_assert(!parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
}
|
|
|
|
igt_subtest("parse-clears-old-data") {
|
|
const char *argv[] = { "runner",
|
|
"-n", "foo",
|
|
"--dry-run",
|
|
"test-root-dir",
|
|
"results-path",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert_eqstr(settings->name, "foo");
|
|
igt_assert(settings->dry_run);
|
|
igt_assert(!settings->test_list);
|
|
igt_assert(!settings->sync);
|
|
|
|
argv[1] = "--test-list";
|
|
argv[3] = "--sync";
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert_eqstr(settings->name, "results-path");
|
|
igt_assert(!settings->dry_run);
|
|
igt_assert(strstr(settings->test_list, "foo") != NULL);
|
|
igt_assert(settings->sync);
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char filename[] = "tmplistXXXXXX";
|
|
|
|
igt_fixture {
|
|
int fd;
|
|
igt_require((fd = mkstemp(filename)) >= 0);
|
|
close(fd);
|
|
}
|
|
|
|
igt_subtest("validate-ok") {
|
|
const char *argv[] = { "runner",
|
|
"--test-list", filename,
|
|
testdatadir,
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(validate_settings(settings));
|
|
}
|
|
|
|
igt_fixture {
|
|
unlink(filename);
|
|
}
|
|
}
|
|
|
|
igt_subtest("validate-no-test-list") {
|
|
const char *nosuchfile = "no-such-file";
|
|
const char *argv[] = { "runner",
|
|
"--test-list", nosuchfile,
|
|
testdatadir,
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert_lt(open(nosuchfile, O_RDONLY), 0);
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(!validate_settings(settings));
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
|
|
igt_fixture {
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
init_job_list(list);
|
|
}
|
|
|
|
igt_subtest("job-list-no-test-list-txt") {
|
|
const char *argv[] = { "runner",
|
|
dirname,
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(!create_job_list(list, settings));
|
|
}
|
|
|
|
igt_fixture {
|
|
rmdir(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
job_list_filter_test("nofilters", "-n", "placeholderargs", 5, 3);
|
|
job_list_filter_test("binary-include", "-t", "successtest", 2, 1);
|
|
job_list_filter_test("binary-exclude", "-x", "successtest", 3, 2);
|
|
job_list_filter_test("subtest-include", "-t", "first-subtest", 1, 1);
|
|
job_list_filter_test("subtest-exclude", "-x", "second-subtest", 4, 3);
|
|
job_list_filter_test("piglit-names", "-t", "igt@successtest", 2, 1);
|
|
job_list_filter_test("piglit-names-subtest", "-t", "igt@successtest@first", 1, 1);
|
|
|
|
igt_subtest_group {
|
|
char filename[] = "tmplistXXXXXX";
|
|
const char testlisttext[] = "igt@successtest@first-subtest\n"
|
|
"igt@successtest@second-subtest\n"
|
|
"igt@nosubtests\n";
|
|
int multiple;
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
|
|
igt_fixture {
|
|
int fd;
|
|
igt_require((fd = mkstemp(filename)) >= 0);
|
|
igt_require(write(fd, testlisttext, strlen(testlisttext)) == strlen(testlisttext));
|
|
close(fd);
|
|
init_job_list(list);
|
|
}
|
|
|
|
for (multiple = 0; multiple < 2; multiple++) {
|
|
igt_subtest_f("job-list-testlist-%s", multiple ? "multiple" : "normal") {
|
|
const char *argv[] = { "runner",
|
|
"--test-list", filename,
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
testdatadir,
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
|
|
igt_assert_eq(list->size, multiple ? 2 : 3);
|
|
|
|
igt_assert_eqstr(list->entries[0].binary, "successtest");
|
|
if (!multiple) igt_assert_eqstr(list->entries[1].binary, "successtest");
|
|
igt_assert_eqstr(list->entries[multiple ? 1 : 2].binary, "nosubtests");
|
|
|
|
igt_assert_eq(list->entries[0].subtest_count, multiple ? 2 : 1);
|
|
igt_assert_eq(list->entries[1].subtest_count, multiple ? 0 : 1);
|
|
if (!multiple) igt_assert_eq(list->entries[2].subtest_count, 0);
|
|
|
|
igt_assert_eqstr(list->entries[0].subtests[0], "first-subtest");
|
|
igt_assert_eqstr(list->entries[multiple ? 0 : 1].subtests[multiple ? 1 : 0], "second-subtest");
|
|
}
|
|
|
|
igt_subtest_f("job-list-testlist-filtered-%s", multiple ? "multiple" : "normal") {
|
|
const char *argv[] = { "runner",
|
|
"--test-list", filename,
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
"-t", "successtest",
|
|
"-x", "first",
|
|
testdatadir,
|
|
"path-to-results",
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
|
|
igt_assert_eq(list->size, 1);
|
|
igt_assert_eqstr(list->entries[0].binary, "successtest");
|
|
|
|
igt_assert_eq(list->entries[0].subtest_count, 1);
|
|
igt_assert_eqstr(list->entries[0].subtests[0], "second-subtest");
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
unlink(filename);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
volatile int dirfd = -1, fd = -1;
|
|
struct settings *cmp_settings = malloc(sizeof(*cmp_settings));
|
|
|
|
igt_fixture {
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
init_settings(cmp_settings);
|
|
}
|
|
|
|
igt_subtest("settings-serialize") {
|
|
const char *argv[] = { "runner",
|
|
"-n", "foo",
|
|
"--abort-on-monitored-error",
|
|
"--test-list", "path-to-test-list",
|
|
"--ignore-missing",
|
|
"--dry-run",
|
|
"-t", "pattern1",
|
|
"-t", "pattern2",
|
|
"-x", "xpattern1",
|
|
"-x", "xpattern2",
|
|
"-s",
|
|
"-l", "verbose",
|
|
"--overwrite",
|
|
"--multiple-mode",
|
|
"--inactivity-timeout", "27",
|
|
"--overall-timeout", "360",
|
|
"--use-watchdog",
|
|
"--piglit-style-dmesg",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
|
|
igt_assert(serialize_settings(settings));
|
|
|
|
dirfd = open(dirname, O_DIRECTORY, O_RDONLY);
|
|
igt_assert_f(dirfd >= 0, "Serialization did not create the results directory\n");
|
|
|
|
igt_assert_f((fd = openat(dirfd, "metadata.txt", O_RDONLY)),
|
|
"Opening %s/metadata.txt failed\n", dirname);
|
|
close(fd);
|
|
|
|
igt_assert_f(read_settings_from_dir(cmp_settings, dirfd), "Reading settings failed\n");
|
|
assert_settings_equal(settings, cmp_settings);
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_settings(cmp_settings);
|
|
free(cmp_settings);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
volatile int dirfd = -1, fd = -1;
|
|
struct job_list *list, *cmp_list;
|
|
int multiple;
|
|
|
|
list = malloc(sizeof(*list));
|
|
cmp_list = malloc(sizeof(*cmp_list));
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
init_job_list(cmp_list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
}
|
|
|
|
for (multiple = 0; multiple < 2; multiple++) {
|
|
igt_subtest_f("job-list-serialize-%s", multiple ? "multiple" : "normal") {
|
|
const char *argv[] = { "runner",
|
|
/* Ugly */
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
|
|
igt_assert(serialize_settings(settings));
|
|
igt_assert(serialize_job_list(list, settings));
|
|
|
|
dirfd = open(dirname, O_DIRECTORY, O_RDONLY);
|
|
igt_assert_f(dirfd >= 0, "Serialization did not create the results directory\n");
|
|
|
|
igt_assert_f((fd = openat(dirfd, "joblist.txt", O_RDONLY)) >= 0,
|
|
"Opening %s/joblist.txt failed\n", dirname);
|
|
close(fd);
|
|
fd = -1;
|
|
|
|
igt_assert_f(read_job_list(cmp_list, dirfd), "Reading job list failed\n");
|
|
assert_job_list_equal(list, cmp_list);
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(cmp_list);
|
|
free_job_list(list);
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
free(cmp_list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
}
|
|
|
|
igt_subtest("dry-run-option") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
"--dry-run",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
|
|
igt_assert(initialize_execute_state(&state, settings, list));
|
|
igt_assert_eq(state.next, 0);
|
|
igt_assert(state.dry);
|
|
igt_assert_eq(list->size, 5);
|
|
|
|
igt_assert_f((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Dry run initialization didn't create the results directory.\n");
|
|
|
|
/* Execute from just initialize_execute_state should fail */
|
|
igt_assert(execute(&state, settings, list));
|
|
igt_assert_f(openat(dirfd, "0", O_DIRECTORY | O_RDONLY) < 0,
|
|
"Dry run executed when it should not have.\n");
|
|
igt_assert_f((fd = openat(dirfd, "metadata.txt", O_RDONLY)) >= 0,
|
|
"Dry run initialization didn't serialize settings.\n");
|
|
close(fd);
|
|
igt_assert_f((fd = openat(dirfd, "joblist.txt", O_RDONLY)) >= 0,
|
|
"Dry run initialization didn't serialize the job list.\n");
|
|
close(fd);
|
|
igt_assert_f((fd = openat(dirfd, "uname.txt", O_RDONLY)) < 0,
|
|
"Dry run initialization created uname.txt.\n");
|
|
|
|
igt_assert(initialize_execute_state_from_resume(dirfd, &state, settings, list));
|
|
igt_assert_eq(state.next, 0);
|
|
igt_assert(!state.dry);
|
|
igt_assert_eq(list->size, 5);
|
|
/* initialize_execute_state_from_resume() closes the dirfd */
|
|
igt_assert_f((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Dry run resume somehow deleted the results directory.\n");
|
|
|
|
/* Execute from resume should work */
|
|
igt_assert(execute(&state, settings, list));
|
|
igt_assert_f((fd = openat(dirfd, "uname.txt", O_RDONLY)) >= 0,
|
|
"Dry run resume didn't create uname.txt.\n");
|
|
close(fd);
|
|
igt_assert_f((subdirfd = openat(dirfd, "0", O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Dry run resume didn't create result directory.\n");
|
|
igt_assert_f((fd = openat(subdirfd, "journal.txt", O_RDONLY)) >= 0,
|
|
"Dry run resume didn't create a journal.\n");
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(dirfd);
|
|
close(subdirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, fd = -1;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
}
|
|
|
|
igt_subtest("execute-initialize-new-run") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
|
|
igt_assert(initialize_execute_state(&state, settings, list));
|
|
|
|
igt_assert_eq(state.next, 0);
|
|
igt_assert_eq(list->size, 5);
|
|
igt_assert_f((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute state initialization didn't create the results directory.\n");
|
|
igt_assert_f((fd = openat(dirfd, "metadata.txt", O_RDONLY)) >= 0,
|
|
"Execute state initialization didn't serialize settings.\n");
|
|
close(fd);
|
|
igt_assert_f((fd = openat(dirfd, "joblist.txt", O_RDONLY)) >= 0,
|
|
"Execute state initialization didn't serialize the job list.\n");
|
|
close(fd);
|
|
igt_assert_f((fd = openat(dirfd, "journal.txt", O_RDONLY)) < 0,
|
|
"Execute state initialization created a journal.\n");
|
|
igt_assert_f((fd = openat(dirfd, "uname.txt", O_RDONLY)) < 0,
|
|
"Execute state initialization created uname.txt.\n");
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
}
|
|
|
|
igt_subtest("execute-initialize-subtest-started") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
"--multiple-mode",
|
|
"-t", "successtest",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
const char journaltext[] = "first-subtest\n";
|
|
const char excludestring[] = "!first-subtest";
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
igt_assert(list->size == 1);
|
|
igt_assert(list->entries[0].subtest_count == 0);
|
|
|
|
igt_assert(serialize_settings(settings));
|
|
igt_assert(serialize_job_list(list, settings));
|
|
|
|
igt_assert((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_assert(mkdirat(dirfd, "0", 0770) == 0);
|
|
igt_assert((subdirfd = openat(dirfd, "0", O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_assert((fd = openat(subdirfd, "journal.txt", O_CREAT | O_WRONLY | O_EXCL, 0660)) >= 0);
|
|
igt_assert(write(fd, journaltext, strlen(journaltext)) == strlen(journaltext));
|
|
|
|
free_job_list(list);
|
|
free_settings(settings);
|
|
igt_assert(initialize_execute_state_from_resume(dirfd, &state, settings, list));
|
|
|
|
igt_assert_eq(state.next, 0);
|
|
igt_assert_eq(list->size, 1);
|
|
igt_assert_eq(list->entries[0].subtest_count, 2);
|
|
igt_assert_eqstr(list->entries[0].subtests[0], "*");
|
|
igt_assert_eqstr(list->entries[0].subtests[1], excludestring);
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(subdirfd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
}
|
|
|
|
igt_subtest("execute-initialize-all-subtests-started") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
"--multiple-mode",
|
|
"-t", "successtest@first-subtest",
|
|
"-t", "successtest@second-subtest",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
const char journaltext[] = "first-subtest\nsecond-subtest\n";
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
igt_assert(list->size == 1);
|
|
igt_assert(list->entries[0].subtest_count == 2);
|
|
|
|
igt_assert(serialize_settings(settings));
|
|
igt_assert(serialize_job_list(list, settings));
|
|
|
|
igt_assert((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_assert(mkdirat(dirfd, "0", 0770) == 0);
|
|
igt_assert((subdirfd = openat(dirfd, "0", O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_assert((fd = openat(subdirfd, "journal.txt", O_CREAT | O_WRONLY | O_EXCL, 0660)) >= 0);
|
|
igt_assert(write(fd, journaltext, strlen(journaltext)) == strlen(journaltext));
|
|
|
|
free_job_list(list);
|
|
free_settings(settings);
|
|
igt_assert(initialize_execute_state_from_resume(dirfd, &state, settings, list));
|
|
|
|
/* All subtests are in journal, the entry should be considered completed */
|
|
igt_assert_eq(state.next, 1);
|
|
igt_assert_eq(list->size, 1);
|
|
igt_assert_eq(list->entries[0].subtest_count, 4);
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(subdirfd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
}
|
|
|
|
igt_subtest("execute-initialize-subtests-complete") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
"--multiple-mode",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
const char journaltext[] = "first-subtest\nsecond-subtest\nexit:0\n";
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
igt_assert(list->size == 3);
|
|
|
|
if (!strcmp(list->entries[0].binary, "no-subtests")) {
|
|
struct job_list_entry tmp = list->entries[0];
|
|
list->entries[0] = list->entries[1];
|
|
list->entries[1] = tmp;
|
|
}
|
|
|
|
igt_assert(list->entries[0].subtest_count == 0);
|
|
|
|
igt_assert(serialize_settings(settings));
|
|
igt_assert(serialize_job_list(list, settings));
|
|
|
|
igt_assert_lte(0, dirfd = open(dirname, O_DIRECTORY | O_RDONLY));
|
|
igt_assert_eq(mkdirat(dirfd, "0", 0770), 0);
|
|
igt_assert((subdirfd = openat(dirfd, "0", O_DIRECTORY | O_RDONLY)) >= 0);
|
|
igt_assert_lte(0, fd = openat(subdirfd, "journal.txt", O_CREAT | O_WRONLY | O_EXCL, 0660));
|
|
igt_assert_eq(write(fd, journaltext, sizeof(journaltext)), sizeof(journaltext));
|
|
|
|
free_job_list(list);
|
|
free_settings(settings);
|
|
igt_assert(initialize_execute_state_from_resume(dirfd, &state, settings, list));
|
|
|
|
igt_assert_eq(state.next, 1);
|
|
igt_assert_eq(list->size, 3);
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(subdirfd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
int multiple;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
}
|
|
|
|
for (multiple = 0; multiple < 2; multiple++) {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
|
|
igt_fixture {
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
}
|
|
|
|
igt_subtest_f("execute-subtests-%s", multiple ? "multiple" : "normal") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
"-t", "-subtest",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
char testdirname[16];
|
|
size_t expected_tests = multiple ? 2 : 3;
|
|
size_t i;
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
igt_assert(initialize_execute_state(&state, settings, list));
|
|
|
|
igt_assert(execute(&state, settings, list));
|
|
igt_assert_f((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute didn't create the results directory\n");
|
|
|
|
igt_assert_f((fd = openat(dirfd, "uname.txt", O_RDONLY)) >= 0,
|
|
"Execute didn't create uname.txt\n");
|
|
close(fd);
|
|
fd = -1;
|
|
|
|
for (i = 0; i < expected_tests; i++) {
|
|
snprintf(testdirname, 16, "%zd", i);
|
|
|
|
igt_assert_f((subdirfd = openat(dirfd, testdirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute didn't create result directory '%s'\n", testdirname);
|
|
assert_execution_results_exist(subdirfd);
|
|
close(subdirfd);
|
|
}
|
|
|
|
snprintf(testdirname, 16, "%zd", expected_tests);
|
|
igt_assert_f((subdirfd = openat(dirfd, testdirname, O_DIRECTORY | O_RDONLY)) < 0,
|
|
"Execute created too many directories\n");
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(subdirfd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
}
|
|
}
|
|
|
|
igt_fixture
|
|
free(list);
|
|
}
|
|
|
|
igt_subtest_group {
|
|
igt_subtest("metadata-read-old-style-infer-dmesg-warn-piglit-style") {
|
|
char metadata[] = "piglit_style_dmesg : 1\n";
|
|
FILE *f = fmemopen(metadata, strlen(metadata), "r");
|
|
igt_assert(f);
|
|
|
|
igt_assert(read_settings_from_file(settings, f));
|
|
|
|
igt_assert(settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 5);
|
|
|
|
fclose(f);
|
|
}
|
|
|
|
igt_subtest("metadata-read-overrides-dmesg-warn-piglit-style") {
|
|
char metadata[] = "piglit_style_dmesg : 1\ndmesg_warn_level : 3";
|
|
FILE *f = fmemopen(metadata, strlen(metadata), "r");
|
|
igt_assert(f);
|
|
|
|
igt_assert(read_settings_from_file(settings, f));
|
|
|
|
igt_assert(settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 3);
|
|
|
|
fclose(f);
|
|
}
|
|
|
|
igt_subtest("metadata-read-old-style-infer-dmesg-warn-default") {
|
|
char metadata[] = "piglit_style_dmesg : 0\n";
|
|
FILE *f = fmemopen(metadata, strlen(metadata), "r");
|
|
igt_assert(f);
|
|
|
|
igt_assert(read_settings_from_file(settings, f));
|
|
|
|
igt_assert(!settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 4);
|
|
|
|
fclose(f);
|
|
}
|
|
|
|
igt_subtest("metadata-read-overrides-dmesg-warn-default") {
|
|
char metadata[] = "piglit_style_dmesg : 0\ndmesg_warn_level : 3";
|
|
FILE *f = fmemopen(metadata, strlen(metadata), "r");
|
|
igt_assert(f);
|
|
|
|
igt_assert(read_settings_from_file(settings, f));
|
|
|
|
igt_assert(!settings->piglit_style_dmesg);
|
|
igt_assert_eq(settings->dmesg_warn_level, 3);
|
|
|
|
fclose(f);
|
|
}
|
|
}
|
|
|
|
igt_subtest_group {
|
|
struct job_list *list = malloc(sizeof(*list));
|
|
volatile int dirfd = -1, subdirfd = -1, fd = -1;
|
|
int multiple;
|
|
|
|
igt_fixture {
|
|
init_job_list(list);
|
|
}
|
|
|
|
for (multiple = 0; multiple < 2; multiple++) {
|
|
char dirname[] = "tmpdirXXXXXX";
|
|
|
|
igt_fixture {
|
|
igt_require(mkdtemp(dirname) != NULL);
|
|
rmdir(dirname);
|
|
}
|
|
|
|
igt_subtest_f("execute-skipper-journal-%s", multiple ? "multiple" : "normal") {
|
|
struct execute_state state;
|
|
const char *argv[] = { "runner",
|
|
multiple ? "--multiple-mode" : "--sync",
|
|
"-t", "skippers",
|
|
testdatadir,
|
|
dirname,
|
|
};
|
|
char *dump;
|
|
const char *expected_0 = multiple ?
|
|
"skip-one\nskip-two\nexit:77 (" :
|
|
"skip-one\nexit:77 (";
|
|
const char *expected_1 = "skip-two\nexit:77 (";
|
|
|
|
igt_assert(parse_options(ARRAY_SIZE(argv), (char**)argv, settings));
|
|
igt_assert(create_job_list(list, settings));
|
|
igt_assert(initialize_execute_state(&state, settings, list));
|
|
|
|
igt_assert(execute(&state, settings, list));
|
|
igt_assert_f((dirfd = open(dirname, O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute didn't create the results directory\n");
|
|
|
|
igt_assert_f((fd = openat(dirfd, "uname.txt", O_RDONLY)) >= 0,
|
|
"Execute didn't create uname.txt\n");
|
|
close(fd);
|
|
fd = -1;
|
|
|
|
igt_assert_f((subdirfd = openat(dirfd, "0", O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute didn't create result directory '0'\n");
|
|
dump = dump_file(subdirfd, "journal.txt");
|
|
igt_assert_f(dump != NULL,
|
|
"Execute didn't create the journal\n");
|
|
/* Trim out the runtime */
|
|
dump[strlen(expected_0)] = '\0';
|
|
igt_assert_eqstr(dump, expected_0);
|
|
free(dump);
|
|
close(subdirfd);
|
|
subdirfd = -1;
|
|
|
|
if (!multiple) {
|
|
igt_assert_f((subdirfd = openat(dirfd, "1", O_DIRECTORY | O_RDONLY)) >= 0,
|
|
"Execute didn't create result directory '1'\n");
|
|
dump = dump_file(subdirfd, "journal.txt");
|
|
igt_assert_f(dump != NULL,
|
|
"Execute didn't create the journal\n");
|
|
dump[strlen(expected_1)] = '\0';
|
|
igt_assert_eqstr(dump, expected_1);
|
|
free(dump);
|
|
close(subdirfd);
|
|
subdirfd = -1;
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
close(fd);
|
|
close(subdirfd);
|
|
close(dirfd);
|
|
clear_directory(dirname);
|
|
free_job_list(list);
|
|
}
|
|
}
|
|
|
|
igt_fixture
|
|
free(list);
|
|
}
|
|
|
|
igt_subtest("file-descriptor-leakage") {
|
|
int i;
|
|
|
|
/*
|
|
* This is a build-time test, and it's expected that
|
|
* all subtests are normally run. Keep this one at the
|
|
* end.
|
|
*
|
|
* Try to close some number of fds after stderr and
|
|
* expect EBADF for each one.
|
|
*/
|
|
for (i = 3; i < 400; i++) {
|
|
errno = 0;
|
|
igt_assert_neq(close(i), 0);
|
|
igt_assert_eq(errno, EBADF);
|
|
}
|
|
}
|
|
|
|
igt_fixture {
|
|
free_settings(settings);
|
|
free(settings);
|
|
}
|
|
}
|