test/rwverify.c

   1 #include <exec/types.h>
   2 #include <dos/dosextens.h>
   3 #include <dos/bptr.h>
   4 #include <proto/exec.h>
   5 #include <proto/dos.h>
   6 #include <stdio.h>
   7
   8 #define CHUNK 16
   9
  10 void hexdump(UBYTE *buf, int size) {
  11     int i,j;
  12     int count;
  13
  14     for (i = 0; i < size; i += CHUNK) {
  15         printf("0x%06x    ", i);
  16
  17         count = ((size-i) > CHUNK ? CHUNK : size-i);
  18
  19         for (j = 0; j < count; j++) {
  20             if (j == CHUNK / 2) fputc(' ', stdout);
  21             printf("%02x ", buf[i+j]);
  22         }
  23
  24         for (j = count; j < CHUNK; j++) {
  25             if (j == CHUNK / 2) fputc(' ', stdout);
  26             fputs("     ", stdout);
  27         }
  28
  29         fputc('\n', stdout);
  30     }
  31 }
  32
  33 int round1(char *filename) {
  34     BPTR fh;
  35     UBYTE buf[1024];
  36     LONG bytes;
  37     int i, n;
  38
  39     fputs("\nround 1: 1024 buffers of 1024 bytes each\n\n", stdout);
  40
  41     fh = Open(filename, MODE_NEWFILE);
  42     if (fh == NULL) {
  43         printf("couldn't open '%s' for write (%ld)\n", filename, IoErr());
  44         return 1;
  45     }
  46
  47     printf("opened '%s' for write\n", filename);
  48
  49     fputs("writing... ", stdout);
  50     fflush(stdout);
  51
  52     for (n = 0; n < 1024; n++) {
  53         for (i = 0; i < 1024; i++)
  54             buf[i] = (i + n) & 0xff;
  55
  56         bytes = Write(fh, buf, 1024);
  57         if (bytes < 0) {
  58             printf("buffer %d: error (%ld)\n", n, IoErr());
  59             Close(fh);
  60             return 1;
  61         }
  62
  63         if (bytes < 1024) {
  64             printf("buffer %d: short write! error is %ld\n", n, IoErr());
  65             Close(fh);
  66             return 1;
  67         }
  68     }
  69
  70     fputs("1024 buffers written\n", stdout);
  71
  72     Close(fh);
  73
  74     fh = Open(filename, MODE_OLDFILE);
  75     if (fh == NULL) {
  76         printf("couldn't open '%s' for read (%ld)\n", filename, IoErr());
  77         return 1;
  78     }
  79
  80     printf("opened '%s' for read\n", filename);
  81
  82     fputs("reading... ", stdout);
  83     fflush(stdout);
  84
  85     for (n = 0; n < 1024; n++) {
  86         bytes = Read(fh, buf, 1024);
  87         if (bytes < 0) {
  88             printf("buffer %d: error (%ld)\n", n, IoErr());
  89             Close(fh);
  90             return 1;
  91         }
  92         if (bytes < 1024) {
  93             printf("buffer %d: short read! error is %ld\n", n, IoErr());
  94             Close(fh);
  95             return 1;
  96         }
  97
  98         for (i = 0; i < 1024; i++)
  99             if (buf[i] != ((i + n) & 0xff)) {
 100                 printf("buffer %d: verify error!\n  file pos %d, expected 0x%02x, got 0x%02x\n", n, n * 1024 + i, ((i + n) & 0xff), buf[i]);
 101                 printf("buffer dump (0x%02x bytes):\n", 1024);
 102                 hexdump(buf, 1024);
 103                 Close(fh);
 104                 return 1;
 105             }
 106     }
 107
 108     fputs("1024 buffers read and verified\n", stdout);
 109
 110     Close(fh);
 111
 112     DeleteFile(filename);
 113
 114     fputs("cleaned up\n", stdout);
 115
 116     return 0;
 117 }
 118
 119 int round2(char *filename) {
 120     BPTR fh;
 121     UBYTE buf[1024];
 122     LONG bytes;
 123     int i, n;
 124
 125     fputs("\nround 2: 8192 buffers, increasing length from 0-1023 bytes\n\n", stdout);
 126
 127     fh = Open(filename, MODE_NEWFILE);
 128     if (fh == NULL) {
 129         printf("couldn't open '%s' for write (%ld)\n", filename, IoErr());
 130         return 1;
 131     }
 132
 133     printf("opened '%s' for write\n", filename);
 134
 135     fputs("writing... ", stdout);
 136     fflush(stdout);
 137
 138     for (n = 0; n < 8192; n++) {
 139         for (i = 0; i < (n & 1023); i++)
 140             buf[i] = (i + n) & 0xff;
 141
 142         bytes = Write(fh, buf, (n & 1023));
 143         if (bytes < 0) {
 144             printf("buffer %d: error (%ld)\n", n, IoErr());
 145             Close(fh);
 146             return 1;
 147         }
 148
 149         if (bytes < (n & 1023)) {
 150             printf("buffer %d: short write! error is %ld\n", n, IoErr());
 151             Close(fh);
 152             return 1;
 153         }
 154     }
 155
 156     fputs("1024 buffers written\n", stdout);
 157
 158     Close(fh);
 159
 160     fh = Open(filename, MODE_OLDFILE);
 161     if (fh == NULL) {
 162         printf("couldn't open '%s' for read (%ld)\n", filename, IoErr());
 163         return 1;
 164     }
 165
 166     printf("opened '%s' for read\n", filename);
 167
 168     fputs("reading... ", stdout);
 169     fflush(stdout);
 170
 171     for (n = 0; n < 8192; n++) {
 172         bytes = Read(fh, buf, (n & 1023));
 173         if (bytes < 0) {
 174             printf("buffer %d: error (%ld)\n", n, IoErr());
 175             Close(fh);
 176             return 1;
 177         }
 178         if (bytes < (n & 1023)) {
 179             printf("buffer %d: short read! error is %ld\n", n, IoErr());
 180             Close(fh);
 181             return 1;
 182         }
 183
 184         for (i = 0; i < (n & 1023); i++)
 185             if (buf[i] != ((i + n) & 0xff)) {
 186                 printf("buffer %d: verify error!\n  file pos %d, expected 0x%02x, got 0x%02x\n", n, n * (n & 1023) + i, ((i + n) & 0xff), buf[i]);
 187                 printf("buffer dump (0x%02x bytes):\n", (n & 1023));
 188                 hexdump(buf, 1024);
 189                 Close(fh);
 190                 return 1;
 191             }
 192     }
 193
 194     fputs("8192 buffers read and verified\n", stdout);
 195
 196     Close(fh);
 197
 198     //DeleteFile(filename);
 199
 200     fputs("cleaned up\n", stdout);
 201
 202     return 0;
 203 }
 204
 205 int main(int argc, char **argv) {
 206     if (argc != 2) {
 207         printf("usage: %s filename\n", argv[0]);
 208         return 1;
 209     }
 210
 211     if (round1(argv[1]) || round2(argv[1]))
 212         return 1;
 213
 214     return 0;
 215 }