1 /* -*- mode: c ; c-file-style: "canonware-c-style" -*-
2 ******************************************************************************
3 *
4 * Copyright (C) 1996-2005 Jason Evans <jasone@canonware.com>.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice(s), this list of conditions and the following disclaimer
12 * unmodified other than the allowable addition of one or more
13 * copyright notices.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice(s), this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
20 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
26 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
28 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
29 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 *
31 ******************************************************************************
32 *
33 * Version: Onyx 5.1.2
34 *
35 * Test the mq (message queue) class.
36 *
37 ******************************************************************************/
38
39 #include "../include/libonyx/libonyx.h"
40
41 int
main()42 main()
43 {
44 libonyx_init(0, NULL, NULL);
45 fprintf(stderr, "Test begin\n");
46
47 /* mq_new(), mq_delete(). */
48 {
49 cw_mq_t mq;
50
51 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
52 mq_delete(&mq);
53
54 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
55 mq_delete(&mq);
56 }
57
58 /* mq_tryget(), mq_put(). */
59 {
60 cw_mq_t mq;
61 uint8_t i = 1, j = 2, k = 3, t;
62
63 mq_new(&mq, cw_g_mema, sizeof(uint8_t));
64
65 cw_assert(mq_tryget(&mq, &t));
66 cw_assert(mq_put(&mq, i) == 0);
67 cw_assert(mq_tryget(&mq, &t) == false);
68 cw_assert(t == i);
69 cw_assert(mq_tryget(&mq, &t));
70
71 cw_assert(mq_put(&mq, i) == 0);
72 cw_assert(mq_put(&mq, j) == 0);
73 cw_assert(mq_put(&mq, k) == 0);
74 cw_assert(mq_tryget(&mq, &t) == false);
75 cw_assert(t == i);
76 cw_assert(mq_put(&mq, i) == 0);
77 cw_assert(mq_tryget(&mq, &t) == false);
78 cw_assert(t == j);
79 cw_assert(mq_tryget(&mq, &t) == false);
80 cw_assert(t == k);
81 cw_assert(mq_tryget(&mq, &t) == false);
82 cw_assert(t == i);
83 cw_assert(mq_tryget(&mq, &t));
84
85 mq_delete(&mq);
86 }
87 {
88 cw_mq_t mq;
89 uint16_t i = 1, j = 2, k = 3, t;
90
91 mq_new(&mq, cw_g_mema, sizeof(uint16_t));
92
93 cw_assert(mq_tryget(&mq, &t));
94 cw_assert(mq_put(&mq, i) == 0);
95 cw_assert(mq_tryget(&mq, &t) == false);
96 cw_assert(t == i);
97 cw_assert(mq_tryget(&mq, &t));
98
99 cw_assert(mq_put(&mq, i) == 0);
100 cw_assert(mq_put(&mq, j) == 0);
101 cw_assert(mq_put(&mq, k) == 0);
102 cw_assert(mq_tryget(&mq, &t) == false);
103 cw_assert(t == i);
104 cw_assert(mq_put(&mq, i) == 0);
105 cw_assert(mq_tryget(&mq, &t) == false);
106 cw_assert(t == j);
107 cw_assert(mq_tryget(&mq, &t) == false);
108 cw_assert(t == k);
109 cw_assert(mq_tryget(&mq, &t) == false);
110 cw_assert(t == i);
111 cw_assert(mq_tryget(&mq, &t));
112
113 mq_delete(&mq);
114 }
115 {
116 cw_mq_t mq;
117 uint32_t i = 1, j = 2, k = 3, t;
118
119 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
120
121 cw_assert(mq_tryget(&mq, &t));
122 cw_assert(mq_put(&mq, i) == 0);
123 cw_assert(mq_tryget(&mq, &t) == false);
124 cw_assert(t == i);
125 cw_assert(mq_tryget(&mq, &t));
126
127 cw_assert(mq_put(&mq, i) == 0);
128 cw_assert(mq_put(&mq, j) == 0);
129 cw_assert(mq_put(&mq, k) == 0);
130 cw_assert(mq_tryget(&mq, &t) == false);
131 cw_assert(t == i);
132 cw_assert(mq_put(&mq, i) == 0);
133 cw_assert(mq_tryget(&mq, &t) == false);
134 cw_assert(t == j);
135 cw_assert(mq_tryget(&mq, &t) == false);
136 cw_assert(t == k);
137 cw_assert(mq_tryget(&mq, &t) == false);
138 cw_assert(t == i);
139 cw_assert(mq_tryget(&mq, &t));
140
141 mq_delete(&mq);
142 }
143 {
144 cw_mq_t mq;
145 uint64_t i = 1, j = 2, k = 3, t;
146
147 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
148
149 cw_assert(mq_tryget(&mq, &t));
150 cw_assert(mq_put(&mq, i) == 0);
151 cw_assert(mq_tryget(&mq, &t) == false);
152 cw_assert(t == i);
153 cw_assert(mq_tryget(&mq, &t));
154
155 cw_assert(mq_put(&mq, i) == 0);
156 cw_assert(mq_put(&mq, j) == 0);
157 cw_assert(mq_put(&mq, k) == 0);
158 cw_assert(mq_tryget(&mq, &t) == false);
159 cw_assert(t == i);
160 cw_assert(mq_put(&mq, i) == 0);
161 cw_assert(mq_tryget(&mq, &t) == false);
162 cw_assert(t == j);
163 cw_assert(mq_tryget(&mq, &t) == false);
164 cw_assert(t == k);
165 cw_assert(mq_tryget(&mq, &t) == false);
166 cw_assert(t == i);
167 cw_assert(mq_tryget(&mq, &t));
168
169 mq_delete(&mq);
170 }
171
172 /* mq_timedget(), mq_put(). */
173 {
174 cw_mq_t mq;
175 uint8_t i = 1, j = 2, k = 3, t;
176 struct timespec timeout = {0, 10000};
177
178 mq_new(&mq, cw_g_mema, sizeof(uint8_t));
179
180 cw_assert(mq_timedget(&mq, &timeout));
181 cw_assert(mq_put(&mq, i) == 0);
182 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
183 cw_assert(t == i);
184 cw_assert(mq_timedget(&mq, &timeout));
185
186 cw_assert(mq_put(&mq, i) == 0);
187 cw_assert(mq_put(&mq, j) == 0);
188 cw_assert(mq_put(&mq, k) == 0);
189 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
190 cw_assert(t == i);
191 cw_assert(mq_put(&mq, i) == 0);
192 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
193 cw_assert(t == j);
194 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
195 cw_assert(t == k);
196 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
197 cw_assert(t == i);
198 cw_assert(mq_timedget(&mq, &timeout, &t));
199
200 mq_delete(&mq);
201 }
202 {
203 cw_mq_t mq;
204 uint16_t i = 1, j = 2, k = 3, t;
205 struct timespec timeout = {0, 10000};
206
207 mq_new(&mq, cw_g_mema, sizeof(uint16_t));
208
209 cw_assert(mq_timedget(&mq, &timeout));
210 cw_assert(mq_put(&mq, i) == 0);
211 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
212 cw_assert(t == i);
213 cw_assert(mq_timedget(&mq, &timeout));
214
215 cw_assert(mq_put(&mq, i) == 0);
216 cw_assert(mq_put(&mq, j) == 0);
217 cw_assert(mq_put(&mq, k) == 0);
218 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
219 cw_assert(t == i);
220 cw_assert(mq_put(&mq, i) == 0);
221 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
222 cw_assert(t == j);
223 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
224 cw_assert(t == k);
225 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
226 cw_assert(t == i);
227 cw_assert(mq_timedget(&mq, &timeout, &t));
228
229 mq_delete(&mq);
230 }
231 {
232 cw_mq_t mq;
233 uint32_t i = 1, j = 2, k = 3, t;
234 struct timespec timeout = {0, 10000};
235
236 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
237
238 cw_assert(mq_timedget(&mq, &timeout));
239 cw_assert(mq_put(&mq, i) == 0);
240 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
241 cw_assert(t == i);
242 cw_assert(mq_timedget(&mq, &timeout));
243
244 cw_assert(mq_put(&mq, i) == 0);
245 cw_assert(mq_put(&mq, j) == 0);
246 cw_assert(mq_put(&mq, k) == 0);
247 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
248 cw_assert(t == i);
249 cw_assert(mq_put(&mq, i) == 0);
250 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
251 cw_assert(t == j);
252 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
253 cw_assert(t == k);
254 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
255 cw_assert(t == i);
256 cw_assert(mq_timedget(&mq, &timeout, &t));
257
258 mq_delete(&mq);
259 }
260 {
261 cw_mq_t mq;
262 uint64_t i = 1, j = 2, k = 3, t;
263 struct timespec timeout = {0, 10000};
264
265 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
266
267 cw_assert(mq_timedget(&mq, &timeout));
268 cw_assert(mq_put(&mq, i) == 0);
269 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
270 cw_assert(t == i);
271 cw_assert(mq_timedget(&mq, &timeout));
272
273 cw_assert(mq_put(&mq, i) == 0);
274 cw_assert(mq_put(&mq, j) == 0);
275 cw_assert(mq_put(&mq, k) == 0);
276 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
277 cw_assert(t == i);
278 cw_assert(mq_put(&mq, i) == 0);
279 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
280 cw_assert(t == j);
281 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
282 cw_assert(t == k);
283 cw_assert(mq_timedget(&mq, &timeout, &t) == false);
284 cw_assert(t == i);
285 cw_assert(mq_timedget(&mq, &timeout, &t));
286
287 mq_delete(&mq);
288 }
289
290 /* mq_get(), mq_put(), mq_tryget(). */
291 {
292 cw_mq_t mq;
293 uint8_t i = 1, j = 2, k = 3, t;
294
295 mq_new(&mq, cw_g_mema, sizeof(uint8_t));
296
297 cw_assert(mq_tryget(&mq, &t));
298 cw_assert(mq_put(&mq, i) == 0);
299 cw_assert(mq_get(&mq, &t) == false);
300 cw_assert(t == i);
301 cw_assert(mq_tryget(&mq, &t));
302
303 cw_assert(mq_put(&mq, i) == 0);
304 cw_assert(mq_put(&mq, j) == 0);
305 cw_assert(mq_put(&mq, k) == 0);
306 cw_assert(mq_get(&mq, &t) == false);
307 cw_assert(t == i);
308 cw_assert(mq_put(&mq, i) == 0);
309 cw_assert(mq_get(&mq, &t) == false);
310 cw_assert(t == j);
311 cw_assert(mq_get(&mq, &t) == false);
312 cw_assert(t == k);
313 cw_assert(mq_get(&mq, &t) == false);
314 cw_assert(t == i);
315 cw_assert(mq_tryget(&mq, &t));
316
317 mq_delete(&mq);
318 }
319 {
320 cw_mq_t mq;
321 uint16_t i = 1, j = 2, k = 3, t;
322
323 mq_new(&mq, cw_g_mema, sizeof(uint16_t));
324
325 cw_assert(mq_tryget(&mq, &t));
326 cw_assert(mq_put(&mq, i) == 0);
327 cw_assert(mq_get(&mq, &t) == false);
328 cw_assert(t == i);
329 cw_assert(mq_tryget(&mq, &t));
330
331 cw_assert(mq_put(&mq, i) == 0);
332 cw_assert(mq_put(&mq, j) == 0);
333 cw_assert(mq_put(&mq, k) == 0);
334 cw_assert(mq_get(&mq, &t) == false);
335 cw_assert(t == i);
336 cw_assert(mq_put(&mq, i) == 0);
337 cw_assert(mq_get(&mq, &t) == false);
338 cw_assert(t == j);
339 cw_assert(mq_get(&mq, &t) == false);
340 cw_assert(t == k);
341 cw_assert(mq_get(&mq, &t) == false);
342 cw_assert(t == i);
343 cw_assert(mq_tryget(&mq, &t));
344
345 mq_delete(&mq);
346 }
347 {
348 cw_mq_t mq;
349 uint32_t i = 1, j = 2, k = 3, t;
350
351 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
352
353 cw_assert(mq_tryget(&mq, &t));
354 cw_assert(mq_put(&mq, i) == 0);
355 cw_assert(mq_get(&mq, &t) == false);
356 cw_assert(t == i);
357 cw_assert(mq_tryget(&mq, &t));
358
359 cw_assert(mq_put(&mq, i) == 0);
360 cw_assert(mq_put(&mq, j) == 0);
361 cw_assert(mq_put(&mq, k) == 0);
362 cw_assert(mq_get(&mq, &t) == false);
363 cw_assert(t == i);
364 cw_assert(mq_put(&mq, i) == 0);
365 cw_assert(mq_get(&mq, &t) == false);
366 cw_assert(t == j);
367 cw_assert(mq_get(&mq, &t) == false);
368 cw_assert(t == k);
369 cw_assert(mq_get(&mq, &t) == false);
370 cw_assert(t == i);
371 cw_assert(mq_tryget(&mq, &t));
372
373 mq_delete(&mq);
374 }
375 {
376 cw_mq_t mq;
377 uint64_t i = 1, j = 2, k = 3, t;
378
379 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
380
381 cw_assert(mq_tryget(&mq, &t));
382 cw_assert(mq_put(&mq, i) == 0);
383 cw_assert(mq_get(&mq, &t) == false);
384 cw_assert(t == i);
385 cw_assert(mq_tryget(&mq, &t));
386
387 cw_assert(mq_put(&mq, i) == 0);
388 cw_assert(mq_put(&mq, j) == 0);
389 cw_assert(mq_put(&mq, k) == 0);
390 cw_assert(mq_get(&mq, &t) == false);
391 cw_assert(t == i);
392 cw_assert(mq_put(&mq, i) == 0);
393 cw_assert(mq_get(&mq, &t) == false);
394 cw_assert(t == j);
395 cw_assert(mq_get(&mq, &t) == false);
396 cw_assert(t == k);
397 cw_assert(mq_get(&mq, &t) == false);
398 cw_assert(t == i);
399 cw_assert(mq_tryget(&mq, &t));
400
401 mq_delete(&mq);
402 }
403
404 /* mq_get_start(), mq_get_stop(), mq_tryget(), mq_put(). */
405 {
406 cw_mq_t mq;
407 uint8_t i = 1, j = 2, k = 3, t;
408
409 mq_new(&mq, cw_g_mema, sizeof(uint8_t));
410
411 cw_assert(mq_get_stop(&mq) == false);
412 cw_assert(mq_get_stop(&mq));
413 cw_assert(mq_tryget(&mq, &t));
414
415 cw_assert(mq_get_start(&mq) == false);
416 cw_assert(mq_get_start(&mq));
417 cw_assert(mq_tryget(&mq, &t));
418
419 cw_assert(mq_put(&mq, i) == 0);
420
421 cw_assert(mq_get_stop(&mq) == false);
422 cw_assert(mq_get_stop(&mq));
423 cw_assert(mq_tryget(&mq, &t));
424 cw_assert(mq_get(&mq, &t));
425
426 cw_assert(mq_get_start(&mq) == false);
427 cw_assert(mq_get_start(&mq));
428 cw_assert(mq_tryget(&mq, &t) == false);
429 cw_assert(t == i);
430 cw_assert(mq_tryget(&mq, &t));
431
432 cw_assert(mq_put(&mq, i) == 0);
433 cw_assert(mq_put(&mq, j) == 0);
434 cw_assert(mq_put(&mq, k) == 0);
435
436 mq_delete(&mq);
437 }
438 {
439 cw_mq_t mq;
440 uint16_t i = 1, j = 2, k = 3, t;
441
442 mq_new(&mq, cw_g_mema, sizeof(uint16_t));
443
444 cw_assert(mq_get_stop(&mq) == false);
445 cw_assert(mq_get_stop(&mq));
446 cw_assert(mq_tryget(&mq, &t));
447
448 cw_assert(mq_get_start(&mq) == false);
449 cw_assert(mq_get_start(&mq));
450 cw_assert(mq_tryget(&mq, &t));
451
452 cw_assert(mq_put(&mq, i) == 0);
453
454 cw_assert(mq_get_stop(&mq) == false);
455 cw_assert(mq_get_stop(&mq));
456 cw_assert(mq_tryget(&mq, &t));
457 cw_assert(mq_get(&mq, &t));
458
459 cw_assert(mq_get_start(&mq) == false);
460 cw_assert(mq_get_start(&mq));
461 cw_assert(mq_tryget(&mq, &t) == false);
462 cw_assert(t == i);
463 cw_assert(mq_tryget(&mq, &t));
464
465 cw_assert(mq_put(&mq, i) == 0);
466 cw_assert(mq_put(&mq, j) == 0);
467 cw_assert(mq_put(&mq, k) == 0);
468
469 mq_delete(&mq);
470 }
471 {
472 cw_mq_t mq;
473 uint32_t i = 1, j = 2, k = 3, t;
474
475 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
476
477 cw_assert(mq_get_stop(&mq) == false);
478 cw_assert(mq_get_stop(&mq));
479 cw_assert(mq_tryget(&mq, &t));
480
481 cw_assert(mq_get_start(&mq) == false);
482 cw_assert(mq_get_start(&mq));
483 cw_assert(mq_tryget(&mq, &t));
484
485 cw_assert(mq_put(&mq, i) == 0);
486
487 cw_assert(mq_get_stop(&mq) == false);
488 cw_assert(mq_get_stop(&mq));
489 cw_assert(mq_tryget(&mq, &t));
490 cw_assert(mq_get(&mq, &t));
491
492 cw_assert(mq_get_start(&mq) == false);
493 cw_assert(mq_get_start(&mq));
494 cw_assert(mq_tryget(&mq, &t) == false);
495 cw_assert(t == i);
496 cw_assert(mq_tryget(&mq, &t));
497
498 cw_assert(mq_put(&mq, i) == 0);
499 cw_assert(mq_put(&mq, j) == 0);
500 cw_assert(mq_put(&mq, k) == 0);
501
502 mq_delete(&mq);
503 }
504 {
505 cw_mq_t mq;
506 uint64_t i = 1, j = 2, k = 3, t;
507
508 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
509
510 cw_assert(mq_get_stop(&mq) == false);
511 cw_assert(mq_get_stop(&mq));
512 cw_assert(mq_tryget(&mq, &t));
513
514 cw_assert(mq_get_start(&mq) == false);
515 cw_assert(mq_get_start(&mq));
516 cw_assert(mq_tryget(&mq, &t));
517
518 cw_assert(mq_put(&mq, i) == 0);
519
520 cw_assert(mq_get_stop(&mq) == false);
521 cw_assert(mq_get_stop(&mq));
522 cw_assert(mq_tryget(&mq, &t));
523 cw_assert(mq_get(&mq, &t));
524
525 cw_assert(mq_get_start(&mq) == false);
526 cw_assert(mq_get_start(&mq));
527 cw_assert(mq_tryget(&mq, &t) == false);
528 cw_assert(t == i);
529 cw_assert(mq_tryget(&mq, &t));
530
531 cw_assert(mq_put(&mq, i) == 0);
532 cw_assert(mq_put(&mq, j) == 0);
533 cw_assert(mq_put(&mq, k) == 0);
534
535 mq_delete(&mq);
536 }
537
538 /* mq_put_start(), mq_put_stop(), mq_tryget(), mq_put(). */
539 {
540 cw_mq_t mq;
541 uint8_t i = 1, j = 2, k = 3, t;
542
543 mq_new(&mq, cw_g_mema, sizeof(uint8_t));
544
545 cw_assert(mq_tryget(&mq, &t));
546 cw_assert(mq_put_stop(&mq) == false);
547 cw_assert(mq_put_stop(&mq));
548 cw_assert(mq_tryget(&mq, &t));
549
550 cw_assert(1 == mq_put(&mq, i));
551
552 cw_assert(mq_put_start(&mq) == false);
553 cw_assert(mq_put_start(&mq));
554 cw_assert(mq_put(&mq, i) == 0);
555 cw_assert(mq_put(&mq, j) == 0);
556
557 cw_assert(mq_put_stop(&mq) == false);
558 cw_assert(mq_put_stop(&mq));
559 cw_assert(mq_put(&mq, k) == 1);
560
561 cw_assert(mq_tryget(&mq, &t) == false);
562 cw_assert(t == i);
563 cw_assert(mq_tryget(&mq, &t) == false);
564 cw_assert(t == j);
565 cw_assert(mq_tryget(&mq, &t));
566
567 mq_delete(&mq);
568 }
569 {
570 cw_mq_t mq;
571 uint16_t i = 1, j = 2, k = 3, t;
572
573 mq_new(&mq, cw_g_mema, sizeof(uint16_t));
574
575 cw_assert(mq_tryget(&mq, &t));
576 cw_assert(mq_put_stop(&mq) == false);
577 cw_assert(mq_put_stop(&mq));
578 cw_assert(mq_tryget(&mq, &t));
579
580 cw_assert(1 == mq_put(&mq, i));
581
582 cw_assert(mq_put_start(&mq) == false);
583 cw_assert(mq_put_start(&mq));
584 cw_assert(mq_put(&mq, i) == 0);
585 cw_assert(mq_put(&mq, j) == 0);
586
587 cw_assert(mq_put_stop(&mq) == false);
588 cw_assert(mq_put_stop(&mq));
589 cw_assert(mq_put(&mq, k) == 1);
590
591 cw_assert(mq_tryget(&mq, &t) == false);
592 cw_assert(t == i);
593 cw_assert(mq_tryget(&mq, &t) == false);
594 cw_assert(t == j);
595 cw_assert(mq_tryget(&mq, &t));
596
597 mq_delete(&mq);
598 }
599 {
600 cw_mq_t mq;
601 uint32_t i = 1, j = 2, k = 3, t;
602
603 mq_new(&mq, cw_g_mema, sizeof(uint32_t));
604
605 cw_assert(mq_tryget(&mq, &t));
606 cw_assert(mq_put_stop(&mq) == false);
607 cw_assert(mq_put_stop(&mq));
608 cw_assert(mq_tryget(&mq, &t));
609
610 cw_assert(1 == mq_put(&mq, i));
611
612 cw_assert(mq_put_start(&mq) == false);
613 cw_assert(mq_put_start(&mq));
614 cw_assert(mq_put(&mq, i) == 0);
615 cw_assert(mq_put(&mq, j) == 0);
616
617 cw_assert(mq_put_stop(&mq) == false);
618 cw_assert(mq_put_stop(&mq));
619 cw_assert(mq_put(&mq, k) == 1);
620
621 cw_assert(mq_tryget(&mq, &t) == false);
622 cw_assert(t == i);
623 cw_assert(mq_tryget(&mq, &t) == false);
624 cw_assert(t == j);
625 cw_assert(mq_tryget(&mq, &t));
626
627 mq_delete(&mq);
628 }
629 {
630 cw_mq_t mq;
631 uint64_t i = 1, j = 2, k = 3, t;
632
633 mq_new(&mq, cw_g_mema, sizeof(uint64_t));
634
635 cw_assert(mq_tryget(&mq, &t));
636 cw_assert(mq_put_stop(&mq) == false);
637 cw_assert(mq_put_stop(&mq));
638 cw_assert(mq_tryget(&mq, &t));
639
640 cw_assert(1 == mq_put(&mq, i));
641
642 cw_assert(mq_put_start(&mq) == false);
643 cw_assert(mq_put_start(&mq));
644 cw_assert(mq_put(&mq, i) == 0);
645 cw_assert(mq_put(&mq, j) == 0);
646
647 cw_assert(mq_put_stop(&mq) == false);
648 cw_assert(mq_put_stop(&mq));
649 cw_assert(mq_put(&mq, k) == 1);
650
651 cw_assert(mq_tryget(&mq, &t) == false);
652 cw_assert(t == i);
653 cw_assert(mq_tryget(&mq, &t) == false);
654 cw_assert(t == j);
655 cw_assert(mq_tryget(&mq, &t));
656
657 mq_delete(&mq);
658 }
659
660 fprintf(stderr, "Test end\n");
661 libonyx_shutdown();
662 return 0;
663 }
664