test7.c

ecos为实时嵌入式操作系统

        t2vp = NULL;
        vp = vptmp = NULL;
        do {
            vp1 = vptmp;
            vptmp = vp;
            ercd = pget_blk( &vp, 1, T1_MALLOC );
        } while ( E_OK == ercd );
        CYG_TEST_CHECK( E_TMOUT == ercd, "get_blk bad ercd" );
        CYG_TEST_CHECK( NULL != vp,  "no allocated block to free" );
        CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" );
        break;
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
}

void
do_tidyup( WAITOP wait )
{
    ER ercd;
    switch ( wait ) {
    case SLEEP:
    case DELAY:
    case SEMGET:
    case MSGGET:
        // do nothing for all of those
        break;
    case FLAGWAIT:
        // clear the flag variable
        ercd = clr_flg( 1, 0 );
        CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd, tidy vp" );
        break;
    case MEMFIXEDGET:
        if ( NULL != vp ) {
            ercd = rel_blf( 1, vp );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp" );
        }
        if ( NULL != vp1 ) {
            ercd = rel_blf( 1, vp1 );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy vp1" );
        }
        if ( NULL != t2vp ) {
            ercd = rel_blf( 1, t2vp );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd, tidy t2vp" );
        }
        break;
    case MEMVARGET:
        if ( NULL != vp ) {
            ercd = rel_blk( 1, vp );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp" );
        }
        if ( NULL != vp1 ) {
            ercd = rel_blk( 1, vp1 );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy vp1" );
        }
        if ( NULL != t2vp ) {
            ercd = rel_blk( 1, t2vp );
            CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd, tidy t2vp" );
        }
        break;
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
}

void
do_recreate( WAITOP wait )
{ 
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
    static T_CSEM t_csem = { NULL, 0, 0 };
#endif
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
    static T_CMBX t_cmbx = { NULL, 0 };
#endif
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
    static T_CFLG t_cflg = { NULL, 0, 0 };
#endif
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
    static T_CMPF t_cmpf = { NULL, 0, 20, 95 };
#endif
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
    static T_CMPL t_cmpl = { NULL, 0, 2000 };
#endif
    ER ercd = E_OK;
    switch ( wait ) {
    case SLEEP:
    case DELAY:
        // do nothing for all of those
        break;
    case SEMGET:
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
        // create the semaphore
        ercd = cre_sem( 1, &t_csem );
        CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_recreate SEMGET" );
#endif
        break;
    case FLAGWAIT:
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
        // create the flag
        ercd = cre_flg( 1, &t_cflg );
        CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_recreate FLAGWAIT" );
#endif
        break;
    case MSGGET:
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
        // create the mbox
        ercd = cre_mbx( 1, &t_cmbx );
        CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_recreate MSGGET" );
#endif
        break;
    case MEMFIXEDGET:
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
        // create the mempool
        ercd = cre_mpf( 1, &t_cmpf );
        CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_recreate MEMFIXEDGET" );
#endif
        break;
    case MEMVARGET:
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
        // create the mempool
        ercd = cre_mpl( 1, &t_cmpl );
        CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_recreate MEMVARGET" );
#endif
        break;
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
    // this is just to use ercd to prevent warnings
    CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" );
}



void
do_signal( WAITOP wait )
{
    ER ercd;
    switch ( wait ) {
    case SLEEP:
        // send a wakeup
        ercd = wup_tsk( 2 );
        CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
        break;
    case DELAY:
        // simply wait for task 2's delay to complete
        ercd = dly_tsk( T1_WAIT );
        CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
        break;
    case SEMGET:
        // signal the semaphore
        ercd = sig_sem( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" );
        break;
    case FLAGWAIT:
        // set the flag bits
        ercd = set_flg( 1, 0xff );
        CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" );
        break;
    case MSGGET:
        // send a message
        ercd = snd_msg( 1, msg );
        CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );
        break;
    case MEMFIXEDGET:
        // release a couple of blocks we allocated earlier.  I hope.
        CYG_TEST_CHECK( NULL != vp,  "no allocated block to free" );
        CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" );
        ercd = rel_blf( 1, vp );
        CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" );
        vp = NULL;
        ercd = rel_blf( 1, vp1 );
        CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd1" );
        vp1 = NULL;
        break;
    case MEMVARGET:
        // release a couple of blocks we allocated earlier.  I hope.
        CYG_TEST_CHECK( NULL != vp,  "no allocated block to free" );
        CYG_TEST_CHECK( NULL != vp1, "no allocated block to free1" );
        ercd = rel_blk( 1, vp );
        CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" );
        vp = NULL;
        ercd = rel_blk( 1, vp1 );
        CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd1" );
        vp1 = NULL;
        break;
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
}

void
do_delete( WAITOP wait )
{
    ER ercd = E_OK;
    switch ( wait ) {
    case SLEEP:
    case DELAY:
        CYG_TEST_FAIL( "bad call to do_delete( SLEEP or DELAY )" );
        break;
    case SEMGET:
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
        // delete the semaphore
        ercd = del_sem( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_delete( SEMGET )" );
#endif
        break;
    case FLAGWAIT:
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
        // delete the flag
        ercd = del_flg( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_delete( FLAGWAIT )" );
#endif
        break;
    case MSGGET:
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
        // delete the mbox
        ercd = del_mbx( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_delete( MSGGET )" );
#endif
        break;
    case MEMFIXEDGET:
#ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
        // delete the mempool
        ercd = del_mpf( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_delete( MEMFIXEDGET )" );
#endif
        break;
    case MEMVARGET:
#ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
        // delete the mempool
        ercd = del_mpl( 1 );
        CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
#else
        CYG_TEST_FAIL( "bad call to do_delete( MEMVARGET )" );
#endif
        break;
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
    // this is just to use ercd to prevent warnings
    CYG_TEST_CHECK( E_OK == ercd, "<blank> bad ercd" );
}
 


ER
do_wait( WAITOP wait, WAITTYPE type )
{
    switch ( wait ) {
    case SLEEP:
        return ( PLAIN == type ) ? slp_tsk() : tslp_tsk( T2_WAIT );
    case DELAY:
        return dly_tsk( T2_WAIT );      // forget the type
    case SEMGET:
        return ( PLAIN == type ) ? wai_sem( 1 ) : twai_sem( 1, T2_WAIT );
    case FLAGWAIT:
        return ( PLAIN == type ) ?
            wai_flg( &scratch, 1, 0x55, TWF_ANDW ) :
           twai_flg( &scratch, 1, 0xaa, TWF_ANDW, T2_WAIT );
    case MSGGET:
        return ( PLAIN == type ) ?
            rcv_msg( &msg1, 1 ) :
           trcv_msg( &msg1, 1, T2_WAIT );
    case MEMFIXEDGET:
        return ( PLAIN == type ) ?
            get_blf( &t2vp, 1 ) :
           tget_blf( &t2vp, 1, T2_WAIT );
    case MEMVARGET:
        return ( PLAIN == type ) ?
            get_blk( &t2vp, 1, T2_MALLOC ) :
           tget_blk( &t2vp, 1, T2_MALLOC, T2_WAIT );
    default:
        CYG_TEST_FAIL( "bad switch" );
        break;
    }
    CYG_TEST_FAIL( "Bad wait in do_wait" );
    return E_SYS;
}

// ========================================================================
void task1( unsigned int arg )
{
    ER ercd;
    WAITOP wait;
    WAITTYPE type;
    KILLOP kill;

    CYG_TEST_INFO( "Task 1 running" );

    ercd = chg_pri( 1, 8 );
    CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );

    for ( wait = START_WAITOP; wait < DONE_WAITOP ; wait++) {
        for ( type = START_TYPE; type < DONE_TYPE   ; type++ ) {
            for ( kill = START_KILLOP; kill < DONE_KILLOP ; kill++ ) {
                
                // These clauses deal with a couple of special cases:
                // [doing it this way helps keep the rest of the code
                //  nicely general and orthogonal]
                // 
                // 1) DELAY: dly_tsk(): when this times out, the retcode is
                // E_OK rather than E_TMOUT, and it always times out.  The
                // "signalling" method here is just to wait yourself.  So we
                // do not test DELAY with TIMED type.
                //
                // 2) PLAIN tests with TIMEOUT kill operations: a PLAIN test
                // will not time out, it'll wait forever, so waiting for it
                // so to do is pointless; further, we would check for the
                // wrong error code.  So we do not test PLAIN tests with
                // TIMOUT kill operations.
                //
                // 3) SLEEP or DELAY tests with DELETE operations: there is