Bug Summary

File:test/stress-test.c
Location:line 408, column 6
Description:Value stored to 'n_rects' is never read

Annotated Source Code

1#include "utils.h"
2
3#if 0
4#define fence_malloc malloc
5#define fence_free free
6#define make_random_bytes malloc
7#endif
8
9static const pixman_format_code_t image_formats[] =
10{
11 PIXMAN_a8r8g8b8,
12 PIXMAN_x8r8g8b8,
13 PIXMAN_r5g6b5,
14 PIXMAN_r3g3b2,
15 PIXMAN_a8,
16 PIXMAN_a8b8g8r8,
17 PIXMAN_x8b8g8r8,
18 PIXMAN_b8g8r8a8,
19 PIXMAN_b8g8r8x8,
20 PIXMAN_x14r6g6b6,
21 PIXMAN_r8g8b8,
22 PIXMAN_b8g8r8,
23 PIXMAN_r5g6b5,
24 PIXMAN_b5g6r5,
25 PIXMAN_x2r10g10b10,
26 PIXMAN_a2r10g10b10,
27 PIXMAN_x2b10g10r10,
28 PIXMAN_a2b10g10r10,
29 PIXMAN_a1r5g5b5,
30 PIXMAN_x1r5g5b5,
31 PIXMAN_a1b5g5r5,
32 PIXMAN_x1b5g5r5,
33 PIXMAN_a4r4g4b4,
34 PIXMAN_x4r4g4b4,
35 PIXMAN_a4b4g4r4,
36 PIXMAN_x4b4g4r4,
37 PIXMAN_a8,
38 PIXMAN_r3g3b2,
39 PIXMAN_b2g3r3,
40 PIXMAN_a2r2g2b2,
41 PIXMAN_a2b2g2r2,
42 PIXMAN_c8,
43 PIXMAN_g8,
44 PIXMAN_x4c4,
45 PIXMAN_x4g4,
46 PIXMAN_c4,
47 PIXMAN_g4,
48 PIXMAN_g1,
49 PIXMAN_x4a4,
50 PIXMAN_a4,
51 PIXMAN_r1g2b1,
52 PIXMAN_b1g2r1,
53 PIXMAN_a1r1g1b1,
54 PIXMAN_a1b1g1r1,
55 PIXMAN_a1
56};
57
58static pixman_filter_t filters[] =
59{
60 PIXMAN_FILTER_NEAREST,
61 PIXMAN_FILTER_BILINEAR,
62 PIXMAN_FILTER_FAST,
63 PIXMAN_FILTER_GOOD,
64 PIXMAN_FILTER_BEST,
65 PIXMAN_FILTER_CONVOLUTION
66};
67
68static int
69get_size (void)
70{
71 switch (lcg_rand_n (28))
72 {
73 case 0:
74 return 1;
75
76 case 1:
77 return 2;
78
79 default:
80 case 2:
81 return lcg_rand_n (200);
82
83 case 4:
84 return lcg_rand_n (2000) + 1000;
85
86 case 5:
87 return 65535;
88
89 case 6:
90 return 65536;
91
92 case 7:
93 return lcg_rand_N (64000) + 63000;
94 }
95}
96
97static void
98destroy (pixman_image_t *image, void *data)
99{
100 if (image->type == BITS && image->bits.free_me != image->bits.bits)
101 {
102 uint32_t *bits;
103
104 if (image->bits.bits != (void *)0x01)
105 {
106 bits = image->bits.bits;
107
108 if (image->bits.rowstride < 0)
109 bits -= (- image->bits.rowstride * (image->bits.height - 1));
110
111 fence_free (bits);
112 }
113 }
114
115 free (data);
116}
117
118static uint32_t
119real_reader (const void *src, int size)
120{
121 switch (size)
122 {
123 case 1:
124 return *(uint8_t *)src;
125 case 2:
126 return *(uint16_t *)src;
127 case 4:
128 return *(uint32_t *)src;
129 default:
130 assert (0)((0) ? (void) (0) : __assert_fail ("0", "stress-test.c", 130,
__PRETTY_FUNCTION__));
131 break;
132 }
133}
134
135static void
136real_writer (void *src, uint32_t value, int size)
137{
138 switch (size)
139 {
140 case 1:
141 *(uint8_t *)src = value;
142 break;
143
144 case 2:
145 *(uint16_t *)src = value;
146 break;
147
148 case 4:
149 *(uint32_t *)src = value;
150 break;
151
152 default:
153 assert (0)((0) ? (void) (0) : __assert_fail ("0", "stress-test.c", 153,
__PRETTY_FUNCTION__));
154 break;
155 }
156}
157
158static uint32_t
159fake_reader (const void *src, int size)
160{
161 uint32_t r = lcg_rand_u32 ();
162
163 assert (size == 1 || size == 2 || size == 4)((size == 1 || size == 2 || size == 4) ? (void) (0) : __assert_fail
("size == 1 || size == 2 || size == 4", "stress-test.c", 163
, __PRETTY_FUNCTION__));
164 return r & ((1 << (size * 8)) - 1);
165}
166
167static void
168fake_writer (void *src, uint32_t value, int size)
169{
170 assert (size == 1 || size == 2 || size == 4)((size == 1 || size == 2 || size == 4) ? (void) (0) : __assert_fail
("size == 1 || size == 2 || size == 4", "stress-test.c", 170
, __PRETTY_FUNCTION__));
171}
172
173static int32_t
174log_rand (void)
175{
176 uint32_t mask;
177
178 mask = (1 << lcg_rand_n (31)) - 1;
179
180 return (lcg_rand () & mask) - (mask >> 1);
181}
182
183static pixman_image_t *
184create_random_bits_image (void)
185{
186 pixman_format_code_t format;
187 pixman_indexed_t *indexed;
188 pixman_image_t *image;
189 int width, height, stride;
190 uint32_t *bits;
191 pixman_read_memory_func_t read_func = NULL((void*)0);
192 pixman_write_memory_func_t write_func = NULL((void*)0);
193 pixman_filter_t filter;
194 pixman_fixed_t *coefficients = NULL((void*)0);
195 int n_coefficients = 0;
196
197 /* format */
198 format = image_formats[lcg_rand_n (ARRAY_LENGTH (image_formats)((int) (sizeof (image_formats) / sizeof ((image_formats) [0])
)))];
199
200 indexed = NULL((void*)0);
201 if (PIXMAN_FORMAT_TYPE (format)(((format) >> 16) & 0xff) == PIXMAN_TYPE_COLOR4)
202 {
203 indexed = malloc (sizeof (pixman_indexed_t));
204
205 initialize_palette (indexed, PIXMAN_FORMAT_BPP (format)(((format) >> 24) ), TRUE1);
206 }
207 else if (PIXMAN_FORMAT_TYPE (format)(((format) >> 16) & 0xff) == PIXMAN_TYPE_GRAY5)
208 {
209 indexed = malloc (sizeof (pixman_indexed_t));
210
211 initialize_palette (indexed, PIXMAN_FORMAT_BPP (format)(((format) >> 24) ), FALSE0);
212 }
213 else
214 {
215 indexed = NULL((void*)0);
216 }
217
218 /* size */
219 width = get_size ();
220 height = get_size ();
221
222 if ((uint64_t)width * height > 200000)
223 {
224 if (lcg_rand_n(2) == 0)
225 height = 200000 / width;
226 else
227 width = 200000 / height;
228 }
229
230 if (height == 0)
231 height = 1;
232 if (width == 0)
233 width = 1;
234
235 /* bits */
236 switch (lcg_rand_n (7))
237 {
238 default:
239 case 0:
240 stride = width * PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) + lcg_rand_n (17);
241 stride = (stride + 3) & (~3);
242 bits = (uint32_t *)make_random_bytes (height * stride);
243 break;
244
245 case 1:
246 stride = 0;
247 bits = NULL((void*)0);
248 break;
249
250 case 2: /* Zero-filled */
251 stride = width * PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) + lcg_rand_n (17);
252 stride = (stride + 3) & (~3);
253 bits = fence_malloc (height * stride);
254 if (!bits)
255 return NULL((void*)0);
256 memset (bits, 0, height * stride);
257 break;
258
259 case 3: /* Filled with 0xFF */
260 stride = width * PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) + lcg_rand_n (17);
261 stride = (stride + 3) & (~3);
262 bits = fence_malloc (height * stride);
263 if (!bits)
264 return NULL((void*)0);
265 memset (bits, 0xff, height * stride);
266 break;
267
268 case 4: /* bits is a bad pointer, has read/write functions */
269 stride = 232;
270 bits = (void *)0x01;
271 read_func = fake_reader;
272 write_func = fake_writer;
273 break;
274
275 case 5: /* bits is a real pointer, has read/write functions */
276 stride = width * PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) + lcg_rand_n (17);
277 stride = (stride + 3) & (~3);
278 bits = fence_malloc (height * stride);
279 if (!bits)
280 return NULL((void*)0);
281 memset (bits, 0xff, height * stride);
282 read_func = real_reader;
283 write_func = real_writer;
284 break;
285
286 case 6: /* bits is a real pointer, stride is negative */
287 stride = (width * PIXMAN_FORMAT_BPP (format)(((format) >> 24) ) + lcg_rand_n (17));
288 stride = (stride + 3) & (~3);
289 bits = (uint32_t *)make_random_bytes (height * stride);
290 if (!bits)
291 return NULL((void*)0);
292 bits += ((height - 1) * stride) / 4;
293 stride = - stride;
294 break;
295 }
296
297 /* Filter */
298 filter = filters[lcg_rand_n (ARRAY_LENGTH (filters)((int) (sizeof (filters) / sizeof ((filters) [0]))))];
299 if (filter == PIXMAN_FILTER_CONVOLUTION)
300 {
301 int width = lcg_rand_n (17);
302 int height = lcg_rand_n (19);
303
304 n_coefficients = width * height + 2;
305 coefficients = malloc (n_coefficients * sizeof (pixman_fixed_t));
306
307 if (coefficients)
308 {
309 int i;
310
311 for (i = 0; i < width * height; ++i)
312 coefficients[i + 2] = lcg_rand_u32();
313
314 coefficients[0] = width << 16;
315 coefficients[1] = height << 16;
316 }
317 else
318 {
319 filter = PIXMAN_FILTER_BEST;
320 }
321 }
322
323 /* Finally create the image */
324 image = pixman_image_create_bits (format, width, height, bits, stride);
325 if (!image)
326 return NULL((void*)0);
327
328 pixman_image_set_indexed (image, indexed);
329 pixman_image_set_destroy_function (image, destroy, indexed);
330 pixman_image_set_accessors (image, read_func, write_func);
331 pixman_image_set_filter (image, filter, coefficients, n_coefficients);
332
333 return image;
334}
335
336static pixman_repeat_t repeats[] =
337{
338 PIXMAN_REPEAT_NONE,
339 PIXMAN_REPEAT_NORMAL,
340 PIXMAN_REPEAT_REFLECT,
341 PIXMAN_REPEAT_PAD
342};
343
344static uint32_t
345absolute (int32_t i)
346{
347 return i < 0? -i : i;
348}
349
350static void
351set_general_properties (pixman_image_t *image, pixman_bool_t allow_alpha_map)
352{
353 pixman_repeat_t repeat;
354
355 /* Set properties that are generic to all images */
356
357 /* Repeat */
358 repeat = repeats[lcg_rand_n (ARRAY_LENGTH (repeats)((int) (sizeof (repeats) / sizeof ((repeats) [0]))))];
359 pixman_image_set_repeat (image, repeat);
360
361 /* Alpha map */
362 if (allow_alpha_map && lcg_rand_n (3) == 0)
363 {
364 pixman_image_t *alpha_map;
365 int16_t x, y;
366
367 alpha_map = create_random_bits_image ();
368
369 if (alpha_map)
370 {
371 set_general_properties (alpha_map, FALSE0);
372
373 x = lcg_rand_N (100000) - 65536;
374 y = lcg_rand_N (100000) - 65536;
375
376 pixman_image_set_alpha_map (image, alpha_map, x, y);
377
378 pixman_image_unref (alpha_map);
379 }
380 }
381
382 /* Component alpha */
383 pixman_image_set_component_alpha (image, lcg_rand_n (3) == 0);
384
385 /* Clip region */
386 if (lcg_rand_n (8) != 0)
387 {
388 pixman_region32_t region;
389 int i, n_rects;
390
391 pixman_region32_init (&region);
392
393 switch (lcg_rand_n (10))
394 {
395 case 0:
396 n_rects = 0;
397 break;
398
399 case 1: case 2: case 3:
400 n_rects = 1;
401 break;
402
403 case 4: case 5:
404 n_rects = 2;
405 break;
406
407 case 6: case 7:
408 n_rects = 3;
Value stored to 'n_rects' is never read
409
410 default:
411 n_rects = lcg_rand_n (100);
412 break;
413 }
414
415 for (i = 0; i < n_rects; ++i)
416 {
417 uint32_t width, height;
418 int x, y;
419
420 x = log_rand();
421 y = log_rand();
422 width = absolute (log_rand ()) + 1;
423 height = absolute (log_rand ()) + 1;
424
425 pixman_region32_union_rect (
426 &region, &region, x, y, width, height);
427 }
428
429 pixman_image_set_clip_region32 (image, &region);
430
431 pixman_region32_fini (&region);
432 }
433
434 /* Whether source clipping is enabled */
435 pixman_image_set_source_clipping (image, !!lcg_rand_n (2));
436
437 /* Client clip */
438 pixman_image_set_has_client_clip (image, !!lcg_rand_n (2));
439
440 /* Transform */
441 if (lcg_rand_n (5) < 2)
442 {
443 pixman_transform_t xform;
444 int i, j, k;
445 uint32_t tx, ty, sx, sy;
446 uint32_t c, s;
447
448 memset (&xform, 0, sizeof xform);
449 xform.matrix[0][0] = pixman_fixed_1(((pixman_fixed_t) ((1) << 16)));
450 xform.matrix[1][1] = pixman_fixed_1(((pixman_fixed_t) ((1) << 16)));
451 xform.matrix[2][2] = pixman_fixed_1(((pixman_fixed_t) ((1) << 16)));
452
453 for (k = 0; k < 3; ++k)
454 {
455 switch (lcg_rand_n (4))
456 {
457 case 0:
458 /* rotation */
459 c = lcg_rand_N (2 * 65536) - 65536;
460 s = lcg_rand_N (2 * 65536) - 65536;
461 pixman_transform_rotate (&xform, NULL((void*)0), c, s);
462 break;
463
464 case 1:
465 /* translation */
466 tx = lcg_rand_u32();
467 ty = lcg_rand_u32();
468 pixman_transform_translate (&xform, NULL((void*)0), tx, ty);
469 break;
470
471 case 2:
472 /* scale */
473 sx = lcg_rand_u32();
474 sy = lcg_rand_u32();
475 pixman_transform_scale (&xform, NULL((void*)0), sx, sy);
476 break;
477
478 case 3:
479 if (lcg_rand_n (16) == 0)
480 {
481 /* random */
482 for (i = 0; i < 3; ++i)
483 for (j = 0; j < 3; ++j)
484 xform.matrix[i][j] = lcg_rand_u32();
485 break;
486 }
487 else if (lcg_rand_n (16) == 0)
488 {
489 /* zero */
490 memset (&xform, 0, sizeof xform);
491 }
492 break;
493 }
494 }
495
496 pixman_image_set_transform (image, &xform);
497 }
498}
499
500static pixman_color_t
501random_color (void)
502{
503 pixman_color_t color =
504 {
505 lcg_rand() & 0xffff,
506 lcg_rand() & 0xffff,
507 lcg_rand() & 0xffff,
508 lcg_rand() & 0xffff,
509 };
510
511 return color;
512}
513
514
515static pixman_image_t *
516create_random_solid_image (void)
517{
518 pixman_color_t color = random_color();
519 pixman_image_t *image = pixman_image_create_solid_fill (&color);
520
521 return image;
522}
523
524static pixman_gradient_stop_t *
525create_random_stops (int *n_stops)
526{
527 pixman_fixed_t step;
528 pixman_fixed_t s;
529 int i;
530 pixman_gradient_stop_t *stops;
531
532 *n_stops = lcg_rand_n (50) + 1;
533
534 step = pixman_fixed_1(((pixman_fixed_t) ((1) << 16))) / *n_stops;
535
536 stops = malloc (*n_stops * sizeof (pixman_gradient_stop_t));
537
538 s = 0;
539 for (i = 0; i < (*n_stops) - 1; ++i)
540 {
541 stops[i].x = s;
542 stops[i].color = random_color();
543
544 s += step;
545 }
546
547 stops[*n_stops - 1].x = pixman_fixed_1(((pixman_fixed_t) ((1) << 16)));
548 stops[*n_stops - 1].color = random_color();
549
550 return stops;
551}
552
553static pixman_point_fixed_t
554create_random_point (void)
555{
556 pixman_point_fixed_t p;
557
558 p.x = log_rand ();
559 p.y = log_rand ();
560
561 return p;
562}
563
564static pixman_image_t *
565create_random_linear_image (void)
566{
567 int n_stops;
568 pixman_gradient_stop_t *stops;
569 pixman_point_fixed_t p1, p2;
570 pixman_image_t *result;
571
572 stops = create_random_stops (&n_stops);
573 if (!stops)
574 return NULL((void*)0);
575
576 p1 = create_random_point ();
577 p2 = create_random_point ();
578
579 result = pixman_image_create_linear_gradient (&p1, &p2, stops, n_stops);
580
581 free (stops);
582
583 return result;
584}
585
586static pixman_image_t *
587create_random_radial_image (void)
588{
589 int n_stops;
590 pixman_gradient_stop_t *stops;
591 pixman_point_fixed_t inner_c, outer_c;
592 pixman_fixed_t inner_r, outer_r;
593 pixman_image_t *result;
594
595 inner_c = create_random_point();
596 outer_c = create_random_point();
597 inner_r = lcg_rand();
598 outer_r = lcg_rand();
599
600 stops = create_random_stops (&n_stops);
601
602 if (!stops)
603 return NULL((void*)0);
604
605 result = pixman_image_create_radial_gradient (
606 &inner_c, &outer_c, inner_r, outer_r, stops, n_stops);
607
608 free (stops);
609
610 return result;
611}
612
613static pixman_image_t *
614create_random_conical_image (void)
615{
616 pixman_gradient_stop_t *stops;
617 int n_stops;
618 pixman_point_fixed_t c;
619 pixman_fixed_t angle;
620 pixman_image_t *result;
621
622 c = create_random_point();
623 angle = lcg_rand();
624
625 stops = create_random_stops (&n_stops);
626
627 if (!stops)
628 return NULL((void*)0);
629
630 result = pixman_image_create_conical_gradient (&c, angle, stops, n_stops);
631
632 free (stops);
633
634 return result;
635}
636
637static pixman_image_t *
638create_random_image (void)
639{
640 pixman_image_t *result;
641
642 switch (lcg_rand_n (5))
643 {
644 default:
645 case 0:
646 result = create_random_bits_image ();
647 break;
648
649 case 1:
650 result = create_random_solid_image ();
651 break;
652
653 case 2:
654 result = create_random_linear_image ();
655 break;
656
657 case 3:
658 result = create_random_radial_image ();
659 break;
660
661 case 4:
662 result = create_random_conical_image ();
663 break;
664 }
665
666 if (result)
667 set_general_properties (result, TRUE1);
668
669 return result;
670}
671
672static const pixman_op_t op_list[] =
673{
674 PIXMAN_OP_SRC,
675 PIXMAN_OP_OVER,
676 PIXMAN_OP_ADD,
677 PIXMAN_OP_CLEAR,
678 PIXMAN_OP_SRC,
679 PIXMAN_OP_DST,
680 PIXMAN_OP_OVER,
681 PIXMAN_OP_OVER_REVERSE,
682 PIXMAN_OP_IN,
683 PIXMAN_OP_IN_REVERSE,
684 PIXMAN_OP_OUT,
685 PIXMAN_OP_OUT_REVERSE,
686 PIXMAN_OP_ATOP,
687 PIXMAN_OP_ATOP_REVERSE,
688 PIXMAN_OP_XOR,
689 PIXMAN_OP_ADD,
690 PIXMAN_OP_SATURATE,
691 PIXMAN_OP_DISJOINT_CLEAR,
692 PIXMAN_OP_DISJOINT_SRC,
693 PIXMAN_OP_DISJOINT_DST,
694 PIXMAN_OP_DISJOINT_OVER,
695 PIXMAN_OP_DISJOINT_OVER_REVERSE,
696 PIXMAN_OP_DISJOINT_IN,
697 PIXMAN_OP_DISJOINT_IN_REVERSE,
698 PIXMAN_OP_DISJOINT_OUT,
699 PIXMAN_OP_DISJOINT_OUT_REVERSE,
700 PIXMAN_OP_DISJOINT_ATOP,
701 PIXMAN_OP_DISJOINT_ATOP_REVERSE,
702 PIXMAN_OP_DISJOINT_XOR,
703 PIXMAN_OP_CONJOINT_CLEAR,
704 PIXMAN_OP_CONJOINT_SRC,
705 PIXMAN_OP_CONJOINT_DST,
706 PIXMAN_OP_CONJOINT_OVER,
707 PIXMAN_OP_CONJOINT_OVER_REVERSE,
708 PIXMAN_OP_CONJOINT_IN,
709 PIXMAN_OP_CONJOINT_IN_REVERSE,
710 PIXMAN_OP_CONJOINT_OUT,
711 PIXMAN_OP_CONJOINT_OUT_REVERSE,
712 PIXMAN_OP_CONJOINT_ATOP,
713 PIXMAN_OP_CONJOINT_ATOP_REVERSE,
714 PIXMAN_OP_CONJOINT_XOR,
715 PIXMAN_OP_MULTIPLY,
716 PIXMAN_OP_SCREEN,
717 PIXMAN_OP_OVERLAY,
718 PIXMAN_OP_DARKEN,
719 PIXMAN_OP_LIGHTEN,
720 PIXMAN_OP_COLOR_DODGE,
721 PIXMAN_OP_COLOR_BURN,
722 PIXMAN_OP_HARD_LIGHT,
723 PIXMAN_OP_DIFFERENCE,
724 PIXMAN_OP_EXCLUSION,
725 PIXMAN_OP_SOFT_LIGHT,
726 PIXMAN_OP_HSL_HUE,
727 PIXMAN_OP_HSL_SATURATION,
728 PIXMAN_OP_HSL_COLOR,
729 PIXMAN_OP_HSL_LUMINOSITY,
730};
731
732static void
733run_test (uint32_t seed)
734{
735 pixman_image_t *source, *mask, *dest;
736 pixman_op_t op;
737
738 lcg_srand (seed);
739
740 source = create_random_image ();
741 mask = create_random_image ();
742 dest = create_random_bits_image ();
743
744 if (source && mask && dest)
745 {
746 set_general_properties (dest, TRUE1);
747
748 op = op_list [lcg_rand_n (ARRAY_LENGTH (op_list)((int) (sizeof (op_list) / sizeof ((op_list) [0]))))];
749
750 pixman_image_composite32 (op,
751 source, mask, dest,
752 log_rand(), log_rand(),
753 log_rand(), log_rand(),
754 log_rand(), log_rand(),
755 absolute (log_rand()),
756 absolute (log_rand()));
757 }
758 if (source)
759 pixman_image_unref (source);
760 if (mask)
761 pixman_image_unref (mask);
762 if (dest)
763 pixman_image_unref (dest);
764}
765
766static pixman_bool_t
767get_int (char *s, uint32_t *i)
768{
769 char *end;
770 int p;
771
772 p = strtol (s, &end, 0);
773
774 if (end != s && *end == 0)
775 {
776 *i = p;
777 return TRUE1;
778 }
779
780 return FALSE0;
781}
782
783int
784main (int argc, char **argv)
785{
786 int verbose = FALSE0;
787 uint32_t seed = 1;
788 uint32_t n_tests = 0xffffffff;
789 uint32_t mod = 0;
790 uint32_t i;
791
792 pixman_disable_out_of_bounds_workaround ();
793
794 enable_fp_exceptions();
795
796 if (getenv ("VERBOSE") != NULL((void*)0))
797 verbose = TRUE1;
798
799 for (i = 1; i < argc; ++i)
800 {
801 if (strcmp (argv[i], "-v") == 0)
802 {
803 verbose = TRUE1;
804
805 if (i + 1 < argc)
806 {
807 get_int (argv[i + 1], &mod);
808 i++;
809 }
810 }
811 else if (strcmp (argv[i], "-s") == 0 && i + 1 < argc)
812 {
813 get_int (argv[i + 1], &seed);
814 i++;
815 }
816 else if (strcmp (argv[i], "-n") == 0 && i + 1 < argc)
817 {
818 get_int (argv[i + 1], &n_tests);
819 i++;
820 }
821 else
822 {
823 if (strcmp (argv[i], "-h") != 0)
824 printf ("Unknown option '%s'\n\n", argv[i]);
825
826 printf ("Options:\n\n"
827 "-n <number> Number of tests to run\n"
828 "-s <seed> Seed of first test\n"
829 "-v Print out seeds\n"
830 "-v <n> Print out every n'th seed\n\n");
831
832 exit (-1);
833 }
834 }
835
836 if (n_tests == 0xffffffff)
837 n_tests = 8000;
838
839 /* FIXME: seed 2005763 fails in set_lum() with divide by zero */
840#ifdef USE_OPENMP
841# pragma omp parallel for default(none) shared(verbose, n_tests, mod, seed)
842#endif
843 for (i = seed; i < seed + n_tests; ++i)
844 {
845 if (verbose)
846 {
847 if (mod == 0 || (i % mod) == 0)
848 printf ("Seed %d\n", i);
849 }
850
851 run_test (i);
852 }
853
854 return 0;
855}