// Copyright 2012 Google Inc.
// All rights reserved.
//
// 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 Google Inc. 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.

#include <sys/wait.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "atf_list.h"
#include "atf_result.h"
#include "cli.h"
#include "defs.h"
#include "error.h"
#include "fs.h"
#include "run.h"
#include "stacktrace.h"
#include "text.h"


/// Template for the creation of the temporary work directories.
#define WORKDIR_TEMPLATE "kyua.atf-tester.XXXXXX"


static void run_list(const char*, const int[2]) KYUA_DEFS_NORETURN;


/// Executes the test program in list mode.
///
/// \param test_program Path to the test program to execute; should be absolute.
/// \param stdout_fds Pipe to write the output of the test program to.
static void
run_list(const char* test_program, const int stdout_fds[2])
{
   (void)close(stdout_fds[0]);

   if (stdout_fds[1] != STDOUT_FILENO) {
       if (dup2(stdout_fds[1], STDOUT_FILENO) == -1)
           err(EXIT_FAILURE, "dup2 failed");
       (void)close(stdout_fds[1]);
   }

   if (dup2(STDOUT_FILENO, STDERR_FILENO) == -1)
       err(EXIT_FAILURE, "dup2 failed");

   const char* const program_args[] = { test_program, "-l", NULL };
   kyua_run_exec(test_program, program_args);
}


/// Dumps the contents of the input file into the output.
///
/// \param input File from which to read.
/// \param output File to which to write.
///
/// \return An error if there is a problem.
static kyua_error_t
dump_file(FILE* input, FILE* output)
{
   char buffer[1024];
   size_t length;

   while ((length = fread(buffer, 1, sizeof(buffer), input)) > 0) {
       if (fwrite(buffer, 1, length, output) != length) {
           return kyua_generic_error_new("Failed to write to output file");
       }
   }
   if (ferror(input))
       return kyua_libc_error_new(errno, "Failed to read test cases list");

   return kyua_error_ok();
}


/// 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;
}


/// Lists the test cases in a test program.
///
/// \param test_program Path to the test program for which to list the test
///     cases.  Should be absolute.
/// \param run_params Execution parameters to configure the test process.
///
/// \return An error if the listing fails; OK otherwise.
static kyua_error_t
list_test_cases(const char* test_program, const kyua_run_params_t* run_params)
{
   kyua_error_t error;

   char* work_directory;
   error = kyua_run_work_directory_enter(WORKDIR_TEMPLATE,
                                         run_params->unprivileged_user,
                                         run_params->unprivileged_group,
                                         &work_directory);
   if (kyua_error_is_set(error))
       goto out;
   kyua_run_params_t real_run_params = *run_params;
   real_run_params.work_directory = work_directory;

   int stdout_fds[2];
   if (pipe(stdout_fds) == -1) {
       error = kyua_libc_error_new(errno, "pipe failed");
       goto out_work_directory;
   }

   pid_t pid;
   error = kyua_run_fork(&real_run_params, &pid);
   if (!kyua_error_is_set(error) && pid == 0) {
       run_list(test_program, stdout_fds);
   }
   assert(pid != -1 && pid != 0);
   if (kyua_error_is_set(error))
       goto out_stdout_fds;

   FILE* tmp_output = NULL;  // Initialize to shut up gcc warning.
   error = create_file_in_work_directory(real_run_params.work_directory,
                                         "list.txt", "w+", &tmp_output);
   if (kyua_error_is_set(error))
       goto out_stdout_fds;

   close(stdout_fds[1]); stdout_fds[1] = -1;
   kyua_error_t parse_error = atf_list_parse(stdout_fds[0], tmp_output);
   stdout_fds[0] = -1;  // Guaranteed closed by atf_list_parse.
   // Delay reporting of parse errors to later.  If we detect a problem while
   // waiting for the test program, we know that the parsing has most likely
   // failed and therefore the error with the program is more important for
   // reporting purposes.

   int status; bool timed_out;
   error = kyua_run_wait(pid, &status, &timed_out);
   if (kyua_error_is_set(error))
       goto out_tmp_output;
   if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS) {
       error = kyua_generic_error_new("Test program list did not return "
                                      "success");
       goto out_tmp_output;
   }

   error = kyua_error_subsume(error, parse_error);
   if (!kyua_error_is_set(error)) {
       rewind(tmp_output);
       error = dump_file(tmp_output, stdout);
   }

out_tmp_output:
   fclose(tmp_output);
out_stdout_fds:
   if (stdout_fds[0] != -1)
       close(stdout_fds[0]);
   if (stdout_fds[1] != -1)
       close(stdout_fds[1]);
out_work_directory:
   error = kyua_error_subsume(error,
       kyua_run_work_directory_leave(&work_directory));
out:
   return error;
}


/// Counts the length of a user variables array.
///
/// \param user_variables The array of elements to be counted.
///
/// \return The length of the array.
static size_t
count_variables(const char* const user_variables[])
{
   size_t count = 0;
   const char* const* iter;
   for (iter = user_variables; *iter != NULL; ++iter)
       count++;
   return count;
}


static void exec_body(const char* test_program, const char* test_case,
                     const char* result_file,
                     const char* const user_variables[]) KYUA_DEFS_NORETURN;


/// Executes the body of a test case.
///
/// \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.
static void
exec_body(const char* test_program, const char* test_case,
         const char* result_file, const char* const user_variables[])
{
   const size_t nargs =
       1 /* test_program */ +
       2 /* -r result_file */
       + 2 * count_variables(user_variables) /* -v name=value */
       + 1 /* test_case */ +
       1 /* NULL */;

   const char** args = malloc(sizeof(const char*) * nargs);
   if (args == NULL)
       kyua_error_err(EXIT_FAILURE, kyua_oom_error_new(),
                      "Failed to construct arguments list");

   size_t i = 0;
   args[i++] = test_program;
   args[i++] = "-r";
   args[i++] = result_file;
   const char* const* iter;
   for (iter = user_variables; *iter != NULL; ++iter) {
       args[i++] = "-v";
       args[i++] = *iter;
   }
   args[i++] = test_case;
   args[i++] = NULL;
   assert(i == nargs);

   kyua_run_exec(test_program, args);
}


/// 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;
}


static void exec_cleanup(const char* test_program, const char* test_case,
                        const char* const user_variables[]) KYUA_DEFS_NORETURN;


/// Executes the cleanup of a test case.
///
/// \param test_program Path to the test program to execute.
/// \param test_case Name of the test case to run.
/// \param user_variables Set of configuration variables to pass to the test.
static void
exec_cleanup(const char* test_program, const char* test_case,
            const char* const user_variables[])
{
   char* name;
   kyua_error_t error = kyua_text_printf(&name, "%s:cleanup", test_case);
   if (kyua_error_is_set(error))
       kyua_error_err(EXIT_FAILURE, error,
                      "Failed to construct argument list");

   const size_t nargs =
       1 /* test_program */ +
       + 2 * count_variables(user_variables) /* -v name=value */
       + 1 /* test_case */ +
       1 /* NULL */;

   const char** args = malloc(sizeof(const char*) * nargs);
   if (args == NULL)
       kyua_error_err(EXIT_FAILURE, kyua_oom_error_new(),
                      "Failed to construct arguments list");

   size_t i = 0;
   args[i++] = test_program;
   const char* const* iter;
   for (iter = user_variables; *iter != NULL; ++iter) {
       args[i++] = "-v";
       args[i++] = *iter;
   }
   args[i++] = name;
   args[i++] = NULL;
   assert(i == nargs);

   kyua_run_exec(test_program, args);
}


/// Forks and executes the cleanup 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 created by the body of the
///     test case.  The cleanup may update such file if it fails.
/// \param user_variables Set of configuration variables to pass to the test.
/// \param run_params Settings to control the subprocess.
/// \param body_success The success value returned by run_body().
/// \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 cleanup is denoted by setting success to false on exit, not by
/// returning an error.
static kyua_error_t
run_cleanup(const char* test_program, const char* test_case,
           const char* result_file, const char* const user_variables[],
           const kyua_run_params_t* run_params, const bool body_success,
           bool* success)
{
   kyua_error_t error;

   pid_t pid;
   error = kyua_run_fork(run_params, &pid);
   if (!kyua_error_is_set(error) && pid == 0) {
       exec_cleanup(test_program, test_case, user_variables);
   }
   assert(pid != -1 && pid != 0);
   if (kyua_error_is_set(error))
       goto out;

   int status; bool timed_out;
   error = kyua_run_wait(pid, &status, &timed_out);
   if (kyua_error_is_set(error))
       goto out;

   if (WIFSIGNALED(status) && WCOREDUMP(status)) {
       kyua_stacktrace_dump(test_program, pid, run_params, stderr);
   }

   if (body_success) {
       // If the body has reported a successful result, we inspect the status
       // of the cleanup routine.  If the cleanup has failed, then we need to
       // mark the test as broken.  However, if the body itself had failed, we
       // don't do this to give preference to the original result, which is
       // probably more informative.
       error = kyua_atf_result_cleanup_rewrite(result_file, status,
                                               timed_out, success);
   }

out:
   return error;
}


/// Checks if the user variables indicate that a test has a cleanup routine.
///
/// This is an ugly hack to allow us to run the cleanup routine only when a test
/// case has it.  When Kyua invokes the tester to generate the test case list,
/// the tester tells Kyua which tests have a cleanup routine.  However, when the
/// tests are later run from here (as a different invocation) we cannot know if
/// the test had a cleanup routine or not.  We rely on Kyua telling us this fact
/// by specifying has.cleanup=true in the variables.
///
/// \param user_variables Array of name=value pairs that describe the user
///     configuration variables for the test case.
static bool
has_cleanup(const char* const* user_variables)
{
   const char* const* iter;
   for (iter = user_variables; *iter != NULL; ++iter) {
       if (strcmp(*iter, "has.cleanup=false") == 0)
           return false;
   }

   // The default is true because not running a cleanup routine when it exists
   // is worse than running an empty routine when not told to do so.
   return true;
}


/// Runs a single test cases of a test program.
///
/// \param test_program Path to the test program for which to list the test
///     cases.  Should be absolute.
/// \param test_case Name of the test case to run.
/// \param result_file Path to the file to which to write the result of the
///     test.  Should be absolute.
/// \param user_variables Array of name=value pairs that describe the user
///     configuration variables for the test case.
/// \param run_params Execution parameters to configure the test process.
/// \param [out] success Set to true if the test case reported a valid exit
///     condition (like "passed" or "skipped"); false otherwise.  This is
///     only updated if the method returns OK.
///
/// \return An error if the listing fails; OK otherwise.
static kyua_error_t
run_test_case(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* work_directory;
   error = kyua_run_work_directory_enter(WORKDIR_TEMPLATE,
                                         run_params->unprivileged_user,
                                         run_params->unprivileged_group,
                                         &work_directory);
   if (kyua_error_is_set(error))
       goto out;
   kyua_run_params_t real_run_params = *run_params;
   real_run_params.work_directory = work_directory;

   error = run_body(test_program, test_case, result_file, user_variables,
                    &real_run_params, success);
   if (has_cleanup(user_variables)) {
       error = run_cleanup(test_program, test_case, result_file,
                           user_variables, &real_run_params, *success,
                           success);
   }

   error = kyua_error_subsume(error,
       kyua_run_work_directory_leave(&work_directory));
out:
   return error;
}


/// Definition of the tester.
static kyua_cli_tester_t atf_tester = {
   .list_test_cases = list_test_cases,
   .run_test_case = run_test_case,
};


/// Tester entry point.
///
/// \param argc Number of command line arguments.
/// \param argv NULL-terminated array of command line arguments.
///
/// \return An exit code.
int
main(const int argc, char* const* const argv)
{
   return kyua_cli_main(argc, argv, &atf_tester);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.