ATF_TC_BODY(usage_error_format__plain, tc)
{
kyua_error_t error = kyua_usage_error_new("Test message");
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_STREQ("Test message", buffer);
kyua_error_free(error);
}
ATF_TC_BODY(usage_error_format__args, tc)
{
kyua_error_t error = kyua_usage_error_new("%s message %d", "A", 123);
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_STREQ("A message 123", buffer);
kyua_error_free(error);
}
ATF_TC_BODY(error_format__custom__error, tc)
{
kyua_error_t error = kyua_error_new("test_error", NULL, 0, test_format);
char buffer[5];
ATF_REQUIRE(kyua_error_format(error, buffer, sizeof(buffer))
>= (int)sizeof(buffer));
kyua_error_free(error);
}
ATF_TC_BODY(oom_error_format, tc)
{
kyua_error_t error = kyua_oom_error_new();
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_STREQ("Not enough memory", buffer);
kyua_error_free(error);
}
ATF_TC_BODY(error_format__default, tc)
{
kyua_error_t error = kyua_error_new("test_error", NULL, 0, NULL);
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_STREQ("Error 'test_error'", buffer);
kyua_error_free(error);
}
ATF_TC_BODY(libc_error_format__args, tc)
{
kyua_error_t error = kyua_libc_error_new(EPERM, "%s message %d", "A", 123);
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE(strstr(buffer, strerror(EPERM)) != NULL);
ATF_REQUIRE(strstr(buffer, "A message 123") != NULL);
kyua_error_free(error);
}
ATF_TC_BODY(libc_error_format__plain, tc)
{
kyua_error_t error = kyua_libc_error_new(ENOMEM, "Test message");
char buffer[1024];
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE(strstr(buffer, strerror(ENOMEM)) != NULL);
ATF_REQUIRE(strstr(buffer, "Test message") != NULL);
kyua_error_free(error);
}
ATF_TC_BODY(error_format__custom__ok, tc)
{
kyua_error_t error = kyua_error_new("test_error", NULL, 0, test_format);
const char* exp_message = "Test formatting function";
char buffer[1024];
ATF_REQUIRE_EQ((int)strlen(exp_message),
kyua_error_format(error, buffer, sizeof(buffer)));
ATF_REQUIRE_STREQ(exp_message, buffer);
kyua_error_free(error);
}
ATF_TC_BODY(fgets_error__libc_error, tc)
{
atf_utils_create_file("test.txt", "Some line\n");
char buffer[1024];
FILE* input = fopen("test.txt", "w");
ATF_REQUIRE(kyua_text_fgets_no_newline(buffer, sizeof(buffer), input)
== NULL);
kyua_error_t error = kyua_text_fgets_error(input, "Foo bar");
ATF_REQUIRE(kyua_error_is_set(error));
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_MATCH("^Foo bar: .*", buffer);
kyua_error_free(error);
fclose(input);
}
ATF_TC_BODY(fgets_error__unexpected_eof, tc)
{
atf_utils_create_file("test.txt", "Some line\n");
char buffer[1024];
FILE* input = fopen("test.txt", "r");
ATF_REQUIRE(kyua_text_fgets_no_newline(buffer, sizeof(buffer), input)
== buffer);
ATF_REQUIRE_STREQ("Some line", buffer);
ATF_REQUIRE(kyua_text_fgets_no_newline(buffer, sizeof(buffer), input)
== NULL);
kyua_error_t error = kyua_text_fgets_error(input, "Foo bar");
ATF_REQUIRE(kyua_error_is_set(error));
kyua_error_format(error, buffer, sizeof(buffer));
ATF_REQUIRE_STREQ("Foo bar: unexpected EOF", buffer);
kyua_error_free(error);
fclose(input);
}
/// Writes a generic result file based on an ATF result file and an exit code.
///
/// \param input_name Path to the ATF result file to parse.
/// \param output_name Path to the generic result file to create.
/// \param wait_status Exit code of the test program as returned by wait().
/// \param timed_out Whether the test program timed out or not.
/// \param [out] success Whether the result should be considered a success or
/// not; e.g. passed and skipped are successful, but failed is not.
///
/// \return An error if the conversion fails; OK otherwise.
kyua_error_t
kyua_atf_result_rewrite(const char* input_name, const char* output_name,
const int wait_status, const bool timed_out,
bool* success)
{
enum atf_status status; int status_arg; char reason[1024];
status = ATF_STATUS_BROKEN; // Initialize to shut up gcc warning.
const kyua_error_t error = read_atf_result(input_name, &status, &status_arg,
reason, sizeof(reason));
if (kyua_error_is_set(error)) {
// Errors while parsing the ATF result file can often be attributed to
// the result file being bogus. Therefore, just mark the test case as
// broken, because it possibly is.
status = ATF_STATUS_BROKEN;
kyua_error_format(error, reason, sizeof(reason));
kyua_error_free(error);
}
// Errors converting the loaded result to the final result file are not due
// to a bad test program: they are because our own code fails (e.g. cannot
// create the output file). These need to be returned to the caller.
return convert_result(status, status_arg, reason, wait_status, timed_out,
output_name, success);
}
