aboutsummaryrefslogtreecommitdiff
path: root/src/util/test_mq.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/test_mq.c')
-rw-r--r--src/util/test_mq.c278
1 files changed, 140 insertions, 138 deletions
diff --git a/src/util/test_mq.c b/src/util/test_mq.c
index 4282f06b7..dc34f2da4 100644
--- a/src/util/test_mq.c
+++ b/src/util/test_mq.c
@@ -32,14 +32,16 @@
32/** 32/**
33 * How long does the receiver take per message? 33 * How long does the receiver take per message?
34 */ 34 */
35#define RECEIVER_THROTTLE GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 1) 35#define RECEIVER_THROTTLE GNUNET_TIME_relative_multiply ( \
36 GNUNET_TIME_UNIT_MILLISECONDS, 1)
36 37
37static unsigned int received_cnt; 38static unsigned int received_cnt;
38 39
39 40
40GNUNET_NETWORK_STRUCT_BEGIN 41GNUNET_NETWORK_STRUCT_BEGIN
41 42
42struct MyMessage { 43struct MyMessage
44{
43 struct GNUNET_MessageHeader header; 45 struct GNUNET_MessageHeader header;
44 uint32_t x GNUNET_PACKED; 46 uint32_t x GNUNET_PACKED;
45}; 47};
@@ -56,28 +58,28 @@ static struct GNUNET_MQ_Handle *cmq;
56 58
57 59
58static void 60static void
59do_shutdown(void *cls) 61do_shutdown (void *cls)
60{ 62{
61 (void)cls; 63 (void) cls;
62 if (NULL != tt) 64 if (NULL != tt)
63 { 65 {
64 GNUNET_SCHEDULER_cancel(tt); 66 GNUNET_SCHEDULER_cancel (tt);
65 tt = NULL; 67 tt = NULL;
66 } 68 }
67 if (NULL != cmq) 69 if (NULL != cmq)
68 { 70 {
69 GNUNET_MQ_destroy(cmq); 71 GNUNET_MQ_destroy (cmq);
70 cmq = NULL; 72 cmq = NULL;
71 } 73 }
72} 74}
73 75
74 76
75static void 77static void
76do_timeout(void *cls) 78do_timeout (void *cls)
77{ 79{
78 (void)cls; 80 (void) cls;
79 tt = NULL; 81 tt = NULL;
80 GNUNET_SCHEDULER_shutdown(); 82 GNUNET_SCHEDULER_shutdown ();
81 global_ret = 1; 83 global_ret = 1;
82} 84}
83 85
@@ -92,59 +94,59 @@ do_timeout(void *cls)
92 * @param error error code 94 * @param error error code
93 */ 95 */
94static void 96static void
95error_cb(void *cls, 97error_cb (void *cls,
96 enum GNUNET_MQ_Error error) 98 enum GNUNET_MQ_Error error)
97{ 99{
98 GNUNET_break(0); 100 GNUNET_break (0);
99 global_ret = 3; 101 global_ret = 3;
100 GNUNET_SCHEDULER_shutdown(); 102 GNUNET_SCHEDULER_shutdown ();
101} 103}
102 104
103 105
104static void 106static void
105client_continue(void *cls) 107client_continue (void *cls)
106{ 108{
107 struct GNUNET_SERVICE_Client *c = cls; 109 struct GNUNET_SERVICE_Client *c = cls;
108 110
109 dt = NULL; 111 dt = NULL;
110 GNUNET_SERVICE_client_continue(c); 112 GNUNET_SERVICE_client_continue (c);
111} 113}
112 114
113 115
114static void 116static void
115handle_dummy(void *cls, 117handle_dummy (void *cls,
116 const struct MyMessage *msg) 118 const struct MyMessage *msg)
117{ 119{
118 struct GNUNET_SERVICE_Client *c = cls; 120 struct GNUNET_SERVICE_Client *c = cls;
119 121
120 GNUNET_assert(NULL == dt); 122 GNUNET_assert (NULL == dt);
121 /* artificially make receiver slower than sender */ 123 /* artificially make receiver slower than sender */
122 dt = GNUNET_SCHEDULER_add_delayed(RECEIVER_THROTTLE, 124 dt = GNUNET_SCHEDULER_add_delayed (RECEIVER_THROTTLE,
123 &client_continue, 125 &client_continue,
124 c); 126 c);
125 if (received_cnt != ntohl(msg->x)) 127 if (received_cnt != ntohl (msg->x))
126 { 128 {
127 GNUNET_break(0); 129 GNUNET_break (0);
128 global_ret = 4; 130 global_ret = 4;
129 GNUNET_SCHEDULER_shutdown(); 131 GNUNET_SCHEDULER_shutdown ();
130 } 132 }
131 received_cnt++; 133 received_cnt++;
132} 134}
133 135
134 136
135static void 137static void
136handle_dummy2(void *cls, 138handle_dummy2 (void *cls,
137 const struct MyMessage *msg) 139 const struct MyMessage *msg)
138{ 140{
139 struct GNUNET_SERVICE_Client *c = cls; 141 struct GNUNET_SERVICE_Client *c = cls;
140 142
141 GNUNET_SERVICE_client_continue(c); 143 GNUNET_SERVICE_client_continue (c);
142 if (NUM_TRANSMISSIONS != received_cnt) 144 if (NUM_TRANSMISSIONS != received_cnt)
143 { 145 {
144 GNUNET_break(0); 146 GNUNET_break (0);
145 global_ret = 5; 147 global_ret = 5;
146 } 148 }
147 GNUNET_SCHEDULER_shutdown(); 149 GNUNET_SCHEDULER_shutdown ();
148} 150}
149 151
150 152
@@ -152,19 +154,19 @@ handle_dummy2(void *cls,
152 * Function called whenever MQ has sent a message. 154 * Function called whenever MQ has sent a message.
153 */ 155 */
154static void 156static void
155notify_sent_cb(void *cls) 157notify_sent_cb (void *cls)
156{ 158{
157 static unsigned int seen; 159 static unsigned int seen;
158 unsigned int *cnt = cls; 160 unsigned int *cnt = cls;
159 161
160 if (seen != *cnt) 162 if (seen != *cnt)
161 { 163 {
162 GNUNET_break(0); 164 GNUNET_break (0);
163 global_ret = 6; 165 global_ret = 6;
164 GNUNET_SCHEDULER_shutdown(); 166 GNUNET_SCHEDULER_shutdown ();
165 } 167 }
166 seen++; 168 seen++;
167 GNUNET_free(cnt); 169 GNUNET_free (cnt);
168} 170}
169 171
170 172
@@ -176,47 +178,47 @@ notify_sent_cb(void *cls)
176 * @param sh handle to the newly create service 178 * @param sh handle to the newly create service
177 */ 179 */
178static void 180static void
179run(void *cls, 181run (void *cls,
180 const struct GNUNET_CONFIGURATION_Handle *cfg, 182 const struct GNUNET_CONFIGURATION_Handle *cfg,
181 struct GNUNET_SERVICE_Handle *sh) 183 struct GNUNET_SERVICE_Handle *sh)
182{ 184{
183 struct GNUNET_MQ_MessageHandler ch[] = { 185 struct GNUNET_MQ_MessageHandler ch[] = {
184 GNUNET_MQ_handler_end() 186 GNUNET_MQ_handler_end ()
185 }; 187 };
186 struct GNUNET_MQ_Envelope *env; 188 struct GNUNET_MQ_Envelope *env;
187 struct MyMessage *m; 189 struct MyMessage *m;
188 190
189 (void)cls; 191 (void) cls;
190 (void)sh; 192 (void) sh;
191 cmq = GNUNET_CLIENT_connect(cfg, 193 cmq = GNUNET_CLIENT_connect (cfg,
192 "test_client", 194 "test_client",
193 ch, 195 ch,
194 &error_cb, 196 &error_cb,
195 NULL); 197 NULL);
196 GNUNET_SCHEDULER_add_shutdown(&do_shutdown, 198 GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
197 NULL); 199 NULL);
198 tt = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, 200 tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
199 &do_timeout, 201 &do_timeout,
200 NULL); 202 NULL);
201 for (unsigned int i = 0; i < NUM_TRANSMISSIONS; i++) 203 for (unsigned int i = 0; i < NUM_TRANSMISSIONS; i++)
202 { 204 {
203 unsigned int *cnt; 205 unsigned int *cnt;
204 206
205 cnt = GNUNET_new(unsigned int); 207 cnt = GNUNET_new (unsigned int);
206 *cnt = i; 208 *cnt = i;
207 env = GNUNET_MQ_msg(m, 209 env = GNUNET_MQ_msg (m,
208 GNUNET_MESSAGE_TYPE_DUMMY); 210 GNUNET_MESSAGE_TYPE_DUMMY);
209 GNUNET_MQ_notify_sent(env, 211 GNUNET_MQ_notify_sent (env,
210 &notify_sent_cb, 212 &notify_sent_cb,
211 cnt); 213 cnt);
212 m->x = htonl(i); 214 m->x = htonl (i);
213 GNUNET_MQ_send(cmq, 215 GNUNET_MQ_send (cmq,
214 env); 216 env);
215 } 217 }
216 env = GNUNET_MQ_msg(m, 218 env = GNUNET_MQ_msg (m,
217 GNUNET_MESSAGE_TYPE_DUMMY2); 219 GNUNET_MESSAGE_TYPE_DUMMY2);
218 GNUNET_MQ_send(cmq, 220 GNUNET_MQ_send (cmq,
219 env); 221 env);
220} 222}
221 223
222 224
@@ -229,12 +231,12 @@ run(void *cls,
229 * @return the client-specific (`internal') closure 231 * @return the client-specific (`internal') closure
230 */ 232 */
231static void * 233static void *
232connect_cb(void *cls, 234connect_cb (void *cls,
233 struct GNUNET_SERVICE_Client *c, 235 struct GNUNET_SERVICE_Client *c,
234 struct GNUNET_MQ_Handle *mq) 236 struct GNUNET_MQ_Handle *mq)
235{ 237{
236 (void)cls; 238 (void) cls;
237 (void)mq; 239 (void) mq;
238 return c; 240 return c;
239} 241}
240 242
@@ -247,18 +249,18 @@ connect_cb(void *cls,
247 * @param internal_cls the client-specific (`internal') closure 249 * @param internal_cls the client-specific (`internal') closure
248 */ 250 */
249static void 251static void
250disconnect_cb(void *cls, 252disconnect_cb (void *cls,
251 struct GNUNET_SERVICE_Client *c, 253 struct GNUNET_SERVICE_Client *c,
252 void *internal_cls) 254 void *internal_cls)
253{ 255{
254 (void)cls; 256 (void) cls;
255 (void)c; 257 (void) c;
256 (void)internal_cls; 258 (void) internal_cls;
257} 259}
258 260
259 261
260static void 262static void
261test1() 263test1 ()
262{ 264{
263 struct GNUNET_MQ_Envelope *mqm; 265 struct GNUNET_MQ_Envelope *mqm;
264 struct MyMessage *mm; 266 struct MyMessage *mm;
@@ -266,74 +268,74 @@ test1()
266 mm = NULL; 268 mm = NULL;
267 mqm = NULL; 269 mqm = NULL;
268 270
269 mqm = GNUNET_MQ_msg(mm, 271 mqm = GNUNET_MQ_msg (mm,
270 GNUNET_MESSAGE_TYPE_DUMMY); 272 GNUNET_MESSAGE_TYPE_DUMMY);
271 GNUNET_assert(NULL != mqm); 273 GNUNET_assert (NULL != mqm);
272 GNUNET_assert(NULL != mm); 274 GNUNET_assert (NULL != mm);
273 GNUNET_assert(GNUNET_MESSAGE_TYPE_DUMMY == ntohs(mm->header.type)); 275 GNUNET_assert (GNUNET_MESSAGE_TYPE_DUMMY == ntohs (mm->header.type));
274 GNUNET_assert(sizeof(struct MyMessage) == ntohs(mm->header.size)); 276 GNUNET_assert (sizeof(struct MyMessage) == ntohs (mm->header.size));
275 GNUNET_MQ_discard(mqm); 277 GNUNET_MQ_discard (mqm);
276} 278}
277 279
278 280
279static void 281static void
280test2() 282test2 ()
281{ 283{
282 struct GNUNET_MQ_Envelope *mqm; 284 struct GNUNET_MQ_Envelope *mqm;
283 struct GNUNET_MessageHeader *mh; 285 struct GNUNET_MessageHeader *mh;
284 286
285 mqm = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_DUMMY); 287 mqm = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_DUMMY);
286 /* how could the above be checked? */ 288 /* how could the above be checked? */
287 289
288 GNUNET_MQ_discard(mqm); 290 GNUNET_MQ_discard (mqm);
289 291
290 mqm = GNUNET_MQ_msg_header_extra(mh, 292 mqm = GNUNET_MQ_msg_header_extra (mh,
291 20, 293 20,
292 GNUNET_MESSAGE_TYPE_DUMMY); 294 GNUNET_MESSAGE_TYPE_DUMMY);
293 GNUNET_assert(GNUNET_MESSAGE_TYPE_DUMMY == ntohs(mh->type)); 295 GNUNET_assert (GNUNET_MESSAGE_TYPE_DUMMY == ntohs (mh->type));
294 GNUNET_assert(sizeof(struct GNUNET_MessageHeader) + 20 == ntohs(mh->size)); 296 GNUNET_assert (sizeof(struct GNUNET_MessageHeader) + 20 == ntohs (mh->size));
295 GNUNET_MQ_discard(mqm); 297 GNUNET_MQ_discard (mqm);
296} 298}
297 299
298 300
299int 301int
300main(int argc, char **argv) 302main (int argc, char **argv)
301{ 303{
302 char * test_argv[] = { 304 char *test_argv[] = {
303 (char *)"test_client", 305 (char *) "test_client",
304 "-c", 306 "-c",
305 "test_client_data.conf", 307 "test_client_data.conf",
306 NULL 308 NULL
307 }; 309 };
308 struct GNUNET_MQ_MessageHandler mh[] = { 310 struct GNUNET_MQ_MessageHandler mh[] = {
309 GNUNET_MQ_hd_fixed_size(dummy, 311 GNUNET_MQ_hd_fixed_size (dummy,
310 GNUNET_MESSAGE_TYPE_DUMMY, 312 GNUNET_MESSAGE_TYPE_DUMMY,
311 struct MyMessage, 313 struct MyMessage,
312 NULL), 314 NULL),
313 GNUNET_MQ_hd_fixed_size(dummy2, 315 GNUNET_MQ_hd_fixed_size (dummy2,
314 GNUNET_MESSAGE_TYPE_DUMMY2, 316 GNUNET_MESSAGE_TYPE_DUMMY2,
315 struct MyMessage, 317 struct MyMessage,
316 NULL), 318 NULL),
317 GNUNET_MQ_handler_end() 319 GNUNET_MQ_handler_end ()
318 }; 320 };
319 321
320 (void)argc; 322 (void) argc;
321 (void)argv; 323 (void) argv;
322 GNUNET_log_setup("test-mq", 324 GNUNET_log_setup ("test-mq",
323 "INFO", 325 "INFO",
324 NULL); 326 NULL);
325 test1(); 327 test1 ();
326 test2(); 328 test2 ();
327 if (0 != 329 if (0 !=
328 GNUNET_SERVICE_run_(3, 330 GNUNET_SERVICE_run_ (3,
329 test_argv, 331 test_argv,
330 "test_client", 332 "test_client",
331 GNUNET_SERVICE_OPTION_NONE, 333 GNUNET_SERVICE_OPTION_NONE,
332 &run, 334 &run,
333 &connect_cb, 335 &connect_cb,
334 &disconnect_cb, 336 &disconnect_cb,
335 NULL, 337 NULL,
336 mh)) 338 mh))
337 return 1; 339 return 1;
338 return global_ret; 340 return global_ret;
339} 341}