fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2025-12-21 00:30:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
cairo/test/copy-path.c

295 lines
8.4 KiB
C
Raw Normal View History

Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
/*
* Copyright © 2005 Red Hat, Inc.
*
* 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.
*
* RED HAT, INC. 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.
*
* Author: Carl D. Worth <cworth@cworth.org>
*/
#include <stdlib.h>
More _/- renames in the test directory.
2005-03-29 00:02:19 +00:00
#include "cairo-test.h"
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
static void
scale_by_two (double *x, double *y)
{
*x = *x * 2.0;
*y = *y * 2.0;
}
typedef void (*munge_func_t) (double *x, double *y);
static void
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
munge_and_set_path (cairo_t *cr,
cairo_path_t *path,
munge_func_t munge)
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
{
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
int i;
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_path_data_t *p;
double x1, y1, x2, y2, x3, y3;
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
for (i=0; i < path->num_data; i += path->data[i].header.length) {
p = &path->data[i];
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
switch (p->header.type) {
case CAIRO_PATH_MOVE_TO:
x1 = p[1].point.x; y1 = p[1].point.y;
(munge) (&x1, &y1);
cairo_move_to (cr, x1, y1);
break;
case CAIRO_PATH_LINE_TO:
x1 = p[1].point.x; y1 = p[1].point.y;
(munge) (&x1, &y1);
cairo_line_to (cr, x1, y1);
break;
case CAIRO_PATH_CURVE_TO:
x1 = p[1].point.x; y1 = p[1].point.y;
x2 = p[2].point.x; y2 = p[2].point.y;
x3 = p[3].point.x; y3 = p[3].point.y;
(munge) (&x1, &y1);
(munge) (&x2, &y2);
(munge) (&x3, &y3);
cairo_curve_to (cr,
x1, y1,
x2, y2,
x3, y3);
break;
case CAIRO_PATH_CLOSE_PATH:
cairo_close_path (cr);
break;
}
}
}
static void
make_path (cairo_t *cr)
{
cairo_rectangle (cr, 0, 0, 5, 5);
cairo_move_to (cr, 15, 2.5);
cairo_arc (cr, 12.5, 2.5, 2.5, 0, 2 * M_PI);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
[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
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_path_t *path;
Fix cairo_copy_path and cairo_copy_path_flat to propagate errors. One of these functions was already documented to be doing this, and the other one should have been. Now the documentation and behavior for both are consistent, (and the path-data test case verifies this).
2006-09-25 16:03:02 -07:00
cairo_t *cr_error;
/* Ensure that calling cairo_copy_path on an in-error cairo_t will
* propagate the error. */
cr_error = cairo_create (NULL);
path = cairo_copy_path (cr_error);
if (path->status == CAIRO_STATUS_SUCCESS ||
path->status != cairo_status (cr_error)) {
[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: cairo_copy_path returned status of %s rather than propagating %s\n",
Fix cairo_copy_path and cairo_copy_path_flat to propagate errors. One of these functions was already documented to be doing this, and the other one should have been. Now the documentation and behavior for both are consistent, (and the path-data test case verifies this).
2006-09-25 16:03:02 -07:00
cairo_status_to_string (path->status),
cairo_status_to_string (cairo_status (cr_error)));
cairo_path_destroy (path);
return CAIRO_TEST_FAILURE;
}
cairo_path_destroy (path);
path = cairo_copy_path_flat (cr_error);
if (path->status == CAIRO_STATUS_SUCCESS ||
path->status != cairo_status (cr_error)) {
[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: cairo_copy_path_flat returned status of %s rather than propagating %s\n",
Fix cairo_copy_path and cairo_copy_path_flat to propagate errors. One of these functions was already documented to be doing this, and the other one should have been. Now the documentation and behavior for both are consistent, (and the path-data test case verifies this).
2006-09-25 16:03:02 -07:00
cairo_status_to_string (path->status),
cairo_status_to_string (cairo_status (cr_error)));
cairo_path_destroy (path);
return CAIRO_TEST_FAILURE;
}
cairo_path_destroy (path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
Augment cairo_test_init with cairo_test_fini to avoid leak Without this, any tests that were using cairo_test_init rather than cairo_test would end up leaking a FILE* for the log file. So this keeps valgrind much more happy with the test suite.
2007-03-02 11:31:13 -08:00
cairo_destroy (cr_error);
[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-path] Don't raise an error when attempting to create an empty path. Generate a real empty path structure instead of returning _cairo_path_nil, if we have been asked to create an empty path. (Also add a couple of missing _cairo_error()s and an appropriate test case.) Spotted by Fred Kiefer.
2007-10-01 17:59:57 +01:00
/* first check that we can copy an empty path */
cairo_new_path (cr);
path = cairo_copy_path (cr);
if (path->status != CAIRO_STATUS_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: cairo_copy_path returned status of %s\n",
[cairo-path] Don't raise an error when attempting to create an empty path. Generate a real empty path structure instead of returning _cairo_path_nil, if we have been asked to create an empty path. (Also add a couple of missing _cairo_error()s and an appropriate test case.) Spotted by Fred Kiefer.
2007-10-01 17:59:57 +01:00
cairo_status_to_string (path->status));
cairo_path_destroy (path);
return CAIRO_TEST_FAILURE;
}
if (path->num_data != 0) {
[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: cairo_copy_path did not copy an empty path, returned path contains %d elements\n",
[cairo-path] Don't raise an error when attempting to create an empty path. Generate a real empty path structure instead of returning _cairo_path_nil, if we have been asked to create an empty path. (Also add a couple of missing _cairo_error()s and an appropriate test case.) Spotted by Fred Kiefer.
2007-10-01 17:59:57 +01:00
path->num_data);
cairo_path_destroy (path);
return CAIRO_TEST_FAILURE;
}
[cairo-path] Check for an empty path in cairo_append_path(). As we now generate empty paths, we must be able to handle empty paths in the user facing API. cairo_append_path() has an explicit check, and raises an error, for a NULL path->data, so we need to check the path->num_data first for empty paths.
2007-10-04 09:08:46 +01:00
cairo_append_path (cr, path);
[cairo-path] Don't raise an error when attempting to create an empty path. Generate a real empty path structure instead of returning _cairo_path_nil, if we have been asked to create an empty path. (Also add a couple of missing _cairo_error()s and an appropriate test case.) Spotted by Fred Kiefer.
2007-10-01 17:59:57 +01:00
cairo_path_destroy (path);
[cairo-path] Check for an empty path in cairo_append_path(). As we now generate empty paths, we must be able to handle empty paths in the user facing API. cairo_append_path() has an explicit check, and raises an error, for a NULL path->data, so we need to check the path->num_data first for empty paths.
2007-10-04 09:08:46 +01:00
if (cairo_status (cr) != CAIRO_STATUS_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: cairo_append_path failed with a copy of an empty path, returned status of %s\n",
[cairo-path] Check for an empty path in cairo_append_path(). As we now generate empty paths, we must be able to handle empty paths in the user facing API. cairo_append_path() has an explicit check, and raises an error, for a NULL path->data, so we need to check the path->num_data first for empty paths.
2007-10-04 09:08:46 +01:00
cairo_status_to_string (cairo_status (cr)));
return CAIRO_TEST_FAILURE;
}
Augment cairo_test_init with cairo_test_fini to avoid leak Without this, any tests that were using cairo_test_init rather than cairo_test would end up leaking a FILE* for the log file. So this keeps valgrind much more happy with the test suite.
2007-03-02 11:31:13 -08:00
Big change to the test infrastructure and supporting internals. The goal now is to test both a COLOR_ALPHA and a COLOR content for each surface backend, (since the semantics are different and we probably need to support both in each backend. The PS/PDF backends don't allow a content to be passed in right now, so they fail against the rgb24 tests, but the trivial addition to the constructors will allow them to pass all tests with both content values. And new constructors (currently internal only) to create an image surface with a cairo_content_t rather than a cairo_format_t. Add a cairo_content_t argument to the constructor. Add a cairo_content_t to the constructor and use this content value when constructing intermediate image surfaces in acquire_source, show_page, copy_page, and snapshot. Add image flattening by compositing over white, as is done in cairo-ps-surface.c. Track changes to cairo-paginates-surface which now requires a cairo_content_t value (no change to public PS/PDF constructors yet). Track change in meta-surface and paginated-surface interfaces by now accepting a cairo_content_t rather than a cairo_format_t. Ignore new output files (argb32 from pdf and ps as well as rgb24 from test-fallback, test-meta, and test-paginated). Add new utility for flattening PNG images in order to generate the -argbf-ref.png images. Add image_diff_flattened for comparing flattened output from PS and PDF backend with ARGB reference images by first blending the reference images over white. Get rid of conditional, format-specific background-color initialization before running tests. Now uses ARGB(0,0,0,0) in all cases. Switch from specifying tests with a format value to specifying tests with a content value. Add support for a 'fake' COLOR_ALPHA_FLATTENED content for testing the PS and PDF output against a flattened version of the argb32 reference images (first blended over white). Track change in cairo_ps_surface_create (now requires cairo_content_t value). Adjust tests that draw in default (black) to first paint white so that the results are visible. Adjust ARGB32 reference images for new white background for changed tests. Adjust RGB24 reference images for new black background due to changed initialization (and the tests themselves being unchanged).
2006-01-17 16:59:08 +00:00
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
/* copy path, munge, and fill */
cairo_translate (cr, 5, 5);
make_path (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
path = cairo_copy_path (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_new_path (cr);
munge_and_set_path (cr, path, scale_by_two);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_path_destroy (path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_fill (cr);
/* copy flattened path, munge, and fill */
cairo_translate (cr, 0, 15);
make_path (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
path = cairo_copy_path_flat (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_new_path (cr);
munge_and_set_path (cr, path, scale_by_two);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_path_destroy (path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_fill (cr);
/* append two copies of path, and fill */
cairo_translate (cr, 0, 15);
cairo_scale (cr, 2.0, 2.0);
make_path (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
path = cairo_copy_path (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_new_path (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_append_path (cr, path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_translate (cr, 2.5, 2.5);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_append_path (cr, path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_fill (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_path_destroy (path);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +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)
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
{
cairo_t *cr;
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_path_data_t data;
cairo_path_t path;
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cairo_surface_t *surface;
[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_status_t status;
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
/* Test a few error cases for cairo_append_path_data */
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cr = cairo_create (surface);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_append_path (cr, NULL);
[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 = cairo_status (cr);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_NULL_POINTER) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
cr = cairo_create (surface);
path.status = -1;
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_INVALID_STATUS) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
cr = cairo_create (surface);
path.status = CAIRO_STATUS_NO_MEMORY;
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_NO_MEMORY) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cr = cairo_create (surface);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
path.data = NULL;
path.num_data = 0;
Remove CAIRO_STATUS_NO_TARGET_SURFAC and add CAIRO_STATUS_INVALID_STATUS. Don't check for gstate->target == NULL anymore as the API now guarantees it never occurs. Check that path->status is a valid status value and cause an INVALID_STATUS error otherwise. Test the new CAIRO_STATUS_INVALID_STATUS error case in cairo_append_path.
2005-07-06 14:52:01 +00:00
path.status = CAIRO_STATUS_SUCCESS;
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
[cairo-path] Check for an empty path in cairo_append_path(). As we now generate empty paths, we must be able to handle empty paths in the user facing API. cairo_append_path() has an explicit check, and raises an error, for a NULL path->data, so we need to check the path->num_data first for empty paths.
2007-10-04 09:08:46 +01:00
cairo_destroy (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
if (status != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
[cairo-path] Check for an empty path in cairo_append_path(). As we now generate empty paths, we must be able to handle empty paths in the user facing API. cairo_append_path() has an explicit check, and raises an error, for a NULL path->data, so we need to check the path->num_data first for empty paths.
2007-10-04 09:08:46 +01:00
cr = cairo_create (surface);
path.data = NULL;
path.num_data = 1;
path.status = CAIRO_STATUS_SUCCESS;
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_NULL_POINTER) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cr = cairo_create (surface);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
/* Intentionally insert bogus header.length value (otherwise would be 2) */
data.header.type = CAIRO_PATH_MOVE_TO;
data.header.length = 1;
path.data = &data;
path.num_data = 1;
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_INVALID_PATH_DATA) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
/* And test the degnerate case */
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cr = cairo_create (surface);
* src/cairo.c: (cairo_copy_path), (cairo_copy_path_flat), (cairo_append_path): Rename cairo_copy_path_data, cairop_copy_path_data_flat, and cairo_append_path_data to cairo_copy_path, cairo_copy_path_flat, and cairo_append_path. Add new cairo_path_t, containing a cairo_path_data_t array and an explicit length. Remove CAIRO_PATH_END_PATH terminator from cairo_path_data_t. Rename the internal path object from cairo_path_t to cairo_path_real_t.
2005-03-18 14:28:53 +00:00
path.num_data = 0;
cairo_append_path (cr, &path);
[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 = cairo_status (cr);
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
cairo_destroy (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
if (status != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy (surface);
return CAIRO_TEST_FAILURE;
}
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +00:00
Remove cairo_set_target_surface and all other backend-specific cairo_set_target functions. Require a cairo_surface_t* to call cairo_create. Port to use new cairo_create interface. Rewrite all tests that were using cairo_set_target_surface to instead create a temporary cairo_t, (eventually to be replaced with cairo_begin_group).
2005-05-06 13:23:41 +00:00
cairo_surface_destroy (surface);
[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 CAIRO_TEST_SUCCESS;
Added some documentation, so we get some churn here. New functions: cairo_copy_path_data, cairo_copy_path_data_flat, and cairo_append_path_data. Add new implementation for cairo_copy_path_data and cairo_append_path_data. New test for new path_data functions.
2005-03-11 14:29:15 +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 (copy_path,
"Tests calls to path_data functions: cairo_copy_path, cairo_copy_path_flat, and cairo_append_path",
"path", /* keywords */
NULL, /* requirements */
45, 53,
preamble, draw)
Reference in a new issue Copy permalink