test/sr_nano_static_test.c

   1 // : vi ts=4 sw=4 noet :
   2 /*
   3 ==================================================================================
   4             Copyright (c) 2019 Nokia
   5             Copyright (c) 2018-2019 AT&T Intellectual Property.
   6
   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
  10
  11            http://www.apache.org/licenses/LICENSE-2.0
  12
  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 ==================================================================================
  19 */
  20
  21 /*
  22         Mmemonic:       sr_nano_static_test.c
  23         Abstract:       Test the send/receive funcitons. These are meant to be included at compile
  24                                 time by the test driver.
  25
  26         Author:         E. Scott Daniels
  27         Date:           3 April 2019
  28 */
  29
  30 #include <unistd.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <strings.h>
  34 #include <errno.h>
  35 #include <string.h>
  36 #include <stdint.h>
  37 #include <pthread.h>
  38 #include <semaphore.h>
  39
  40 #include "rmr.h"
  41 #include "rmr_agnostic.h"
  42
  43 /*
  44         Generate a simple route table (for all but direct route table testing).
  45         This table contains multiple tables inasmuch as a second update set of
  46         records follows the initial set.
  47 */
  48 static void gen_rt( uta_ctx_t* ctx ) {
  49         int             fd;
  50         char*   rt_stuff;               // strings for the route table
  51
  52         rt_stuff =
  53                 "\r"                                                                            // ensure we are not screwed by broken OSes that insist on using \r
  54                 "newrt|end\n"                                                           // end of table check before start of table found
  55                 "# comment to drive full comment test\n"
  56                 "\n"                                                                            // handle blank lines
  57                 "   \n"                                                                         // handle blank lines
  58             "mse|4|10|localhost:4561\n"                                 // entry before start message
  59             "rte|4|localhost:4561\n"                                    // entry before start message
  60                 "newrt|start\n"                                                         // false start to drive detection
  61                 "xxx|badentry to drive default case"
  62                 "newrt|start\n"
  63             "rte|0|localhost:4560,localhost:4562\n"                                     // these are legitimate entries for our testing
  64             "rte|1|localhost:4562;localhost:4561,localhost:4569\n"
  65             "rte|2|localhost:4562| 10\n"                                                                // new subid at end
  66             "mse|4|10|localhost:4561\n"                                                                 // new msg/subid specifier rec
  67             "mse|4|localhost:4561\n"                                                                    // new mse entry with less than needed fields
  68                 "   rte|   5   |localhost:4563    #garbage comment\n"           // tests white space cleanup
  69             "rte|6|localhost:4562\n"
  70                 "newrt|end\n";
  71
  72         fd = open( "utesting.rt", O_WRONLY | O_CREAT, 0600 );
  73         if( fd < 0 ) {
  74                 fprintf( stderr, "<BUGGERED> unable to open file for testing route table gen\n" );
  75                 return;
  76         }
  77
  78         setenv( "RMR_SEED_RT", "utesting.rt", 1 );
  79         write( fd, rt_stuff, strlen( rt_stuff ) );
  80         close( fd );
  81         read_static_rt( ctx, 0 );
  82         unlink( "utesting.rt" );
  83 }
  84
  85
  86 /*
  87         Drive the send and receive functions.  We also drive as much of the route
  88         table collector as is possible without a real rtg process running somewhere.
  89
  90         Send and receive functions are indirectly exercised from the rmr_nano_static_test
  91         module as it tests the user facing send/receive/call/rts functions. These tests
  92         should exercise specific cases for the internal functions as they will not
  93         specifically be driven elsewhere.
  94 */
  95 static int sr_nano_test() {
  96         int errors = 0;                 // number errors found
  97
  98         uta_ctx_t* ctx;                         // context needed to test load static rt
  99         uta_ctx_t*      real_ctx;       // real one to force odd situations for error testing
 100         rmr_mbuf_t*     mbuf;           // mbuf to send/receive
 101         rmr_mbuf_t*     mb2;            // error capturing msg buf
 102         int             whid = -1;
 103         int             last_whid;
 104         int     state;
 105         int nn_dummy_sock;                                      // dummy needed to drive send
 106         int             size;
 107         int             i;
 108         void*   p;
 109
 110         //ctx = rmr_init( "tcp:4360", 2048, 0 );                                // do NOT call init -- that starts the rtc thread which isn't good here
 111         ctx = (uta_ctx_t *) malloc( sizeof( uta_ctx_t ) );              // alloc the context manually
 112         memset( ctx, 0, sizeof( uta_ctx_t ) );
 113
 114         ctx->mring = NULL;              //uta_mk_ring( 128 );
 115         ctx->max_plen = RMR_MAX_RCV_BYTES + sizeof( uta_mhdr_t );
 116         ctx->max_mlen = ctx->max_plen + sizeof( uta_mhdr_t );
 117         ctx->my_name = strdup( "dummy-test" );
 118         ctx->my_ip = strdup( "30.4.19.86:1111" );
 119         uta_lookup_rtg( ctx );
 120
 121         gen_rt( ctx );                                                          // forces a static load with some known info since we don't start the rtc()
 122         gen_rt( ctx );                                                          // force a second load to test cloning
 123
 124         p = rt_ensure_ep( NULL, "foo" );                                // drive for coverage
 125         errors += fail_not_nil( p,  "rt_ensure_ep did not return nil when given nil route table" );
 126
 127         state = rmr_ready( NULL );
 128         errors += fail_if_true( state, "reported ready when given a nil context" );
 129         state = rmr_ready( ctx );
 130         errors += fail_if_false( state, "reported not ready when it should be" );
 131
 132         mbuf = rcv_msg( ctx, NULL );
 133         errors += fail_if_nil( mbuf, "no mbuf returned on receive test" );
 134
 135         mbuf->len = 10;
 136         mbuf->mtype = 1;
 137
 138         mb2 = clone_msg( mbuf );
 139         errors += fail_if_nil( mb2, "clone message returned nil pointer" );
 140         //errors += fail_not_equal( mbuf->flags, mb2->flags, "clone did not duplicate flags" );
 141         errors += fail_not_equal( mbuf->alloc_len, mb2->alloc_len, "clone did not dup alloc-len" );
 142         errors += fail_not_equal( mbuf->state, mb2->state, "clone did not dup state" );
 143         rmr_free_msg( mb2 );
 144
 145         mbuf = rmr_send_msg( NULL, mbuf );
 146         errors += fail_if_nil( mbuf, "send with nil context but buffere didn't return buffer" );
 147         if( mbuf ) {
 148                 errors += fail_not_equal( mbuf->state, RMR_ERR_BADARG, "send with buffer but nil context didn't return right state" );
 149         } else {
 150                 mbuf = rmr_rcv_msg( ctx, NULL );
 151         }
 152
 153         size = 4096;
 154         state = rmr_payload_size( mbuf );
 155         errors += fail_not_equal( state, size, "payload size (b) didn't return expected value (a)" );   // receive should always give 4k buffer
 156
 157         rmr_free_msg( mbuf );
 158
 159
 160         // ---- direct message read into payload (no rmr header) -------------------------
 161         mbuf = rcv_payload( ctx, NULL );
 162         errors += fail_if_nil( mbuf, "rcv_payload did not return a message buffer when given a nil messge" );
 163         if( mbuf ) {
 164                 errors += fail_if_true( mbuf->len <= 0, "rcv_payload did not return a buffer with payload length set when given a nil messge" );
 165                 errors += fail_not_equal( mbuf->state, 0, "rcv_payload did not return a buffer with good state when given a nil messge" );
 166         }
 167
 168         mbuf = rcv_payload( ctx, NULL );
 169         errors += fail_if_nil( mbuf, "rcv_payload did not return a message buffer" );
 170         if( mbuf ) {
 171                 errors += fail_if_true( mbuf->len <= 0, "rcv_payload did not return a buffer with payload length set" );
 172                 errors += fail_not_equal( mbuf->state, 0, "rcv_payload did not return a buffer with good state" );
 173         }
 174
 175         // ---- drive rtc in a 'static' (not pthreaded) mode to get some coverage; no 'results' to be verified -----
 176         setenv( ENV_RTG_RAW, "1", 1 );                                                          // rtc should expect raw messages (mostly coverage here)
 177         setenv( ENV_VERBOSE_FILE, ".ut_rmr_verbose", 1 );                       // allow for verbose code in rtc to be driven
 178         i = open( ".ut_rmr_verbose", O_RDWR | O_CREAT, 0654 );
 179         if( i >= 0 ) {
 180                 write( i, "2\n", 2 );
 181                 close( i );
 182         }
 183         ctx->shutdown = 1;                      // should force rtc to quit on first pass
 184         rtc( NULL );                            // coverage test with nil pointer
 185         rtc( ctx );
 186
 187
 188         // --- drive the route table things which are nanomsg specific ------
 189
 190         return !!errors;
 191 }