path: root/testsuites/psxtests/psx13/test.c

/*
 *  Psx13
 *  Chris Bond (working under Jennifer's account)
 *
 *  This test exercises the following routines:
 *
 *     device_lseek - test implemented
 *     dup          - test implemented
 *     dup2         - test implemented
 *     fdatasync    - test implemented
 *     fsync        - test implemented
 *     pathconf     - test implemented
 *     fpathconf    - test implemented
 *     umask        - test implemented
 *     utime        - test implemented
 *     utimes       - test implemented
 *
 *  COPYRIGHT (c) 1989-2009.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <rtems.h>
#include <rtems/libio.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <utime.h>

#include <stdio.h>
#include <unistd.h>

#include <pmacros.h>

const char rtems_test_name[] = "PSX 13";

int InitFiles(void);
int DeviceLSeekTest(void);
int DupTest(void);
int Dup2Test(void);
int FDataSyncTest(void);
int UMaskTest(void);
int UTimeTest(void);
int UTimesTest(void);
int PathConfTest(void);
int FPathConfTest(void);
int FSyncTest(void);

/*-------------------------------------------------------------------
 * InitFiles function
 *
 * Initializes the three files to be used in the test.
 *
 * arguments: none
 * assumptions: fopen, fprintf, fwrite, FILE are available
 * actions: creates testfile1, a text file with 'a'..'z' listed 4 times.
 *          creates testfile2, a text file with 'a'..'z' listed 4 times.
 *          creates testfile3, a binary file with 0..9 listed 4 times.
 * returns: TRUE if files opened successfully.
 *          FALSE if fail on file open for write.
 *
 * ------------------------------------------------------------------
 */

int InitFiles (void)
{
  int count;
  FILE *fp1, *fp2, *fp3;
  char letter;
  int number;
  int retval;

  fp1 = fopen("testfile1.tst", "wt");
  fp2 = fopen("testfile2.tst", "wt");
  fp3 = fopen("testfile4.tst", "wb");

  if ((fp1 != NULL) && (fp2 != NULL) && (fp3 !=NULL)) {

    letter = 'a';

    for (count=0 ; count<(26*4); ++count) {
      fprintf (fp1, "%c", letter);
      fprintf (fp2, "%c", letter);

      ++letter;
      if (letter > 'z')
	letter = 'a';
    }

    number = 0;

    for (count = 0; count <40; ++count) {

      fwrite (&number, 1, sizeof(int), fp3);

      ++number;
      if (number > 9)
	number = 0;
    }

    fclose(fp1);
    fclose(fp2);
    fclose(fp3);

    retval = TRUE;
  }

  else
    retval = FALSE;

  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * DeviceLSeekTest function
 *
 * Hits the device_lseek code by lseeking on the console.
 *
 * arguments: none
 * assumptions: lseek available
 * actions: hits lseek with some dummy arguments.
 * returns: value of return from lseek.
 *
 * ---------------------------------------------------------------
 */

int DeviceLSeekTest (void)
{
  int error = -1, retval = FALSE;

  int fd = open ("/dev/console", O_RDONLY);

  error = lseek(fd, 5, SEEK_SET);

  if (error == 0)
    retval = TRUE;
  else
    retval = FALSE;

  close( fd );  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * DupTest function
 *
 * Hits the dup code.
 *
 * arguments: none
 * assumptions: dup, open, close, fcntl available.
 * actions: Gets a file descriptor(fd1) for test file1.
 *          dups fd1 to fd2.
 *          sets fd1 to append mode
 *          checks fd2 to ensure it's in append mode, also.
 * returns: success if fd2 is indeed a copy of fd1.
 *
 * ---------------------------------------------------------------
 */

int DupTest(void)
{
  int fd1, fd2;

  int flags = 0, retval = FALSE;

  fd1 = open ("testfile1.tst", O_RDONLY);
  fd2 = dup(fd1);

  if (fd2 != -1) {

    fcntl(fd1, F_SETFL, O_APPEND);
    flags = fcntl(fd2, F_GETFL);

    close (fd1);

    flags = (flags & O_APPEND);

    retval = (flags == O_APPEND);
  }

  else
    retval = FALSE;

  close( fd1 );
  close( fd2 );
  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * Dup2Test function
 *
 * Hits the dup2 code.
 *
 * arguments: none
 * assumptions: dup, dup2, open, close, fcntl available.
 * actions: Gets a file descriptor(fd1) for test file1.
 *          dups fd1 to fd2.
 *          sets fd1 to append mode
 *          checks fd2 to ensure it's in append mode, also.
 *          sets fd1 to invalid value, fd2 to valid, tries to dup2.
 *          sets fd2 to invalid value, fd1 to valid tries to dup2.
 * returns: success if fd2 is a copy of fd1, and invalid fd1 or fd2 produce errors.
 *
 * ---------------------------------------------------------------
 */

int Dup2Test(void)
{
  int fd1, fd2;

  int flags = 0, retval = FALSE;

  int error = 0;

  fd1 = open ("testfile1.tst", O_RDONLY);
  fd2 = open ("testfile2.tst", O_RDONLY);
  error = dup2(fd1, fd2);

  /* make sure dup2 works if both fd1 and fd2 are valid file descriptors. */

  if (error != -1) {

    fcntl(fd1, F_SETFL, O_APPEND);
    flags = fcntl(fd1, F_GETFL);

    flags = (flags & O_APPEND);
    retval = (flags == O_APPEND);
  }

  else {
    retval = FALSE;
    close(fd2);
  }

  if (retval == TRUE) {

    /* make sure dup2 fails correctly if one or the other arguments are invalid. */
    /* this assumes -1 is an invalid value for a file descriptor!!! (POSIX book, p.135) */

    fd1 = -1;

    if (dup2 (fd1, fd2) != -1)
      retval = FALSE;
    else {
      fd1 = dup(fd2);
      fd2 = -1;

      if (dup2(fd1, fd2) != -1)
	retval = FALSE;
    }
  }

  close (fd1);
  close (fd2);
  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * FDataSyncTest function
 *
 * Hits the fdatasync code. Does NOT test the functionality of the
 * underlying fdatasync entry in the IMFS op table.
 *
 * arguments: none
 * assumptions: open, close, fdatasync functions available.
 * actions: attempts to fdatasync a file descriptor flagged as read-only.
 *          attempts to fdatasync an invalid file descriptor (-1).
 *          attempts to fdatasync a perfectly valid fd opened as RDWR
 *
 * returns: TRUE if attempt to fdatasync invalid and read-only filed
 *           descriptor fail, and fdatasync succeeds on valid fd.
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int FDataSyncTest(void)
{
  int fd = -1;
  int error = 0, retval = TRUE;

  /* Try it with a RD_ONLY file. */

  fd = open ("testfile1.tst", O_RDONLY);

  error = fdatasync(fd);
  if ((error == -1) && (errno == EINVAL))
    retval = TRUE;
  else
    retval = FALSE;

  close (fd);

  if (retval == TRUE) {

    /* Try it with a bad file descriptor */

    fd = -1;

    error = fdatasync(fd);
    if ((errno == EBADF) && (error == -1))
      retval = TRUE;
    else
      retval = FALSE;
  }

  /* Okay - now the success case... */

  if (retval == TRUE) {
    fd = open ("testfile1.tst", O_RDWR);
    error = fdatasync(fd);

    if (error == 0)
      retval = TRUE;
    else
      retval = FALSE;

    close (fd);
  }

  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * UMaskTest function
 *
 * Hits the umask code.
 *
 * arguments: none
 * assumptions: umask function available.
 * actions: set umask to 0ctal 23.
 *          set umask to Octal 22, retrieve the old value.
 *
 * returns: TRUE if old value is 23,
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int UMaskTest (void)
{
  mode_t error = 0;
  int    retval = FALSE;

  umask(023);
  error = umask(022);

  if (error == 023)
    retval = TRUE;
  else
    retval = FALSE;

  /* assert (retval == TRUE);*/

  return(retval);
}

/* ---------------------------------------------------------------
 * UTimeTest function
 *
 * Hits the utime code. Does NOT test the functionality of the underlying utime
 * entry in the IMFS op table.
 *
 * arguments: none
 * assumptions: utime function available.
 * actions: set utime for an invalid filename.
 *          set utime for a valid filename.
 *
 * returns: TRUE if time on valid file is set correctly and utime failed on
 *          an invalid filename.
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int UTimeTest (void)
{
  int error = 0, retval = FALSE;
  struct utimbuf time;
  struct stat fstat;

  /* First, an invalid filename. */
  error = utime("!This is an =invalid p@thname!!! :)", NULL);

  if (error == -1)
    retval = TRUE;
  else
    retval = FALSE;

  /* Now, the success test. */
  if (retval == TRUE) {

    time.actime  = 12345;
    time.modtime = 54321;

    error = utime("testfile1.tst", &time);

    if (error == 0) {

      /* But, did it set the time? */
      stat ("testfile1.tst", &fstat);

      if ((fstat.st_atime == 12345) && (fstat.st_mtime == 54321 ))
	retval = TRUE;
      else
	retval = FALSE;
    }
    else
      retval = FALSE;

    error = utime("testfile1.tst", NULL );
    retval &= (error == 0) ? TRUE : FALSE;
  }

  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * UTimesTest function
 *
 * Hits the utimes code. Does NOT test the functionality of the underlying utime
 * entry in the IMFS op table.
 *
 * arguments: none
 * assumptions: utimes function available.
 * actions: set utimes for an invalid filename.
 *          set utimes for a valid filename.
 *
 * returns: TRUE if time on valid file is set correctly and utimes failed on
 *          an invalid filename.
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int UTimesTest (void)
{
  int error = 0, retval = FALSE;
  struct timeval time[2];
  struct stat fstat;

  /* First, an invalid filename. */
  error = utimes("!This is an =invalid p@thname!!! :)", NULL);

  if (error == -1)
    retval = TRUE;
  else
    retval = FALSE;

  /* Now, the success test. */
  if (retval == TRUE) {

    time[0].tv_sec = 12345;
    time[1].tv_sec = 54321;

    error = utimes("testfile1.tst", (struct timeval *)&time);

    if (error == 0) {

      /* But, did it set the time? */
      stat ("testfile1.tst", &fstat);

      if ((fstat.st_atime == 12345) && (fstat.st_mtime == 54321 ))
	retval = TRUE;
      else
	retval = FALSE;
    }

    else
      retval = FALSE;
  }

  /* assert (retval == TRUE);*/

  return (retval);
}

/* ---------------------------------------------------------------
 * PathConfTest function
 *
 * Hits the pathconf code.
 *
 * arguments: none
 * assumptions: pathconf function available.
 * actions: Try to pathconf a bad filename.
 *          Try to pathconf a good filename.
 *
 * returns: TRUE if pathconf fails on bad file, succeeds on good file.
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int PathConfTest (void)
{
  int error = 0, retval = FALSE;

  error = pathconf("thisfiledoesnotexist", _PC_LINK_MAX);

  if (error == -1) {
    error = pathconf("testfile1.tst", _PC_LINK_MAX);

    if (error != -1)
      retval = TRUE;
    else
      retval = FALSE;
  }

  else
    retval = FALSE;

  /* assert (retval == TRUE);*/

  return(retval);
}

/* ---------------------------------------------------------------
 * FPathConfTest function
 *
 * Hits the fpathconf code.
 *
 * arguments: none
 * assumptions: fpathconf function available.
 * actions: Call fpathconf with all arguments, plus an invalid.
 *
 * returns: TRUE always.
 *
 * ---------------------------------------------------------------
 */

int FPathConfTest (void)
{
  int error = 0, retval = TRUE;

  int fd  = -1;

  error = fpathconf(fd, _PC_LINK_MAX);

  if (error == -1) {
    fd = open("testfile1.tst", O_RDWR);

    error = fpathconf(fd, _PC_LINK_MAX);
    error = fpathconf(fd, _PC_MAX_CANON);
    error = fpathconf(fd, _PC_MAX_INPUT);
    error = fpathconf(fd, _PC_NAME_MAX);
    error = fpathconf(fd, _PC_PATH_MAX);
    error = fpathconf(fd, _PC_PIPE_BUF);
    error = fpathconf(fd, _PC_CHOWN_RESTRICTED);
    error = fpathconf(fd, _PC_NO_TRUNC);
    error = fpathconf(fd, _PC_VDISABLE);
    error = fpathconf(fd, _PC_ASYNC_IO);
    error = fpathconf(fd, _PC_PRIO_IO);
    error = fpathconf(fd, _PC_SYNC_IO);
    error = fpathconf(fd, 255);

    close(fd);

    fd = open("testfile1.tst", O_WRONLY);

    error = fpathconf(fd, _PC_LINK_MAX);

    retval = TRUE;
  }

  else
    retval = FALSE;

  /* assert (retval == TRUE);*/

  return(retval);
}

/* ---------------------------------------------------------------
 * FSyncTest function
 *
 * Hits the fsync code.
 *
 * arguments: none
 * assumptions: open, fsync functions available.
 * actions: open test file,
 *          try to fsync it.
 *
 * returns: TRUE if fsync doesn't return -1,
 *          FALSE otherwise.
 *
 * ---------------------------------------------------------------
 */

int FSyncTest (void)
{
  int error = 0, retval = FALSE;
  int fd = -1;

  fd = open("testfile1.tst", O_RDWR);

  if (fd != -1) {

    error = fsync(fd);

    if (error != -1)
      retval = TRUE;
    else
      retval = FALSE;

    close(fd);
  }

  else
    retval = FALSE;

  /* assert (retval == TRUE);*/

  return(retval);
}

/* ---------------------------------------------------------------
 * Main function
 *
 *  main entry point to the test
 *
 * ---------------------------------------------------------------
 */

#if defined(__rtems__)
int test_main(void);
int test_main(void)
#else
int main(
  int    argc,
  char **argv
)
#endif
{
  TEST_BEGIN();

  if (InitFiles() == TRUE) {
    printf ("\nFiles initialized successfully.\n");

    printf ("Testing device_lseek()... ");
    if (DeviceLSeekTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

    printf ("Testing dup()............ ");
    if (DupTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

    printf ("Testing dup2()........... ");
    if (Dup2Test() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

    printf ("Testing fdatasync()...... ");
    if (FDataSyncTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

    printf ("Testing umask().......... ");
    if (UMaskTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

   printf ("Testing utime().......... ");
    if (UTimeTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

   printf ("Testing utimes().......... ");
    if (UTimesTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

   printf ("Testing fsync().......... ");
    if (FSyncTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

   printf ("Testing pathconf()....... ");
    if (PathConfTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

   printf ("Testing fpathconf()...... ");
    if (FPathConfTest() == TRUE)
      printf ("Success.\n");
    else
      printf ("Failed!!!\n");

    printf ("Testing sync()...... ");
    sync();
    printf ("Done.\n");

    TEST_END();
  }

  rtems_test_exit(0);
}