iotest.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 766 行 · 第 1/2 页

    TestFile_Destroy( cur_test );

    return( 1 );
}

int Test_File_IO_More( char *cur_mode )
/*************************************/
{
    TestFile    *cur_test;

    /* Create a file (testing some write functinos) */
    if( cur_mode[0] == 'r' ) {
        cur_mode[0] = 'w';
        cur_test = TestFile_Get( cur_mode );
        cur_mode[0] = 'r';
    } else {
        cur_test = TestFile_Get( cur_mode );
    }

    if( cur_test != 0 ) {
        Test_File_FWriteRead( cur_test, cur_mode );
    }

    /* Free memory; close and remove test file */
    TestFile_Destroy( cur_test );

    return( 1 );
}

int Test_Temp_IO( void )
/**********************/
{
    int     i, num_closed;
    FILE    *cur_file[ NUM_FILES ];
    char    cur_mode[4] = "tmp";     /* for the VERIFY/EXPECT macros */

    for( i = 0; i < NUM_FILES; i++ ) {
        cur_file[i] = tmpfile();
        VERIFY( cur_file[i] != NULL );
        VERIFY( fputc( 'x', cur_file[i] ) != EOF );
    }

#ifndef __UNIX__    // _TMPFIL flag isn't used on UNIX
    for( i = 0; i < NUM_FILES; i++ ) {
        EXPECT( ( cur_file[i]->_flag & _TMPFIL ) != 0 );
    }
#endif

    fcloseall();
    num_closed = fcloseall();

    /* re-open the console and the windows tmp.log file */
#ifdef __SW_BW
    con = fopen( "tmp.log", "a" );
#else
    con = fopen( CONSOLE_OUT, "w" );
#endif
    VERIFY( con != NULL );

    EXPECT( num_closed == 0 );

    return( 1 );
}

int Test_StdWrite( FILE *fp, FILE **my_fp, const char *filename )
/***************************************************************/
{
    int     test_int = 21718, test_buff;
    char    test_str[10] = "Hello", buff[80] = "Different";
    char    cur_mode[10];

    if( fp == stdout ) {
        strcpy( cur_mode, "stdout" );
    } else if( fp == stderr ) {
        strcpy( cur_mode, "stderr" );
    }

    /* Test all the standard write and read routines */

    VERIFY( putc( 'a', fp ) != EOF );

    if( fp == stdout ) {
        VERIFY( putchar( 'b' ) != EOF );
        VERIFY( fputchar( 'c' ) != EOF );
        VERIFY( printf( "%d\n", test_int ) > 0 );
        VERIFY( puts( test_str ) > 0 );
        VERIFY( putchar( '\n' ) != EOF );
        Test_vprintf( "%d\n", 53 );
    }

    fflush( *my_fp );

    /* Check the data just written */
    fseek( *my_fp, 0, SEEK_SET );
    VERIFY( fgetc( *my_fp ) == 'a' );

    if( fp == stdout ) {
        VERIFY( fgetc( *my_fp ) == 'b' );
        VERIFY( fgetc( *my_fp ) == 'c' );

        /* Check all the reads as well */
        EXPECT( freopen( CONSOLE_IN, "r+t", *my_fp ) != NULL );
        VERIFY( (*my_fp = freopen( filename, "rt", stdin )) != NULL );

        fseek( *my_fp, 0, SEEK_SET );
        VERIFY( getc( stdin ) == 'a' );
        VERIFY( getchar() == 'b' );
        VERIFY( fgetchar() == 'c' );
        VERIFY( scanf( "%d", &test_buff ) > 0 );
        VERIFY( test_buff == test_int );
        VERIFY( ( gets( buff ) ) != NULL );
        VERIFY( ( gets( buff ) ) != NULL );
        VERIFY( strcmp( buff, test_str ) == 0 );
        Test_vscanf( "%d\n", &test_int );
        VERIFY( test_int == 53 );
    }

    return( 1 );
}

int Test_StdWrites( FILE *fp )
/****************************/
{
    char    cur_mode[10] = "stdio";
    char    filename[ L_tmpnam ];
    FILE    *my_fp;

    EXPECT( tmpnam( filename ) != NULL );
    EXPECT( (my_fp = freopen( filename, "a+t", fp )) != NULL );

    /* A separate function is used to assure the deletion of the test file. */

    Test_StdWrite( fp, &my_fp, filename );

    EXPECT( (fp = freopen( CONSOLE_IN, "r+t", my_fp )) != NULL );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_File_Errors( void )
/**************************/
{
    char    cur_mode[10] = "error";
    char    filename[ L_tmpnam ], filename2[ L_tmpnam ];
    FILE    *fp, *fp2;

    /* get a temporary file */
    EXPECT( tmpnam( filename ) != NULL );
    EXPECT( ( fp = fopen( filename, "wt" ) ) != NULL );

    /* test the error routines */
    EXPECT( fgetc( fp ) == EOF );
    EXPECT( fgetc( fp ) == EOF );
    EXPECT( ferror( fp ) != 0 );

    /* test perror */
    EXPECT( tmpnam( filename2 ) != NULL );
    EXPECT( ( fp2 = freopen( filename2, "a+t", stderr ) ) != NULL );
    perror( "" );
    fflush( stderr );
    EXPECT( fgetc( fp2 ) == EOF );
    EXPECT( fclose( fp2 ) == 0 );
    EXPECT( remove( filename2 ) == 0 );

    /* test clearerr() */
    clearerr( fp );
    EXPECT( ferror( fp ) == 0 );

    /* cleanup */
    EXPECT( fclose( fp ) == 0 );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_Flushes( void )
/**********************/
{
    char    cur_mode[10] = "flushes";
    FILE    *fpr, *fpw;
    char    filename[ L_tmpnam ];

    VERIFY( tmpnam( filename ) != NULL );
    EXPECT( (fpw = fopen( filename, "w" )) != NULL );
    EXPECT( (fpr = fopen( filename, "r" )) != NULL );

    /* Test fflush() */

    EXPECT( fputc( 'z', fpw ) );
    EXPECT( fgetc( fpr ) == EOF );
    EXPECT( fflush( fpw ) == 0 );
    EXPECT( fgetc( fpr ) != EOF );

    /* Test flushall() */

    EXPECT( fputc( 'z', fpw ) );
    EXPECT( fgetc( fpr ) == EOF );
    EXPECT( flushall() );
    EXPECT( fgetc( fpr ) != EOF );

    EXPECT( fclose( fpr ) == 0 );
    EXPECT( fclose( fpw ) == 0 );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_fdopen( void )
/*********************/
{
    int     handle;
    FILE    *fp;
    char    filename[ L_tmpnam ];
    char    cur_mode[10] = "fdopen";

    VERIFY( tmpnam( filename ) != NULL );

    VERIFY( (fp = fopen( filename, "w+t" )) != NULL );
    EXPECT( fputc( 'y', fp ) != EOF );
    EXPECT( fclose( fp ) == 0 );

    handle = open( filename, O_RDONLY | O_TEXT );
    VERIFY( handle != -1 );

    EXPECT( (fp = fdopen( handle, "r" )) != NULL );
    if( fp != NULL ) {
        EXPECT( fgetc( fp ) == 'y' );
        fclose( fp );
    } else {
        close( handle );
    }
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_setbuf( void )
/*********************/
{
    FILE    *fp;
    char    buffer[ BUFSIZ ];
    char    filename[ L_tmpnam ];
    char    cur_mode[10] = "setbuf";

    VERIFY( tmpnam( filename ) != NULL );
    VERIFY( (fp = fopen( filename, "w" )) != NULL );
    setbuf( fp, buffer );

    fputc( 'a', fp );
    fputc( 'z', fp );
    EXPECT( buffer[0] == 'a' );
    EXPECT( buffer[1] == 'z' );

    fclose( fp );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_setvbuf( void )
/**********************/
{
    FILE    *fp;
    char    buff1[ BUFSIZ ];
    char    filename[ L_tmpnam ];
    char    cur_mode[10] = "setvbuf";

    /* open the tmpfile */
    VERIFY( tmpnam( filename ) != NULL );
    VERIFY( (fp = fopen( filename, "w" )) != NULL );

    /* setvbuf is tested in only one mode */
    setvbuf( fp, buff1, _IOFBF, BUFSIZ );

    fclose( fp );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}

int Test_ungetc( void )
/*********************/
{
    FILE    *fp;
    char    filename[ L_tmpnam ];
    char    cur_mode[10] = "ungetc";

    /* open the tmpfile */
    VERIFY( tmpnam( filename ) != NULL );
    VERIFY( (fp = fopen( filename, "w+t" )) != NULL );

    /* Test of ungetc() */
    VERIFY( 'z' == ungetc( 'z', fp ) );
    VERIFY( 'z' == getc( fp ) );

    fclose( fp );
    EXPECT( remove( filename ) == 0 );

    return( 1 );
}


int main( int argc, char *argv[] )
/********************************/
{
    int         cur_omode;              /* current open mode */
    int         cur_update;             /* current update mode */
    int         cur_ftype;              /* current file type */
    char        cur_mode[MAX_MODE + 1]; /* actual file mode paramater */
    TestFile    *cur_test;
    int         old_stdout_fd;
    FILE        *old_stdout;

#ifdef __SW_BW
    con = fopen( "tmp.log", "a" );
#else
    con = fopen( CONSOLE_OUT, "w" );
#endif
    VERIFY( con != NULL );

    /******************/
    /* Start of tests */
    /******************/

    /* The following tests are run for each file mode type */

    for( cur_omode = 0; cur_omode < NUM_OMODES; cur_omode++ ) {
        for( cur_update = 0; cur_update < 2; cur_update++ ) {
            for( cur_ftype = 0; cur_ftype < NUM_FTYPES; cur_ftype++ ) {
                /* Get the mode string */
                Mode_Get( cur_mode, cur_omode, cur_update, cur_ftype);

                /* Test fopen, fclose, and ferror */
                cur_test = TestFile_Get( cur_mode );
                  TestFile_Destroy( cur_test );

                /* Test standard file input and output functions */
                Test_File_IO( cur_mode );

                /* Test more of the standard functions */
                Test_File_IO_More( cur_mode );

            } /* cur_ftype */
        } /* cur_update */
    } /* cur_omode */

    Test_Temp_IO( );   /* tmpfile based tests */

    /* Create a clone of stdout for later use; must be done after
     * Test_Temp_IO() which calls fcloseall(). This needs to be done
     * for output redirection to work.
     */
    old_stdout_fd = fileno( stdout );
    EXPECT( (old_stdout_fd = dup( old_stdout_fd )) != -1 );
    EXPECT( (old_stdout = fdopen( old_stdout_fd, "wt" )) != NULL );

    Test_StdWrites( stderr );
    Test_StdWrites( stdout );
    Test_File_Errors( );   /* eg.  perror, ferror, etc.. */
    Test_Flushes( );
    Test_fdopen( );
    Test_setbuf( );
    Test_setvbuf( );
    Test_ungetc( );

    fprintf( old_stdout, "Tests completed (%s).\n", strlwr( argv[0] ) );
    fclose( old_stdout );
    fclose( con );
    //Status_Print( );
#ifdef __SW_BW
    con = fopen( "tmp.log", "a" );
    fprintf( con, "Tests completed (%s).\n", strlwr( argv[0] ) );
    _dwShutDown();
#endif

    /****************/
    /* End of tests */
    /****************/

    return( 0 );
}