tests/lib/xwrite-t.c

   1 /* $Id: xwrite-t.c 5790 2002-09-30 01:05:09Z rra $ */
   2 /* Test suite for xwrite and xwritev. */
   3
   4 #include "config.h"
   5 #include "clibrary.h"
   6 #include <sys/uio.h>
   7
   8 #include "libinn.h"
   9
  10 /* The data array we'll use to do testing. */
  11 char data[256];
  12
  13 /* These come from fakewrite. */
  14 extern char write_buffer[];
  15 extern size_t write_offset;
  16 extern int write_interrupt;
  17 extern int write_fail;
  18
  19 static void
  20 test_write(int n, int status, int total)
  21 {
  22     int success;
  23
  24     success = (status == total && memcmp(data, write_buffer, 256) == 0);
  25     printf("%sok %d\n", success ? "" : "not ", n);
  26     if (!success && status != total)
  27         printf("  status %d, total %d\n", status, total);
  28 }
  29
  30 int
  31 main(void)
  32 {
  33     int i;
  34     struct iovec iov[4];
  35
  36     puts("19");
  37
  38     /* Test xwrite. */
  39     for (i = 0; i < 256; i++)
  40         data[i] = i;
  41     test_write(1, xwrite(0, data, 256), 256);
  42     write_offset = 0;
  43     write_interrupt = 1;
  44     memset(data, 0, 256);
  45     test_write(2, xwrite(0, data, 256), 256);
  46     write_offset = 0;
  47     for (i = 0; i < 32; i++)
  48         data[i] = i * 2;
  49     test_write(3, xwrite(0, data, 32), 32);
  50     for (i = 32; i < 65; i++)
  51         data[i] = i * 2;
  52     test_write(4, xwrite(0, data + 32, 33), 33);
  53     write_offset = 0;
  54     write_interrupt = 0;
  55
  56     /* Test xwritev. */
  57     memset(data, 0, 256);
  58     iov[0].iov_base = data;
  59     iov[0].iov_len = 256;
  60     test_write(5, xwritev(0, iov, 1), 256);
  61     write_offset = 0;
  62     for (i = 0; i < 256; i++)
  63         data[i] = i;
  64     iov[0].iov_len = 128;
  65     iov[1].iov_base = &data[128];
  66     iov[1].iov_len = 16;
  67     iov[2].iov_base = &data[144];
  68     iov[2].iov_len = 112;
  69     test_write(6, xwritev(0, iov, 3), 256);
  70     write_offset = 0;
  71     write_interrupt = 1;
  72     memset(data, 0, 256);
  73     iov[0].iov_len = 32;
  74     iov[1].iov_base = &data[32];
  75     iov[1].iov_len = 224;
  76     test_write(7, xwritev(0, iov, 2), 256);
  77     for (i = 0; i < 32; i++)
  78         data[i] = i * 2;
  79     write_offset = 0;
  80     test_write(8, xwritev(0, iov, 1), 32);
  81     for (i = 32; i < 65; i++)
  82         data[i] = i * 2;
  83     iov[0].iov_base = &data[32];
  84     iov[0].iov_len = 16;
  85     iov[1].iov_base = &data[48];
  86     iov[1].iov_len = 1;
  87     iov[2].iov_base = &data[49];
  88     iov[2].iov_len = 8;
  89     iov[3].iov_base = &data[57];
  90     iov[3].iov_len = 8;
  91     test_write(9, xwritev(0, iov, 4), 33);
  92     write_offset = 0;
  93     write_interrupt = 0;
  94
  95     /* Test xpwrite. */
  96     for (i = 0; i < 256; i++)
  97         data[i] = i;
  98     test_write(10, xpwrite(0, data, 256, 0), 256);
  99     write_interrupt = 1;
 100     memset(data + 1, 0, 255);
 101     test_write(11, xpwrite(0, data + 1, 255, 1), 255);
 102     for (i = 0; i < 32; i++)
 103         data[i + 32] = i * 2;
 104     test_write(12, xpwrite(0, data + 32, 32, 32), 32);
 105     for (i = 32; i < 65; i++)
 106         data[i + 32] = i * 2;
 107     test_write(13, xpwrite(0, data + 64, 33, 64), 33);
 108     write_interrupt = 0;
 109
 110     /* Test failures. */
 111     write_fail = 1;
 112     test_write(14, xwrite(0, data + 1, 255), -1);
 113     iov[0].iov_base = data + 1;
 114     iov[0].iov_len = 255;
 115     test_write(15, xwritev(0, iov, 1), -1);
 116     test_write(16, xpwrite(0, data + 1, 255, 0), -1);
 117
 118     /* Test zero-length writes. */
 119     test_write(17, xwrite(0, "   ", 0), 0);
 120     test_write(18, xpwrite(0, "   ", 0, 2), 0);
 121     iov[0].iov_base = data + 1;
 122     iov[0].iov_len = 2;
 123     test_write(19, xwritev(0, iov, 0), 0);
 124
 125     return 0;
 126 }