int
main( 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 void
cyg_start( void )
{
    CYG_TEST_INIT();
    CYG_TEST_NA( "This test needs CYGVAR_KERNEL_COUNTERS_CLOCK "
                 "and CYGFUN_KERNEL_API_C" );
}

externC void
cyg_start( void )
{
    CYG_TEST_INIT();

    CYG_TEST_NA("This test needs DHCP enabled");
}

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

externC void
cyg_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 void
cyg_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");
}

void
tcp_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" );
}

int
main(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");
}

int
main(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 void
cyg_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 void
cyg_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
}

int
main(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()

void
cyg_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 void
cyg_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 void
cyg_start( void )
{ 
    kmutex1_main();
}

#else /* def CYGFUN_KERNEL_API_C */
externC void
cyg_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();
}