URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [psxtests/] [psxfile01/] [test.c] - Blame information for rev 509

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  Simple test program to exercise some of the basic functionality of
 *  POSIX Files and Directories Support.
 *
 *  This test assumes that the file system is initialized with the
 *  following directory structure:
 *
 *  XXXX fill this in.
 *    /
 *    /dev
 *    /dev/XXX   [where XXX includes at least console]
 *
 *  COPYRIGHT (c) 1989-1999.
 *  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.OARcorp.com/rtems/license.html.
 *
 *  $Id: test.c,v 1.2 2001-09-27 12:02:25 chris Exp $
 */
 
#include <stdio.h>
 
#include <tmacros.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
 
#include <assert.h>
#include <rtems.h>
#include <rtems/libio.h>
 
char test_write_buffer[ 1024 ];
 
/*
 *  File test support routines.
 */
 
void test_cat(
  char *file,
  int   offset_arg,
  int   length
);
 
void test_write(
  char   *file,
  off_t  offset,
  char  *buffer
);
 
void test_extend(
  char *file,
  off_t new_len
);
 
void IMFS_dump( void );
int IMFS_memfile_maximum_size( void );
 
/*
 *  dump_statbuf
 */
 
void dump_statbuf( struct stat *buf )
{
  int         major1;
  int         minor1;
  int         major2;
  int         minor2;
 
  rtems_filesystem_split_dev_t( buf->st_dev, major1, minor1 );
  rtems_filesystem_split_dev_t( buf->st_rdev, major2, minor2 );
 
  printf( "....st_dev     (0x%x:0x%x)\n", major1, minor1 );
  printf( "....st_ino     %x  may vary by small amount\n",
      (unsigned int) buf->st_ino );
  printf( "....mode  = %08o\n", buf->st_mode );
  printf( "....nlink = %d\n", buf->st_nlink );
 
  printf( "....uid = %d\n", buf->st_uid );
  printf( "....gid = %d\n", buf->st_gid );
 
  printf( "....atime = %s", ctime(&buf->st_atime) );
  printf( "....mtime = %s", ctime(&buf->st_mtime) );
  printf( "....ctime = %s", ctime(&buf->st_ctime) );
 
#if defined(__svr4__) && !defined(__PPC__) && !defined(__sun__)
  printf( "....st_blksize %x\n", buf.st_blksize );
  printf( "....st_blocks  %x\n", buf.st_blocks );
#endif
 
}
 
void stat_a_file(
  const char *file
)
{
  int         status;
  struct stat statbuf;
 
  assert( file );
 
  printf( "stat( %s ) returned ", file );
  fflush( stdout );
 
  status = stat( file, &statbuf );
 
  if ( status == -1 ) {
    printf( ": %s\n", strerror( errno ) );
  } else {
    puts("");
    dump_statbuf( &statbuf );
  }
 
}
 
 
/*
 *  Main entry point of the test
 */
 
#if defined(__rtems__)
int test_main(void)
#else
int main(
  int argc,
  char **argv
)
#endif
{
  int               status;
  int               max_size;
  int               fd;
  int               i;
  struct stat       buf;
  char              buffer[128];
  FILE             *file;
  time_t            atime1;
  time_t            mtime1;
  time_t            ctime1;
  time_t            atime2;
  time_t            mtime2;
  time_t            ctime2;
  rtems_status_code rtems_status;
  rtems_time_of_day time;
 
  printf( "\n\n*** FILE TEST 1 ***\n" );
 
  /*
   *  Grab the maximum size of an in-memory file.
   */
 
  max_size = IMFS_memfile_maximum_size();
 
  build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );
  rtems_status = rtems_clock_set( &time );
 
  /*
   *  Dump an empty file system
   */
 
  IMFS_dump();
 
  /*
   *  Simple stat() of /dev/console.
   */
 
  puts( "stat of /dev/console" );
  status = stat( "/dev/console", &buf );
  assert( !status );
 
  dump_statbuf( &buf );
 
  /*
   *  Exercise mkdir() and some path evaluation.
   */
 
  puts( "" );
  puts( "mkdir /dev/tty" );
  status = mkdir( "/dev/tty", S_IRWXU );
  assert( !status );
 
  puts( "" );
  puts( "mkdir /usr" );
  status = mkdir( "/usr", S_IRWXU );
  assert( !status );
  puts( "mkdir /etc" );
  status = mkdir( "/etc", S_IRWXU );
  assert( !status );
 
  puts( "mkdir /tmp" );
  status = mkdir( "/tmp", S_IRWXU );
  assert( !status );
 
  /* this tests the ".." path in path name evaluation */
  puts( "mkdir /tmp/.." );
  status = mkdir( "/tmp/..", S_IRWXU );
  assert( status == -1 );
  assert( errno == EEXIST );
 
  /* now check out trailing separators */
  puts( "mkdir /tmp/" );
  status = mkdir( "/tmp/", S_IRWXU );
  assert( status == -1 );
  assert( errno == EEXIST );
 
  /* try to make a directory under a non-existent subdirectory */
  puts( "mkdir /j/j1" );
  status = mkdir( "/j/j1", S_IRWXU );
  assert( status == -1 );
  assert( errno == ENOENT );
 
  /* this tests the ability to make a directory in the current one */
  puts( "mkdir tmp" );
  status = mkdir( "tmp", S_IRWXU );
  assert( status == -1 );
  assert( errno == EEXIST );
 
  /* test rtems_filesystem_evaluate_path by sending NULL path */
  status = chdir( NULL );
  assert( status == -1 );
 
  /*
   *  Now switch gears and exercise rmdir().
   */
 
  puts( "" );
  puts( "rmdir /usr" );
  status = rmdir( "/usr" );
  assert( !status );
 
  puts( "rmdir /dev" );
  status = rmdir( "/dev" );
  assert( status == -1 );
  assert( errno ==  ENOTEMPTY);
 
  puts( "rmdir /fred" );
  status = rmdir ("/fred");
  assert (status == -1);
  assert( errno == ENOENT );
 
  puts( "mknod /dev/test_console" );
  status = mknod( "/dev/test_console", S_IFCHR, 0LL );
  assert( !status );
 
  puts( "mknod /dev/tty/S3" );
  status = mknod( "/dev/tty/S3", S_IFCHR, 0xFF00000080LL );
  assert( !status );
 
  puts ("mknod /etc/passwd");
  status = mknod( "/etc/passwd", (S_IFREG | S_IRWXU), 0LL );
  assert( !status );
 
  puts( "mkdir /tmp/my_dir");
  status = mkdir( "/tmp/my_dir", S_IRWXU );
  assert( status == 0 );
 
  puts("mkfifo /c/my_dir" );
  status = mkfifo( "/c/my_dir", S_IRWXU );
  assert( status == -1 );
 
  /*
   *  Try to make a directory under a file -- ERROR
   */
 
  puts( "mkdir /etc/passwd/j" );
  status = mkdir( "/etc/passwd/j", S_IRWXU );
  assert( status == -1 );
  assert( errno == ENOTDIR );
 
  /*
   *  Simple open failure case on non-existent file
   */
 
  puts( "open /tmp/joel - should fail with ENOENT" );
  fd = open( "/tmp/joel", O_RDONLY );
  assert( fd == -1 );
  assert( errno == ENOENT );
 
  /*
   *  Simple open case where the file is created.
   */
 
  puts( "open /tmp/j" );
  fd = open( "/tmp/j", O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO );
  assert( fd != -1 );
  printf( "open returned file descriptor %d\n", fd );
 
  puts( "close /tmp/j" );
  status = close( fd );
  assert( !status );
 
  puts( "close /tmp/j again" );
  status = close( fd );
  assert( status == -1 );
 
  puts( "unlink /tmp/j" );
  status = unlink( "/tmp/j" );
  assert( !status );
 
  puts( "unlink /tmp" );
  status = unlink( "/tmp" );
  assert( status );
 
  /*
   *  Simple open failure. Trying to create an existing file.
   */
 
  puts("create and close /tmp/tom");
  fd = open( "/tmp/tom", O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO );
  assert( fd != -1 );
  status = close( fd );
  assert( status == 0 );
 
  puts("Attempt to recreate /tmp/tom");
  fd = open( "/tmp/tom", O_CREAT | O_EXCL, S_IRWXU|S_IRWXG|S_IRWXO );
  assert( fd == -1 );
  assert( errno == EEXIST );
 
  puts("create /tmp/john");
  fd = open( "/tmp/john", O_RDWR|O_CREAT, S_IRWXU|S_IRWXG|S_IRWXO );
  assert( fd != -1 );
 
  puts("tcdrain /tmp/john" );
  status = tcdrain( fd );
  assert( status == 0 );
 
  /*
   *  Test simple write to a file at offset 0
   */
 
  puts( "mknod /tmp/joel" );
  status = mknod( "/tmp/joel", (S_IFREG | S_IRWXU), 0LL );
  test_write( "/tmp/joel", 0, "the first write!!!\n" );
  test_cat( "/tmp/joel", 0, 0 );
 
  /*
   *  Test simple write to a file at a non-0 offset in the first block
   */
 
  status = unlink( "/tmp/joel" );
  assert( !status );
 
  status = mknod( "/tmp/joel", (S_IFREG | S_IRWXU), 0LL );
  assert( !status );
 
  test_write( "/tmp/joel", 10, "the first write!!!\n" );
  test_cat( "/tmp/joel", 0, 0 );
  stat_a_file( "/tmp/joel" );
 
  /*
   *  Test simple write to a file at a non-0 offset in the second block.  Then
   *  try to read from various offsets and lengths.
   */
 
  puts("unlink /tmp/joel");
  status = unlink( "/tmp/joel" );
  assert( !status );
 
  /* Test a failure path */
 
  puts( "unlink /tmp/joel" );
  status = unlink( "/tmp/joel" );
  assert( status == -1 );
 
  puts( "mknod /tmp/joel");
  status = mknod( "/tmp/joel", (S_IFREG | S_IRWXU), 0LL );
  assert( !status );
 
  test_write( "/tmp/joel", 514, "the first write!!!\n" );
  test_write( "/tmp/joel", 1, test_write_buffer );
  test_write( "/tmp/joel", 63, test_write_buffer );
  test_cat( "/tmp/joel", 0, 1 );
  test_cat( "/tmp/joel", 1, 1 );
  test_cat( "/tmp/joel", 490, 1 );
  test_cat( "/tmp/joel", 512, 1 );
  test_cat( "/tmp/joel", 513, 1 );
  test_cat( "/tmp/joel", 514, 1 );
  test_cat( "/tmp/joel", 520, 1 );
  test_cat( "/tmp/joel", 1, 1024 );
 
  /*
   *  Read from a much longer file so we can descend into doubly and
   *  triply indirect blocks.
   */
 
  if ( max_size < 300 * 1024 ) {
    test_extend( "/tmp/joel", max_size - 1 );
    test_cat( "/tmp/joel", max_size / 2, 1024 );
  } else {
    printf( "Skipping maximum file size test since max_size is %d bytes\n", max_size );
    puts("That is likely to be bigger than the available RAM on many targets." );
  }
 
  stat_a_file( "/tmp/joel" );
 
  /*
   *  Now try to use a FILE * descriptor
   *
   *  /tmp/j should not exist at this point.
   */
 
  puts( "stat of /tmp/j" );
  errno = 0;
  status = stat( "/tmp/j", &buf );
  printf( "stat(/tmp/j) returned %d (errno=%d)\n", status, errno );
  dump_statbuf( &buf );
 
  puts( "fopen of /tmp/j" );
  file = fopen( "/tmp/j", "w+" );
  assert( file );
 
  puts( "fprintf to /tmp/j" );
  for (i=1 ; i<=5 ; i++) {
    status = fprintf( file, "This is call %d to fprintf\n", i );
    assert( status );
    printf( "(%d) %d characters written to the file\n", i, status );
  }
 
  fflush( file );
 
  status = stat( "/tmp/j", &buf );
  assert( !status );
  dump_statbuf( &buf );
  atime2 = buf.st_atime;
  mtime2 = buf.st_mtime;
  ctime2 = buf.st_ctime;
 
 
  status = rtems_task_wake_after( 1 * TICKS_PER_SECOND );
  rewind( file );
  while ( fgets(buffer, 128, file) )
    printf( "%s", buffer );
 
  /*
   * Verify only atime changed for a read.
   */
  status = stat( "/tmp/j", &buf );
  assert( !status );
  dump_statbuf( &buf );
  atime1 = buf.st_atime;
  mtime1 = buf.st_mtime;
  ctime1 = buf.st_ctime;
  assert( atime1 != atime2);
  assert( mtime1 == mtime2);
  assert( ctime1 == ctime2);
 
  IMFS_dump();
 
  unlink( "/tmp/joel" );
 
  /*
   *  Now truncate a file
   */
 
  status = rtems_task_wake_after( 1 * TICKS_PER_SECOND );
  puts( "truncate /tmp/j to length of 40" );
  status = truncate( "/tmp/j", 40 );
  assert( !status );
 
  /*
   * Verify truncate changed only atime.
   */
  status = stat( "/tmp/j", &buf );
  assert( !status );
  dump_statbuf( &buf );
  atime2 = buf.st_atime;
  mtime2 = buf.st_mtime;
  ctime2 = buf.st_ctime;
  assert( atime1 != atime2);
  assert( mtime1 == mtime2);
  assert( ctime1 == ctime2);
 
  IMFS_dump();
 
  /* try to truncate the console and see what happens */
  status = truncate( "/dev/console", 40 );
  assert(status == -1 );
 
  puts( "truncate /tmp/j to length of 0" );
  status = truncate( "/tmp/j", 0 );
  assert( !status );
 
  puts( "truncate /tmp to length of 0 should fail with EISDIR\n");
  status = truncate( "/tmp", 0 );
  assert( status == -1 );
  printf( "%d: %s\n", errno, strerror( errno ) );
  assert( errno == EISDIR );
 
  IMFS_dump();
 
  status = truncate( "/tmp/fred", 10 );
  assert( status == -1);
 
  rtems_status = rtems_io_register_name( "/dev/console", 0, 0 );
 
  printf( "*** END OF FILE TEST 1 ***\n" );
  exit( 0 );
}
 
 

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [psxtests/] [psxfile01/] [test.c] - Blame information for rev 509

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`* Simple test program to exercise some of the basic functionality of`
3			`* POSIX Files and Directories Support.`
4			`*`
5			`* This test assumes that the file system is initialized with the`
6			`* following directory structure:`
7			`*`
8			`* XXXX fill this in.`
9			`* /`
10			`* /dev`
11			`* /dev/XXX [where XXX includes at least console]`
12			`*`
13			`* COPYRIGHT (c) 1989-1999.`
14			`* On-Line Applications Research Corporation (OAR).`
15			`*`
16			`* The license and distribution terms for this file may be`
17			`* found in the file LICENSE in this distribution or at`
18			`* http://www.OARcorp.com/rtems/license.html.`
19			`*`
20			`* $Id: test.c,v 1.2 2001-09-27 12:02:25 chris Exp $`
21			`*/`
22
23			`#include <stdio.h>`
24
25			`#include <tmacros.h>`
26			`#include <sys/types.h>`
27			`#include <sys/stat.h>`
28			`#include <fcntl.h>`
29			`#include <unistd.h>`
30			`#include <errno.h>`
31			`#include <string.h>`
32			`#include <ctype.h>`
33
34			`#include <assert.h>`
35			`#include <rtems.h>`
36			`#include <rtems/libio.h>`
37
38			`char test_write_buffer[ 1024 ];`
39
40			`/*`
41			`* File test support routines.`
42			`*/`
43
44			`void test_cat(`
45			`char *file,`
46			`int offset_arg,`
47			`int length`
48			`);`
49
50			`void test_write(`
51			`char *file,`
52			`off_t offset,`
53			`char *buffer`
54			`);`
55
56			`void test_extend(`
57			`char *file,`
58			`off_t new_len`
59			`);`
60
61			`void IMFS_dump( void );`
62			`int IMFS_memfile_maximum_size( void );`
63
64			`/*`
65			`* dump_statbuf`
66			`*/`
67
68			`void dump_statbuf( struct stat *buf )`
69			`{`
70			`int major1;`
71			`int minor1;`
72			`int major2;`
73			`int minor2;`
74
75			`rtems_filesystem_split_dev_t( buf->st_dev, major1, minor1 );`
76			`rtems_filesystem_split_dev_t( buf->st_rdev, major2, minor2 );`
77
78			`printf( "....st_dev (0x%x:0x%x)\n", major1, minor1 );`
79			`printf( "....st_ino %x may vary by small amount\n",`
80			`(unsigned int) buf->st_ino );`
81			`printf( "....mode = %08o\n", buf->st_mode );`
82			`printf( "....nlink = %d\n", buf->st_nlink );`
83
84			`printf( "....uid = %d\n", buf->st_uid );`
85			`printf( "....gid = %d\n", buf->st_gid );`
86
87			`printf( "....atime = %s", ctime(&buf->st_atime) );`
88			`printf( "....mtime = %s", ctime(&buf->st_mtime) );`
89			`printf( "....ctime = %s", ctime(&buf->st_ctime) );`
90
91			`#if defined(__svr4__) && !defined(__PPC__) && !defined(__sun__)`
92			`printf( "....st_blksize %x\n", buf.st_blksize );`
93			`printf( "....st_blocks %x\n", buf.st_blocks );`
94			`#endif`
95
96			`}`
97
98			`void stat_a_file(`
99			`const char *file`
100			`)`
101			`{`
102			`int status;`
103			`struct stat statbuf;`
104
105			`assert( file );`
106
107			`printf( "stat( %s ) returned ", file );`
108			`fflush( stdout );`
109
110			`status = stat( file, &statbuf );`
111
112			`if ( status == -1 ) {`
113			`printf( ": %s\n", strerror( errno ) );`
114			`} else {`
115			`puts("");`
116			`dump_statbuf( &statbuf );`
117			`}`
118
119			`}`
120
121
122			`/*`
123			`* Main entry point of the test`
124			`*/`
125
126			`#if defined(__rtems__)`
127			`int test_main(void)`
128			`#else`
129			`int main(`
130			`int argc,`
131			`char **argv`
132			`)`
133			`#endif`
134			`{`
135			`int status;`
136			`int max_size;`
137			`int fd;`
138			`int i;`
139			`struct stat buf;`
140			`char buffer[128];`
141			`FILE *file;`
142			`time_t atime1;`
143			`time_t mtime1;`
144			`time_t ctime1;`
145			`time_t atime2;`
146			`time_t mtime2;`
147			`time_t ctime2;`
148			`rtems_status_code rtems_status;`
149			`rtems_time_of_day time;`
150
151			`printf( "\n\n* FILE TEST 1 *\n" );`
152
153			`/*`
154			`* Grab the maximum size of an in-memory file.`
155			`*/`
156
157			`max_size = IMFS_memfile_maximum_size();`
158
159			`build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );`
160			`rtems_status = rtems_clock_set( &time );`
161
162			`/*`
163			`* Dump an empty file system`
164			`*/`
165
166			`IMFS_dump();`
167
168			`/*`
169			`* Simple stat() of /dev/console.`
170			`*/`
171
172			`puts( "stat of /dev/console" );`
173			`status = stat( "/dev/console", &buf );`
174			`assert( !status );`
175
176			`dump_statbuf( &buf );`
177
178			`/*`
179			`* Exercise mkdir() and some path evaluation.`
180			`*/`
181
182			`puts( "" );`
183			`puts( "mkdir /dev/tty" );`
184			`status = mkdir( "/dev/tty", S_IRWXU );`
185			`assert( !status );`
186
187			`puts( "" );`
188			`puts( "mkdir /usr" );`
189			`status = mkdir( "/usr", S_IRWXU );`
190			`assert( !status );`
191			`puts( "mkdir /etc" );`
192			`status = mkdir( "/etc", S_IRWXU );`
193			`assert( !status );`
194
195			`puts( "mkdir /tmp" );`
196			`status = mkdir( "/tmp", S_IRWXU );`
197			`assert( !status );`
198
199			`/* this tests the ".." path in path name evaluation */`
200			`puts( "mkdir /tmp/.." );`
201			`status = mkdir( "/tmp/..", S_IRWXU );`
202			`assert( status == -1 );`
203			`assert( errno == EEXIST );`
204
205			`/* now check out trailing separators */`
206			`puts( "mkdir /tmp/" );`
207			`status = mkdir( "/tmp/", S_IRWXU );`
208			`assert( status == -1 );`
209			`assert( errno == EEXIST );`
210
211			`/* try to make a directory under a non-existent subdirectory */`
212			`puts( "mkdir /j/j1" );`
213			`status = mkdir( "/j/j1", S_IRWXU );`
214			`assert( status == -1 );`
215			`assert( errno == ENOENT );`
216
217			`/* this tests the ability to make a directory in the current one */`
218			`puts( "mkdir tmp" );`
219			`status = mkdir( "tmp", S_IRWXU );`
220			`assert( status == -1 );`
221			`assert( errno == EEXIST );`
222
223			`/* test rtems_filesystem_evaluate_path by sending NULL path */`
224			`status = chdir( NULL );`
225			`assert( status == -1 );`
226
227			`/*`
228			`* Now switch gears and exercise rmdir().`
229			`*/`
230
231			`puts( "" );`
232			`puts( "rmdir /usr" );`
233			`status = rmdir( "/usr" );`
234			`assert( !status );`
235
236			`puts( "rmdir /dev" );`
237			`status = rmdir( "/dev" );`
238			`assert( status == -1 );`
239			`assert( errno == ENOTEMPTY);`
240
241			`puts( "rmdir /fred" );`
242			`status = rmdir ("/fred");`
243			`assert (status == -1);`
244			`assert( errno == ENOENT );`
245
246			`puts( "mknod /dev/test_console" );`
247			`status = mknod( "/dev/test_console", S_IFCHR, 0LL );`
248			`assert( !status );`
249
250			`puts( "mknod /dev/tty/S3" );`
251			`status = mknod( "/dev/tty/S3", S_IFCHR, 0xFF00000080LL );`
252			`assert( !status );`
253
254			`puts ("mknod /etc/passwd");`
255			`status = mknod( "/etc/passwd", (S_IFREG \| S_IRWXU), 0LL );`
256			`assert( !status );`
257
258			`puts( "mkdir /tmp/my_dir");`
259			`status = mkdir( "/tmp/my_dir", S_IRWXU );`
260			`assert( status == 0 );`
261
262			`puts("mkfifo /c/my_dir" );`
263			`status = mkfifo( "/c/my_dir", S_IRWXU );`
264			`assert( status == -1 );`
265
266			`/*`
267			`* Try to make a directory under a file -- ERROR`
268			`*/`
269
270			`puts( "mkdir /etc/passwd/j" );`
271			`status = mkdir( "/etc/passwd/j", S_IRWXU );`
272			`assert( status == -1 );`
273			`assert( errno == ENOTDIR );`
274
275			`/*`
276			`* Simple open failure case on non-existent file`
277			`*/`
278
279			`puts( "open /tmp/joel - should fail with ENOENT" );`
280			`fd = open( "/tmp/joel", O_RDONLY );`
281			`assert( fd == -1 );`
282			`assert( errno == ENOENT );`
283
284			`/*`
285			`* Simple open case where the file is created.`
286			`*/`
287
288			`puts( "open /tmp/j" );`
289			`fd = open( "/tmp/j", O_RDWR\|O_CREAT, S_IRWXU\|S_IRWXG\|S_IRWXO );`
290			`assert( fd != -1 );`
291			`printf( "open returned file descriptor %d\n", fd );`
292
293			`puts( "close /tmp/j" );`
294			`status = close( fd );`
295			`assert( !status );`
296
297			`puts( "close /tmp/j again" );`
298			`status = close( fd );`
299			`assert( status == -1 );`
300
301			`puts( "unlink /tmp/j" );`
302			`status = unlink( "/tmp/j" );`
303			`assert( !status );`
304
305			`puts( "unlink /tmp" );`
306			`status = unlink( "/tmp" );`
307			`assert( status );`
308
309			`/*`
310			`* Simple open failure. Trying to create an existing file.`
311			`*/`
312
313			`puts("create and close /tmp/tom");`
314			`fd = open( "/tmp/tom", O_CREAT, S_IRWXU\|S_IRWXG\|S_IRWXO );`
315			`assert( fd != -1 );`
316			`status = close( fd );`
317			`assert( status == 0 );`
318
319			`puts("Attempt to recreate /tmp/tom");`
320			`fd = open( "/tmp/tom", O_CREAT \| O_EXCL, S_IRWXU\|S_IRWXG\|S_IRWXO );`
321			`assert( fd == -1 );`
322			`assert( errno == EEXIST );`
323
324			`puts("create /tmp/john");`
325			`fd = open( "/tmp/john", O_RDWR\|O_CREAT, S_IRWXU\|S_IRWXG\|S_IRWXO );`
326			`assert( fd != -1 );`
327
328			`puts("tcdrain /tmp/john" );`
329			`status = tcdrain( fd );`
330			`assert( status == 0 );`
331
332			`/*`
333			`* Test simple write to a file at offset 0`
334			`*/`
335
336			`puts( "mknod /tmp/joel" );`
337			`status = mknod( "/tmp/joel", (S_IFREG \| S_IRWXU), 0LL );`
338			`test_write( "/tmp/joel", 0, "the first write!!!\n" );`
339			`test_cat( "/tmp/joel", 0, 0 );`
340
341			`/*`
342			`* Test simple write to a file at a non-0 offset in the first block`
343			`*/`
344
345			`status = unlink( "/tmp/joel" );`
346			`assert( !status );`
347
348			`status = mknod( "/tmp/joel", (S_IFREG \| S_IRWXU), 0LL );`
349			`assert( !status );`
350
351			`test_write( "/tmp/joel", 10, "the first write!!!\n" );`
352			`test_cat( "/tmp/joel", 0, 0 );`
353			`stat_a_file( "/tmp/joel" );`
354
355			`/*`
356			`* Test simple write to a file at a non-0 offset in the second block. Then`
357			`* try to read from various offsets and lengths.`
358			`*/`
359
360			`puts("unlink /tmp/joel");`
361			`status = unlink( "/tmp/joel" );`
362			`assert( !status );`
363
364			`/* Test a failure path */`
365
366			`puts( "unlink /tmp/joel" );`
367			`status = unlink( "/tmp/joel" );`
368			`assert( status == -1 );`
369
370			`puts( "mknod /tmp/joel");`
371			`status = mknod( "/tmp/joel", (S_IFREG \| S_IRWXU), 0LL );`
372			`assert( !status );`
373
374			`test_write( "/tmp/joel", 514, "the first write!!!\n" );`
375			`test_write( "/tmp/joel", 1, test_write_buffer );`
376			`test_write( "/tmp/joel", 63, test_write_buffer );`
377			`test_cat( "/tmp/joel", 0, 1 );`
378			`test_cat( "/tmp/joel", 1, 1 );`
379			`test_cat( "/tmp/joel", 490, 1 );`
380			`test_cat( "/tmp/joel", 512, 1 );`
381			`test_cat( "/tmp/joel", 513, 1 );`
382			`test_cat( "/tmp/joel", 514, 1 );`
383			`test_cat( "/tmp/joel", 520, 1 );`
384			`test_cat( "/tmp/joel", 1, 1024 );`
385
386			`/*`
387			`* Read from a much longer file so we can descend into doubly and`
388			`* triply indirect blocks.`
389			`*/`
390
391			`if ( max_size < 300 * 1024 ) {`
392			`test_extend( "/tmp/joel", max_size - 1 );`
393			`test_cat( "/tmp/joel", max_size / 2, 1024 );`
394			`} else {`
395			`printf( "Skipping maximum file size test since max_size is %d bytes\n", max_size );`
396			`puts("That is likely to be bigger than the available RAM on many targets." );`
397			`}`
398
399			`stat_a_file( "/tmp/joel" );`
400
401			`/*`
402			`* Now try to use a FILE * descriptor`
403			`*`
404			`* /tmp/j should not exist at this point.`
405			`*/`
406
407			`puts( "stat of /tmp/j" );`
408			`errno = 0;`
409			`status = stat( "/tmp/j", &buf );`
410			`printf( "stat(/tmp/j) returned %d (errno=%d)\n", status, errno );`
411			`dump_statbuf( &buf );`
412
413			`puts( "fopen of /tmp/j" );`
414			`file = fopen( "/tmp/j", "w+" );`
415			`assert( file );`
416
417			`puts( "fprintf to /tmp/j" );`
418			`for (i=1 ; i<=5 ; i++) {`
419			`status = fprintf( file, "This is call %d to fprintf\n", i );`
420			`assert( status );`
421			`printf( "(%d) %d characters written to the file\n", i, status );`
422			`}`
423
424			`fflush( file );`
425
426			`status = stat( "/tmp/j", &buf );`
427			`assert( !status );`
428			`dump_statbuf( &buf );`
429			`atime2 = buf.st_atime;`
430			`mtime2 = buf.st_mtime;`
431			`ctime2 = buf.st_ctime;`
432
433
434			`status = rtems_task_wake_after( 1 * TICKS_PER_SECOND );`
435			`rewind( file );`
436			`while ( fgets(buffer, 128, file) )`
437			`printf( "%s", buffer );`
438
439			`/*`
440			`* Verify only atime changed for a read.`
441			`*/`
442			`status = stat( "/tmp/j", &buf );`
443			`assert( !status );`
444			`dump_statbuf( &buf );`
445			`atime1 = buf.st_atime;`
446			`mtime1 = buf.st_mtime;`
447			`ctime1 = buf.st_ctime;`
448			`assert( atime1 != atime2);`
449			`assert( mtime1 == mtime2);`
450			`assert( ctime1 == ctime2);`
451
452			`IMFS_dump();`
453
454			`unlink( "/tmp/joel" );`
455
456			`/*`
457			`* Now truncate a file`
458			`*/`
459
460			`status = rtems_task_wake_after( 1 * TICKS_PER_SECOND );`
461			`puts( "truncate /tmp/j to length of 40" );`
462			`status = truncate( "/tmp/j", 40 );`
463			`assert( !status );`
464
465			`/*`
466			`* Verify truncate changed only atime.`
467			`*/`
468			`status = stat( "/tmp/j", &buf );`
469			`assert( !status );`
470			`dump_statbuf( &buf );`
471			`atime2 = buf.st_atime;`
472			`mtime2 = buf.st_mtime;`
473			`ctime2 = buf.st_ctime;`
474			`assert( atime1 != atime2);`
475			`assert( mtime1 == mtime2);`
476			`assert( ctime1 == ctime2);`
477
478			`IMFS_dump();`
479
480			`/* try to truncate the console and see what happens */`
481			`status = truncate( "/dev/console", 40 );`
482			`assert(status == -1 );`
483
484			`puts( "truncate /tmp/j to length of 0" );`
485			`status = truncate( "/tmp/j", 0 );`
486			`assert( !status );`
487
488			`puts( "truncate /tmp to length of 0 should fail with EISDIR\n");`
489			`status = truncate( "/tmp", 0 );`
490			`assert( status == -1 );`
491			`printf( "%d: %s\n", errno, strerror( errno ) );`
492			`assert( errno == EISDIR );`
493
494			`IMFS_dump();`
495
496			`status = truncate( "/tmp/fred", 10 );`
497			`assert( status == -1);`
498
499			`rtems_status = rtems_io_register_name( "/dev/console", 0, 0 );`
500
501			`printf( "* END OF FILE TEST 1 *\n" );`
502			`exit( 0 );`
503			`}`
504
505