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