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: 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.
26 Author: E. Scott Daniels
38 #include <semaphore.h>
41 #include "rmr_agnostic.h"
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.
48 static void gen_rt( uta_ctx_t* ctx ) {
50 char* rt_stuff; // strings for the route table
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"
63 "rte|0|localhost:4560,localhost:4562,dummy-test:1111\n" // these are legitimate entries for our testing
64 "rte|1|localhost:4562;localhost:4561,localhost:4569,10.7.9.86:4560\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"
72 fd = open( "utesting.rt", O_WRONLY | O_CREAT, 0600 );
74 fprintf( stderr, "<BUGGERED> unable to open file for testing route table gen\n" );
78 setenv( "RMR_SEED_RT", "utesting.rt", 1 );
79 write( fd, rt_stuff, strlen( rt_stuff ) );
81 read_static_rt( ctx, 0 );
82 unlink( "utesting.rt" );
86 Generates a legitimate table but with a missing newline on the last record.
88 static void gen_mlnl_rt( uta_ctx_t* ctx ) {
90 char* rt_stuff; // strings for the route table
94 "rte|0|localhost:4560,localhost:4562\n" // these are legitimate entries for our testing
95 "rte|1|localhost:4562;localhost:4561,localhost:4569\n"
96 "rte|2|localhost:4562| 10\n" // new subid at end
97 "mse|4|10|localhost:4561\n" // new msg/subid specifier rec
98 "mse|4|localhost:4561\n" // new mse entry with less than needed fields
99 " rte| 5 |localhost:4563 #garbage comment\n" // tests white space cleanup
100 "rte|6|localhost:4562\n"
101 "newrt|end"; // should not affect the loader
103 fd = open( "utesting.rt", O_WRONLY | O_CREAT, 0600 );
105 fprintf( stderr, "<BUGGERED> unable to open file for testing route table gen\n" );
109 setenv( "RMR_SEED_RT", "utesting.rt", 1 );
110 write( fd, rt_stuff, strlen( rt_stuff ) );
112 read_static_rt( ctx, 0 );
113 unlink( "utesting.rt" );
117 Generate an empty route table to test edge case.
119 static void gen_empty_rt( uta_ctx_t* ctx ) {
122 fd = open( "utesting.rt", O_WRONLY | O_CREAT | O_TRUNC, 0600 );
124 fprintf( stderr, "<BUGGERED> unable to open file for testing route table gen\n" );
128 setenv( "RMR_SEED_RT", "utesting.rt", 1 );
129 //write( fd, "", 0 );
131 read_static_rt( ctx, 0 );
132 unlink( "utesting.rt" );
136 Generate an single byte route table to drive an edge handling case.
138 static void gen_sb_rt( uta_ctx_t* ctx ) {
141 fd = open( "utesting.rt", O_WRONLY | O_CREAT | O_TRUNC, 0600 );
143 fprintf( stderr, "<BUGGERED> unable to open file for testing route table gen\n" );
147 setenv( "RMR_SEED_RT", "utesting.rt", 1 );
150 read_static_rt( ctx, 0 );
151 unlink( "utesting.rt" );
156 Drive the send and receive functions. We also drive as much of the route
157 table collector as is possible without a real rtg process running somewhere.
159 Send and receive functions are indirectly exercised from the rmr_nano_static_test
160 module as it tests the user facing send/receive/call/rts functions. These tests
161 should exercise specific cases for the internal functions as they will not
162 specifically be driven elsewhere.
164 static int sr_nano_test() {
165 int errors = 0; // number errors found
167 uta_ctx_t* ctx; // context needed to test load static rt
168 uta_ctx_t* real_ctx; // real one to force odd situations for error testing
169 rmr_mbuf_t* mbuf; // mbuf to send/receive
170 rmr_mbuf_t* mb2; // error capturing msg buf
174 int nn_dummy_sock; // dummy needed to drive send
179 //ctx = rmr_init( "tcp:4360", 2048, 0 ); // do NOT call init -- that starts the rtc thread which isn't good here
180 ctx = (uta_ctx_t *) malloc( sizeof( uta_ctx_t ) ); // alloc the context manually
181 memset( ctx, 0, sizeof( uta_ctx_t ) );
183 ctx->mring = NULL; //uta_mk_ring( 128 );
184 ctx->max_plen = RMR_MAX_RCV_BYTES + sizeof( uta_mhdr_t );
185 ctx->max_mlen = ctx->max_plen + sizeof( uta_mhdr_t );
186 ctx->my_name = strdup( "dummy-test:1111" );
187 ctx->my_ip = strdup( "30.4.19.86:1111" );
188 uta_lookup_rtg( ctx );
191 gen_sb_rt( ctx ); // generate and read a file with a sinle byte to test edge case
192 errors += fail_not_nil( ctx->rtable, "read single byte route table produced a table" );
195 gen_empty_rt( ctx ); // generate and read an empty rt file to test edge case
196 errors += fail_not_nil( ctx->rtable, "read empty route table file produced a table" );
199 gen_mlnl_rt( ctx ); // ensure that a file with missing last new line does not trip us up
200 errors += fail_if_nil( ctx->rtable, "read route table file with missing last newline did not produce a table" );
203 gen_rt( ctx ); // forces a static load with some known info since we don't start the rtc()
204 errors += fail_if_nil( ctx->rtable, "read multi test route table file did not produce a table" );
205 gen_rt( ctx ); // force a second load to test cloning
206 errors += fail_if_nil( ctx->rtable, "read multi test route table file to test clone did not produce a table" );
208 p = rt_ensure_ep( NULL, "foo" ); // drive for coverage
209 errors += fail_not_nil( p, "rt_ensure_ep did not return nil when given nil route table" );
211 state = rmr_ready( NULL );
212 errors += fail_if_true( state, "reported ready when given a nil context" );
213 state = rmr_ready( ctx );
214 errors += fail_if_false( state, "reported not ready when it should be" );
216 mbuf = rcv_msg( ctx, NULL );
217 errors += fail_if_nil( mbuf, "no mbuf returned on receive test" );
222 mb2 = clone_msg( mbuf );
223 errors += fail_if_nil( mb2, "clone message returned nil pointer" );
224 //errors += fail_not_equal( mbuf->flags, mb2->flags, "clone did not duplicate flags" );
225 errors += fail_not_equal( mbuf->alloc_len, mb2->alloc_len, "clone did not dup alloc-len" );
226 errors += fail_not_equal( mbuf->state, mb2->state, "clone did not dup state" );
229 mbuf = rmr_send_msg( NULL, mbuf );
230 errors += fail_if_nil( mbuf, "send with nil context but buffere didn't return buffer" );
232 errors += fail_not_equal( mbuf->state, RMR_ERR_BADARG, "send with buffer but nil context didn't return right state" );
234 mbuf = rmr_rcv_msg( ctx, NULL );
238 state = rmr_payload_size( mbuf );
239 errors += fail_not_equal( state, size, "payload size (b) didn't return expected value (a)" ); // receive should always give 4k buffer
241 rmr_free_msg( mbuf );
244 // ---- direct message read into payload (no rmr header) -------------------------
245 mbuf = rcv_payload( ctx, NULL );
246 errors += fail_if_nil( mbuf, "rcv_payload did not return a message buffer when given a nil messge" );
248 errors += fail_if_true( mbuf->len <= 0, "rcv_payload did not return a buffer with payload length set when given a nil messge" );
249 errors += fail_not_equal( mbuf->state, 0, "rcv_payload did not return a buffer with good state when given a nil messge" );
252 mbuf = rcv_payload( ctx, NULL );
253 errors += fail_if_nil( mbuf, "rcv_payload did not return a message buffer" );
255 errors += fail_if_true( mbuf->len <= 0, "rcv_payload did not return a buffer with payload length set" );
256 errors += fail_not_equal( mbuf->state, 0, "rcv_payload did not return a buffer with good state" );
259 // ---- drive rtc in a 'static' (not pthreaded) mode to get some coverage; no 'results' to be verified -----
260 setenv( ENV_RTG_RAW, "1", 1 ); // rtc should expect raw messages (mostly coverage here)
261 setenv( ENV_VERBOSE_FILE, ".ut_rmr_verbose", 1 ); // allow for verbose code in rtc to be driven
262 i = open( ".ut_rmr_verbose", O_RDWR | O_CREAT, 0654 );
264 write( i, "2\n", 2 );
267 ctx->shutdown = 1; // should force rtc to quit on first pass
268 rtc( NULL ); // coverage test with nil pointer
272 // --- drive the route table things which are nanomsg specific ------