isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 20:32:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
447488dd5b
mutter/tests/conform/Makefile.am

228 lines
6.6 KiB
Makefile
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 22:34:38 +00:00
include $(top_srcdir)/build/autotools/Makefile.am.silent
NULL =
noinst_PROGRAMS = test-conformance
common_sources = \
test-conform-main.c \
$(NULL)
unported_test_sources = \
test-fixed.c \
test-materials.c \
test-viewport.c \
test-multitexture.c \
test-npot-texture.c \
test-object.c \
test-readpixels.c \
test-texture-mipmaps.c \
test-texture-pixmap-x11.c \
test-texture-rectangle.c \
test-vertex-buffer-contiguous.c \
test-vertex-buffer-interleved.c \
test-vertex-buffer-mutability.c \
$(NULL)
test_sources = \
Convert the test-atlas-migration test to a standalone Cogl test This updates test-atlas-migration from being a Clutter-based test to a Cogl-based test. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 32c5a3ed546effd2e2946f22f173a20cf36b2fdf)
2012-05-16 11:57:32 +00:00
test-atlas-migration.c \
tests: Port blend-strings to test both the legacy and the new API https://bugzilla.gnome.org/show_bug.cgi?id=660617 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-02 08:22:43 +00:00
test-blend-strings.c \
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 18:49:05 +00:00
test-blend.c \
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 22:34:38 +00:00
test-depth-test.c \
tests: Add a test for the RGB <-> HSL functions Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 32d67c2bf40641b2d1d30fa2d994013c3e6ce5bc)
2013-05-14 20:26:30 +00:00
test-color-hsl.c \
Add a conformance test for setting the color mask on a framebuffer There is a currently a bug where pushing a buffer with a different color mask will not cause the color mask to be flushed. This adds a test to demonstrate that. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-15 12:12:27 +00:00
test-color-mask.c \
Port the backface culling test This ports the backface culling conformance test to work without Clutter. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-19 14:24:36 +00:00
test-backface-culling.c \
Port just-vertex-shader to test both the legacy and the new API Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-01 07:07:36 +00:00
test-just-vertex-shader.c \
Port the pipeline-user-matrix conformance test from Clutter Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-01 09:04:32 +00:00
test-pipeline-user-matrix.c \
Add a conformance test for setting uniforms on a pipeline The tests tries all of the various combinations of setting uniform values on a pipeline and verifies the expected results with a some example shaders. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-03 17:28:01 +00:00
test-pipeline-uniforms.c \
Port the test-pixel-buffer test This ports the text-pixel-buffer test from being a Clutter test to a straight Cogl test. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-25 21:00:55 +00:00
test-pixel-buffer.c \
tests: Port test-premult This ports the test-offscreen test from being a Clutter test to a straight Cogl test. https://bugzilla.gnome.org/show_bug.cgi?id=660617 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-04-02 22:41:54 +00:00
test-premult.c \
Add a conformance test for CoglSnippets This adds a conformance test testing various operations on CoglSnippets. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-11-17 16:52:50 +00:00
test-snippets.c \
tests: ports test-wrap-modes.c to be standalone cogl test This ports test-wrap-modes.c from being a clutter based test to one that is a standalone cogl test. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-12 16:12:08 +00:00
test-wrap-modes.c \
tests: ports test-sub-texture to not depend on clutter As part of the on going effort to port the conformance tests that were originally written as clutter tests to be standalone cogl tests this patch ports the test-sub-texture test to be standalone now. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-28 18:10:01 +00:00
test-sub-texture.c \
Add a conformance test for custom attributes The test creates some pipelines with snippets with custom attributes and uses CoglAttribute to define values for them. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-02 10:55:41 +00:00
test-custom-attributes.c \
tests: Port test-offscreen This ports the test-offscreen test from being a Clutter test to a straight Cogl test. https://bugzilla.gnome.org/show_bug.cgi?id=668913 Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-28 13:19:01 +00:00
test-offscreen.c \
Port the test-primitive test from Clutter to Cogl This converts test-primitive to be a standalone Cogl test instead of relying on Clutter code. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-06 13:30:08 +00:00
test-primitive.c \
test-texture-3d: Port to Cogl This ports the texture-3d test to Cogl instead of depending on Clutter. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 17:54:07 +00:00
test-texture-3d.c \
Add a test for pipelines with sparse layer indices There are currently quite a few places in Cogl where we muddle the layer index and the texture unit number. The theory is that these two numbers shouldn't be related and it should be possible to pick large layer numbers with gaps. This patch adds a test case to check that we can reference a large layer number from a texture combine string by creating a pipeline with only three layers but that have very large layer indices. This doesn't currently work because Cogl interprets the numbers in the combine strings to be the unit indices and not the layer indices. The documentation however calls these numbers layer numbers so presumably it is not meant to work that way. There are probably many other bugs related to this that the test case doesn't pick up so it would be good to add some more tests here, for example to test that you can bind an attribute to the texture coordinates for a large layer index. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-09 20:36:14 +00:00
test-sparse-pipeline.c \
tests: Test reading all pixel formats The test-read-alpha-texture test has been replaced with a test that tries reading an RGBA texture in all current pixel formats. On GLES2 this should end up testing all of the convesion code because in that case GL only supports reading back RGBA data. The test now works on GLES2 since the conversion code for all of the formats has been added so this also removes the GL requirement. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-02-29 21:43:01 +00:00
test-read-texture-formats.c \
tests: Add a test which writes all pixel formats This adds a test similar to the test-read-texture-formats test but that updates data on a 1x1 pixel RGBA texture instead. On GLES2 this should end up testing all of the convesion code because in that case GL only supports reading back RGBA data. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-01 00:40:34 +00:00
test-write-texture-formats.c \
Add a conformance test for point sizes This tries rendering some points at various sizes and checks that they are the expected size and make a rectangle shape. This is currently failing when the GLSL vertend is used because it flushes the point size in the wrong place. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 23:14:27 +00:00
test-point-size.c \
Add support for per-vertex point sizes This adds a new function to enable per-vertex point size on a pipeline. This can be set with cogl_pipeline_set_per_vertex_point_size(). Once enabled the point size can be set either by drawing with an attribute named 'cogl_point_size_in' or by writing to the 'cogl_point_size_out' builtin from a snippet. There is a feature flag which must be checked for before using per-vertex point sizes. This will only be set on GL >= 2.0 or on GLES 2.0. GL will only let you set a per-vertex point size from GLSL by writing to gl_PointSize. This is only available in GL2 and not in the older GLSL extensions. The per-vertex point size has its own pipeline state flag so that it can be part of the state that affects vertex shader generation. Having to enable the per vertex point size with a separate function is a bit awkward. Ideally it would work like the color attribute where you can just set it for every vertex in your primitive with cogl_pipeline_set_color or set it per-vertex by just using the attribute. This is harder to get working with the point size because we need to generate a different vertex shader depending on what attributes are bound. I think if we wanted to make this work transparently we would still want to internally have a pipeline property describing whether the shader was generated with per-vertex support so that it would work with the shader cache correctly. Potentially we could make the per-vertex property internal and automatically make a weak pipeline whenever the attribute is bound. However we would then also need to automatically detect when an application is writing to cogl_point_size_out from a snippet. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8495d9c1c15ce389885a9356d965eabd97758115) Conflicts: cogl/cogl-context.c cogl/cogl-pipeline-private.h cogl/cogl-pipeline.c cogl/cogl-private.h cogl/driver/gl/cogl-pipeline-progend-fixed.c cogl/driver/gl/gl/cogl-pipeline-progend-fixed-arbfp.c
2012-11-08 16:56:02 +00:00
test-point-size-attribute.c \
Add a conformance test for point sprites This adds a conformance test which renders a texture point using a 2x2 texture with a different color for each texel. It then verifies that each texel is mapped to the correct position on the point. The test is currently failing. The test requires the point sprite feature flag so this patch also adds a TEST_REQUIREMENT_* flag for that. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-03-06 23:36:45 +00:00
test-point-sprite.c \
Don't include any GL header from the public GL headers This splits the GL header inclusion from cogl-defines.h into a separate headear called cogl-gl-header.h which we will only include internally. That way we don't leak GL declarations out of our public headers. The texture functions that were using GLenum and GLuint in the public header have now changed to just use unsigned int. Note however that if an EGL winsys is enabled then it will still publicly include an EGL header. This is a bit more awkward to fix because we have public API which returns an EGLDisplay and we can't determine what type that is. There is also a conformance test which just verifies that no GL header has been included while compiling. The test isn't added to test-conform-main because it doesn't actually test anything at runtime. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ef5680d3fda5df929dbd0b420c8f598ded58dfee)
2012-03-23 18:05:46 +00:00
test-no-gl-header.c \
Add a cogl-version header This adds a version header which contains macros to define which version of Cogl the application is being compiled against. This helps applications that want to support multiple incompatible versions of Cogl at compile time. The macros are called COGL_VERSION_{MAJOR,MINOR,MICRO}. This does not match Clutter which names them CLUTTER_{MAJOR,MINOR,MICRO}_VERSION but I think the former is nicer and it at least matches Cairo and Pango. The values of the macro are defined to COGL_VERSION_*_INTERNAL which is generated by the configure script into cogl-defines.h. There is also a macro for the entire version as a string called COGL_VERSION_STRING. The internal utility macros for encoding a 3 part version number into a single integer have been moved into the new header so they can be used publicly as a convenient way to check if the version is within a particular range. There is also a COGL_VERSION_CHECK macro for the very common case that a feature will be used since a particular version of Cogl. There is a macro called COGL_VERSION which contains the pre-encoded version of Cogl being compiled against for convenience. Unlike in Clutter this patch does not add any runtime version identification mechanism. A test case is also added which just contains static asserts to sanity check the macros. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3480cf140dc355fa87ab3fbcf0aeeb0124798a8f)
2012-04-23 13:09:19 +00:00
test-version.c \
conform: Adds a gles2 context test This adds a conformance test that creates a GLES2 context via the cogl api and verifies clearing an offscreen framebuffer via the gles2 api, and switching back and forth between the Cogl and GLES2 apis. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 9369c60a596c0cbc7a8bb9a45d7b8ffb6a848311)
2012-04-19 17:48:19 +00:00
test-gles2-context.c \
Add a basic conformance test for eulers and quaternions This adds some preliminary testing for eulers and quaternions. It mostly just tests the cogl_matrix_init_from_{quaternion,euler} functions as well as applying a euler or quaternion transformation to a framebuffer's modelview matrix. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit a32eb76e16d7d76af2fe8a6ba9151d8826b58864)
2012-05-17 21:30:37 +00:00
test-euler-quaternion.c \
Add a conformance test for removing a pipeline layer The test creates a pipeline with two layers which add two different color constants together and then tries various combinations of removing the layers and checks that it gets the right color. Currently this is failing if a pipeline is copied and then a layer is removed from the copy. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 844440a5cee5907c4d61e995804534ac0613bb0f)
2012-05-24 11:54:43 +00:00
test-layer-remove.c \
Add a simple conformance test for alpha testing This adds a simple test which sets an alpha test on a pipeline and then renders a texture. It then verifies that the transparent parts of the texture aren't drawn. This is currently failing with the GL3 driver because GL3 requires the alpha test to be implemented in GLSL but the generated alpha test uniform is only updated for the GLES2 driver. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 4ec04507bfaf2d61707dccfb59ac7326962ee741)
2012-10-01 13:46:24 +00:00
test-alpha-test.c \
Add a test case for cogl_buffer_map_range This adds a small test case which maps a sub region of a small attribute buffer and replaces the texture coordinates of one of the vertices. The vertices are then drawn and the correct colours are checked. There is now a new test requirement for the COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE feature which this test requires. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 22183265b021dd038338b4398056c0a1eae77edb)
2012-10-17 20:40:26 +00:00
test-map-buffer-range.c \
tests: Convert test-npot-texture to Cogl This updates the npot-texture test to use Cogl directly instead of relying on Clutter. Note that this currently fails when Cogl ends up using sliced textures. It looks like there is some bug with the meta texture function to iterate the primitive textures. This happens when COGL_DEBUG=disable-npot-textures is set. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 32f0e1e8fff56be3123dc4571f07bb5a314f6818)
2012-11-09 16:28:53 +00:00
test-npot-texture.c \
Add a conformance test using alpha textures This adds a conformance test with an alpha-component texture. The texture is rendered using a pipeline with the same layer combine mode as cogl-pango. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 05190519bad4519e66cbdb5326943c832d15a841)
2012-11-19 17:28:53 +00:00
test-alpha-textures.c \
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 18:11:28 +00:00
test-wrap-rectangle-textures.c \
tests: port test-texture-get-set-data to be standalone This ports the test-texture-get-set-data clutter test to be a standalone Cogl test. (cherry picked from commit 40defa3dbd355754d0f7611d3c50de35db514e4a)
2012-11-21 22:12:54 +00:00
test-texture-get-set-data.c \
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 15:27:52 +00:00
test-framebuffer-get-bits.c \
Add a test to check interleaving primitives and the journal This adds a conformance test which draws a rectangle using the journal in-between two rectangles drawn with primitives without changing any other state. Currently this is failing because the modelview matrix state is not correctly flushed. The journal also flushes in own clip state so the test additionally puts everything in a clip and verifies that that worked. This is not currently broken but we might as well test it. https://bugzilla.gnome.org/show_bug.cgi?id=693612 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit b703f9a1a98894a12021cbdd632e1d59214e612f)
2013-02-18 18:13:01 +00:00
test-primitive-and-journal.c \
Add test to verify replacing a layer doesn't leak the pipeline parent The current recommendation for pipelines is that once they have been used for painting then they should be considered immutable. If you want to modify a pipeline you should instead make a copy and unref the original pipeline. Internally we try to check whether the modified copy replaces all of the properties of the parent and prune a redundant ancestor hierarchy. Pruning the hierarchy is particularly important if the pipelines contain textures because otherwise the textures may be leaked when the parent pipeline keeps a reference to it. This test verifies that usage pattern by creating a chain of pipeline copies each with their own replacement texture. Some user data is then set on the textures with a callback so that we can verify that once the original pipelines are destroyed then the textures are also destroyed. The test is currently failing because Cogl doesn't correctly prune ancestory for layer state authority. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3fbec92acb90008492eb125025f92b42d6e07930)
2013-03-09 19:43:46 +00:00
test-copy-replace-texture.c \
Conformance test to check whether the pipeline cache holds textures Currently when a unique pipeline is created and added to the pipeline cache that pipeline will live forever which includes keeping a reference to any large resources that the pipeline has such as textures. These textures don't actually need to be kept for the pipeline to be used as a key in the hash table so ideally we wouldn't do this. This test case tries rendering with a pipeline that has textures and then checks whether the textures are successfully destroyed after the pipeline is unreffed. The test is currently marked as a known failure because the pipeline cache will prevent them from being destroyed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0056f805dadd46b966d57f66b02890b8c29971ac)
2013-03-26 12:08:12 +00:00
test-pipeline-cache-unrefs-texture.c \
Add test that Cogl doesn't crash when freeing unallocated texture It looks like Cogl doesn't currently clean up an unallocated atlas texture properly so if it fails to allocate it. It will then crash when it is freed. This adds a conformance test to verify that all of the various texture types can be freed without allocating them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit bfada22d9a7f60baad5ae5615e45f10327e23e36)
2013-06-11 14:57:37 +00:00
test-texture-no-allocate.c \
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 22:34:38 +00:00
$(NULL)
Adds initial Emscripten support to Cogl This enables basic Emscripten support in Cogl via the SDL winsys. Assuming you have setup an emscripten toolchain you can configure Cogl like this: emconfigure ./configure --enable-debug --enable-emscripten Building the examples will build .html files that can be loaded directly by a WebGL enabled browser. Note: at this point the emscripten support has just barely been smoke tested so it's expected that as we continue to build on this we will learn about more things we need to change in Cogl to full support this environment. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a3bc2e7539391b074e697839dfae60b69c37cf10)
2013-04-28 01:42:24 +00:00
if !USING_EMSCRIPTEN
# test-fence depends on the glib mainloop so it won't compile if using
# emscripten which builds in standalone mode.
test_sources += test-fence.c
endif
Separate out CoglPath api into sub-library This splits out the cogl_path_ api into a separate cogl-path sub-library like cogl-pango and cogl-gst. This enables developers to build Cogl with this sub-library disabled if they don't need it which can be useful when its important to keep the size of an application and its dependencies down to a minimum. The functions cogl_framebuffer_{fill,stroke}_path have been renamed to cogl_path_{fill,stroke}. There were a few places in core cogl and cogl-gst that referenced the CoglPath api and these have been decoupled by using the CoglPrimitive api instead. In the case of cogl_framebuffer_push_path_clip() the core clip stack no longer accepts path clips directly but it's now possible to get a CoglPrimitive for the fill of a path and so the implementation of cogl_framebuffer_push_path_clip() now lives in cogl-path and works as a shim that first gets a CoglPrimitive and uses cogl_framebuffer_push_primitive_clip instead. We may want to consider renaming cogl_framebuffer_push_path_clip to put it in the cogl_path_ namespace. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 8aadfd829239534fb4ec8255cdea813d698c5a3f) So as to avoid breaking the 1.x API or even the ABI since we are quite late in the 1.16 development cycle the patch was modified to build cogl-path as a noinst_LTLIBRARY before building cogl and link the code directly into libcogl.so as it was previously. This way we can wait until the start of the 1.18 cycle before splitting the code into a separate libcogl-path.so. This also adds shims for cogl_framebuffer_fill/stroke_path() to avoid breaking the 1.x API/ABI.
2013-04-28 02:22:24 +00:00
if BUILD_COGL_PATH
test_sources += test-path.c
endif
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 22:34:38 +00:00
test_conformance_SOURCES = $(common_sources) $(test_sources)
if OS_WIN32
SHEXT =
else
SHEXT = $(EXEEXT)
endif
# For convenience, this provides a way to easily run individual unit tests:
.PHONY: wrappers clean-wrappers
wrappers: stamp-test-conformance
@true
stamp-test-conformance: Makefile $(srcdir)/test-conform-main.c
@mkdir -p wrappers
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 12:30:51 +00:00
@sed -n -e 's/^ \{1,\}ADD_TEST *( *\([a-zA-Z0-9_]\{1,\}\).*/\1/p' $(srcdir)/test-conform-main.c > unit-tests
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 12:22:22 +00:00
@chmod +x $(top_srcdir)/tests/test-launcher.sh
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 22:34:38 +00:00
@( echo "/stamp-test-conformance" ; \
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 12:30:51 +00:00
echo "/test-conformance$(EXEEXT)" ; \
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 22:34:38 +00:00
echo "*.o" ; \
echo ".gitignore" ; \
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 12:30:51 +00:00
echo "unit-tests" ; ) > .gitignore
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 22:34:38 +00:00
@for i in `cat unit-tests`; \
do \
unit=`basename $$i | sed -e s/_/-/g`; \
echo " GEN $$unit"; \
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 12:22:22 +00:00
( echo "#!/bin/sh" ; echo "$(top_srcdir)/tests/test-launcher.sh $(abs_builddir)/test-conformance$(EXEEXT) '' '$$i' \"\$$@\"" ) > $$unit$(SHEXT) ; \
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 22:34:38 +00:00
chmod +x $$unit$(SHEXT); \
echo "/$$unit$(SHEXT)" >> .gitignore; \
done \
&& echo timestamp > $(@F)
clean-wrappers:
@for i in `cat unit-tests`; \
do \
unit=`basename $$i | sed -e s/_/-/g`; \
echo " RM $$unit"; \
rm -f $$unit$(SHEXT) ; \
done \
&& rm -f unit-tests \
&& rm -f stamp-test-conformance
# NB: BUILT_SOURCES here a misnomer. We aren't building source, just inserting
# a phony rule that will generate symlink scripts for running individual tests
BUILT_SOURCES = wrappers
build: update to build with automake 1.13 This make autogen.sh look for automake-1.13 and also updates all Makefile.am files to no longer use the INCLUDES variable which automake 1.13 warns is deprecated by AM_CPPFLAGS. https://bugzilla.gnome.org/show_bug.cgi?id=690891 Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5de5569e960102afe979a5f2f0403e1defebca62)
2013-01-17 22:56:41 +00:00
AM_CPPFLAGS = \
Add a conformance test for CoglBitmask This adds a test which tries manipulating some bits on a CoglBitmask and verifies that it gets the expected result. This test is fairly unusual in that it is directly testing some internal Cogl code that isn't exposed through the public API. To make this work it directly includes the source for CoglBitmask. CoglBitmask does some somewhat dodgy things with converting longs to pointers and back so it makes sense to have a test case to verify that this is working on all platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 14:00:54 +00:00
-I$(top_srcdir) \
units: remove test-bitmask and add UNIT_TEST instead This moves the code in test-bitmask into a UNIT_TEST() directly in cogl-bitmask.c which will now be run as a tests/unit/ test. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 693c85e0cde8a1ffbffc03a5f8fcc1f92e8d0ac7) Includes fix to build conform tests with -I$(top_builddir)/cogl to be able to find cogl-gl-header.h
2013-05-30 14:06:24 +00:00
-I$(top_builddir)/cogl \
-I$(top_srcdir)/test-fixtures
build: don't include deps/glib headers if glib enabled If we're using the system glib library then we need to make sure not to include headers under deps/glib otherwise we end up with with incompatible typedefs that break the build. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5d5fc97b59951ec56a4193b7ee7909ebd3cfbb94)
2012-09-24 15:42:44 +00:00
if !USE_GLIB
build: update to build with automake 1.13 This make autogen.sh look for automake-1.13 and also updates all Makefile.am files to no longer use the INCLUDES variable which automake 1.13 warns is deprecated by AM_CPPFLAGS. https://bugzilla.gnome.org/show_bug.cgi?id=690891 Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5de5569e960102afe979a5f2f0403e1defebca62)
2013-01-17 22:56:41 +00:00
AM_CPPFLAGS += -I$(top_builddir)/deps/glib
build: don't include deps/glib headers if glib enabled If we're using the system glib library then we need to make sure not to include headers under deps/glib otherwise we end up with with incompatible typedefs that break the build. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5d5fc97b59951ec56a4193b7ee7909ebd3cfbb94)
2012-09-24 15:42:44 +00:00
endif
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 22:34:38 +00:00
build: update to build with automake 1.13 This make autogen.sh look for automake-1.13 and also updates all Makefile.am files to no longer use the INCLUDES variable which automake 1.13 warns is deprecated by AM_CPPFLAGS. https://bugzilla.gnome.org/show_bug.cgi?id=690891 Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5de5569e960102afe979a5f2f0403e1defebca62)
2013-01-17 22:56:41 +00:00
AM_CPPFLAGS += \
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 22:34:38 +00:00
-DCOGL_ENABLE_EXPERIMENTAL_API \
-DCOGL_DISABLE_DEPRECATED \
Add a conformance test for CoglBitmask This adds a test which tries manipulating some bits on a CoglBitmask and verifies that it gets the expected result. This test is fairly unusual in that it is directly testing some internal Cogl code that isn't exposed through the public API. To make this work it directly includes the source for CoglBitmask. CoglBitmask does some somewhat dodgy things with converting longs to pointers and back so it makes sense to have a test case to verify that this is working on all platforms. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-10-28 14:00:54 +00:00
-DTESTS_DATADIR=\""$(top_srcdir)/tests/data"\" \
Mass rename CLUTTER_COMPILATION to COGL_COMPILATION Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a99512e5798e48ffa3a9a1a7eb98bc55647ee1b6)
2012-06-20 17:49:08 +00:00
-DCOGL_COMPILATION
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 22:34:38 +00:00
test_conformance_CFLAGS = -g3 -O0 $(COGL_DEP_CFLAGS) $(COGL_EXTRA_CFLAGS)
Add $(LIBM) to the LDADD for all of the examples and tests Some of the examples and tests are using functions from -lm. With some linkers, if we don't expicitly link against it an error will be reported. This patch adds the library to all of the examples even though not all of them use math functions because I don't think it will do any harm and it will save us having to remember to add it if an example later starts using some math functions. https://bugzilla.gnome.org/show_bug.cgi?id=697330 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 66a1aeaee1f7cdcdd505f5745277723a43d714b6) Conflicts: examples/Makefile.am tests/conform/Makefile.am tests/micro-perf/Makefile.am
2013-04-23 16:40:38 +00:00
test_conformance_LDADD = \
$(COGL_DEP_LIBS) \
$(top_builddir)/cogl/libcogl.la \
$(LIBM)
build: Allow to build cogl without an external glib dependency This commit pushes --disable-glib to the extreme of embedding the par of glib cogl depends on in tree to be able to generate a DSO that does not depend on an external glib. To do so, it: - keeps a lot of glib's configure.ac in as-glibconfig.m4 - pulls the code cogl depends on and the necessary dependencies Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-09-17 01:20:10 +00:00
if !USE_GLIB
test_conformance_LDADD += $(top_builddir)/deps/glib/libglib.la
endif
Separate out CoglPath api into sub-library This splits out the cogl_path_ api into a separate cogl-path sub-library like cogl-pango and cogl-gst. This enables developers to build Cogl with this sub-library disabled if they don't need it which can be useful when its important to keep the size of an application and its dependencies down to a minimum. The functions cogl_framebuffer_{fill,stroke}_path have been renamed to cogl_path_{fill,stroke}. There were a few places in core cogl and cogl-gst that referenced the CoglPath api and these have been decoupled by using the CoglPrimitive api instead. In the case of cogl_framebuffer_push_path_clip() the core clip stack no longer accepts path clips directly but it's now possible to get a CoglPrimitive for the fill of a path and so the implementation of cogl_framebuffer_push_path_clip() now lives in cogl-path and works as a shim that first gets a CoglPrimitive and uses cogl_framebuffer_push_primitive_clip instead. We may want to consider renaming cogl_framebuffer_push_path_clip to put it in the cogl_path_ namespace. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 8aadfd829239534fb4ec8255cdea813d698c5a3f) So as to avoid breaking the 1.x API or even the ABI since we are quite late in the 1.16 development cycle the patch was modified to build cogl-path as a noinst_LTLIBRARY before building cogl and link the code directly into libcogl.so as it was previously. This way we can wait until the start of the 1.18 cycle before splitting the code into a separate libcogl-path.so. This also adds shims for cogl_framebuffer_fill/stroke_path() to avoid breaking the 1.x API/ABI.
2013-04-28 02:22:24 +00:00
if BUILD_COGL_PATH
test_conformance_LDADD += $(top_builddir)/cogl-path/libcogl-path.la
endif
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 22:34:38 +00:00
test_conformance_LDFLAGS = -export-dynamic
test: wrappers
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 12:22:22 +00:00
@$(top_srcdir)/tests/run-tests.sh $(abs_builddir)/../config.env $(abs_builddir)/test-conformance$(EXEEXT)
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 22:34:38 +00:00
# XXX: we could prevent the conformance test suite from running
# by simply defining this variable conditionally
TEST_PROGS = test-conformance
.PHONY: test
build: Fix doc build and make dist Reviewed-by: Neil Roberts <neil@linux.intel.com>
2013-07-02 12:19:05 +00:00
DISTCLEANFILES = .gitignore
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 22:34:38 +00:00
VS 2008/2010 project files to build Cogl These are the VS 2008/2010 project files to build Cogl, with a README.txt to explain the process involved. Note that the Cogl and Cogl-Pango projects (and filters for VS2010) are expanded with the correct source file listings during "make dist", which is done to simplify maintenance of these project files. -added preconfigured config.h(.win32.in), which is expanded with the correct versioining info during autogen -added preconfigued cogl/cogl-defines.h.win32 -added symbols files for cogl and cogl-pango -Have configure.ac expand the config.h.win32.in into config.h.win32 with the correct versioning info, etc, and to include the Visual C++ project files for distribution -Added rules in cogl/Makefile.am to expand the cogl VS 2008/2010 projects and filters from the templates with up-to-date source file listings, to distribute cogl-enum-types.c, cogl-enum-types.h to ease compilation and to avoid depending on PERL on Windows installations. -Added rules in cogl-pango/Makefile.am to expand the cogl-pango VS2008/ 2010 projects and filters from the templates with up-to-date source file listings. -Added/edited various Makefile.am's in build to distribute the VS2008/2010 project files and associated items required for the build. -Update .gitignore. There needs to be a pre-configured config.h(.win32) and its template, config.h.win32.in for Visual C++ builds https://bugzilla.gnome.org/show_bug.cgi?id=650020 Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-05-12 09:06:32 +00:00
dist-hook: ../../build/win32/vs9/test-conformance-cogl.vcproj ../../build/win32/vs10/test-conformance-cogl.vcxproj ../../build/win32/vs10/test-conformance-cogl.vcxproj.filters
../../build/win32/vs9/test-conformance-cogl.vcproj: $(top_srcdir)/build/win32/vs9/test-conformance-cogl.vcprojin
for F in $(test_conformance_SOURCES); do \
case $$F in \
*.c) echo ' <File RelativePath="..\..\..\tests\conform\'$$F'" />' \
;; \
esac; \
done >testconformance.sourcefiles
$(CPP) -P - <$(top_srcdir)/build/win32/vs9/test-conformance-cogl.vcprojin >$@
rm testconformance.sourcefiles
../../build/win32/vs10/test-conformance-cogl.vcxproj: $(top_srcdir)/build/win32/vs10/test-conformance-cogl.vcxprojin
for F in $(test_conformance_SOURCES); do \
case $$F in \
*.c) echo ' <ClCompile Include="..\..\..\tests\conform\'$$F'" />' \
;; \
esac; \
done >testconformance.vs10.sourcefiles
$(CPP) -P - <$(top_srcdir)/build/win32/vs10/test-conformance-cogl.vcxprojin >$@
rm testconformance.vs10.sourcefiles
../../build/win32/vs10/test-conformance-cogl.vcxproj.filters: $(top_srcdir)/build/win32/vs10/test-conformance-cogl.vcxproj.filtersin
for F in $(test_conformance_SOURCES); do \
case $$F in \
*.c) echo ' <ClCompile Include="..\..\..\tests\conform\'$$F'"><Filter>Sources</Filter></ClCompile>' \
;; \
esac; \
done >testconformance.vs10.sourcefiles.filters
$(CPP) -P - <$(top_srcdir)/build/win32/vs10/test-conformance-cogl.vcxproj.filtersin >$@
rm testconformance.vs10.sourcefiles.filters
# Let the VS9/VS10 Project files be cleared out before they are re-expanded...
DISTCLEANFILES += ../../build/win32/vs9/test-conformance-cogl.vcproj \
../../build/win32/vs10/test-conformance-cogl.vcxproj \
../../build/win32/vs10/test-conformance-cogl.vcxproj.filters
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 22:34:38 +00:00
# we override the clean-generic target to clean up the wrappers so
# we cannot use CLEANFILES
clean-generic: clean-wrappers
build: clean .log file in tests/conform dir When running the conformance tests we write to a .log file which wasn't being removed by make clean which was causing make release-check to fail.
2012-03-05 23:24:16 +00:00
$(QUIET_RM)rm -f .log
Install conformance tests Install the conformance tests, and metadata to run them with gnome-desktop-testing-runner. https://bugzilla.gnome.org/show_bug.cgi?id=702942 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 53f3eb421239982b69569ad03ccbfa4b4f601cf3)
2013-06-24 03:33:05 +00:00
if ENABLE_INSTALLED_TESTS
insttestdir = $(libexecdir)/installed-tests/$(PACKAGE)/conform
insttest_PROGRAMS = test-conformance
insttest_DATA = unit-tests
testmetadir = $(datadir)/installed-tests/$(PACKAGE)
testmeta_DATA = conform.test
conform.test:
echo " GEN $@"; \
echo "[Test]" > $@.tmp; \
echo "Type=session" >> $@.tmp; \
echo "Exec=sh -c \"cd $(libexecdir)/installed-tests/$(PACKAGE)/conform; ../run-tests.sh ../config.env ./test-conformance\"" >> $@.tmp; \
mv $@.tmp $@
CLEANFILES = conform.test
endif
Reference in New Issue Copy Permalink