ATF_TC_BODY(concat__two, tc) { char* path; ATF_REQUIRE(!kyua_error_is_set(kyua_fs_concat(&path, "foo", "bar", NULL))); ATF_REQUIRE_STREQ("foo/bar", path); free(path); }
ATF_TC_BODY(work_directory__env_tmpdir, tc) { char* tmpdir; RE(kyua_fs_make_absolute("worktest", &tmpdir)); ATF_REQUIRE(mkdir(tmpdir, 0755) != -1); RE(kyua_env_set("TMPDIR", tmpdir)); char* work_directory; RE(kyua_run_work_directory_enter("template.XXXXXX", getuid(), getgid(), &work_directory)); { char* template_test; RE(kyua_fs_concat(&template_test, atf_tc_get_config_var(tc, "srcdir"), "worktest", "template.XXXXXX", NULL)); ATF_REQUIRE(access(template_test, X_OK) == -1); free(template_test); } ATF_REQUIRE(access(work_directory, X_OK) != -1); ATF_REQUIRE(rmdir(tmpdir) == -1); // Not yet empty. RE(kyua_run_work_directory_leave(&work_directory)); ATF_REQUIRE(rmdir(tmpdir) != -1); free(tmpdir); }
ATF_TC_BODY(concat__several, tc) { char* path; ATF_REQUIRE(!kyua_error_is_set(kyua_fs_concat(&path, "/usr", ".", "bin", "ls", NULL))); ATF_REQUIRE_STREQ("/usr/./bin/ls", path); free(path); }
ATF_TC_BODY(current_path__ok, tc) { char* previous; ATF_REQUIRE(!kyua_error_is_set(kyua_fs_current_path(&previous))); ATF_REQUIRE(mkdir("root", 0755) != -1); ATF_REQUIRE(chdir("root") != -1); char* cwd; ATF_REQUIRE(!kyua_error_is_set(kyua_fs_current_path(&cwd))); char* exp_cwd; ATF_REQUIRE(!kyua_error_is_set(kyua_fs_concat(&exp_cwd, previous, "root", NULL))); ATF_REQUIRE_STREQ(exp_cwd, cwd); free(exp_cwd); free(cwd); free(previous); }
/// Forks and executes the body of a test case in a controlled manner. /// /// \param test_program Path to the test program to execute. /// \param test_case Name of the test case to run. /// \param result_file Path to the ATF result file to be created. /// \param user_variables Set of configuration variables to pass to the test. /// \param run_params Settings to control the subprocess. /// \param [out] success Set to true if the test case runs properly and returns /// a result that is to be considered as successful. /// /// \return OK if all goes well, an error otherwise. Note that a failed test /// case is denoted by setting success to false on exit, not by returning an /// error. static kyua_error_t run_body(const char* test_program, const char* test_case, const char* result_file, const char* const user_variables[], const kyua_run_params_t* run_params, bool* success) { kyua_error_t error; char* tmp_result_file; error = kyua_fs_concat(&tmp_result_file, run_params->work_directory, "result.txt", NULL); if (kyua_error_is_set(error)) goto out; pid_t pid; error = kyua_run_fork(run_params, &pid); if (!kyua_error_is_set(error) && pid == 0) { exec_body(test_program, test_case, tmp_result_file, user_variables); } assert(pid != -1 && pid != 0); if (kyua_error_is_set(error)) goto out_tmp_result_file; int status; bool timed_out; error = kyua_run_wait(pid, &status, &timed_out); if (kyua_error_is_set(error)) goto out_tmp_result_file; if (WIFSIGNALED(status) && WCOREDUMP(status)) { kyua_stacktrace_dump(test_program, pid, run_params, stderr); } error = kyua_atf_result_rewrite(tmp_result_file, result_file, status, timed_out, success); out_tmp_result_file: free(tmp_result_file); out: return error; }
/// Creates a file within the work directory. /// /// \param work_directory Path to the work directory. /// \param name Name of the file to create. /// \param mode Mode of the file, as specified by fopen(3). /// \param [out] file Pointer to the created stream. /// /// \return An error if there is a problem. static kyua_error_t create_file_in_work_directory(const char* work_directory, const char* name, const char* mode, FILE** file) { char* path; kyua_error_t error = kyua_fs_concat(&path, work_directory, name, NULL); if (kyua_error_is_set(error)) goto out; FILE* tmp_file = fopen(path, mode); if (tmp_file == NULL) { error = kyua_libc_error_new(errno, "Failed to create %s", path); goto out_path; } *file = tmp_file; assert(!kyua_error_is_set(error)); out_path: free(path); out: return error; }