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

375 lines
12 KiB
C
Raw Normal View History

test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/*
* Copyright © 2007 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Author: Carl Worth <cworth@cworth.org>
*/
Move _GNU_SOURCE declarations to where it's used Such that we don't rely on more GNU extensions accidentally.
2008-09-02 21:50:08 -04:00
#define _ISOC99_SOURCE /* for INFINITY */
#define _GNU_SOURCE 1 /* for fedisableeexcept() et al */
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
#include "cairo-test.h"
[test] Define INFINITY on MSVC 1./0. produces a compiler error on MSVC so we'll use HUGEVAL instead.
2009-02-09 15:12:41 -05:00
#if !defined(INFINITY) && defined(_MSC_VER)
#define INFINITY HUGE_VAL
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
#endif
[test/invalid-matrix] Disable floating point exception. test/invalid-matrix purposely feeds invalid numbers into cairo, in order to check its detection of garbage values. In doing so, cairo raises an Invalid exception, but as this is a direct result of an abuse of the API we can treat it as expected behaviour and ignore the exception.
2008-05-06 11:31:14 +01:00
#if HAVE_FEDISABLEEXCEPT
#include <fenv.h>
#endif
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07: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);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_status_t status;
cairo_surface_t *target;
cairo_font_face_t *font_face;
cairo_font_options_t *font_options;
cairo_scaled_font_t *scaled_font;
cairo_pattern_t *pattern;
cairo_t *cr2;
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
cairo_matrix_t identity, bogus, inf, invalid = {
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
4.0, 4.0,
4.0, 4.0,
4.0, 4.0
};
#define CHECK_STATUS(status, function_name) \
if ((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: %s with invalid matrix passed\n", \
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
(function_name)); \
return CAIRO_TEST_FAILURE; \
} else if ((status) != CAIRO_STATUS_INVALID_MATRIX) { \
[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: %s with invalid matrix returned unexpected status " \
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
"(%d): %s\n", \
(function_name), \
status, \
cairo_status_to_string (status)); \
[test/invalid-matrix] Promote incorrect status warning to an error. As the last warning for an incorrect status has been resolved, throw an error if we regress and no longer report an INVALID_MATRIX under testing.
2008-02-11 16:45:18 +00:00
return CAIRO_TEST_FAILURE; \
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
}
[test/invalid-matrix] Disable floating point exception. test/invalid-matrix purposely feeds invalid numbers into cairo, in order to check its detection of garbage values. In doing so, cairo raises an Invalid exception, but as this is a direct result of an abuse of the API we can treat it as expected behaviour and ignore the exception.
2008-05-06 11:31:14 +01:00
/* clear floating point exceptions (added by cairo_test_init()) */
#if HAVE_FEDISABLEEXCEPT
fedisableexcept (FE_INVALID);
#endif
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
/* create a bogus matrix and check results of attempted inversion */
[test] Add cairo_test_NaN and use it in place of strtod strtod("NaN") returns 0.0 with the MSVC runtime so we need to generate NaN some other way.
2009-02-11 15:24:20 -05:00
bogus.x0 = bogus.xy = bogus.xx = cairo_test_NaN ();
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
bogus.y0 = bogus.yx = bogus.yy = bogus.xx;
status = cairo_matrix_invert (&bogus);
CHECK_STATUS (status, "cairo_matrix_invert(NaN)");
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
inf.x0 = inf.xy = inf.xx = INFINITY;
inf.y0 = inf.yx = inf.yy = inf.xx;
status = cairo_matrix_invert (&inf);
CHECK_STATUS (status, "cairo_matrix_invert(infinity)");
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
/* test cairo_matrix_invert with invalid matrix */
status = cairo_matrix_invert (&invalid);
CHECK_STATUS (status, "cairo_matrix_invert(invalid)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_matrix_init_identity (&identity);
[test/*] Create new surfaces using the group target. cairo_get_target() returns the original surface passed to cairo_create(), and not the current destination as required when testing drawing to the same surface using multiple contexts. For completeness we also use the group target when creating similar surfaces within the tests (to check that similar surfaces of similar surfaces also work).
2007-12-20 18:15:48 +00:00
target = cairo_get_group_target (cr);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/* test cairo_transform with invalid matrix */
cr2 = cairo_create (target);
cairo_transform (cr2, &invalid);
status = cairo_status (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_transform(invalid)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
/* test cairo_transform with bogus matrix */
cr2 = cairo_create (target);
cairo_transform (cr2, &bogus);
status = cairo_status (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_destroy (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_transform(NaN)");
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
/* test cairo_transform with ∞ matrix */
cr2 = cairo_create (target);
cairo_transform (cr2, &inf);
status = cairo_status (cr2);
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_transform(infinity)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/* test cairo_set_matrix with invalid matrix */
cr2 = cairo_create (target);
cairo_set_matrix (cr2, &invalid);
status = cairo_status (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_set_matrix(invalid)");
/* test cairo_set_matrix with bogus matrix */
cr2 = cairo_create (target);
cairo_set_matrix (cr2, &bogus);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
status = cairo_status (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_destroy (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_set_matrix(NaN)");
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
/* test cairo_set_matrix with ∞ matrix */
cr2 = cairo_create (target);
cairo_set_matrix (cr2, &inf);
status = cairo_status (cr2);
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_set_matrix(infinity)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/* test cairo_set_font_matrix with invalid matrix */
cr2 = cairo_create (target);
cairo_set_font_matrix (cr2, &invalid);
/* draw some text to force the font to be resolved */
cairo_show_text (cr2, "hello");
status = cairo_status (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_set_font_matrix(invalid)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
/* test cairo_set_font_matrix with bogus matrix */
cr2 = cairo_create (target);
cairo_set_font_matrix (cr2, &bogus);
/* draw some text to force the font to be resolved */
cairo_show_text (cr2, "hello");
status = cairo_status (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_destroy (cr2);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_set_font_matrix(NaN)");
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
/* test cairo_set_font_matrix with ∞ matrix */
cr2 = cairo_create (target);
cairo_set_font_matrix (cr2, &inf);
/* draw some text to force the font to be resolved */
cairo_show_text (cr2, "hello");
status = cairo_status (cr2);
cairo_destroy (cr2);
CHECK_STATUS (status, "cairo_set_font_matrix(infinity)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/* test cairo_scaled_font_create with invalid matrix */
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
cr2 = cairo_create (target);
font_face = cairo_get_font_face (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&invalid,
&identity,
font_options);
status = cairo_scaled_font_status (scaled_font);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_scaled_font_create(invalid)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_scaled_font_destroy (scaled_font);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&invalid,
font_options);
status = cairo_scaled_font_status (scaled_font);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_scaled_font_create(invalid)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
cairo_destroy (cr2);
/* test cairo_scaled_font_create with bogus matrix */
cr2 = cairo_create (target);
font_face = cairo_get_font_face (cr2);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&bogus,
&identity,
font_options);
status = cairo_scaled_font_status (scaled_font);
CHECK_STATUS (status, "cairo_scaled_font_create(NaN)");
cairo_scaled_font_destroy (scaled_font);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&bogus,
font_options);
status = cairo_scaled_font_status (scaled_font);
CHECK_STATUS (status, "cairo_scaled_font_create(NaN)");
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
cairo_destroy (cr2);
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
/* test cairo_scaled_font_create with ∞ matrix */
cr2 = cairo_create (target);
font_face = cairo_get_font_face (cr2);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&inf,
&identity,
font_options);
status = cairo_scaled_font_status (scaled_font);
CHECK_STATUS (status, "cairo_scaled_font_create(infinity)");
cairo_scaled_font_destroy (scaled_font);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&inf,
font_options);
status = cairo_scaled_font_status (scaled_font);
CHECK_STATUS (status, "cairo_scaled_font_create(infinity)");
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
cairo_destroy (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
/* test cairo_pattern_set_matrix with invalid matrix */
pattern = cairo_pattern_create_rgb (1.0, 1.0, 1.0);
cairo_pattern_set_matrix (pattern, &invalid);
status = cairo_pattern_status (pattern);
[cairo-matrix] Check determinant for invalid numbers. By checking matrices for invalid determinants, we can prevent the setting and application of invalid matrices. The trick used here is that NaNs, as specified by IEE754, always return FALSE in comparisons. Since we know that the square of the determinant must be positive definite, then if the comparison is FALSE the computation must have resulted in a NaN.
2007-07-05 18:52:21 +01:00
CHECK_STATUS (status, "cairo_pattern_set_matrix(invalid)");
cairo_pattern_destroy (pattern);
/* test cairo_pattern_set_matrix with bogus matrix */
pattern = cairo_pattern_create_rgb (1.0, 1.0, 1.0);
cairo_pattern_set_matrix (pattern, &bogus);
status = cairo_pattern_status (pattern);
CHECK_STATUS (status, "cairo_pattern_set_matrix(NaN)");
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
cairo_pattern_destroy (pattern);
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
/* test cairo_pattern_set_matrix with ∞ matrix */
pattern = cairo_pattern_create_rgb (1.0, 1.0, 1.0);
cairo_pattern_set_matrix (pattern, &inf);
status = cairo_pattern_status (pattern);
CHECK_STATUS (status, "cairo_pattern_set_matrix(infinity)");
cairo_pattern_destroy (pattern);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07:00
[test/invalid] Test cairo_translate() and friends for NaN safety. Pass NaNs to cairo_translate() and friends and check that they raise an INVALID_MATRIX error.
2008-01-17 23:05:53 +00:00
/* test invalid transformations */
cr2 = cairo_create (target);
cairo_translate (cr2, bogus.xx, bogus.yy);
CHECK_STATUS (status, "cairo_translate(NaN, NaN)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_translate (cr2, 0, bogus.yy);
CHECK_STATUS (status, "cairo_translate(0, NaN)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_translate (cr2, bogus.xx, 0);
CHECK_STATUS (status, "cairo_translate(NaN, 0)");
cairo_destroy (cr2);
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
cr2 = cairo_create (target);
cairo_translate (cr2, inf.xx, inf.yy);
CHECK_STATUS (status, "cairo_translate(∞, ∞)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_translate (cr2, 0, inf.yy);
CHECK_STATUS (status, "cairo_translate(0, ∞)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_translate (cr2, inf.xx, 0);
CHECK_STATUS (status, "cairo_translate(∞, 0)");
cairo_destroy (cr2);
[test/invalid] Test cairo_translate() and friends for NaN safety. Pass NaNs to cairo_translate() and friends and check that they raise an INVALID_MATRIX error.
2008-01-17 23:05:53 +00:00
cr2 = cairo_create (target);
cairo_scale (cr2, bogus.xx, bogus.yy);
CHECK_STATUS (status, "cairo_scale(NaN, NaN)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, 1, bogus.yy);
CHECK_STATUS (status, "cairo_scale(1, NaN)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, bogus.xx, 1);
CHECK_STATUS (status, "cairo_scale(NaN, 1)");
cairo_destroy (cr2);
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
cr2 = cairo_create (target);
cairo_scale (cr2, inf.xx, inf.yy);
CHECK_STATUS (status, "cairo_scale(∞, ∞)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, 1, inf.yy);
CHECK_STATUS (status, "cairo_scale(1, ∞)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, inf.xx, 1);
CHECK_STATUS (status, "cairo_scale(∞, 1)");
cairo_destroy (cr2);
[test/invalid-matrix] Check scale(0,0) Test that INVALID_MATRIX is returned if the user calls cairo_scale(0,0) or a variant thereof.
2008-02-11 16:48:24 +00:00
cr2 = cairo_create (target);
cairo_scale (cr2, bogus.xx, bogus.yy);
CHECK_STATUS (status, "cairo_scale(0, 0)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, 1, bogus.yy);
CHECK_STATUS (status, "cairo_scale(1, 0)");
cairo_destroy (cr2);
cr2 = cairo_create (target);
cairo_scale (cr2, bogus.xx, 1);
CHECK_STATUS (status, "cairo_scale(0, 1)");
cairo_destroy (cr2);
[test/invalid] Test cairo_translate() and friends for NaN safety. Pass NaNs to cairo_translate() and friends and check that they raise an INVALID_MATRIX error.
2008-01-17 23:05:53 +00:00
cr2 = cairo_create (target);
cairo_rotate (cr2, bogus.xx);
CHECK_STATUS (status, "cairo_rotate(NaN)");
cairo_destroy (cr2);
[test/invalid-matrix] Test detection of infinities. Feed infinities into the API and check that we correctly return INVALID_MATRIX.
2008-02-11 17:00:30 +00:00
cr2 = cairo_create (target);
cairo_rotate (cr2, inf.xx);
CHECK_STATUS (status, "cairo_rotate(∞)");
cairo_destroy (cr2);
test/invalid-matrix: Add new test to exercise CAIRO_STATUS_INVALID_MATRIX paths This new test exercises every path where the user might possibly pass in an invalid matrix. Currently the test fails if no error is reported. Also, if an incorrect error is reported, (such as CAIRO_STATUS_NO_MEMORY instead of CAIRO_STATUS_INVALID_MATRIX), this is logged as a warning in invalid-matrix.log, but the test still passes. It would still be worthwhile to follow up quickly and fix those cases to propagate the correct error value.
2007-04-10 22:55:00 -07: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
CAIRO_TEST (invalid_matrix,
"Test that all relevant public functions return CAIRO_STATUS_INVALID_MATRIX as appropriate",
"api, matrix", /* keywords */
NULL, /* requirements */
0, 0,
NULL, draw)
Reference in a new issue Copy permalink