[PATCH v4] psx13: Reworked and relicensed

Gedare Bloom gedare at rtems.org
Mon Apr 26 19:17:09 UTC 2021


Looks ok, confirm you tested with/without debug, and go ahead and push.

On Mon, Apr 26, 2021 at 10:10 AM Ryan Long <ryan.long at oarcorp.com> wrote:
>
> Changed the way the tests were structured, added rtems_test_assert()'s,
> updated psx13.scn and the license.
>
> Update #3899
> ---
>  testsuites/psxtests/psx13/main.c    |  37 +-
>  testsuites/psxtests/psx13/psx13.scn |  21 +-
>  testsuites/psxtests/psx13/test.c    | 852 ++++++++++++------------------------
>  3 files changed, 328 insertions(+), 582 deletions(-)
>
> diff --git a/testsuites/psxtests/psx13/main.c b/testsuites/psxtests/psx13/main.c
> index 20788b3..f9e7907 100644
> --- a/testsuites/psxtests/psx13/main.c
> +++ b/testsuites/psxtests/psx13/main.c
> @@ -1,14 +1,37 @@
> -/*
> - *  Simple test program -- simplified version of sample test hello.
> +/*  SPDX-License-Identifier: BSD-2-Clause */
> +
> +/**
> + *  @file
>   *
> - *  COPYRIGHT (c) 1989-2009.
> - *  On-Line Applications Research Corporation (OAR).
> + *  @brief Simple test program -- simplified version of sample test hello.
>   *
> - *  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.
>   */
>
> +/*
> + *  COPYRIGHT (c) 1989-2009, 2021.
> + *  On-Line Applications Research Corporation (OAR).
> + *
> + * Redistribution and use in source and binary forms, with or without
> + * modification, are permitted provided that the following conditions
> + * are met:
> + * 1. Redistributions of source code must retain the above copyright
> + *    notice, this list of conditions and the following disclaimer.
> + * 2. Redistributions in binary form must reproduce the above copyright
> + *    notice, this list of conditions and the following disclaimer in the
> + *    documentation and/or other materials provided with the distribution.
> + *
> + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
> + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> + * * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
> + * POSSIBILITY OF SUCH DAMAGE.
> + */
>
>  #ifdef HAVE_CONFIG_H
>  #include "config.h"
> diff --git a/testsuites/psxtests/psx13/psx13.scn b/testsuites/psxtests/psx13/psx13.scn
> index 428a931..efa79c9 100644
> --- a/testsuites/psxtests/psx13/psx13.scn
> +++ b/testsuites/psxtests/psx13/psx13.scn
> @@ -1,16 +1,7 @@
> -*** POSIX TEST 13 ***
> +*** BEGIN OF TEST PSX 13 ***
> +*** TEST VERSION: 6.0.0.75f80242186af2dde0c5bc7272a119e3b78d7ba0
> +*** TEST STATE: EXPECTED_PASS
> +*** TEST BUILD: RTEMS_DEBUG RTEMS_POSIX_API
> +*** TEST TOOLS: 10.2.1 20210309 (RTEMS 6, RSB 5e449fb5c2cb6812a238f9f9764fd339cbbf05c2, Newlib d10d0d9)
>
> -Files initialized successfully.
> -Testing device_lseek()... Failed!!!
> -Testing dup()............ Failed!!!
> -Testing dup2()........... Success.
> -Testing fdatasync()...... Success.
> -Testing umask().......... Success.
> -Testing utime().......... Success.
> -Testing utimes().......... Success.
> -Testing fsync().......... Success.
> -Testing pathconf()....... Success.
> -Testing fpathconf()...... Success.
> -Testing sync()......
> -
> -*** END OF TEST PSX13 ***
> +*** END OF TEST PSX 13 ***
> diff --git a/testsuites/psxtests/psx13/test.c b/testsuites/psxtests/psx13/test.c
> index 79b24c2..a82242b 100644
> --- a/testsuites/psxtests/psx13/test.c
> +++ b/testsuites/psxtests/psx13/test.c
> @@ -1,26 +1,49 @@
> -/*
> - *  Psx13
> - *  Chris Bond (working under Jennifer's account)
> +/*  SPDX-License-Identifier: BSD-2-Clause */
> +
> +/**
> + *  @file
>   *
> - *  This test exercises the following routines:
> + *  @brief This tests various file system functions.
>   *
> - *     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
> + *  This test exercises the following routines:
>   *
> - *  COPYRIGHT (c) 1989-2009.
> + *     - lseek()
> + *     - dup()
> + *     - dup2()
> + *     - fdatasync()
> + *     - fsync()
> + *     - pathconf()
> + *     - fpathconf()
> + *     - umask()
> + *     - utime()
> + *     - utimes()
> + *     - sync()
> + */
> +
> +/*
> + *  COPYRIGHT (c) 1989-2009, 2021.
>   *  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.
> + * Redistribution and use in source and binary forms, with or without
> + * modification, are permitted provided that the following conditions
> + * are met:
> + * 1. Redistributions of source code must retain the above copyright
> + *    notice, this list of conditions and the following disclaimer.
> + * 2. Redistributions in binary form must reproduce the above copyright
> + *    notice, this list of conditions and the following disclaimer in the
> + *    documentation and/or other materials provided with the distribution.
> + *
> + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
> + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
> + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
> + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
> + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
> + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
> + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
> + * * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
> + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
> + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
> + * POSSIBILITY OF SUCH DAMAGE.
>   */
>
>  #ifdef HAVE_CONFIG_H
> @@ -34,6 +57,7 @@
>  #include <unistd.h>
>  #include <errno.h>
>  #include <utime.h>
> +#include <tmacros.h>
>
>  #include <stdio.h>
>  #include <unistd.h>
> @@ -42,685 +66,393 @@
>
>  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.
> - *
> - * ------------------------------------------------------------------
> +/**
> + * @brief Initializes the three files to be used for the test.
>   */
> -
> -int InitFiles (void)
> +static void InitFiles( void )
>  {
>    int count;
> +  int rv;
>    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)) {
> +  fp1 = fopen( "testfile1.tst", "wt" );
> +  rtems_test_assert( fp1 != NULL );
>
> -    letter = 'a';
> +  fp2 = fopen( "testfile2.tst", "wt" );
> +  rtems_test_assert( fp2 != NULL );
>
> -    for (count=0 ; count<(26*4); ++count) {
> -      fprintf (fp1, "%c", letter);
> -      fprintf (fp2, "%c", letter);
> +  fp3 = fopen( "testfile4.tst", "wb" );
> +  rtems_test_assert( fp3 != NULL );
>
> -      ++letter;
> -      if (letter > 'z')
> -       letter = 'a';
> -    }
> +  letter = 'a';
>
> -    number = 0;
> +  for( count = 0 ; count < (26*4); ++count) {
> +    fprintf( fp1, "%c", letter );
> +    fprintf( fp2, "%c", letter );
>
> -    for (count = 0; count <40; ++count) {
> -
> -      fwrite (&number, 1, sizeof(int), fp3);
> +    ++letter;
> +    if( letter > 'z' )
> +      letter = 'a';
> +  }
>
> -      ++number;
> -      if (number > 9)
> -       number = 0;
> -    }
> +  number = 0;
>
> -    fclose(fp1);
> -    fclose(fp2);
> -    fclose(fp3);
> +  for( count = 0; count < 40; ++count ) {
> +    fwrite( &number, 1, sizeof(int), fp3 );
>
> -    retval = TRUE;
> +    ++number;
> +    if( number > 9 )
> +      number = 0;
>    }
>
> -  else
> -    retval = FALSE;
> +  rv = fclose( fp1 );
> +  rtems_test_assert( rv != EOF );
>
> -  /* assert (retval == TRUE);*/
> +  rv = fclose( fp2 );
> +  rtems_test_assert( rv != EOF );
>
> -  return (retval);
> +  rv = fclose( fp3 );
> +  rtems_test_assert( rv != EOF );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises lseek() by lseeking on the console.
>   */
> -
> -int DeviceLSeekTest (void)
> +static void DeviceLSeekTest( void )
>  {
> -  int error = -1, retval = FALSE;
> -
> -  int fd = open ("/dev/console", O_RDONLY);
> -
> -  error = lseek(fd, 5, SEEK_SET);
> +  int rv;
> +  int fd;
>
> -  if (error == 0)
> -    retval = TRUE;
> -  else
> -    retval = FALSE;
> +  fd = open( "/dev/console", O_RDONLY );
> +  rtems_test_assert( fd != -1 );
>
> -  close( fd );  /* assert (retval == TRUE);*/
> +  rv = lseek( fd, 5, SEEK_SET );
> +  rtems_test_assert( rv == -1 );
> +  rtems_test_assert( errno == ESPIPE );
>
> -  return (retval);
> +  rv = close( fd );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises dup().
>   */
> -
> -int DupTest(void)
> +static void DupTest( void )
>  {
>    int fd1, fd2;
> +  int flags;
> +  int rv;
>
> -  int flags = 0, retval = FALSE;
> +  fd1 = open( "testfile1.tst", O_RDONLY );
> +  rtems_test_assert( fd1 != -1 );
>
> -  fd1 = open ("testfile1.tst", O_RDONLY);
> -  fd2 = dup(fd1);
> +  fd2 = dup( fd1 );
> +  rtems_test_assert( fd2 != -1 );
>
> -  if (fd2 != -1) {
> +  rv = fcntl( fd1, F_SETFL, O_APPEND );
> +  rtems_test_assert( rv != -1 );
>
> -    fcntl(fd1, F_SETFL, O_APPEND);
> -    flags = fcntl(fd2, F_GETFL);
> +  flags = fcntl( fd2, F_GETFL ) & O_APPEND;
> +  rtems_test_assert( flags == 0 );
>
> -    close (fd1);
> +  rv = close( fd1 );
> +  rtems_test_assert( rv == 0 );
>
> -    flags = (flags & O_APPEND);
> -
> -    retval = (flags == O_APPEND);
> -  }
> -
> -  else
> -    retval = FALSE;
> -
> -  close( fd1 );
> -  close( fd2 );
> -  /* assert (retval == TRUE);*/
> -
> -  return (retval);
> +  rv = close( fd2 );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises dup2().
>   */
> -
> -int Dup2Test(void)
> +static void Dup2Test( void )
>  {
>    int fd1, fd2;
> +  int flags;
> +  int rv;
>
> -  int flags = 0, retval = FALSE;
> +  fd1 = open( "testfile1.tst", O_RDONLY );
> +  rtems_test_assert( fd1 != -1 );
>
> -  int error = 0;
> -
> -  fd1 = open ("testfile1.tst", O_RDONLY);
> -  fd2 = open ("testfile2.tst", O_RDONLY);
> -  error = dup2(fd1, fd2);
> +  fd2 = open( "testfile2.tst", O_RDONLY );
> +  rtems_test_assert( fd2 != -1 );
>
>    /* make sure dup2 works if both fd1 and fd2 are valid file descriptors. */
> +  rv = dup2( fd1, fd2 );
> +  rtems_test_assert( rv != -1 );
>
> -  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);
> -  }
> +  rv = fcntl( fd1, F_SETFL, O_APPEND );
> +  rtems_test_assert( rv != -1 );
>
> -  if (retval == TRUE) {
> +  flags = fcntl( fd1, F_GETFL ) & O_APPEND;
> +  rtems_test_assert( flags == O_APPEND );
>
> -    /* 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) */
> +  /* 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) */
> +  rv = close( fd1 );
> +  rtems_test_assert( rv == 0 );
>
> -    fd1 = -1;
> +  fd1 = -1;
>
> -    if (dup2 (fd1, fd2) != -1)
> -      retval = FALSE;
> -    else {
> -      fd1 = dup(fd2);
> -      fd2 = -1;
> +  rv = dup2( fd1, fd2 );
> +  rtems_test_assert( rv == -1 );
>
> -      if (dup2(fd1, fd2) != -1)
> -       retval = FALSE;
> -    }
> -  }
> +  fd1 = dup( fd2 );
> +  fd2 = -1;
>
> -  close (fd1);
> -  close (fd2);
> -  /* assert (retval == TRUE);*/
> +  rv = dup2( fd1, fd2 );
> +  rtems_test_assert( rv == -1 );
>
> -  return (retval);
> +  rv = close( fd1 );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises fdatasync(). Does NOT test the functionality of the
> + *        underlying fdatasync entry in the IMFS op table.
>   */
> -
> -int FDataSyncTest(void)
> +static void FDataSyncTest( void )
>  {
> -  int fd = -1;
> -  int error = 0, retval = TRUE;
> +  int fd;
> +  int rv;
>
>    /* Try it with a RD_ONLY file. */
> +  fd = open( "testfile1.tst", O_RDONLY );
> +  rtems_test_assert( fd != -1 );
>
> -  fd = open ("testfile1.tst", O_RDONLY);
> -
> -  error = fdatasync(fd);
> -  if ((error == -1) && (errno == EINVAL))
> -    retval = TRUE;
> -  else
> -    retval = FALSE;
> -
> -  close (fd);
> +  rv = fdatasync( fd );
> +  rtems_test_assert( rv == -1 );
> +  rtems_test_assert( errno == EBADF );
>
> -  if (retval == TRUE) {
> +  rv = close(fd);
> +  rtems_test_assert( rv == 0 );
>
> -    /* Try it with a bad file descriptor */
> +  /* Try it with a bad file descriptor */
> +  fd = -1;
>
> -    fd = -1;
> -
> -    error = fdatasync(fd);
> -    if ((errno == EBADF) && (error == -1))
> -      retval = TRUE;
> -    else
> -      retval = FALSE;
> -  }
> +  rv = fdatasync( fd );
> +  rtems_test_assert( rv == -1 );
> +  rtems_test_assert( errno == EBADF );
>
>    /* Okay - now the success case... */
> +  fd = open( "testfile1.tst", O_RDWR );
> +  rv = fdatasync( fd );
> +  rtems_test_assert( rv == 0 );
>
> -  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);
> +  rv = close( fd );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises umask().
>   */
> -
> -int UMaskTest (void)
> +static void UMaskTest( void )
>  {
> -  mode_t error = 0;
> -  int    retval = FALSE;
> +  mode_t rv;
>
> -  umask(023);
> -  error = umask(022);
> +  (void) umask( 023 );
>
> -  if (error == 023)
> -    retval = TRUE;
> -  else
> -    retval = FALSE;
> -
> -  /* assert (retval == TRUE);*/
> -
> -  return(retval);
> +  rv = umask( 022 );
> +  rtems_test_assert( rv == 023 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises utime(). Does not test the functionality of the
> + *        underlying utime entry in the IMFS op table.
>   */
> -
> -int UTimeTest (void)
> +static void UTimeTest( void )
>  {
> -  int error = 0, retval = FALSE;
> +  int rv;
>    struct utimbuf time;
>    struct stat fstat;
>
>    /* First, an invalid filename. */
> -  error = utime("!This is an =invalid p at thname!!! :)", NULL);
> -
> -  if (error == -1)
> -    retval = TRUE;
> -  else
> -    retval = FALSE;
> +  rv = utime( "!This is an =invalid p at thname!!! :)", NULL );
> +  rtems_test_assert( rv == -1 );
> +  rtems_test_assert( errno == ENOENT );
>
>    /* Now, the success test. */
> -  if (retval == TRUE) {
> -
> -    time.actime  = 12345;
> -    time.modtime = 54321;
> -
> -    error = utime("testfile1.tst", &time);
> -
> -    if (error == 0) {
> +  time.actime  = 12345;
> +  time.modtime = 54321;
>
> -      /* But, did it set the time? */
> -      stat ("testfile1.tst", &fstat);
> +  rv = utime( "testfile1.tst", &time );
> +  rtems_test_assert( rv == 0 );
>
> -      if ((fstat.st_atime == 12345) && (fstat.st_mtime == 54321 ))
> -       retval = TRUE;
> -      else
> -       retval = FALSE;
> -    }
> -    else
> -      retval = FALSE;
> +  /* But, did it set the time? */
> +  rv = stat( "testfile1.tst", &fstat );
> +  rtems_test_assert( rv == 0 );
> +  rtems_test_assert( fstat.st_atime == 12345 );
> +  rtems_test_assert( fstat.st_mtime == 54321 );
>
> -    error = utime("testfile1.tst", NULL );
> -    retval &= (error == 0) ? TRUE : FALSE;
> -  }
> -
> -  /* assert (retval == TRUE);*/
> -
> -  return (retval);
> +  rv = utime( "testfile1.tst", NULL );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises utimes(). Does NOT test the functionality of the
> + *        underlying utime entry in the IMFS op table.
>   */
> -
> -int UTimesTest (void)
> +static void UTimesTest( void )
>  {
> -  int error = 0, retval = FALSE;
> +  int rv;
>    struct timeval time[2];
>    struct stat fstat;
>
>    /* First, an invalid filename. */
> -  error = utimes("!This is an =invalid p at thname!!! :)", NULL);
> -
> -  if (error == -1)
> -    retval = TRUE;
> -  else
> -    retval = FALSE;
> +  rv = utimes( "!This is an =invalid p at thname!!! : )", NULL);
> +  rtems_test_assert( rv == -1 );
> +  rtems_test_assert( errno == ENOENT );
>
>    /* 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) {
> +  time[0].tv_sec = 12345;
> +  time[1].tv_sec = 54321;
>
> -      /* But, did it set the time? */
> -      stat ("testfile1.tst", &fstat);
> +  rv = utimes( "testfile1.tst", (struct timeval *)&time );
> +  rtems_test_assert( rv == 0 );
>
> -      if ((fstat.st_atime == 12345) && (fstat.st_mtime == 54321 ))
> -       retval = TRUE;
> -      else
> -       retval = FALSE;
> -    }
> +  /* But, did it set the time? */
> +  rv = stat( "testfile1.tst", &fstat );
> +  rtems_test_assert( rv == 0 );
> +  rtems_test_assert( fstat.st_atime == 12345 );
> +  rtems_test_assert( fstat.st_mtime == 54321 );
> +}
>
> -    else
> -      retval = FALSE;
> -  }
> +/**
> + * @brief Exercises pathconf().
> + */
> +static void PathConfTest( void )
> +{
> +  int rv;
>
> -  /* assert (retval == TRUE);*/
> +  rv = pathconf( "thisfiledoesnotexist", _PC_LINK_MAX );
> +  rtems_test_assert( rv == -1 );
>
> -  return (retval);
> +  rv = pathconf( "testfile1.tst", _PC_LINK_MAX );
> +  rtems_test_assert( rv != -1 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises fpathconf().
>   */
> -
> -int PathConfTest (void)
> +static void FPathConfTest( void )
>  {
> -  int error = 0, retval = FALSE;
> +  int rv;
> +  int fd;
>
> -  error = pathconf("thisfiledoesnotexist", _PC_LINK_MAX);
> +  fd = -1;
> +  rv = fpathconf( fd, _PC_LINK_MAX );
> +  rtems_test_assert( rv == -1 );
>
> -  if (error == -1) {
> -    error = pathconf("testfile1.tst", _PC_LINK_MAX);
> +  fd = open( "testfile1.tst", O_RDWR );
> +  rtems_test_assert( fd != -1 );
>
> -    if (error != -1)
> -      retval = TRUE;
> -    else
> -      retval = FALSE;
> -  }
> +  rv = fpathconf( fd, _PC_LINK_MAX );
> +  rtems_test_assert( rv != -1 );
>
> -  else
> -    retval = FALSE;
> +  rv = fpathconf( fd, _PC_MAX_CANON );
> +  rtems_test_assert( rv != -1 );
>
> -  /* assert (retval == TRUE);*/
> +  rv = fpathconf( fd, _PC_MAX_INPUT );
> +  rtems_test_assert( rv != -1 );
>
> -  return(retval);
> -}
> +  rv = fpathconf( fd, _PC_NAME_MAX );
> +  rtems_test_assert( rv != -1 );
>
> -/* ---------------------------------------------------------------
> - * FPathConfTest function
> - *
> - * Hits the fpathconf code.
> - *
> - * arguments: none
> - * assumptions: fpathconf function available.
> - * actions: Call fpathconf with all arguments, plus an invalid.
> - *
> - * returns: TRUE always.
> - *
> - * ---------------------------------------------------------------
> - */
> +  rv = fpathconf( fd, _PC_PATH_MAX );
> +  rtems_test_assert( rv != -1 );
>
> -int FPathConfTest (void)
> -{
> -  int error = 0, retval = TRUE;
> +  rv = fpathconf( fd, _PC_PIPE_BUF );
> +  rtems_test_assert( rv != -1 );
>
> -  int fd  = -1;
> +  rv = fpathconf( fd, _PC_CHOWN_RESTRICTED );
> +  rtems_test_assert( rv != -1 );
>
> -  error = fpathconf(fd, _PC_LINK_MAX);
> +  rv = fpathconf( fd, _PC_NO_TRUNC );
> +  rtems_test_assert( rv != -1 );
>
> -  if (error == -1) {
> -    fd = open("testfile1.tst", O_RDWR);
> +  rv = fpathconf( fd, _PC_VDISABLE );
> +  rtems_test_assert( rv != -1 );
>
> -    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);
> +  rv = fpathconf( fd, _PC_ASYNC_IO );
> +  rtems_test_assert( rv != -1 );
>
> -    close(fd);
> +  rv = fpathconf( fd, _PC_PRIO_IO );
> +  rtems_test_assert( rv != -1 );
>
> -    fd = open("testfile1.tst", O_WRONLY);
> +  rv = fpathconf( fd, _PC_SYNC_IO );
> +  rtems_test_assert( rv != -1 );
>
> -    error = fpathconf(fd, _PC_LINK_MAX);
> +  rv = fpathconf( fd, 255 );
> +#ifdef __sparc__
> +  rtems_test_assert( rv == 0 );
> +#else
> +  rtems_test_assert( rv == -1 );
> +#endif
>
> -    retval = TRUE;
> -  }
> +  rv = close( fd );
> +  rtems_test_assert( rv == 0 );
>
> -  else
> -    retval = FALSE;
> +  fd = open( "testfile1.tst", O_WRONLY );
> +  rtems_test_assert( rv != -1 );
>
> -  /* assert (retval == TRUE);*/
> +  rv = fpathconf( fd, _PC_LINK_MAX );
> +  rtems_test_assert( rv != -1 );
>
> -  return(retval);
> +  rv = close( fd );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * 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.
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises fsync().
>   */
> -
> -int FSyncTest (void)
> +static void FSyncTest( void )
>  {
> -  int error = 0, retval = FALSE;
> -  int fd = -1;
> -
> -  fd = open("testfile1.tst", O_RDWR);
> +  int rv;
> +  int fd;
>
> -  if (fd != -1) {
> +  fd = open( "testfile1.tst", O_RDWR );
> +  rtems_test_assert( fd != -1 );
>
> -    error = fsync(fd);
> +  rv = fsync(fd);
> +  rtems_test_assert( rv != -1 );
>
> -    if (error != -1)
> -      retval = TRUE;
> -    else
> -      retval = FALSE;
> -
> -    close(fd);
> -  }
> -
> -  else
> -    retval = FALSE;
> -
> -  /* assert (retval == TRUE);*/
> -
> -  return(retval);
> +  rv = close( fd );
> +  rtems_test_assert( rv == 0 );
>  }
>
> -/* ---------------------------------------------------------------
> - * Main function
> - *
> - *  main entry point to the test
> - *
> - * ---------------------------------------------------------------
> +/**
> + * @brief Exercises sync().
>   */
> +static void SyncTest( void )
> +{
> +  sync();
> +}
>
> -#if defined(__rtems__)
> -int test_main(void);
> -int test_main(void)
> -#else
> -int main(
> -  int    argc,
> -  char **argv
> -)
> -#endif
> +/**
> + * @brief The main entry point to the test.
> + */
> +int test_main( void );
> +int test_main( void )
>  {
>    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();
> -  }
> +  InitFiles();
> +
> +  DeviceLSeekTest();
> +  DupTest();
> +  Dup2Test();
> +  FDataSyncTest();
> +  UMaskTest();
> +  UTimeTest();
> +  UTimesTest();
> +  FSyncTest();
> +  PathConfTest();
> +  FPathConfTest();
> +  SyncTest();
> +
> +  TEST_END();
>
> -  rtems_test_exit(0);
> +  rtems_test_exit( 0 );
>  }
> --
> 1.8.3.1
>
> _______________________________________________
> devel mailing list
> devel at rtems.org
> http://lists.rtems.org/mailman/listinfo/devel


More information about the devel mailing list