source: rtems/testsuites/psxtests/psxrdwrv/test.c @ 9b4422a2

4.11
Last change on this file since 9b4422a2 was 9b4422a2, checked in by Joel Sherrill <joel.sherrill@…>, on May 3, 2012 at 3:09:24 PM

Remove All CVS Id Strings Possible Using a Script

Script does what is expected and tries to do it as
smartly as possible.

+ remove occurrences of two blank comment lines

next to each other after Id string line removed.

+ remove entire comment blocks which only exited to

contain CVS Ids

+ If the processing left a blank line at the top of

a file, it was removed.

  • Property mode set to 100644
File size: 9.6 KB
Line 
1/*
2 *  This test exercises the following routines:
3 *
4 *    + readv
5 *    + writev
6 *
7 *  COPYRIGHT (c) 1989-2009.
8 *  On-Line Applications Research Corporation (OAR).
9 *
10 *  The license and distribution terms for this file may be
11 *  found in the file LICENSE in this distribution or at
12 *  http://www.rtems.com/license/LICENSE.
13 */
14
15
16#ifdef HAVE_CONFIG_H
17#include "config.h"
18#endif
19
20#include <fcntl.h>
21#include <unistd.h>
22#include <errno.h>
23#include <utime.h>
24#include <string.h>
25#include <inttypes.h>
26
27#include <stdio.h>
28#include <unistd.h>
29#include <sys/uio.h>
30
31#if defined(__rtems__)
32  #include <rtems.h>
33  #include <rtems/libio.h>
34  #include <pmacros.h>
35#else
36  #define TRUE  1
37  #define FALSE 0
38  #include <stdlib.h>
39  #define rtems_test_exit(_s) exit(_s)
40#endif
41
42#define TESTFILE "testfile1.tst"
43
44
45/* This buffer size is assumed in the iovec initialization below */
46#define MAX_BUFFER 1000
47unsigned char PatternBuffer[MAX_BUFFER];
48unsigned char ReadBuffer[MAX_BUFFER];
49
50/*
51 * fillPatternBuffer function
52 *
53 * Fill the test buffer.
54 *
55 * Returns: TRUE if buffer filled
56 *          FALSE if buffer failed to fill
57 *
58 */
59
60int fillPatternBuffer(void)
61{
62  int retval = TRUE;
63  int i;
64
65  for (i=0 ; i<200  ; i++ ) PatternBuffer[i] = 'a';
66  for (    ; i<400  ; i++ ) PatternBuffer[i] = 'b';
67  for (    ; i<600  ; i++ ) PatternBuffer[i] = 'c';
68  for (    ; i<800  ; i++ ) PatternBuffer[i] = 'd';
69  for (    ; i<1000 ; i++ ) PatternBuffer[i] = 'e';
70  return retval;
71}
72
73/*
74 * doFunctionalTest function
75 *
76 * Write a file with writev and then read it back with readv.
77 *
78 * Returns: TRUE if all operations worked as expected
79 *          FALSE if an operation did not work as expected.
80 *
81 */
82
83int doFunctionalTest(void) {
84  FILE         *fp;
85  int           fd;
86  struct iovec  rdvec[4];
87  struct iovec  wrvec[4];
88  int           rc;
89
90
91  /*
92   * Setup the iovec
93   */
94  wrvec[0].iov_base = &PatternBuffer[0];
95  wrvec[0].iov_len  = 100;
96  wrvec[1].iov_base = &PatternBuffer[100];
97  wrvec[1].iov_len  = 200;
98  wrvec[2].iov_base = &PatternBuffer[300];
99  wrvec[2].iov_len  = 300;
100  wrvec[3].iov_base = &PatternBuffer[600];
101  wrvec[3].iov_len  = 400;
102
103  rdvec[0].iov_base = &ReadBuffer[0];
104  rdvec[0].iov_len  = 400;
105  rdvec[1].iov_base = &ReadBuffer[400];
106  rdvec[1].iov_len  = 300;
107  rdvec[2].iov_base = &ReadBuffer[700];
108  rdvec[2].iov_len  = 200;
109  rdvec[3].iov_base = &ReadBuffer[900];
110  rdvec[3].iov_len  = 100;
111
112  /*
113   * Write the File
114   */
115  fp = fopen(TESTFILE, "wt");
116  if ( fp == NULL ) {
117    printf( "fopen for write: %d=%s\n", errno, strerror(errno));
118    return FALSE;
119  }
120  fd = fileno(fp);
121
122  rc = writev(fd, wrvec, 4);
123  if ( rc <= 0 ) {
124    printf( "writev: %d=%s\n", errno, strerror(errno) );
125    return FALSE;
126  }
127
128  fclose(fp);
129
130  puts("File written using writev .. OK");
131
132  /*
133   * Now read it back and check it
134   */
135
136  fp = fopen(TESTFILE, "rt");
137  if ( fp == NULL ) {
138    printf( "fopen for write: %d=%s\n", errno, strerror(errno));
139    return FALSE;
140  }
141  fd = fileno(fp);
142
143  rc = readv(fd, rdvec, 4);
144  if ( rc <= 0 ) {
145    printf( "rd: %d=%s\n", errno, strerror(errno) );
146    return FALSE;
147  }
148
149  if ( memcmp( PatternBuffer, ReadBuffer, MAX_BUFFER ) ) {
150    puts("readv .. Buffers do not match");
151    return FALSE;
152  }
153
154  puts("File read using readv .. OK");
155
156  return TRUE;
157}
158
159/*
160 * doErrorTest function
161 *
162 * Hit all the error cases in readv/writev.
163 *
164 * Returns: TRUE if all operations worked as expected
165 *          FALSE if an operation did not work as expected.
166 *
167 */
168
169int doErrorTest(void)
170{
171  FILE         *fp;
172  int           fd;
173  struct iovec  vec[4];
174  int           rc;
175
176  /*
177   * Open and close the file to get a bad file descriptor
178   */
179  fp = fopen(TESTFILE, "wt");
180  if ( fp == NULL ) {
181    printf( "fopen for error 1: %d=%s\n", errno, strerror(errno));
182    return FALSE;
183  }
184  fd = fileno(fp);
185  fclose(fp);
186
187  /* writev -- bad file descriptor */
188  puts("writev bad file descriptor -- EBADF");
189  rc = writev(fd, vec, 4);
190  if ( (rc != -1) || (errno != EBADF) ) {
191    printf( "writev error 1: %d=%s\n", errno, strerror(errno) );
192    return FALSE;
193  }
194
195  /* readv -- bad file descriptor */
196  puts("readv bad file descriptor -- EBADF");
197  rc = read(fd, vec, 4);
198  if ( (rc != -1) || (errno != EBADF) ) {
199    printf( "readv error 1: %d=%s\n", errno, strerror(errno) );
200    return FALSE;
201  }
202
203  /*
204   * Open the file for the rest of the tests
205   */
206  fp = fopen(TESTFILE, "w+");
207  if ( fp == NULL ) {
208    printf( "fopen for error 2: %d=%s\n", errno, strerror(errno));
209    return FALSE;
210  }
211  fd = fileno(fp);
212
213  /* writev --  bad iovec pointer */
214  puts("writev bad iovec pointer -- EINVAL");
215  rc = writev(fd, NULL, 4);
216  if ( (rc != -1) || (errno != EINVAL) ) {
217    printf( "writev error 2: %d=%s\n", errno, strerror(errno) );
218    fclose(fp);
219    return FALSE;
220  }
221
222  /* readv --  bad iovec pointer */
223  puts("readv bad iovec pointer -- EINVAL");
224  rc = readv(fd, NULL, 4);
225  if ( (rc != -1) || (errno != EINVAL) ) {
226    printf( "readv error 2: %d=%s\n", errno, strerror(errno) );
227    fclose(fp);
228    return FALSE;
229  }
230
231  /* writev --  bad iovcnt 0 */
232  puts("readv bad iovcnt of 0 -- EINVAL");
233  rc = writev(fd, vec, 0);
234  if ( (rc != -1) || (errno != EINVAL) ) {
235    printf( "writev error 3: %d=%s\n", errno, strerror(errno) );
236    fclose(fp);
237    return FALSE;
238  }
239
240  /* readv --  bad iovcnt 0 */
241  puts("readv bad iovcnt of 0 -- EINVAL");
242  rc = readv(fd, vec, 0);
243  if ( (rc != -1) || (errno != EINVAL) ) {
244    printf( "readv error 3: %d=%s\n", errno, strerror(errno) );
245    fclose(fp);
246    return FALSE;
247  }
248
249  /* writev --  bad iovcnt negative */
250  puts("writev bad iovcnt negative -- EINVAL");
251  rc = writev(fd, vec, -2);
252  if ( (rc != -1) || (errno != EINVAL) ) {
253    printf( "writev error 4: %d=%s\n", errno, strerror(errno) );
254    fclose(fp);
255    return FALSE;
256  }
257
258  /* readv --  bad iovcnt negative */
259  puts("readv bad iovcnt negative -- EINVAL");
260  rc = readv(fd, vec, -100);
261  if ( (rc != -1) || (errno != EINVAL) ) {
262    printf( "readv error 4: %d=%s\n", errno, strerror(errno) );
263    fclose(fp);
264    return FALSE;
265  }
266
267  /* writev --  bad iov[i].iov_base */
268  vec[0].iov_base = vec;
269  vec[0].iov_len = 100;
270  vec[1].iov_base = NULL;
271  vec[1].iov_len = 100;
272  puts("writev bad iov[i].iov_base -- EINVAL");
273  rc = writev(fd, vec, 2);
274  if ( (rc != -1) || (errno != EINVAL) ) {
275    printf( "writev error 5: %d=%s\n", errno, strerror(errno) );
276    fclose(fp);
277    return FALSE;
278  }
279
280  /*  readv --  bad iov[i].iov_base */
281  vec[0].iov_base = vec;
282  vec[0].iov_len = 100;
283  vec[1].iov_base = NULL;
284  vec[1].iov_len = 100;
285  puts("readv bad iov[i].iov_base -- EINVAL");
286  rc = readv(fd, vec, 2);
287  if ( (rc != -1) || (errno != EINVAL) ) {
288    printf( "readv error 5: %d=%s\n", errno, strerror(errno) );
289    fclose(fp);
290    return FALSE;
291  }
292
293  /*  writev --  bad iov[i].iov_len < 0 */
294  vec[0].iov_base = vec;
295  vec[0].iov_len = 100;
296  vec[1].iov_base = vec;
297  vec[1].iov_len = -10;
298  puts("writev bad iov[i].iov_len < 0 -- EINVAL");
299  rc = writev(fd, vec, 2);
300  if ( (rc != -1) || (errno != EINVAL) ) {
301    printf( "writev error 6: %d=%s\n", errno, strerror(errno) );
302    fclose(fp);
303    return FALSE;
304  }
305
306  /*  readv --  bad iov[i].iov_len = 0 */
307  vec[0].iov_base = vec;
308  vec[0].iov_len = 100;
309  vec[1].iov_base = vec;
310  vec[1].iov_len = -1024;
311  puts("readv bad iov[i].iov_len = 0 -- EINVAL");
312  rc = readv(fd, vec, 2);
313  if ( (rc != -1) || (errno != EINVAL) ) {
314    printf( "readv error 6: %d=%s\n", errno, strerror(errno) );
315    fclose(fp);
316    return FALSE;
317  }
318
319  /*  writev --  iov_len total overflows */
320  vec[0].iov_base = vec;
321  vec[0].iov_len = SIZE_MAX;
322  vec[1].iov_base = vec;
323  vec[1].iov_len = SIZE_MAX;
324  vec[2].iov_base = vec;
325  vec[2].iov_len = SIZE_MAX;
326  puts("writev iov_len total overflows -- EINVAL");
327  rc = writev(fd, vec, 3);
328  if ( (rc != -1) || (errno != EINVAL) ) {
329    printf( "writev error 7: rc=%d %d=%s\n", rc, errno, strerror(errno) );
330    fclose(fp);
331    return FALSE;
332  }
333
334  /*  readv --  iov_len total overflows */
335  vec[0].iov_base = vec;
336  vec[0].iov_len = SIZE_MAX;
337  vec[1].iov_base = vec;
338  vec[1].iov_len = SIZE_MAX;
339  puts("readv iov_len total overflows -- EINVAL");
340  rc = readv(fd, vec, 2);
341  if ( (rc != -1) || (errno != EINVAL) ) {
342    printf( "read error 7: rc=%d %d=%s\n", rc, errno, strerror(errno) );
343    fclose(fp);
344    return FALSE;
345  }
346
347  /*  writev --  all zero length buffers */
348  vec[0].iov_base = vec;
349  vec[0].iov_len = 0;
350  vec[1].iov_base = vec;
351  vec[1].iov_len = 0;
352  puts("writev iov_len works with no effect -- OK");
353  rc = writev(fd, vec, 2);
354  if ( (rc != 0) ) {
355    printf( "writev error 8: %d=%s\n", errno, strerror(errno) );
356    fclose(fp);
357    return FALSE;
358  }
359
360  /*  readv --  all zero length buffers */
361  vec[0].iov_base = vec;
362  vec[0].iov_len = 0;
363  vec[1].iov_base = vec;
364  vec[1].iov_len = 0;
365  puts("readv iov_len works with no effect -- OK");
366  rc = readv(fd, vec, 2);
367  if ( (rc != 0) ) {
368    printf( "readv error 8: %d=%s\n", errno, strerror(errno) );
369    fclose(fp);
370    return FALSE;
371  }
372
373  fclose(fp);
374  return TRUE;
375}
376
377
378/* ---------------------------------------------------------------
379 * Main function
380 *
381 *  main entry point to the test
382 *
383 * ---------------------------------------------------------------
384 */
385
386#if defined(__rtems__)
387int test_main(void)
388#else
389int main(
390  int    argc,
391  char **argv
392)
393#endif
394{
395  puts( "*** POSIX TEST READV/WRITEV ***" );
396
397  if ( fillPatternBuffer() != TRUE ) {
398    puts("Error filling pattern buffer" );
399    rtems_test_exit(0);
400  }
401
402  if (doErrorTest() != TRUE) {
403    puts("Error during error test!!!!");
404    rtems_test_exit(0);
405  }
406  if (doFunctionalTest() != TRUE) {
407    puts("Error during functional test!!!!");
408    rtems_test_exit(0);
409  }
410
411  unlink(TESTFILE);
412  puts( "*** END OF TEST PSXRDWRV ***" );
413  rtems_test_exit(0);
414}
Note: See TracBrowser for help on using the repository browser.