void sparc_ex_main( void ) { int i; CYG_TEST_INIT(); for ( i = CYGNUM_HAL_EXCEPTION_MIN; i <= CYGNUM_HAL_EXCEPTION_MAX; i++ ){ int j; HAL_TRANSLATE_VECTOR( i, j ); HAL_INTERRUPT_ATTACH( j, &fail_exception_handler, j, 0 ); // we must also ensure that eCos handles the exception; // do not drop into CygMon or equivalent. // Leave USER_TRAP undisturbed so that breakpoints work. if ( CYGNUM_HAL_VECTOR_USER_TRAP != i ) { extern void hal_default_exception_vsr( void ); HAL_VSR_SET( i, (CYG_ADDRESS)hal_default_exception_vsr, NULL ); } } HAL_TRANSLATE_VECTOR( CYGNUM_HAL_VECTOR_UNALIGNED, i ); HAL_INTERRUPT_DETACH( i, &fail_exception_handler ); HAL_INTERRUPT_ATTACH( i, &skip_exception_handler, i, 0 ); CYG_TEST_INFO( "Vectors attached OK; calling do_test" ); do_test(); CYG_TEST_EXIT( "Done" ); }
cyg_start( void ) #endif { int loops; CYG_TEST_INIT(); CYG_TEST_INFO( "cyg_user_start()" ); HAL_ENABLE_INTERRUPTS(); loops = start(); // Typically about 1200 loops execute on the 33MHz 86832; // I hoped to put in a check that we hadn't wasted time in // spurious interrupts, but kernel instrumentation, for example, // is more than enough to slow the world down... so keep this // very weak test in, as a placeholder. CYG_TEST_CHECK( 100 <= loops, "Not enough tests executed" ); CYG_TEST_EXIT( "All done" ); }
void net_test(cyg_addrword_t param) { extern void cyg_net_snmp_init(void); CYG_TEST_INIT(); CYG_TEST_INFO("Start multiple SNMP server test"); init_all_network_interfaces(); autohost_init(); cyg_net_snmp_init(); TNR_INIT(); // Now command the host to do ping to us... #ifdef CYGHWR_NET_DRIVER_ETH0 if (eth0_up) { do_snmp_tests(ð0_bootp_data, 3, TESTTIME); } #endif #ifdef CYGHWR_NET_DRIVER_ETH1 if (eth1_up) { do_snmp_tests(ð1_bootp_data, 3, TESTTIME); } #endif // Let the server run for 5 minutes cyg_thread_delay(2*100); // let the stuff start up first TNR_ON(); cyg_thread_delay(TESTTIME*100); // FIXME - assume cS clock. // Additional delay 'cos host may be slower than us - and it has to // complete a transfer anyway: cyg_thread_delay( 30 *100); // FIXME - assume cS clock. TNR_OFF(); autohost_end( 3 * (0 #ifdef CYGHWR_NET_DRIVER_ETH0 + eth0_up #endif #ifdef CYGHWR_NET_DRIVER_ETH1 + eth1_up #endif ) ); // check for N pass messages from hosts TNR_PRINT_ACTIVITY(); CYG_TEST_EXIT("Done"); }
void cyg_start(void) { int i, j; int x = 0, y = 0; int result; cyg_ucount16 block_width; CYG_FB_PIXEL0_VAR(FRAMEBUF); CYG_FB_PIXEL1_VAR(FRAMEBUF); #define DEPTH CYG_FB_DEPTH(FRAMEBUF) #define WIDTH CYG_FB_WIDTH(FRAMEBUF) #define HEIGHT CYG_FB_HEIGHT(FRAMEBUF) CYG_TEST_INIT(); diag_printf("Frame buffer %s\n", STRING(FRAMEBUF)); diag_printf("Depth %d, width %d, height %d\n", DEPTH, WIDTH, HEIGHT); result = CYG_FB_ON(FRAMEBUF); if (CYG_FB_FLAGS0(FRAMEBUF) & CYG_FB_FLAGS0_TRUE_COLOUR) { reset_colours_to_true(); } // A white background CYG_FB_FILL_BLOCK(FRAMEBUF, 0, 0, WIDTH, HEIGHT, WHITE); // A black block in the middle, 25 pixels in. CYG_FB_FILL_BLOCK(FRAMEBUF, 32, 32, WIDTH - 64, HEIGHT - 64, BLACK); // Four diagonal lines in the corners. Red in the top left, blue in the top right, // green in the bottom left, and yellow in the bottom right. for (i = 0; i < 32; i++) { CYG_FB_WRITE_PIXEL(FRAMEBUF, i, i, RED); CYG_FB_WRITE_PIXEL(FRAMEBUF, (WIDTH - 1) - i, i, BLUE); CYG_FB_WRITE_PIXEL(FRAMEBUF, i, (HEIGHT - 1) - i, GREEN); CYG_FB_WRITE_PIXEL(FRAMEBUF, (WIDTH - 1) - i, (HEIGHT - 1) - i, YELLOW); } // Horizontal and vertical lines. Cyan at the top, magenta on the bottom, // brown on the left, lightgrey on the right. CYG_FB_WRITE_HLINE(FRAMEBUF, 32, 16, WIDTH - 64, CYAN); CYG_FB_WRITE_HLINE(FRAMEBUF, 32, HEIGHT - 16, WIDTH - 64, MAGENTA); CYG_FB_WRITE_VLINE(FRAMEBUF, 16, 32, HEIGHT - 64, BROWN); CYG_FB_WRITE_VLINE(FRAMEBUF, WIDTH - 16, 32, HEIGHT - 64, LIGHTGREY); // Top left, diagonal lines away from 0,0 with increasing spacing horizontally for (i = 0; i < 16; i++) { CYG_FB_PIXEL0_SET(FRAMEBUF, i + 16, i); for (j = 0; j < 16; j++) { CYG_FB_PIXEL0_WRITE(FRAMEBUF, colours[i]); CYG_FB_PIXEL0_ADDX(FRAMEBUF, j); } } // Top right, diagonal lines away from the corner, with increasing spacing horizontally for (i = 0; i < 16; i++) { CYG_FB_PIXEL0_SET(FRAMEBUF, WIDTH - (i + 16), i); for (j = 0; j < 16; j++) { CYG_FB_PIXEL0_WRITE(FRAMEBUF, colours[i]); CYG_FB_PIXEL0_ADDX(FRAMEBUF, -1 * j); } } // Top left, diagonal lines away from the corner, with increasing spacing vertically for (i = 0; i < 16; i++) { CYG_FB_PIXEL0_SET(FRAMEBUF, i, i + 16); for (j = 0; j < 16; j++) { CYG_FB_PIXEL0_WRITE(FRAMEBUF, colours[i]); CYG_FB_PIXEL0_ADDY(FRAMEBUF, j); } } // Bottom left, diagonal lines away from the corner, with increasing spacing vertically for (i = 0; i < 16; i++) { CYG_FB_PIXEL0_SET(FRAMEBUF, i, HEIGHT - (i + 16)); for (j = 0; j < 16; j++) { CYG_FB_PIXEL0_WRITE(FRAMEBUF, colours[i]); CYG_FB_PIXEL0_ADDY(FRAMEBUF, -1 * j); } } // Thin vertical bars in the top-middle of the screen, between the hline and the box. // Starting in the center and moving out with increasing spacing. for (j = 0; j < 8; j++) { CYG_FB_PIXEL0_SET(FRAMEBUF, (WIDTH / 2) - 2, 20 + j); CYG_FB_PIXEL0_GET(FRAMEBUF, x, y); CYG_FB_PIXEL1_SET(FRAMEBUF, x + 3, y); for (i = 0; i < 16; i++) { CYG_FB_PIXEL0_ADDX(FRAMEBUF, -1 * i); CYG_FB_PIXEL1_ADDX(FRAMEBUF, i); CYG_FB_PIXEL0_WRITE(FRAMEBUF, colours[i]); CYG_FB_PIXEL1_WRITE(FRAMEBUF, colours[i]); } } if (8 == DEPTH) { CYG_FB_WRITE_BLOCK(FRAMEBUF, 0, HEIGHT / 2, 8, 8, bitmap8, 0, 8); } else if (16 == DEPTH) { CYG_FB_WRITE_BLOCK(FRAMEBUF, 0, HEIGHT / 2, 8, 8, bitmap16, 0, 8); } else if (32 == DEPTH) { CYG_FB_WRITE_BLOCK(FRAMEBUF, 0, HEIGHT / 2, 8, 8, bitmap32, 0, 8); } block_width = (WIDTH - 100) / 14; for (i = 1; i <= 14; i++) { CYG_FB_FILL_BLOCK(FRAMEBUF, 50 + ((i - 1) * block_width), 50, block_width, HEIGHT - 100, colours[i]); } CYG_TEST_EXIT("Done"); }
cyg_start( void ) #endif { int stackmem = 127; unsigned int p1, p2, v1, v2; CYG_TEST_INIT(); CYG_TEST_INFO( "Starting MMap test" ); // First check the pagesize macro for various objects. p1 = 0; HAL_MM_PAGESIZE( &stackmem, p1 ); CYG_TEST_CHECK( SZ_1M == p1, "Pagesize bad for stackmem" ); p1 = 1; HAL_MM_PAGESIZE( &staticmem, p1 ); CYG_TEST_CHECK( SZ_1M == p1, "Pagesize bad for staticmem" ); p1 = 2; HAL_MM_PAGESIZE( &somefunc, p1 ); CYG_TEST_CHECK( SZ_1M == p1, "Pagesize bad for somefunc" ); CYG_TEST_PASS( "Pagesize macro OK" ); // Test the macros with directly quoted "&thing" input args, // with things being static, on-stack, and code area: HAL_VIRT_TO_PHYS_ADDRESS( &stackmem, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( (unsigned int)(&stackmem) == v2, "Stackmem translation failed" ); HAL_VIRT_TO_PHYS_ADDRESS( &staticmem, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( (unsigned int)(&staticmem) == v2, "Staticmem translation failed" ); HAL_VIRT_TO_PHYS_ADDRESS( &somefunc, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( (unsigned int)(&somefunc) == v2, "Somefunc translation failed" ); // Test the macros with variable pointer input args: v1 = (unsigned int)&stackmem; HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( v1 == v2, "Ptr-to-stackmem translation failed" ); v1 = (unsigned int)&staticmem; HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( v1 == v2, "Ptr-to-staticmem translation failed" ); v1 = (unsigned int)&somefunc; HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( v1 == v2, "Ptr-to-somefunc translation failed" ); // Test the UNCACHED address macros similarly: v1 = (unsigned int)&stackmem; HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( v1 != p2, "Stack mem already uncached!" ); *(int *)v1 = 17; HAL_DCACHE_STORE( v1, 4 ); CYG_TEST_CHECK( *(int *)p2 == 17, "Uncached stack data not 17" ); *(int *)v1 = 23; HAL_DCACHE_STORE( v1, 4 ); CYG_TEST_CHECK( *(int *)p2 == 23, "Uncached stack data not 23" ); v1 = (unsigned int)&staticmem; HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( v1 != p2, "Static mem already uncached!" ); *(int *)v1 = 117; HAL_DCACHE_STORE( v1, 4 ); CYG_TEST_CHECK( *(int *)p2 == 117, "Uncached static data not 117" ); *(int *)v1 = 123; HAL_DCACHE_STORE( v1, 4 ); CYG_TEST_CHECK( *(int *)p2 == 123, "Uncached static data not 123" ); #ifdef CYG_HAL_STARTUP_RAM // then somefunc is in RAM, and this is valid v1 = (unsigned int)&somefunc; HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( v1 != p2, "Somefunc already uncached!" ); CYG_TEST_CHECK( *(int *)p2 == *(int *)v1, "Uncached instruction not the same" ); #else CYG_TEST_INFO( "Skipping code cachability test, not RAM start" ); #endif // Now check via the routines that actually read the MMAP table: v1 = (unsigned int)&stackmem; p1 = hal_virt_to_phys_address( v1 ); HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Physical address of stackmem mismatch" ); v1 = hal_phys_to_virt_address( p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( &stackmem == (int *)v1, "Func : Virtual address of stackmem wrong" ); CYG_TEST_CHECK( &stackmem == (int *)v2, "Macro: Virtual address of stackmem wrong" ); v1 = (unsigned int)&staticmem; p1 = hal_virt_to_phys_address( v1 ); HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Physical address of staticmem mismatch" ); v1 = hal_phys_to_virt_address( p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( &staticmem == (int *)v1, "Func : Virtual address of staticmem wrong" ); CYG_TEST_CHECK( &staticmem == (int *)v2, "Macro: Virtual address of staticmem wrong" ); v1 = (unsigned int)&somefunc; p1 = hal_virt_to_phys_address( v1 ); HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Physical address of somefunc mismatch" ); v1 = hal_phys_to_virt_address( p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); CYG_TEST_CHECK( (unsigned int)&somefunc ==v1, "Func : Virtual address of somefunc wrong" ); CYG_TEST_CHECK( (unsigned int)&somefunc == v2, "Macro: Virtual address of somefunc wrong" ); // And check the uncached-address version of the routines that actually // read the MMAP table: v1 = (unsigned int)&stackmem; p1 = hal_virt_to_uncached_address( v1 ); HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Uncached address of stackmem mismatch" ); v1 = (unsigned int)&staticmem; p1 = hal_virt_to_uncached_address( v1 ); HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Uncached address of staticmem mismatch" ); #ifdef CYG_HAL_STARTUP_RAM // then somefunc is in RAM, and this is valid v1 = (unsigned int)&somefunc; p1 = hal_virt_to_uncached_address( v1 ); HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); CYG_TEST_CHECK( p1 == p2, "Uncached address of somefunc mismatch" ); #else CYG_TEST_INFO( "Skipping code cachability test 2, not RAM start" ); #endif CYG_TEST_PASS( "Initial explicit tests AOK" ); // --------------------------------------------------------------- // // We have now tested the macros and routines for some example objects // that we know are in RAM and which therefore should be dual-mapped. // // We can now whizz through all of the address space, checking as we go // that sensible things happen. We must NOT use the addresses in // question, just pass them through the macros and routines. // Start from some random address, // go up until we have covered all of memory // increment by about 0.8 of a Mb, for ( v1 = 0x12345; v1 ; v1 += 0xffff7 ) { unsigned int v3; loopcount++; p1 = hal_virt_to_phys_address( v1 ); HAL_VIRT_TO_PHYS_ADDRESS( v1, p2 ); if ( p1 ) { vpcount++; // Then there is a physical address for this virtual address if (p1 != p2) diag_printf("v1: %p, p1: %p, p2: %p\n", v1, p1, p2); CYG_TEST_CHECK( p1 == p2, "Scan: truly mapped physical address mismatch" ); v3 = hal_phys_to_virt_address( p2 ); HAL_PHYS_TO_VIRT_ADDRESS( p2, v2 ); if (v2 != v3) diag_printf("v1: %p, p1: %p, v2: %p, v3: %p\n", v1, p1, v2, v3); CYG_TEST_CHECK( v3 == v2, "Scan: backmapped virtual address mismatch" ); // But the virtual address might be elsewhere, ie. a cached // nonphysical address. if ( v3 != v1 ) { // Then it is [also] elsewhere, apparently. Check that its // otherness maps right back to this physical address. p1 = hal_virt_to_phys_address( v2 ); if (p1 != p2) diag_printf("v1: %p, p1: %p, p2: %p\n", v1, p1, p2); CYG_TEST_CHECK( p1 == p2, "Scan: phys(virt(phys(x))) mismatch" ); } } p1 = hal_virt_to_uncached_address( v1 ); HAL_VIRT_TO_UNCACHED_ADDRESS( v1, p2 ); if ( p1 ) { uncachedcount++; // Then there is an uncached address for this virtual address if (p1 != p2) diag_printf("v1: %p, p1: %p, p2: %p\n", v1, p1, p2); CYG_TEST_CHECK( p1 == p2, "Uncached address of stackmem mismatch" ); } if ( v1 > 0xfff00000u ) break; } diag_printf( "INFO:<%d addresses tested>\n", loopcount ); diag_printf( "INFO:<%d virt-phys mappings checked>\n", vpcount ); diag_printf( "INFO:<%d uncachable addresses checked>\n", uncachedcount ); CYG_TEST_PASS( "MMap memory scan test OK" ); // --------------------------------------------------------------- CYG_TEST_EXIT( "Done" ); }
int main(void) { mqd_t q1, q2; char buf[20]; ssize_t recvlen; unsigned int prio; struct mq_attr attr, oattr; mode_t mode; int err; CYG_TEST_INIT(); CYG_TEST_INFO( "Starting POSIX message test 1" ); q1 = mq_open( "/mq1", O_RDWR ); CYG_TEST_PASS_FAIL( q1 == (mqd_t)-1, "error for non-existent queue" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for non-existent queue" ); attr.mq_flags = 0; attr.mq_maxmsg = 4; attr.mq_msgsize = 20; mode = S_IRWXU|S_IRWXG|S_IRWXO; // rwx for all q1 = mq_open( "/mq1", O_CREAT|O_NONBLOCK|O_WRONLY, mode, &attr ); CYG_TEST_PASS_FAIL( q1 != (mqd_t)-1, "simple mq_open (write only)" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "getattr attributes correct" ); err = mq_send( q1, "Vik is brill", sizeof("Vik is brill"), 10 ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_send" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr after send" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #2" ); q2 = mq_open( "/mq1", O_RDONLY|O_CREAT|O_EXCL ); CYG_TEST_PASS_FAIL( q2 == (mqd_t)-1, "error for exclusive open of existing queue" ); CYG_TEST_PASS_FAIL( EEXIST == errno, "errno correct for exclusive open of existing queue" ); q2 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q2 != (mqd_t)-1, "simple mq_open (read only)" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr, different mqd_t" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK != (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #3" ); err = mq_close( q2 ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_close" ); q2 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q2 != (mqd_t)-1, "mq_open reopen (read only)" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr, different mqd_t" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK != (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (1 == attr.mq_curmsgs ), "getattr attributes correct #4" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("Vik is brill"), "receive message length" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "Vik is brill", sizeof("Vik is brill")), "received message data intact" ); CYG_TEST_PASS_FAIL( 10 == prio, "received at correct priority" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr after send" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY != (attr.mq_flags & O_RDONLY)) && (O_WRONLY == (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "getattr attributes correct #5" ); attr.mq_flags |= O_NONBLOCK; err = mq_setattr( q2, &attr, &oattr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_setattr O_NONBLOCK" ); CYG_TEST_PASS_FAIL( (4 == oattr.mq_maxmsg) && (20 == oattr.mq_msgsize) && (O_NONBLOCK != (oattr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (oattr.mq_flags & O_RDONLY)) && (O_WRONLY != (oattr.mq_flags & O_WRONLY)) && (O_RDWR != (oattr.mq_flags & O_RDWR)) && (0 == oattr.mq_curmsgs ), "old attribute correct" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_getattr after O_NONBLOCK" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "new attribute correct" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, empty buffer, non-blocking" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for non-blocking" ); err = mq_send( q2, "foo", sizeof("foo"), 1 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send on read-only descriptor" ); CYG_TEST_PASS_FAIL( EBADF == errno, "errno correct for mq_send on r/o descriptor" ); err = mq_send( q2, "supercalifragilisticexpealidocious", 21, 2 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send (message too long)" ); CYG_TEST_PASS_FAIL( EMSGSIZE == errno, "errno correct for mq_send (message too long)" ); err = mq_send( q1, "", sizeof(""), 5 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send \"\"" ); err = mq_send( q1, "I love Vik", sizeof("I love Vik"), 7 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (different priority)" ); err = mq_send( q1, "a lot!", sizeof("a lot!"), 7 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (same priority)" ); err = mq_send( q1, "Vik is a babe", sizeof("Vik is a babe"), 6 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (middle priority)" ); err = mq_send( q1, "wibble", sizeof("wibble"), 6 ); CYG_TEST_PASS_FAIL( -1 == err, "error on mq_send with full queue" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for mq_send full queue" ); err = mq_getattr( q2, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "mq_getattr after sends" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDONLY == (attr.mq_flags & O_RDONLY)) && (O_WRONLY != (attr.mq_flags & O_WRONLY)) && (O_RDWR != (attr.mq_flags & O_RDWR)) && (4 == attr.mq_curmsgs ), "getattr attributes correct #5" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("I love Vik"), "receive message length (prioritized) #1" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "I love Vik", sizeof("I love Vik")), "received message data intact (prioritized) #1" ); CYG_TEST_PASS_FAIL( 7 == prio, "received at correct priority (prioritized) #1" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("a lot!"), "receive message length (prioritized) #2" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "a lot!", sizeof("a lot!")), "received message data intact (prioritized) #2" ); CYG_TEST_PASS_FAIL( 7 == prio, "received at correct priority (prioritized) #2" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof("Vik is a babe"), "receive message length (prioritized) #3" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "Vik is a babe", sizeof("Vik is a babe")), "received message data intact (prioritized) #3" ); CYG_TEST_PASS_FAIL( 6 == prio, "received at correct priority (prioritized) #3" ); recvlen = mq_receive( q2, buf, 0, &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, zero-sized buffer" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == sizeof(""), "receive message length (prioritized) #4" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "", sizeof("")), "received message data intact (prioritized) #4" ); CYG_TEST_PASS_FAIL( 5 == prio, "received at correct priority (prioritzed) #4" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == (ssize_t)-1, "mq_receive, empty buffer, non-blocking #2" ); CYG_TEST_PASS_FAIL( EAGAIN == errno, "errno correct for non-blocking #2" ); err = mq_send( q1, "12345678901234567890", 20, 15 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send (before closing)" ); err = mq_unlink( "/foo" ); CYG_TEST_PASS_FAIL( -1 == err, "mq_unlink (wrong name)" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for mq_unlink (wrong name)" ); err = mq_unlink( "/mq1" ); CYG_TEST_PASS_FAIL( 0 == err, "mq_unlink (before closing)" ); err = mq_close( q1 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_close (send descriptor)" ); recvlen = mq_receive( q2, buf, sizeof(buf), &prio ); CYG_TEST_PASS_FAIL( recvlen == 20, "receive message length (mid close)" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, "12345678901234567890", 20 ), "received message data intact (mid close)" ); CYG_TEST_PASS_FAIL( 15 == prio, "received at correct priority (mid close)" ); err = mq_close( q2 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_close (receive descriptor)" ); q1 = mq_open( "/mq1", O_RDONLY ); CYG_TEST_PASS_FAIL( q1 == (mqd_t)-1, "error for non-existent queue" ); CYG_TEST_PASS_FAIL( ENOENT == errno, "errno correct for non-existent queue" ); CYG_TEST_EXIT("POSIX message test 1"); return 0; } // main()
int main(void) { mqd_t q1; struct mq_attr attr; mode_t mode; int err; ssize_t recvlen; char mybuf[20]; unsigned int myprio; struct sigevent ev; struct sigaction act; CYG_TEST_INIT(); CYG_TEST_INFO( "Starting POSIX message test 2" ); #if 0 if ( 0 != pthread_create( &thr, NULL, &thread, NULL ) ) { CYG_TEST_FAIL_FINISH( "Couldn't create a helper thread" ); } #endif attr.mq_flags = 0; attr.mq_maxmsg = 4; attr.mq_msgsize = 20; mode = S_IRWXU|S_IRWXG|S_IRWXO; // rwx for all q1 = mq_open( "/mq1", O_CREAT|O_NONBLOCK|O_RDWR, mode, &attr ); CYG_TEST_PASS_FAIL( q1 != (mqd_t)-1, "simple mq_open (write only)" ); err = mq_getattr( q1, &attr ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_getattr" ); CYG_TEST_PASS_FAIL( (4 == attr.mq_maxmsg) && (20 == attr.mq_msgsize) && (O_NONBLOCK == (attr.mq_flags & O_NONBLOCK)) && (O_RDWR == (attr.mq_flags & O_RDWR)) && (0 == attr.mq_curmsgs ), "getattr attributes correct" ); act.sa_sigaction = &sigusr1_handler; sigfillset( &act.sa_mask ); // enable all signals act.sa_flags = SA_SIGINFO; if ( 0 != sigaction( SIGUSR1, &act, NULL ) ) { CYG_TEST_FAIL_FINISH( "Couldn't register signal handler" ); } ev.sigev_notify = SIGEV_SIGNAL; ev.sigev_signo = SIGUSR1; ev.sigev_value.sival_ptr = (void *)&q1; err = mq_notify( q1, &ev ); CYG_TEST_PASS_FAIL( 0 == err, "simple mq_notify" ); my_strcpy( buf, "Vik is the best" ); prio = 7; err = mq_send( q1, buf, my_strlen(buf), prio ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send #1" ); CYG_TEST_PASS_FAIL( 1 == signals, "got notification" ); my_strcpy( buf, "Scrummy Vik" ); prio = 6; err = mq_send( q1, buf, my_strlen(buf), prio ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send #2" ); CYG_TEST_PASS_FAIL( 1 == signals, "correctly didn't get notification" ); recvlen = mq_receive( q1, mybuf, sizeof(mybuf), &myprio ); CYG_TEST_PASS_FAIL( recvlen == my_strlen(buf), "receive message length" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, mybuf, my_strlen(buf)), "received message data intact" ); CYG_TEST_PASS_FAIL( prio == myprio, "received at correct priority" ); err = mq_notify( q1, &ev ); CYG_TEST_PASS_FAIL( 0 == err, "mq_notify #2" ); err = mq_notify( q1, &ev ); CYG_TEST_PASS_FAIL( -1 == err, "second mq_notify returns error" ); CYG_TEST_PASS_FAIL( EBUSY == errno, "errno correct for second mq_notify error" ); err = mq_notify( q1, NULL ); CYG_TEST_PASS_FAIL( 0 == err, "clear notification" ); my_strcpy( buf, "Vik is k3wl" ); prio = 8; err = mq_send( q1, buf, my_strlen(buf), prio ); CYG_TEST_PASS_FAIL( 0 == err, "mq_send #2" ); CYG_TEST_PASS_FAIL( 1 == signals, "correctly didn't get notification #2" ); recvlen = mq_receive( q1, mybuf, sizeof(mybuf), &myprio ); CYG_TEST_PASS_FAIL( recvlen == my_strlen(buf), "receive message length" ); CYG_TEST_PASS_FAIL( 0 == my_memcmp( buf, mybuf, my_strlen(buf)), "received message data intact" ); CYG_TEST_PASS_FAIL( prio == myprio, "received at correct priority" ); err = mq_close( q1 ); CYG_TEST_PASS_FAIL( 0 == err, "mq_close" ); err = mq_unlink( "/mq1" ); CYG_TEST_PASS_FAIL( 0 == err, "mq_unlink" ); CYG_TEST_EXIT("POSIX message test 2"); return 0; } // main()
void task1( unsigned int arg ) { ER ercd; int tests = 0; CYG_TEST_INFO( "Task 1 running" ); ercd = dis_dsp(); CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); ercd = sta_tsk( 2, 22222 ); CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); ercd = chg_pri( 2, 5 ); CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); ercd = ena_dsp(); CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); ercd = dly_tsk( 10 ); CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); #ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE tests++; #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = del_sem( -6 ); CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); ercd = del_sem( 99 ); CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" ); ercd = cre_sem( -6, &t_csem ); CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); ercd = cre_sem( 99, &t_csem ); CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" ); #endif // we can test bad param error returns // try a pre-existing object ercd = cre_sem( 3, &t_csem ); CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" ); // delete it so we can play ercd = del_sem( 3 ); CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" ); // check it is deleted ercd = sig_sem( 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); ercd = preq_sem( 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" ); ercd = twai_sem( 3, 10 ); CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" ); ercd = wai_sem( 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" ); ercd = ref_sem( &t_rsem, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem 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_sem( 3, NULL ); CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" ); #endif ercd = cre_sem( 3, NADR ); CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" ); t_csem.sematr = 0xfff; ercd = cre_sem( 3, &t_csem ); CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" ); t_csem.sematr = 0; #endif // we can test bad param error returns ercd = cre_sem( 3, &t_csem ); CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); // and check we can use it ercd = sig_sem( 3 ); CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); ercd = wai_sem( 3 ); CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); ercd = preq_sem( 3 ); CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); ercd = twai_sem( 3, 2 ); CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); ercd = ref_sem( &t_rsem, 3 ); CYG_TEST_CHECK( E_OK == ercd, "ref_sem 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 = wai_sem( 1 ); CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = twai_sem( 2, 20 ); CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); // check they are deleted ercd = sig_sem( 1 ); CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); ercd = sig_sem( 2 ); CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); // re-create and do it again ercd = cre_sem( 1, &t_csem ); CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" ); ercd = cre_sem( 2, &t_csem ); CYG_TEST_CHECK( E_OK == ercd, "cre_sem 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 = wai_sem( 1 ); CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = twai_sem( 2, 20 ); CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" ); // check they are deleted ercd = sig_sem( 1 ); CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); ercd = sig_sem( 2 ); CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" ); CYG_TEST_PASS("create/delete semaphores"); #endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE #ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE tests++; #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = del_flg( -6 ); CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); ercd = del_flg( 99 ); CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" ); ercd = cre_flg( -6, &t_cflg ); CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); ercd = cre_flg( 99, &t_cflg ); CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" ); #endif // we can test bad param error returns // try a pre-existing object ercd = cre_flg( 3, &t_cflg ); CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" ); // delete it so we can play ercd = del_flg( 3 ); CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); // check it is deleted ercd = set_flg( 3, 0x6789 ); CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); ercd = clr_flg( 3, 0x9876 ); CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW ); CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" ); ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 ); CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" ); ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR ); CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" ); ercd = ref_flg( &t_rflg, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg 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_flg( 3, NULL ); CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" ); #endif ercd = cre_flg( 3, NADR ); CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" ); t_cflg.flgatr = 0xfff; ercd = cre_flg( 3, &t_cflg ); CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" ); #endif // we can test bad param error returns // now create it well t_cflg.flgatr = 0; t_cflg.iflgptn = 0; ercd = cre_flg( 3, &t_cflg ); CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); // and check we can use it ercd = clr_flg( 3, 0x7256 ); CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); ercd = set_flg( 3, 0xff ); CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" ); ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR ); CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 ); CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); ercd = ref_flg( &t_rflg, 3 ); CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" ); // now create it again with a preset pattern and check that we can // detect that pattern: ercd = del_flg( 3 ); CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" ); t_cflg.flgatr = 0; t_cflg.iflgptn = 0x1234; ercd = cre_flg( 3, &t_cflg ); CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); // and check we can use it ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW ); CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW ); CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" ); ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 ); CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" ); ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW ); CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); ercd = ref_flg( &t_rflg, 3 ); CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" ); ercd = clr_flg( 3, 0 ); ercd = ref_flg( &t_rflg, 3 ); CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg 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 = wai_flg( &scratch, 1, 0xaa, TWF_ANDW ); CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 ); CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); // check they are deleted ercd = set_flg( 1, 0x22 ); CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); ercd = clr_flg( 2, 0xdd ); CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); // re-create and do it again t_cflg.iflgptn = 0x5555; ercd = cre_flg( 1, &t_cflg ); CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" ); t_cflg.iflgptn = 0; ercd = cre_flg( 2, &t_cflg ); CYG_TEST_CHECK( E_OK == ercd, "cre_flg 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 = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR ); CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 ); CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" ); // check they are deleted ercd = clr_flg( 1, 0xd00d ); CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" ); ercd = set_flg( 2, 0xfff00 ); CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" ); CYG_TEST_PASS("create/delete flags"); #endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE #ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE tests++; #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = del_mbx( -6 ); CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); ercd = del_mbx( 99 ); CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" ); ercd = cre_mbx( -6, &t_cmbx ); CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" ); ercd = cre_mbx( 99, &t_cmbx ); 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(); }
void task1( unsigned int arg ) { ER ercd; int i; T_RSYS rsys; CYG_TEST_INFO( "Task 1 running" ); // check initial state ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); // disable intrs and check state ercd = loc_cpu(); CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS // try an illegal op ercd = dly_tsk( 10 ); CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); #endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS // enable intrs and check state and a legal sleep ercd = unl_cpu(); CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); ercd = dly_tsk( 1 ); CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); // disable intrs and try scheduler illegal ops ercd = loc_cpu(); CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = dis_dsp(); CYG_TEST_CHECK( E_CTX == ercd, "dis_dsp bad ercd !E_CTX" ); ercd = ena_dsp(); CYG_TEST_CHECK( E_CTX == ercd, "ena_dsp bad ercd !E_CTX" ); #endif // CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS // enable again and check state ercd = unl_cpu(); CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); // disable the scheduler and check state ercd = dis_dsp(); CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_DDSP == rsys.sysstat, "system state not TSS_DDSP" ); // disable intrs and check state ercd = loc_cpu(); CYG_TEST_CHECK( E_OK == ercd, "loc_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_LOC == rsys.sysstat, "system state not TSS_LOC" ); // then unlock and check state ercd = unl_cpu(); CYG_TEST_CHECK( E_OK == ercd, "unl_cpu bad ercd" ); ercd = ref_sys( &rsys ); CYG_TEST_CHECK( E_OK == ercd, "ref_sys bad ercd" ); CYG_TEST_CHECK( TSS_TSK == rsys.sysstat, "system state not TSS_TSK" ); CYG_TEST_PASS( "Interrupt dis/enabling and interactions" ); // and now we can do the rest of the test #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = rel_wai( 2 ); CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); ercd = rel_wai( 1 ); CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); ercd = rel_wai( -6 ); CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); ercd = rel_wai( 99 ); CYG_TEST_CHECK( E_ID == ercd, "rel_wai bad ercd !E_ID" ); #endif // we can test bad param error returns ercd = dis_dsp(); CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); ercd = sta_tsk( 2, 22222 ); CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); ercd = chg_pri( 2, 5 ); CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); ercd = ena_dsp(); CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = rel_wai( 2 ); CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai bad ercd !E_OBJ" ); ercd = rel_wai( 1 ); CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai(me) bad ercd !E_OBJ" ); #endif // we can test bad param error returns ercd = wai_sem( 1 ); CYG_TEST_CHECK( E_RLWAI == ercd, "wai_sem bad ercd !E_RLWAI" ); ercd = twai_sem( 1, 20 ); CYG_TEST_CHECK( E_RLWAI == ercd, "twai_sem bad ercd !E_RLWAI" ); ercd = wai_flg( &scratch, 1, 9999, 0 ); CYG_TEST_CHECK( E_RLWAI == ercd, "wai_flg bad ercd !E_RLWAI" ); ercd = twai_flg( &scratch, 1, 9999, 0, 10 ); CYG_TEST_CHECK( E_RLWAI == ercd, "twai_flg bad ercd !E_RLWAI" ); ercd = rcv_msg( &t_msg, 1 ); CYG_TEST_CHECK( E_RLWAI == ercd, "rcv_msg bad ercd !E_RLWAI" ); ercd = trcv_msg( &t_msg, 1, 10 ); CYG_TEST_CHECK( E_RLWAI == ercd, "trcv_msg bad ercd !E_RLWAI" ); // these are loops so as to consume the whole of the mempool // in order to wait at the end for ( i = 0; i < 10; i++ ) if ( E_OK != (ercd = get_blf( &vp, 3 ) ) ) break; CYG_TEST_CHECK( E_RLWAI == ercd, "get_blf bad ercd !E_RLWAI" ); for ( i = 0; i < 10; i++ ) if ( E_OK != (ercd = tget_blf( &vp, 3, 10 ) ) ) break; CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blf bad ercd !E_RLWAI" ); for ( i = 0; i < 10; i++ ) if ( E_OK != (ercd = get_blk( &vp, 1, 1000 ) ) ) break; CYG_TEST_CHECK( E_RLWAI == ercd, "get_blk bad ercd !E_RLWAI" ); for ( i = 0; i < 10; i++ ) if ( E_OK != (ercd = tget_blk( &vp, 1, 1000, 10 ) ) ) break; CYG_TEST_CHECK( E_RLWAI == ercd, "tget_blk bad ercd !E_RLWAI" ); ercd = dly_tsk( 10 ); CYG_TEST_CHECK( E_RLWAI == ercd, "dly_tsk bad ercd !E_RLWAI" ); ercd = tslp_tsk( 10 ); CYG_TEST_CHECK( E_RLWAI == ercd, "tslp_tsk bad ercd !E_RLWAI" ); ercd = slp_tsk(); CYG_TEST_CHECK( E_RLWAI == ercd, "slp_tsk bad ercd !E_RLWAI" ); ercd = ter_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" ); ercd = dly_tsk( 10 ); CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); CYG_TEST_PASS("release wait: various waiting calls"); // all done CYG_TEST_EXIT( "All done" ); ext_tsk(); }
void net_test(cyg_addrword_t q) { char oldbuff[128]; size_t oldbuffsize; char pbuff[128], name[64], *p; int *new_oid; size_t num_elem; int ret, i, oid_kind; diag_printf("Start sysctl1 test\n"); // init_all_network_interfaces(); /* Test the OID to name function of sysctl*/ oldbuffsize = sizeof(oldbuff); ret = sysctl(mib_name_debug_name, CYG_NELEM(mib_name_debug_name), oldbuff, &oldbuffsize, NULL, 0); if (ret == -1) CYG_TEST_FAIL("sysclt(mib_name) failed"); CYG_TEST_INFO(oldbuff); CYG_TEST_PASS_FAIL(!strcmp(oldbuff, "sysctl.name"), "sysctl.name"); /* Test the name to OID function of sysclt */ oldbuffsize = sizeof(oldbuff); ret = sysctl(mib_name2oid, CYG_NELEM(mib_name2oid), oldbuff, &oldbuffsize, name2oid, sizeof(name2oid)); if (ret == -1) CYG_TEST_FAIL("sysclt(mib_name) failed"); CYG_TEST_PASS_FAIL(((ret == 8 ) && (((int *)&oldbuff)[0] == CTL_DEBUG) && (((int *)&oldbuff)[1] == 3)), "sysctl.name2oid"); /* Walk the table using the next function of sysclt */ num_elem = CYG_NELEM(mib_next)+1; new_oid = mib + CYG_NELEM(mib_next); mib[2] = 0; do { memcpy(mib,mib_next,sizeof(mib_next)); oldbuffsize = sizeof(mib) - sizeof(mib_next); ret = sysctl(mib, num_elem, new_oid, &oldbuffsize, NULL, 0); if (ret == -1) { if (errno != ENOENT) { CYG_TEST_FAIL_FINISH("sysclt(mib_name) failed"); } else { break; } } p = pbuff; num_elem = CYG_NELEM(mib_next) + (ret / 4); i=0; while (ret > 0) { p+=diag_sprintf(p, "%d ",new_oid[i++]); ret -= sizeof(int); } /* Get the name of this oid */ oldbuffsize = sizeof(name); memcpy(mib,mib_name,sizeof(mib_name)); ret = sysctl(mib, num_elem, name, &oldbuffsize, NULL, 0); if (ret == -1) CYG_TEST_FAIL("sysclt(mib2name) failed"); name[ret] = 0; p += diag_sprintf(p, "= %s (", name); /* Get the find and format */ memcpy(mib,mib_oidfmt,sizeof(mib_oidfmt)); ret = sysctl(mib, num_elem, name, &oldbuffsize, NULL, 0); if (ret == -1) CYG_TEST_FAIL("sysclt(mib2name) failed"); oid_kind = *(int *)name; switch (oid_kind & CTLTYPE) { case CTLTYPE_NODE: p += diag_sprintf(p, "NODE"); break; case CTLTYPE_INT: p += diag_sprintf(p, "INT"); break; case CTLTYPE_STRING: p += diag_sprintf(p, "STRING"); break; case CTLTYPE_QUAD: p += diag_sprintf(p, "QUAD"); break; case CTLTYPE_STRUCT: p += diag_sprintf(p, "STRUCT"); break; case CTLTYPE_UINT: p += diag_sprintf(p, "UINT"); break; case CTLTYPE_LONG: p += diag_sprintf(p, "LONG"); break; case CTLTYPE_ULONG: p += diag_sprintf(p, "ULONG"); break; default: p += diag_sprintf(p,"Unknown type! (%d)", oid_kind & CTLTYPE); } if (oid_kind & CTLFLAG_RD) p += diag_sprintf(p," Read"); if (oid_kind & CTLFLAG_WR) p += diag_sprintf(p," Write"); if (oid_kind & CTLFLAG_NOLOCK) p += diag_sprintf(p," Nolock"); if (oid_kind & CTLFLAG_ANYBODY) p += diag_sprintf(p," Anybody"); if (oid_kind & CTLFLAG_SECURE) p += diag_sprintf(p," Secure"); if (oid_kind & CTLFLAG_PRISON) p += diag_sprintf(p," Prison"); if (oid_kind & CTLFLAG_DYN) p += diag_sprintf(p," Dynamic"); p += diag_sprintf(p," )"); p += diag_sprintf(p,"{%d}", num_elem); CYG_TEST_INFO(pbuff); } while (ret != -1); /* Tests for sysctlnametomib */ num_elem = CYG_NELEM(mib); ret = sysctlnametomib(name2oid, mib,&num_elem); if (ret == -1) CYG_TEST_FAIL("sysctlnametomib failed"); CYG_TEST_PASS_FAIL(((num_elem == 2 ) && (((int *)&oldbuff)[0] == CTL_DEBUG) && (((int *)&oldbuff)[1] == 3)), "sysctlnametooid1"); /* This time with too small a results buffer */ num_elem = 1; ret = sysctlnametomib(name2oid, mib,&num_elem); CYG_TEST_PASS_FAIL((ret == -1) && (errno = ENOMEM), "sysctlnametooid2"); /* This time with an unknown name */ num_elem = CYG_NELEM(mib); ret = sysctlnametomib("unknown.unknown", mib,&num_elem); CYG_TEST_PASS_FAIL((ret == -1) && (errno = ENOENT), "sysctlnametooid3"); /* Tests for sysctlbyname */ oldbuffsize = sizeof(oldbuff); ret = sysctlbyname("sysctl.name2oid", oldbuff, &oldbuffsize, name2oid, sizeof(name2oid)); if (ret == -1) CYG_TEST_FAIL("sysclt(mib_name) failed"); CYG_TEST_PASS_FAIL(((ret == 8 ) && (((int *)&oldbuff)[0] == CTL_DEBUG) && (((int *)&oldbuff)[1] == 3)), "sysctlbyname"); CYG_TEST_EXIT ("sysctl1 exit"); }
void task1( unsigned int arg ) { ER ercd; int tests = 0; CYG_TEST_INFO( "Task 1 running" ); ercd = dis_dsp(); CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); ercd = sta_tsk( 2, 22222 ); CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); ercd = chg_pri( 2, 5 ); CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); ercd = ena_dsp(); CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); ercd = dly_tsk( 10 ); CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE tests++; #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = del_mpf( -6 ); CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); ercd = del_mpf( 99 ); CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" ); ercd = cre_mpf( -6, &t_cmpf ); CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); ercd = cre_mpf( 99, &t_cmpf ); CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" ); #endif // we can test bad param error returns // try a pre-existing object // [first get a valid block from it for the freeing test later] ercd = pget_blf( &vp, 3 ); CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); ercd = cre_mpf( 3, &t_cmpf ); CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpf bad ercd !E_OBJ" ); // delete it so we can play ercd = del_mpf( 3 ); CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" ); // check it is deleted ercd = rel_blf( 3, vp ); // vp did come from this pool CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blf bad ercd !E_NOEXS" ); ercd = pget_blf( &vp, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); ercd = tget_blf( &vp, 3, 10 ); CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blf bad ercd !E_NOEXS" ); ercd = get_blf( &vp, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); ercd = ref_mpf( &t_rmpf, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpf 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_mpf( 3, NULL ); CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" ); #endif ercd = cre_mpf( 3, NADR ); CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" ); t_cmpf.mpfatr = 0xfff; ercd = cre_mpf( 3, &t_cmpf ); CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpf bad ercd !E_RSATR" ); #endif // we can test bad param error returns t_cmpf.mpfatr = 0; t_cmpf.mpfcnt = 10000; t_cmpf.blfsz = 100; ercd = cre_mpf( 3, &t_cmpf ); CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); t_cmpf.mpfcnt = 100; t_cmpf.blfsz = 100000; ercd = cre_mpf( 3, &t_cmpf ); CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" ); // now create it well t_cmpf.mpfatr = 0; t_cmpf.mpfcnt = 10; t_cmpf.blfsz = 100; ercd = cre_mpf( 3, &t_cmpf ); CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); // and check we can use it ercd = pget_blf( &vp, 3 ); CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); ercd = tget_blf( &vp, 3, 10 ); CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); ercd = get_blf( &vp, 3 ); CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); ercd = rel_blf( 3, vp ); // vp did come from new pool CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); ercd = rel_blf( 3, vp ); // vp already freed CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); ercd = ref_mpf( &t_rmpf, 3 ); CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); // In order to wait on the pools, we must first consume all they have: while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf 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_blf( &vp, 1 ); CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = tget_blf( &vp, 2, 20 ); CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); // check they are deleted ercd = get_blf( &vp, 1 ); CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); ercd = pget_blf( &vp, 2 ); CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); // re-create and do it again t_cmpf.mpfcnt = 90; t_cmpf.blfsz = 20; ercd = cre_mpf( 1, &t_cmpf ); CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); t_cmpf.mpfcnt = 5; t_cmpf.blfsz = 200; ercd = cre_mpf( 2, &t_cmpf ); CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" ); // In order to wait on the pools, we must first consume all they have: while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */; CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */; CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf 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_blf( &vp, 1 ); CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" ); ercd = wup_tsk( 2 ); CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); ercd = tget_blf( &vp, 2, 10 ); CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" ); // check they are deleted ercd = tget_blf( &vp, 1, 1 ); CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" ); ercd = get_blf( &vp, 2 ); CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" ); CYG_TEST_PASS("create/delete fixed mempools"); #endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE tests++; #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS ercd = del_mpl( -6 ); CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); ercd = del_mpl( 99 ); CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" ); ercd = cre_mpl( -6, &t_cmpl ); CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); ercd = cre_mpl( 99, &t_cmpl ); CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" ); #endif // we can test bad param error returns // try a pre-existing object // [first get a valid block from it for the freeing test later] ercd = pget_blk( &vp, 3, 100 ); CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); ercd = cre_mpl( 3, &t_cmpl ); CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpl bad ercd !E_OBJ" ); // delete it so we can play ercd = del_mpl( 3 ); CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" ); // check it is deleted ercd = rel_blk( 3, vp ); // vp did come from this pool CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blk bad ercd !E_NOEXS" ); ercd = pget_blk( &vp, 3, 100 ); CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" ); ercd = tget_blk( &vp, 3, 100, 10 ); CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blk bad ercd !E_NOEXS" ); ercd = get_blk( &vp, 3, 100 ); CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" ); ercd = ref_mpl( &t_rmpl, 3 ); CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpl 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_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(); }