fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2025-12-20 05:50:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
cairo/test/a8-mask.c

202 lines
5.4 KiB
C
Raw Permalink Normal View History

Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
/*
* Copyright © Jeff Muizelaar
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice appear in all copies
* and that both that copyright notice and this permission notice
* appear in supporting documentation, and that the name of
* Red Hat, Inc. not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. Red Hat, Inc. makes no representations about the
* suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* JEFF MUIZELAAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL RED HAT, INC. BE LIABLE FOR ANY SPECIAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
Rename cairo_image_surface_stride_for_width to cairo_format_stride_for_width Thanks for Behdad for the suggested name improvement. Also, make it more clear that the stride passed to cairo_image_surface_create_for_data should come from calling cairo_format_stride_for_width with the same width.
2008-01-28 14:29:36 -08:00
* Authors: Jeff Muizelaar <jeff@infidigm.net>
* Carl Worth <cworth@cworth.org>
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
*/
#include "cairo-test.h"
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
#define MASK_WIDTH 8
#define MASK_HEIGHT 8
static unsigned char mask[MASK_WIDTH * MASK_HEIGHT] = {
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0,
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
};
static cairo_test_status_t
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
check_status (const cairo_test_context_t *ctx,
cairo_status_t status,
cairo_status_t expected)
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
{
if (status == expected)
return CAIRO_TEST_SUCCESS;
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
cairo_test_log (ctx,
"Error: Expected status value %d (%s), received %d (%s)\n",
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
expected,
cairo_status_to_string (expected),
status,
cairo_status_to_string (status));
return CAIRO_TEST_FAILURE;
}
static cairo_test_status_t
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
test_surface_with_width_and_stride (const cairo_test_context_t *ctx,
int width, int stride,
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
cairo_status_t expected)
{
cairo_test_status_t status;
cairo_surface_t *surface;
cairo_t *cr;
[test/a8-mask] Check negative strides as well. Check that we also allow surfaces to be created using a negative stride.
2008-02-28 16:04:08 +00:00
int len;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
unsigned char *data;
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
cairo_test_log (ctx,
"Creating surface with width %d and stride %d\n",
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
width, stride);
[test/a8-mask] Check negative strides as well. Check that we also allow surfaces to be created using a negative stride.
2008-02-28 16:04:08 +00:00
len = stride;
if (len < 0)
len = -len;
data = xmalloc (len);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
surface = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_A8,
width, 1, stride);
cr = cairo_create (surface);
cairo_paint (cr);
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
status = check_status (ctx, cairo_surface_status (surface), expected);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
if (status)
[test/a8-mask] Fix memleak. Destroy the auxiallary surfaces and contexts.
2008-01-30 15:20:50 +00:00
goto BAIL;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
status = check_status (ctx, cairo_status (cr), expected);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
if (status)
[test/a8-mask] Fix memleak. Destroy the auxiallary surfaces and contexts.
2008-01-30 15:20:50 +00:00
goto BAIL;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
[test/a8-mask] Fix memleak. Destroy the auxiallary surfaces and contexts.
2008-01-30 15:20:50 +00:00
BAIL:
cairo_destroy (cr);
cairo_surface_destroy (surface);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
free (data);
[test/a8-mask] Fix memleak. Destroy the auxiallary surfaces and contexts.
2008-01-30 15:20:50 +00:00
return status;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
}
static cairo_test_status_t
draw (cairo_t *cr, int dst_width, int dst_height)
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
{
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
int stride, row;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
unsigned char *src, *dst, *mask_aligned;
Patch memory leaks.
2005-08-05 15:48:42 +00:00
cairo_surface_t *surface;
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
/* Now test actually drawing through our mask data, allocating and
* copying with the proper stride. */
Rename cairo_image_surface_stride_for_width to cairo_format_stride_for_width Thanks for Behdad for the suggested name improvement. Also, make it more clear that the stride passed to cairo_image_surface_create_for_data should come from calling cairo_format_stride_for_width with the same width.
2008-01-28 14:29:36 -08:00
stride = cairo_format_stride_for_width (CAIRO_FORMAT_A8,
MASK_WIDTH);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
[test/a8-mask] Fix memleak. Destroy the auxiallary surfaces and contexts.
2008-01-30 15:20:50 +00:00
mask_aligned = xmalloc (stride * MASK_HEIGHT);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
src = mask;
dst = mask_aligned;
for (row = 0; row < MASK_HEIGHT; row++) {
memcpy (dst, src, MASK_WIDTH);
src += MASK_WIDTH;
dst += stride;
}
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
surface = cairo_image_surface_create_for_data (mask_aligned,
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
CAIRO_FORMAT_A8,
MASK_WIDTH,
MASK_HEIGHT,
stride);
/* Paint background blue */
cairo_set_source_rgb (cr, 0, 0, 1); /* blue */
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
cairo_paint (cr);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
/* Then paint red through our mask */
cairo_set_source_rgb (cr, 1, 0, 0); /* red */
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
cairo_mask_surface (cr, surface, 0, 0);
Patch memory leaks.
2005-08-05 15:48:42 +00:00
cairo_surface_destroy (surface);
Add cairo_image_surface_stride_for_width Document this function as a required call to get the correct stride value before calling cairo_image_surface_create_for_data. This means that previously-failing calls with non-multiple-of-4 stride values are now documented as errors. Also, we now have the possibility of moving to more stringent alignment constraints, (one can imagine doing 64-bit or 128-bit boundaries for example).
2008-01-26 23:12:14 -08:00
free (mask_aligned);
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
return CAIRO_TEST_SUCCESS;
}
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
{
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
cairo_test_status_t status = CAIRO_TEST_SUCCESS;
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
int test_width;
for (test_width = 0; test_width < 40; test_width++) {
int stride = cairo_format_stride_for_width (CAIRO_FORMAT_A8,
test_width);
cairo_status_t expected;
/* First create a surface using the width as the stride,
* (most of these should fail).
*/
expected = (stride == test_width) ?
CAIRO_STATUS_SUCCESS : CAIRO_STATUS_INVALID_STRIDE;
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
status = test_surface_with_width_and_stride (ctx,
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
test_width,
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
test_width,
expected);
if (status)
return status;
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
status = test_surface_with_width_and_stride (ctx,
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
test_width,
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
-test_width,
expected);
if (status)
return status;
/* Then create a surface using the correct stride,
* (should always succeed).
*/
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
status = test_surface_with_width_and_stride (ctx,
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
test_width,
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
stride,
CAIRO_STATUS_SUCCESS);
if (status)
return status;
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
status = test_surface_with_width_and_stride (ctx,
[test] Preparatory work for running under memfault. In order to run under memfault, the framework is first extended to handle running concurrent tests - i.e. multi-threading. (Not that this is a requirement for memfault, instead it shares a common goal of storing per-test data). To that end all the global data is moved into a per-test context and the targets are adjusted to avoid overlap on shared, global resources (such as output files and frame buffers). In order to preserve the simplicity of the standard draw routines, the context is not passed explicitly as a parameter to the routines, but is instead attached to the cairo_t via the user_data. For the masochist, to enable the tests to be run across multiple threads simply set the environment variable CAIRO_TEST_NUM_THREADS to the desired number. In the long run, we can hope the need for memfault (runtime testing of error paths) will be mitigated by static analysis. A promising candidate for this task would appear to be http://hal.cs.berkeley.edu/cil/.
2008-08-11 21:12:45 +01:00
test_width,
[test/a8-mask] Perform the stride API checking once. The stride API is independent of the surface and does not need to be repeated for every surface.
2008-04-14 20:32:29 +01:00
-stride,
CAIRO_STATUS_SUCCESS);
if (status)
return status;
}
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
return status;
Add a test case for CAIRO_FORMAT_A8 masks that fails with libpixman.
2005-08-05 15:07:45 +00:00
}
[test] Build test suite into single binary. Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
2008-09-03 16:38:03 +01:00
CAIRO_TEST (a8_mask,
"test masks of CAIRO_FORMAT_A8",
"alpha, mask", /* keywords */
NULL, /* requirements */
8, 8,
preamble, draw)
Reference in a new issue Copy permalink