testcxx.cxx

eCos/RedBoot for勤研ARM AnywhereII(4510) 含全部源代码

    ICWAIT( 2 );
    CYG_TEST_CHECK( 2 == intercount, "intercount != 2" );
    intercom = 3;                       // test tslp_tsk
    TSRELEASE();
    ercd = rot_rdq( 0 );
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    CYG_TEST_CHECK( 2 == intercount, "intercount != 2" );
    intercom = 1;                       // test slp_tsk next...
    ercd = dly_tsk( 20 );               // without a wup
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    ICWAIT( 3 );
    CYG_TEST_CHECK( 3 == intercount, "intercount != 3" );

    intercom = 1;                       // ...test slp_tsk
    TSRELEASE();
    ercd = dly_tsk( 20 );               // without a wup (yet)
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    CYG_TEST_CHECK( 3 == intercount, "intercount != 3" );
    TSRELEASE();
    ercd = tslp_tsk( 20 );              // yield again
    CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" );
    CYG_TEST_CHECK( 3 == intercount, "intercount != 3" );
    TSRELEASE();
    ercd = rot_rdq( 0 );                // and again
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    CYG_TEST_CHECK( 3 == intercount, "intercount != 3" );
    TSRELEASE();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    ercd = rot_rdq( 0 );                // and yield
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    ICWAIT( 4 );
    CYG_TEST_CHECK( 4 == intercount, "intercount != 4" );

    intercom = 1;                       // test slp_tsk
    TSRELEASE();
    ercd = dly_tsk( 20 );               // without a wup (yet)
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    CYG_TEST_CHECK( 4 == intercount, "intercount != 4" );

    // this wup will restart it when we yield:
    TSLOCK();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    // these will count up:
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    scratch = -1;
    ercd = can_wup( &scratch, 4 );
    CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" );
    CYG_TEST_CHECK( 2 == scratch, "Cancelled wups not 2" );
    CYG_TEST_CHECK( 4 == intercount, "intercount != 4" );
    TSUNLOCK();

    intercom = 4;                       // do nothing
    TSRELEASE();
    ercd = rot_rdq( 0 );                // and yield
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    ICWAIT( 5 );
    CYG_TEST_CHECK( 5 == intercount, "intercount != 5" );
    TSRELEASE();
    ercd = dly_tsk( 20 );               // let it do nothing
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );

    TSRELEASE();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    TSRELEASE();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    TSRELEASE();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    TSRELEASE();
    ercd = dly_tsk( 20 );               // lots of wups but no sleep
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    CYG_TEST_CHECK( 5 == intercount, "intercount != 5" );
    scratch = -1;
    ercd = can_wup( &scratch, 4 );
    CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" );
    CYG_TEST_CHECK( 3 == scratch, "Cancelled wups not 3" );
    // now check that they are cancelled by doing a wait again
    intercom = 1;                       // test slp_tsk
    TSRELEASE();
    ercd = rot_rdq( 0 );                // still without a wup
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    TSRELEASE();
    ercd = rot_rdq( 0 );                // still without a wup
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    intercom = 4;                       // do nothing next
    TSRELEASE();
    ICWAIT( 6 );
    CYG_TEST_CHECK( 6 == intercount, "intercount != 6" );
    ercd = rot_rdq( 0 );                // still without a wup
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    CYG_TEST_CHECK( 6 == intercount, "intercount != 6" );
    TSRELEASE();
    ercd = wup_tsk( 4 );                // now issue a wup
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    ercd = rot_rdq( 0 );                // it will run now
    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
    TSRELEASE();
    ercd = rot_rdq( 0 );                // it will run now
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    ICWAIT( 7 );
    CYG_TEST_CHECK( 7 == intercount, "intercount != 7" );

    TSRELEASE();
    intercom = 99;                      // exit, all done
    ercd = rot_rdq( 0 );                // let it run
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    ICWAIT( 8 );
    CYG_TEST_CHECK( 8 == intercount, "intercount != 8" );

    TSRELEASE();
    ercd = rot_rdq( 0 );                // let it run
    CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" );
    CYG_TEST_CHECK( 8 == intercount, "intercount != 8" );
   
    CYG_TEST_PASS( "wup_tsk, can_wup, slp_tsk, tslp_tsk" );

#ifdef CYG_TEST_UITRON_TEST1_LOOPING
    chg_pri( 1, 1 );
    rot_rdq( 0 );
    ter_tsk( 2 );
    rot_rdq( 0 );
    ter_tsk( 3 );
    rot_rdq( 0 );
    ter_tsk( 4 );
    rot_rdq( 0 );
    }
#endif // CYG_TEST_UITRON_TEST1_LOOPING

    CYG_TEST_EXIT( "All done" );
    ext_tsk();
}



void task2( unsigned int arg )
{
    ER ercd;
    CYG_TEST_PASS( "Task 2 running" );
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 2 == scratch, "tid not 2" );
    if ( 99 != arg )
        CYG_TEST_FAIL( "Task 2 arg not 99" );
    ext_tsk();
    CYG_TEST_FAIL( "Task 2 failed to exit" );
}

void task3( unsigned int arg )
{
    ER ercd;
    TSLOCK();
    CYG_TEST_PASS("Task3 running");
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 3 == scratch, "tid not 3" );
    if ( 66 != arg )
        CYG_TEST_FAIL( "Task 3 arg not 66" );

    while ( 2 & intercom ) {
        while ( 1 & intercom ) {
            intercount++;
            TSSTOP();
            do {
                TSUNLOCK();
                ercd = rot_rdq( 0 );        // yield()
                TSLOCK();
                CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 1 (task3) bad ercd" );
            } while ( !TSGO() );
        }
        CYG_TEST_CHECK( 4 & intercom, "should not have got here yet 1" );
        TSSTOP();
        do {
            TSUNLOCK();
            ercd = rot_rdq( 0 );            // yield()
            TSLOCK();
            CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 2 (task3) bad ercd" );
        } while ( !TSGO() );
    }
    CYG_TEST_CHECK( 8 & intercom, "should not have got here yet 2" );
    
    TSUNLOCK();
    ext_tsk();
    CYG_TEST_FAIL( "Task 3 failed to exit" );
}

void task4( unsigned int arg )
{
    ER ercd;
    CYG_TEST_PASS("Task4 running");
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 4 == scratch, "tid not 4" );
    if ( 77 != arg )
        CYG_TEST_FAIL( "Task 4 arg not 77" );
    while ( 1 ) {
        switch ( intercom ) {
        case 1:
            ercd = slp_tsk();
            CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" );
            break;
        case 2:
            ercd = tslp_tsk( 10 );
            CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" );
            break;
        case 3:
            ercd = tslp_tsk( 10 );
            CYG_TEST_CHECK( E_TMOUT == ercd,
                            "slp_tsk (task4) bad ercd !E_TMOUT" );
            break;
        case 4:
            // busily do nothing
            while ( 4 == intercom ) {
                ercd = rot_rdq( 0 );
                CYG_TEST_CHECK( E_OK == ercd,
                                "rot_rdq (task4 idle) bad ercd" );
            }
            break;
        case 99:
            goto out;
        default:
            CYG_TEST_FAIL( "Task 4 bad intercom" );
            goto out;
        }
        intercount++;
        TSSTOP();
        do {
            ercd = rot_rdq( 0 );            // yield()
            CYG_TEST_CHECK( E_OK == ercd, "rot_rdq (task4) bad ercd" );
        } while ( !TSGO() );
    }
out:
    ext_tsk();
    CYG_TEST_FAIL( "Task 4 failed to exit" );
}

#else // not enough (or too many) uITRON objects configured in
#define N_A_MSG "not enough uITRON objects to run test"
#endif // not enough (or too many) uITRON objects configured in
#else  // not C++ and some C++ specific options enabled
#define N_A_MSG "C++ specific options selected but this is C"
#endif  // not C++ and some C++ specific options enabled
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK   - can't test without it
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK"
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK  - can't test without it
#else  // ! CYGFUN_KERNEL_THREADS_TIMER   - can't test without it
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER"
#endif // ! CYGFUN_KERNEL_THREADS_TIMER   - can't test without it
#else  // ! CYGIMP_THREAD_PRIORITY        - can't test without it
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE"
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE   - can't test without it
#else  // ! CYGPKG_UITRON
#define N_A_MSG "uITRON Compatibility layer disabled"
#endif // CYGPKG_UITRON

#ifdef N_A_MSG
externC void
cyg_start( void )
{
    CYG_TEST_INIT();
    CYG_TEST_NA( N_A_MSG );
}
#endif // N_A_MSG defined ie. we are N/A.

// EOF testcxx.cxx