diff options
Diffstat (limited to 'src/util/test_mq.c')
-rw-r--r-- | src/util/test_mq.c | 278 |
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 | ||
37 | static unsigned int received_cnt; | 38 | static unsigned int received_cnt; |
38 | 39 | ||
39 | 40 | ||
40 | GNUNET_NETWORK_STRUCT_BEGIN | 41 | GNUNET_NETWORK_STRUCT_BEGIN |
41 | 42 | ||
42 | struct MyMessage { | 43 | struct 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 | ||
58 | static void | 60 | static void |
59 | do_shutdown(void *cls) | 61 | do_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 | ||
75 | static void | 77 | static void |
76 | do_timeout(void *cls) | 78 | do_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 | */ |
94 | static void | 96 | static void |
95 | error_cb(void *cls, | 97 | error_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 | ||
104 | static void | 106 | static void |
105 | client_continue(void *cls) | 107 | client_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 | ||
114 | static void | 116 | static void |
115 | handle_dummy(void *cls, | 117 | handle_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 | ||
135 | static void | 137 | static void |
136 | handle_dummy2(void *cls, | 138 | handle_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 | */ |
154 | static void | 156 | static void |
155 | notify_sent_cb(void *cls) | 157 | notify_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 | */ |
178 | static void | 180 | static void |
179 | run(void *cls, | 181 | run (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 | ¬ify_sent_cb, | 212 | ¬ify_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 | */ |
231 | static void * | 233 | static void * |
232 | connect_cb(void *cls, | 234 | connect_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 | */ |
249 | static void | 251 | static void |
250 | disconnect_cb(void *cls, | 252 | disconnect_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 | ||
260 | static void | 262 | static void |
261 | test1() | 263 | test1 () |
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 | ||
279 | static void | 281 | static void |
280 | test2() | 282 | test2 () |
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 | ||
299 | int | 301 | int |
300 | main(int argc, char **argv) | 302 | main (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 | } |