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
106 int more = 0; // more flag from round robin
107 int errors = 0; // number errors found
110 int c1; // general counters
115 ei_t entries[50]; // end point information
116 int gcounts[7]; // number of groups in this set
117 int ecounts[7]; // number of elements per group
118 uint64_t mtypes[7]; // mtype/sid 'key' in the modern RMR world
124 char* seed_fname; // seed file
125 nng_socket nn_sock; // this is a struct in nng, so difficult to validate
127 setenv( "ENV_VERBOSE_FILE", ".ut_rmr_verbose", 1 ); // allow for verbose code in rtc to be driven
128 i = open( ".ut_rmr_verbose", O_RDWR | O_CREAT, 0644 );
130 write( i, "2\n", 2 );
136 The hacky code below calls the necessary rmr functions to create a route table
137 as though the following were read and parsed by the rmr functions. (This tests
138 the individual funcitons and avoids writing another parser, so it's not pretty.)
140 mse | 0 | 0 | yahoo.com:4561,localhost:4562
141 mse | 1 | 0 | localhost:4560,localhost:4568,localhost:4569; localhost:4561,localhost:4562
142 mse | 2 | 0 | localhost:4563,localhost:4564
143 mse | 3 | 0 | localhost:4565
144 mse | 3 | 11 | locahost:5511
145 mse | 3 | -1 | localhost:5500
147 gcounts[0] = 1; // first entry has 1 group with 2 endpoints; message type 0, sid 0
149 mtypes[0] = build_key( 0, 0 ); // mtype is now a key of mtype/sid
150 entries[enu].group = 0; entries[enu].ep_name = "yahoo.com:4561"; enu++; // use a dns resolvable name to test that
151 entries[enu].group = 0; entries[enu].ep_name = "localhost:4562"; enu++; // rest can default to some dummy ip
153 gcounts[1] = 2; // 2 groups
154 ecounts[1] = 3; // first has 3 endpoints
155 mtypes[1] = build_key( 1, 0 );
156 entries[enu].group = 0; entries[enu].ep_name = "localhost:4560"; enu++;
157 entries[enu].group = 0; entries[enu].ep_name = "localhost:4568"; enu++;
158 entries[enu].group = 0; entries[enu].ep_name = "localhost:4569"; enu++;
160 gcounts[2] = 0; // 0 means use same rte, this is the next group for the entry
161 ecounts[2] = 2; // 2 endpoints
162 mtypes[2] = 999; // ignored when appending to previous entry
163 entries[enu].group = 1; entries[enu].ep_name = "localhost:4561"; enu++;
164 entries[enu].group = 1; entries[enu].ep_name = "localhost:4562"; enu++;
166 gcounts[3] = 1; // next entry has 1 group
167 ecounts[3] = 2; // with 2 enpoints
168 mtypes[3] = build_key( 2, 0 );
169 entries[enu].group = 0; entries[enu].ep_name = "localhost:4563"; enu++;
170 entries[enu].group = 0; entries[enu].ep_name = "localhost:4564"; enu++;
172 gcounts[4] = 1; // three entries for mt==3 with different sids
174 mtypes[4] = build_key( 3, 0 );
175 entries[enu].group = 0; entries[enu].ep_name = "localhost:5500"; enu++;
179 mtypes[5] = build_key( 3, 11 );
180 entries[enu].group = 0; entries[enu].ep_name = "localhost:5511"; enu++;
184 mtypes[6] = build_key( 3, -1 );
185 entries[enu].group = 0; entries[enu].ep_name = "localhost:5512"; enu++;
188 rt = uta_rt_init( ); // get us a route table
189 if( (errors += fail_if_nil( rt, "pointer to route table" )) ) {
190 fprintf( stderr, "<FAIL> abort: cannot continue without a route table\n" );
196 for( i = 0; i < sizeof( gcounts )/sizeof( int ); i++ ) { // add entries defined above
198 rte = uta_add_rte( rt, mtypes[i], gcounts[i] ); // get/create entry for message type
199 if( (errors += fail_if_nil( rte, "route table entry" )) ) {
200 fprintf( stderr, "<FAIL> abort: cannot continue without a route table entry\n" );
205 fprintf( stderr, "<SNAFU> internal testing error -- rte was nil for gcount == 0\n" );
210 for( k = 0; k < ecounts[i]; k++ ) {
211 ep = uta_add_ep( rt, rte, entries[enu].ep_name, entries[enu].group );
212 errors += fail_if_nil( ep, "endpoint" );
217 // ----- end hacking together a route table ---------------------------------------------------
220 crt = uta_rt_clone( rt ); // clone only the endpoint entries
221 errors += fail_if_nil( crt, "cloned route table" );
223 c1 = count_entries( rt, 1 );
224 c2 = count_entries( crt, 1 );
225 errors += fail_not_equal( c1, c2, "cloned (endpoints) table entries space 1 count (b) did not match original table count (a)" );
227 c2 = count_entries( crt, 0 );
228 errors += fail_not_equal( c2, 0, "cloned (endpoints) table entries space 0 count (a) was not zero as expected" );
233 crt = uta_rt_clone_all( rt ); // clone all entries
234 errors += fail_if_nil( crt, "cloned all route table" );
237 c1 = count_entries( rt, 0 );
238 c2 = count_entries( crt, 0 );
239 errors += fail_not_equal( c1, c2, "cloned (all) table entries space 0 count (b) did not match original table count (a)" );
241 c1 = count_entries( rt, 1 );
242 c2 = count_entries( crt, 1 );
243 errors += fail_not_equal( c1, c2, "cloned (all) table entries space 1 count (b) did not match original table count (a)" );
248 ep = uta_get_ep( rt, "localhost:4561" );
249 errors += fail_if_nil( ep, "end point (fetch by name)" );
250 ep = uta_get_ep( rt, "bad_name:4560" );
251 errors += fail_not_nil( ep, "end point (fetch by name with bad name)" );
253 state = uta_epsock_byname( rt, "localhost:4561", &nn_sock ); // this should be found
254 errors += fail_if_equal( state, 0, "socket (by name)" );
255 //alt_value = uta_epsock_byname( rt, "localhost:4562" ); // we might do a memcmp on the two structs, but for now nothing
256 //errors += fail_if_equal( value, alt_value, "app1/app2 sockets" );
259 // --- test that the get_rte function finds expected keys, and retries to find 'bad' sid attempts for valid mtypes with no sid
260 rte = uta_get_rte( rt, 0, 1, TRUE ); // s=0 m=1 is defined, so this should return a pointer
261 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=1 true given" );
263 rte = uta_get_rte( rt, 0, 1, FALSE ); // the retry shouldn't apply, but ensure it does the righ thing
264 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=1 false given" );
266 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
267 errors += fail_not_nil( rte, "get_rte returned a pointer when s=1000 m=1 false given" );
269 rte = uta_get_rte( rt, 1000, 1, TRUE ); // this should also fail as there is no mt==1 sid==-1 defined
270 errors += fail_not_nil( rte, "get_rte returned a pointer when s=1000 m=1 true given" );
272 rte = uta_get_rte( rt, 0, 3, TRUE ); // mtype sid combo does exist; true/false should not matter
273 errors += fail_if_nil( rte, "get_rte did not return a pointer when s=0 m=3 true given" );
275 rte2 = uta_get_rte( rt, 11, 3, TRUE ); // same mtype as before, different (valid) group, rte should be different than before
276 errors += fail_if_nil( rte2, "get_rte did not return a pointer when s=11 m=3 true given" );
277 errors += fail_if_true( rte == rte2, "get_rte for mtype==3 and different sids (0 and 11) returned the same rte pointer" );
279 rte2 = uta_get_rte( rt, 0, 3, FALSE ); // since the mtype/sid combo exists, setting false should return the same as before
280 errors += fail_if_nil( rte2, "get_rte did not return a pointer when s=0 m=3 false given" );
281 errors += fail_if_false( rte == rte2, "get_rte did not return same pointer when mtype/sid combo given with different true/false" );
283 rte = uta_get_rte( rt, 12, 3, FALSE ); // this combo does not exist and should fail when alt-key is not allowed (false)
284 errors += fail_not_nil( rte, "get_rte returned a pointer for s=12, m=3, false" );
286 rte = uta_get_rte( rt, 12, 3, TRUE ); // this should return the entry for the 3/-1 combination
287 errors += fail_if_nil( rte, "get_rte did not return a pointer for s=12, m=3, true" );
290 rte = uta_get_rte( rt, 0, 1, FALSE ); // get an rte for the next loop
292 for( i = 0; i < 10; i++ ) { // round robin return value should be different each time
293 value = uta_epsock_rr( rte, 0, &more, &nn_sock ); // msg type 1, group 1
294 errors += fail_if_equal( value, alt_value, "round robiin sockets with multiple end points" );
295 errors += fail_if_false( more, "more for mtype==1" );
301 rte = uta_get_rte( rt, 0, 3, FALSE ); // get an rte for the next loop
303 for( i = 0; i < 10; i++ ) { // this mtype has only one endpoint, so rr should be same each time
304 value = uta_epsock_rr( rte, 0, NULL, &nn_sock ); // also test ability to deal properly with nil more pointer
306 errors += fail_not_equal( value, alt_value, "round robin sockets with one endpoint" );
307 errors += fail_not_equal( more, -1, "more value changed in single group instance" );
313 rte = uta_get_rte( rt, 11, 3, TRUE );
314 state = uta_epsock_rr( rte, 22, NULL, NULL );
315 errors += fail_if_true( state, "uta_epsock_rr returned bad (non-zero) state when given nil socket pointer" );
317 uta_rt_clone( NULL ); // verify null parms don't crash things
319 uta_epsock_rr( NULL, 0, &more, &nn_sock ); // drive null case for coverage
320 uta_add_rte( NULL, 99, 1 );
321 uta_get_rte( NULL, 0, 1000, TRUE );
323 fprintf( stderr, "[INFO] test: adding end points with nil data; warnings expected\n" );
324 uta_add_ep( NULL, NULL, "foo", 1 );
325 uta_add_ep( rt, NULL, "foo", 1 );
327 buf = uta_fib( ".gitignore" );
328 errors += fail_if_nil( buf, "buffer from read file into buffer" );
332 buf = uta_fib( "no-file" );
333 errors += fail_if_nil( buf, "buffer from read file into buffer (no file)" );
341 if( (ctx = (uta_ctx_t *) malloc( sizeof( uta_ctx_t ) )) != NULL ) {
342 memset( ctx, 0, sizeof( *ctx ) );
344 if( (seed_fname = getenv( "RMR_SEED_RT" )) != NULL ) {
345 read_static_rt( ctx, 0 );
347 errors += fail_if_nil( rt, "read seed table didn't generate a rtable pointer in context" );
348 unsetenv( "RMR_SEED_RT" ); // remove for next test
351 read_static_rt( ctx, 0 ); // drive for not there coverage
355 buf = uta_fib( "no-suhch-file" ); // drive some error checking for coverage
361 ep = (endpoint_t *) malloc( sizeof( *ep ) );
362 pthread_mutex_init( &ep->gate, NULL );
363 ep->name = strdup( "worm" );
365 state = uta_link2( ep );
366 errors += fail_if_true( state, "link2 did not return false when given nil pointers" );
369 return !!errors; // 1 or 0 regardless of count