pintos-os.org Git - pintos-anon/blob - src/tests/lib.c

   1 #include "tests/lib.h"
   2 #include <random.h>
   3 #include <stdarg.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <syscall.h>
   7
   8 const char *test_name;
   9 bool quiet = false;
  10
  11 static void
  12 vmsg (const char *format, va_list args, const char *suffix)
  13 {
  14   /* We go to some trouble to stuff the entire message into a
  15      single buffer and output it in a single system call, because
  16      that'll (typically) ensure that it gets sent to the console
  17      atomically.  Otherwise kernel messages like "foo: exit(0)"
  18      can end up being interleaved if we're unlucky. */
  19   static char buf[1024];
  20
  21   snprintf (buf, sizeof buf, "(%s) ", test_name);
  22   vsnprintf (buf + strlen (buf), sizeof buf - strlen (buf), format, args);
  23   strlcpy (buf + strlen (buf), suffix, sizeof buf - strlen (buf));
  24   write (STDOUT_FILENO, buf, strlen (buf));
  25 }
  26
  27 void
  28 msg (const char *format, ...)
  29 {
  30   va_list args;
  31
  32   if (quiet)
  33     return;
  34   va_start (args, format);
  35   vmsg (format, args, "\n");
  36   va_end (args);
  37 }
  38
  39 void
  40 fail (const char *format, ...)
  41 {
  42   va_list args;
  43
  44   va_start (args, format);
  45   vmsg (format, args, ": FAILED\n");
  46   va_end (args);
  47
  48   exit (1);
  49 }
  50
  51 static void
  52 swap (void *a_, void *b_, size_t size)
  53 {
  54   uint8_t *a = a_;
  55   uint8_t *b = b_;
  56   size_t i;
  57
  58   for (i = 0; i < size; i++)
  59     {
  60       uint8_t t = a[i];
  61       a[i] = b[i];
  62       b[i] = t;
  63     }
  64 }
  65
  66 void
  67 shuffle (void *buf_, size_t cnt, size_t size)
  68 {
  69   char *buf = buf_;
  70   size_t i;
  71
  72   for (i = 0; i < cnt; i++)
  73     {
  74       size_t j = i + random_ulong () % (cnt - i);
  75       swap (buf + i * size, buf + j * size, size);
  76     }
  77 }
  78
  79 void
  80 exec_children (const char *child_name, pid_t pids[], size_t child_cnt)
  81 {
  82   size_t i;
  83
  84   for (i = 0; i < child_cnt; i++)
  85     {
  86       char cmd_line[128];
  87       snprintf (cmd_line, sizeof cmd_line, "%s %zu", child_name, i);
  88       CHECK ((pids[i] = exec (cmd_line)) != PID_ERROR,
  89              "exec child %zu of %zu: \"%s\"", i + 1, child_cnt, cmd_line);
  90     }
  91 }
  92
  93 void
  94 wait_children (pid_t pids[], size_t child_cnt)
  95 {
  96   size_t i;
  97
  98   for (i = 0; i < child_cnt; i++)
  99     {
 100       int status = wait (pids[i]);
 101       CHECK (status == (int) i,
 102              "wait for child %zu of %zu returned %d (expected %zu)",
 103              i + 1, child_cnt, status, i);
 104     }
 105 }
 106
 107 void
 108 check_file_handle (int fd,
 109                    const char *file_name, const void *buf_, size_t size)
 110 {
 111   const char *buf = buf_;
 112   size_t ofs = 0;
 113   size_t file_size;
 114
 115   /* Warn about file of wrong size.  Don't fail yet because we
 116      may still be able to get more information by reading the
 117      file. */
 118   file_size = filesize (fd);
 119   if (file_size != size)
 120     msg ("size of %s (%zu) differs from expected (%zu)",
 121           file_name, file_size, size);
 122
 123   /* Read the file block-by-block, comparing data as we go. */
 124   while (ofs < size)
 125     {
 126       char block[512];
 127       size_t block_size, ret_val;
 128
 129       block_size = size - ofs;
 130       if (block_size > sizeof block)
 131         block_size = sizeof block;
 132
 133       ret_val = read (fd, block, block_size);
 134       if (ret_val != block_size)
 135         fail ("read of %zu bytes at offset %zu in \"%s\" returned %zu",
 136               block_size, ofs, file_name, ret_val);
 137
 138       compare_bytes (block, buf + ofs, block_size, ofs, file_name);
 139       ofs += block_size;
 140     }
 141
 142   /* Now fail due to wrong file size. */
 143   if (file_size != size)
 144     fail ("size of %s (%zu) differs from expected (%zu)",
 145           file_name, file_size, size);
 146
 147   msg ("verified contents of \"%s\"", file_name);
 148 }
 149
 150 void
 151 check_file (const char *file_name, const void *buf, size_t size)
 152 {
 153   int fd;
 154
 155   CHECK ((fd = open (file_name)) > 1, "open \"%s\" for verification",
 156          file_name);
 157   check_file_handle (fd, file_name, buf, size);
 158   msg ("close \"%s\"", file_name);
 159   close (fd);
 160 }
 161
 162 void
 163 compare_bytes (const void *read_data_, const void *expected_data_, size_t size,
 164                size_t ofs, const char *file_name)
 165 {
 166   const uint8_t *read_data = read_data_;
 167   const uint8_t *expected_data = expected_data_;
 168   size_t i, j;
 169   size_t show_cnt;
 170
 171   if (!memcmp (read_data, expected_data, size))
 172     return;
 173
 174   for (i = 0; i < size; i++)
 175     if (read_data[i] != expected_data[i])
 176       break;
 177   for (j = i + 1; j < size; j++)
 178     if (read_data[j] == expected_data[j])
 179       break;
 180
 181   quiet = false;
 182   msg ("%zu bytes read starting at offset %zu in \"%s\" differ "
 183        "from expected.", j - i, ofs + i, file_name);
 184   show_cnt = j - i;
 185   if (j - i > 64)
 186     {
 187       show_cnt = 64;
 188       msg ("Showing first differing %zu bytes.", show_cnt);
 189     }
 190   msg ("Data actually read:");
 191   hex_dump (ofs + i, read_data + i, show_cnt, true);
 192   msg ("Expected data:");
 193   hex_dump (ofs + i, expected_data + i, show_cnt, true);
 194   fail ("%zu bytes read starting at offset %zu in \"%s\" differ "
 195         "from expected", j - i, ofs + i, file_name);
 196 }