自学教程：C++ CYG_TEST_NA函数代码示例

intmain( int argc, char *argv[] ){    CYG_TEST_INIT();    CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C "                  "library atexit() function");#if defined(CYGFUN_LIBC_ATEXIT)    // we only have one test in us! We can only exit once :-)    CYG_TEST_PASS_FAIL( atexit(&myfun3)==0,                         "Simple registration of first atexit() function" );    CYG_TEST_PASS_FAIL( atexit(&myfun2)==0,                        "Simple registration of second atexit() function" );    CYG_TEST_PASS_FAIL( atexit(&myfun1)==0,                         "Simple registration of third atexit() function" );    return 0;#else    CYG_TEST_NA("Testing is not applicable to this configuration");    CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C "                    "library atexit() function");#endif // if defined(CYGFUN_LIBC_ATEXIT)} // main()

int main( int argc, char **argv ){    CYG_TEST_INIT();    CYG_TEST_NA("stdio");}

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_NA( "This test needs CYGVAR_KERNEL_COUNTERS_CLOCK "                 "and CYGFUN_KERNEL_API_C" );}

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_NA("This test needs DHCP enabled");}

voidcyg_start(void){    CYG_TEST_INIT();    CYG_TEST_NA( NA_MSG );    CYG_TEST_FINISH("Done");}

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_NA("FP test requires:/n"                "CYGFUN_KERNEL_API_C && /n"                "CYGSEM_KERNEL_SCHED_MLQUEUE && /n"                "(CYGNUM_KERNEL_SCHED_PRIORITIES > 12)/n");}

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_INFO("FP test requires:/n"                "CYGFUN_KERNEL_API_C && /n"                "CYGSEM_KERNEL_SCHED_MLQUEUE && /n"                "(CYGNUM_KERNEL_SCHED_PRIORITIES > 12) &&/n"                "(CYGMEM_REGION_ram_SIZE >= (49152-4096))/n");    CYG_TEST_NA("FP test requirements");}

voidtcp_server(cyg_addrword_t param){    init_all_network_interfaces();    diag_printf("Start TCP server - test/n");    cyg_thread_resume(client_thread_handle);    // Start it#if NLOOP > 0    server();    CYG_TEST_PASS_FINISH( "server returned OK" );#endif    CYG_TEST_NA( "No loopback devs" );}

intmain(int argc, char *argv[]){    CYG_TEST_INIT();    CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "                  "rand() function");    test(0);    CYG_TEST_NA("Testing is not applicable to this configuration");} // main()

static void entry0( cyg_addrword_t data ){    int i;    unsigned long len;    int err;    int buf_size = sizeof(gzip_test_ref)+512;    unsigned char* unpacked = malloc(buf_size);        if (NULL == unpacked)        CYG_TEST_NA("Not enough memory for buffers");    CYG_TEST_INFO("Decompressing");    len = buf_size;    err = uncompress(unpacked, &len, gzip_test, sizeof(gzip_test));    switch (err) {    case Z_OK:        break;    case Z_MEM_ERROR:        CYG_TEST_NA("Not enough memory for decompression");        break;    case Z_BUF_ERROR:        CYG_TEST_FAIL_FINISH("Decompressed data larger than original");        break;    case Z_DATA_ERROR:        CYG_TEST_FAIL_FINISH("Decompression failed");        break;    default:        CYG_TEST_FAIL_FINISH("Unknown decompression error");        break;    }    for (i = 0; i < sizeof(gzip_test_ref)-1; i++) {        if (gzip_test_ref[i] != unpacked[i])            CYG_TEST_FAIL_FINISH("Verify failed");    }    CYG_TEST_PASS_FINISH("zlib2 OK");}

intmain(int argc, char *argv[]){    CYG_TEST_INIT();    CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "                  "strtok() function");    CYG_TEST_INFO("This testcase provides simple basic tests");    test(0);    CYG_TEST_NA("Testing is not applicable to this configuration");} // main()

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_INFO("Timeslice test requires:/n"                "CYGSEM_KERNEL_SCHED_TIMESLICE &&/n"                "CYGFUN_KERNEL_API_C && /n"                "CYGSEM_KERNEL_SCHED_MLQUEUE &&/n"                "CYGVAR_KERNEL_COUNTERS_CLOCK &&/n"                "!CYGDBG_INFRA_DIAG_USE_DEVICE &&/n"                "(CYGNUM_KERNEL_SCHED_PRIORITIES > 12)/n");    CYG_TEST_NA("Timeslice test requirements");}

externC voidcyg_start( void ){    CYG_TEST_INIT();    // Attaching the ISR will not succeed if the kernel real-time    // clock has been configured in.#ifndef CYGVAR_KERNEL_COUNTERS_CLOCK    intr_main();#else    CYG_TEST_NA("Cannot override kernel real-time clock.");#endif}

intmain(int argc, char *argv[]){#if TEST_VALID    int i;    int r, prev, prevprev;    int how_many_periodics = 0;#endif    CYG_TEST_INIT();    CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "                  "rand() function");    CYG_TEST_INFO("This test tests the distribution of random numbers and");    CYG_TEST_INFO("may take some time");#if TEST_VALID    r = rand() % 2;    prev = r;    r = rand() % 2;    for (i = 0; i < TEST_LENGTH; ++i) {      prevprev = prev;      prev = r;      r = rand() % 2;      if (r == prevprev) {        ++how_many_periodics;      }      if (how_many_periodics > (2*TEST_LENGTH)/3) {        break;      }    }    CYG_TEST_PASS_FAIL( (how_many_periodics <= (2*TEST_LENGTH)/3),                        "periodicity of rand() in lowest bit");#else        // TODO: should be an _expected_ fail i.e. XFAIL    CYG_TEST_NA("Chosen rand algorithm is known to fail this test");    #endif    CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for "                    "C library rand() function");} // main()

voidcyg_start(void){#ifdef CYGPKG_SNMPAGENT // Do we support SNMP at all?    // Create a main thread, so we can run the scheduler and have time 'pass'    cyg_thread_create(10,                // Priority - just a number                      net_test,          // entry                      0,                 // entry parameter                      "Network test",    // Name                      &stack[0],         // Stack                      STACK_SIZE,        // Size                      &thread_handle,    // Handle                      &thread_data       // Thread data structure            );    cyg_thread_resume(thread_handle);  // Start it    cyg_scheduler_start();#else    CYG_TEST_NA( "No SNMP agent in this configuration" );#endif // CYGPKG_SNMPAGENT - Do we support SNMP at all?}

externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_NA(N_A_MSG);}

void cyg_start(void){    CYG_TEST_INIT();    CYG_TEST_NA(NA_MSG);}

//.........这里部分代码省略.........static void entry0( cyg_addrword_t data ){    cyg_mutex_lock( &m0 ); {        CHECK( ! cyg_mutex_trylock( &m0 ) );        cyg_mutex_lock( &m1 ); {            CHECK( ! cyg_mutex_trylock( &m0 ) );                    } cyg_mutex_unlock( &m1 );    } cyg_mutex_unlock( &m0 );    cyg_mutex_lock( &m0 ); {        while ( 0 == m0d )            cyg_cond_wait( &cvar0 );        CHECK( 1 == m0d++ );        cyg_cond_signal( &cvar0 );        while ( 4 != m0d )            cyg_cond_wait( &cvar1 );        CHECK( 4 == m0d );    } cyg_mutex_unlock( &m0 );    finish( (cyg_ucount8)data );}static void entry1( cyg_addrword_t data ){    cyg_mutex_lock( &m0 ); {        CHECK( cyg_mutex_trylock( &m1 ) ); {        } cyg_mutex_unlock( &m1 );    } cyg_mutex_unlock( &m0 );    cyg_mutex_lock( &m0 ); {        CHECK( 0 == m0d++ );        cyg_cond_broadcast( &cvar0 );    } cyg_mutex_unlock( &m0 );        cyg_mutex_lock( &m0 ); {        while( 1 == m0d )            cyg_cond_wait( &cvar0 );        CHECK( 2 == m0d++ );        cyg_cond_signal( &cvar0 );        while( 3 == m0d )            cyg_cond_wait( &cvar1 );    } cyg_mutex_unlock( &m0 );    finish( (cyg_ucount8)data );}static void entry2( cyg_addrword_t data ){    cyg_mutex_lock( &m0 ); {        while( 3 != m0d ) {            cyg_cond_wait( &cvar0 );        }        CHECK( 3 == m0d++ );        cyg_cond_broadcast( &cvar1 );    } cyg_mutex_unlock( &m0 );    finish( (cyg_ucount8)data );}void kmutex1_main( void ){    CYG_TEST_INIT();    cyg_thread_create(4, entry0 , (cyg_addrword_t)0, "kmutex1-0",        (void *)stack[0], STACKSIZE, &thread[0], &thread_obj[0]);    cyg_thread_resume(thread[0]);    cyg_thread_create(4, entry1 , (cyg_addrword_t)1, "kmutex1-1",        (void *)stack[1], STACKSIZE, &thread[1], &thread_obj[1]);    cyg_thread_resume(thread[1]);    cyg_thread_create(4, entry2 , (cyg_addrword_t)2, "kmutex1-2",        (void *)stack[2], STACKSIZE, &thread[2], &thread_obj[2]);    cyg_thread_resume(thread[2]);    cyg_mutex_init( &m0 );    cyg_mutex_init( &m1 );    cyg_cond_init( &cvar0, &m0 );    cyg_cond_init( &cvar1, &m0 );    cyg_cond_init( &cvar2, &m1 );    cyg_scheduler_start();    CYG_TEST_FAIL_FINISH("Not reached");}externC voidcyg_start( void ){     kmutex1_main();}#else /* def CYGFUN_KERNEL_API_C */externC voidcyg_start( void ){    CYG_TEST_INIT();    CYG_TEST_NA("Kernel C API layer disabled");}

int main (void)#endif // __ECOS__/*****/  /* main program, corresponds to procedures        */  /* Main and Proc_0 in the Ada version             */{#ifndef __ECOS__  double   dtime();#endif // __ECOS__        One_Fifty       Int_1_Loc;  REG   One_Fifty       Int_2_Loc;        One_Fifty       Int_3_Loc;  REG   char            Ch_Index;        Enumeration     Enum_Loc;        Str_30          Str_1_Loc;        Str_30          Str_2_Loc;  REG   int             Run_Index;  REG   int             Number_Of_Runs;#ifdef __ECOS__    CYG_TEST_INIT();#ifdef CYG_HAL_I386_LINUX    CYG_TEST_NA("Only runs on hardware...");#else    if (cyg_test_is_simulator)        CYG_TEST_NA("Only runs on hardware...");#endif#else // __ECOS__        FILE            *Ap;  /* Initializations */  if ((Ap = fopen("dhry.res","a+")) == NULL)    {       printf("Can not open dhry.res/n/n");       exit(1);    }#endif // __ECOS__  Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));  Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));  Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;  Ptr_Glob->Discr                       = Ident_1;  Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;  Ptr_Glob->variant.var_1.Int_Comp      = 40;  strcpy (Ptr_Glob->variant.var_1.Str_Comp,           "DHRYSTONE PROGRAM, SOME STRING");  strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");  Arr_2_Glob [8][7] = 10;        /* Was missing in published program. Without this statement,    */        /* Arr_2_Glob [8][7] would have an undefined value.             */        /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */        /* overflow may occur for this array element.                   */  printf ("/n");  printf ("Dhrystone Benchmark, Version 2.1 (Language: C)/n");  printf ("/n");/*    if (Reg)  {    printf ("Program compiled with 'register' attribute/n");    printf ("/n");  }  else  {    printf ("Program compiled without 'register' attribute/n");    printf ("/n");  }*/#ifdef __ECOS__  Number_Of_Runs = PASSES;#else // __ECOS__  printf ("Please give the number of runs through the benchmark: ");  {    int n;    scanf ("%d", &n);    Number_Of_Runs = n;  }  printf ("/n");#endif // __ECOS__  printf ("Execution starts, %d runs through Dhrystone/n",Number_Of_Runs);  /***************/  /* Start timer */  /***************/   Begin_Time = dtime();    for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)  {//.........这里部分代码省略.........

//.........这里部分代码省略.........#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS    // now try creating it (badly)#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR    ercd = cre_mpl( 3, NULL );    CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" );#endif    ercd = cre_mpl( 3, NADR );    CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" );    t_cmpl.mplatr = 0xfff;    ercd = cre_mpl( 3, &t_cmpl );    CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpl bad ercd !E_RSATR" );#endif // we can test bad param error returns    t_cmpl.mplatr = 0;    t_cmpl.mplsz = 100000000;    ercd = cre_mpl( 3, &t_cmpl );    CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpl bad ercd" );    // now create it well    t_cmpl.mplatr = 0;    t_cmpl.mplsz = 1000;    ercd = cre_mpl( 3, &t_cmpl );    CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );    // and check we can use it    ercd = pget_blk( &vp, 3, 100 );    CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" );    ercd = pget_blk( &vp, 3, 100000000 ); // way too large    CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );    ercd = tget_blk( &vp, 3, 100, 10 );    CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" );    ercd = get_blk( &vp, 3, 100 );    CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" );    ercd = rel_blk( 3, vp );            // vp did come from new pool    CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" );    ercd = rel_blk( 3, vp );            // vp already freed    CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" );    ercd = ref_mpl( &t_rmpl, 3 );    CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" );    // In order to wait on the pools, we must first consume all they have:    while ( E_OK == (ercd = pget_blk( &vp, 1, 100 )) ) /* nothing */;    CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );    while ( E_OK == (ercd = tget_blk( &vp, 2, 100, 1 )) ) /* nothing */;    CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" );    // now wait while task 2 deletes the wait objects    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = get_blk( &vp, 1, 200 );    CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" );    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = tget_blk( &vp, 2, 100, 20 );    CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" );    // check they are deleted    ercd = get_blk( &vp, 1, 200 );    CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" );    ercd = pget_blk( &vp, 2, 20 );    CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" );    // re-create and do it again    ercd = cre_mpl( 1, &t_cmpl );    CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );    ercd = cre_mpl( 2, &t_cmpl );    CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );    // In order to wait on the pools, we must first consume all they have:    while ( E_OK == (ercd = pget_blk( &vp, 1, 20 )) ) /* nothing */;    CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );    while ( E_OK == (ercd = tget_blk( &vp, 2, 400, 1 )) ) /* nothing */;    CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" );    // now wait while task 2 deletes the wait objects    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = get_blk( &vp, 1, 200 );    CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" );    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = tget_blk( &vp, 2, 500, 20 );    CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" );    // check they are deleted    ercd = tget_blk( &vp, 1, 200, 1 );    CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" );    ercd = get_blk( &vp, 2, 20 );    CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" );    CYG_TEST_PASS("create/delete variable mempools");#endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE    ercd = ter_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );    ercd = dly_tsk( 5 );    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );    // all done    if ( 0 == tests ) {        CYG_TEST_NA( "No objects have create/delete enabled" );    }    else {        CYG_TEST_EXIT( "All done" );    }    ext_tsk();}

static void entry0( CYG_ADDRWORD data ){#ifdef EXCEPTION_DATA_ACCESS    cyg_code_t n;#endif    cyg_exception_handler_t *old_handler, *old_handler1;    cyg_addrword_t old_data, old_data1;    CYG_UNUSED_PARAM(CYG_ADDRESS, data);    cyg_exception_set_handler(        CYGNUM_HAL_EXCEPTION_MAX,         &handler1,        (cyg_addrword_t)&d0,        &old_handler,        &old_data);    cyg_exception_set_handler(        CYGNUM_HAL_EXCEPTION_MAX,         &handler1,        (cyg_addrword_t)&d0,        &old_handler1,        &old_data1);        CYG_TEST_CHECK(old_handler1 == &handler1,        "register exception: old_handler not the one previously registered");    CYG_TEST_CHECK(old_data1 == (cyg_addrword_t)&d0,        "register exception: old_data not those previously registered");    cyg_exception_call_handler(        cyg_thread_self(),        CYGNUM_HAL_EXCEPTION_MAX,        (cyg_addrword_t)99);    CYG_TEST_INFO("handler 1 returned");    cyg_exception_clear_handler(CYGNUM_HAL_EXCEPTION_MAX);    cyg_exception_clear_handler(CYGNUM_HAL_EXCEPTION_MAX);#ifdef EXCEPTION_DATA_ACCESS#if 0#elif defined(CYGPKG_HAL_POWERPC_SIM)    // The exception generated by the SIM is not recognized by GDB.    // PR 19945 workaround.    CYG_TEST_NA("Not applicable to PowerPC SIM");#endif    for(n = CYGNUM_HAL_EXCEPTION_MIN; n <= CYGNUM_HAL_EXCEPTION_MAX; n++) {        cyg_exception_set_handler(            n,            handler0,            (cyg_addrword_t)123,             &old_handler1,            &old_data1);    }    CYG_TEST_PASS("Attempting to provoke exception");    cause_exception();    CYG_TEST_FAIL_FINISH("Couldn't cause exception");#else // EXCEPTION_DATA_ACCESS    CYG_TEST_NA("Platform does not support data exceptions");#endif}

//.........这里部分代码省略.........    CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );#endif // we can test bad param error returns    // try a pre-existing object    ercd = cre_mbx( 3, &t_cmbx );    CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" );    // delete it so we can play    ercd = del_mbx( 3 );    CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );    // check it is deleted    ercd = snd_msg( 3, t_msg );    CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );    ercd = rcv_msg( &msg, 3 );           CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" );    ercd = trcv_msg( &msg, 3, 10 );       CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" );    ercd = prcv_msg( &msg, 3 );            CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" );    ercd = ref_mbx( &t_rmbx, 3 );    CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" );#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS    // now try creating it (badly)#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR    ercd = cre_mbx( 3, NULL );    CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );#endif    ercd = cre_mbx( 3, NADR );    CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );    t_cmbx.mbxatr = 0xfff;    ercd = cre_mbx( 3, &t_cmbx );    CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" );    t_cmbx.mbxatr = 0;#endif // we can test bad param error returns    ercd = cre_mbx( 3, &t_cmbx );    CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );    // and check we can use it    ercd = snd_msg( 3, t_msg );    CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );    ercd = rcv_msg( &msg, 3 );           CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" );    ercd = trcv_msg( &msg, 3, 2 );       CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );    ercd = prcv_msg( &msg, 3 );                                CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );    ercd = ref_mbx( &t_rmbx, 3 );    CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );    // now wait while task 2 deletes the wait objects    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = rcv_msg( &msg, 1 );    CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = trcv_msg( &msg, 2, 20 );    CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );    // check they are deleted    ercd = snd_msg( 1, t_msg );    CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );    ercd = snd_msg( 2, t_msg );           CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );    // re-create and do it again    ercd = cre_mbx( 1, &t_cmbx );    CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );    ercd = cre_mbx( 2, &t_cmbx );    CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );    // now wait while task 2 deletes the wait objects again    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = rcv_msg( &msg, 1 );    CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );    ercd = wup_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );    ercd = trcv_msg( &msg, 2, 20 );    CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );    // check they are deleted    ercd = snd_msg( 1, t_msg );    CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );    ercd = snd_msg( 2, t_msg );           CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );    CYG_TEST_PASS("create/delete mboxes");#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE    ercd = ter_tsk( 2 );    CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );    ercd = dly_tsk( 5 );    CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );    // all done    if ( 0 == tests ) {        CYG_TEST_NA( "No objects have create/delete enabled" );    }    else {        CYG_TEST_EXIT( "All done" );    }    ext_tsk();}