← Back to branch summary

~ubuntu-branches/ubuntu/precise/libpgm/precise

« back to all changes in this revision

Viewing changes to openpgm/pgm/thread_unittest.c

  • Committer: Bazaar Package Importer
  • Author(s): Gabriel de Perthuis
  • Date: 2011-04-07 16:48:52 UTC
  • Revision ID: james.westby@ubuntu.com-20110407164852-8uamem42ojeptj6l
Tags: upstream-5.1.116~dfsg
Import upstream version 5.1.116~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
openpgm/pgm/thread_unittest.c
 
1
/* vim:ts=8:sts=8:sw=4:noai:noexpandtab
 
2
 *
 
3
 * unit tests for concurrency operations.
 
4
 *
 
5
 * Copyright (c) 2011 Miru Limited.
 
6
 *
 
7
 * This library is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public
 
9
 * License as published by the Free Software Foundation; either
 
10
 * version 2.1 of the License, or (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this library; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 */
 
21
 
 
22
 
 
23
#include <stdint.h>
 
24
#include <signal.h>
 
25
#include <stdlib.h>
 
26
#include <glib.h>
 
27
#include <check.h>
 
28
 
 
29
 
 
30
/* mock state */
 
31
 
 
32
 
 
33
/* mock functions for external references */
 
34
 
 
35
#include "thread.c"
 
36
 
 
37
 
 
38
static
 
39
void
 
40
mock_setup (void)
 
41
{
 
42
        pgm_thread_init ();
 
43
}
 
44
 
 
45
static
 
46
void
 
47
mock_teardown (void)
 
48
{
 
49
        pgm_thread_shutdown ();
 
50
}
 
51
 
 
52
PGM_GNUC_INTERNAL
 
53
int
 
54
pgm_get_nprocs (void)
 
55
{
 
56
        return 1;
 
57
}
 
58
 
 
59
/* target:
 
60
 *      void
 
61
 *      pgm_thread_init (void)
 
62
 */
 
63
 
 
64
START_TEST (test_init_pass_001)
 
65
{
 
66
        pgm_thread_init ();
 
67
#ifdef PGM_CHECK_NOFORK
 
68
        pgm_thread_shutdown ();
 
69
#endif
 
70
}
 
71
END_TEST
 
72
 
 
73
/* target:
 
74
 *      void
 
75
 *      pgm_thread_shutdown (void)
 
76
 */
 
77
 
 
78
START_TEST (test_shutdown_pass_001)
 
79
{
 
80
/* unreferences are emitted as warnings */
 
81
        pgm_thread_shutdown ();
 
82
        pgm_thread_shutdown ();
 
83
 
 
84
        pgm_thread_init ();
 
85
        pgm_thread_shutdown ();
 
86
}
 
87
END_TEST
 
88
 
 
89
/* target:
 
90
 *      void
 
91
 *      pgm_mutex_init (pgm_mutex_t* mutex)
 
92
 */
 
93
 
 
94
START_TEST (test_mutex_init_pass_001)
 
95
{
 
96
        pgm_mutex_t mutex;
 
97
        pgm_mutex_init (&mutex);
 
98
#ifdef PGM_CHECK_NOFORK
 
99
        pgm_mutex_free (&mutex);
 
100
#endif
 
101
}
 
102
END_TEST
 
103
 
 
104
/* target:
 
105
 *      void
 
106
 *      pgm_mutex_free (pgm_mutex_t* mutex)
 
107
 */
 
108
 
 
109
START_TEST (test_mutex_free_pass_001)
 
110
{
 
111
        pgm_mutex_t mutex;
 
112
        pgm_mutex_init (&mutex);
 
113
        pgm_mutex_free (&mutex);
 
114
}
 
115
END_TEST
 
116
 
 
117
/* target:
 
118
 *      void
 
119
 *      pgm_mutex_lock (pgm_mutex_t* mutex)
 
120
 */
 
121
 
 
122
START_TEST (test_mutex_lock_pass_001)
 
123
{
 
124
        pgm_mutex_t mutex;
 
125
        pgm_mutex_init (&mutex);
 
126
        pgm_mutex_lock (&mutex);
 
127
#ifdef PGM_CHECK_NOFORK
 
128
        pgm_mutex_unlock (&mutex);
 
129
        pgm_mutex_free (&mutex);
 
130
#endif
 
131
}
 
132
END_TEST
 
133
 
 
134
/* target:
 
135
 *      void
 
136
 *      pgm_mutex_unlock (pgm_mutex_t* mutex)
 
137
 */
 
138
 
 
139
START_TEST (test_mutex_unlock_pass_001)
 
140
{
 
141
        pgm_mutex_t mutex;
 
142
        pgm_mutex_init (&mutex);
 
143
        pgm_mutex_lock (&mutex);
 
144
        pgm_mutex_unlock (&mutex);
 
145
        pgm_mutex_free (&mutex);
 
146
}
 
147
END_TEST
 
148
 
 
149
/* target:
 
150
 *      bool
 
151
 *      pgm_mutex_trylock (pgm_mutex_t* mutex)
 
152
 */
 
153
 
 
154
START_TEST (test_mutex_trylock_pass_001)
 
155
{
 
156
        pgm_mutex_t mutex;
 
157
        pgm_mutex_init (&mutex);
 
158
        fail_unless (TRUE == pgm_mutex_trylock (&mutex), "initial state lock");
 
159
#ifndef _WIN32
 
160
        fail_unless (FALSE == pgm_mutex_trylock (&mutex), "locked mutex");
 
161
#else
 
162
/* only works in separate threads */
 
163
        fail_unless (TRUE == pgm_mutex_trylock (&mutex), "locked mutex");
 
164
#endif
 
165
        pgm_mutex_unlock (&mutex);
 
166
        fail_unless (TRUE == pgm_mutex_trylock (&mutex), "unlocked mutex");
 
167
        pgm_mutex_unlock (&mutex);
 
168
        pgm_mutex_free (&mutex);
 
169
}
 
170
END_TEST
 
171
 
 
172
/* target:
 
173
 *      void
 
174
 *      pgm_spinlock_init (pgm_spinlock_t* spinlock)
 
175
 */
 
176
 
 
177
START_TEST (test_spinlock_init_pass_001)
 
178
{
 
179
        pgm_spinlock_t spinlock;
 
180
        pgm_spinlock_init (&spinlock);
 
181
#ifdef PGM_CHECK_NOFORK
 
182
        pgm_spinlock_free (&spinlock);
 
183
#endif
 
184
}
 
185
END_TEST
 
186
 
 
187
/* target:
 
188
 *      void
 
189
 *      pgm_spinlock_free (pgm_spinlock_t* spinlock)
 
190
 */
 
191
 
 
192
START_TEST (test_spinlock_free_pass_001)
 
193
{
 
194
        pgm_spinlock_t spinlock;
 
195
        pgm_spinlock_init (&spinlock);
 
196
        pgm_spinlock_free (&spinlock);
 
197
}
 
198
END_TEST
 
199
 
 
200
/* target:
 
201
 *      void
 
202
 *      pgm_spinlock_lock (pgm_spinlock_t* spinlock)
 
203
 */
 
204
 
 
205
START_TEST (test_spinlock_lock_pass_001)
 
206
{
 
207
        pgm_spinlock_t spinlock;
 
208
        pgm_spinlock_init (&spinlock);
 
209
        pgm_spinlock_lock (&spinlock);
 
210
#ifdef PGM_CHECK_NOFORK
 
211
        pgm_spinlock_unlock (&spinlock);
 
212
        pgm_spinlock_free (&spinlock);
 
213
#endif
 
214
}
 
215
END_TEST
 
216
 
 
217
/* target:
 
218
 *      void
 
219
 *      pgm_spinlock_unlock (pgm_spinlock_t* spinlock)
 
220
 */
 
221
 
 
222
START_TEST (test_spinlock_unlock_pass_001)
 
223
{
 
224
        pgm_spinlock_t spinlock;
 
225
        pgm_spinlock_init (&spinlock);
 
226
        pgm_spinlock_lock (&spinlock);
 
227
        pgm_spinlock_unlock (&spinlock);
 
228
        pgm_spinlock_free (&spinlock);
 
229
}
 
230
END_TEST
 
231
 
 
232
/* target:
 
233
 *      bool
 
234
 *      pgm_spinlock_trylock (pgm_spinlock_t* spinlock)
 
235
 */
 
236
 
 
237
START_TEST (test_spinlock_trylock_pass_001)
 
238
{
 
239
        pgm_spinlock_t spinlock;
 
240
        pgm_spinlock_init (&spinlock);
 
241
        fail_unless (TRUE == pgm_spinlock_trylock (&spinlock), "initial state lock");
 
242
        fail_unless (FALSE == pgm_spinlock_trylock (&spinlock), "locked spinlock");
 
243
        pgm_spinlock_unlock (&spinlock);
 
244
        fail_unless (TRUE == pgm_spinlock_trylock (&spinlock), "unlocked spinlock");
 
245
        pgm_spinlock_unlock (&spinlock);
 
246
        pgm_spinlock_free (&spinlock);
 
247
}
 
248
END_TEST
 
249
 
 
250
/* target:
 
251
 *      void
 
252
 *      pgm_rwlock_init (pgm_rwlock_t* rwlock)
 
253
 */
 
254
 
 
255
START_TEST (test_rwlock_init_pass_001)
 
256
{
 
257
        pgm_rwlock_t rwlock;
 
258
        pgm_rwlock_init (&rwlock);
 
259
#ifdef PGM_CHECK_NOFORK
 
260
        pgm_rwlock_free (&rwlock);
 
261
#endif
 
262
}
 
263
END_TEST
 
264
 
 
265
/* target:
 
266
 *      void
 
267
 *      pgm_rwlock_free (pgm_rwlock_t* rwlock)
 
268
 */
 
269
 
 
270
START_TEST (test_rwlock_free_pass_001)
 
271
{
 
272
        pgm_rwlock_t rwlock;
 
273
        pgm_rwlock_init (&rwlock);
 
274
        pgm_rwlock_free (&rwlock);
 
275
}
 
276
END_TEST
 
277
 
 
278
/* target:
 
279
 *      void
 
280
 *      pgm_rwlock_reader_lock (pgm_rwlock_t* rwlock)
 
281
 */
 
282
 
 
283
START_TEST (test_rwlock_reader_lock_pass_001)
 
284
{
 
285
        pgm_rwlock_t rwlock;
 
286
        pgm_rwlock_init (&rwlock);
 
287
/* multiple readers permitted */
 
288
        pgm_rwlock_reader_lock (&rwlock);
 
289
        pgm_rwlock_reader_lock (&rwlock);
 
290
#ifdef PGM_CHECK_NOFORK
 
291
        pgm_rwlock_reader_unlock (&rwlock);
 
292
        pgm_rwlock_reader_unlock (&rwlock);
 
293
        pgm_rwlock_free (&rwlock);
 
294
#endif
 
295
}
 
296
END_TEST
 
297
 
 
298
/* target:
 
299
 *      void
 
300
 *      pgm_rwlock_reader_unlock (pgm_rwlock_t* rwlock)
 
301
 */
 
302
 
 
303
START_TEST (test_rwlock_reader_unlock_pass_001)
 
304
{
 
305
        pgm_rwlock_t rwlock;
 
306
        pgm_rwlock_init (&rwlock);
 
307
/* single lock */
 
308
        pgm_rwlock_reader_lock (&rwlock);
 
309
        pgm_rwlock_reader_unlock (&rwlock);
 
310
/* multiple lock */
 
311
        pgm_rwlock_reader_lock (&rwlock);
 
312
        pgm_rwlock_reader_lock (&rwlock);
 
313
        pgm_rwlock_reader_unlock (&rwlock);
 
314
        pgm_rwlock_reader_unlock (&rwlock);
 
315
        pgm_rwlock_free (&rwlock);
 
316
}
 
317
END_TEST
 
318
 
 
319
/* target:
 
320
 *      bool
 
321
 *      pgm_rwlock_reader_trylock (pgm_rwlock_t* rwlock)
 
322
 */
 
323
 
 
324
START_TEST (test_rwlock_reader_trylock_pass_001)
 
325
{
 
326
        pgm_rwlock_t rwlock;
 
327
        pgm_rwlock_init (&rwlock);
 
328
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "initial state lock");
 
329
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader locked");
 
330
        pgm_rwlock_reader_unlock (&rwlock);
 
331
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader unlocked");
 
332
        pgm_rwlock_reader_unlock (&rwlock);
 
333
        pgm_rwlock_reader_unlock (&rwlock);
 
334
        pgm_rwlock_free (&rwlock);
 
335
}
 
336
END_TEST
 
337
 
 
338
/* target:
 
339
 *      void
 
340
 *      pgm_rwlock_writer_lock (pgm_rwlock_t* rwlock)
 
341
 */
 
342
 
 
343
START_TEST (test_rwlock_writer_lock_pass_001)
 
344
{
 
345
        pgm_rwlock_t rwlock;
 
346
        pgm_rwlock_init (&rwlock);
 
347
/* only single writer permitted */
 
348
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "initial state lock");
 
349
        pgm_rwlock_reader_unlock (&rwlock);
 
350
        pgm_rwlock_writer_lock (&rwlock);
 
351
        fail_unless (FALSE == pgm_rwlock_reader_trylock (&rwlock), "writer locked");
 
352
#ifdef PGM_CHECK_NOFORK
 
353
        pgm_rwlock_writer_unlock (&rwlock);
 
354
        pgm_rwlock_free (&rwlock);
 
355
#endif
 
356
}
 
357
END_TEST
 
358
 
 
359
/* target:
 
360
 *      void
 
361
 *      pgm_rwlock_writer_unlock (pgm_rwlock_t* rwlock)
 
362
 */
 
363
 
 
364
START_TEST (test_rwlock_writer_unlock_pass_001)
 
365
{
 
366
        pgm_rwlock_t rwlock;
 
367
        pgm_rwlock_init (&rwlock);
 
368
/* single lock */
 
369
        pgm_rwlock_writer_lock (&rwlock);
 
370
        fail_unless (FALSE == pgm_rwlock_reader_trylock (&rwlock), "writer locked");
 
371
        pgm_rwlock_writer_unlock (&rwlock);
 
372
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "writer unlocked");
 
373
        pgm_rwlock_reader_unlock (&rwlock);
 
374
        pgm_rwlock_writer_lock (&rwlock);
 
375
        fail_unless (FALSE == pgm_rwlock_reader_trylock (&rwlock), "writer locked");
 
376
        pgm_rwlock_writer_unlock (&rwlock);
 
377
        pgm_rwlock_free (&rwlock);
 
378
}
 
379
END_TEST
 
380
 
 
381
/* target:
 
382
 *      bool
 
383
 *      pgm_rwlock_writer_trylock (pgm_rwlock_t* rwlock)
 
384
 */
 
385
 
 
386
START_TEST (test_rwlock_writer_trylock_pass_001)
 
387
{
 
388
        pgm_rwlock_t rwlock;
 
389
        pgm_rwlock_init (&rwlock);
 
390
/* clean lock */
 
391
        fail_unless (TRUE == pgm_rwlock_writer_trylock (&rwlock), "writer lock");
 
392
        pgm_rwlock_writer_unlock (&rwlock);
 
393
/* blocked writer */
 
394
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
395
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
396
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
397
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
398
        pgm_rwlock_reader_unlock (&rwlock);
 
399
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
400
        pgm_rwlock_reader_unlock (&rwlock);
 
401
/* blocked reader */
 
402
        fail_unless (TRUE == pgm_rwlock_writer_trylock (&rwlock), "writer lock");
 
403
        fail_unless (FALSE == pgm_rwlock_reader_trylock (&rwlock), "reader on writer locked");
 
404
        fail_unless (FALSE == pgm_rwlock_reader_trylock (&rwlock), "reader on writer locked");
 
405
        pgm_rwlock_writer_unlock (&rwlock);
 
406
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
407
        pgm_rwlock_reader_unlock (&rwlock);
 
408
/* two step */
 
409
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
410
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
411
        pgm_rwlock_reader_unlock (&rwlock);
 
412
        fail_unless (TRUE == pgm_rwlock_reader_trylock (&rwlock), "reader lock");
 
413
        pgm_rwlock_reader_unlock (&rwlock);
 
414
        pgm_rwlock_reader_unlock (&rwlock);
 
415
/* wrapped around regular reader locks */
 
416
        pgm_rwlock_reader_lock (&rwlock);
 
417
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
418
        pgm_rwlock_reader_lock (&rwlock);
 
419
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
420
        pgm_rwlock_reader_unlock (&rwlock);
 
421
        fail_unless (FALSE == pgm_rwlock_writer_trylock (&rwlock), "writer on reader locked");
 
422
        pgm_rwlock_reader_unlock (&rwlock);
 
423
        fail_unless (TRUE == pgm_rwlock_writer_trylock (&rwlock), "writer lock");
 
424
        pgm_rwlock_writer_unlock (&rwlock);
 
425
 
 
426
        pgm_rwlock_free (&rwlock);
 
427
}
 
428
END_TEST
 
429
 
 
430
static
 
431
Suite*
 
432
make_test_suite (void)
 
433
{
 
434
        Suite* s;
 
435
 
 
436
        s = suite_create (__FILE__);
 
437
 
 
438
        TCase* tc_init = tcase_create ("init");
 
439
        suite_add_tcase (s, tc_init);
 
440
        tcase_add_test (tc_init, test_init_pass_001);
 
441
 
 
442
        TCase* tc_shutdown = tcase_create ("shutdown");
 
443
        suite_add_tcase (s, tc_shutdown);
 
444
        tcase_add_test (tc_shutdown, test_shutdown_pass_001);
 
445
 
 
446
        return s;
 
447
}
 
448
 
 
449
static
 
450
Suite*
 
451
make_mutex_suite (void)
 
452
{
 
453
        Suite* s;
 
454
 
 
455
        s = suite_create ("mutex");
 
456
 
 
457
        TCase* tc_init = tcase_create ("init");
 
458
        tcase_add_checked_fixture (tc_init, mock_setup, mock_teardown);
 
459
        suite_add_tcase (s, tc_init);
 
460
        tcase_add_test (tc_init, test_mutex_init_pass_001);
 
461
 
 
462
        TCase* tc_free = tcase_create ("free");
 
463
        tcase_add_checked_fixture (tc_free, mock_setup, mock_teardown);
 
464
        suite_add_tcase (s, tc_free);
 
465
        tcase_add_test (tc_free, test_mutex_free_pass_001);
 
466
 
 
467
        TCase* tc_lock = tcase_create ("lock");
 
468
        tcase_add_checked_fixture (tc_lock, mock_setup, mock_teardown);
 
469
        suite_add_tcase (s, tc_lock);
 
470
        tcase_add_test (tc_lock, test_mutex_lock_pass_001);
 
471
 
 
472
        TCase* tc_unlock = tcase_create ("unlock");
 
473
        tcase_add_checked_fixture (tc_unlock, mock_setup, mock_teardown);
 
474
        suite_add_tcase (s, tc_unlock);
 
475
        tcase_add_test (tc_unlock, test_mutex_unlock_pass_001);
 
476
 
 
477
        TCase* tc_trylock = tcase_create ("trylock");
 
478
        tcase_add_checked_fixture (tc_trylock, mock_setup, mock_teardown);
 
479
        suite_add_tcase (s, tc_trylock);
 
480
        tcase_add_test (tc_trylock, test_mutex_trylock_pass_001);
 
481
 
 
482
        return s;
 
483
}
 
484
 
 
485
static
 
486
Suite*
 
487
make_spinlock_suite (void)
 
488
{
 
489
        Suite* s;
 
490
 
 
491
        s = suite_create ("spinlock");
 
492
 
 
493
        TCase* tc_init = tcase_create ("init");
 
494
        tcase_add_checked_fixture (tc_init, mock_setup, mock_teardown);
 
495
        suite_add_tcase (s, tc_init);
 
496
        tcase_add_test (tc_init, test_spinlock_init_pass_001);
 
497
 
 
498
        TCase* tc_free = tcase_create ("free");
 
499
        tcase_add_checked_fixture (tc_free, mock_setup, mock_teardown);
 
500
        suite_add_tcase (s, tc_free);
 
501
        tcase_add_test (tc_free, test_spinlock_free_pass_001);
 
502
 
 
503
        TCase* tc_lock = tcase_create ("lock");
 
504
        tcase_add_checked_fixture (tc_lock, mock_setup, mock_teardown);
 
505
        suite_add_tcase (s, tc_lock);
 
506
        tcase_add_test (tc_lock, test_spinlock_lock_pass_001);
 
507
 
 
508
        TCase* tc_unlock = tcase_create ("unlock");
 
509
        tcase_add_checked_fixture (tc_unlock, mock_setup, mock_teardown);
 
510
        suite_add_tcase (s, tc_unlock);
 
511
        tcase_add_test (tc_unlock, test_spinlock_unlock_pass_001);
 
512
 
 
513
        TCase* tc_trylock = tcase_create ("trylock");
 
514
        tcase_add_checked_fixture (tc_trylock, mock_setup, mock_teardown);
 
515
        suite_add_tcase (s, tc_trylock);
 
516
        tcase_add_test (tc_trylock, test_spinlock_trylock_pass_001);
 
517
 
 
518
        return s;
 
519
}
 
520
 
 
521
static
 
522
Suite*
 
523
make_rwlock_suite (void)
 
524
{
 
525
        Suite* s;
 
526
 
 
527
        s = suite_create ("rwlock");
 
528
 
 
529
        TCase* tc_init = tcase_create ("init");
 
530
        tcase_add_checked_fixture (tc_init, mock_setup, mock_teardown);
 
531
        suite_add_tcase (s, tc_init);
 
532
        tcase_add_test (tc_init, test_rwlock_init_pass_001);
 
533
 
 
534
        TCase* tc_free = tcase_create ("free");
 
535
        tcase_add_checked_fixture (tc_free, mock_setup, mock_teardown);
 
536
        suite_add_tcase (s, tc_free);
 
537
        tcase_add_test (tc_free, test_rwlock_free_pass_001);
 
538
 
 
539
        TCase* tc_reader_lock = tcase_create ("reader: lock");
 
540
        tcase_add_checked_fixture (tc_reader_lock, mock_setup, mock_teardown);
 
541
        suite_add_tcase (s, tc_reader_lock);
 
542
        tcase_add_test (tc_reader_lock, test_rwlock_reader_lock_pass_001);
 
543
 
 
544
        TCase* tc_reader_unlock = tcase_create ("reader: unlock");
 
545
        tcase_add_checked_fixture (tc_reader_unlock, mock_setup, mock_teardown);
 
546
        suite_add_tcase (s, tc_reader_unlock);
 
547
        tcase_add_test (tc_reader_unlock, test_rwlock_reader_unlock_pass_001);
 
548
 
 
549
        TCase* tc_reader_trylock = tcase_create ("reader: trylock");
 
550
        tcase_add_checked_fixture (tc_reader_trylock, mock_setup, mock_teardown);
 
551
        suite_add_tcase (s, tc_reader_trylock);
 
552
        tcase_add_test (tc_reader_trylock, test_rwlock_reader_trylock_pass_001);
 
553
 
 
554
        TCase* tc_writer_lock = tcase_create ("writer: lock");
 
555
        tcase_add_checked_fixture (tc_writer_lock, mock_setup, mock_teardown);
 
556
        suite_add_tcase (s, tc_writer_lock);
 
557
        tcase_add_test (tc_writer_lock, test_rwlock_writer_lock_pass_001);
 
558
 
 
559
        TCase* tc_writer_unlock = tcase_create ("writer: unlock");
 
560
        tcase_add_checked_fixture (tc_writer_unlock, mock_setup, mock_teardown);
 
561
        suite_add_tcase (s, tc_writer_unlock);
 
562
        tcase_add_test (tc_writer_unlock, test_rwlock_writer_unlock_pass_001);
 
563
 
 
564
        TCase* tc_writer_trylock = tcase_create ("writer: trylock");
 
565
        tcase_add_checked_fixture (tc_writer_trylock, mock_setup, mock_teardown);
 
566
        suite_add_tcase (s, tc_writer_trylock);
 
567
        tcase_add_test (tc_writer_trylock, test_rwlock_writer_trylock_pass_001);
 
568
 
 
569
        return s;
 
570
}
 
571
 
 
572
static
 
573
Suite*
 
574
make_master_suite (void)
 
575
{
 
576
        Suite* s = suite_create ("Master");
 
577
        return s;
 
578
}
 
579
 
 
580
int
 
581
main (void)
 
582
{
 
583
        pgm_messages_init();
 
584
        SRunner* sr = srunner_create (make_master_suite ());
 
585
        srunner_add_suite (sr, make_test_suite ());
 
586
        srunner_add_suite (sr, make_mutex_suite ());
 
587
        srunner_add_suite (sr, make_spinlock_suite ());
 
588
        srunner_add_suite (sr, make_rwlock_suite ());
 
589
        srunner_run_all (sr, CK_ENV);
 
590
        int number_failed = srunner_ntests_failed (sr);
 
591
        srunner_free (sr);
 
592
        pgm_messages_shutdown();
 
593
        return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 
594
}
 
595
 
 
596
/* eof */