[Pixman] [PATCH 2/4] New test of pixman_region_contains_{rectangle, point}

Soeren Sandmann sandmann at cs.au.dk
Wed Aug 3 21:32:41 PDT 2011


Søren Sandmann <sandmann at cs.au.dk> writes:

> From: Søren Sandmann Pedersen <ssp at redhat.com>
>
> This test generates random regions and checks whether random boxes and
> points are contained within them. The results are combined and a CRC32
> value is computed and compared to a known-correct one.

Apparently, I forgot to add the region-contains-test.c file, but it was
buggy anyway and had endian issues. Below is a new version of that patch.


Soren


commit 55edc9eb4c9041b4ed9639b6428ee215e5412ea0
Author: Søren Sandmann Pedersen <ssp at redhat.com>
Date:   Tue Aug 2 01:32:15 2011 -0400

    New test of pixman_region_contains_{rectangle,point}
    
    This test generates random regions and checks whether random boxes and
    points are contained within them. The results are combined and a CRC32
    value is computed and compared to a known-correct one.

diff --git a/test/Makefile.am b/test/Makefile.am
index 9dc7219..9f61fc9 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -15,6 +15,7 @@ TESTPROGRAMS =			\
 	scaling-crash-test	\
 	scaling-helpers-test	\
 	gradient-crash-test	\
+	region-contains-test	\
 	alphamap		\
 	stress-test		\
 	composite-traps-test	\
@@ -26,6 +27,7 @@ TESTPROGRAMS =			\
 pdf_op_test_SOURCES = pdf-op-test.c utils.c utils.h
 region_test_SOURCES = region-test.c utils.c utils.h
 blitters_test_SOURCES = blitters-test.c utils.c utils.h
+region_contains_test_SOURCES = region-contains-test.c utils.c utils.h
 composite_traps_test_SOURCES = composite-traps-test.c utils.c utils.h
 scaling_test_SOURCES = scaling-test.c utils.c utils.h
 affine_test_SOURCES = affine-test.c utils.c utils.h
diff --git a/test/region-contains-test.c b/test/region-contains-test.c
new file mode 100644
index 0000000..276c70f
--- /dev/null
+++ b/test/region-contains-test.c
@@ -0,0 +1,170 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "utils.h"
+
+static void
+make_random_region (pixman_region32_t *region)
+{
+    int n_boxes;
+    
+    pixman_region32_init (region);
+
+    n_boxes = lcg_rand_n (64);
+    while (n_boxes--)
+    {
+	int32_t x1, y1, x2, y2;
+
+	x1 = (int32_t)lcg_rand_u32();
+	y1 = (int32_t)lcg_rand_u32();
+	x2 = (int32_t)lcg_rand_u32();
+	y2 = (int32_t)lcg_rand_u32();
+	
+	pixman_region32_union_rect (region, region, x1, y1, x2, y2);
+    }
+}
+
+static void
+print_box (pixman_box32_t *box)
+{
+    printf ("    %d %d %d %d\n", box->x1, box->y1, box->x2, box->y2);
+}
+
+static int32_t
+random_coord (pixman_region32_t *region, pixman_bool_t x)
+{
+    pixman_box32_t *b, *bb;
+    int n_boxes;
+    int begin, end;
+
+    if (lcg_rand_n (14))
+    {
+	bb = pixman_region32_rectangles (region, &n_boxes);
+	if (n_boxes == 0)
+	    goto use_extent;
+	b = bb + lcg_rand_n (n_boxes);
+    }
+    else
+    {
+    use_extent:
+	b = pixman_region32_extents (region);
+	n_boxes = 1;
+    }
+
+    if (x)
+    {
+	begin = b->x1;
+	end = b->x2;
+    }
+    else
+    {
+	begin = b->y1;
+	end = b->y2;
+    }
+    
+    switch (lcg_rand_n (5))
+    {
+    case 0:
+	return begin - lcg_rand_u32();
+    case 1:
+	return end + lcg_rand_u32 ();
+    case 2:
+	return end;
+    case 3:
+	return begin;
+    default:
+	return (begin + end) / 2;
+    }
+    return 0;
+}
+
+static uint32_t
+compute_crc32_u32 (uint32_t crc32, uint32_t v)
+{
+    if (!is_little_endian())
+    {
+	v = ((v & 0xff000000) >> 24)	|
+	    ((v & 0x00ff0000) >> 8)	|
+	    ((v & 0x0000ff00) << 8)	|
+	    ((v & 0x000000ff) << 24);
+    }
+
+    return compute_crc32 (crc32, &v, sizeof (int32_t));
+}
+    
+static uint32_t
+crc32_box32 (uint32_t crc32, pixman_box32_t *box)
+{
+    crc32 = compute_crc32_u32 (crc32, box->x1);
+    crc32 = compute_crc32_u32 (crc32, box->y1);
+    crc32 = compute_crc32_u32 (crc32, box->x2);
+    crc32 = compute_crc32_u32 (crc32, box->y2);
+
+    return crc32;
+}
+
+static uint32_t
+test_region_contains_rectangle (int i, int verbose)
+{
+    pixman_box32_t box;
+    pixman_box32_t rbox = { 0, 0, 0, 0 };
+    pixman_region32_t region;
+    uint32_t r, r1, r2, r3, r4, crc32;
+    
+    lcg_srand (i);
+    
+    make_random_region (&region);
+
+    box.x1 = random_coord (&region, TRUE);
+    box.x2 = box.x1 + lcg_rand_u32 ();
+    box.y1 = random_coord (&region, FALSE);
+    box.y2 = box.y1 + lcg_rand_u32 ();
+
+    if (verbose)
+    {
+	int n_rects;
+	pixman_box32_t *boxes;
+
+	boxes = pixman_region32_rectangles (&region, &n_rects);
+	
+	printf ("region:\n");
+	while (n_rects--)
+	    print_box (boxes++);
+	printf ("box:\n");
+	print_box (&box);
+    }
+
+    crc32 = 0;
+    
+    r1 = pixman_region32_contains_point (&region, box.x1, box.y1, &rbox);
+    crc32 = crc32_box32 (crc32, &rbox);
+    r2 = pixman_region32_contains_point (&region, box.x1, box.y2, &rbox);
+    crc32 = crc32_box32 (crc32, &rbox);
+    r3 = pixman_region32_contains_point (&region, box.x2, box.y1, &rbox);
+    crc32 = crc32_box32 (crc32, &rbox);
+    r4 = pixman_region32_contains_point (&region, box.x2, box.y2, &rbox);
+    crc32 = crc32_box32 (crc32, &rbox);
+
+    r = pixman_region32_contains_rectangle (&region, &box);
+    r = (i << 8) | (r << 4) | (r1 << 3) | (r2 << 2) | (r3 << 1) | (r4 << 0);
+
+    crc32 = compute_crc32_u32 (crc32, r);
+    
+    if (verbose)
+	printf ("results: %d %d %d %d %d\n", (r & 0xf0) >> 4, r1, r2, r3, r4);
+
+    pixman_region32_fini (&region);
+	
+    return crc32;
+}
+
+int
+main (int argc, const char *argv[])
+{
+    return fuzzer_test_main ("region_contains",
+			     1000000,
+			     0x6AAEBC14,
+			     test_region_contains_rectangle,
+			     argc, argv);
+		      
+}    
diff --git a/test/utils.c b/test/utils.c
index 4025602..ffe8065 100644
--- a/test/utils.c
+++ b/test/utils.c
@@ -130,6 +130,14 @@ compute_crc32 (uint32_t    in_crc32,
     return (crc32 ^ 0xFFFFFFFF);
 }
 
+pixman_bool_t
+is_little_endian (void)
+{
+    volatile uint16_t endian_check_var = 0x1234;
+
+    return (*(volatile uint8_t *)&endian_check_var == 0x34);
+}
+
 /* perform endian conversion of pixel data
  */
 void
@@ -142,10 +150,9 @@ image_endian_swap (pixman_image_t *img)
     int i, j;
 
     /* swap bytes only on big endian systems */
-    volatile uint16_t endian_check_var = 0x1234;
-    if (*(volatile uint8_t *)&endian_check_var != 0x12)
+    if (is_little_endian())
 	return;
-
+    
     if (bpp == 8)
 	return;
 
diff --git a/test/utils.h b/test/utils.h
index a249627..ef7cb0c 100644
--- a/test/utils.h
+++ b/test/utils.h
@@ -58,6 +58,10 @@ compute_crc32 (uint32_t    in_crc32,
 	       const void *buf,
 	       size_t      buf_len);
 
+/* Returns TRUE if running on a big endian system */
+pixman_bool_t
+is_little_endian (void);
+
 /* perform endian conversion of pixel data
  */
 void


More information about the Pixman mailing list