1 // : vi ts=4 sw=4 noet :
3 ==================================================================================
4 Copyright (c) 2019 Nokia
5 Copyright (c) 2018-2019 AT&T Intellectual Property.
7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
11 http://www.apache.org/licenses/LICENSE-2.0
13 Unless required by applicable law or agreed to in writing, software
14 distributed under the License is distributed on an "AS IS" BASIS,
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 See the License for the specific language governing permissions and
17 limitations under the License.
18 ==================================================================================
22 Mmemonic: rt_static_test.c
23 Abstract: Test the route table funcitons. These are meant to be included at compile
24 time by the test driver.
26 Author: E. Scott Daniels
38 #include <semaphore.h>
41 #include "rmr_agnostic.h"
43 typedef struct entry_info {
50 Driven by symtab foreach element of one space.
51 We count using the data as a counter.
53 static void count_things( void* st, void* entry, char const* name, void* thing, void* vdata ) {
57 if( (counter = (int *) vdata) != NULL ) {
64 Returns the number of entries in the table for the given class.
66 static int count_entries( route_table_t* rt, int class ) {
76 rmr_sym_foreach_class( rt->hash, class, count_things, &counter ); // run each and update counter
82 Builds a route table key.
84 static uint64_t build_key( uint32_t mtype, uint32_t sid ) {
87 k = (uint64_t) sid << 32;
90 fprintf( stderr, "<INFO> build key: %x %x --> %llx\n", (int) mtype, (int) sid, (long long) k );
95 This is the main route table test. It sets up a very specific table
96 for testing (not via the generic setup function for other test
99 static int rt_test( ) {
100 uta_ctx_t* ctx; // context needed to test load static rt
101 route_table_t* rt; // route table
102 route_table_t* crt; // cloned route table
103 rtable_ent_t* rte; // route table entries from table
105 endpoint_t* ep; // endpoint added
107 int more = 0; // more flag from round robin
108 int errors = 0; // number errors found
111 int c1; // general counters
116 ei_t entries[50]; // end point information
117 int gcounts[7]; // number of groups in this set
118 int ecounts[7]; // number of elements per group
119 uint64_t mtypes[7]; // mtype/sid 'key' in the modern RMR world
125 char* seed_fname; // seed file
126 SOCKET_TYPE nn_sock; // differnt in each transport (nng == struct, SI/Nano == int)
127 rmr_mbuf_t* mbuf; // message for meid route testing
129 #ifndef NNG_UNDER_TEST
130 si_ctx_t* si_ctx = NULL;
133 setenv( "ENV_VERBOSE_FILE", ".ut_rmr_verbose", 1 ); // allow for verbose code in rtc to be driven
134 i = open( ".ut_rmr_verbose", O_RDWR | O_CREAT, 0644 );
136 write( i, "2\n", 2 );
142 The hacky code below calls the necessary rmr functions to create a route table
143 as though the following were read and parsed by the rmr functions. (This tests
144 the individual funcitons and avoids writing another parser, so it's not pretty.)
146 mse | 0 | 0 | yahoo.com:4561,localhost:4562
147 mse | 1 | 0 | localhost:4560,localhost:4568,localhost:4569; localhost:4561,localhost:4562
148 mse | 2 | 0 | localhost:4563,localhost:4564
149 mse | 3 | 0 | localhost:4565
150 mse | 3 | 11 | locahost:5511
151 mse | 3 | -1 | localhost:5500
153 gcounts[0] = 1; // first entry has 1 group with 2 endpoints; message type 0, sid 0
155 mtypes[0] = build_key( 0, 0 ); // mtype is now a key of mtype/sid
156 entries[enu].group = 0; entries[enu].ep_name = "yahoo.com:4561"; enu++; // use a dns resolvable name to test that
157 entries[enu].group = 0; entries[enu].ep_name = "localhost:4562"; enu++; // rest can default to some dummy ip
159 gcounts[1] = 2; // 2 groups
160 ecounts[1] = 3; // first has 3 endpoints
161 mtypes[1] = build_key( 1, 0 );
162 entries[enu].group = 0; entries[enu].ep_name = "localhost:4560"; enu++;
163 entries[enu].group = 0; entries[enu].ep_name = "localhost:4568"; enu++;
164 entries[enu].group = 0; entries[enu].ep_name = "localhost:4569"; enu++;
166 gcounts[2] = 0; // 0 means use same rte, this is the next group for the entry
167 ecounts[2] = 2; // 2 endpoints
168 mtypes[2] = 999; // ignored when appending to previous entry
169 entries[enu].group = 1; entries[enu].ep_name = "localhost:4561"; enu++;
170 entries[enu].group = 1; entries[enu].ep_name = "localhost:4562"; enu++;
172 gcounts[3] = 1; // next entry has 1 group
173 ecounts[3] = 2; // with 2 enpoints
174 mtypes[3] = build_key( 2, 0 );
175 entries[enu].group = 0; entries[enu].ep_name = "localhost:4563"; enu++;
176 entries[enu].group = 0; entries[enu].ep_name = "localhost:4564"; enu++;
178 gcounts[4] = 1; // three entries for mt==3 with different sids
180 mtypes[4] = build_key( 3, 0 );
181 entries[enu].group = 0; entries[enu].ep_name = "localhost:5500"; enu++;
185 mtypes[5] = build_key( 3, 11 );
186 entries[enu].group = 0; entries[enu].ep_name = "localhost:5511"; enu++;
190 mtypes[6] = build_key( 3, -1 );
191 entries[enu].group = 0; entries[enu].ep_name = "localhost:5512"; enu++;
194 rt = uta_rt_init( ); // get us a route table
195 if( (errors += fail_if_nil( rt, "pointer to route table" )) ) {
196 fprintf( stderr, "<FAIL> abort: cannot continue without a route table\n" );
202 for( i = 0; i < sizeof( gcounts )/sizeof( int ); i++ ) { // add entries defined above
204 rte = uta_add_rte( rt, mtypes[i], gcounts[i] ); // get/create entry for message type
205 if( (errors += fail_if_nil( rte, "route table entry" )) ) {
206 fprintf( stderr, "<FAIL> abort: cannot continue without a route table entry\n" );
211 fprintf( stderr, "<SNAFU> internal testing error -- rte was nil for gcount == 0\n" );
216 for( k = 0; k < ecounts[i]; k++ ) {
217 ep = uta_add_ep( rt, rte, entries[enu].ep_name, entries[enu].group );
218 errors += fail_if_nil( ep, "endpoint" );
223 // ----- end hacking together a route table ---------------------------------------------------
226 crt = uta_rt_clone( rt ); // clone only the endpoint entries
227 errors += fail_if_nil( crt, "cloned route table" );
229 c1 = count_entries( rt, 1 );
230 c2 = count_entries( crt, 1 );
231 errors += fail_not_equal( c1, c2, "cloned (endpoints) table entries space 1 count (b) did not match original table count (a)" );
233 c2 = count_entries( crt, 0 );
234 errors += fail_not_equal( c2, 0, "cloned (endpoints) table entries space 0 count (a) was not zero as expected" );
239 crt = uta_rt_clone_all( rt ); // clone all entries
240 errors += fail_if_nil( crt, "cloned all route table" );
243 c1 = count_entries( rt, 0 );
244 c2 = count_entries( crt, 0 );
245 errors += fail_not_equal( c1, c2, "cloned (all) table entries space 0 count (b) did not match original table count (a)" );
247 c1 = count_entries( rt, 1 );
248 c2 = count_entries( crt, 1 );
249 errors += fail_not_equal( c1, c2, "cloned (all) table entries space 1 count (b) did not match original table count (a)" );
253 #ifdef NNG_UNDER_TEST
254 if( (ctx = (uta_ctx_t *) malloc( sizeof( uta_ctx_t ) )) != NULL ) { // get a "context" needed for si testing
255 memset( ctx, 0, sizeof( *ctx ) );
258 fprintf( stderr, "<FAIL> cannot acllocate a context, cannot continue rtable tests\n" );
262 ctx = mk_dummy_ctx();
267 ep = uta_get_ep( rt, "localhost:4561" );
268 errors += fail_if_nil( ep, "end point (fetch by name)" );
269 ep = uta_get_ep( rt, "bad_name:4560" );
270 errors += fail_not_nil( ep, "end point (fetch by name with bad name)" );
273 #ifdef NNG_UNDER_TEST
274 state = uta_epsock_byname( rt, "localhost:4561", &nn_sock, &ep ); // this should be found
276 state = uta_epsock_byname( ctx, "localhost:4561", &nn_sock, &ep ); // this should be found
278 errors += fail_if_equal( state, 0, "socket (by name)" );
279 errors += fail_if_nil( ep, "epsock_byname did not populate endpoint pointer when expected to" );
280 //alt_value = uta_epsock_byname( rt, "localhost:4562" ); // we might do a memcmp on the two structs, but for now nothing
281 //errors += fail_if_equal( value, alt_value, "app1/app2 sockets" );
284 state = uta_epsock_byname( NULL, "localhost:4561", &nn_sock, &ep ); // test coverage on nil checks
286 state = uta_epsock_byname( NULL, "localhost:4561", &nn_sock, &ep );
288 errors += fail_not_equal( state, 0, "socket (by name) nil check returned true" );
292 state = uta_epsock_byname( rt, "localhost:4561", &nn_sock, NULL ); // test coverage on nil checks
294 state = uta_epsock_byname( ctx, "localhost:4561", &nn_sock, NULL );
296 errors += fail_if_equal( state, 0, "socket (by name) open ep check returned false" );
299 // --- test that the get_rte function finds expected keys, and retries to find 'bad' sid attempts for valid mtypes with no sid
300 rte = uta_get_rte( rt, 0, 1, TRUE ); // s=0 m=1 is defined, so this should return a pointer
301 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=1 true given" );
303 rte = uta_get_rte( rt, 0, 1, FALSE ); // the retry shouldn't apply, but ensure it does the righ thing
304 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=1 false given" );
306 rte = uta_get_rte( rt, 1000, 1, FALSE ); // s=1000 does not exist for any msg type; should return nil as not allowed to drop sid
307 errors += fail_not_nil( rte, "get_rte returned a pointer when s=1000 m=1 false given" );
309 rte = uta_get_rte( rt, 1000, 1, TRUE ); // this should also fail as there is no mt==1 sid==-1 defined
310 errors += fail_not_nil( rte, "get_rte returned a pointer when s=1000 m=1 true given" );
312 rte = uta_get_rte( rt, 0, 3, TRUE ); // mtype sid combo does exist; true/false should not matter
313 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=3 true given" );
315 rte2 = uta_get_rte( rt, 11, 3, TRUE ); // same mtype as before, different (valid) group, rte should be different than before
316 errors += fail_if_nil( rte2, "get_rte did not return a pointer when s=11 m=3 true given" );
317 errors += fail_if_true( rte == rte2, "get_rte for mtype==3 and different sids (0 and 11) returned the same rte pointer" );
319 rte2 = uta_get_rte( rt, 0, 3, FALSE ); // since the mtype/sid combo exists, setting false should return the same as before
320 errors += fail_if_nil( rte2, "get_rte did not return a pointer when s=0 m=3 false given" );
321 errors += fail_if_false( rte == rte2, "get_rte did not return same pointer when mtype/sid combo given with different true/false" );
323 rte = uta_get_rte( rt, 12, 3, FALSE ); // this combo does not exist and should fail when alt-key is not allowed (false)
324 errors += fail_not_nil( rte, "get_rte returned a pointer for s=12, m=3, false" );
326 rte = uta_get_rte( rt, 12, 3, TRUE ); // this should return the entry for the 3/-1 combination
327 errors += fail_if_nil( rte, "get_rte did not return a pointer for s=12, m=3, true" );
331 rte = uta_get_rte( rt, 0, 1, FALSE ); // get an rte for the next loop
333 for( i = 0; i < 10; i++ ) { // round robin return value should be different each time
334 #ifdef NNG_UNDER_TEST
335 value = uta_epsock_rr( rte, 0, &more, &nn_sock, &ep ); // msg type 1, group 1
337 value = uta_epsock_rr( ctx, rte, 0, &more, &nn_sock, &ep );
340 errors += fail_if_equal( value, alt_value, "round robiin sockets with multiple end points" );
341 errors += fail_if_false( more, "more for mtype==1" );
347 rte = uta_get_rte( rt, 0, 3, FALSE ); // get an rte for the next loop
349 for( i = 0; i < 10; i++ ) { // this mtype has only one endpoint, so rr should be same each time
350 #ifdef NNG_UNDER_TEST
351 value = uta_epsock_rr( rte, 0, NULL, &nn_sock, &ep ); // also test ability to deal properly with nil more pointer
353 value = uta_epsock_rr( ctx, rte, 0, NULL, &nn_sock, &ep );
357 errors += fail_not_equal( value, alt_value, "round robin sockets with one endpoint" );
358 errors += fail_not_equal( more, -1, "more value changed in single group instance" );
364 rte = uta_get_rte( rt, 11, 3, TRUE );
365 #ifdef NNG_UNDER_TEST
366 state = uta_epsock_rr( rte, 22, NULL, NULL, &ep );
368 state = uta_epsock_rr( ctx, rte, 22, NULL, NULL, &ep );
370 errors += fail_if_true( state, "uta_epsock_rr returned bad (non-zero) state when given nil socket pointer" );
373 uta_rt_clone( NULL ); // verify null parms don't crash things
375 #ifdef NNG_UNDER_TEST
376 uta_epsock_rr( NULL, 0, &more, &nn_sock, &ep ); // drive null case for coverage
377 state = uta_epsock_rr( rte, 22, NULL, NULL, &ep );
379 state = uta_epsock_rr( NULL, NULL, 0, &more, &nn_sock, &ep ); // drive null case for coverage
380 errors += fail_not_equal( state, 0, "uta_epsock_rr did not return false when given nil ctx" );
382 state = uta_epsock_rr( ctx, NULL, 0, &more, &nn_sock, &ep );
383 errors += fail_not_equal( state, 0, "uta_epsock_rr did not return false when given nil rte" );
385 state = uta_epsock_rr( ctx, rte, 10000, &more, &nn_sock, &ep );
386 errors += fail_not_equal( state, 0, "uta_epsock_rr did not return false when given invalid group number" );
388 uta_add_rte( NULL, 99, 1 );
389 uta_get_rte( NULL, 0, 1000, TRUE );
391 fprintf( stderr, "[INFO] test: adding end points with nil data; warnings expected\n" );
392 uta_add_ep( NULL, NULL, "foo", 1 );
393 uta_add_ep( rt, NULL, "foo", 1 );
395 buf = uta_fib( ".gitignore" );
396 errors += fail_if_nil( buf, "buffer from read file into buffer" );
400 buf = uta_fib( "no-file" );
401 errors += fail_if_nil( buf, "buffer from read file into buffer (no file)" );
411 if( (seed_fname = getenv( "RMR_SEED_RT" )) != NULL ) {
412 read_static_rt( ctx, 0 );
414 errors += fail_if_nil( rt, "read seed table didn't generate a rtable pointer in context" );
415 unsetenv( "RMR_SEED_RT" ); // remove for next test
418 read_static_rt( ctx, 0 ); // drive for not there coverage
422 buf = uta_fib( "no-suhch-file" ); // drive some error checking for coverage
428 ep = (endpoint_t *) malloc( sizeof( *ep ) );
429 pthread_mutex_init( &ep->gate, NULL );
430 ep->name = strdup( "worm" );
432 #ifdef NNG_UNDER_TEST
433 state = uta_link2( ep );
435 state = uta_link2( ctx, ep );
437 errors += fail_if_true( state, "link2 did not return false when given a bad target name" );
439 #ifdef NNG_UNDER_TEST
440 state = uta_link2( NULL );
442 state = uta_link2( ctx, NULL );
443 errors += fail_if_true( state, "link2 did not return false when given nil ep pointer" );
445 state = uta_link2( NULL, ep );
447 errors += fail_if_true( state, "link2 did not return false when given nil pointer" );
449 ep->name = strdup( "localhost:5512" );
451 #ifdef NNG_UNDER_TEST
452 state = uta_link2( ep ); // drive for coverage
454 state = uta_link2( ctx, ep );
456 errors += fail_if_false( state, "link2 did returned false when given open ep" );
458 #ifndef NNG_UNDER_TEST
459 ep->open = 0; // context is used only if ep not open, so to check this test close the ep
460 state = rt_link2_ep( NULL, ep );
461 errors += fail_if_true( state, "rt_link2_ep returned true when given bad context" );
463 state = rt_link2_ep( ctx, NULL );
464 errors += fail_if_true( state, "rt_link2_ep returned true when given bad ep" );
467 state = rt_link2_ep( ctx, ep );
468 errors += fail_if_false( state, "rt_link2_ep returned false when given an open ep" );
471 state = rt_link2_ep( ctx, ep );
472 errors += fail_if_false( state, "rt_link2_ep returned false when given a closed ep" );
476 errors += fail_if_true( ep->open, "uta_ep_failed didn't set open flag to false" );
481 // ----------------- test the meid support for looking up an endpoint based on the meid in the message -----
484 ctx->my_name = strdup( "my_host_name" ); // set up to load a rtable
485 ctx->my_ip = strdup( "192.168.1.30" );
486 gen_rt( ctx ); // generate a route table with meid entries and hang off ctx
488 mbuf = rmr_alloc_msg( ctx, 2048 ); // buffer to play with
490 rmr_str2meid( mbuf, "meid1" ); // id that we know is in the map
492 #ifdef NNG_UNDER_TEST
493 ep = NULL; // force to nil so we see it go non-nil
494 state = epsock_meid( ctx->rtable, mbuf, &nn_sock, &ep );
495 errors += fail_if_nil( ep, "ep was nil when looking up ep with known meid in message" );
496 errors += fail_not_equal( state, 1, "state was not true when looking up ep with known meid in message" );
498 rmr_str2meid( mbuf, "XXXmeid1" ); // id that we know is NOT in the map
499 state = epsock_meid( ctx->rtable, mbuf, &nn_sock, &ep );
500 // it is NOT a valid check to test ep for nil -- epsock_mied doesn't guarentee ep is set/cleared when state is false
501 errors += fail_not_equal( state, 0, "state was not false when looking up ep with unknown meid in message" );
503 ep = NULL; // force to nil so we see it go non-nil
504 state = epsock_meid( ctx, ctx->rtable, mbuf, &nn_sock, &ep );
505 errors += fail_if_nil( ep, "ep was nil when looking up ep with known meid in message" );
506 errors += fail_not_equal( state, 1, "state was not true when looking up ep with known meid in message" );
508 state = epsock_meid( ctx, ctx->rtable, mbuf, &nn_sock, &ep ); // a second call to drive open == true check for coverage
509 errors += fail_if_nil( ep, "ep was nil when looking up ep with known meid in message; on open ep" );
510 errors += fail_not_equal( state, 1, "state was not true when looking up ep with known meid in message; on open ep" );
512 rmr_str2meid( mbuf, "XXXmeid1" ); // id that we know is NOT in the map
513 state = epsock_meid( ctx, ctx->rtable, mbuf, &nn_sock, &ep );
514 // it is NOT a valid check to test ep for nil -- epsock_mied doesn't guarentee ep is set/cleared when state is false
515 errors += fail_not_equal( state, 0, "state was not false when looking up ep with unknown meid in message" );
517 state = epsock_meid( NULL, ctx->rtable, mbuf, &nn_sock, &ep );
518 errors += fail_not_equal( state, 0, "epsock_meid returned true when given nil context" );
520 state = epsock_meid( ctx, ctx->rtable, mbuf, NULL, &ep );
521 errors += fail_not_equal( state, 0, "epsock_meid returned true when given nil socket pointer" );
525 // ------------- si only; fd to ep conversion functions ---------------------------------------------------------
526 #ifndef NNG_UNDER_TEST
527 ep2 = (endpoint_t *) malloc( sizeof( *ep ) );
530 fd2ep_add( ctx, 10, ep2 );
532 ep = fd2ep_get( ctx, 10 );
533 errors += fail_if_nil( ep, "fd2ep did not return pointer for known mapping" );
534 errors += fail_if_false( ep == ep2, "fd2ep did not return same pointer that was added" );
536 ep = fd2ep_get( ctx, 20 );
537 errors += fail_not_nil( ep, "fd2ep did returned a pointer for unknown mapping" );
539 ep = fd2ep_del( ctx, 10 );
540 errors += fail_if_nil( ep, "fd2ep delete did not return pointer for known mapping" );
541 errors += fail_if_false( ep == ep2, "fd2ep delete did not return same pointer that was added" );
543 ep = fd2ep_del( ctx, 20 );
544 errors += fail_not_nil( ep, "fd2ep delete returned a pointer for unknown mapping" );
547 return !!errors; // 1 or 0 regardless of count