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