[PATCH] psx13: Reworked and relicensed

Joel Sherrill joel at rtems.org
Fri Apr 23 20:25:24 UTC 2021


On Fri, Apr 23, 2021 at 3:09 PM Joel Sherrill <joel at rtems.org> wrote:

>
>
> On Fri, Apr 23, 2021 at 3:08 PM Joel Sherrill <joel at rtems.org> wrote:
>
>>
>>
>> On Thu, Apr 22, 2021 at 11:06 AM Ryan Long <ryan.long at oarcorp.com> wrote:
>>
>>> >> +#ifdef __sparc__
>>> >What's this for?
>>> Joel said this was a special case, and that it needed to be put in, so
>>> I'm not sure.
>>>
>>
>> https://git.rtems.org/rtems/tree/cpukit/posix/src/sysconf.c#n57
>>
>> This was to support code in GCC which had hard-coded calls to this
>> sysconf()
>> in the SPARC backend but I grep'ed for them and didn't find them on
>> master.
>> Admittedly, I checked all the way back to egcs 1.1 and didn't find it
>> there either
>> so I am probably not looking right.
>>
>> If we are sure this isn't in GCC anymore, then it can be removed in a
>> follow up
>> patch.
>>
>
OK. Archeology update. The code in GCC requiring this was removed (drumroll
please......) 21 years ago!!!!

I have filed a ticket for this.

https://devel.rtems.org/ticket/4391#ticket

Ryan.. once this is merged, follow up with a simple patch to delete this
code.
#4391 is yours. :)

Thanks for triggering the investigation Gedare. Twenty years is a long time
to
carry this around and not need it.

>
>>
>>> For the printf's in test_main(), I should take out all of the print
>>> statements saying
>>>
>>> "Testing <function>.....Success"?
>>>
>>>
>>>
>>> -----Original Message-----
>>> From: Gedare Bloom <gedare at rtems.org>
>>> Sent: Thursday, April 22, 2021 8:45 AM
>>> To: Ryan Long <ryan.long at oarcorp.com>
>>> Cc: devel at rtems.org
>>> Subject: Re: [PATCH] psx13: Reworked and relicensed
>>>
>>> See below for comments. This test suite might be a good candidate for
>>> conversion to T_TEST_CASE framework. At any rate, this refactor is a marked
>>> improvement.
>>>
>>> On Wed, Apr 21, 2021 at 2:57 PM 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.
>>>
>>> relicense changes should generally Update #3899.
>>>
>>
> You can have two lines for ticket updates in the git commit (I think).
>
> close
> updates
>
>
>
>>
>>> > ---
>>> >  testsuites/psxtests/psx13/psx13.scn |  24 +-
>>> >  testsuites/psxtests/psx13/test.c    | 879
>>> +++++++++++++-----------------------
>>> >  2 files changed, 335 insertions(+), 568 deletions(-)
>>> >
>>> > diff --git a/testsuites/psxtests/psx13/psx13.scn
>>> > b/testsuites/psxtests/psx13/psx13.scn
>>> > index 428a931..ee99867 100644
>>> > --- a/testsuites/psxtests/psx13/psx13.scn
>>> > +++ b/testsuites/psxtests/psx13/psx13.scn
>>> > @@ -1,16 +1,16 @@
>>> >  *** POSIX TEST 13 ***
>>> >
>>> >  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()......
>>> > +Testing lseek() on device... Success.
>>> > +Testing dup()............... Success.
>>> > +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().............. Success.
>>> >
>>> > -*** 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..2d25b02 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)
>>> > +/**
>>> > + *  @file
>>> > + *
>>> > + *  @brief This tests various file system functions.
>>> >   *
>>> >   *  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
>>> > + *     - lseek()
>>> > + *     - dup()
>>> > + *     - dup2()
>>> > + *     - fdatasync()
>>> > + *     - fsync()
>>> > + *     - pathconf()
>>> > + *     - fpathconf()
>>> > + *     - umask()
>>> > + *     - utime()
>>> > + *     - utimes()
>>> > + *     - sync()
>>> > + */
>>> > +
>>>
>>> While you're at it, please conform to
>>>
>>> https://docs.rtems.org/branches/master/eng/coding-file-hdr.html#c-c-header-file-template
>>>
>>> > +/*
>>> > + *  SPDX-License-Identifier: BSD-2-Clause
>>> >   *
>>> > - *  COPYRIGHT (c) 1989-2009.
>>> > + *  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,428 @@
>>> >
>>> >  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 Hits the device_lseek code by lseeking on the console.
>>> >   */
>>> > -
>>> > -int DeviceLSeekTest (void)
>>> > +static void DeviceLSeekTest( void )
>>> >  {
>>> > -  int error = -1, retval = FALSE;
>>> > +  int rv;
>>> > +  int fd;
>>> >
>>> > -  int fd = open ("/dev/console", O_RDONLY);
>>> > +  fd = open( "/dev/console", O_RDONLY );  rtems_test_assert( fd != -1
>>> > + );
>>> >
>>> > -  error = lseek(fd, 5, SEEK_SET);
>>> > +  rv = lseek( fd, 5, SEEK_SET );
>>> > +  rtems_test_assert( rv == -1 );
>>> > +  rtems_test_assert( errno == ESPIPE );
>>> >
>>> > -  if (error == 0)
>>> > -    retval = TRUE;
>>> > -  else
>>> > -    retval = FALSE;
>>> > -
>>> > -  close( fd );  /* assert (retval == TRUE);*/
>>> > -
>>> > -  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);
>>> > -  fd2 = dup(fd1);
>>> > -
>>> > -  if (fd2 != -1) {
>>> > +  fd1 = open( "testfile1.tst", O_RDONLY );  rtems_test_assert( fd1 !=
>>> > + -1 );
>>> >
>>> > -    fcntl(fd1, F_SETFL, O_APPEND);
>>> > -    flags = fcntl(fd2, F_GETFL);
>>> > +  fd2 = dup( fd1 );
>>> > +  rtems_test_assert( fd2 != -1 );
>>> >
>>> > -    close (fd1);
>>> > +  rv = fcntl( fd1, F_SETFL, O_APPEND );  rtems_test_assert( rv != -1
>>> > + );
>>> >
>>> > -    flags = (flags & O_APPEND);
>>> > +  flags = fcntl( fd2, F_GETFL );
>>> > +  flags = ( flags & O_APPEND );
>>> minor nit, this could be more concise
>>> flags = fcntl( fd2, F_GETFL) & O_APPEND;
>>>
>>> > +  rtems_test_assert( flags == 0 );
>>> >
>>> > -    retval = (flags == O_APPEND);
>>> > -  }
>>> > -
>>> > -  else
>>> > -    retval = FALSE;
>>> > +  rv = close( fd1 );
>>> > +  rtems_test_assert( rv == 0 );
>>> >
>>> Just curious, why be inconsistent how you check for the return from
>>> close? Above using != EOF, here using == 0. It doesn't matter greatly.
>>>
>>> > -  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;
>>> > -
>>> > -  int error = 0;
>>> > +  fd1 = open( "testfile1.tst", O_RDONLY );  rtems_test_assert( fd1 !=
>>> > + -1 );
>>> >
>>> > -  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) {
>>> > +  rv = fcntl( fd1, F_SETFL, O_APPEND );  rtems_test_assert( rv != -1
>>> > + );
>>> >
>>> > -    fcntl(fd1, F_SETFL, O_APPEND);
>>> > -    flags = fcntl(fd1, F_GETFL);
>>> > +  flags = fcntl( fd1, F_GETFL );
>>> > +  flags = ( flags & O_APPEND );
>>> > +  rtems_test_assert( flags == O_APPEND );
>>> ditto on both conciseness and consistency here.
>>>
>>> >
>>> > -    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) */  rv = close( fd1 );  rtems_test_assert( rv ==
>>> > + 0 );
>>> >
>>> > -    /* 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;
>>> >
>>> > -    fd1 = -1;
>>> > +  rv = dup2( fd1, fd2 );
>>> > +  rtems_test_assert( rv == -1 );
>>> >
>>> > -    if (dup2 (fd1, fd2) != -1)
>>> > -      retval = FALSE;
>>> > -    else {
>>> > -      fd1 = dup(fd2);
>>> > -      fd2 = -1;
>>> > +  fd1 = dup( fd2 );
>>> > +  fd2 = -1;
>>> >
>>> > -      if (dup2(fd1, fd2) != -1)
>>> > -       retval = FALSE;
>>> > -    }
>>> > -  }
>>> > -
>>> > -  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;
>>> > +  rv = fdatasync( fd );
>>> > +  rtems_test_assert( rv == -1 );
>>> > +  rtems_test_assert( errno == EBADF );
>>> >
>>> > -  close (fd);
>>> > +  rv = close(fd);
>>> > +  rtems_test_assert( rv == 0 );
>>> >
>>> > -  if (retval == TRUE) {
>>> > +  /* Try it with a bad file descriptor */  fd = -1;
>>> >
>>> > -    /* Try it with a bad file descriptor */
>>> > -
>>> > -    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 Hits the umask code.
>>> >   */
>>> > -
>>> > -int UMaskTest (void)
>>> > +static void UMaskTest( void )
>>> >  {
>>> > -  mode_t error = 0;
>>> > -  int    retval = FALSE;
>>> > -
>>> > -  umask(023);
>>> > -  error = umask(022);
>>> > +  mode_t rv;
>>> >
>>> > -  if (error == 023)
>>> > -    retval = TRUE;
>>> > -  else
>>> > -    retval = FALSE;
>>> > +  (void)umask( 023 );
>>> nit: add a space after (void)
>>>
>>> >
>>> > -  /* 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 Hits the utime code. 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);
>>> > +  time.actime  = 12345;
>>> > +  time.modtime = 54321;
>>> >
>>> > -    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;
>>> > -  }
>>> > +  rv = utime( "testfile1.tst", &time );  rtems_test_assert( rv == 0
>>> > + );
>>> >
>>> > -  /* assert (retval == TRUE);*/
>>> > +  /* 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 );
>>> >
>>> > -  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 Hits the utimes code. 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;
>>> >
>>> > -    time[0].tv_sec = 12345;
>>> > -    time[1].tv_sec = 54321;
>>> > +  rv = utimes( "testfile1.tst", (struct timeval *)&time );
>>> > + rtems_test_assert( rv == 0 );
>>> >
>>> > -    error = utimes("testfile1.tst", (struct timeval *)&time);
>>> > +  /* 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 ); }
>>> >
>>> > -    if (error == 0) {
>>> > +/**
>>> > + * @brief Hits the pathconf code.
>>> > + */
>>> > +static void PathConfTest( void )
>>> > +{
>>> > +  int rv;
>>> >
>>> > -      /* But, did it set the time? */
>>> > -      stat ("testfile1.tst", &fstat);
>>> > +  rv = pathconf( "thisfiledoesnotexist", _PC_LINK_MAX );
>>> > + rtems_test_assert( rv == -1 );
>>> >
>>> > -      if ((fstat.st_atime == 12345) && (fstat.st_mtime == 54321 ))
>>> > -       retval = TRUE;
>>> > -      else
>>> > -       retval = FALSE;
>>> > -    }
>>> > +  rv = pathconf( "testfile1.tst", _PC_LINK_MAX );
>>> > +  rtems_test_assert( rv != -1 );
>>> > +}
>>> >
>>> > -    else
>>> > -      retval = FALSE;
>>> > -  }
>>> > +/**
>>> > + * @brief Hits the fpathconf code.
>>> > + */
>>> > +static void FPathConfTest( void )
>>> > +{
>>> > +  int rv;
>>> > +  int fd;
>>> >
>>> > -  /* assert (retval == TRUE);*/
>>> > +  fd = -1;
>>> > +  rv = fpathconf( fd, _PC_LINK_MAX );  rtems_test_assert( rv == -1 );
>>> >
>>> > -  return (retval);
>>> > -}
>>> > +  fd = open( "testfile1.tst", O_RDWR );  rtems_test_assert( fd != -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.
>>> > - *
>>> > - * ---------------------------------------------------------------
>>> > - */
>>> > +  rv = fpathconf( fd, _PC_LINK_MAX );  rtems_test_assert( rv != -1 );
>>> >
>>> > -int PathConfTest (void)
>>> > -{
>>> > -  int error = 0, retval = FALSE;
>>> > +  rv = fpathconf( fd, _PC_MAX_CANON );  rtems_test_assert( rv != -1
>>> > + );
>>> >
>>> > -  error = pathconf("thisfiledoesnotexist", _PC_LINK_MAX);
>>> > +  rv = fpathconf( fd, _PC_MAX_INPUT );  rtems_test_assert( rv != -1
>>> > + );
>>> >
>>> > -  if (error == -1) {
>>> > -    error = pathconf("testfile1.tst", _PC_LINK_MAX);
>>> > +  rv = fpathconf( fd, _PC_NAME_MAX );  rtems_test_assert( rv != -1 );
>>> >
>>> > -    if (error != -1)
>>> > -      retval = TRUE;
>>> > -    else
>>> > -      retval = FALSE;
>>> > -  }
>>> > +  rv = fpathconf( fd, _PC_PATH_MAX );  rtems_test_assert( rv != -1 );
>>> >
>>> > -  else
>>> > -    retval = FALSE;
>>> > +  rv = fpathconf( fd, _PC_PIPE_BUF );  rtems_test_assert( rv != -1 );
>>> >
>>> > -  /* assert (retval == TRUE);*/
>>> > +  rv = fpathconf( fd, _PC_CHOWN_RESTRICTED );  rtems_test_assert( rv
>>> > + != -1 );
>>> >
>>> > -  return(retval);
>>> > -}
>>> > +  rv = fpathconf( fd, _PC_NO_TRUNC );  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_VDISABLE );  rtems_test_assert( rv != -1 );
>>> >
>>> > -int FPathConfTest (void)
>>> > -{
>>> > -  int error = 0, retval = TRUE;
>>> > +  rv = fpathconf( fd, _PC_ASYNC_IO );  rtems_test_assert( rv != -1 );
>>> >
>>> > -  int fd  = -1;
>>> > +  rv = fpathconf( fd, _PC_PRIO_IO );
>>> > +  rtems_test_assert( rv != -1 );
>>> >
>>> > -  error = fpathconf(fd, _PC_LINK_MAX);
>>> > +  rv = fpathconf( fd, _PC_SYNC_IO );
>>> > +  rtems_test_assert( rv != -1 );
>>> >
>>> > -  if (error == -1) {
>>> > -    fd = open("testfile1.tst", O_RDWR);
>>> > +  rv = fpathconf( fd, 255 );
>>> > +#ifdef __sparc__
>>> What's this for?
>>>
>>> > +  rtems_test_assert( rv == 0 );
>>> > +#else
>>> > +  rtems_test_assert( rv == -1 );
>>> > +#endif
>>> >
>>> > -    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 = close( fd );
>>> > +  rtems_test_assert( rv == 0 );
>>> >
>>> > -    close(fd);
>>> > +  fd = open( "testfile1.tst", O_WRONLY );  rtems_test_assert( rv !=
>>> > + -1 );
>>> >
>>> > -    fd = open("testfile1.tst", O_WRONLY);
>>> > +  rv = fpathconf( fd, _PC_LINK_MAX );  rtems_test_assert( rv != -1 );
>>> >
>>> > -    error = fpathconf(fd, _PC_LINK_MAX);
>>> > +  rv = close( fd );
>>> > +  rtems_test_assert( rv == 0 );
>>> > +}
>>> >
>>> > -    retval = TRUE;
>>> > -  }
>>> > +/**
>>> > + * @brief Hits the fsync code.
>>> > + */
>>> > +static void FSyncTest( void )
>>> > +{
>>> > +  int rv;
>>> > +  int fd;
>>> >
>>> > -  else
>>> > -    retval = FALSE;
>>> > +  fd = open( "testfile1.tst", O_RDWR );  rtems_test_assert( fd != -1
>>> > + );
>>> >
>>> > -  /* assert (retval == TRUE);*/
>>> > +  rv = fsync(fd);
>>> > +  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 sync().
>>> >   */
>>> > +static void SyncTest( void )
>>> > +{
>>> > +  sync();
>>> > +}
>>> >
>>> > -int FSyncTest (void)
>>> > +/**
>>> > + * @brief The main entry point to the test.
>>> > + */
>>> > +int test_main( void );
>>> > +int test_main( void )
>>> >  {
>>> > -  int error = 0, retval = FALSE;
>>> > -  int fd = -1;
>>> > +  TEST_BEGIN();
>>> >
>>> > -  fd = open("testfile1.tst", O_RDWR);
>>> > +  InitFiles();
>>> > +  printf( "\nFiles initialized successfully.\n" );
>>> >
>>> remove the extraneous print statements. If things are working, the test
>>> output should be minimal/quiet just the start/end banners.
>>>
>>> > -  if (fd != -1) {
>>> > +  printf( "Testing lseek() on device... " );  DeviceLSeekTest();
>>> > + printf( "Success.\n" );
>>> >
>>> > -    error = fsync(fd);
>>> > +  printf( "Testing dup()............... " );  DupTest();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -    if (error != -1)
>>> > -      retval = TRUE;
>>> > -    else
>>> > -      retval = FALSE;
>>> > +  printf( "Testing dup2().............. " );  Dup2Test();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -    close(fd);
>>> > -  }
>>> > +  printf( "Testing fdatasync()......... " );  FDataSyncTest();
>>> > + printf( "Success.\n" );
>>> >
>>> > -  else
>>> > -    retval = FALSE;
>>> > +  printf( "Testing umask()............. " );  UMaskTest();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -  /* assert (retval == TRUE);*/
>>> > +  printf( "Testing utime()............. " );  UTimeTest();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -  return(retval);
>>> > -}
>>> > +  printf( "Testing utimes()............ " );  UTimesTest();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -/* ---------------------------------------------------------------
>>> > - * Main function
>>> > - *
>>> > - *  main entry point to the test
>>> > - *
>>> > - * ---------------------------------------------------------------
>>> > - */
>>> > +  printf( "Testing fsync()............. " );  FSyncTest();  printf(
>>> > + "Success.\n" );
>>> >
>>> > -#if defined(__rtems__)
>>> > -int test_main(void);
>>> > -int test_main(void)
>>> > -#else
>>> > -int main(
>>> > -  int    argc,
>>> > -  char **argv
>>> > -)
>>> > -#endif
>>> > -{
>>> > -  TEST_BEGIN();
>>> > +  printf( "Testing pathconf().......... " );  PathConfTest();
>>> > + printf( "Success.\n" );
>>> >
>>> > -  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();
>>> > -  }
>>> > +  printf( "Testing fpathconf()......... " );  FPathConfTest();
>>> > + printf( "Success.\n" );
>>> > +
>>> > +  printf( "Testing sync().............. " );  SyncTest();  printf(
>>> > + "Success.\n" );
>>> > +
>>> > +  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
>>> _______________________________________________
>>> devel mailing list
>>> devel at rtems.org
>>> http://lists.rtems.org/mailman/listinfo/devel
>>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.rtems.org/pipermail/devel/attachments/20210423/6d170ec0/attachment-0001.html>


More information about the devel mailing list