static
void
check_prepend(atf_error_t (*prepend)(atf_dynstr_t *, const char *, ...))
{
const size_t maxlen = 8192;
char buf[maxlen + 1];
size_t i;
atf_dynstr_t str;
printf("Prepending with plain string\n");
buf[0] = '\0';
RE(atf_dynstr_init(&str));
for (i = 0; i < maxlen; i++) {
if (strcmp(atf_dynstr_cstring(&str), buf) != 0) {
fprintf(stderr, "Failed at iteration %zd\n", i);
atf_tc_fail("Failed to prepend character at iteration %zd", i);
}
memmove(buf + 1, buf, i + 1);
if (i % 2 == 0) {
RE(prepend(&str, "%s", "a"));
buf[0] = 'a';
} else {
RE(prepend(&str, "%s", "b"));
buf[0] = 'b';
}
}
atf_dynstr_fini(&str);
printf("Prepending with formatted string\n");
buf[0] = '\0';
RE(atf_dynstr_init(&str));
for (i = 0; i < maxlen; i++) {
if (strcmp(atf_dynstr_cstring(&str), buf) != 0) {
fprintf(stderr, "Failed at iteration %zd\n", i);
atf_tc_fail("Failed to prepend character at iteration %zd", i);
}
memmove(buf + 1, buf, i + 1);
if (i % 2 == 0) {
RE(prepend(&str, "%s", "a"));
buf[0] = 'a';
} else {
RE(prepend(&str, "%s", "b"));
buf[0] = 'b';
}
}
atf_dynstr_fini(&str);
}
static
atf_error_t
normalize_ap(atf_dynstr_t *d, const char *p, va_list ap)
{
char *str;
atf_error_t err;
va_list ap2;
err = atf_dynstr_init(d);
if (atf_is_error(err))
goto out;
va_copy(ap2, ap);
err = atf_text_format_ap(&str, p, ap2);
va_end(ap2);
if (atf_is_error(err))
atf_dynstr_fini(d);
else {
err = normalize(d, str);
free(str);
}
out:
return err;
}
bool
grep_file(const char *file, const char *regex, ...)
{
bool done, found;
int fd;
va_list ap;
atf_dynstr_t formatted;
va_start(ap, regex);
RE(atf_dynstr_init_ap(&formatted, regex, ap));
va_end(ap);
done = false;
found = false;
ATF_REQUIRE((fd = open(file, O_RDONLY)) != -1);
do {
atf_dynstr_t line;
RE(atf_dynstr_init(&line));
done = read_line(fd, &line);
if (!done)
found = grep_string(&line, atf_dynstr_cstring(&formatted));
atf_dynstr_fini(&line);
} while (!found && !done);
close(fd);
atf_dynstr_fini(&formatted);
return found;
}
static void capture_stream_init (void *v)
{
struct capture_stream *s = v;
s->m_base.m_sb_ptr = &s->m_base.m_sb;
RE (atf_process_stream_init_capture (&s->m_base.m_sb));
RE (atf_dynstr_init (&s->m_msg));
}
ATF_TC_BODY(init, tc)
{
atf_dynstr_t str;
RE(atf_dynstr_init(&str));
ATF_REQUIRE_EQ(atf_dynstr_length(&str), 0);
ATF_REQUIRE(strcmp(atf_dynstr_cstring(&str), "") == 0);
atf_dynstr_fini(&str);
}
ATF_TC_BODY(equal_dynstr, tc)
{
atf_dynstr_t str, str2;
RE(atf_dynstr_init(&str));
RE(atf_dynstr_init_fmt(&str2, "Test"));
ATF_REQUIRE( atf_equal_dynstr_dynstr(&str, &str));
ATF_REQUIRE(!atf_equal_dynstr_dynstr(&str, &str2));
atf_dynstr_fini(&str2);
atf_dynstr_fini(&str);
}
static
void
check_line(int fd, const char *exp)
{
atf_dynstr_t line;
atf_dynstr_init(&line);
ATF_CHECK(!read_line(fd, &line));
ATF_CHECK_MSG(atf_equal_dynstr_cstring(&line, exp),
"read: '%s', expected: '%s'",
atf_dynstr_cstring(&line), exp);
atf_dynstr_fini(&line);
}
static
void
check_append(atf_error_t (*append)(atf_dynstr_t *, const char *, ...))
{
const size_t maxlen = 8192;
char buf[maxlen + 1];
size_t i;
atf_dynstr_t str;
printf("Appending with plain string\n");
buf[0] = '\0';
RE(atf_dynstr_init(&str));
for (i = 0; i < maxlen; i++) {
if (strcmp(atf_dynstr_cstring(&str), buf) != 0) {
fprintf(stderr, "Failed at iteration %zd\n", i);
atf_tc_fail("Failed to append character at iteration %zd", i);
}
RE(append(&str, "a"));
strcat(buf, "a");
}
atf_dynstr_fini(&str);
printf("Appending with formatted string\n");
buf[0] = '\0';
RE(atf_dynstr_init(&str));
for (i = 0; i < maxlen; i++) {
if (strcmp(atf_dynstr_cstring(&str), buf) != 0) {
fprintf(stderr, "Failed at iteration %zd\n", i);
atf_tc_fail("Failed to append character at iteration %zd", i);
}
RE(append(&str, "%s", "a"));
strcat(buf, "a");
}
atf_dynstr_fini(&str);
}
ATF_TC_BODY(equal_cstring, tc)
{
atf_dynstr_t str;
RE(atf_dynstr_init(&str));
ATF_REQUIRE( atf_equal_dynstr_cstring(&str, ""));
ATF_REQUIRE(!atf_equal_dynstr_cstring(&str, "Test"));
atf_dynstr_fini(&str);
RE(atf_dynstr_init_fmt(&str, "Test"));
ATF_REQUIRE( atf_equal_dynstr_cstring(&str, "Test"));
ATF_REQUIRE(!atf_equal_dynstr_cstring(&str, ""));
ATF_REQUIRE(!atf_equal_dynstr_cstring(&str, "Tes"));
ATF_REQUIRE(!atf_equal_dynstr_cstring(&str, "Test "));
atf_dynstr_fini(&str);
}
ATF_TC_BODY(clear, tc)
{
atf_dynstr_t str;
printf("Clear an empty string\n");
RE(atf_dynstr_init(&str));
atf_dynstr_clear(&str);
ATF_REQUIRE_EQ(atf_dynstr_length(&str), 0);
ATF_REQUIRE(strcmp(atf_dynstr_cstring(&str), "") == 0);
atf_dynstr_fini(&str);
printf("Clear a non-empty string\n");
RE(atf_dynstr_init_fmt(&str, "Not empty"));
ATF_REQUIRE_EQ(atf_dynstr_length(&str), strlen("Not empty"));
ATF_REQUIRE(strcmp(atf_dynstr_cstring(&str), "Not empty") == 0);
atf_dynstr_clear(&str);
ATF_REQUIRE_EQ(atf_dynstr_length(&str), 0);
ATF_REQUIRE(strcmp(atf_dynstr_cstring(&str), "") == 0);
atf_dynstr_fini(&str);
}
/** Reads a line of arbitrary length.
*
* \param fd The descriptor from which to read the line.
*
* \return A pointer to the read line, which must be released with free(), or
* NULL if there was nothing to read from the file. */
char *
atf_utils_readline(const int fd)
{
char ch;
ssize_t cnt;
atf_dynstr_t temp;
atf_error_t error;
error = atf_dynstr_init(&temp);
ATF_REQUIRE(!atf_is_error(error));
while ((cnt = read(fd, &ch, sizeof(ch))) == sizeof(ch) &&
ch != '\n') {
error = atf_dynstr_append_fmt(&temp, "%c", ch);
ATF_REQUIRE(!atf_is_error(error));
}
ATF_REQUIRE(cnt != -1);
if (cnt == 0 && atf_dynstr_length(&temp) == 0) {
atf_dynstr_fini(&temp);
return NULL;
} else
return atf_dynstr_fini_disown(&temp);
}
ATF_TC_BODY(read_line, tc)
{
const char *l1 = "First line with % formatting % characters %";
const char *l2 = "Second line; much longer than the first one";
const char *l3 = "Last line, without terminator";
{
FILE *f;
f = fopen("test", "w");
ATF_REQUIRE(f != NULL);
fclose(f);
}
{
int fd;
atf_dynstr_t dest;
bool eof;
fd = open("test", O_RDONLY);
ATF_REQUIRE(fd != -1);
RE(atf_dynstr_init(&dest));
eof = read_line(fd, &dest);
ATF_REQUIRE(eof);
atf_dynstr_fini(&dest);
}
{
FILE *f;
f = fopen("test", "w");
ATF_REQUIRE(f != NULL);
fprintf(f, "%s\n", l1);
fprintf(f, "%s\n", l2);
fprintf(f, "%s", l3);
fclose(f);
}
{
int fd;
atf_dynstr_t dest;
bool eof;
fd = open("test", O_RDONLY);
ATF_REQUIRE(fd != -1);
RE(atf_dynstr_init(&dest));
eof = read_line(fd, &dest);
ATF_REQUIRE(!eof);
printf("1st line: >%s<\n", atf_dynstr_cstring(&dest));
ATF_REQUIRE(atf_equal_dynstr_cstring(&dest, l1));
atf_dynstr_fini(&dest);
RE(atf_dynstr_init(&dest));
eof = read_line(fd, &dest);
ATF_REQUIRE(!eof);
printf("2nd line: >%s<\n", atf_dynstr_cstring(&dest));
ATF_REQUIRE(atf_equal_dynstr_cstring(&dest, l2));
atf_dynstr_fini(&dest);
RE(atf_dynstr_init(&dest));
eof = read_line(fd, &dest);
ATF_REQUIRE(eof);
printf("3rd line: >%s<\n", atf_dynstr_cstring(&dest));
ATF_REQUIRE(atf_equal_dynstr_cstring(&dest, l3));
atf_dynstr_fini(&dest);
close(fd);
}
}
