externC void
cyg_package_start( void )
{
CYG_TEST_INIT();
CYG_TEST_INFO( "Calling cyg_uitron_start()" );
cyg_uitron_start();
}
int main(int argc, char **argv)
{
pthread_t thread;
pthread_attr_t attr;
void *retval;
CYG_TEST_INIT();
// Create test thread
pthread_attr_init( &attr );
pthread_attr_setstackaddr( &attr, (void *)&thread_stack[sizeof(thread_stack)] );
pthread_attr_setstacksize( &attr, sizeof(thread_stack) );
pthread_create( &thread,
&attr,
pthread_entry1,
(void *)0x12345678);
// Now join with it
pthread_join( thread, &retval );
// check retval
if( (long)retval == 0x12345679 )
CYG_TEST_PASS_FINISH( "pthread1" );
else
CYG_TEST_FAIL_FINISH( "pthread1" );
}
// This is the main starting point for our example application.
void cyg_user_start( void )
{
int err;
void* lib_handle;
void (*fn)( void );
CYG_TEST_INIT();
CYG_TEST_INFO( "Object loader module test started" );
err = chdir( "/" );
if( err < 0 )
SHOW_RESULT( chdir, err );
lib_handle = cyg_ldr_open_library( (CYG_ADDRWORD)"/hello.o", 0 );
CYG_TEST_CHECK( lib_handle , "Unable to load object file to load" );
fn = cyg_ldr_find_symbol( lib_handle, "print_message" );
CYG_TEST_CHECK( fn , "Unable to find print_message function" );
fn();
fn = cyg_ldr_find_symbol( lib_handle, "weak_function" );
CYG_TEST_CHECK( fn , "Unable to find weak_function" );
fn();
fn = cyg_ldr_find_symbol ( lib_handle, "unresolvable_symbol" );
CYG_TEST_CHECK( !fn , "Found none existing symbol!" );
thread_a = cyg_ldr_find_symbol( lib_handle, "thread_a" );
thread_b = cyg_ldr_find_symbol( lib_handle, "thread_b" );
CYG_TEST_CHECK( thread_a && thread_b , "Unable to find thread functions" );
// Create our two threads.
cyg_thread_create( THREAD_PRIORITY,
thread_a,
(cyg_addrword_t) 75,
"Thread A",
(void *)thread_a_stack,
THREAD_STACK_SIZE,
&thread_a_hdl,
&thread_a_obj );
cyg_thread_create( THREAD_PRIORITY + 1,
thread_b,
(cyg_addrword_t) 68,
"Thread B",
(void *)thread_b_stack,
THREAD_STACK_SIZE,
&thread_b_hdl,
&thread_b_obj );
// Resume the threads so they start when the scheduler begins.
cyg_thread_resume( thread_a_hdl );
cyg_thread_resume( thread_b_hdl );
cyg_scheduler_start();
}
externC void
cyg_start( void )
{
CYG_TEST_INIT();
CYG_TEST_INFO("Calculating CRCs");
if (1500790746l != cyg_posix_crc32(license_txt,sizeof(license_txt)-1)) {
CYG_TEST_FAIL("Wrong POSIX CRC32 calculation");
} else {
CYG_TEST_PASS("POSIX CRC32 calculation");
}
if (1247800780 != cyg_crc32(license_txt,sizeof(license_txt)-1)) {
CYG_TEST_FAIL("Wrong Gary S. Browns' crc32 calculation");
} else {
CYG_TEST_PASS("Gary S. Browns' crc32 calculation");
}
if (32256 != cyg_crc16(license_txt,sizeof(license_txt)-1)) {
CYG_TEST_FAIL_FINISH("Wrong 16bit CRC calculation");
} else {
CYG_TEST_PASS_FINISH("16bit CRC calculation");
}
}
void
cyg_start(void)
{
CYG_TEST_INIT();
//
// open CAN device driver
//
if (ENOERR != cyg_io_lookup("/dev/can0", &hCAN0))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
}
//
// create the two threads which access the CAN device driver
// a reader thread with a higher priority and a writer thread
// with a lower priority
//
cyg_thread_create(4, can0_thread,
(cyg_addrword_t) 0,
"can0_thread",
(void *) can0_thread_data.stack,
1024 * sizeof(long),
&can0_thread_data.hdl,
&can0_thread_data.obj);
cyg_thread_resume(can0_thread_data.hdl);
cyg_scheduler_start();
}
void
cyg_start(void)
{
CYG_TEST_INIT();
//
// open CAN device driver
//
if (ENOERR != cyg_io_lookup("/dev/can0", &hCAN0))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
}
//
// create the thread that accesses the CAN device driver
//
cyg_thread_create(4, can0_thread,
(cyg_addrword_t) 0,
"can0_thread",
(void *) can0_thread_data.stack,
1024 * sizeof(long),
&can0_thread_data.hdl,
&can0_thread_data.obj);
cyg_thread_resume(can0_thread_data.hdl);
cyg_scheduler_start();
}
externC void
cyg_start( void )
{
CYG_TEST_INIT();
CYG_TEST_NA("This test needs DHCP enabled");
}
int main( int argc, char **argv )
{
void *retval;
pthread_attr_t attr;
struct sched_param schedparam;
CYG_TEST_INIT();
#ifdef TEST_NET
sa.sin_family = AF_INET;
sa.sin_len = sizeof(sa);
inet_aton("127.0.0.1", &sa.sin_addr);
sa.sin_port = htons(1234);
init_all_network_interfaces();
#endif
// Create test threads
{
pthread_attr_init( &attr );
schedparam.sched_priority = 10;
pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
pthread_attr_setschedpolicy( &attr, SCHED_RR );
pthread_attr_setschedparam( &attr, &schedparam );
pthread_attr_setstackaddr( &attr, (void *)&thread1_stack[sizeof(thread1_stack)] );
pthread_attr_setstacksize( &attr, sizeof(thread1_stack) );
pthread_create( &thread1,
&attr,
pthread_entry1,
(void *)0x12345671);
}
{
pthread_attr_init( &attr );
schedparam.sched_priority = 5;
pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
pthread_attr_setschedpolicy( &attr, SCHED_RR );
pthread_attr_setschedparam( &attr, &schedparam );
pthread_attr_setstackaddr( &attr, (void *)&thread2_stack[sizeof(thread2_stack)] );
pthread_attr_setstacksize( &attr, sizeof(thread2_stack) );
pthread_create( &thread2,
&attr,
pthread_entry2,
(void *)0x12345672);
}
// Now join with thread1
CYG_TEST_INFO( "Main: calling pthread_join(thread1)");
pthread_join( thread1, &retval );
// And thread 2
CYG_TEST_INFO( "Main: calling pthread_join(thread2)");
pthread_join( thread2, &retval );
CYG_TEST_PASS_FINISH("select");
}
void
cyg_start(void)
{
CYG_TEST_INIT();
cyg_thread_create(MAIN_THREAD_PRIORITY, // Priority
tcp_server, // entry
0, // entry parameter
"TCP loopback server", // Name
&stack_server[0], // Stack
STACK_SIZE, // Size
&server_thread_handle, // Handle
&server_thread_data // Thread data structure
);
cyg_thread_resume(server_thread_handle); // Start it
cyg_thread_create(MAIN_THREAD_PRIORITY, // Priority
tcp_client, // entry
0, // entry parameter
"TCP loopback client", // Name
&stack_client[0], // Stack
STACK_SIZE, // Size
&client_thread_handle, // Handle
&client_thread_data // Thread data structure
);
cyg_scheduler_start();
}
void timeslice_main( void )
{
CYG_TEST_INIT();
// Work out how many CPUs we actually have.
ncpus = CYG_KERNEL_CPU_COUNT();
cyg_thread_create(0, // Priority - just a number
run_tests, // entry
0, // index
"run_tests", // Name
test_stack, // Stack
STACK_SIZE, // Size
&main_thread, // Handle
&test_thread // Thread data structure
);
cyg_thread_resume( main_thread);
cyg_thread_create(5, // Priority - just a number
hipri_test, // entry
0, // index
"hipri_run", // Name
hipri_stack, // Stack
STACK_SIZE, // Size
&hipri_thread, // Handle
&hipri_thread_obj // Thread data structure
);
cyg_thread_resume( hipri_thread);
cyg_scheduler_start();
}
int
main( int argc, char *argv[] )
{
int num, denom;
div_t result;
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"div() function");
num = 10232;
denom = 43;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==237) && (result.rem==41),
"div( 10232, 43 )");
num = 4232;
denom = 2000;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==2) && (result.rem==232),
"div( 4232, 2000 )");
num = 20;
denom = 20;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==1) && (result.rem==0),
"div( 20, 20 )");
num = -5;
denom = 4;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==-1) && (result.rem==-1),
"div( -5, 4 )");
num = 5;
denom = -4;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==-1) && (result.rem==1),
"div( 5, -4 )");
num = -5;
denom = -3;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==1) && (result.rem==-2),
"div( -5, -3 )");
num = -7;
denom = -7;
result = div(num, denom);
CYG_TEST_PASS_FAIL( (result.quot==1) && (result.rem==0),
"div( -7, -7 )");
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"div() function");
} // main()
void fptest_main( void )
{
CYG_TEST_INIT();
if( cyg_test_is_simulator )
{
run_ticks = RUN_TICKS_SIM;
}
CYG_TEST_INFO("Run fptest in cyg_start");
do_test( fpt3_values, FP3_COUNT, 1000, 0, "start" );
CYG_TEST_INFO( "cyg_start run done");
cyg_thread_create( BASE_PRI-1,
fptest1,
0,
"fptest1",
&stacks[0][0],
STACK_SIZE,
&thread[0],
&thread_struct[0]);
cyg_thread_resume( thread[0] );
cyg_thread_create( BASE_PRI,
fptest2,
1,
"fptest2",
&stacks[1][0],
STACK_SIZE,
&thread[1],
&thread_struct[1]);
cyg_thread_resume( thread[1] );
cyg_thread_create( BASE_PRI,
fptest3,
2,
"fptest3",
&stacks[2][0],
STACK_SIZE,
&thread[2],
&thread_struct[2]);
cyg_thread_resume( thread[2] );
cyg_alarm_create( cyg_real_time_clock(),
alarm_fn,
0,
&alarm,
&alarm_struct );
cyg_alarm_initialize( alarm, cyg_current_time()+1, 1 );
cyg_scheduler_start();
}
void cyg_user_start(void)
#endif
{
char x[300];
char y[300];
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"strcmp() function");
CYG_TEST_INFO("This testcase provides simple basic tests");
// Check 1
my_strcpy(x, "I have become, comfortably numb");
my_strcpy(y, "I have become, comfortably numb");
CYG_TEST_PASS_FAIL( (strcmp(x, y) == 0), "Simple compare");
// Check 2
my_strcpy(x, "");
my_strcpy(y, "");
CYG_TEST_PASS_FAIL( (strcmp(x, y) == 0), "Simple empty string compare");
// Check 3
my_strcpy(x, "..shall snuff it. And the Lord did grin");
my_strcpy(y, "..shall snuff it. And the Lord did grio");
CYG_TEST_PASS_FAIL( (strcmp(x, y) < 0),
"Memory less than #1" );
// Check 4
my_strcpy(x, "A reading from the Book of Armaments, Chapter 4, "
"Verses 16 to 20:");
my_strcpy(y, "Bless this, O Lord, that with it thou mayst blow thine "
"enemies to tiny bits, in thy mercy.");
CYG_TEST_PASS_FAIL( (strcmp(x, y) < 0),
"Memory less than #2");
// Check 5
my_strcpy(x, "Lobeth this thy holy hand grenade at thy foe");
my_strcpy(y, "Lobeth this thy holy hand grenade at thy fod");
CYG_TEST_PASS_FAIL( (strcmp(x, y) > 0),
"Memory greater than #1" );
// Check 6
my_strcpy(y, "Three shall be the number of the counting and the");
my_strcpy(x, "number of the counting shall be three");
CYG_TEST_PASS_FAIL( (strcmp(x, y) > 0),
"Memory greater than #2" );
// CYG_TEST_NA("Testing is not applicable to this configuration");
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"strcmp() function");
} // main()
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");
}
int main(int argc, char **argv)
{
int i, j;
int ret;
void *retval[NTHREADS];
CYG_TEST_INIT();
// Create test threads
for( i = 0; i < NTHREADS; i++ )
{
pthread_attr_t attr;
pthread_attr_init( &attr );
pthread_attr_setstackaddr( &attr, (void *)&thread_stack[i][sizeof(thread_stack[i])] );
pthread_attr_setstacksize( &attr, sizeof(thread_stack[i]) );
ret = pthread_create( &thread[i],
&attr,
pthread_entry[i],
(void *)(0x12340000+i));
CYG_TEST_CHECK( ret == 0, "pthread_create() returned error");
}
// Let the threads get going
for ( i = 0; i < NTHREADS ; i++ ) {
while ( thread_ready[i] == false )
sched_yield();
}
// Now wait a bit to be sure that the other threads have reached
// their cancellation points.
for ( j = 0; j < 20 ; j++ )
sched_yield();
// Now cancel them
for( i = 0; i < NTHREADS; i++ )
pthread_cancel( thread[i] );
// Now join with threads
for( i = 0; i < NTHREADS; i++ )
pthread_join( thread[i], &retval[i] );
// check retvals
for( i = 0; i < NTHREADS; i++ )
CYG_TEST_CHECK( retval[i] == PTHREAD_CANCELED,
"thread didn't exit with PTHREAD_CANCELED" );
CYG_TEST_CHECK( cancel_handler1_called, "cancel_handler1 not called" );
CYG_TEST_CHECK( cancel_handler2_called, "cancel_handler2 not called" );
CYG_TEST_CHECK( cancel_handler3_called, "cancel_handler3 not called" );
CYG_TEST_PASS_FINISH( "pthread3" );
}
externC void
cyg_start( void )
{
CYG_TEST_INIT();
intr_main();
CYG_TEST_NA("Cannot override kernel real-time clock.");
}
void kflag0_main( void )
{
CYG_TEST_INIT();
CHECK(flash());
CHECK(flash());
CYG_TEST_PASS_FINISH("Kernel C API Flag 0 OK");
}
void kcache2_main( void )
{
CYG_TEST_INIT();
cyg_thread_create(4, entry0 , (cyg_addrword_t)0, "kcache1",
(void *)stack[0], STACKSIZE, &thread[0], &thread_obj[0]);
cyg_thread_resume(thread[0]);
cyg_scheduler_start();
}
void cyg_user_start(void)
#endif
{
char x[300];
char y[300];
char *ret;
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"strcat() function");
CYG_TEST_INFO("This testcase provides simple basic tests");
// Check 1
my_strcpy(x, "One ring to rule them all.");
my_strcpy(y, "One ring to find them.");
ret = strcat(x, y);
if ( my_strcmp(x, "One ring to rule them all.One ring to find them.")==0 )
CYG_TEST_PASS("Simple concatenation");
else
CYG_TEST_FAIL("Simple concatenation");
// Check return val
CYG_TEST_PASS_FAIL( ( ret == x ), "Simple concatenation return value" );
// Check 2
my_strcpy(x, "One ring to bring them all,");
my_strcpy(y, "");
ret = strcat(x, y);
if ( my_strcmp(x, "One ring to bring them all,")==0 )
CYG_TEST_PASS("Concatenation of empty string");
else
CYG_TEST_FAIL("Concatenation of empty string");
// Check return val
CYG_TEST_PASS_FAIL( ( ret == x ),
"Concatenation of empty string return value" );
// Check 3
my_strcpy(x, "and in the darkness bind them");
my_strcpy(y, "");
ret = strcat(y, x);
if ( my_strcmp(x, "and in the darkness bind them")==0 )
CYG_TEST_PASS("Concatenation to empty string");
else
CYG_TEST_FAIL("Concatenation to empty string");
// Check return val
CYG_TEST_PASS_FAIL( ( ret == y ),
"Concatenation to empty string return value" );
// CYG_TEST_NA("Testing is not applicable to this configuration");
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"strcat() function");
} // main()
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");
}
externC void
cyg_start( void )
{
CYG_TEST_INIT();
cyg_thread_create(4, entry0 , (cyg_addrword_t)0, "intr",
(void *)stack[0], STACKSIZE, &thread[0], &thread_obj[0]);
cyg_thread_resume(thread[0]);
cyg_scheduler_start();
}
void cyg_user_start(void)
#endif
{
char x[300];
char y[300];
void *ret, *ptr1, *ptr2;
char *c_ret;
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"memcpy() function");
CYG_TEST_INFO("This testcase provides simple basic tests");
// Check 1
ptr1 = x;
ptr2 = y;
my_strcpy(x, "Great shot kid! That was one in a million!");
ret = memcpy(ptr2, ptr1, my_strlen(x) + 1);
CYG_TEST_PASS_FAIL( (my_strcmp(x, ptr2)==0), "Simple copy" );
// Check return value
CYG_TEST_PASS_FAIL( (my_strcmp(ret, ptr2)==0), "Simple copy return value");
// Check 2
ptr1 = x;
ptr2 = y;
my_strcpy(x, "");
my_strcpy(y, "xxxx"); // Bogus val to get overwritten
ret = memcpy(ptr2, ptr1, 1);
c_ret = ret;
if ((*c_ret == '\0') && (y[0] == '\0') && (y[1] == 'x'))
CYG_TEST_PASS("Simple copy with boundary check worked");
else
CYG_TEST_FAIL("Simple copy with boundary check failed");
// Check 3
ptr1 = x;
ptr2 = y;
my_strcpy(x, "xxxx");
my_strcpy(y, "yyyy");
ret = memcpy(ptr1, ptr2, 0);
c_ret = ret;
if ((*c_ret =='x') && (x[0] == 'x'))
CYG_TEST_PASS("Simple copy with size=0 worked");
else
CYG_TEST_FAIL("Simple copy with size=0 failed");
// CYG_TEST_NA("Testing is not applicable to this configuration");
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"memcpy() function");
} // main()
int
main(int argc, char *argv[])
{
time_t t1, t2;
unsigned long ctr;
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"time() function");
t1 = time(&t2);
CYG_TEST_PASS_FAIL(t1==t2, "time() return value == argument");
if (t1 == (time_t)-1) // unimplemented is just as valid
{
#ifndef CYGSEM_LIBC_TIME_TIME_WORKING
CYG_TEST_PASS_FINISH( "time() returns -1, meaning unimplemented");
#else
CYG_TEST_FAIL("time() returned -1 unnecessarily");
#endif
} // if
// First wait for a clock tick
for (ctr = 0; ctr<MAX_TIMEOUT; ctr++) {
if ((t2=time(NULL)) > t1)
break; // Hit the next time pulse
}
CYG_TEST_PASS_FAIL( ctr< MAX_TIMEOUT, "time()'s state changes");
#ifdef CYGSEM_LIBC_TIME_SETTIME_WORKING
CYG_TEST_PASS_FAIL(cyg_libc_time_settime(0)==0, "Set time to 0");
t1 = time(NULL);
// give it a small amount of tolerance
CYG_TEST_PASS_FAIL(t1 < 3, "t1 remembered setting");
CYG_TEST_PASS_FAIL(cyg_libc_time_settime(1000)==0, "Set time to 1000");
// give it a small amount of tolerance
CYG_TEST_PASS_FAIL(t1 < 1003, "t1 remembered setting");
#else // ! CYGSEM_LIBC_TIME_SETTIME_WORKING
CYG_TEST_PASS_FAIL(cyg_libc_time_settime(0)!=0,
"Set time expected fail");
#endif // CYGSEM_LIBC_TIME_SETTIME_WORKING
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"time() function");
} // main()
void
httpd_test(cyg_addrword_t p)
{
CYG_TEST_INIT();
init_all_network_interfaces();
cyg_thread_delay(1 * 60 * 100);
CYG_TEST_PASS_FINISH( "httpd test finished" );
}
void zlib2_main( void )
{
CYG_TEST_INIT();
cyg_thread_create(4, entry0 , (cyg_addrword_t)0, "zlib1",
(void *)stack[0], STACKSIZE,&thread[0], &thread_obj[0]);
cyg_thread_resume(thread[0]);
cyg_scheduler_start();
CYG_TEST_FAIL_FINISH("Not reached");
}
void
net_test(cyg_addrword_t param)
{
cyg_serial_baud_rate_t old;
cyg_ppp_options_t options;
cyg_ppp_handle_t ppp_handle;
CYG_TEST_INIT();
diag_printf("Start TCP test - ECHO mode\n");
init_all_network_interfaces();
calibrate_load(DESIRED_BACKGROUND_LOAD);
#ifdef CYGPKG_SNMPAGENT
{
extern void cyg_net_snmp_init(void);
cyg_net_snmp_init();
}
#endif
old = ppp_test_set_baud( CYGNUM_SERIAL_BAUD_115200 );
ppp_test_announce( "TCP_ECHO" );
cyg_ppp_options_init( &options );
// options.debug = 1;
// options.kdebugflag = 1;
// options.flowctl = CYG_PPP_FLOWCTL_SOFTWARE;
ppp_handle = cyg_ppp_up( CYGPKG_PPP_TEST_DEVICE, &options );
CYG_TEST_INFO( "Waiting for PPP to come up");
cyg_ppp_wait_up( ppp_handle );
echo_test(param);
CYG_TEST_INFO( "Bringing PPP down");
cyg_ppp_down( ppp_handle );
CYG_TEST_INFO( "Waiting for PPP to go down");
cyg_ppp_wait_down( ppp_handle );
cyg_thread_delay( 200 );
ppp_test_set_baud( old );
ppp_test_finish();
CYG_TEST_PASS_FINISH("TCP ECHO test OK");
}
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()
void cyg_user_start(void)
#endif
{
char x[300];
char y[300];
char *ret;
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for C library "
"strstr() function");
CYG_TEST_INFO("This testcase provides simple basic tests");
// Check 1
my_strcpy(x, "I will not have my fwends widiculed by the common soldiewy");
my_strcpy(y, "fwends");
ret = strstr(x, y);
CYG_TEST_PASS_FAIL( (ret == &x[19]), "Simple strstr()" );
// Check 2 (boundary condition)
my_strcpy(x, "Not bad for a little fur ball. You! Stay here.");
my_strcpy(y, "ball ");
ret = strstr(x, y);
CYG_TEST_PASS_FAIL( (ret == NULL), "String to search for not present" );
// Check 3 (boundary condition)
my_strcpy(x, "");
my_strcpy(y, "zx");
ret = strstr(x, y);
CYG_TEST_PASS_FAIL( (ret == NULL), "Empty string to search" );
// Check 4 (boundary condition)
my_strcpy(x, "fdafdafdfahjgf");
my_strcpy(y, "");
ret = strstr(x, y);
CYG_TEST_PASS_FAIL( (ret == x), "Empty search string" );
// Check 5 (boundary condition)
my_strcpy(x, "");
my_strcpy(y, "");
ret = strstr(x, y);
CYG_TEST_PASS_FAIL( (ret == x), "Both strings empty" );
// CYG_TEST_NA("Testing is not applicable to this configuration");
CYG_TEST_FINISH("Finished tests from testcase " __FILE__ " for C library "
"strstr() function");
} // main()
int
main(int argc, char *argv[])
{
CYG_TEST_INIT();
CYG_TEST_INFO("Starting tests from testcase " __FILE__ " for Math library "
"expm1f() function");
START_TEST( test );
CYG_TEST_PASS_FINISH("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");
}