testcx2.cxx

ecos为实时嵌入式操作系统

    CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" );
#endif
    ercd = wai_flg( &flagptn, 2, 7, 34657 );
    CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" );
    ercd = wai_flg( &flagptn, 2, 0, TWF_ANDW );
    CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" );
    ercd = pol_flg( &flagptn, -6, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" );
    ercd = pol_flg( &flagptn, 99, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = pol_flg( NULL, 2, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" );
#endif
    ercd = pol_flg( &flagptn, 2, 7, 34657 );
    CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" );
    ercd = pol_flg( &flagptn, 2, 0, TWF_ANDW );
    CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" );
    ercd = twai_flg( &flagptn, -6, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" );
    ercd = twai_flg( &flagptn, 99, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = twai_flg( NULL, 2, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" );
#endif
    ercd = twai_flg( &flagptn, 2, 7, 34657, delay );
    CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, -999 );
    CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" );
    ercd = twai_flg( &flagptn, 2, 0, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" );
    ercd = ref_flg( &flg_info, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" );
    ercd = ref_flg( &flg_info, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = ref_flg( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "ref_flg bad ercd !E_PAR" );
#endif
    CYG_TEST_PASS( "bad calls: set_flg, clr_flg, [t]wai,pol_flg, ref_flg" );
#endif // we can test bad param error returns

    // check the waitable functions versus dispatch disable
    ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" );
    ercd = dis_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = wai_flg( &flagptn, 2, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_CTX == ercd, "wai_flg bad ercd !E_CTX" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_CTX == ercd, "twai_flg bad ercd !E_CTX" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_FEVR );
    CYG_TEST_CHECK( E_CTX == ercd, "twai_flg(FEVR) bad ercd !E_CTX" );
#endif // we can test bad param error returns
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" );
    ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
    ercd = ena_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
    ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW );
    CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay );
    CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" );
    ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" );
    CYG_TEST_PASS( "bad calls: wai_flg, twai_flg with dis_dsp" );

    // check ref_flg with various states
    ercd = ref_flg( &flg_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
    CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be non0" );
    CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" );
    intercom = 0;
    ercd = dly_tsk( delay );               // let task 2 start waiting
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    intercom = 1;
    ercd = ref_flg( &flg_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
    CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" );
    CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" );
    ercd = set_flg( 2, 0x5555 );
    CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" );
    ercd = dly_tsk( delay );
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    ercd = ref_flg( &flg_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
    CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" );
    CYG_TEST_CHECK( 0x5555 == flg_info.flgptn, "flgptn should be 0x5555" );
    ercd = clr_flg( 2, 0xF0F0 );
    CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" );
    ercd = dly_tsk( delay );
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    ercd = ref_flg( &flg_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
    CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" );
    CYG_TEST_CHECK( 0x5050 == flg_info.flgptn, "flgptn should be 0x5050" );
    ercd = set_flg( 2, 0xFFFF );
    CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" );
    ercd = dly_tsk( delay );
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    ercd = ref_flg( &flg_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
    CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be 0" );
    CYG_TEST_CHECK( 0xFFFF == flg_info.flgptn, "flgptn should be 0xFFFF" );
    CYG_TEST_PASS( "good calls: clr_flg, set_flg, wai_flg with ref_flg" );

    // Mailboxes; all the illegal argument combinations first
    CYG_TEST_INFO( "Testing mailbox ops" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = snd_msg( -6, msgptr );
    CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" );
    ercd = snd_msg( 99, msgptr );
    CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = snd_msg( 2, NULL );
    CYG_TEST_CHECK( E_PAR == ercd, "snd_msg bad ercd !E_PAR" );
#endif
    ercd = rcv_msg( &rxptr, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" );
    ercd = rcv_msg( &rxptr, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = rcv_msg( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "rcv_msg bad ercd !E_PAR" );
#endif
    ercd = prcv_msg( &rxptr, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" );
    ercd = prcv_msg( &rxptr, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = prcv_msg( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "prcv_msg bad ercd !E_PAR" );
#endif
    ercd = trcv_msg( &rxptr, -6, delay );
    CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" );
    ercd = trcv_msg( &rxptr, 99, delay );
    CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" );
    ercd = trcv_msg( &rxptr, 2, -999 );
    CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = trcv_msg( NULL, 2, delay );
    CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" );
#endif
    ercd = ref_mbx( &mbx_info, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" );
    ercd = ref_mbx( &mbx_info, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = ref_mbx( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "ref_mbx bad ercd !E_PAR" );
#endif
    CYG_TEST_PASS( "bad calls: snd_msg, [pt]rcv_msg, ref_mbx" );
#endif // we can test bad param error returns

    // check the waitable functions versus dispatch disable
    ercd = prcv_msg( &rxptr, 2 );
    CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
    ercd = trcv_msg( &rxptr, 2, delay );
    CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );
    ercd = trcv_msg( &rxptr, 2, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" );
    ercd = dis_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = rcv_msg( &rxptr, 2 );
    CYG_TEST_CHECK( E_CTX == ercd, "rcv_msg bad ercd !E_CTX" );
    ercd = trcv_msg( &rxptr, 2, delay );
    CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg bad ercd !E_CTX" );
    ercd = trcv_msg( &rxptr, 2, TMO_FEVR );
    CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg(FEVR) bad ercd !E_CTX" );
#endif // we can test bad param error returns
    ercd = trcv_msg( &rxptr, 2, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" );
    ercd = prcv_msg( &rxptr, 2 );
    CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
    ercd = ena_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
    ercd = prcv_msg( &rxptr, 2 );
    CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
    ercd = trcv_msg( &rxptr, 2, delay );
    CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );
    ercd = trcv_msg( &rxptr, 2, TMO_POL );
    CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" );
    CYG_TEST_PASS( "bad calls: rcv_msg, trcv_msg with dis_dsp" );

    // check ref_mbx with various states
    ercd = ref_mbx( &mbx_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
    CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" );
    CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" );
    intercom = 0;
    ercd = dly_tsk( delay );               // let task 2 start waiting
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    intercom = 1;
    ercd = ref_mbx( &mbx_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
    CYG_TEST_CHECK( 0 != mbx_info.wtsk, "mbx.wtsk should be non0" );
    CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" );
    ercd = snd_msg( 2, msgptr );
    CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );
    ercd = ref_mbx( &mbx_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
    CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" );
#if 1
    CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" );
#else // old, non-uITRON semantics
    CYG_TEST_CHECK( msgptr == mbx_info.pk_msg, "mbx peek should be msgptr" );
#endif
    ercd = dly_tsk( delay );
    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
    ercd = ref_mbx( &mbx_info, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
    CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" );
    CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" );
    // fill the message box, expect E_QOVR
    for ( scratch = 0 ; scratch < 100 ; scratch++ ) {
        if ( E_OK != ( ercd = snd_msg( 2, msgptr ) ) )
            break;
    }
    CYG_TEST_CHECK( (100 == scratch) || (E_QOVR == ercd),
                    "snd_msg bad ercd !E_QOVR/E_OK" );
    // empty the message box, expect the right number and E_TMOUT
    for (             ;     1         ; scratch-- ) {
        if ( E_OK != ( ercd = prcv_msg( &rxptr, 2 ) ) )
            break;
    }
    CYG_TEST_CHECK( 0 == scratch, "rcv_msg count bad scratch!=0" );
    CYG_TEST_CHECK( E_TMOUT == ercd, "rcv_msg bad ercd !E_TMOUT" );

    CYG_TEST_PASS( "good calls: rcv_msg, snd_msg with ref_msg" );

    // Fixed block memory pools: all the illegal argument combinations first
    CYG_TEST_INFO( "Testing fixed block memory ops" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = rel_blf( -6, blfptr );
    CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" );
    ercd = rel_blf( 99, blfptr );
    CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = rel_blf( 2, NULL );
    CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" );
#endif
#endif // we can test bad param error returns
    ercd = rel_blf( 2, blfptr );        // it did not come from a mpf
    CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = get_blf( &blfptr, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" );
    ercd = get_blf( &blfptr, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = get_blf( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "get_blf bad ercd !E_PAR" );
#endif
    ercd = pget_blf( &blfptr, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" );
    ercd = pget_blf( &blfptr, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = pget_blf( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "pget_blf bad ercd !E_PAR" );
#endif
    ercd = tget_blf( &blfptr, -6, delay );
    CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" );
    ercd = tget_blf( &blfptr, 99, delay );
    CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" );
    ercd = tget_blf( &blfptr, 2, -999 );
    CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = tget_blf( NULL, 2, delay );
    CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" );
#endif
    ercd = ref_mpf( &mpf_info, -6 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" );
    ercd = ref_mpf( &mpf_info, 99 );
    CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" );
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
    ercd = ref_mpf( NULL, 2 );
    CYG_TEST_CHECK( E_PAR == ercd, "ref_mpf bad ercd !E_PAR" );
#endif
    CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf, ref_mpf " );
#endif // we can test bad param error returns

    // check the waitable functions versus dispatch disable
    ercd = pget_blf( &blfptr, 2 );
    CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" );
    ercd = rel_blf( 2, blfptr );
    CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" );
    ercd = tget_blf( &blfptr, 2, delay );
    CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" );
    ercd = dis_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
    ercd = rel_blf( 2, blfptr );
    CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
    ercd = get_blf( &blfptr, 2 );
    CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" );
    ercd = tget_blf( &blfptr, 2, delay );
    CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" );
#endif // we can test bad param error returns
    ercd = ena_dsp();
    CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );