CS代考计算机代写 #include “tests/lib.h”

#include “tests/lib.h”
#include
#include
#include
#include
#include

const char *test_name;
bool quiet = false;

static void
vmsg (const char *format, va_list args, const char *suffix)
{
/* We go to some trouble to stuff the entire message into a
single buffer and output it in a single system call, because
that’ll (typically) ensure that it gets sent to the console
atomically. Otherwise kernel messages like “foo: exit(0)”
can end up being interleaved if we’re unlucky. */
static char buf[1024];

snprintf (buf, sizeof buf, “(%s) “, test_name);
vsnprintf (buf + strlen (buf), sizeof buf – strlen (buf), format, args);
strlcpy (buf + strlen (buf), suffix, sizeof buf – strlen (buf));
write (STDOUT_FILENO, buf, strlen (buf));
}

void
msg (const char *format, …)
{
va_list args;

if (quiet)
return;
va_start (args, format);
vmsg (format, args, “\n”);
va_end (args);
}

void
fail (const char *format, …)
{
va_list args;

va_start (args, format);
vmsg (format, args, “: FAILED\n”);
va_end (args);

exit (1);
}

static void
swap (void *a_, void *b_, size_t size)
{
uint8_t *a = a_;
uint8_t *b = b_;
size_t i;

for (i = 0; i < size; i++) { uint8_t t = a[i]; a[i] = b[i]; b[i] = t; } } void shuffle (void *buf_, size_t cnt, size_t size) { char *buf = buf_; size_t i; for (i = 0; i < cnt; i++) { size_t j = i + random_ulong () % (cnt - i); swap (buf + i * size, buf + j * size, size); } } void exec_children (const char *child_name, pid_t pids[], size_t child_cnt) { size_t i; for (i = 0; i < child_cnt; i++) { char cmd_line[128]; snprintf (cmd_line, sizeof cmd_line, "%s %zu", child_name, i); CHECK ((pids[i] = exec (cmd_line)) != PID_ERROR, "exec child %zu of %zu: \"%s\"", i + 1, child_cnt, cmd_line); } } void wait_children (pid_t pids[], size_t child_cnt) { size_t i; for (i = 0; i < child_cnt; i++) { int status = wait (pids[i]); CHECK (status == (int) i, "wait for child %zu of %zu returned %d (expected %zu)", i + 1, child_cnt, status, i); } } void check_file_handle (int fd, const char *file_name, const void *buf_, size_t size) { const char *buf = buf_; size_t ofs = 0; size_t file_size; /* Warn about file of wrong size. Don't fail yet because we may still be able to get more information by reading the file. */ file_size = filesize (fd); if (file_size != size) msg ("size of %s (%zu) differs from expected (%zu)", file_name, file_size, size); /* Read the file block-by-block, comparing data as we go. */ while (ofs < size) { char block[512]; size_t block_size, ret_val; block_size = size - ofs; if (block_size > sizeof block)
block_size = sizeof block;

ret_val = read (fd, block, block_size);
if (ret_val != block_size)
fail (“read of %zu bytes at offset %zu in \”%s\” returned %zu”,
block_size, ofs, file_name, ret_val);

compare_bytes (block, buf + ofs, block_size, ofs, file_name);
ofs += block_size;
}

/* Now fail due to wrong file size. */
if (file_size != size)
fail (“size of %s (%zu) differs from expected (%zu)”,
file_name, file_size, size);

msg (“verified contents of \”%s\””, file_name);
}

void
check_file (const char *file_name, const void *buf, size_t size)
{
int fd;

CHECK ((fd = open (file_name)) > 1, “open \”%s\” for verification”,
file_name);
check_file_handle (fd, file_name, buf, size);
msg (“close \”%s\””, file_name);
close (fd);
}

void
compare_bytes (const void *read_data_, const void *expected_data_, size_t size,
size_t ofs, const char *file_name)
{
const uint8_t *read_data = read_data_;
const uint8_t *expected_data = expected_data_;
size_t i, j;
size_t show_cnt;

if (!memcmp (read_data, expected_data, size))
return;

for (i = 0; i < size; i++) if (read_data[i] != expected_data[i]) break; for (j = i + 1; j < size; j++) if (read_data[j] == expected_data[j]) break; quiet = false; msg ("%zu bytes read starting at offset %zu in \"%s\" differ " "from expected.", j - i, ofs + i, file_name); show_cnt = j - i; if (j - i > 64)
{
show_cnt = 64;
msg (“Showing first differing %zu bytes.”, show_cnt);
}
msg (“Data actually read:”);
hex_dump (ofs + i, read_data + i, show_cnt, true);
msg (“Expected data:”);
hex_dump (ofs + i, expected_data + i, show_cnt, true);
fail (“%zu bytes read starting at offset %zu in \”%s\” differ ”
“from expected”, j – i, ofs + i, file_name);
}