fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2025-12-20 16:20:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
cairo/test/create-from-png.c

321 lines
11 KiB
C
Raw Normal View History

Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +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 Worth <cworth@cworth.org>
*/
#include "cairo-test.h"
#include <stdlib.h>
#define WIDTH 2
#define HEIGHT 2
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
static cairo_status_t
no_memory_error (void *closure, unsigned char *data, unsigned int size)
{
return CAIRO_STATUS_NO_MEMORY;
}
static cairo_status_t
read_error (void *closure, unsigned char *data, unsigned int size)
{
return CAIRO_STATUS_READ_ERROR;
}
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +00:00
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);
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +00:00
char *filename;
cairo_surface_t *surface;
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/reference/%s",
ctx->srcdir, "create-from-png.ref.png");
Factor out bulk of the code into a new callback based function, write_png(). Call it with a stdio write callback. (cairo_surface_write_png_to_stream): New function to write a surface to a PNG stream. (cairo_image_surface_create_from_png): Likewise, move most of the code to read_png(), clean up error handling and reduce this function to calling read_png() with a stdio based read function. (cairo_image_surface_create_from_png_stream): New function to create an image surface from a PNG stream. New functions to get widht and height of an image surface. Add new prototype and error codes. Adjust to new PNG API.
2005-04-25 20:42:54 +00:00
surface = cairo_image_surface_create_from_png (filename);
Fix so that one of three different error status values will be returned: CAIRO_STATUS_NO_MEMORY CAIRO_STATUS_FILE_NOT_FOUND CAIRO_STATUS_READ_ERROR Add new CAIRO_STATUS_FILE_NOT_FOUND. Add new _cairo_surface_nil_read_error and _cairo_surface_nil_file_not_found. Test the new FILE_NOT_FOUND error.
2005-07-28 10:41:08 +00:00
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
cairo_test_status_t result;
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
Fix typo that caused cairo_image_surface_create_from_png_stream to segfault. Closes bug #3863 (thanks to Steve Chaplin). Add a test to actually call cairo_image_surface_create_from_png_stream.
2005-07-27 09:23:29 +00:00
free (filename);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
return result;
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +00:00
}
Fix typo that caused cairo_image_surface_create_from_png_stream to segfault. Closes bug #3863 (thanks to Steve Chaplin). Add a test to actually call cairo_image_surface_create_from_png_stream.
2005-07-27 09:23:29 +00:00
create-from-png*: Test mark_dirty with mime data This currently hits the following assertion: lt-cairo-test-suite: cairo-surface.c:1381: cairo_surface_mark_dirty_rectangle: Assertion `! _cairo_surface_has_mime_data (surface)' failed. Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=41409 Signed-off-by: Uli Schlachter <psychon@znc.in>
2011-10-08 13:37:20 +02:00
/* Pretend we modify the surface data (which detaches the PNG mime data) */
cairo_surface_flush (surface);
cairo_surface_mark_dirty (surface);
Originally 2005-04-20 Carl Worth <cworth@cworth.org> Remove cairo_show_surface. Add new cairo_set_source_surface. Remove _cairo_gstate_show_surface. Replace calls to cairo_show_surface with cairo_set_source_surface; cairo_paint. Fix messages to prefer - over _. Fix documentation. Three new tests to exercise set_source_surface more completely, (two of these are expected failures dues to outstanding bugs).
2005-05-03 08:33:32 +00:00
cairo_set_source_surface (cr, surface, 0, 0);
PS/PDF: Set image Interpolation flag If the filter mode is anything other than DEFAILT, FAST or NEAREST set the Interpolate flag in the image dictionary so that a smoothing filter is applied when rasterising the vector file. As we have no control over the implementation of the Interpolate filter (the PS/PDF specifications leave it undefined) we need to capture the output of poppler/GS and update our reference images. (For a couple of tests, the filtering is irrelevant so for those we set the filter to NEAREST.) Note that GhostScript's Interpolate filter does not work on rotated images (and a variety of other transformations) so several of the PS reference images have use nearest-neighbour sampling instead of a bilinear filter.
2008-04-05 13:32:51 +10:30
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
Originally 2005-04-20 Carl Worth <cworth@cworth.org> Remove cairo_show_surface. Add new cairo_set_source_surface. Remove _cairo_gstate_show_surface. Replace calls to cairo_show_surface with cairo_set_source_surface; cairo_paint. Fix messages to prefer - over _. Fix documentation. Three new tests to exercise set_source_surface more completely, (two of these are expected failures dues to outstanding bugs).
2005-05-03 08:33:32 +00:00
cairo_paint (cr);
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +00:00
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
free (filename);
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +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)
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +00:00
{
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
char *filename;
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
char *path;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
cairo_surface_t *surface;
cairo_status_t status;
[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_status_t result = CAIRO_TEST_SUCCESS;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
surface = cairo_image_surface_create_from_png ("___THIS_FILE_DOES_NOT_EXIST___");
if (cairo_surface_status (surface) != CAIRO_STATUS_FILE_NOT_FOUND) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"file not found\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01: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
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
surface = cairo_image_surface_create_from_png_stream (no_memory_error, NULL);
if (cairo_surface_status (surface) != CAIRO_STATUS_NO_MEMORY) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01: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
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
surface = cairo_image_surface_create_from_png_stream (read_error, NULL);
if (cairo_surface_status (surface) != CAIRO_STATUS_READ_ERROR) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01: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
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
/* cheekily test error propagation from the user write funcs as well ... */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&path, "%s/reference", ctx->srcdir);
xasprintf (&filename, "%s/%s", path, "create-from-png.ref.png");
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else {
status = cairo_surface_write_to_png_stream (surface,
(cairo_write_func_t) no_memory_error,
NULL);
if (status != CAIRO_STATUS_NO_MEMORY) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx, status);
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n",
cairo_status_to_string (status));
}
[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-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01: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 = cairo_surface_write_to_png_stream (surface,
(cairo_write_func_t) read_error,
NULL);
if (status != CAIRO_STATUS_READ_ERROR) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx, status);
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n",
cairo_status_to_string (status));
}
[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
}
/* and check that error has not propagated to the surface */
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: user write error propagated to surface: %s",
cairo_status_to_string (cairo_surface_status (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-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
}
cairo_surface_destroy (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
free (filename);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[cairo-png] Propagate error from read and write funcs. Use the png_struct->error_ptr to propagate the error status from the user/stdio read and write functions through the png_error() to the cairo_surface_write_to_png*() and cairo_surface_read_from_png*() functions. From there the error is returned back to the user either directly or as the most appropriate error surface. (Fixes https://bugs.freedesktop.org/show_bug.cgi?id=6909)
2007-09-25 23:35:25 +01:00
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
/* check that loading alpha/opaque PNGs generate the correct surfaces */
test: Add special cases for create-from-png and fallback-resolution These tests use reference images somewhat differently from other tests, so treat them as special cases and avoid recommending deleting any of their files. Add TODO's to each test to rework them to be more consistent with other tests. Signed-off-by: Bryce Harrington <b.harrington@samsung.com>
2013-07-03 22:37:41 +00:00
/* TODO: Avoid using target-specific references as sample images */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.alpha.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
[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_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
[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_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
/* check paletted PNGs */
test: Add special cases for create-from-png and fallback-resolution These tests use reference images somewhat differently from other tests, so treat them as special cases and avoid recommending deleting any of their files. Add TODO's to each test to rework them to be more consistent with other tests. Signed-off-by: Bryce Harrington <b.harrington@samsung.com>
2013-07-03 22:37:41 +00:00
/* TODO: Avoid using target-specific references as sample images */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.indexed-alpha.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
[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_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
test: Add special cases for create-from-png and fallback-resolution These tests use reference images somewhat differently from other tests, so treat them as special cases and avoid recommending deleting any of their files. Add TODO's to each test to rework them to be more consistent with other tests. Signed-off-by: Bryce Harrington <b.harrington@samsung.com>
2013-07-03 22:37:41 +00:00
/* TODO: Avoid using target-specific references as sample images */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.indexed.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
[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_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
/* check grayscale PNGs */
test: Add special cases for create-from-png and fallback-resolution These tests use reference images somewhat differently from other tests, so treat them as special cases and avoid recommending deleting any of their files. Add TODO's to each test to rework them to be more consistent with other tests. Signed-off-by: Bryce Harrington <b.harrington@samsung.com>
2013-07-03 22:37:41 +00:00
/* TODO: Avoid using target-specific references as sample images */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.gray-alpha.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
[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_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
if (result != CAIRO_TEST_SUCCESS)
return result;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
test: Add special cases for create-from-png and fallback-resolution These tests use reference images somewhat differently from other tests, so treat them as special cases and avoid recommending deleting any of their files. Add TODO's to each test to rework them to be more consistent with other tests. Signed-off-by: Bryce Harrington <b.harrington@samsung.com>
2013-07-03 22:37:41 +00:00
/* TODO: Avoid using target-specific references as sample images */
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
xasprintf (&filename, "%s/%s", path, "create-from-png.gray.ref.png");
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
[test] Memfault checks. Don't assume an error means the test failed, check for injected allocation errors.
2009-03-30 13:41:00 +01:00
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (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
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
[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_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
[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
filename);
result = CAIRO_TEST_FAILURE;
[test/create-from-png] Check loading of various colour types. Check that when loading from index/gray/rgb PNGs, with and without alpha/transparency, that the correct surface is generated by read_png(), i.e. if the PNG contains an alpha channel then the image must be an ARGB32 surface.
2008-04-21 19:44:11 +01:00
}
free (filename);
cairo_surface_destroy (surface);
test/create-from-png: Update to point to new reference/ images Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-09-23 13:20:14 +01:00
free (path);
[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 result;
Change type of data parameter from char* to unsigned char*. Propagate the unsigned char* change down the stack. Add cast since XImage uses char* rather than unsigned char*. Fix memory leak of image data. Switch to use cairo_surface_write_png rather than a custom write_png_argb32. Add test to exercise the cairo_image_surface_create_for_png function.
2005-04-04 09:47:12 +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 (create_from_png,
"Tests the creation of an image surface from a PNG file",
"png", /* keywords */
NULL, /* requirements */
WIDTH, HEIGHT,
preamble, draw)
Reference in a new issue Copy permalink