gdb/testsuite/gdb.base/fileio.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <sys/errno.h>
   5 #include <sys/types.h>
   6 #include <sys/fcntl.h>
   7 #include <sys/stat.h>
   8 #include <sys/time.h>
   9 #include <errno.h>
  10 #include <sys/wait.h>
  11 /* TESTS :
  12  * - open(const char *pathname, int flags, mode_t mode);
  13 1) Attempt to create file that already exists - EEXIST
  14 2) Attempt to open a directory for writing - EISDIR
  15 3) Pathname does not exist - ENOENT
  16 4) Open for write but no write permission - EACCES
  17
  18 read(int fd, void *buf, size_t count);
  19 1) Read using invalid file descriptor - EBADF
  20
  21 write(int fd, const void *buf, size_t count);
  22 1) Write using invalid file descriptor - EBADF
  23 2) Attempt to write to read-only file - EBADF
  24
  25 lseek(int fildes, off_t offset, int whence);
  26 1) Seeking on an invalid file descriptor - EBADF
  27 2) Invalid "whence" (3rd param) value -  EINVAL
  28
  29 close(int fd);
  30 1) Attempt to close an invalid file descriptor - EBADF
  31
  32 stat(const char *file_name, struct stat *buf);
  33 1) Pathname is a null string -  ENOENT
  34 2) Pathname does not exist - ENOENT
  35
  36 fstat(int filedes, struct stat *buf);
  37 1) Attempt to stat using an invalid file descriptor - EBADF
  38
  39 isatty (int desc);
  40 Not applicable. We will test that it returns 1 when expected and a case
  41 where it should return 0.
  42
  43 rename(const char *oldpath, const char *newpath);
  44 1) newpath is an existing directory, but oldpath is not a directory. - EISDIR
  45 2) newpath is a non-empty directory. - ENOTEMPTY or EEXIST
  46 3) newpath is a subdirectory of old path. - EINVAL
  47 4) oldpath does not exist. - ENOENT
  48
  49 unlink(const char *pathname);
  50 1) pathname does not have write access. - EACCES
  51 2) pathname does not exist. - ENOENT
  52
  53 time(time_t *t);
  54 Not applicable.
  55
  56 system (const char * string);
  57 1) Invalid string/command. -  returns 127.  */
  58
  59 static const char *strerrno (int err);
  60
  61 #define FILENAME    "foo.fileio.test"
  62 #define RENAMED     "bar.fileio.test"
  63 #define NONEXISTANT "nofoo.fileio.test"
  64 #define NOWRITE     "nowrt.fileio.test"
  65 #define TESTDIR1     "dir1.fileio.test"
  66 #define TESTDIR2     "dir2.fileio.test"
  67 #define TESTSUBDIR   "dir1.fileio.test/subdir.fileio.test"
  68
  69 #define STRING      "Hello World"
  70
  71 int
  72 test_open ()
  73 {
  74   int ret;
  75
  76   /* Test opening */
  77   errno = 0;
  78   ret = open (FILENAME, O_CREAT | O_TRUNC | O_RDWR, S_IWUSR | S_IRUSR);
  79   printf ("open 1: ret = %d, errno = %d %s\n", ret, errno,
  80           ret >= 0 ? "OK" : "");
  81   if (ret >= 0)
  82     close (ret);
  83   /* Creating an already existing file (created by fileio.exp) */
  84   errno = 0;
  85   ret = open (FILENAME, O_CREAT | O_EXCL | O_WRONLY, S_IWUSR | S_IRUSR);
  86   printf ("open 2: ret = %d, errno = %d %s\n", ret, errno,
  87           strerrno (errno));
  88   if (ret >= 0)
  89     close (ret);
  90   /* Open directory (for writing) */
  91   errno = 0;
  92   ret = open (".", O_WRONLY);
  93   printf ("open 3: ret = %d, errno = %d %s\n", ret, errno,
  94           strerrno (errno));
  95   if (ret >= 0)
  96     close (ret);
  97   /* Opening nonexistant file */
  98   errno = 0;
  99   ret = open (NONEXISTANT, O_RDONLY);
 100   printf ("open 4: ret = %d, errno = %d %s\n", ret, errno,
 101           strerrno (errno));
 102   if (ret >= 0)
 103     close (ret);
 104   /* Open for write but no write permission */
 105   errno = 0;
 106   ret = open (NOWRITE, O_CREAT | O_RDONLY, S_IRUSR);
 107   if (ret >= 0)
 108     {
 109       close (ret);
 110       errno = 0;
 111       ret = open (NOWRITE, O_WRONLY);
 112       printf ("open 5: ret = %d, errno = %d %s\n", ret, errno,
 113               strerrno (errno));
 114       if (ret >= 0)
 115         close (ret);
 116     }
 117   else
 118     printf ("open 5: ret = %d, errno = %d\n", ret, errno);
 119 }
 120
 121 int
 122 test_write ()
 123 {
 124   int fd, ret;
 125
 126   /* Test writing */
 127   errno = 0;
 128   fd = open (FILENAME, O_WRONLY);
 129   if (fd >= 0)
 130     {
 131       errno = 0;
 132       ret = write (fd, STRING, strlen (STRING));
 133       printf ("write 1: ret = %d, errno = %d %s\n", ret, errno,
 134               ret == strlen (STRING) ? "OK" : "");
 135       close (fd);
 136     }
 137   else
 138     printf ("write 1: ret = %d, errno = %d\n", ret, errno);
 139   /* Write using invalid file descriptor */
 140   errno = 0;
 141   ret = write (999, STRING, strlen (STRING));
 142   printf ("write 2: ret = %d, errno = %d, %s\n", ret, errno,
 143           strerrno (errno));
 144   /* Write to a read-only file */
 145   errno = 0;
 146   fd = open (FILENAME, O_RDONLY);
 147   if (fd >= 0)
 148     {
 149       errno = 0;
 150       ret = write (fd, STRING, strlen (STRING));
 151       printf ("write 3: ret = %d, errno = %d %s\n", ret, errno,
 152               strerrno (errno));
 153     }
 154   else
 155     printf ("write 3: ret = %d, errno = %d\n", ret, errno);
 156 }
 157
 158 int
 159 test_read ()
 160 {
 161   int fd, ret;
 162   char buf[16];
 163
 164   /* Test reading */
 165   errno = 0;
 166   fd = open (FILENAME, O_RDONLY);
 167   if (fd >= 0)
 168     {
 169       memset (buf, 0, 16);
 170       errno = 0;
 171       ret = read (fd, buf, 16);
 172       buf[15] = '\0'; /* Don't trust anybody... */
 173       if (ret == strlen (STRING))
 174         printf ("read 1: %s %s\n", buf, !strcmp (buf, STRING) ? "OK" : "");
 175       else
 176         printf ("read 1: ret = %d, errno = %d\n", ret, errno);
 177       close (fd);
 178     }
 179   else
 180     printf ("read 1: ret = %d, errno = %d\n", ret, errno);
 181   /* Read using invalid file descriptor */
 182   errno = 0;
 183   ret = read (999, buf, 16);
 184   printf ("read 2: ret = %d, errno = %d %s\n", ret, errno,
 185           strerrno (errno));
 186 }
 187
 188 int
 189 test_lseek ()
 190 {
 191   int fd;
 192   off_t ret = 0;
 193
 194   /* Test seeking */
 195   errno = 0;
 196   fd = open (FILENAME, O_RDONLY);
 197   if (fd >= 0)
 198     {
 199       errno = 0;
 200       ret = lseek (fd, 0, SEEK_CUR);
 201       printf ("lseek 1: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 202               ret == 0 ? "OK" : "");
 203       errno = 0;
 204       ret = lseek (fd, 0, SEEK_END);
 205       printf ("lseek 2: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 206               ret == 11 ? "OK" : "");
 207       errno = 0;
 208       ret = lseek (fd, 3, SEEK_SET);
 209       printf ("lseek 3: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 210               ret == 3 ? "OK" : "");
 211       close (fd);
 212     }
 213   else
 214     {
 215       printf ("lseek 1: ret = %d, errno = %d\n", ret, errno);
 216       printf ("lseek 2: ret = %d, errno = %d\n", ret, errno);
 217       printf ("lseek 3: ret = %d, errno = %d\n", ret, errno);
 218     }
 219   /* Seeking on an invalid file descriptor */
 220
 221 }
 222
 223 int
 224 test_close ()
 225 {
 226   int fd, ret;
 227
 228   /* Test close */
 229   errno = 0;
 230   fd = open (FILENAME, O_RDONLY);
 231   if (fd >= 0)
 232     {
 233       errno = 0;
 234       ret = close (fd);
 235       printf ("close 1: ret = %d, errno = %d, %s\n", ret, errno,
 236               ret == 0 ? "OK" : "");
 237     }
 238   else
 239     printf ("close 1: ret = %d, errno = %d\n", ret, errno);
 240   /* Close an invalid file descriptor */
 241   errno = 0;
 242   ret = close (999);
 243   printf ("close 2: ret = %d, errno = %d, %s\n", ret, errno,
 244           strerrno (errno));
 245 }
 246
 247 int
 248 test_stat ()
 249 {
 250   int ret;
 251   struct stat st;
 252
 253   /* Test stat */
 254   errno = 0;
 255   ret = stat (FILENAME, &st);
 256   if (!ret)
 257     printf ("stat 1: ret = %d, errno = %d %s\n", ret, errno,
 258             st.st_size == 11 ? "OK" : "");
 259   else
 260     printf ("stat 1: ret = %d, errno = %d\n", ret, errno);
 261   /* NULL pathname */
 262   errno = 0;
 263   ret = stat (NULL, &st);
 264   printf ("stat 2: ret = %d, errno = %d %s\n", ret, errno,
 265           strerrno (errno));
 266   /* Empty pathname */
 267   errno = 0;
 268   ret = stat ("", &st);
 269   printf ("stat 3: ret = %d, errno = %d %s\n", ret, errno,
 270           strerrno (errno));
 271   /* Nonexistant file */
 272   errno = 0;
 273   ret = stat (NONEXISTANT, &st);
 274   printf ("stat 4: ret = %d, errno = %d %s\n", ret, errno,
 275           strerrno (errno));
 276 }
 277
 278 int
 279 test_fstat ()
 280 {
 281   int fd, ret;
 282   struct stat st;
 283
 284   /* Test fstat */
 285   errno = 0;
 286   fd = open (FILENAME, O_RDONLY);
 287   if (fd >= 0)
 288     {
 289       errno = 0;
 290       ret = fstat (fd, &st);
 291       if (!ret)
 292         printf ("fstat 1: ret = %d, errno = %d %s\n", ret, errno,
 293                 st.st_size == 11 ? "OK" : "");
 294       else
 295         printf ("fstat 1: ret = %d, errno = %d\n", ret, errno);
 296       close (fd);
 297     }
 298   else
 299     printf ("fstat 1: ret = %d, errno = %d\n", ret, errno);
 300   /* Fstat using invalid file descriptor */
 301   errno = 0;
 302   ret = fstat (999, &st);
 303   printf ("fstat 2: ret = %d, errno = %d %s\n", ret, errno,
 304           strerrno (errno));
 305 }
 306
 307 int
 308 test_isatty ()
 309 {
 310   int fd;
 311
 312   /* Check std I/O */
 313   printf ("isatty 1: stdin %s\n", isatty (0) ? "yes OK" : "no");
 314   printf ("isatty 2: stdout %s\n", isatty (1) ? "yes OK" : "no");
 315   printf ("isatty 3: stderr %s\n", isatty (2) ? "yes OK" : "no");
 316   /* Check invalid fd */
 317   printf ("isatty 4: invalid %s\n", isatty (999) ? "yes" : "no OK");
 318   /* Check open file */
 319   fd = open (FILENAME, O_RDONLY);
 320   if (fd >= 0)
 321     {
 322       printf ("isatty 5: file %s\n", isatty (fd) ? "yes" : "no OK");
 323       close (fd);
 324     }
 325   else
 326     printf ("isatty 5: file couldn't open\n");
 327 }
 328
 329
 330 int
 331 test_system ()
 332 {
 333   /*
 334    * Requires test framework to switch on "set remote system-call-allowed 1"
 335    */
 336   int ret;
 337   char sys[512];
 338
 339   /* This test prepares the directory for test_rename() */
 340   sprintf (sys, "mkdir -p %s %s", TESTSUBDIR, TESTDIR2);
 341   ret = system (sys);
 342   if (ret == 127)
 343     printf ("system 1: ret = %d /bin/sh unavailable???\n", ret);
 344   else
 345     printf ("system 1: ret = %d %s\n", ret, ret == 0 ? "OK" : "");
 346   /* Invalid command (just guessing ;-) ) */
 347   ret = system ("wrtzlpfrmpft");
 348   printf ("system 2: ret = %d %s\n", ret, WEXITSTATUS (ret) == 127 ? "OK" : "");
 349 }
 350
 351 int
 352 test_rename ()
 353 {
 354   int ret;
 355   struct stat st;
 356
 357   /* Test rename */
 358   errno = 0;
 359   ret = rename (FILENAME, RENAMED);
 360   if (!ret)
 361     {
 362       errno = 0;
 363       ret = stat (FILENAME, &st);
 364       if (ret && errno == ENOENT)
 365         {
 366           errno = 0;
 367           ret = stat (RENAMED, &st);
 368           printf ("rename 1: ret = %d, errno = %d %s\n", ret, errno,
 369                   strerrno (errno));
 370           errno = 0;
 371         }
 372       else
 373         printf ("rename 1: ret = %d, errno = %d\n", ret, errno);
 374     }
 375   else
 376     printf ("rename 1: ret = %d, errno = %d\n", ret, errno);
 377   /* newpath is existing directory, oldpath is not a directory */
 378   errno = 0;
 379   ret = rename (RENAMED, TESTDIR2);
 380   printf ("rename 2: ret = %d, errno = %d %s\n", ret, errno,
 381           strerrno (errno));
 382   /* newpath is a non-empty directory */
 383   errno = 0;
 384   ret = rename (TESTDIR2, TESTDIR1);
 385   printf ("rename 3: ret = %d, errno = %d %s\n", ret, errno,
 386           strerrno (errno));
 387   /* newpath is a subdirectory of old path */
 388   errno = 0;
 389   ret = rename (TESTDIR1, TESTSUBDIR);
 390   printf ("rename 4: ret = %d, errno = %d %s\n", ret, errno,
 391           strerrno (errno));
 392   /* oldpath does not exist */
 393   errno = 0;
 394   ret = rename (NONEXISTANT, FILENAME);
 395   printf ("rename 5: ret = %d, errno = %d %s\n", ret, errno,
 396           strerrno (errno));
 397 }
 398
 399 int
 400 test_unlink ()
 401 {
 402   int ret;
 403   char name[256];
 404   char sys[512];
 405
 406   /* Test unlink */
 407   errno = 0;
 408   ret = unlink (RENAMED);
 409   printf ("unlink 1: ret = %d, errno = %d %s\n", ret, errno,
 410           strerrno (errno));
 411   /* No write access */
 412   sprintf (name, "%s/%s", TESTDIR2, FILENAME);
 413   errno = 0;
 414   ret = open (name, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
 415   if (ret >= 0)
 416     {
 417       sprintf (sys, "chmod -w %s", TESTDIR2);
 418       ret = system (sys);
 419       if (!ret)
 420         {
 421           errno = 0;
 422           ret = unlink (name);
 423           printf ("unlink 2: ret = %d, errno = %d %s\n", ret, errno,
 424                   strerrno (errno));
 425         }
 426       else
 427         printf ("unlink 2: ret = %d chmod failed\n", ret, errno);
 428     }
 429   else
 430     printf ("unlink 2: ret = %d, errno = %d\n", ret, errno);
 431   /* pathname doesn't exist */
 432   errno = 0;
 433   ret = unlink (NONEXISTANT);
 434   printf ("unlink 3: ret = %d, errno = %d %s\n", ret, errno,
 435           strerrno (errno));
 436 }
 437
 438 int
 439 test_time ()
 440 {
 441   time_t ret, t;
 442
 443   errno = 0;
 444   ret = time (&t);
 445   printf ("time 1: ret = %ld, errno = %d, t = %ld %s\n", (long) ret, errno, (long) t, ret == t ? "OK" : "");
 446   errno = 0;
 447   ret = time (NULL);
 448   printf ("time 2: ret = %ld, errno = %d, t = %ld %s\n",
 449           (long) ret, errno, (long) t, ret >= t && ret < t + 10 ? "OK" : "");
 450 }
 451
 452 static const char *
 453 strerrno (int err)
 454 {
 455   switch (err)
 456     {
 457     case 0: return "OK";
 458 #ifdef EACCES
 459     case EACCES: return "EACCES";
 460 #endif
 461 #ifdef EBADF
 462     case EBADF: return "EBADF";
 463 #endif
 464 #ifdef EEXIST
 465     case EEXIST: return "EEXIST";
 466 #endif
 467 #ifdef EFAULT
 468     case EFAULT: return "EFAULT";
 469 #endif
 470 #ifdef EINVAL
 471     case EINVAL: return "EINVAL";
 472 #endif
 473 #ifdef EISDIR
 474     case EISDIR: return "EISDIR";
 475 #endif
 476 #ifdef ENOENT
 477     case ENOENT: return "ENOENT";
 478 #endif
 479 #ifdef ENOTEMPTY
 480     case ENOTEMPTY: return "ENOTEMPTY";
 481 #endif
 482 #ifdef EBUSY
 483     case EBUSY: return "EBUSY";
 484 #endif
 485     default: return "E??";
 486     }
 487 }
 488
 489 int
 490 main ()
 491 {
 492   /* Don't change the order of the calls.  They partly depend on each other */
 493   test_open ();
 494   test_write ();
 495   test_read ();
 496   test_lseek ();
 497   test_close ();
 498   test_stat ();
 499   test_fstat ();
 500   test_isatty ();
 501   test_system ();
 502   test_rename ();
 503   test_unlink ();
 504   test_time ();
 505   return 0;
 506 }