test/mbuf_api_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:       mbuf_api_static_test.c
  23         Abstract:       Test the message buffer  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 int mbuf_api_test( ) {
  45         unsigned char* c;
  46         int i;
  47         int state;
  48         int errors = 0;
  49         char*   buf;
  50         void*   ptr;
  51         rmr_mbuf_t*     mbuf;
  52         uta_mhdr_t*     hdr;
  53         unsigned char src_buf[256];
  54         unsigned char dest_buf[256];
  55
  56
  57         // --- dummy up a message buffer --------------------------------------------------------
  58         mbuf = (rmr_mbuf_t *) malloc( sizeof( *mbuf ) );
  59         if( mbuf == NULL ) {
  60                 fprintf( stderr, "[FAIL] tester cannot allocate memory: mbuf\n" );
  61                 exit( 1 );
  62         }
  63         memset( mbuf, 0, sizeof( *mbuf ) );
  64
  65         mbuf->tp_buf = (void *) malloc( sizeof( char ) * 1024 );                // add a dummy header/payload
  66         memset( mbuf->tp_buf, 0, sizeof( char ) * 1024 );
  67
  68         mbuf->header = mbuf->tp_buf;
  69         mbuf->alloc_len = 1024;
  70         mbuf->payload = PAYLOAD_ADDR( mbuf->header );
  71         hdr = (rmr_mbuf_t *) mbuf->header;
  72         mbuf->xaction = hdr->xid;
  73
  74
  75
  76
  77         // --- test payload field  access functions ---------------------------------------------------
  78         memset( src_buf, 0, sizeof( src_buf ) );
  79         rmr_bytes2payload( mbuf, NULL, strlen( src_buf) );                              // errno should be set on return
  80         errors += fail_if( errno == 0, "buf copy to payload with nil src returned good errno" );
  81
  82         rmr_bytes2payload( NULL, src_buf, strlen( src_buf) );                   // errno should be set on return
  83         errors += fail_if( errno == 0, "buf copy to payload with nil mbuf returned good errno" );
  84
  85         mbuf->state = 1;                                                                                        // force it to something to test that it was set
  86         rmr_bytes2payload( mbuf, src_buf, strlen( src_buf) );
  87         errors += fail_if( mbuf->state != RMR_OK, "buf copy to payload returned bad state in mbuf" );
  88
  89         rmr_bytes2payload( mbuf, src_buf, 8192 );                                               // bust the limit
  90         errors += fail_if( mbuf->state == RMR_OK, "huge buf copy to payload returned good state in mbuf" );
  91         errors += fail_if( errno == 0, "huge buf copy to payload returned good state in errno" );
  92
  93
  94         snprintf( src_buf, sizeof( src_buf ), "This is some text in the buffer" );
  95         rmr_str2payload( mbuf, src_buf );                                                       // this uses bytes2payload, so only one invocation needed
  96
  97
  98         // --- test meid field  access functions ---------------------------------------------------
  99         errno = 0;
 100         i = rmr_bytes2meid( NULL, src_buf, RMR_MAX_MEID );
 101         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to meid with nil message" );
 102         errors += fail_if( i > 0, "(rv) attempt to copy bytes to meid with nil message" );
 103
 104         errno = 0;
 105         i = rmr_bytes2meid( mbuf, NULL, RMR_MAX_MEID );
 106         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to meid with nil source buffer" );
 107         errors += fail_if( i > 0, "(rv) attempt to copy bytes to meid with nil message" );
 108
 109         errno = 0;
 110         i = rmr_bytes2meid( mbuf, src_buf, RMR_MAX_MEID + 1 );
 111         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to meid with large source buffer" );
 112         errors += fail_if( i != RMR_MAX_MEID, "(rv) attempt to copy bytes to meid with large source buffer" );
 113
 114         errno = 0;
 115         i = rmr_bytes2meid( mbuf, src_buf, RMR_MAX_MEID  );
 116         errors += fail_if( errno != 0, "copy bytes to meid; expected errno to be ok" );
 117         errors += fail_if( i != RMR_MAX_MEID, "copy bytes to meid; expected return value to be max meid len" );
 118
 119
 120
 121         errno = 0;
 122         snprintf( src_buf, sizeof( src_buf ), "meid-fits" );
 123         i = rmr_str2meid( NULL, src_buf );
 124         errors += fail_if( errno == 0, "(errno) attempt to copy string to meid with nil message" );
 125         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to meid with nil message" );
 126
 127         errno = 0;
 128         i = rmr_str2meid( mbuf, NULL );
 129         errors += fail_if( errno == 0, "(errno) attempt to copy string to meid with nil source buffer" );
 130         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to meid with nil message" );
 131
 132         errno = 0;
 133         i = rmr_str2meid( mbuf, src_buf );
 134         errors += fail_if( errno != 0, "copy string to meid; expected errno to be ok" );
 135         errors += fail_if( i != RMR_OK, "copy string to meid; expected return value to be RMR_OK" );
 136
 137         errno = 0;
 138         snprintf( src_buf, sizeof( src_buf ), "meid-should-be-too-large-to-fit-in-the-meid" );
 139         i = rmr_str2meid( mbuf, src_buf );
 140         errors += fail_if( errno == 0, "(errno) attempt to copy string to meid with large source buffer" );
 141         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to meid with large source buffer" );
 142
 143
 144         snprintf( src_buf, sizeof( src_buf ), "test-meid" );
 145         rmr_str2meid( mbuf, src_buf );
 146
 147         errno = 0;
 148         c = rmr_get_meid( NULL, NULL );
 149         errors += fail_if( c != NULL, "get meid with nil message buffer" );
 150         errors += fail_if( errno == 0, "(errno bad) get meid with nil msg buffer" );
 151
 152         c = rmr_get_meid( mbuf, NULL );                 // should allocate and return c
 153         errors += fail_if( c == NULL, "get meid with nil dest pointer (did not allocate a buffer)" );
 154         errors += fail_if( strcmp( c, "test-meid" ) != 0, "did not get expected meid from mbuffer" );
 155         if( c ) {
 156                 free( c );
 157                 c = NULL;
 158         }
 159
 160         c = rmr_get_meid( mbuf, c );
 161         errors += fail_if( c == NULL, "get meid with a dest pointer returned no pointer" );
 162         errors += fail_if( strcmp( c, "test-meid" ) != 0, "did not get expected meid from mbuffer" );
 163         if( c ) {
 164                 free( c );
 165                 c = NULL;
 166         }
 167
 168
 169         // --- test transaction field  access functions ---------------------------------------------------
 170         snprintf( src_buf, sizeof( src_buf ), "xaction-test##################." );              // full 32 bytes
 171
 172         errno = 0;
 173         i = rmr_bytes2xact( NULL, src_buf, RMR_MAX_XID );
 174         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to xact with nil message" );
 175         errors += fail_if( i > 0, "(rv) attempt to copy bytes to xact with nil message" );
 176
 177         errno = 0;
 178         i = rmr_bytes2xact( mbuf, NULL, RMR_MAX_XID );
 179         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to xact with nil source buffer" );
 180         errors += fail_if( i > 0, "(rv) attempt to copy bytes to xact with nil message" );
 181
 182         errno = 0;
 183         i = rmr_bytes2xact( mbuf, src_buf, RMR_MAX_XID + 1 );
 184         errors += fail_if( errno == 0, "(errno) attempt to copy bytes to xact with large source buffer" );
 185         errors += fail_if( i != RMR_MAX_XID, "(rv) attempt to copy bytes to xact with large source buffer" );
 186
 187         errno = 0;
 188         i = rmr_bytes2xact( mbuf, src_buf, RMR_MAX_XID  );
 189         errors += fail_if( errno != 0, "copy bytes to xact; expected errno to be ok" );
 190         errors += fail_if( i != RMR_MAX_XID, "copy bytes to xact; expected return value to be max xact len" );
 191
 192         errno = 0;
 193         ptr = rmr_get_xact( NULL, NULL );
 194         errors += fail_if( errno == 0, "get xaction with nil msg did not set errno" );
 195         errors += fail_not_nil( ptr, "get xaction with nil msg did not return a nil pointer" );
 196
 197         errno = 999;
 198         ptr = rmr_get_xact( mbuf, NULL );
 199         errors += fail_if( errno == 999, "get xaction with valid msg and nil dest didn't clear errno" );
 200         errors += fail_not_equal( errno, 0, "get xaction with valid msg and nil dest set errno (a)" );
 201         errors += fail_if_nil( ptr, "get xaction with valid msg  and nil dest did not return a valid pointer" );
 202         if( ptr ) {
 203                 i = strcmp( ptr, src_buf );
 204                 errors += fail_not_equal( i, 0, "get xaction did not fetch expected string cmp return (a) was not 0" );
 205                 free( ptr );
 206                 ptr = NULL;
 207         }
 208
 209         errno = 999;
 210         ptr = rmr_get_xact( mbuf, dest_buf );
 211         errors += fail_if( errno == 999, "get xaction with valid msg and nil dest didn't clear errno" );
 212         errors += fail_not_equal( errno, 0, "get xaction with valid msg and nil dest set errno (a)" );
 213         errors += fail_if_nil( ptr, "get xaction with valid msg  and valid dest did not return a valid pointer" );
 214         errors += fail_if( ptr != dest_buf, "get xaction did not return pointer to dest string" );
 215         if( ptr == dest_buf ) {
 216                 i = strcmp( ptr, src_buf );
 217                 errors += fail_not_equal( i, 0, "get xaction into dest string did not fetch expected string cmp return (a) was not 0" );
 218         }
 219
 220         errno = 0;
 221         snprintf( src_buf, sizeof( src_buf ), "xact-fits" );
 222         i = rmr_str2xact( NULL, src_buf );
 223         errors += fail_if( errno == 0, "(errno) attempt to copy string to xact with nil message" );
 224         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to xact with nil message" );
 225
 226         errno = 0;
 227         i = rmr_str2xact( mbuf, NULL );
 228         errors += fail_if( errno == 0, "(errno) attempt to copy string to xact with nil source buffer" );
 229         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to xact with nil message" );
 230
 231         errno = 0;
 232         i = rmr_str2xact( mbuf, src_buf );
 233         errors += fail_if( errno != 0, "copy string to xact; expected errno to be ok" );
 234         errors += fail_if( i != RMR_OK, "copy string to xact; expected return value to be RMR_OK" );
 235
 236         errno = 0;
 237         snprintf( src_buf, sizeof( src_buf ), "xact-should-be-too-large-to-fit-in-the-xact" );
 238         i = rmr_str2xact( mbuf, src_buf );
 239         errors += fail_if( errno == 0, "(errno) attempt to copy string to xact with large source buffer" );
 240         errors += fail_if( i == RMR_OK, "(rv) attempt to copy string to xact with large source buffer" );
 241
 242
 243         rmr_free_msg( mbuf );
 244
 245         // ------------ trace data tests ----------------------------------------------------------------
 246         // CAUTION: to support standalone mbuf api tests, the underlying buffer reallocation functions are NOT used
 247         //                      if this is driven by the mbuf_api_test.c driver
 248
 249         mbuf = test_mk_msg( 2048, 0 );          // initially no trace size to force realloc
 250
 251         state = TRACE_OFFSET( mbuf->header ) - PAYLOAD_OFFSET( mbuf->header );          // no trace data, payload and trace offset should be the same
 252         errors += fail_not_equal( state, 0, "trace offset and payload offset do NOT match when trace data is absent" );
 253
 254         state = rmr_get_trlen( mbuf );
 255         errors += fail_not_equal( state, 0, "initial trace len reported (a) does not match expected (b)" );
 256
 257         state = rmr_set_trace( NULL, src_buf, 100 );                            // coverage test on nil check
 258         errors += fail_not_equal( state, 0, "set trace with nil msg didn't return expected 0 status" );
 259
 260         state = rmr_set_trace( mbuf, src_buf, 0 );                              // coverage test on length check
 261         errors += fail_not_equal( state, 0, "set trace with 0 len didn't return expected 0 status" );
 262
 263         state = rmr_get_trace( NULL, src_buf, 100 );                            // coverage test on nil check
 264         errors += fail_not_equal( state, 0, "get trace with nil msg didn't return expected 0 status" );
 265
 266         state = rmr_get_trace( mbuf, NULL, 100 );                                       // coverage test on nil check
 267         errors += fail_not_equal( state, 0, "get trace with nil dest didn't return expected 0 status" );
 268
 269         state = rmr_get_trlen( NULL );                                                          // coverage test on nil check
 270         errors += fail_not_equal( state, 0, "get trace length with nil msg didn't return expected 0 status" );
 271
 272         ptr = rmr_trace_ref( NULL, NULL );
 273         errors += fail_not_nil( ptr, "trace ref returned non-nil pointer when given nil message" );
 274
 275         mbuf = test_mk_msg( 2048, 0 );          // initially no trace size to force realloc
 276         ptr = rmr_trace_ref( mbuf, NULL );
 277         errors += fail_not_nil( ptr, "trace ref returned non-nil pointer when given a message without trace data" );
 278
 279         i = 100;                                                                // ensure that i is reset when there is no trace data
 280         ptr = rmr_trace_ref( mbuf, &i );
 281         errors += fail_not_nil( ptr, "trace ref returned non-nil pointer when given a message without trace data" );
 282         errors += fail_not_equal( i, 0, "trace ref returned non zero size (a) when no trace info in message" );
 283
 284         i = 100;
 285         mbuf = test_mk_msg( 2048, 113 );                // alloc with a trace data area
 286         ptr = rmr_trace_ref( mbuf, &i );
 287         errors += fail_if_nil( ptr, "trace ref returned nil pointer when given a message with trace data" );
 288         errors += fail_not_equal( i, 113, "trace ref returned bad size (a), expected (b)" );
 289
 290
 291         src_buf[0] = 0;
 292         state = rmr_set_trace( mbuf, "foo bar was here", 17 );          // should force a realloc
 293         errors += fail_not_equal( state, 17, "bytes copied to trace (a) did not match expected size (b)" );
 294
 295         state = rmr_get_trace( mbuf, src_buf, 17 );
 296         errors += fail_not_equal( state, 17, "bytes retrieved from trace (a) did not match expected size (b)" );
 297
 298         state = rmr_get_trlen( mbuf );
 299         errors += fail_not_equal( state, 17, "trace len reported (a) does not match expected (b)" );
 300         state = strcmp( src_buf, "foo bar was here" );
 301         errors+= fail_not_equal( state, 0, "compare of pulled trace info did not match" );
 302
 303         state = TRACE_OFFSET( mbuf->header ) - PAYLOAD_OFFSET( mbuf->header );          // when there is a trace area these should NOT be the same
 304         errors += fail_if_equal( state, 0, "trace offset and payload offset match when trace data is present" );
 305
 306
 307                                                                                         // second round of trace testing, allocating a message with a trace size that matches
 308         mbuf = test_mk_msg( 2048, 17 );                 // trace size that matches what we'll stuff in, no realloc
 309         state = rmr_get_trlen( mbuf );
 310         errors += fail_not_equal( state, 17, "alloc with trace size: initial trace len reported (a) does not match expected (b)" );
 311
 312         src_buf[0] = 0;
 313         state = rmr_set_trace( mbuf, "foo bar was here", 17 );          // should force a realloc
 314         errors += fail_not_equal( state, 17, "bytes copied to trace (a) did not match expected size (b)" );
 315
 316         state = rmr_get_trace( mbuf, src_buf, 17 );
 317         errors += fail_not_equal( state, 17, "bytes retrieved from trace (a) did not match expected size (b)" );
 318         state = strcmp( src_buf, "foo bar was here" );
 319         errors+= fail_not_equal( state, 0, "compare of pulled trace info did not match" );
 320
 321         i = rmr_get_trlen( mbuf );
 322
 323
 324         // ------------- source field tests ------------------------------------------------------------
 325         // we cannot force anything into the message source field, so no way to test the content, but we
 326         // can test pointers and expected nils
 327
 328         buf = rmr_get_src( NULL, src_buf );                                     // coverage test for nil msg check
 329         errors += fail_not_nil( buf, "rmr_get_src returned a pointer when given a nil message" );
 330
 331         buf = rmr_get_src( mbuf, NULL );                                        // coverage test for nil dst check
 332         errors += fail_not_nil( buf, "rmr_get_src returned a pointer when given a nil dest buffer" );
 333
 334         buf = rmr_get_src( mbuf, src_buf );
 335         errors += fail_not_equalp( buf, src_buf, "rmr_get_src didn't return expexted buffer pointer" );
 336
 337         buf = rmr_get_srcip( NULL, NULL );
 338         errors += fail_not_nil( buf, "get_srcip did not return nil when given nil pointers" );
 339
 340         buf = rmr_get_srcip( mbuf, NULL );
 341         errors += fail_not_nil( buf, "get_srcip did not return nil when given nil destination" );
 342
 343         buf = rmr_get_srcip( mbuf, src_buf );
 344         errors += fail_not_equalp( buf, src_buf, "rmr_get_srcip didn't return expexted buffer pointer" );
 345
 346         test_set_ver( mbuf, 2 );                                                        // set older message version to ensure properly handled
 347         buf = rmr_get_srcip( mbuf, src_buf );
 348
 349         return errors > 0;                      // overall exit code bad if errors
 350 }