brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
eb7fafe700
mutter/test-fixtures/test-utils.h

157 lines
5.1 KiB
C
Raw Normal View History

Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
#ifndef _TEST_UTILS_H_
#define _TEST_UTILS_H_
tests: Adds our first white-box unit test This adds a white-box unit test that verifies that GL_BLEND is disabled when drawing an opaque rectangle, enabled when drawing a transparent rectangle and then disabled again when drawing a transparent rectangle but with a blend string that effectively disables blending. This shares the test utilities and launcher infrastructure we are using for conformance tests so we get consistent reporting and so unit tests will be run against a range of different drivers. This adds a --enable-unit-tests configure option which is enabled by default but if disabled will make all UNIT_TESTS() into static inline functions that we should expect the compiler to discard since they won't be referenced by anything. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 9047cce06bbf9051ec77e622be2fdbb96ed767a8)
2013-05-30 08:22:22 -04:00
#include <cogl/cogl.h>
Fixes for --disable-glib This fixes some problems which were stopping --disable-glib from working properly: • A lot of the public headers were including glib.h. This shouldn't be necessary because the API doesn't expose any glib types. Otherwise any apps would require glib in order to get the header. • The public headers were using G_BEGIN_DECLS. There is now a replacement macro called COGL_BEGIN_DECLS which is defined in cogl-types.h. • A similar fix has been done for G_GNUC_NULL_TERMINATED and G_GNUC_DEPRECATED. • The CFLAGS were not including $(builddir)/deps/glib which was preventing it finding the generated glibconfig.h when building out of tree. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4138b3141c2f39cddaea3d72bfc04342ed5092d0)
2012-11-22 13:01:10 -05:00
#include <glib.h>
Add -Wmissing-declarations to maintainer flags and fix problems This option to GCC makes it give a warning whenever a global function is defined without a declaration. This should catch cases were we've defined a function but forgot to put it in a header. In that case it is either only used within one file so we should make it static or we should declare it in a header. The following changes where made to fix problems: • Some functions were made static • cogl-path.h (the one containing the 1.0 API) was split into two files, one defining the functions and one defining the enums so that cogl-path.c can include the enum and function declarations from the 2.0 API as well as the function declarations from the 1.0 API. • cogl2-clip-state has been removed. This only had one experimental function called cogl_clip_push_from_path but as this is unstable we might as well remove it favour of the equivalent cogl_framebuffer_* API. • The GLX, SDL and WGL winsys's now have a private header to define their get_vtable function instead of directly declaring in the C file where it is called. • All places that were calling COGL_OBJECT_DEFINE need to have the cogl_is_whatever function declared so these have been added either as a public function or in a private header. • Some files that were not including the header containing their function declarations have been fixed to do so. • Any unused error quark functions have been removed. If we later want them we should add them back one by one and add a declaration for them in a header. • _cogl_is_framebuffer has been renamed to cogl_is_framebuffer and made a public function with a declaration in cogl-framebuffer.h • Similarly for CoglOnscreen. • cogl_vdraw_indexed_attributes is called cogl_framebuffer_vdraw_indexed_attributes in the header. The definition has been changed to match the header. • cogl_index_buffer_allocate has been removed. This had no declaration and I'm not sure what it's supposed to do. • CoglJournal has been changed to use the internal CoglObject macro so that it won't define an exported cogl_is_journal symbol. • The _cogl_blah_pointer_from_handle functions have been removed. CoglHandle isn't used much anymore anyway and in the few places where it is used I think it's safe to just use the implicit cast from void* to the right type. • The test-utils.h header for the conformance tests explicitly disables the -Wmissing-declaration option using a pragma because all of the tests declare their main function without a header. Any mistakes relating to missing declarations aren't really important for the tests. • cogl_quaternion_init_from_quaternion and init_from_matrix have been given declarations in cogl-quaternion.h Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 13:21:28 -05:00
/* We don't really care about functions that are defined without a
header for the unit tests so we can just disable it here */
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#endif
tests: Add a flag to say that the test is known to fail in all cases This renames the TestRequirement enum to TestFlags and then adds a TEST_KNOWN_FAILURE flag. The rename is because the new flag is not really a requirement. If the flag is set then the test is assumed to always fail. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:41:49 -05:00
typedef enum _TestFlags
Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
{
Add a conformance test for some wrap modes on a rectangle texture This adds a conformance test which renders a rectangle texture using the two wrap modes clamp-to-edge and repeat. It then verifies that the correct region of the texture is drawn for the texture coordinates that are > 1.0. The test currently always fails. The cogl_framebuffer_draw_rectangle function is documented to always take normalized texture coordinates regardless of the coordinate system of the texture. This works correctly if all of the texture coordinates are in the range [0.0,1.0] because cogl-primitives uses a different code path in that case. However if the multiple-quad code path is taken then the coordinates actually need to un-normalized for it to work. There is a comment in cogl_meta_texture_foreach_in_region() which implies that the incoming coordinates should always be normalized. The documentation for the callback says that the resulting sub-texture coordinates will always be in the coordinate system of the low-level texture. However it doesn't work out like this because the meta texture function uses the span iterating function which always returns normalized coordinates. It looks like there needs to be some more conversions going on somewhere. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit d2059bb32b8015060e10f41dbbb68d4230b47ddb)
2012-12-10 13:11:28 -05:00
TEST_KNOWN_FAILURE = 1<<0,
TEST_REQUIREMENT_GL = 1<<1,
TEST_REQUIREMENT_NPOT = 1<<2,
TEST_REQUIREMENT_TEXTURE_3D = 1<<3,
TEST_REQUIREMENT_TEXTURE_RECTANGLE = 1<<4,
TEST_REQUIREMENT_POINT_SPRITE = 1<<5,
TEST_REQUIREMENT_GLES2_CONTEXT = 1<<6,
TEST_REQUIREMENT_MAP_WRITE = 1<<7,
Add a test for getting the component sizes from different fbs This adds a test which creates two offscreen framebuffers, one with just an alpha component texture and the other will a full RGBA texture. The bit sizes of both framebuffers are then checked to verify that they either have or haven't got bits for the RGB components. The test currently fails because the framebuffer functions don't bind the framebuffer before querying so they just query whichever framebuffer happened to be used last. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 7ca01373efe908efc9f18f2cb7f4a51c274ef677)
2012-12-13 10:27:52 -05:00
TEST_REQUIREMENT_GLSL = 1<<8,
Add fence API cogl_framebuffer_add_fence creates a synchronisation fence, which will invoke a user-specified callback when the GPU has finished executing all commands provided to it up to that point in time. Support is currently provided for GL 3.x's GL_ARB_sync extension, and EGL's EGL_KHR_fence_sync (when used with OpenGL ES). Signed-off-by: Daniel Stone <daniel@fooishbar.org> Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> https://bugzilla.gnome.org/show_bug.cgi?id=691752 (cherry picked from commit e6d37470da9294adc1554c0a8c91aa2af560ed9f)
2013-01-10 20:13:34 -05:00
TEST_REQUIREMENT_OFFSCREEN = 1<<9,
TEST_REQUIREMENT_FENCE = 1<<10
tests: Add a flag to say that the test is known to fail in all cases This renames the TestRequirement enum to TestFlags and then adds a TEST_KNOWN_FAILURE flag. The rename is because the new flag is not really a requirement. If the flag is set then the test is assumed to always fail. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 18:41:49 -05:00
} TestFlags;
tests: Improve thoroughness and reporting of make test This patch reworks our conformance testing framework because it seems that glib's gtesting framework isn't really well suited to our use case. For example we weren't able to test windows builds given the way we were using it and also for each test we'd like to repeat the test with several different environments so we can test important driver and feature combinations. This patch instead switches away to a simplified but custom approach for running our unit tests. We hope that having a more bespoke setup will enable us to easily extend it to focus on the details important to us. Notable changes with this new approach are: We can now run 'make test' for our mingw windows builds. We've got rid of all the test-*report* make rules and we're just left with 'make test' 'make test' now runs each test several times with different driver and feature combinations checking the result for each run. 'make test' will then output a concise table of all of the results. The combinations tested are: - OpenGL Fixed Function - OpenGL ARBfp - OpenGL GLSL - OpenGL No NPOT texture support - OpenGLES 2.0 - OpenGLES 2.0 No NPOT texture support Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-23 07:30:51 -05:00
tests: update inline with master This renames the global ctx and fb variables to test_ctx and test_fb respectively in line with the names use on the master branch. This is to make it easier to cherry pick patches from master.
2013-01-18 12:57:06 -05:00
extern CoglContext *test_ctx;
extern CoglFramebuffer *test_fb;
Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
void
tests: Differentiate between known failures and missing requirements Previously when make test is run it would say ‘fail’ in lower case letters for both tests that are known bugs we need to fix and for drivers that can't run the test. This makes it too easy to lose track of bugs. To fix this, the ADD_TEST macro has now been changed to take two sets of flags instead of just one. The first specifies the requirements for the test to run at all. The second specifies the set of flags required to run without any known failures. The table in the test report now says ‘n/a’ instead of ‘fail’ for tests that don't match the feature requirements. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 723f8d4402e7b2ef3a71f51bb29b10d1c0ec8d81)
2012-11-09 11:47:01 -05:00
test_utils_init (TestFlags requirement_flags,
TestFlags known_failure_flags);
Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
void
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
test_utils_fini (void);
Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
/*
* test_utils_check_pixel:
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* @framebuffer: The #CoglFramebuffer to read from
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
* @x: x co-ordinate of the pixel to test
* @y: y co-ordinate of the pixel to test
* @pixel: An integer of the form 0xRRGGBBAA representing the expected
* pixel value
*
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* This performs reads a pixel on the given cogl @framebuffer and
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
* asserts that it matches the given color. The alpha channel of the
* color is ignored. The pixels are converted to a string and compared
* with g_assert_cmpstr so that if the comparison fails then the
* assert will display a meaningful message
*/
void
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
test_utils_check_pixel (CoglFramebuffer *framebuffer,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
int x, int y, uint32_t expected_pixel);
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
conform: Add color attribute based blending test This adds a test to make sure that if the same pipeline is used to draw two primitives, one which doesn't need blending because it has an opaque color associated, and another using a color attribute that requires blending then Cogl should recognize that it needs to enable blending for the second primitive even though the pipeline hasn't changed. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit c15d91f1c6293bebd4494d1e20586121483cddef)
2013-05-22 14:49:05 -04:00
/**
* @framebuffer: The #CoglFramebuffer to read from
* @x: x co-ordinate of the pixel to test
* @y: y co-ordinate of the pixel to test
* @pixel: An integer of the form 0xRRGGBBAA representing the expected
* pixel value
*
* This performs reads a pixel on the given cogl @framebuffer and
* asserts that it matches the given color. The alpha channel is also
* checked unlike with test_utils_check_pixel(). The pixels are
* converted to a string and compared with g_assert_cmpstr so that if
* the comparison fails then the assert will display a meaningful
* message.
*/
void
test_utils_check_pixel_and_alpha (CoglFramebuffer *fb,
int x, int y, uint32_t expected_pixel);
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
/*
* test_utils_check_pixel:
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* @framebuffer: The #CoglFramebuffer to read from
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
* @x: x co-ordinate of the pixel to test
* @y: y co-ordinate of the pixel to test
* @pixel: An integer of the form 0xrrggbb representing the expected pixel value
*
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* This performs reads a pixel on the given cogl @framebuffer and
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
* asserts that it matches the given color. The alpha channel of the
* color is ignored. The pixels are converted to a string and compared
* with g_assert_cmpstr so that if the comparison fails then the
* assert will display a meaningful message
*/
void
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
test_utils_check_pixel_rgb (CoglFramebuffer *framebuffer,
int x, int y, int r, int g, int b);
tests: Add a utility function for reading a pixel Most of the conformance tests read a pixel value and assert that it matches a known value. However they were all doing this with slightly different methods. This adds a common test_utils_check_pixel function which they now all use. The function takes an x and y coordinate and a 32-bit value representing the color. It is assumed that writing a known color is most convenient as an 8 digit hex sequence which this function allows. There is also a test_utils_check_pixel_rgb function wrapper which takes the components as separate arguments. This is more convenient when the expected color is also calculated by the test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-26 09:15:14 -04:00
tests: Adds test_utils_check_region() utility api For conformance tests that want to read back a region of pixels and check they all have the same color we now have a test_utils_check_region utility function for that. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-31 10:55:20 -04:00
/*
* test_utils_check_region:
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* @framebuffer: The #CoglFramebuffer to read from
tests: Adds test_utils_check_region() utility api For conformance tests that want to read back a region of pixels and check they all have the same color we now have a test_utils_check_region utility function for that. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-31 10:55:20 -04:00
* @x: x co-ordinate of the region to test
* @y: y co-ordinate of the region to test
* @width: width of the region to test
* @height: height of the region to test
* @pixel: An integer of the form 0xrrggbb representing the expected region color
*
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
* Performs a read pixel on the specified region of the given cogl
* @framebuffer and asserts that it matches the given color. The alpha
tests: Adds test_utils_check_region() utility api For conformance tests that want to read back a region of pixels and check they all have the same color we now have a test_utils_check_region utility function for that. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-31 10:55:20 -04:00
* channel of the color is ignored. The pixels are converted to a
* string and compared with g_assert_cmpstr so that if the comparison
* fails then the assert will display a meaningful message
*/
void
Adds cogl_framebuffer_draw_[*_]rectangle functions This adds experimental 2.0 api replacements for the cogl_rectangle[_*] functions that don't depend on having a current pipeline set on the context via cogl_{set,push}_source() or having a current framebuffer set on the context via cogl_push_framebuffer(). The aim for 2.0 is to switch away from having a statefull context that affects drawing to having framebuffer drawing apis that are explicitly passed a framebuffer and pipeline. To test this change several of the conformance tests were updated to use this api instead of cogl_rectangle and cogl_rectangle_with_texture_coords. Since it's quite laborious going through all of the conformance tests the opportunity was taken to make other clean ups in the conformance tests to replace other uses of 1.x api with experimental 2.0 api so long as that didn't affect what was being tested.
2012-03-16 15:54:13 -04:00
test_utils_check_region (CoglFramebuffer *framebuffer,
int x, int y,
tests: Adds test_utils_check_region() utility api For conformance tests that want to read back a region of pixels and check they all have the same color we now have a test_utils_check_region utility function for that. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-31 10:55:20 -04:00
int width, int height,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint32_t expected_rgba);
tests: Adds test_utils_check_region() utility api For conformance tests that want to read back a region of pixels and check they all have the same color we now have a test_utils_check_region utility function for that. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-31 10:55:20 -04:00
test-utils: Expose the compare_pixel function The compare pixel function was a static function used internally by the test_utils_check_* functions. It takes a pointer to a pixel in a buffer read back from Cogl and compares it with an expected value. This function could also be useful in tests wanting to check the data returned from a call to cogl_texture_get_data so we should share it with the rest of the tests. https://bugzilla.gnome.org/show_bug.cgi?id=668913 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-28 08:40:22 -05:00
/*
* test_utils_compare_pixel:
* @screen_pixel: A pixel stored in memory
* @expected_pixel: The expected RGBA value
*
* Compares a pixel from a buffer to an expected value. The pixels are
* converted to a string and compared with g_assert_cmpstr so that if
* the comparison fails then the assert will display a meaningful
* message.
*/
void
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
test_utils_compare_pixel (const uint8_t *screen_pixel, uint32_t expected_pixel);
test-utils: Expose the compare_pixel function The compare pixel function was a static function used internally by the test_utils_check_* functions. It takes a pointer to a pixel in a buffer read back from Cogl and compares it with an expected value. This function could also be useful in tests wanting to check the data returned from a call to cogl_texture_get_data so we should share it with the rest of the tests. https://bugzilla.gnome.org/show_bug.cgi?id=668913 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-28 08:40:22 -05:00
test-write-texture-formats: Add fuzziness to the pixel comparisons The rounding used when storing 10-bit per component data into an 8-bit per component texture seems to have changed in recent versions of Mesa which was causing this test to fail. I've also noticed this failing on the NVidia binary driver. This patch adds some fuzziness to the comparison so that it will pass. There is a new test_utils function called test_utils_compare_pixel_and_alpha which is the same as test_utils_compare_pixel except that it also compares the alpha component. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ce626fb3939b0f200d85ccdf32809608b879212d)
2013-01-21 13:43:24 -05:00
/*
* test_utils_compare_pixel_and_alpha:
* @screen_pixel: A pixel stored in memory
* @expected_pixel: The expected RGBA value
*
* Compares a pixel from a buffer to an expected value. This is
* similar to test_utils_compare_pixel() except that it doesn't ignore
* the alpha component.
*/
void
test_utils_compare_pixel_and_alpha (const uint8_t *screen_pixel,
uint32_t expected_pixel);
tests: Move the create_color_texture function to test-utils This adds a shared utility function to create a 1x1 texture with a given color. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-10 11:57:24 -05:00
/*
* test_utils_create_color_texture:
* @context: A #CoglContext
* @color: A color to put in the texture
*
* Creates a 1x1-pixel RGBA texture filled with the given color.
*/
CoglTexture *
test_utils_create_color_texture (CoglContext *context,
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint32_t color);
tests: Move the create_color_texture function to test-utils This adds a shared utility function to create a 1x1 texture with a given color. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-10 11:57:24 -05:00
tests: Improve thoroughness and reporting of make test This patch reworks our conformance testing framework because it seems that glib's gtesting framework isn't really well suited to our use case. For example we weren't able to test windows builds given the way we were using it and also for each test we'd like to repeat the test with several different environments so we can test important driver and feature combinations. This patch instead switches away to a simplified but custom approach for running our unit tests. We hope that having a more bespoke setup will enable us to easily extend it to focus on the details important to us. Notable changes with this new approach are: We can now run 'make test' for our mingw windows builds. We've got rid of all the test-*report* make rules and we're just left with 'make test' 'make test' now runs each test several times with different driver and feature combinations checking the result for each run. 'make test' will then output a concise table of all of the results. The combinations tested are: - OpenGL Fixed Function - OpenGL ARBfp - OpenGL GLSL - OpenGL No NPOT texture support - OpenGLES 2.0 - OpenGLES 2.0 No NPOT texture support Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-23 07:30:51 -05:00
/* cogl_test_verbose:
*
* Queries if the user asked for verbose output or not.
*/
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool
tests: Improve thoroughness and reporting of make test This patch reworks our conformance testing framework because it seems that glib's gtesting framework isn't really well suited to our use case. For example we weren't able to test windows builds given the way we were using it and also for each test we'd like to repeat the test with several different environments so we can test important driver and feature combinations. This patch instead switches away to a simplified but custom approach for running our unit tests. We hope that having a more bespoke setup will enable us to easily extend it to focus on the details important to us. Notable changes with this new approach are: We can now run 'make test' for our mingw windows builds. We've got rid of all the test-*report* make rules and we're just left with 'make test' 'make test' now runs each test several times with different driver and feature combinations checking the result for each run. 'make test' will then output a concise table of all of the results. The combinations tested are: - OpenGL Fixed Function - OpenGL ARBfp - OpenGL GLSL - OpenGL No NPOT texture support - OpenGLES 2.0 - OpenGLES 2.0 No NPOT texture support Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-23 07:30:51 -05:00
cogl_test_verbose (void);
Starts porting Cogl conformance tests from Clutter This makes a start on porting the Cogl conformance tests that currently still live in the Clutter repository to be standalone Cogl tests that no longer require a ClutterStage. The main thing is that this commit brings in is the basic testing infrastructure we need, so now we can port more and more tests incrementally. Since the test suite wants a way to synchronize X requests/replies and we can't simply call XSynchronize in the test-utils code before we know if we are really running on X this adds a check for an environment variable named "COGL_X11_SYNC" in cogl-xlib-renderer.c and if it's set it forces XSynchronize (dpy, TRUE) to be called. By default the conformance tests are run off screen. This makes the tests run much faster and they also don't interfere with other work you may want to do by constantly stealing focus. CoglOnscreen framebuffers obviously don't get tested this way so it's important that the tests also get run on screen every once in a while, especially if changes are being made to CoglFramebuffer related code. On screen testing can be enabled by setting COGL_TEST_ONSCREEN=1 in your environment.
2011-05-05 18:34:38 -04:00
#endif /* _TEST_UTILS_H_ */
Reference in New Issue Copy Permalink