X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=test%2Frmr_nng_api_static_test.c;h=2db1a202a3d178203cce84d8ae70dc9ff8054fc4;hb=907fbf43104b1670b7374bf1a4b22096977774bf;hp=e86c6f5095b96d5d994dde2de127df2799c08fe0;hpb=8790bf0c4f4f08fd05853afa67e211112b344a42;p=ric-plt%2Flib%2Frmr.git diff --git a/test/rmr_nng_api_static_test.c b/test/rmr_nng_api_static_test.c index e86c6f5..2db1a20 100644 --- a/test/rmr_nng_api_static_test.c +++ b/test/rmr_nng_api_static_test.c @@ -22,10 +22,13 @@ Mmemonic: rmr_api_static_test.c Abstract: Specific tests related to the API functions in rmr_nng.c/rmr.c. This should be included by a driver, but only the main RMr - driver and there likely not be a specific stand alone driver + driver and there will likely not be a specific stand alone driver for just this small set of tests because of the depth of the library needed to test at this level. + This can be used for both the nng and nanomsg outward facing + RMr API functions. + The message buffer specific API tests are in a different static module. API functions tested here are: rmr_close @@ -57,7 +60,6 @@ #include "../src/common/include/rmr.h" #include "../src/common/include/rmr_agnostic.h" -//#include "../src/common/src/ring_static.c" /* Send a 'burst' of messages to drive some send retry failures to increase RMr coverage @@ -94,50 +96,62 @@ static int rmr_api_test( ) { int state; v = rmr_ready( NULL ); - errors += fail_if( v != 0, "rmr_ready returned true before initialisation" ); + errors += fail_if( v != 0, "rmr_ready returned true before initialisation " ); if( (rmc = rmr_init( "4560", 1024, FL_NOTHREAD )) == NULL ) { - fail_if_nil( rmc, "rmr_init returned a nil pointer" ); + fail_if_nil( rmc, "rmr_init returned a nil pointer " ); return 1; } if( (rmc2 = rmr_init( ":6789", 1024, FL_NOTHREAD )) == NULL ) { // init without starting a thread - errors += fail_if_nil( rmc, "rmr_init returned a nil pointer for non-threaded init" ); + errors += fail_if_nil( rmc, "rmr_init returned a nil pointer for non-threaded init " ); } free_ctx( rmc2 ); // coverage if( (rmc2 = rmr_init( NULL, 1024, FL_NOTHREAD )) == NULL ) { // drive default port selector code - errors += fail_if_nil( rmc, "rmr_init returned a nil pointer when driving for default port" ); + errors += fail_if_nil( rmc, "rmr_init returned a nil pointer when driving for default port " ); } v = rmr_ready( rmc ); // unknown return; not checking at the moment msg = rmr_alloc_msg( NULL, 1024 ); // should return nil pointer - errors += fail_not_nil( msg, "rmr_alloc_msg didn't return nil when given nil context" ); + errors += fail_not_nil( msg, "rmr_alloc_msg didn't return nil when given nil context " ); msg = rmr_alloc_msg( rmc, 2048 ); // allocate larger than default size given on init - errors += fail_if_nil( msg, "rmr_alloc_msg returned nil msg pointer" ); + errors += fail_if_nil( msg, "rmr_alloc_msg returned nil msg pointer " ); v = rmr_payload_size( NULL ); - errors += fail_if( v >= 0, "rmr_payload_size returned valid size for nil message" ); - errors += fail_if( errno == 0, "rmr_payload_size did not set errno on failure" ); + errors += fail_if( v >= 0, "rmr_payload_size returned valid size for nil message " ); + errors += fail_if( errno == 0, "rmr_payload_size did not set errno on failure " ); v = rmr_payload_size( msg ); if( v >= 0 ) { - errors += fail_not_equal( v, 2048, "rmr_payload_size returned invalid size (a) instead of expected size (b)" ); - errors += fail_if( errno != 0, "rmr_payload_size did not clear errno on success" ); + errors += fail_not_equal( v, 2048, "rmr_payload_size returned invalid size (a) instead of expected size (b) " ); + errors += fail_if( errno != 0, "rmr_payload_size did not clear errno on success " ); } else { - errors += fail_if( v < 0, "rmr_payload_size returned invalid size for good message" ); + errors += fail_if( v < 0, "rmr_payload_size returned invalid size for good message " ); } +#ifdef EMULATE_NNG + // this is only supported in nng, so behavour is different depending on the underlying library being tested + v = rmr_get_rcvfd( NULL ); + errors += fail_if( v >= 0, "rmr_get_rcvfd returned a valid file descriptor when given nil context " ); + v = rmr_get_rcvfd( rmc ); + errors += fail_if( v < 0, "rmr_get_rcvfd did not return a valid file descriptor " ); +#else v = rmr_get_rcvfd( NULL ); - errors += fail_if( v >= 0, "rmr_get_rcvfd returned a valid file descriptor when given nil context" ); + errors += fail_if( v >= 0, "rmr_get_rcvfd returned a valid file descriptor when given nil context " ); v = rmr_get_rcvfd( rmc ); - errors += fail_if( v < 0, "rmr_get_rcvfd did not return a valid file descriptor" ); + errors += fail_if( v >= 0, "rmr_get_rcvfd returned a valid file descriptor (not supported in nanomsg)" ); +#endif msg2 = rmr_send_msg( NULL, NULL ); // drive for coverage - errors += fail_not_nil( msg2, "send_msg returned msg pointer when given a nil message and context" ); + errors += fail_not_nil( msg2, "send_msg returned msg pointer when given a nil message and context " ); + + msg->state = 0; + msg = rmr_send_msg( NULL, msg ); + errors += fail_if( msg->state == 0, "rmr_send_msg did not set msg state when msg given with nil context " ); // --- sends will fail with a no endpoint error until a dummy route table is set, so we test fail case first. msg->len = 100; @@ -145,10 +159,10 @@ static int rmr_api_test( ) { msg->state = 999; errno = 999; msg = rmr_send_msg( rmc, msg ); - errors += fail_if_nil( msg, "send_msg_ did not return a message on send" ); + errors += fail_if_nil( msg, "send_msg_ did not return a message on send " ); if( msg ) { - errors += fail_not_equal( msg->state, RMR_ERR_NOENDPT, "send_msg did not return no endpoints before rtable added" ); - errors += fail_if( errno == 0, "send_msg did not set errno" ); + errors += fail_not_equal( msg->state, RMR_ERR_NOENDPT, "send_msg did not return no endpoints before rtable added " ); + errors += fail_if( errno == 0, "send_msg did not set errno " ); } gen_rt( rmc ); // --- after this point there is a dummy route table so send and rts calls should be ok @@ -158,12 +172,12 @@ static int rmr_api_test( ) { msg->state = 999; errno = 999; msg = rmr_send_msg( rmc, msg ); - errors += fail_if_nil( msg, "send_msg_ did not return a message on send" ); + errors += fail_if_nil( msg, "send_msg_ did not return a message on send " ); if( msg ) { - errors += fail_not_equal( msg->state, RMR_OK, "send_msg returned bad status for send that should work" ); - errors += fail_if( errno != 0, "send_msg set errno for send that should work" ); + errors += fail_not_equal( msg->state, RMR_OK, "send_msg returned bad status for send that should work " ); + errors += fail_if( errno != 0, "send_msg set errno for send that should work " ); v = rmr_payload_size( msg ); - errors += fail_if( v != 2048, "send_msg did not allocate new buffer with correct size" ); + errors += fail_if( v != 2048, "send_msg did not allocate new buffer with correct size " ); } rmr_set_stimeout( NULL, 0 ); @@ -174,41 +188,57 @@ static int rmr_api_test( ) { rmr_set_rtimeout( rmc, -1 ); msg2 = rmr_rcv_msg( NULL, NULL ); - errors += fail_if( msg2 != NULL, "rmr_rcv_msg returned msg when given nil context and msg" ); + errors += fail_if( msg2 != NULL, "rmr_rcv_msg returned msg when given nil context and msg " ); msg2 = rmr_rcv_msg( rmc, NULL ); - errors += fail_if( msg2 == NULL, "rmr_rcv_msg returned nil msg when given nil msg" ); + errors += fail_if( msg2 == NULL, "rmr_rcv_msg returned nil msg when given nil msg " ); if( msg2 ) { - errors += fail_not_equal( msg2->state, RMR_OK, "receive given nil message did not return msg with good state" ); + if( msg2->state != RMR_ERR_EMPTY ) { + errors += fail_not_equal( msg2->state, RMR_OK, "receive given nil message did not return msg with good state (not empty) " ); + } + //errors += fail_not_equal( msg2->state, RMR_OK, "receive given nil message did not return msg with good state " ); } + msg = rmr_rcv_msg( rmc, msg ); if( msg ) { - errors += fail_if( msg->state != RMR_OK, "rmr_rcv_msg did not return an ok state" ); - errors += fail_not_equal( msg->len, 129, "rmr_rcv_msg returned message with invalid len" ); + errors += fail_not_equal( msg->state, RMR_OK, "rmr_rcv_msg did not return an ok state " ); + errors += fail_not_equal( msg->len, 220, "rmr_rcv_msg returned message with invalid len " ); } else { - errors += fail_if_nil( msg, "rmr_rcv_msg returned a nil pointer" ); + errors += fail_if_nil( msg, "rmr_rcv_msg returned a nil pointer " ); } rmr_rts_msg( NULL, NULL ); // drive for coverage rmr_rts_msg( rmc, NULL ); - errors += fail_if( errno == 0, "rmr_rts_msg did not set errno when given a nil message" ); + errors += fail_if( errno == 0, "rmr_rts_msg did not set errno when given a nil message " ); + + msg->state = 0; + msg = rmr_rts_msg( NULL, msg ); // should set state in msg + errors += fail_if_equal( msg->state, 0, "rmr_rts_msg did not set state when given valid message but no context " ); + msg = rmr_rts_msg( rmc, msg ); // return the buffer to the sender - errors += fail_if_nil( msg, "rmr_rts_msg did not return a message pointer" ); - errors += fail_if( errno != 0, "rmr_rts_msg did not reset errno" ); + errors += fail_if_nil( msg, "rmr_rts_msg did not return a message pointer " ); + errors += fail_if( errno != 0, "rmr_rts_msg did not reset errno " ); + + msg->state = 0; + msg = rmr_call( NULL, msg ); + errors += fail_if( msg->state == 0, "rmr_call did not set message state when given message with nil context " ); + snprintf( msg->xaction, 17, "%015d", 16 ); // dummy transaction id (emulation generates, this should arrive after a few calls to recv) - msg = rmr_call( rmc, msg ); // this call should return a message as we can anticipate a dummy message in - errors += fail_if_nil( msg, "rmr_call returned a nil message on call expected to succeed" ); + msg->mtype = 0; + msg->sub_id = -1; + msg = rmr_call( rmc, msg ); // dummy nng/nano function will sequentually add xactions and should match or '16' + errors += fail_if_nil( msg, "rmr_call returned a nil message on call expected to succeed " ); if( msg ) { - errors += fail_not_equal( msg->state, RMR_OK, "rmr_call did not properly set state on successful return" ); - errors += fail_if( errno != 0, "rmr_call did not properly set errno on successful return" ); + errors += fail_not_equal( msg->state, RMR_OK, "rmr_call did not properly set state on successful return " ); + errors += fail_not_equal( errno, 0, "rmr_call did not properly set errno (a) on successful return " ); } - snprintf( wbuf, 17, "%015d", 14 ); // if we call receive we should find this in the first 15 tries - for( i = 0; i < 16; i++ ) { + snprintf( wbuf, 17, "%015d", 14 ); // while waiting, the queued messages should have #14, so issue a few receives looking for it + for( i = 0; i < 16; i++ ) { // it should be in the first 15 msg = rmr_rcv_msg( rmc, msg ); if( msg ) { if( strcmp( wbuf, msg->xaction ) == 0 ) { // found the queued message @@ -216,60 +246,60 @@ static int rmr_api_test( ) { } fprintf( stderr, " msg: %s\n", msg->xaction ); } else { - errors += fail_if_nil( msg, "receive returnd nil msg while looking for queued message" ); + errors += fail_if_nil( msg, "receive returnd nil msg while looking for queued message " ); } } - errors += fail_if( i >= 16, "did not find expected message on queue" ); + errors += fail_if( i >= 16, "did not find expected message on queue " ); if( ! msg ) { msg = rmr_alloc_msg( rmc, 2048 ); // something buggered above; get a new one } - msg = rmr_call( rmc, msg ); // make a call that we never expect a response on - errors += fail_not_nil( msg, "rmr_call returned a non-nil message on call expected not to receive a response" ); - if( msg ) { - errors += fail_not_equal( msg->state, RMR_OK, "rmr_call did not properly set state on queued message receive" ); - errors += fail_if( errno != 0, "rmr_call did not properly set errno on queued message receivesuccessful" ); - } - - msg = rmr_call( rmc, msg ); // this should "timeout" because the message xaction id won't ever appear again - errors += fail_not_nil( msg, "rmr_call returned a non-nil message on call expected to fail" ); - errors += fail_if( errno == 0, "rmr_call did not set errno on failure" ); + msg->mtype = 0; + msg->sub_id = -1; + msg = rmr_call( rmc, msg ); // make a call that we never expect a response on (nil pointer back) + errors += fail_not_nil( msg, "rmr_call returned a nil message on call expected not to receive a response " ); + errors += fail_if( errno == 0, "rmr_call did not set errno on failure " ); rmr_free_msg( NULL ); // drive for coverage; nothing to check rmr_free_msg( msg2 ); + msg2 = rmr_torcv_msg( NULL, NULL, 10 ); + errors += fail_not_nil( msg2, "rmr_torcv_msg returned a pointer when given nil information " ); + msg2 = rmr_torcv_msg( rmc, NULL, 10 ); + errors += fail_if_nil( msg2, "rmr_torcv_msg did not return a message pointer when given a nil old msg " ); + // --- test timeout receive; our dummy epoll function will return 1 ready on first call and 0 ready (timeout emulation) on second // however we must drain the swamp (queue) first, so run until we get a timeout error, or 20 and report error if we get to 20. msg = NULL; for( i = 0; i < 40; i++ ) { msg = rmr_torcv_msg( rmc, msg, 10 ); - errors += fail_if_nil( msg, "torcv_msg returned nil msg when message expected" ); + errors += fail_if_nil( msg, "torcv_msg returned nil msg when message expected " ); if( msg ) { - if( msg->state == RMR_ERR_TIMEOUT ) { // queue drained and we've seen both states from poll if we get a timeout + if( msg->state == RMR_ERR_TIMEOUT || msg->state == RMR_ERR_EMPTY ) { // queue drained and we've seen both states from poll if we get a timeout break; } } } - errors += fail_if( i >= 40, "torcv_msg never returned a timeout" ); + errors += fail_if( i >= 40, "torcv_msg never returned a timeout " ); // ---- trace things that are not a part of the mbuf_api functions and thus must be tested here state = rmr_init_trace( NULL, 37 ); // coverage test nil context - errors += fail_not_equal( state, 0, "attempt to initialise trace with nil context returned non-zero state (a)" ); - errors += fail_if_equal( errno, 0, "attempt to initialise trace with nil context did not set errno as expected" ); + errors += fail_not_equal( state, 0, "attempt to initialise trace with nil context returned non-zero state (a) " ); + errors += fail_if_equal( errno, 0, "attempt to initialise trace with nil context did not set errno as expected " ); state = rmr_init_trace( rmc, 37 ); - errors += fail_if_equal( state, 0, "attempt to set trace len in context was not successful" ); - errors += fail_not_equal( errno, 0, "attempt to set trace len in context did not clear errno" ); + errors += fail_if_equal( state, 0, "attempt to set trace len in context was not successful " ); + errors += fail_not_equal( errno, 0, "attempt to set trace len in context did not clear errno " ); msg = rmr_tralloc_msg( rmc, 1024, 17, "1904308620110417" ); - errors += fail_if_nil( msg, "attempt to allocate message with trace data returned nil message" ); + errors += fail_if_nil( msg, "attempt to allocate message with trace data returned nil message " ); state = rmr_get_trace( msg, wbuf, 17 ); - errors += fail_not_equal( state, 17, "len of trace data (a) returned after msg allocation was not expected size (b)" ); + errors += fail_not_equal( state, 17, "len of trace data (a) returned after msg allocation was not expected size (b) " ); state = strcmp( wbuf, "1904308620110417" ); - errors += fail_not_equal( state, 0, "trace data returned after tralloc was not correct" ); + errors += fail_not_equal( state, 0, "trace data returned after tralloc was not correct " ); em_send_failures = 1; send_n_msgs( rmc, 30 ); // send 30 messages with emulation failures